Convert to use libtraceevent

Rasdaemon used for a long time an early version of this library,
with the code embedded directly into its code. The rationale is
that the library was not officially released on that time, but
this has long changed.

So, instead, just use the library directly.

Signed-off-by: Mauro Carvalho Chehab <mchehab@kernel.org>

diff --git a/Makefile.am b/Makefile.am
index 36e7d4e3bd7978acc4a8b19d6cdd2ab1ca631a9c..f4e6fc1bc202f3e874c102b9c98202a8531cf0f8 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,5 @@
 ACLOCAL_AMFLAGS=-I m4
-SUBDIRS = libtrace util man
+SUBDIRS = util man
 SYSTEMD_SERVICES_IN = misc/rasdaemon.service.in misc/ras-mc-ctl.service.in
 SYSTEMD_SERVICES = $(SYSTEMD_SERVICES_IN:.service.in=.service)
 EXTRA_DIST = $(SYSTEMD_SERVICES_IN) misc/rasdaemon.env
@@ -72,7 +72,8 @@ endif
 if WITH_CPU_FAULT_ISOLATION
    rasdaemon_SOURCES += ras-cpu-isolation.c queue.c
 endif
-rasdaemon_LDADD = -lpthread $(SQLITE3_LIBS) libtrace/libtrace.a
+rasdaemon_LDADD = -lpthread $(SQLITE3_LIBS) $(LIBTRACEEVENT_LIBS)
+rasdaemon_CFLAGS = $(SQLITE3_CFLAGS) $(LIBTRACEEVENT_CFLAGS)
 
 include_HEADERS = config.h  ras-events.h  ras-logger.h  ras-mc-handler.h \
                  ras-aer-handler.h ras-mce-handler.h ras-record.h bitfield.h ras-report.h \

diff --git a/README b/README
index 833b91827951ca4b0e6ff826758bcf5f91c566bb..e92dfe201821f7e76fca83c6a712eb5a22a322b8 100644 (file)
--- a/README
+++ b/README
@@ -88,15 +88,16 @@ by installing the following packages:
        autoconf
        automake
        libtool
+       libtraceevent-devel
        tar
        sqlite-devel    (if sqlite3 will be used)
        perl-DBD-SQLite (if sqlite3 will be used)
 
 To install then on Fedora, run:
-       yum install -y make gcc autoconf automake libtool tar perl-dbd-sqlite
+       dnf install -y make gcc autoconf automake libtool tar perl-dbd-sqlite libtraceevent-devel
 
 Or, if sqlite3 database will be used to store data:
-       yum install -y make gcc autoconf automake libtool tar sqlite-devel
+       dnf install -y make gcc autoconf automake libtool tar sqlite-devel libtraceevent-devel
 
 There are currently 3 features that are enabled optionally, via
 ./configure parameters:

diff --git a/configure.ac b/configure.ac
index c7af727eb44e9089d88a89e7fd8d2a84f178638f..776bcd986ce21f8e3810761a6c8d11d38a9c9537 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -12,7 +12,6 @@ X_AC_META
 
 AC_CONFIG_FILES([
        Makefile
-       libtrace/Makefile
        man/Makefile
        man/ras-mc-ctl.8
        man/rasdaemon.1
@@ -39,6 +38,13 @@ AM_COND_IF([WITH_SQLITE3], [USE_SQLITE3="yes"], [USE_SQLITE3="no"])
 
 AC_SUBST([SQLITE3_LIBS])
 
+has_libtraceevent_ver=0
+dnl check for tracevent library
+PKG_CHECK_MODULES([LIBTRACEEVENT], [libtraceevent], [has_libtraceevent_ver=1])
+
+AS_IF([test "$has_libtraceevent_ver" -eq 0], [
+       AC_MSG_ERROR([libtraceevent is required but were not found])
+])
 
 AC_ARG_ENABLE([aer],
     AS_HELP_STRING([--enable-aer], [enable PCIe AER events (currently experimental)]))

diff --git a/non-standard-ampere.h b/non-standard-ampere.h
index f463c532812b73075be124777e9c2ca5d1c713f7..2db0db21a9ecb57f50dcc5d2ee849127fdc3350a 100644 (file)
--- a/non-standard-ampere.h
+++ b/non-standard-ampere.h
@@ -13,7 +13,7 @@
 #define __NON_STANDARD_AMPERE_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 #define SOCKET_NUM(x) ((x >> 14) & 0x3)
 #define PAYLOAD_TYPE(x) ((x >> 6) & 0x3)

diff --git a/ras-aer-handler.c b/ras-aer-handler.c
index 6f4cb2bbfd598f82f0dcede3fdff7ce2f68b4326..ed637e06595550dd44851b173e3a5a136bc10355 100644 (file)
--- a/ras-aer-handler.c
+++ b/ras-aer-handler.c
@@ -19,7 +19,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-aer-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -55,8 +55,8 @@ static const char *aer_uncor_errors[32] = {
 #define BUF_LEN        1024
 
 int ras_aer_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context)
+                        struct tep_record *record,
+                        struct tep_event *event, void *context)
 {
        int len;
        unsigned long long severity_val;
@@ -91,16 +91,16 @@ int ras_aer_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       ev.dev_name = pevent_get_field_raw(s, event, "dev_name",
+       ev.dev_name = tep_get_field_raw(s, event, "dev_name",
                                           record, &len, 1);
        if (!ev.dev_name)
                return -1;
        trace_seq_printf(s, "%s ", ev.dev_name);
 
-       if (pevent_get_field_val(s,  event, "status", record, &status_val, 1) < 0)
+       if (tep_get_field_val(s,  event, "status", record, &status_val, 1) < 0)
                return -1;
 
-       if (pevent_get_field_val(s, event, "severity", record, &severity_val, 1) < 0)
+       if (tep_get_field_val(s, event, "severity", record, &severity_val, 1) < 0)
                return -1;
 
        /* Fills the error buffer. If it is a correctable error then use the
@@ -112,13 +112,13 @@ int ras_aer_event_handler(struct trace_seq *s,
                bitfield_msg(buf, sizeof(buf), aer_uncor_errors, 32, 0, 0, status_val);
        ev.msg = buf;
 
-       if (pevent_get_field_val(s, event, "tlp_header_valid",
+       if (tep_get_field_val(s, event, "tlp_header_valid",
                                record, &val, 1) < 0)
                return -1;
 
        ev.tlp_header_valid = val;
        if (ev.tlp_header_valid) {
-               ev.tlp_header = pevent_get_field_raw(s, event, "tlp_header",
+               ev.tlp_header = tep_get_field_raw(s, event, "tlp_header",
                                                     record, &len, 1);
                snprintf((buf + strlen(ev.msg)), BUF_LEN - strlen(ev.msg),
                         " TLP Header: %08x %08x %08x %08x",

diff --git a/ras-aer-handler.h b/ras-aer-handler.h
index 876a60ba7199f8a1ccf22915e5941633de9374a3..9918e8ceeb8a9fd2756b243665abe6b338299dd6 100644 (file)
--- a/ras-aer-handler.h
+++ b/ras-aer-handler.h
@@ -20,10 +20,10 @@
 #define __RAS_AER_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 int ras_aer_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context);
+                        struct tep_record *record,
+                        struct tep_event *event, void *context);
 
 #endif

diff --git a/ras-arm-handler.c b/ras-arm-handler.c
index a0dfc512d8bcce3aae2e339c621938ff70c98feb..7d17cb4926f51cd50fac93ec1c95b2d6dc300d26 100644 (file)
--- a/ras-arm-handler.c
+++ b/ras-arm-handler.c
@@ -15,7 +15,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-arm-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -100,8 +100,8 @@ static int count_errors(struct ras_arm_event *ev, int sev)
 }
 
 static int ras_handle_cpu_error(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event,
+                        struct tep_record *record,
+                        struct tep_event *event,
                         struct ras_arm_event *ev, time_t now)
 {
        unsigned long long val;
@@ -109,13 +109,13 @@ static int ras_handle_cpu_error(struct trace_seq *s,
        char *severity;
        struct error_info err_info;
 
-       if (pevent_get_field_val(s, event, "cpu", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "cpu", record, &val, 1) < 0)
                return -1;
        cpu = val;
        trace_seq_printf(s, "\n cpu: %d", cpu);
 
        /* record cpu error */
-       if (pevent_get_field_val(s, event, "sev", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "sev", record, &val, 1) < 0)
                return -1;
        /* refer to UEFI_2_9 specification chapter N2.2 Table N-5 */
        switch (val) {
@@ -150,8 +150,8 @@ static int ras_handle_cpu_error(struct trace_seq *s,
 #endif
 
 int ras_arm_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context)
+                        struct tep_record *record,
+                        struct tep_event *event, void *context)
 {
        unsigned long long val;
        struct ras_events *ras = context;
@@ -182,60 +182,60 @@ int ras_arm_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s\n", ev.timestamp);
 
-       if (pevent_get_field_val(s, event, "affinity", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "affinity", record, &val, 1) < 0)
                return -1;
        ev.affinity = val;
        trace_seq_printf(s, " affinity: %d", ev.affinity);
 
-       if (pevent_get_field_val(s, event, "mpidr", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "mpidr", record, &val, 1) < 0)
                return -1;
        ev.mpidr = val;
        trace_seq_printf(s, "\n MPIDR: 0x%llx", (unsigned long long)ev.mpidr);
 
-       if (pevent_get_field_val(s, event, "midr", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "midr", record, &val, 1) < 0)
                return -1;
        ev.midr = val;
        trace_seq_printf(s, "\n MIDR: 0x%llx", (unsigned long long)ev.midr);
 
-       if (pevent_get_field_val(s, event, "running_state", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "running_state", record, &val, 1) < 0)
                return -1;
        ev.running_state = val;
        trace_seq_printf(s, "\n running_state: %d", ev.running_state);
 
-       if (pevent_get_field_val(s, event, "psci_state", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "psci_state", record, &val, 1) < 0)
                return -1;
        ev.psci_state = val;
        trace_seq_printf(s, "\n psci_state: %d", ev.psci_state);
 
-       if (pevent_get_field_val(s, event, "pei_len", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "pei_len", record, &val, 1) < 0)
                return -1;
        ev.pei_len = val;
        trace_seq_printf(s, "\n ARM Processor Err Info data len: %d\n",
                         ev.pei_len);
 
-       ev.pei_error = pevent_get_field_raw(s, event, "buf", record, &len, 1);
+       ev.pei_error = tep_get_field_raw(s, event, "buf", record, &len, 1);
        if (!ev.pei_error)
                return -1;
        display_raw_data(s, ev.pei_error, ev.pei_len);
 
-       if (pevent_get_field_val(s, event, "ctx_len", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "ctx_len", record, &val, 1) < 0)
                return -1;
        ev.ctx_len = val;
        trace_seq_printf(s, "\n ARM Processor Err Context Info data len: %d\n",
                         ev.ctx_len);
 
-       ev.ctx_error = pevent_get_field_raw(s, event, "buf1", record, &len, 1);
+       ev.ctx_error = tep_get_field_raw(s, event, "buf1", record, &len, 1);
        if (!ev.ctx_error)
                return -1;
        display_raw_data(s, ev.ctx_error, ev.ctx_len);
 
-       if (pevent_get_field_val(s, event, "oem_len", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "oem_len", record, &val, 1) < 0)
                return -1;
        ev.oem_len = val;
        trace_seq_printf(s, "\n Vendor Specific Err Info data len: %d\n",
                         ev.oem_len);
 
-       ev.vsei_error = pevent_get_field_raw(s, event, "buf2", record, &len, 1);
+       ev.vsei_error = tep_get_field_raw(s, event, "buf2", record, &len, 1);
        if (!ev.vsei_error)
                return -1;
 

diff --git a/ras-arm-handler.h b/ras-arm-handler.h
index 52813e7faa4c823c7c88bb28d0af7ebd33519d7a..29df238ff1c1046394f76ee962c4cace0639d783 100644 (file)
--- a/ras-arm-handler.h
+++ b/ras-arm-handler.h
@@ -15,7 +15,7 @@
 #define __RAS_ARM_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 /*
  * ARM Processor Error Information Structure, According to
@@ -36,8 +36,8 @@ struct ras_arm_err_info {
 #pragma pack()
 
 int ras_arm_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context);
+                        struct tep_record *record,
+                        struct tep_event *event, void *context);
 void display_raw_data(struct trace_seq *s,
                const uint8_t *buf,
                uint32_t datalen);

diff --git a/ras-devlink-handler.c b/ras-devlink-handler.c
index e52d66e1b04438fb75cb3720dcc006a3e1ec11ac..a1623e59c0456f1611899759f26539160afaf94e 100644 (file)
--- a/ras-devlink-handler.c
+++ b/ras-devlink-handler.c
@@ -20,15 +20,15 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-devlink-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
 #include "ras-report.h"
 
 int ras_net_xmit_timeout_handler(struct trace_seq *s,
-                                struct pevent_record *record,
-                                struct event_format *event, void *context)
+                                struct tep_record *record,
+                                struct tep_event *event, void *context)
 {
        unsigned long long val;
        int len;
@@ -51,17 +51,17 @@ int ras_net_xmit_timeout_handler(struct trace_seq *s,
        ev.bus_name = "";
        ev.reporter_name = "";
 
-       ev.dev_name = pevent_get_field_raw(s, event, "name",
+       ev.dev_name = tep_get_field_raw(s, event, "name",
                                           record, &len, 1);
        if (!ev.dev_name)
                return -1;
 
-       ev.driver_name = pevent_get_field_raw(s, event, "driver",
+       ev.driver_name = tep_get_field_raw(s, event, "driver",
                                           record, &len, 1);
        if (!ev.driver_name)
                return -1;
 
-       if (pevent_get_field_val(s, event, "queue_index", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "queue_index", record, &val, 1) < 0)
                return -1;
        if (asprintf(&ev.msg, "TX timeout on queue: %d\n", (int)val) < 0)
                return -1;
@@ -82,8 +82,8 @@ int ras_net_xmit_timeout_handler(struct trace_seq *s,
 }
 
 int ras_devlink_event_handler(struct trace_seq *s,
-                             struct pevent_record *record,
-                             struct event_format *event, void *context)
+                             struct tep_record *record,
+                             struct tep_event *event, void *context)
 {
        int len;
        struct ras_events *ras = context;
@@ -92,7 +92,7 @@ int ras_devlink_event_handler(struct trace_seq *s,
        struct devlink_event ev;
 
        if (ras->filters[DEVLINK_EVENT] &&
-           pevent_filter_match(ras->filters[DEVLINK_EVENT], record) == FILTER_MATCH)
+           tep_filter_match(ras->filters[DEVLINK_EVENT], record) == FILTER_MATCH)
                return 0;
        /*
         * Newer kernels (3.10-rc1 or upper) provide an uptime clock.
@@ -114,27 +114,27 @@ int ras_devlink_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       ev.bus_name = pevent_get_field_raw(s, event, "bus_name",
+       ev.bus_name = tep_get_field_raw(s, event, "bus_name",
                                           record, &len, 1);
        if (!ev.bus_name)
                return -1;
 
-       ev.dev_name = pevent_get_field_raw(s, event, "dev_name",
+       ev.dev_name = tep_get_field_raw(s, event, "dev_name",
                                           record, &len, 1);
        if (!ev.dev_name)
                return -1;
 
-       ev.driver_name = pevent_get_field_raw(s, event, "driver_name",
+       ev.driver_name = tep_get_field_raw(s, event, "driver_name",
                                           record, &len, 1);
        if (!ev.driver_name)
                return -1;
 
-       ev.reporter_name = pevent_get_field_raw(s, event, "reporter_name",
+       ev.reporter_name = tep_get_field_raw(s, event, "reporter_name",
                                           record, &len, 1);
        if (!ev.reporter_name)
                return -1;
 
-       ev.msg = pevent_get_field_raw(s, event, "msg", record, &len, 1);
+       ev.msg = tep_get_field_raw(s, event, "msg", record, &len, 1);
        if (!ev.msg)
                return -1;
 

diff --git a/ras-devlink-handler.h b/ras-devlink-handler.h
index ca9a1b7f239ca79da56228428488aaf4bebf4c87..39139e997bbe8f90b1d72f93fdeff3b166033305 100644 (file)
--- a/ras-devlink-handler.h
+++ b/ras-devlink-handler.h
@@ -20,14 +20,14 @@
 #define __RAS_DEVLINK_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 int ras_net_xmit_timeout_handler(struct trace_seq *s,
-                                struct pevent_record *record,
-                                struct event_format *event, void *context);
+                                struct tep_record *record,
+                                struct tep_event *event, void *context);
 
 int ras_devlink_event_handler(struct trace_seq *s,
-                             struct pevent_record *record,
-                             struct event_format *event, void *context);
+                             struct tep_record *record,
+                             struct tep_event *event, void *context);
 
 #endif

diff --git a/ras-diskerror-handler.c b/ras-diskerror-handler.c
index b16319f3f974ea2dbdb38a303825d249946fd526..38d0a36c239784e88481d2cab8d503c10676997b 100644 (file)
--- a/ras-diskerror-handler.c
+++ b/ras-diskerror-handler.c
@@ -24,7 +24,7 @@
 #include <string.h>
 #include <errno.h>
 #include <sys/sysmacros.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-diskerror-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -61,8 +61,8 @@ static const char *get_blk_error(int err)
 }
 
 int ras_diskerror_event_handler(struct trace_seq *s,
-                               struct pevent_record *record,
-                               struct event_format *event, void *context)
+                               struct tep_record *record,
+                               struct tep_event *event, void *context)
 {
        unsigned long long val;
        int len;
@@ -92,29 +92,29 @@ int ras_diskerror_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       if (pevent_get_field_val(s, event, "dev", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "dev", record, &val, 1) < 0)
                return -1;
        dev = (dev_t)val;
        if (asprintf(&ev.dev, "%u:%u", major(dev), minor(dev)) < 0)
                return -1;
 
-       if (pevent_get_field_val(s, event, "sector", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "sector", record, &val, 1) < 0)
                return -1;
        ev.sector = val;
 
-       if (pevent_get_field_val(s, event, "nr_sector", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "nr_sector", record, &val, 1) < 0)
                return -1;
        ev.nr_sector = (unsigned int)val;
 
-       if (pevent_get_field_val(s, event, "error", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "error", record, &val, 1) < 0)
                return -1;
        ev.error = get_blk_error((int)val);
 
-       ev.rwbs = pevent_get_field_raw(s, event, "rwbs", record, &len, 1);
+       ev.rwbs = tep_get_field_raw(s, event, "rwbs", record, &len, 1);
        if (!ev.rwbs)
                return -1;
 
-       ev.cmd = pevent_get_field_raw(s, event, "cmd", record, &len, 1);
+       ev.cmd = tep_get_field_raw(s, event, "cmd", record, &len, 1);
        if (!ev.cmd)
                return -1;
 

diff --git a/ras-diskerror-handler.h b/ras-diskerror-handler.h
index 002f1c4dd218b13c0378786e4d9fa09f6ffa6e40..ba4c1ab16daf3c1cbdff645d2c8666b4e4905a44 100644 (file)
--- a/ras-diskerror-handler.h
+++ b/ras-diskerror-handler.h
@@ -20,10 +20,10 @@
 #define __RAS_DISKERROR_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 int ras_diskerror_event_handler(struct trace_seq *s,
-                               struct pevent_record *record,
-                               struct event_format *event, void *context);
+                               struct tep_record *record,
+                               struct tep_event *event, void *context);
 
 #endif

diff --git a/ras-events.c b/ras-events.c
index db73870906e0ea4add77d478a1dafee02973d01b..39f9ce242d3a130e34158fd139d7d083acad0995 100644 (file)
--- a/ras-events.c
+++ b/ras-events.c
@@ -29,8 +29,8 @@
 #include <signal.h>
 #include <sys/signalfd.h>
 #include <linux/version.h>
-#include "libtrace/kbuffer.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/kbuffer.h>
+#include <traceevent/event-parse.h>
 #include "ras-mc-handler.h"
 #include "ras-aer-handler.h"
 #include "ras-non-standard-handler.h"
@@ -286,7 +286,7 @@ static int filter_ras_mc_event(struct ras_events *ras, char *group, char *event,
  * Tracing read code
  */
 
-static int get_pagesize(struct ras_events *ras, struct pevent *pevent)
+static int get_pagesize(struct ras_events *ras, struct tep_handle *pevent)
 {
        int fd, len, page_size = 4096;
        char buf[page_size];
@@ -298,11 +298,9 @@ static int get_pagesize(struct ras_events *ras, struct pevent *pevent)
        len = read(fd, buf, page_size);
        if (len <= 0)
                goto error;
-       if (pevent_parse_header_page(pevent, buf, len, sizeof(long)))
+       if (tep_parse_header_page(pevent, buf, len, sizeof(long)))
                goto error;
 
-       page_size = pevent->header_page_data_offset + pevent->header_page_data_size;
-
 error:
        close(fd);
        return page_size;
@@ -312,7 +310,7 @@ error:
 static void parse_ras_data(struct pthread_data *pdata, struct kbuffer *kbuf,
                           void *data, unsigned long long time_stamp)
 {
-       struct pevent_record record;
+       struct tep_record record;
        struct trace_seq s;
 
        record.ts = time_stamp;
@@ -327,7 +325,11 @@ static void parse_ras_data(struct pthread_data *pdata, struct kbuffer *kbuf,
 
        /* TODO - logging */
        trace_seq_init(&s);
-       pevent_print_event(pdata->ras->pevent, &s, &record);
+       tep_print_event(pdata->ras->pevent, &s, &record,
+                       "%16s-%-5d [%03d] %s %6.1000d %s %s",
+                        TEP_PRINT_COMM, TEP_PRINT_PID, TEP_PRINT_CPU,
+                        TEP_PRINT_LATENCY, TEP_PRINT_TIME, TEP_PRINT_NAME,
+                        TEP_PRINT_INFO);
        trace_seq_do_printf(&s);
        printf("\n");
        fflush(stdout);
@@ -688,13 +690,13 @@ static int select_tracing_timestamp(struct ras_events *ras)
        return 0;
 }
 
-static int add_event_handler(struct ras_events *ras, struct pevent *pevent,
+static int add_event_handler(struct ras_events *ras, struct tep_handle *pevent,
                             unsigned page_size, char *group, char *event,
-                            pevent_event_handler_func func, char *filter_str, int id)
+                            tep_event_handler_func func, char *filter_str, int id)
 {
        int fd, size, rc;
        char *page, fname[MAX_PATH + 1];
-       struct event_filter * filter = NULL;
+       struct tep_event_filter * filter = NULL;
 
        snprintf(fname, sizeof(fname), "events/%s/%s/format", group, event);
 
@@ -724,15 +726,15 @@ static int add_event_handler(struct ras_events *ras, struct pevent *pevent,
        }
 
        /* Registers the special event handlers */
-       rc = pevent_register_event_handler(pevent, -1, group, event, func, ras);
-       if (rc == PEVENT_ERRNO__MEM_ALLOC_FAILED) {
+       rc = tep_register_event_handler(pevent, -1, group, event, func, ras);
+       if (rc == TEP_ERRNO__MEM_ALLOC_FAILED) {
                log(TERM, LOG_ERR, "Can't register event handler for %s:%s\n",
                    group, event);
                free(page);
                return EINVAL;
        }
 
-       rc = pevent_parse_event(pevent, page, size, group);
+       rc = tep_parse_event(pevent, page, size, group);
        if (rc) {
                log(TERM, LOG_ERR, "Can't parse event %s:%s\n", group, event);
                free(page);
@@ -740,20 +742,21 @@ static int add_event_handler(struct ras_events *ras, struct pevent *pevent,
        }
 
        if (filter_str) {
-               char *error;
+               char error[255];
 
-               filter = pevent_filter_alloc(pevent);
+               filter = tep_filter_alloc(pevent);
                if (!filter) {
                        log(TERM, LOG_ERR,
                            "Failed to allocate filter for %s/%s.\n", group, event);
                        free(page);
                        return EINVAL;
                }
-               rc = pevent_filter_add_filter_str(filter, filter_str, &error);
-               if (rc) {
+               rc = tep_filter_add_filter_str(filter, filter_str);
+               if (rc < 0) {
+                       tep_filter_strerror(filter, rc, error, sizeof(error));
                        log(TERM, LOG_ERR,
                            "Failed to install filter for %s/%s: %s\n", group, event, error);
-                       pevent_filter_free(filter);
+                       tep_filter_free(filter);
                        free(page);
                        return rc;
                }
@@ -781,7 +784,7 @@ int handle_ras_events(int record_events)
        int rc, page_size, i;
        int num_events = 0;
        unsigned cpus;
-       struct pevent *pevent = NULL;
+       struct tep_handle *pevent = NULL;
        struct pthread_data *data = NULL;
        struct ras_events *ras = NULL;
 #ifdef HAVE_DEVLINK
@@ -806,7 +809,7 @@ int handle_ras_events(int record_events)
                goto err;
        }
 
-       pevent = pevent_alloc();
+       pevent = tep_alloc();
        if (!pevent) {
                log(TERM, LOG_ERR, "Can't allocate pevent\n");
                rc = errno;
@@ -996,12 +999,12 @@ err:
                free(data);
 
        if (pevent)
-               pevent_free(pevent);
+               tep_free(pevent);
 
        if (ras) {
                for (i = 0; i < NR_EVENTS; i++) {
                        if (ras->filters[i])
-                               pevent_filter_free(ras->filters[i]);
+                               tep_filter_free(ras->filters[i]);
                }
                free(ras);
        }

diff --git a/ras-events.h b/ras-events.h
index dfd690c3b0a497a63191a3017de3a4b71dcf8628..466d7af91febcfeb7c9dcad4cc41fd3cef13a582 100644 (file)
--- a/ras-events.h
+++ b/ras-events.h
@@ -45,7 +45,7 @@ enum {
 struct ras_events {
        char debugfs[MAX_PATH + 1];
        char tracing[MAX_PATH + 1];
-       struct pevent   *pevent;
+       struct tep_handle       *pevent;
        int             page_size;
 
        /* Booleans */
@@ -64,12 +64,12 @@ struct ras_events {
        /* For ABRT socket*/
        int socketfd;
 
-       struct event_filter *filters[NR_EVENTS];
+       struct tep_event_filter *filters[NR_EVENTS];
 };
 
 struct pthread_data {
        pthread_t               thread;
-       struct pevent           *pevent;
+       struct tep_handle               *pevent;
        struct ras_events       *ras;
        int                     cpu;
 };

diff --git a/ras-extlog-handler.c b/ras-extlog-handler.c
index 183468734cac0ac2c4f4e837a6b57c83b9deade2..8863e39f13362dec085982ff67a7cd2a81cb4546 100644 (file)
--- a/ras-extlog-handler.c
+++ b/ras-extlog-handler.c
@@ -22,7 +22,7 @@
 #include <string.h>
 #include <unistd.h>
 #include <stdint.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-extlog-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -170,7 +170,7 @@ static char *uuid_le(const char *uu)
 
 
 static void report_extlog_mem_event(struct ras_events *ras,
-                                   struct pevent_record *record,
+                                   struct tep_record *record,
                                    struct trace_seq *s,
                                    struct ras_extlog_event *ev)
 {
@@ -184,8 +184,8 @@ static void report_extlog_mem_event(struct ras_events *ras,
 }
 
 int ras_extlog_mem_event_handler(struct trace_seq *s,
-                         struct pevent_record *record,
-                         struct event_format *event, void *context)
+                         struct tep_record *record,
+                         struct tep_event *event, void *context)
 {
        int len;
        unsigned long long val;
@@ -214,28 +214,28 @@ int ras_extlog_mem_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       if (pevent_get_field_val(s,  event, "etype", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "etype", record, &val, 1) < 0)
                return -1;
        ev.etype = val;
-       if (pevent_get_field_val(s,  event, "err_seq", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "err_seq", record, &val, 1) < 0)
                return -1;
        ev.error_seq = val;
-       if (pevent_get_field_val(s,  event, "sev", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "sev", record, &val, 1) < 0)
                return -1;
        ev.severity = val;
-       if (pevent_get_field_val(s,  event, "pa", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "pa", record, &val, 1) < 0)
                return -1;
        ev.address = val;
-       if (pevent_get_field_val(s,  event, "pa_mask_lsb", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "pa_mask_lsb", record, &val, 1) < 0)
                return -1;
        ev.pa_mask_lsb = val;
 
-       ev.cper_data = pevent_get_field_raw(s, event, "data",
+       ev.cper_data = tep_get_field_raw(s, event, "data",
                                           record, &len, 1);
        ev.cper_data_length = len;
-       ev.fru_text = pevent_get_field_raw(s, event, "fru_text",
+       ev.fru_text = tep_get_field_raw(s, event, "fru_text",
                                           record, &len, 1);
-       ev.fru_id = pevent_get_field_raw(s, event, "fru_id",
+       ev.fru_id = tep_get_field_raw(s, event, "fru_id",
                                           record, &len, 1);
 
        report_extlog_mem_event(ras, record, s, &ev);

diff --git a/ras-extlog-handler.h b/ras-extlog-handler.h
index 54e8cec93af9439271762e62016f997ab2f506a3..5f08b100516aa244a0a0a12f75e37134d5e5cfcf 100644 (file)
--- a/ras-extlog-handler.h
+++ b/ras-extlog-handler.h
@@ -22,10 +22,10 @@
 #include <stdint.h>
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 extern int ras_extlog_mem_event_handler(struct trace_seq *s,
-                         struct pevent_record *record,
-                         struct event_format *event, void *context);
+                         struct tep_record *record,
+                         struct tep_event *event, void *context);
 
 #endif

diff --git a/ras-mc-handler.c b/ras-mc-handler.c
index 42b05cd7ee0036d84f33b138b355a5a5dfdf4019..1be9e7ef5f6dbae5e49485526d747b89a6d540b6 100644 (file)
--- a/ras-mc-handler.c
+++ b/ras-mc-handler.c
@@ -19,7 +19,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-mc-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -27,8 +27,8 @@
 #include "ras-report.h"
 
 int ras_mc_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context)
+                        struct tep_record *record,
+                        struct tep_event *event, void *context)
 {
        int len;
        unsigned long long val;
@@ -58,14 +58,14 @@ int ras_mc_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       if (pevent_get_field_val(s,  event, "error_count", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "error_count", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
 
        ev.error_count = val;
        trace_seq_printf(s, "%d ", ev.error_count);
 
-       if (pevent_get_field_val(s, event, "error_type", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "error_type", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
 
@@ -90,7 +90,7 @@ int ras_mc_event_handler(struct trace_seq *s,
        else
                trace_seq_puts(s, " error:");
 
-       ev.msg = pevent_get_field_raw(s, event, "msg", record, &len, 1);
+       ev.msg = tep_get_field_raw(s, event, "msg", record, &len, 1);
        if (!ev.msg)
                goto parse_error;
        parsed_fields++;
@@ -100,7 +100,7 @@ int ras_mc_event_handler(struct trace_seq *s,
                trace_seq_puts(s, ev.msg);
        }
 
-       ev.label = pevent_get_field_raw(s, event, "label", record, &len, 1);
+       ev.label = tep_get_field_raw(s, event, "label", record, &len, 1);
        if (!ev.label)
                goto parse_error;
        parsed_fields++;
@@ -111,24 +111,24 @@ int ras_mc_event_handler(struct trace_seq *s,
        }
 
        trace_seq_puts(s, " (");
-       if (pevent_get_field_val(s,  event, "mc_index", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "mc_index", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
 
        ev.mc_index = val;
        trace_seq_printf(s, "mc: %d", ev.mc_index);
 
-       if (pevent_get_field_val(s,  event, "top_layer", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "top_layer", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
        ev.top_layer = (signed char) val;
 
-       if (pevent_get_field_val(s,  event, "middle_layer", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "middle_layer", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
        ev.middle_layer = (signed char) val;
 
-       if (pevent_get_field_val(s,  event, "lower_layer", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "lower_layer", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
        ev.lower_layer = (signed char) val;
@@ -144,7 +144,7 @@ int ras_mc_event_handler(struct trace_seq *s,
                        trace_seq_printf(s, " location: %d", ev.top_layer);
        }
 
-       if (pevent_get_field_val(s,  event, "address", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "address", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
 
@@ -152,7 +152,7 @@ int ras_mc_event_handler(struct trace_seq *s,
        if (ev.address)
                trace_seq_printf(s, " address: 0x%08llx", ev.address);
 
-       if (pevent_get_field_val(s,  event, "grain_bits", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "grain_bits", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
 
@@ -160,7 +160,7 @@ int ras_mc_event_handler(struct trace_seq *s,
        trace_seq_printf(s, " grain: %lld", ev.grain);
 
 
-       if (pevent_get_field_val(s,  event, "syndrome", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "syndrome", record, &val, 1) < 0)
                goto parse_error;
        parsed_fields++;
 
@@ -168,7 +168,7 @@ int ras_mc_event_handler(struct trace_seq *s,
        if (val)
                trace_seq_printf(s, " syndrome: 0x%08llx", ev.syndrome);
 
-       ev.driver_detail = pevent_get_field_raw(s, event, "driver_detail", record,
+       ev.driver_detail = tep_get_field_raw(s, event, "driver_detail", record,
                                             &len, 1);
        if (!ev.driver_detail)
                goto parse_error;

diff --git a/ras-mc-handler.h b/ras-mc-handler.h
index 2e3dfc50c058ef05ed16f6b5a6b65904b0919615..afc000506dd8ea806743859020a9d71dab5e3500 100644 (file)
--- a/ras-mc-handler.h
+++ b/ras-mc-handler.h
@@ -20,10 +20,10 @@
 #define __RAS_MC_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 int ras_mc_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context);
+                        struct tep_record *record,
+                        struct tep_event *event, void *context);
 
 #endif

diff --git a/ras-mce-handler.c b/ras-mce-handler.c
index f2b53d43b37e6d72f2b3c86f7348a21ecae787c3..66004153d8a31a831baf50a9134dcef63a258410 100644 (file)
--- a/ras-mce-handler.c
+++ b/ras-mce-handler.c
@@ -22,7 +22,7 @@
 #include <string.h>
 #include <unistd.h>
 #include <stdint.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-mce-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -273,7 +273,7 @@ int register_mce_handler(struct ras_events *ras, unsigned ncpus)
  */
 
 static void report_mce_event(struct ras_events *ras,
-                            struct pevent_record *record,
+                            struct tep_record *record,
                             struct trace_seq *s, struct mce_event *e)
 {
        time_t now;
@@ -384,8 +384,8 @@ static void report_mce_event(struct ras_events *ras,
 }
 
 int ras_mce_event_handler(struct trace_seq *s,
-                         struct pevent_record *record,
-                         struct event_format *event, void *context)
+                         struct tep_record *record,
+                         struct tep_event *event, void *context)
 {
        unsigned long long val;
        struct ras_events *ras = context;
@@ -396,56 +396,56 @@ int ras_mce_event_handler(struct trace_seq *s,
        memset(&e, 0, sizeof(e));
 
        /* Parse the MCE error data */
-       if (pevent_get_field_val(s, event, "mcgcap", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "mcgcap", record, &val, 1) < 0)
                return -1;
        e.mcgcap = val;
-       if (pevent_get_field_val(s, event, "mcgstatus", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "mcgstatus", record, &val, 1) < 0)
                return -1;
        e.mcgstatus = val;
-       if (pevent_get_field_val(s, event, "status", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "status", record, &val, 1) < 0)
                return -1;
        e.status = val;
-       if (pevent_get_field_val(s, event, "addr", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "addr", record, &val, 1) < 0)
                return -1;
        e.addr = val;
-       if (pevent_get_field_val(s, event, "misc", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "misc", record, &val, 1) < 0)
                return -1;
        e.misc = val;
-       if (pevent_get_field_val(s, event, "ip", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "ip", record, &val, 1) < 0)
                return -1;
        e.ip = val;
-       if (pevent_get_field_val(s, event, "tsc", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "tsc", record, &val, 1) < 0)
                return -1;
        e.tsc = val;
-       if (pevent_get_field_val(s, event, "walltime", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "walltime", record, &val, 1) < 0)
                return -1;
        e.walltime = val;
-       if (pevent_get_field_val(s, event, "cpu", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "cpu", record, &val, 1) < 0)
                return -1;
        e.cpu = val;
-       if (pevent_get_field_val(s, event, "cpuid", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "cpuid", record, &val, 1) < 0)
                return -1;
        e.cpuid = val;
-       if (pevent_get_field_val(s, event, "apicid", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "apicid", record, &val, 1) < 0)
                return -1;
        e.apicid = val;
-       if (pevent_get_field_val(s, event, "socketid", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "socketid", record, &val, 1) < 0)
                return -1;
        e.socketid = val;
-       if (pevent_get_field_val(s, event, "cs", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "cs", record, &val, 1) < 0)
                return -1;
        e.cs = val;
-       if (pevent_get_field_val(s, event, "bank", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "bank", record, &val, 1) < 0)
                return -1;
        e.bank = val;
-       if (pevent_get_field_val(s, event, "cpuvendor", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "cpuvendor", record, &val, 1) < 0)
                return -1;
        e.cpuvendor = val;
        /* Get New entries */
-       if (pevent_get_field_val(s, event, "synd", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "synd", record, &val, 1) < 0)
                return -1;
        e.synd = val;
-       if (pevent_get_field_val(s, event, "ipid", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "ipid", record, &val, 1) < 0)
                return -1;
        e.ipid = val;
 

diff --git a/ras-mce-handler.h b/ras-mce-handler.h
index c6216ee009eabbf7e87655245bbb91230441c47d..91ff5f7f5b7cd688494ae975e94e9a1633d8c5b0 100644 (file)
--- a/ras-mce-handler.h
+++ b/ras-mce-handler.h
@@ -22,7 +22,7 @@
 #include <stdint.h>
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 enum cputype {
        CPU_GENERIC,
@@ -112,8 +112,8 @@ struct mce_priv {
 /* register and handling routines */
 int register_mce_handler(struct ras_events *ras, unsigned ncpus);
 int ras_mce_event_handler(struct trace_seq *s,
-                         struct pevent_record *record,
-                         struct event_format *event, void *context);
+                         struct tep_record *record,
+                         struct tep_event *event, void *context);
 
 /* enables intel iMC logs */
 int set_intel_imc_log(enum cputype cputype, unsigned ncpus);

diff --git a/ras-memory-failure-handler.c b/ras-memory-failure-handler.c
index 1951456a67524c3bb57b93eccc1537dd2576c7fc..72c65deab16ba3723342dc11cf0693f50e53f95b 100644 (file)
--- a/ras-memory-failure-handler.c
+++ b/ras-memory-failure-handler.c
@@ -15,7 +15,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-memory-failure-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -121,8 +121,8 @@ static const char *get_action_result(int result)
 
 
 int ras_memory_failure_event_handler(struct trace_seq *s,
-                                    struct pevent_record *record,
-                                    struct event_format *event, void *context)
+                                    struct tep_record *record,
+                                    struct tep_event *event, void *context)
 {
        unsigned long long val;
        struct ras_events *ras = context;
@@ -152,17 +152,17 @@ int ras_memory_failure_event_handler(struct trace_seq *s,
                strncpy(ev.timestamp, "1970-01-01 00:00:00 +0000", sizeof(ev.timestamp));
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       if (pevent_get_field_val(s,  event, "pfn", record, &val, 1) < 0)
+       if (tep_get_field_val(s,  event, "pfn", record, &val, 1) < 0)
                return -1;
        sprintf(ev.pfn, "0x%llx", val);
        trace_seq_printf(s, "pfn=0x%llx ", val);
 
-       if (pevent_get_field_val(s, event, "type", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "type", record, &val, 1) < 0)
                return -1;
        ev.page_type = get_page_type(val);
        trace_seq_printf(s, "page_type=%s ", ev.page_type);
 
-       if (pevent_get_field_val(s, event, "result", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "result", record, &val, 1) < 0)
                return -1;
        ev.action_result = get_action_result(val);
        trace_seq_printf(s, "action_result=%s ", ev.action_result);

diff --git a/ras-memory-failure-handler.h b/ras-memory-failure-handler.h
index b9e99716162196700cdfd36945c784035c4359d0..a28ca24d962b8527c3cd02b9170f512bc452f214 100644 (file)
--- a/ras-memory-failure-handler.h
+++ b/ras-memory-failure-handler.h
@@ -16,10 +16,10 @@
 #define __RAS_MEMORY_FAILURE_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 int ras_memory_failure_event_handler(struct trace_seq *s,
-                                    struct pevent_record *record,
-                                    struct event_format *event, void *context);
+                                    struct tep_record *record,
+                                    struct tep_event *event, void *context);
 
 #endif

diff --git a/ras-non-standard-handler.c b/ras-non-standard-handler.c
index 6932e581245bc9c543cc235523d5c494842a049d..d7f39447b7534b0b3338da92896b8386e03a8862 100644 (file)
--- a/ras-non-standard-handler.c
+++ b/ras-non-standard-handler.c
@@ -16,7 +16,7 @@
 #include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
-#include "libtrace/kbuffer.h"
+#include <traceevent/kbuffer.h>
 #include "ras-non-standard-handler.h"
 #include "ras-record.h"
 #include "ras-logger.h"
@@ -113,8 +113,8 @@ static void unregister_ns_ev_decoder(void)
 }
 
 int ras_non_standard_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context)
+                        struct tep_record *record,
+                        struct tep_event *event, void *context)
 {
        int len, i, line_count;
        unsigned long long val;
@@ -144,7 +144,7 @@ int ras_non_standard_event_handler(struct trace_seq *s,
                         "%Y-%m-%d %H:%M:%S %z", tm);
        trace_seq_printf(s, "%s ", ev.timestamp);
 
-       if (pevent_get_field_val(s, event, "sev", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "sev", record, &val, 1) < 0)
                return -1;
        switch (val) {
        case GHES_SEV_NO:
@@ -162,7 +162,7 @@ int ras_non_standard_event_handler(struct trace_seq *s,
        }
        trace_seq_printf(s, "\n %s", ev.severity);
 
-       ev.sec_type = pevent_get_field_raw(s, event, "sec_type",
+       ev.sec_type = tep_get_field_raw(s, event, "sec_type",
                                           record, &len, 1);
        if(!ev.sec_type)
                return -1;
@@ -173,20 +173,20 @@ int ras_non_standard_event_handler(struct trace_seq *s,
        else
                trace_seq_printf(s, "\n section type: %s",
                                 uuid_le(ev.sec_type));
-       ev.fru_text = pevent_get_field_raw(s, event, "fru_text",
+       ev.fru_text = tep_get_field_raw(s, event, "fru_text",
                                                record, &len, 1);
-       ev.fru_id = pevent_get_field_raw(s, event, "fru_id",
+       ev.fru_id = tep_get_field_raw(s, event, "fru_id",
                                                record, &len, 1);
        trace_seq_printf(s, " fru text: %s fru id: %s ",
                                ev.fru_text,
                                uuid_le(ev.fru_id));
 
-       if (pevent_get_field_val(s, event, "len", record, &val, 1) < 0)
+       if (tep_get_field_val(s, event, "len", record, &val, 1) < 0)
                return -1;
        ev.length = val;
        trace_seq_printf(s, "\n length: %d\n", ev.length);
 
-       ev.error = pevent_get_field_raw(s, event, "buf", record, &len, 1);
+       ev.error = tep_get_field_raw(s, event, "buf", record, &len, 1);
        if(!ev.error)
                return -1;
 

diff --git a/ras-non-standard-handler.h b/ras-non-standard-handler.h
index 57d4cb57225c82daf0825747e8b1a7e8ed235e88..0faed9efdcb3657927b51d0085db1d87033425c1 100644 (file)
--- a/ras-non-standard-handler.h
+++ b/ras-non-standard-handler.h
@@ -15,7 +15,7 @@
 #define __RAS_NON_STANDARD_HANDLER_H
 
 #include "ras-events.h"
-#include "libtrace/event-parse.h"
+#include <traceevent/event-parse.h>
 
 #define BIT(nr)                 (1UL << (nr))
 #define BIT_ULL(nr)             (1ULL << (nr))
@@ -32,8 +32,8 @@ struct ras_ns_ev_decoder {
 };
 
 int ras_non_standard_event_handler(struct trace_seq *s,
-                        struct pevent_record *record,
-                        struct event_format *event, void *context);
+                        struct tep_record *record,
+                        struct tep_event *event, void *context);
 
 void print_le_hex(struct trace_seq *s, const uint8_t *buf, int index);