Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull perf updates from Ingo Molnar:
 "The main updates in this cycle were:

   - Lots of perf tooling changes too voluminous to list (big perf trace
     and perf stat improvements, lots of libtraceevent reorganization,
     etc.), so I'll list the authors and refer to the changelog for
     details:

       Benjamin Peterson, Jérémie Galarneau, Kim Phillips, Peter
       Zijlstra, Ravi Bangoria, Sangwon Hong, Sean V Kelley, Steven
       Rostedt, Thomas Gleixner, Ding Xiang, Eduardo Habkost, Thomas
       Richter, Andi Kleen, Sanskriti Sharma, Adrian Hunter, Tzvetomir
       Stoyanov, Arnaldo Carvalho de Melo, Jiri Olsa.

     ... with the bulk of the changes written by Jiri Olsa, Tzvetomir
     Stoyanov and Arnaldo Carvalho de Melo.

   - Continued intel_rdt work with a focus on playing well with perf
     events. This also imported some non-perf RDT work due to
     dependencies. (Reinette Chatre)

   - Implement counter freezing for Arch Perfmon v4 (Skylake and newer).
     This allows to speed up the PMI handler by avoiding unnecessary MSR
     writes and make it more accurate. (Andi Kleen)

   - kprobes cleanups and simplification (Masami Hiramatsu)

   - Intel Goldmont PMU updates (Kan Liang)

   - ... plus misc other fixes and updates"

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (155 commits)
  kprobes/x86: Use preempt_enable() in optimized_callback()
  x86/intel_rdt: Prevent pseudo-locking from using stale pointers
  kprobes, x86/ptrace.h: Make regs_get_kernel_stack_nth() not fault on bad stack
  perf/x86/intel: Export mem events only if there's PEBS support
  x86/cpu: Drop pointless static qualifier in punit_dev_state_show()
  x86/intel_rdt: Fix initial allocation to consider CDP
  x86/intel_rdt: CBM overlap should also check for overlap with CDP peer
  x86/intel_rdt: Introduce utility to obtain CDP peer
  tools lib traceevent, perf tools: Move struct tep_handler definition in a local header file
  tools lib traceevent: Separate out tep_strerror() for strerror_r() issues
  perf python: More portable way to make CFLAGS work with clang
  perf python: Make clang_has_option() work on Python 3
  perf tools: Free temporary 'sys' string in read_event_files()
  perf tools: Avoid double free in read_event_file()
  perf tools: Free 'printk' string in parse_ftrace_printk()
  perf tools: Cleanup trace-event-info 'tdata' leak
  perf strbuf: Match va_{add,copy} with va_end
  perf test: S390 does not support watchpoints in test 22
  perf auxtrace: Include missing asm/bitsperlong.h to get BITS_PER_LONG
  tools include: Adopt linux/bits.h
  ...

141 files changed, 6261 insertions, 3870 deletions

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index e9054fd1d0d0..4c74a2f4ddfc 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -856,6 +856,11 @@
                         causing system reset or hang due to sending
                         INIT from AP to BSP.
 
+        disable_counter_freezing [HW]
+                        Disable Intel PMU counter freezing feature.
+                        The feature only exists starting from
+                        Arch Perfmon v4 (Skylake and newer).
+
         disable_ddw     [PPC/PSERIES]
                         Disable Dynamic DMA Window support. Use this if
                         to workaround buggy firmware.
diff --git a/Documentation/x86/intel_rdt_ui.txt b/Documentation/x86/intel_rdt_ui.txt
index f662d3c530e5..52b10945ff75 100644
--- a/Documentation/x86/intel_rdt_ui.txt
+++ b/Documentation/x86/intel_rdt_ui.txt
@@ -520,18 +520,24 @@ the pseudo-locked region:
 2) Cache hit and miss measurements using model specific precision counters if
    available. Depending on the levels of cache on the system the pseudo_lock_l2
    and pseudo_lock_l3 tracepoints are available.
-   WARNING: triggering this  measurement uses from two (for just L2
-   measurements) to four (for L2 and L3 measurements) precision counters on
-   the system, if any other measurements are in progress the counters and
-   their corresponding event registers will be clobbered.
 
 When a pseudo-locked region is created a new debugfs directory is created for
 it in debugfs as /sys/kernel/debug/resctrl/<newdir>. A single
 write-only file, pseudo_lock_measure, is present in this directory. The
-measurement on the pseudo-locked region depends on the number, 1 or 2,
-written to this debugfs file. Since the measurements are recorded with the
-tracing infrastructure the relevant tracepoints need to be enabled before the
-measurement is triggered.
+measurement of the pseudo-locked region depends on the number written to this
+debugfs file:
+1 -  writing "1" to the pseudo_lock_measure file will trigger the latency
+     measurement captured in the pseudo_lock_mem_latency tracepoint. See
+     example below.
+2 -  writing "2" to the pseudo_lock_measure file will trigger the L2 cache
+     residency (cache hits and misses) measurement captured in the
+     pseudo_lock_l2 tracepoint. See example below.
+3 -  writing "3" to the pseudo_lock_measure file will trigger the L3 cache
+     residency (cache hits and misses) measurement captured in the
+     pseudo_lock_l3 tracepoint.
+
+All measurements are recorded with the tracing infrastructure. This requires
+the relevant tracepoints to be enabled before the measurement is triggered.
 
 Example of latency debugging interface:
 In this example a pseudo-locked region named "newlock" was created. Here is
diff --git a/arch/x86/events/core.c b/arch/x86/events/core.c
index dfb2f7c0d019..de32741d041a 100644
--- a/arch/x86/events/core.c
+++ b/arch/x86/events/core.c
@@ -1033,6 +1033,27 @@ static inline void x86_assign_hw_event(struct perf_event *event,
         }
 }
 
+/**
+ * x86_perf_rdpmc_index - Return PMC counter used for event
+ * @event: the perf_event to which the PMC counter was assigned
+ *
+ * The counter assigned to this performance event may change if interrupts
+ * are enabled. This counter should thus never be used while interrupts are
+ * enabled. Before this function is used to obtain the assigned counter the
+ * event should be checked for validity using, for example,
+ * perf_event_read_local(), within the same interrupt disabled section in
+ * which this counter is planned to be used.
+ *
+ * Return: The index of the performance monitoring counter assigned to
+ * @perf_event.
+ */
+int x86_perf_rdpmc_index(struct perf_event *event)
+{
+        lockdep_assert_irqs_disabled();
+
+        return event->hw.event_base_rdpmc;
+}
+
 static inline int match_prev_assignment(struct hw_perf_event *hwc,
                                         struct cpu_hw_events *cpuc,
                                         int i)
@@ -1584,7 +1605,7 @@ static void __init pmu_check_apic(void)
 
 }
 
-static struct attribute_group x86_pmu_format_group = {
+static struct attribute_group x86_pmu_format_group __ro_after_init = {
         .name = "format",
         .attrs = NULL,
 };
@@ -1631,9 +1652,9 @@ __init struct attribute **merge_attr(struct attribute **a, struct attribute **b)
         struct attribute **new;
         int j, i;
 
-        for (j = 0; a[j]; j++)
+        for (j = 0; a && a[j]; j++)
                 ;
-        for (i = 0; b[i]; i++)
+        for (i = 0; b && b[i]; i++)
                 j++;
         j++;
 
@@ -1642,9 +1663,9 @@ __init struct attribute **merge_attr(struct attribute **a, struct attribute **b)
                 return NULL;
 
         j = 0;
-        for (i = 0; a[i]; i++)
+        for (i = 0; a && a[i]; i++)
                 new[j++] = a[i];
-        for (i = 0; b[i]; i++)
+        for (i = 0; b && b[i]; i++)
                 new[j++] = b[i];
         new[j] = NULL;
 
@@ -1715,7 +1736,7 @@ static struct attribute *events_attr[] = {
         NULL,
 };
 
-static struct attribute_group x86_pmu_events_group = {
+static struct attribute_group x86_pmu_events_group __ro_after_init = {
         .name = "events",
         .attrs = events_attr,
 };
@@ -2230,7 +2251,7 @@ static struct attribute *x86_pmu_attrs[] = {
         NULL,
 };
 
-static struct attribute_group x86_pmu_attr_group = {
+static struct attribute_group x86_pmu_attr_group __ro_after_init = {
         .attrs = x86_pmu_attrs,
 };
 
@@ -2248,7 +2269,7 @@ static struct attribute *x86_pmu_caps_attrs[] = {
         NULL
 };
 
-static struct attribute_group x86_pmu_caps_group = {
+static struct attribute_group x86_pmu_caps_group __ro_after_init = {
         .name = "caps",
         .attrs = x86_pmu_caps_attrs,
 };
diff --git a/arch/x86/events/intel/core.c b/arch/x86/events/intel/core.c
index 035c37481f57..0fb8659b20d8 100644
--- a/arch/x86/events/intel/core.c
+++ b/arch/x86/events/intel/core.c
@@ -242,7 +242,7 @@ EVENT_ATTR_STR(mem-loads,	mem_ld_nhm,	"event=0x0b,umask=0x10,ldlat=3");
 EVENT_ATTR_STR(mem-loads,       mem_ld_snb,     "event=0xcd,umask=0x1,ldlat=3");
 EVENT_ATTR_STR(mem-stores,      mem_st_snb,     "event=0xcd,umask=0x2");
 
-static struct attribute *nhm_events_attrs[] = {
+static struct attribute *nhm_mem_events_attrs[] = {
         EVENT_PTR(mem_ld_nhm),
         NULL,
 };
@@ -278,8 +278,6 @@ EVENT_ATTR_STR_HT(topdown-recovery-bubbles.scale, td_recovery_bubbles_scale,
         "4", "2");
 
 static struct attribute *snb_events_attrs[] = {
-        EVENT_PTR(mem_ld_snb),
-        EVENT_PTR(mem_st_snb),
         EVENT_PTR(td_slots_issued),
         EVENT_PTR(td_slots_retired),
         EVENT_PTR(td_fetch_bubbles),
@@ -290,6 +288,12 @@ static struct attribute *snb_events_attrs[] = {
         NULL,
 };
 
+static struct attribute *snb_mem_events_attrs[] = {
+        EVENT_PTR(mem_ld_snb),
+        EVENT_PTR(mem_st_snb),
+        NULL,
+};
+
 static struct event_constraint intel_hsw_event_constraints[] = {
         FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
         FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
@@ -1995,6 +1999,18 @@ static void intel_pmu_nhm_enable_all(int added)
         intel_pmu_enable_all(added);
 }
 
+static void enable_counter_freeze(void)
+{
+        update_debugctlmsr(get_debugctlmsr() |
+                        DEBUGCTLMSR_FREEZE_PERFMON_ON_PMI);
+}
+
+static void disable_counter_freeze(void)
+{
+        update_debugctlmsr(get_debugctlmsr() &
+                        ~DEBUGCTLMSR_FREEZE_PERFMON_ON_PMI);
+}
+
 static inline u64 intel_pmu_get_status(void)
 {
         u64 status;
@@ -2200,59 +2216,15 @@ static void intel_pmu_reset(void)
         local_irq_restore(flags);
 }
 
-/*
- * This handler is triggered by the local APIC, so the APIC IRQ handling
- * rules apply:
- */
-static int intel_pmu_handle_irq(struct pt_regs *regs)
+static int handle_pmi_common(struct pt_regs *regs, u64 status)
 {
         struct perf_sample_data data;
-        struct cpu_hw_events *cpuc;
-        int bit, loops;
-        u64 status;
-        int handled;
-        int pmu_enabled;
-
-        cpuc = this_cpu_ptr(&cpu_hw_events);
-
-        /*
-         * Save the PMU state.
-         * It needs to be restored when leaving the handler.
-         */
-        pmu_enabled = cpuc->enabled;
-        /*
-         * No known reason to not always do late ACK,
-         * but just in case do it opt-in.
-         */
-        if (!x86_pmu.late_ack)
-                apic_write(APIC_LVTPC, APIC_DM_NMI);
-        intel_bts_disable_local();
-        cpuc->enabled = 0;
-        __intel_pmu_disable_all();
-        handled = intel_pmu_drain_bts_buffer();
-        handled += intel_bts_interrupt();
-        status = intel_pmu_get_status();
-        if (!status)
-                goto done;
-
-        loops = 0;
-again:
-        intel_pmu_lbr_read();
-        intel_pmu_ack_status(status);
-        if (++loops > 100) {
-                static bool warned = false;
-                if (!warned) {
-                        WARN(1, "perfevents: irq loop stuck!\n");
-                        perf_event_print_debug();
-                        warned = true;
-                }
-                intel_pmu_reset();
-                goto done;
-        }
+        struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
+        int bit;
+        int handled = 0;
 
         inc_irq_stat(apic_perf_irqs);
 
-
         /*
          * Ignore a range of extra bits in status that do not indicate
          * overflow by themselves.
@@ -2261,7 +2233,7 @@ again:
                     GLOBAL_STATUS_ASIF |
                     GLOBAL_STATUS_LBRS_FROZEN);
         if (!status)
-                goto done;
+                return 0;
         /*
          * In case multiple PEBS events are sampled at the same time,
          * it is possible to have GLOBAL_STATUS bit 62 set indicating
@@ -2331,6 +2303,146 @@ again:
                         x86_pmu_stop(event, 0);
         }
 
+        return handled;
+}
+
+static bool disable_counter_freezing;
+static int __init intel_perf_counter_freezing_setup(char *s)
+{
+        disable_counter_freezing = true;
+        pr_info("Intel PMU Counter freezing feature disabled\n");
+        return 1;
+}
+__setup("disable_counter_freezing", intel_perf_counter_freezing_setup);
+
+/*
+ * Simplified handler for Arch Perfmon v4:
+ * - We rely on counter freezing/unfreezing to enable/disable the PMU.
+ * This is done automatically on PMU ack.
+ * - Ack the PMU only after the APIC.
+ */
+
+static int intel_pmu_handle_irq_v4(struct pt_regs *regs)
+{
+        struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events);
+        int handled = 0;
+        bool bts = false;
+        u64 status;
+        int pmu_enabled = cpuc->enabled;
+        int loops = 0;
+
+        /* PMU has been disabled because of counter freezing */
+        cpuc->enabled = 0;
+        if (test_bit(INTEL_PMC_IDX_FIXED_BTS, cpuc->active_mask)) {
+                bts = true;
+                intel_bts_disable_local();
+                handled = intel_pmu_drain_bts_buffer();
+                handled += intel_bts_interrupt();
+        }
+        status = intel_pmu_get_status();
+        if (!status)
+                goto done;
+again:
+        intel_pmu_lbr_read();
+        if (++loops > 100) {
+                static bool warned;
+
+                if (!warned) {
+                        WARN(1, "perfevents: irq loop stuck!\n");
+                        perf_event_print_debug();
+                        warned = true;
+                }
+                intel_pmu_reset();
+                goto done;
+        }
+
+
+        handled += handle_pmi_common(regs, status);
+done:
+        /* Ack the PMI in the APIC */
+        apic_write(APIC_LVTPC, APIC_DM_NMI);
+
+        /*
+         * The counters start counting immediately while ack the status.
+         * Make it as close as possible to IRET. This avoids bogus
+         * freezing on Skylake CPUs.
+         */
+        if (status) {
+                intel_pmu_ack_status(status);
+        } else {
+                /*
+                 * CPU may issues two PMIs very close to each other.
+                 * When the PMI handler services the first one, the
+                 * GLOBAL_STATUS is already updated to reflect both.
+                 * When it IRETs, the second PMI is immediately
+                 * handled and it sees clear status. At the meantime,
+                 * there may be a third PMI, because the freezing bit
+                 * isn't set since the ack in first PMI handlers.
+                 * Double check if there is more work to be done.
+                 */
+                status = intel_pmu_get_status();
+                if (status)
+                        goto again;
+        }
+
+        if (bts)
+                intel_bts_enable_local();
+        cpuc->enabled = pmu_enabled;
+        return handled;
+}
+
+/*
+ * This handler is triggered by the local APIC, so the APIC IRQ handling
+ * rules apply:
+ */
+static int intel_pmu_handle_irq(struct pt_regs *regs)
+{
+        struct cpu_hw_events *cpuc;
+        int loops;
+        u64 status;
+        int handled;
+        int pmu_enabled;
+
+        cpuc = this_cpu_ptr(&cpu_hw_events);
+
+        /*
+         * Save the PMU state.
+         * It needs to be restored when leaving the handler.
+         */
+        pmu_enabled = cpuc->enabled;
+        /*
+         * No known reason to not always do late ACK,
+         * but just in case do it opt-in.
+         */
+        if (!x86_pmu.late_ack)
+                apic_write(APIC_LVTPC, APIC_DM_NMI);
+        intel_bts_disable_local();
+        cpuc->enabled = 0;
+        __intel_pmu_disable_all();
+        handled = intel_pmu_drain_bts_buffer();
+        handled += intel_bts_interrupt();
+        status = intel_pmu_get_status();
+        if (!status)
+                goto done;
+
+        loops = 0;
+again:
+        intel_pmu_lbr_read();
+        intel_pmu_ack_status(status);
+        if (++loops > 100) {
+                static bool warned;
+
+                if (!warned) {
+                        WARN(1, "perfevents: irq loop stuck!\n");
+                        perf_event_print_debug();
+                        warned = true;
+                }
+                intel_pmu_reset();
+                goto done;
+        }
+
+        handled += handle_pmi_common(regs, status);
+
         /*
          * Repeat if there is more work to be done:
          */
@@ -3350,6 +3462,9 @@ static void intel_pmu_cpu_starting(int cpu)
         if (x86_pmu.version > 1)
                 flip_smm_bit(&x86_pmu.attr_freeze_on_smi);
 
+        if (x86_pmu.counter_freezing)
+                enable_counter_freeze();
+
         if (!cpuc->shared_regs)
                 return;
 
@@ -3421,6 +3536,9 @@ static void intel_pmu_cpu_dying(int cpu)
         free_excl_cntrs(cpu);
 
         fini_debug_store_on_cpu(cpu);
+
+        if (x86_pmu.counter_freezing)
+                disable_counter_freeze();
 }
 
 static void intel_pmu_sched_task(struct perf_event_context *ctx,
@@ -3725,6 +3843,40 @@ static __init void intel_nehalem_quirk(void)
         }
 }
 
+static bool intel_glp_counter_freezing_broken(int cpu)
+{
+        u32 rev = UINT_MAX; /* default to broken for unknown stepping */
+
+        switch (cpu_data(cpu).x86_stepping) {
+        case 1:
+                rev = 0x28;
+                break;
+        case 8:
+                rev = 0x6;
+                break;
+        }
+
+        return (cpu_data(cpu).microcode < rev);
+}
+
+static __init void intel_glp_counter_freezing_quirk(void)
+{
+        /* Check if it's already disabled */
+        if (disable_counter_freezing)
+                return;
+
+        /*
+         * If the system starts with the wrong ucode, leave the
+         * counter-freezing feature permanently disabled.
+         */
+        if (intel_glp_counter_freezing_broken(raw_smp_processor_id())) {
+                pr_info("PMU counter freezing disabled due to CPU errata,"
+                        "please upgrade microcode\n");
+                x86_pmu.counter_freezing = false;
+                x86_pmu.handle_irq = intel_pmu_handle_irq;
+        }
+}
+
 /*
  * enable software workaround for errata:
  * SNB: BJ122
@@ -3764,8 +3916,6 @@ EVENT_ATTR_STR(cycles-t,	cycles_t,	"event=0x3c,in_tx=1");
 EVENT_ATTR_STR(cycles-ct,       cycles_ct,      "event=0x3c,in_tx=1,in_tx_cp=1");
 
 static struct attribute *hsw_events_attrs[] = {
-        EVENT_PTR(mem_ld_hsw),
-        EVENT_PTR(mem_st_hsw),
         EVENT_PTR(td_slots_issued),
         EVENT_PTR(td_slots_retired),
         EVENT_PTR(td_fetch_bubbles),
@@ -3776,6 +3926,12 @@ static struct attribute *hsw_events_attrs[] = {
         NULL
 };
 
+static struct attribute *hsw_mem_events_attrs[] = {
+        EVENT_PTR(mem_ld_hsw),
+        EVENT_PTR(mem_st_hsw),
+        NULL,
+};
+
 static struct attribute *hsw_tsx_events_attrs[] = {
         EVENT_PTR(tx_start),
         EVENT_PTR(tx_commit),
@@ -3792,13 +3948,6 @@ static struct attribute *hsw_tsx_events_attrs[] = {
         NULL
 };
 
-static __init struct attribute **get_hsw_events_attrs(void)
-{
-        return boot_cpu_has(X86_FEATURE_RTM) ?
-                merge_attr(hsw_events_attrs, hsw_tsx_events_attrs) :
-                hsw_events_attrs;
-}
-
 static ssize_t freeze_on_smi_show(struct device *cdev,
                                   struct device_attribute *attr,
                                   char *buf)
@@ -3875,9 +4024,32 @@ static struct attribute *intel_pmu_attrs[] = {
         NULL,
 };
 
+static __init struct attribute **
+get_events_attrs(struct attribute **base,
+                 struct attribute **mem,
+                 struct attribute **tsx)
+{
+        struct attribute **attrs = base;
+        struct attribute **old;
+
+        if (mem && x86_pmu.pebs)
+                attrs = merge_attr(attrs, mem);
+
+        if (tsx && boot_cpu_has(X86_FEATURE_RTM)) {
+                old = attrs;
+                attrs = merge_attr(attrs, tsx);
+                if (old != base)
+                        kfree(old);
+        }
+
+        return attrs;
+}
+
 __init int intel_pmu_init(void)
 {
         struct attribute **extra_attr = NULL;
+        struct attribute **mem_attr = NULL;
+        struct attribute **tsx_attr = NULL;
         struct attribute **to_free = NULL;
         union cpuid10_edx edx;
         union cpuid10_eax eax;
@@ -3935,6 +4107,9 @@ __init int intel_pmu_init(void)
                         max((int)edx.split.num_counters_fixed, assume);
         }
 
+        if (version >= 4)
+                x86_pmu.counter_freezing = !disable_counter_freezing;
+
         if (boot_cpu_has(X86_FEATURE_PDCM)) {
                 u64 capabilities;
 
@@ -3986,7 +4161,7 @@ __init int intel_pmu_init(void)
                 x86_pmu.enable_all = intel_pmu_nhm_enable_all;
                 x86_pmu.extra_regs = intel_nehalem_extra_regs;
 
-                x86_pmu.cpu_events = nhm_events_attrs;
+                mem_attr = nhm_mem_events_attrs;
 
                 /* UOPS_ISSUED.STALLED_CYCLES */
                 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =
@@ -4004,11 +4179,11 @@ __init int intel_pmu_init(void)
                 name = "nehalem";
                 break;
 
-        case INTEL_FAM6_ATOM_PINEVIEW:
-        case INTEL_FAM6_ATOM_LINCROFT:
-        case INTEL_FAM6_ATOM_PENWELL:
-        case INTEL_FAM6_ATOM_CLOVERVIEW:
-        case INTEL_FAM6_ATOM_CEDARVIEW:
+        case INTEL_FAM6_ATOM_BONNELL:
+        case INTEL_FAM6_ATOM_BONNELL_MID:
+        case INTEL_FAM6_ATOM_SALTWELL:
+        case INTEL_FAM6_ATOM_SALTWELL_MID:
+        case INTEL_FAM6_ATOM_SALTWELL_TABLET:
                 memcpy(hw_cache_event_ids, atom_hw_cache_event_ids,
                        sizeof(hw_cache_event_ids));
 
@@ -4021,9 +4196,11 @@ __init int intel_pmu_init(void)
                 name = "bonnell";
                 break;
 
-        case INTEL_FAM6_ATOM_SILVERMONT1:
-        case INTEL_FAM6_ATOM_SILVERMONT2:
+        case INTEL_FAM6_ATOM_SILVERMONT:
+        case INTEL_FAM6_ATOM_SILVERMONT_X:
+        case INTEL_FAM6_ATOM_SILVERMONT_MID:
         case INTEL_FAM6_ATOM_AIRMONT:
+        case INTEL_FAM6_ATOM_AIRMONT_MID:
                 memcpy(hw_cache_event_ids, slm_hw_cache_event_ids,
                         sizeof(hw_cache_event_ids));
                 memcpy(hw_cache_extra_regs, slm_hw_cache_extra_regs,
@@ -4042,7 +4219,7 @@ __init int intel_pmu_init(void)
                 break;
 
         case INTEL_FAM6_ATOM_GOLDMONT:
-        case INTEL_FAM6_ATOM_DENVERTON:
+        case INTEL_FAM6_ATOM_GOLDMONT_X:
                 memcpy(hw_cache_event_ids, glm_hw_cache_event_ids,
                        sizeof(hw_cache_event_ids));
                 memcpy(hw_cache_extra_regs, glm_hw_cache_extra_regs,
@@ -4068,7 +4245,8 @@ __init int intel_pmu_init(void)
                 name = "goldmont";
                 break;
 
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
+                x86_add_quirk(intel_glp_counter_freezing_quirk);
                 memcpy(hw_cache_event_ids, glp_hw_cache_event_ids,
                        sizeof(hw_cache_event_ids));
                 memcpy(hw_cache_extra_regs, glp_hw_cache_extra_regs,
@@ -4112,7 +4290,7 @@ __init int intel_pmu_init(void)
                 x86_pmu.extra_regs = intel_westmere_extra_regs;
                 x86_pmu.flags |= PMU_FL_HAS_RSP_1;
 
-                x86_pmu.cpu_events = nhm_events_attrs;
+                mem_attr = nhm_mem_events_attrs;
 
                 /* UOPS_ISSUED.STALLED_CYCLES */
                 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =
@@ -4152,6 +4330,7 @@ __init int intel_pmu_init(void)
                 x86_pmu.flags |= PMU_FL_NO_HT_SHARING;
 
                 x86_pmu.cpu_events = snb_events_attrs;
+                mem_attr = snb_mem_events_attrs;
 
                 /* UOPS_ISSUED.ANY,c=1,i=1 to count stall cycles */
                 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =
@@ -4192,6 +4371,7 @@ __init int intel_pmu_init(void)
                 x86_pmu.flags |= PMU_FL_NO_HT_SHARING;
 
                 x86_pmu.cpu_events = snb_events_attrs;
+                mem_attr = snb_mem_events_attrs;
 
                 /* UOPS_ISSUED.ANY,c=1,i=1 to count stall cycles */
                 intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] =
@@ -4226,10 +4406,12 @@ __init int intel_pmu_init(void)
 
                 x86_pmu.hw_config = hsw_hw_config;
                 x86_pmu.get_event_constraints = hsw_get_event_constraints;
-                x86_pmu.cpu_events = get_hsw_events_attrs();
+                x86_pmu.cpu_events = hsw_events_attrs;
                 x86_pmu.lbr_double_abort = true;
                 extra_attr = boot_cpu_has(X86_FEATURE_RTM) ?
                         hsw_format_attr : nhm_format_attr;
+                mem_attr = hsw_mem_events_attrs;
+                tsx_attr = hsw_tsx_events_attrs;
                 pr_cont("Haswell events, ");
                 name = "haswell";
                 break;
@@ -4265,10 +4447,12 @@ __init int intel_pmu_init(void)
 
                 x86_pmu.hw_config = hsw_hw_config;
                 x86_pmu.get_event_constraints = hsw_get_event_constraints;
-                x86_pmu.cpu_events = get_hsw_events_attrs();
+                x86_pmu.cpu_events = hsw_events_attrs;
                 x86_pmu.limit_period = bdw_limit_period;
                 extra_attr = boot_cpu_has(X86_FEATURE_RTM) ?
                         hsw_format_attr : nhm_format_attr;
+                mem_attr = hsw_mem_events_attrs;
+                tsx_attr = hsw_tsx_events_attrs;
                 pr_cont("Broadwell events, ");
                 name = "broadwell";
                 break;
@@ -4324,7 +4508,9 @@ __init int intel_pmu_init(void)
                         hsw_format_attr : nhm_format_attr;
                 extra_attr = merge_attr(extra_attr, skl_format_attr);
                 to_free = extra_attr;
-                x86_pmu.cpu_events = get_hsw_events_attrs();
+                x86_pmu.cpu_events = hsw_events_attrs;
+                mem_attr = hsw_mem_events_attrs;
+                tsx_attr = hsw_tsx_events_attrs;
                 intel_pmu_pebs_data_source_skl(
                         boot_cpu_data.x86_model == INTEL_FAM6_SKYLAKE_X);
                 pr_cont("Skylake events, ");
@@ -4357,6 +4543,9 @@ __init int intel_pmu_init(void)
                 WARN_ON(!x86_pmu.format_attrs);
         }
 
+        x86_pmu.cpu_events = get_events_attrs(x86_pmu.cpu_events,
+                                              mem_attr, tsx_attr);
+
         if (x86_pmu.num_counters > INTEL_PMC_MAX_GENERIC) {
                 WARN(1, KERN_ERR "hw perf events %d > max(%d), clipping!",
                      x86_pmu.num_counters, INTEL_PMC_MAX_GENERIC);
@@ -4431,6 +4620,13 @@ __init int intel_pmu_init(void)
                 pr_cont("full-width counters, ");
         }
 
+        /*
+         * For arch perfmon 4 use counter freezing to avoid
+         * several MSR accesses in the PMI.
+         */
+        if (x86_pmu.counter_freezing)
+                x86_pmu.handle_irq = intel_pmu_handle_irq_v4;
+
         kfree(to_free);
         return 0;
 }
diff --git a/arch/x86/events/intel/cstate.c b/arch/x86/events/intel/cstate.c
index 9f8084f18d58..d2e780705c5a 100644
--- a/arch/x86/events/intel/cstate.c
+++ b/arch/x86/events/intel/cstate.c
@@ -559,8 +559,8 @@ static const struct x86_cpu_id intel_cstates_match[] __initconst = {
 
         X86_CSTATES_MODEL(INTEL_FAM6_HASWELL_ULT, hswult_cstates),
 
-        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_SILVERMONT1, slm_cstates),
-        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_SILVERMONT2, slm_cstates),
+        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_SILVERMONT, slm_cstates),
+        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_SILVERMONT_X, slm_cstates),
         X86_CSTATES_MODEL(INTEL_FAM6_ATOM_AIRMONT,     slm_cstates),
 
         X86_CSTATES_MODEL(INTEL_FAM6_BROADWELL_CORE,   snb_cstates),
@@ -581,9 +581,9 @@ static const struct x86_cpu_id intel_cstates_match[] __initconst = {
         X86_CSTATES_MODEL(INTEL_FAM6_XEON_PHI_KNM, knl_cstates),
 
         X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT, glm_cstates),
-        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_DENVERTON, glm_cstates),
+        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT_X, glm_cstates),
 
-        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GEMINI_LAKE, glm_cstates),
+        X86_CSTATES_MODEL(INTEL_FAM6_ATOM_GOLDMONT_PLUS, glm_cstates),
         { },
 };
 MODULE_DEVICE_TABLE(x86cpu, intel_cstates_match);
diff --git a/arch/x86/events/intel/pt.c b/arch/x86/events/intel/pt.c
index 8d016ce5b80d..3a0aa83cbd07 100644
--- a/arch/x86/events/intel/pt.c
+++ b/arch/x86/events/intel/pt.c
@@ -95,7 +95,7 @@ static ssize_t pt_cap_show(struct device *cdev,
         return snprintf(buf, PAGE_SIZE, "%x\n", pt_cap_get(cap));
 }
 
-static struct attribute_group pt_cap_group = {
+static struct attribute_group pt_cap_group __ro_after_init = {
         .name   = "caps",
 };
 
diff --git a/arch/x86/events/intel/rapl.c b/arch/x86/events/intel/rapl.c
index 32f3e9423e99..91039ffed633 100644
--- a/arch/x86/events/intel/rapl.c
+++ b/arch/x86/events/intel/rapl.c
@@ -777,9 +777,9 @@ static const struct x86_cpu_id rapl_cpu_match[] __initconst = {
         X86_RAPL_MODEL_MATCH(INTEL_FAM6_CANNONLAKE_MOBILE,  skl_rapl_init),
 
         X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_GOLDMONT, hsw_rapl_init),
-        X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_DENVERTON, hsw_rapl_init),
+        X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_GOLDMONT_X, hsw_rapl_init),
 
-        X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_GEMINI_LAKE, hsw_rapl_init),
+        X86_RAPL_MODEL_MATCH(INTEL_FAM6_ATOM_GOLDMONT_PLUS, hsw_rapl_init),
         {},
 };
 
diff --git a/arch/x86/events/msr.c b/arch/x86/events/msr.c
index b4771a6ddbc1..1b9f85abf9bc 100644
--- a/arch/x86/events/msr.c
+++ b/arch/x86/events/msr.c
@@ -69,14 +69,14 @@ static bool test_intel(int idx)
         case INTEL_FAM6_BROADWELL_GT3E:
         case INTEL_FAM6_BROADWELL_X:
 
-        case INTEL_FAM6_ATOM_SILVERMONT1:
-        case INTEL_FAM6_ATOM_SILVERMONT2:
+        case INTEL_FAM6_ATOM_SILVERMONT:
+        case INTEL_FAM6_ATOM_SILVERMONT_X:
         case INTEL_FAM6_ATOM_AIRMONT:
 
         case INTEL_FAM6_ATOM_GOLDMONT:
-        case INTEL_FAM6_ATOM_DENVERTON:
+        case INTEL_FAM6_ATOM_GOLDMONT_X:
 
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
 
         case INTEL_FAM6_XEON_PHI_KNL:
         case INTEL_FAM6_XEON_PHI_KNM:
diff --git a/arch/x86/events/perf_event.h b/arch/x86/events/perf_event.h
index 156286335351..adae087cecdd 100644
--- a/arch/x86/events/perf_event.h
+++ b/arch/x86/events/perf_event.h
@@ -560,9 +560,11 @@ struct x86_pmu {
         struct event_constraint *event_constraints;
         struct x86_pmu_quirk *quirks;
         int             perfctr_second_write;
-        bool            late_ack;
         u64             (*limit_period)(struct perf_event *event, u64 l);
 
+        /* PMI handler bits */
+        unsigned int    late_ack                :1,
+                        counter_freezing        :1;
         /*
          * sysfs attrs
          */
diff --git a/arch/x86/include/asm/intel-family.h b/arch/x86/include/asm/intel-family.h
index 7ed08a7c3398..0dd6b0f4000e 100644
--- a/arch/x86/include/asm/intel-family.h
+++ b/arch/x86/include/asm/intel-family.h
@@ -8,9 +8,6 @@
  * The "_X" parts are generally the EP and EX Xeons, or the
  * "Extreme" ones, like Broadwell-E.
  *
- * Things ending in "2" are usually because we have no better
- * name for them.  There's no processor called "SILVERMONT2".
- *
  * While adding a new CPUID for a new microarchitecture, add a new
  * group to keep logically sorted out in chronological order. Within
  * that group keep the CPUID for the variants sorted by model number.
@@ -57,19 +54,23 @@
 
 /* "Small Core" Processors (Atom) */
 
-#define INTEL_FAM6_ATOM_PINEVIEW        0x1C
-#define INTEL_FAM6_ATOM_LINCROFT        0x26
-#define INTEL_FAM6_ATOM_PENWELL         0x27
-#define INTEL_FAM6_ATOM_CLOVERVIEW      0x35
-#define INTEL_FAM6_ATOM_CEDARVIEW       0x36
-#define INTEL_FAM6_ATOM_SILVERMONT1     0x37 /* BayTrail/BYT / Valleyview */
-#define INTEL_FAM6_ATOM_SILVERMONT2     0x4D /* Avaton/Rangely */
-#define INTEL_FAM6_ATOM_AIRMONT         0x4C /* CherryTrail / Braswell */
-#define INTEL_FAM6_ATOM_MERRIFIELD      0x4A /* Tangier */
-#define INTEL_FAM6_ATOM_MOOREFIELD      0x5A /* Anniedale */
-#define INTEL_FAM6_ATOM_GOLDMONT        0x5C
-#define INTEL_FAM6_ATOM_DENVERTON       0x5F /* Goldmont Microserver */
-#define INTEL_FAM6_ATOM_GEMINI_LAKE     0x7A
+#define INTEL_FAM6_ATOM_BONNELL         0x1C /* Diamondville, Pineview */
+#define INTEL_FAM6_ATOM_BONNELL_MID     0x26 /* Silverthorne, Lincroft */
+
+#define INTEL_FAM6_ATOM_SALTWELL        0x36 /* Cedarview */
+#define INTEL_FAM6_ATOM_SALTWELL_MID    0x27 /* Penwell */
+#define INTEL_FAM6_ATOM_SALTWELL_TABLET 0x35 /* Cloverview */
+
+#define INTEL_FAM6_ATOM_SILVERMONT      0x37 /* Bay Trail, Valleyview */
+#define INTEL_FAM6_ATOM_SILVERMONT_X    0x4D /* Avaton, Rangely */
+#define INTEL_FAM6_ATOM_SILVERMONT_MID  0x4A /* Merriefield */
+
+#define INTEL_FAM6_ATOM_AIRMONT         0x4C /* Cherry Trail, Braswell */
+#define INTEL_FAM6_ATOM_AIRMONT_MID     0x5A /* Moorefield */
+
+#define INTEL_FAM6_ATOM_GOLDMONT        0x5C /* Apollo Lake */
+#define INTEL_FAM6_ATOM_GOLDMONT_X      0x5F /* Denverton */
+#define INTEL_FAM6_ATOM_GOLDMONT_PLUS   0x7A /* Gemini Lake */
 
 /* Xeon Phi */
 
diff --git a/arch/x86/include/asm/msr-index.h b/arch/x86/include/asm/msr-index.h
index 4731f0cf97c5..80f4a4f38c79 100644
--- a/arch/x86/include/asm/msr-index.h
+++ b/arch/x86/include/asm/msr-index.h
@@ -164,6 +164,7 @@
 #define DEBUGCTLMSR_BTS_OFF_OS          (1UL <<  9)
 #define DEBUGCTLMSR_BTS_OFF_USR         (1UL << 10)
 #define DEBUGCTLMSR_FREEZE_LBRS_ON_PMI  (1UL << 11)
+#define DEBUGCTLMSR_FREEZE_PERFMON_ON_PMI       (1UL << 12)
 #define DEBUGCTLMSR_FREEZE_IN_SMM_BIT   14
 #define DEBUGCTLMSR_FREEZE_IN_SMM       (1UL << DEBUGCTLMSR_FREEZE_IN_SMM_BIT)
 
diff --git a/arch/x86/include/asm/perf_event.h b/arch/x86/include/asm/perf_event.h
index 78241b736f2a..8bdf74902293 100644
--- a/arch/x86/include/asm/perf_event.h
+++ b/arch/x86/include/asm/perf_event.h
@@ -278,6 +278,7 @@ struct perf_guest_switch_msr {
 extern struct perf_guest_switch_msr *perf_guest_get_msrs(int *nr);
 extern void perf_get_x86_pmu_capability(struct x86_pmu_capability *cap);
 extern void perf_check_microcode(void);
+extern int x86_perf_rdpmc_index(struct perf_event *event);
 #else
 static inline struct perf_guest_switch_msr *perf_guest_get_msrs(int *nr)
 {
diff --git a/arch/x86/include/asm/ptrace.h b/arch/x86/include/asm/ptrace.h
index 5e58a74bfd3a..25f49af1b13c 100644
--- a/arch/x86/include/asm/ptrace.h
+++ b/arch/x86/include/asm/ptrace.h
@@ -239,23 +239,51 @@ static inline int regs_within_kernel_stack(struct pt_regs *regs,
 }
 
 /**
+ * regs_get_kernel_stack_nth_addr() - get the address of the Nth entry on stack
+ * @regs:       pt_regs which contains kernel stack pointer.
+ * @n:          stack entry number.
+ *
+ * regs_get_kernel_stack_nth() returns the address of the @n th entry of the
+ * kernel stack which is specified by @regs. If the @n th entry is NOT in
+ * the kernel stack, this returns NULL.
+ */
+static inline unsigned long *regs_get_kernel_stack_nth_addr(struct pt_regs *regs, unsigned int n)
+{
+        unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
+
+        addr += n;
+        if (regs_within_kernel_stack(regs, (unsigned long)addr))
+                return addr;
+        else
+                return NULL;
+}
+
+/* To avoid include hell, we can't include uaccess.h */
+extern long probe_kernel_read(void *dst, const void *src, size_t size);
+
+/**
  * regs_get_kernel_stack_nth() - get Nth entry of the stack
  * @regs:       pt_regs which contains kernel stack pointer.
  * @n:          stack entry number.
  *
  * regs_get_kernel_stack_nth() returns @n th entry of the kernel stack which
- * is specified by @regs. If the @n th entry is NOT in the kernel stack,
+ * is specified by @regs. If the @n th entry is NOT in the kernel stack
  * this returns 0.
  */
 static inline unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
                                                       unsigned int n)
 {
-        unsigned long *addr = (unsigned long *)kernel_stack_pointer(regs);
-        addr += n;
-        if (regs_within_kernel_stack(regs, (unsigned long)addr))
-                return *addr;
-        else
-                return 0;
+        unsigned long *addr;
+        unsigned long val;
+        long ret;
+
+        addr = regs_get_kernel_stack_nth_addr(regs, n);
+        if (addr) {
+                ret = probe_kernel_read(&val, addr, sizeof(val));
+                if (!ret)
+                        return val;
+        }
+        return 0;
 }
 
 #define arch_has_single_step()  (1)
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index 44c4ef3d989b..10e5ccfa9278 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -949,11 +949,11 @@ static void identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
 }
 
 static const __initconst struct x86_cpu_id cpu_no_speculation[] = {
-        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_CEDARVIEW,   X86_FEATURE_ANY },
-        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_CLOVERVIEW,  X86_FEATURE_ANY },
-        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_LINCROFT,    X86_FEATURE_ANY },
-        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_PENWELL,     X86_FEATURE_ANY },
-        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_PINEVIEW,    X86_FEATURE_ANY },
+        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_SALTWELL,    X86_FEATURE_ANY },
+        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_SALTWELL_TABLET,     X86_FEATURE_ANY },
+        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_BONNELL_MID, X86_FEATURE_ANY },
+        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_SALTWELL_MID,        X86_FEATURE_ANY },
+        { X86_VENDOR_INTEL,     6, INTEL_FAM6_ATOM_BONNELL,     X86_FEATURE_ANY },
         { X86_VENDOR_CENTAUR,   5 },
         { X86_VENDOR_INTEL,     5 },
         { X86_VENDOR_NSC,       5 },
@@ -968,10 +968,10 @@ static const __initconst struct x86_cpu_id cpu_no_meltdown[] = {
 
 /* Only list CPUs which speculate but are non susceptible to SSB */
 static const __initconst struct x86_cpu_id cpu_no_spec_store_bypass[] = {
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT1     },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT      },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_AIRMONT         },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT2     },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_MERRIFIELD      },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT_X    },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT_MID  },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_CORE_YONAH           },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_XEON_PHI_KNL         },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_XEON_PHI_KNM         },
@@ -984,14 +984,14 @@ static const __initconst struct x86_cpu_id cpu_no_spec_store_bypass[] = {
 
 static const __initconst struct x86_cpu_id cpu_no_l1tf[] = {
         /* in addition to cpu_no_speculation */
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT1     },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT2     },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT      },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT_X    },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_AIRMONT         },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_MERRIFIELD      },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_MOOREFIELD      },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_SILVERMONT_MID  },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_AIRMONT_MID     },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_GOLDMONT        },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_DENVERTON       },
-        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_GEMINI_LAKE     },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_GOLDMONT_X      },
+        { X86_VENDOR_INTEL,     6,      INTEL_FAM6_ATOM_GOLDMONT_PLUS   },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_XEON_PHI_KNL         },
         { X86_VENDOR_INTEL,     6,      INTEL_FAM6_XEON_PHI_KNM         },
         {}
diff --git a/arch/x86/kernel/cpu/intel_rdt.c b/arch/x86/kernel/cpu/intel_rdt.c
index abb71ac70443..44272b7107ad 100644
--- a/arch/x86/kernel/cpu/intel_rdt.c
+++ b/arch/x86/kernel/cpu/intel_rdt.c
@@ -485,9 +485,7 @@ static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d)
         size_t tsize;
 
         if (is_llc_occupancy_enabled()) {
-                d->rmid_busy_llc = kcalloc(BITS_TO_LONGS(r->num_rmid),
-                                           sizeof(unsigned long),
-                                           GFP_KERNEL);
+                d->rmid_busy_llc = bitmap_zalloc(r->num_rmid, GFP_KERNEL);
                 if (!d->rmid_busy_llc)
                         return -ENOMEM;
                 INIT_DELAYED_WORK(&d->cqm_limbo, cqm_handle_limbo);
@@ -496,7 +494,7 @@ static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d)
                 tsize = sizeof(*d->mbm_total);
                 d->mbm_total = kcalloc(r->num_rmid, tsize, GFP_KERNEL);
                 if (!d->mbm_total) {
-                        kfree(d->rmid_busy_llc);
+                        bitmap_free(d->rmid_busy_llc);
                         return -ENOMEM;
                 }
         }
@@ -504,7 +502,7 @@ static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d)
                 tsize = sizeof(*d->mbm_local);
                 d->mbm_local = kcalloc(r->num_rmid, tsize, GFP_KERNEL);
                 if (!d->mbm_local) {
-                        kfree(d->rmid_busy_llc);
+                        bitmap_free(d->rmid_busy_llc);
                         kfree(d->mbm_total);
                         return -ENOMEM;
                 }
@@ -610,9 +608,16 @@ static void domain_remove_cpu(int cpu, struct rdt_resource *r)
                         cancel_delayed_work(&d->cqm_limbo);
                 }
 
+                /*
+                 * rdt_domain "d" is going to be freed below, so clear
+                 * its pointer from pseudo_lock_region struct.
+                 */
+                if (d->plr)
+                        d->plr->d = NULL;
+
                 kfree(d->ctrl_val);
                 kfree(d->mbps_val);
-                kfree(d->rmid_busy_llc);
+                bitmap_free(d->rmid_busy_llc);
                 kfree(d->mbm_total);
                 kfree(d->mbm_local);
                 kfree(d);
diff --git a/arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c b/arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c
index 0f53049719cd..27937458c231 100644
--- a/arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c
+++ b/arch/x86/kernel/cpu/intel_rdt_ctrlmondata.c
@@ -404,8 +404,16 @@ int rdtgroup_schemata_show(struct kernfs_open_file *of,
                         for_each_alloc_enabled_rdt_resource(r)
                                 seq_printf(s, "%s:uninitialized\n", r->name);
                 } else if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
-                        seq_printf(s, "%s:%d=%x\n", rdtgrp->plr->r->name,
-                                   rdtgrp->plr->d->id, rdtgrp->plr->cbm);
+                        if (!rdtgrp->plr->d) {
+                                rdt_last_cmd_clear();
+                                rdt_last_cmd_puts("Cache domain offline\n");
+                                ret = -ENODEV;
+                        } else {
+                                seq_printf(s, "%s:%d=%x\n",
+                                           rdtgrp->plr->r->name,
+                                           rdtgrp->plr->d->id,
+                                           rdtgrp->plr->cbm);
+                        }
                 } else {
                         closid = rdtgrp->closid;
                         for_each_alloc_enabled_rdt_resource(r) {
diff --git a/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c b/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c
index f8c260d522ca..815b4e92522c 100644
--- a/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c
+++ b/arch/x86/kernel/cpu/intel_rdt_pseudo_lock.c
@@ -17,6 +17,7 @@
 #include <linux/debugfs.h>
 #include <linux/kthread.h>
 #include <linux/mman.h>
+#include <linux/perf_event.h>
 #include <linux/pm_qos.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
@@ -26,6 +27,7 @@
 #include <asm/intel_rdt_sched.h>
 #include <asm/perf_event.h>
 
+#include "../../events/perf_event.h" /* For X86_CONFIG() */
 #include "intel_rdt.h"
 
 #define CREATE_TRACE_POINTS
@@ -91,7 +93,7 @@ static u64 get_prefetch_disable_bits(void)
                  */
                 return 0xF;
         case INTEL_FAM6_ATOM_GOLDMONT:
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
                 /*
                  * SDM defines bits of MSR_MISC_FEATURE_CONTROL register
                  * as:
@@ -106,16 +108,6 @@ static u64 get_prefetch_disable_bits(void)
         return 0;
 }
 
-/*
- * Helper to write 64bit value to MSR without tracing. Used when
- * use of the cache should be restricted and use of registers used
- * for local variables avoided.
- */
-static inline void pseudo_wrmsrl_notrace(unsigned int msr, u64 val)
-{
-        __wrmsr(msr, (u32)(val & 0xffffffffULL), (u32)(val >> 32));
-}
-
 /**
  * pseudo_lock_minor_get - Obtain available minor number
  * @minor: Pointer to where new minor number will be stored
@@ -888,31 +880,14 @@ static int measure_cycles_lat_fn(void *_plr)
         struct pseudo_lock_region *plr = _plr;
         unsigned long i;
         u64 start, end;
-#ifdef CONFIG_KASAN
-        /*
-         * The registers used for local register variables are also used
-         * when KASAN is active. When KASAN is active we use a regular
-         * variable to ensure we always use a valid pointer to access memory.
-         * The cost is that accessing this pointer, which could be in
-         * cache, will be included in the measurement of memory read latency.
-         */
         void *mem_r;
-#else
-#ifdef CONFIG_X86_64
-        register void *mem_r asm("rbx");
-#else
-        register void *mem_r asm("ebx");
-#endif /* CONFIG_X86_64 */
-#endif /* CONFIG_KASAN */
 
         local_irq_disable();
         /*
-         * The wrmsr call may be reordered with the assignment below it.
-         * Call wrmsr as directly as possible to avoid tracing clobbering
-         * local register variable used for memory pointer.
+         * Disable hardware prefetchers.
          */
-        __wrmsr(MSR_MISC_FEATURE_CONTROL, prefetch_disable_bits, 0x0);
-        mem_r = plr->kmem;
+        wrmsr(MSR_MISC_FEATURE_CONTROL, prefetch_disable_bits, 0x0);
+        mem_r = READ_ONCE(plr->kmem);
         /*
          * Dummy execute of the time measurement to load the needed
          * instructions into the L1 instruction cache.
@@ -934,157 +909,240 @@ static int measure_cycles_lat_fn(void *_plr)
         return 0;
 }
 
-static int measure_cycles_perf_fn(void *_plr)
+/*
+ * Create a perf_event_attr for the hit and miss perf events that will
+ * be used during the performance measurement. A perf_event maintains
+ * a pointer to its perf_event_attr so a unique attribute structure is
+ * created for each perf_event.
+ *
+ * The actual configuration of the event is set right before use in order
+ * to use the X86_CONFIG macro.
+ */
+static struct perf_event_attr perf_miss_attr = {
+        .type           = PERF_TYPE_RAW,
+        .size           = sizeof(struct perf_event_attr),
+        .pinned         = 1,
+        .disabled       = 0,
+        .exclude_user   = 1,
+};
+
+static struct perf_event_attr perf_hit_attr = {
+        .type           = PERF_TYPE_RAW,
+        .size           = sizeof(struct perf_event_attr),
+        .pinned         = 1,
+        .disabled       = 0,
+        .exclude_user   = 1,
+};
+
+struct residency_counts {
+        u64 miss_before, hits_before;
+        u64 miss_after,  hits_after;
+};
+
+static int measure_residency_fn(struct perf_event_attr *miss_attr,
+                                struct perf_event_attr *hit_attr,
+                                struct pseudo_lock_region *plr,
+                                struct residency_counts *counts)
 {
-        unsigned long long l3_hits = 0, l3_miss = 0;
-        u64 l3_hit_bits = 0, l3_miss_bits = 0;
-        struct pseudo_lock_region *plr = _plr;
-        unsigned long long l2_hits, l2_miss;
-        u64 l2_hit_bits, l2_miss_bits;
-        unsigned long i;
-#ifdef CONFIG_KASAN
-        /*
-         * The registers used for local register variables are also used
-         * when KASAN is active. When KASAN is active we use regular variables
-         * at the cost of including cache access latency to these variables
-         * in the measurements.
-         */
+        u64 hits_before = 0, hits_after = 0, miss_before = 0, miss_after = 0;
+        struct perf_event *miss_event, *hit_event;
+        int hit_pmcnum, miss_pmcnum;
         unsigned int line_size;
         unsigned int size;
+        unsigned long i;
         void *mem_r;
-#else
-        register unsigned int line_size asm("esi");
-        register unsigned int size asm("edi");
-#ifdef CONFIG_X86_64
-        register void *mem_r asm("rbx");
-#else
-        register void *mem_r asm("ebx");
-#endif /* CONFIG_X86_64 */
-#endif /* CONFIG_KASAN */
+        u64 tmp;
+
+        miss_event = perf_event_create_kernel_counter(miss_attr, plr->cpu,
+                                                      NULL, NULL, NULL);
+        if (IS_ERR(miss_event))
+                goto out;
+
+        hit_event = perf_event_create_kernel_counter(hit_attr, plr->cpu,
+                                                     NULL, NULL, NULL);
+        if (IS_ERR(hit_event))
+                goto out_miss;
+
+        local_irq_disable();
+        /*
+         * Check any possible error state of events used by performing
+         * one local read.
+         */
+        if (perf_event_read_local(miss_event, &tmp, NULL, NULL)) {
+                local_irq_enable();
+                goto out_hit;
+        }
+        if (perf_event_read_local(hit_event, &tmp, NULL, NULL)) {
+                local_irq_enable();
+                goto out_hit;
+        }
+
+        /*
+         * Disable hardware prefetchers.
+         */
+        wrmsr(MSR_MISC_FEATURE_CONTROL, prefetch_disable_bits, 0x0);
+
+        /* Initialize rest of local variables */
+        /*
+         * Performance event has been validated right before this with
+         * interrupts disabled - it is thus safe to read the counter index.
+         */
+        miss_pmcnum = x86_perf_rdpmc_index(miss_event);
+        hit_pmcnum = x86_perf_rdpmc_index(hit_event);
+        line_size = READ_ONCE(plr->line_size);
+        mem_r = READ_ONCE(plr->kmem);
+        size = READ_ONCE(plr->size);
+
+        /*
+         * Read counter variables twice - first to load the instructions
+         * used in L1 cache, second to capture accurate value that does not
+         * include cache misses incurred because of instruction loads.
+         */
+        rdpmcl(hit_pmcnum, hits_before);
+        rdpmcl(miss_pmcnum, miss_before);
+        /*
+         * From SDM: Performing back-to-back fast reads are not guaranteed
+         * to be monotonic.
+         * Use LFENCE to ensure all previous instructions are retired
+         * before proceeding.
+         */
+        rmb();
+        rdpmcl(hit_pmcnum, hits_before);
+        rdpmcl(miss_pmcnum, miss_before);
+        /*
+         * Use LFENCE to ensure all previous instructions are retired
+         * before proceeding.
+         */
+        rmb();
+        for (i = 0; i < size; i += line_size) {
+                /*
+                 * Add a barrier to prevent speculative execution of this
+                 * loop reading beyond the end of the buffer.
+                 */
+                rmb();
+                asm volatile("mov (%0,%1,1), %%eax\n\t"
+                             :
+                             : "r" (mem_r), "r" (i)
+                             : "%eax", "memory");
+        }
+        /*
+         * Use LFENCE to ensure all previous instructions are retired
+         * before proceeding.
+         */
+        rmb();
+        rdpmcl(hit_pmcnum, hits_after);
+        rdpmcl(miss_pmcnum, miss_after);
+        /*
+         * Use LFENCE to ensure all previous instructions are retired
+         * before proceeding.
+         */
+        rmb();
+        /* Re-enable hardware prefetchers */
+        wrmsr(MSR_MISC_FEATURE_CONTROL, 0x0, 0x0);
+        local_irq_enable();
+out_hit:
+        perf_event_release_kernel(hit_event);
+out_miss:
+        perf_event_release_kernel(miss_event);
+out:
+        /*
+         * All counts will be zero on failure.
+         */
+        counts->miss_before = miss_before;
+        counts->hits_before = hits_before;
+        counts->miss_after  = miss_after;
+        counts->hits_after  = hits_after;
+        return 0;
+}
+
+static int measure_l2_residency(void *_plr)
+{
+        struct pseudo_lock_region *plr = _plr;
+        struct residency_counts counts = {0};
 
         /*
          * Non-architectural event for the Goldmont Microarchitecture
          * from Intel x86 Architecture Software Developer Manual (SDM):
          * MEM_LOAD_UOPS_RETIRED D1H (event number)
          * Umask values:
-         *     L1_HIT   01H
          *     L2_HIT   02H
-         *     L1_MISS  08H
          *     L2_MISS  10H
-         *
-         * On Broadwell Microarchitecture the MEM_LOAD_UOPS_RETIRED event
-         * has two "no fix" errata associated with it: BDM35 and BDM100. On
-         * this platform we use the following events instead:
-         *  L2_RQSTS 24H (Documented in https://download.01.org/perfmon/BDW/)
-         *       REFERENCES FFH
-         *       MISS       3FH
-         *  LONGEST_LAT_CACHE 2EH (Documented in SDM)
-         *       REFERENCE 4FH
-         *       MISS      41H
          */
-
-        /*
-         * Start by setting flags for IA32_PERFEVTSELx:
-         *     OS  (Operating system mode)  0x2
-         *     INT (APIC interrupt enable)  0x10
-         *     EN  (Enable counter)         0x40
-         *
-         * Then add the Umask value and event number to select performance
-         * event.
-         */
-
         switch (boot_cpu_data.x86_model) {
         case INTEL_FAM6_ATOM_GOLDMONT:
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
-                l2_hit_bits = (0x52ULL << 16) | (0x2 << 8) | 0xd1;
-                l2_miss_bits = (0x52ULL << 16) | (0x10 << 8) | 0xd1;
-                break;
-        case INTEL_FAM6_BROADWELL_X:
-                /* On BDW the l2_hit_bits count references, not hits */
-                l2_hit_bits = (0x52ULL << 16) | (0xff << 8) | 0x24;
-                l2_miss_bits = (0x52ULL << 16) | (0x3f << 8) | 0x24;
-                /* On BDW the l3_hit_bits count references, not hits */
-                l3_hit_bits = (0x52ULL << 16) | (0x4f << 8) | 0x2e;
-                l3_miss_bits = (0x52ULL << 16) | (0x41 << 8) | 0x2e;
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
+                perf_miss_attr.config = X86_CONFIG(.event = 0xd1,
+                                                   .umask = 0x10);
+                perf_hit_attr.config = X86_CONFIG(.event = 0xd1,
+                                                  .umask = 0x2);
                 break;
         default:
                 goto out;
         }
 
-        local_irq_disable();
+        measure_residency_fn(&perf_miss_attr, &perf_hit_attr, plr, &counts);
         /*
-         * Call wrmsr direcly to avoid the local register variables from
-         * being overwritten due to reordering of their assignment with
-         * the wrmsr calls.
+         * If a failure prevented the measurements from succeeding
+         * tracepoints will still be written and all counts will be zero.
          */
-        __wrmsr(MSR_MISC_FEATURE_CONTROL, prefetch_disable_bits, 0x0);
-        /* Disable events and reset counters */
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0, 0x0);
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x0);
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_PERFCTR0, 0x0);
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_PERFCTR0 + 1, 0x0);
-        if (l3_hit_bits > 0) {
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x0);
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 3, 0x0);
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_PERFCTR0 + 2, 0x0);
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_PERFCTR0 + 3, 0x0);
-        }
-        /* Set and enable the L2 counters */
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0, l2_hit_bits);
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 1, l2_miss_bits);
-        if (l3_hit_bits > 0) {
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 2,
-                                      l3_hit_bits);
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 3,
-                                      l3_miss_bits);
-        }
-        mem_r = plr->kmem;
-        size = plr->size;
-        line_size = plr->line_size;
-        for (i = 0; i < size; i += line_size) {
-                asm volatile("mov (%0,%1,1), %%eax\n\t"
-                             :
-                             : "r" (mem_r), "r" (i)
-                             : "%eax", "memory");
-        }
+        trace_pseudo_lock_l2(counts.hits_after - counts.hits_before,
+                             counts.miss_after - counts.miss_before);
+out:
+        plr->thread_done = 1;
+        wake_up_interruptible(&plr->lock_thread_wq);
+        return 0;
+}
+
+static int measure_l3_residency(void *_plr)
+{
+        struct pseudo_lock_region *plr = _plr;
+        struct residency_counts counts = {0};
+
         /*
-         * Call wrmsr directly (no tracing) to not influence
-         * the cache access counters as they are disabled.
+         * On Broadwell Microarchitecture the MEM_LOAD_UOPS_RETIRED event
+         * has two "no fix" errata associated with it: BDM35 and BDM100. On
+         * this platform the following events are used instead:
+         * LONGEST_LAT_CACHE 2EH (Documented in SDM)
+         *       REFERENCE 4FH
+         *       MISS      41H
          */
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0,
-                              l2_hit_bits & ~(0x40ULL << 16));
-        pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 1,
-                              l2_miss_bits & ~(0x40ULL << 16));
-        if (l3_hit_bits > 0) {
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 2,
-                                      l3_hit_bits & ~(0x40ULL << 16));
-                pseudo_wrmsrl_notrace(MSR_ARCH_PERFMON_EVENTSEL0 + 3,
-                                      l3_miss_bits & ~(0x40ULL << 16));
-        }
-        l2_hits = native_read_pmc(0);
-        l2_miss = native_read_pmc(1);
-        if (l3_hit_bits > 0) {
-                l3_hits = native_read_pmc(2);
-                l3_miss = native_read_pmc(3);
+
+        switch (boot_cpu_data.x86_model) {
+        case INTEL_FAM6_BROADWELL_X:
+                /* On BDW the hit event counts references, not hits */
+                perf_hit_attr.config = X86_CONFIG(.event = 0x2e,
+                                                  .umask = 0x4f);
+                perf_miss_attr.config = X86_CONFIG(.event = 0x2e,
+                                                   .umask = 0x41);
+                break;
+        default:
+                goto out;
         }
-        wrmsr(MSR_MISC_FEATURE_CONTROL, 0x0, 0x0);
-        local_irq_enable();
+
+        measure_residency_fn(&perf_miss_attr, &perf_hit_attr, plr, &counts);
         /*
-         * On BDW we count references and misses, need to adjust. Sometimes
-         * the "hits" counter is a bit more than the references, for
-         * example, x references but x + 1 hits. To not report invalid
-         * hit values in this case we treat that as misses eaqual to
-         * references.
+         * If a failure prevented the measurements from succeeding
+         * tracepoints will still be written and all counts will be zero.
          */
-        if (boot_cpu_data.x86_model == INTEL_FAM6_BROADWELL_X)
-                l2_hits -= (l2_miss > l2_hits ? l2_hits : l2_miss);
-        trace_pseudo_lock_l2(l2_hits, l2_miss);
-        if (l3_hit_bits > 0) {
-                if (boot_cpu_data.x86_model == INTEL_FAM6_BROADWELL_X)
-                        l3_hits -= (l3_miss > l3_hits ? l3_hits : l3_miss);
-                trace_pseudo_lock_l3(l3_hits, l3_miss);
+
+        counts.miss_after -= counts.miss_before;
+        if (boot_cpu_data.x86_model == INTEL_FAM6_BROADWELL_X) {
+                /*
+                 * On BDW references and misses are counted, need to adjust.
+                 * Sometimes the "hits" counter is a bit more than the
+                 * references, for example, x references but x + 1 hits.
+                 * To not report invalid hit values in this case we treat
+                 * that as misses equal to references.
+                 */
+                /* First compute the number of cache references measured */
+                counts.hits_after -= counts.hits_before;
+                /* Next convert references to cache hits */
+                counts.hits_after -= min(counts.miss_after, counts.hits_after);
+        } else {
+                counts.hits_after -= counts.hits_before;
         }
 
+        trace_pseudo_lock_l3(counts.hits_after, counts.miss_after);
 out:
         plr->thread_done = 1;
         wake_up_interruptible(&plr->lock_thread_wq);
@@ -1116,6 +1174,11 @@ static int pseudo_lock_measure_cycles(struct rdtgroup *rdtgrp, int sel)
                 goto out;
         }
 
+        if (!plr->d) {
+                ret = -ENODEV;
+                goto out;
+        }
+
         plr->thread_done = 0;
         cpu = cpumask_first(&plr->d->cpu_mask);
         if (!cpu_online(cpu)) {
@@ -1123,13 +1186,20 @@ static int pseudo_lock_measure_cycles(struct rdtgroup *rdtgrp, int sel)
                 goto out;
         }
 
+        plr->cpu = cpu;
+
         if (sel == 1)
                 thread = kthread_create_on_node(measure_cycles_lat_fn, plr,
                                                 cpu_to_node(cpu),
                                                 "pseudo_lock_measure/%u",
                                                 cpu);
         else if (sel == 2)
-                thread = kthread_create_on_node(measure_cycles_perf_fn, plr,
+                thread = kthread_create_on_node(measure_l2_residency, plr,
+                                                cpu_to_node(cpu),
+                                                "pseudo_lock_measure/%u",
+                                                cpu);
+        else if (sel == 3)
+                thread = kthread_create_on_node(measure_l3_residency, plr,
                                                 cpu_to_node(cpu),
                                                 "pseudo_lock_measure/%u",
                                                 cpu);
@@ -1173,7 +1243,7 @@ static ssize_t pseudo_lock_measure_trigger(struct file *file,
         buf[buf_size] = '\0';
         ret = kstrtoint(buf, 10, &sel);
         if (ret == 0) {
-                if (sel != 1)
+                if (sel != 1 && sel != 2 && sel != 3)
                         return -EINVAL;
                 ret = debugfs_file_get(file->f_path.dentry);
                 if (ret)
@@ -1429,6 +1499,11 @@ static int pseudo_lock_dev_mmap(struct file *filp, struct vm_area_struct *vma)
 
         plr = rdtgrp->plr;
 
+        if (!plr->d) {
+                mutex_unlock(&rdtgroup_mutex);
+                return -ENODEV;
+        }
+
         /*
          * Task is required to run with affinity to the cpus associated
          * with the pseudo-locked region. If this is not the case the task
diff --git a/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c b/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
index b140c68bc14b..f27b8115ffa2 100644
--- a/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
+++ b/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
@@ -268,17 +268,27 @@ static int rdtgroup_cpus_show(struct kernfs_open_file *of,
                               struct seq_file *s, void *v)
 {
         struct rdtgroup *rdtgrp;
+        struct cpumask *mask;
         int ret = 0;
 
         rdtgrp = rdtgroup_kn_lock_live(of->kn);
 
         if (rdtgrp) {
-                if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED)
-                        seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n",
-                                   cpumask_pr_args(&rdtgrp->plr->d->cpu_mask));
-                else
+                if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
+                        if (!rdtgrp->plr->d) {
+                                rdt_last_cmd_clear();
+                                rdt_last_cmd_puts("Cache domain offline\n");
+                                ret = -ENODEV;
+                        } else {
+                                mask = &rdtgrp->plr->d->cpu_mask;
+                                seq_printf(s, is_cpu_list(of) ?
+                                           "%*pbl\n" : "%*pb\n",
+                                           cpumask_pr_args(mask));
+                        }
+                } else {
                         seq_printf(s, is_cpu_list(of) ? "%*pbl\n" : "%*pb\n",
                                    cpumask_pr_args(&rdtgrp->cpu_mask));
+                }
         } else {
                 ret = -ENOENT;
         }
@@ -961,7 +971,78 @@ static int rdtgroup_mode_show(struct kernfs_open_file *of,
 }
 
 /**
- * rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other
+ * rdt_cdp_peer_get - Retrieve CDP peer if it exists
+ * @r: RDT resource to which RDT domain @d belongs
+ * @d: Cache instance for which a CDP peer is requested
+ * @r_cdp: RDT resource that shares hardware with @r (RDT resource peer)
+ *         Used to return the result.
+ * @d_cdp: RDT domain that shares hardware with @d (RDT domain peer)
+ *         Used to return the result.
+ *
+ * RDT resources are managed independently and by extension the RDT domains
+ * (RDT resource instances) are managed independently also. The Code and
+ * Data Prioritization (CDP) RDT resources, while managed independently,
+ * could refer to the same underlying hardware. For example,
+ * RDT_RESOURCE_L2CODE and RDT_RESOURCE_L2DATA both refer to the L2 cache.
+ *
+ * When provided with an RDT resource @r and an instance of that RDT
+ * resource @d rdt_cdp_peer_get() will return if there is a peer RDT
+ * resource and the exact instance that shares the same hardware.
+ *
+ * Return: 0 if a CDP peer was found, <0 on error or if no CDP peer exists.
+ *         If a CDP peer was found, @r_cdp will point to the peer RDT resource
+ *         and @d_cdp will point to the peer RDT domain.
+ */
+static int rdt_cdp_peer_get(struct rdt_resource *r, struct rdt_domain *d,
+                            struct rdt_resource **r_cdp,
+                            struct rdt_domain **d_cdp)
+{
+        struct rdt_resource *_r_cdp = NULL;
+        struct rdt_domain *_d_cdp = NULL;
+        int ret = 0;
+
+        switch (r->rid) {
+        case RDT_RESOURCE_L3DATA:
+                _r_cdp = &rdt_resources_all[RDT_RESOURCE_L3CODE];
+                break;
+        case RDT_RESOURCE_L3CODE:
+                _r_cdp =  &rdt_resources_all[RDT_RESOURCE_L3DATA];
+                break;
+        case RDT_RESOURCE_L2DATA:
+                _r_cdp =  &rdt_resources_all[RDT_RESOURCE_L2CODE];
+                break;
+        case RDT_RESOURCE_L2CODE:
+                _r_cdp =  &rdt_resources_all[RDT_RESOURCE_L2DATA];
+                break;
+        default:
+                ret = -ENOENT;
+                goto out;
+        }
+
+        /*
+         * When a new CPU comes online and CDP is enabled then the new
+         * RDT domains (if any) associated with both CDP RDT resources
+         * are added in the same CPU online routine while the
+         * rdtgroup_mutex is held. It should thus not happen for one
+         * RDT domain to exist and be associated with its RDT CDP
+         * resource but there is no RDT domain associated with the
+         * peer RDT CDP resource. Hence the WARN.
+         */
+        _d_cdp = rdt_find_domain(_r_cdp, d->id, NULL);
+        if (WARN_ON(!_d_cdp)) {
+                _r_cdp = NULL;
+                ret = -EINVAL;
+        }
+
+out:
+        *r_cdp = _r_cdp;
+        *d_cdp = _d_cdp;
+
+        return ret;
+}
+
+/**
+ * __rdtgroup_cbm_overlaps - Does CBM for intended closid overlap with other
  * @r: Resource to which domain instance @d belongs.
  * @d: The domain instance for which @closid is being tested.
  * @cbm: Capacity bitmask being tested.
@@ -980,8 +1061,8 @@ static int rdtgroup_mode_show(struct kernfs_open_file *of,
  *
  * Return: false if CBM does not overlap, true if it does.
  */
-bool rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d,
-                           unsigned long cbm, int closid, bool exclusive)
+static bool __rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d,
+                                    unsigned long cbm, int closid, bool exclusive)
 {
         enum rdtgrp_mode mode;
         unsigned long ctrl_b;
@@ -1017,6 +1098,41 @@ bool rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d,
 }
 
 /**
+ * rdtgroup_cbm_overlaps - Does CBM overlap with other use of hardware
+ * @r: Resource to which domain instance @d belongs.
+ * @d: The domain instance for which @closid is being tested.
+ * @cbm: Capacity bitmask being tested.
+ * @closid: Intended closid for @cbm.
+ * @exclusive: Only check if overlaps with exclusive resource groups
+ *
+ * Resources that can be allocated using a CBM can use the CBM to control
+ * the overlap of these allocations. rdtgroup_cmb_overlaps() is the test
+ * for overlap. Overlap test is not limited to the specific resource for
+ * which the CBM is intended though - when dealing with CDP resources that
+ * share the underlying hardware the overlap check should be performed on
+ * the CDP resource sharing the hardware also.
+ *
+ * Refer to description of __rdtgroup_cbm_overlaps() for the details of the
+ * overlap test.
+ *
+ * Return: true if CBM overlap detected, false if there is no overlap
+ */
+bool rdtgroup_cbm_overlaps(struct rdt_resource *r, struct rdt_domain *d,
+                           unsigned long cbm, int closid, bool exclusive)
+{
+        struct rdt_resource *r_cdp;
+        struct rdt_domain *d_cdp;
+
+        if (__rdtgroup_cbm_overlaps(r, d, cbm, closid, exclusive))
+                return true;
+
+        if (rdt_cdp_peer_get(r, d, &r_cdp, &d_cdp) < 0)
+                return false;
+
+        return  __rdtgroup_cbm_overlaps(r_cdp, d_cdp, cbm, closid, exclusive);
+}
+
+/**
  * rdtgroup_mode_test_exclusive - Test if this resource group can be exclusive
  *
  * An exclusive resource group implies that there should be no sharing of
@@ -1176,6 +1292,7 @@ static int rdtgroup_size_show(struct kernfs_open_file *of,
         struct rdt_resource *r;
         struct rdt_domain *d;
         unsigned int size;
+        int ret = 0;
         bool sep;
         u32 ctrl;
 
@@ -1186,11 +1303,18 @@ static int rdtgroup_size_show(struct kernfs_open_file *of,
         }
 
         if (rdtgrp->mode == RDT_MODE_PSEUDO_LOCKED) {
-                seq_printf(s, "%*s:", max_name_width, rdtgrp->plr->r->name);
-                size = rdtgroup_cbm_to_size(rdtgrp->plr->r,
-                                            rdtgrp->plr->d,
-                                            rdtgrp->plr->cbm);
-                seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size);
+                if (!rdtgrp->plr->d) {
+                        rdt_last_cmd_clear();
+                        rdt_last_cmd_puts("Cache domain offline\n");
+                        ret = -ENODEV;
+                } else {
+                        seq_printf(s, "%*s:", max_name_width,
+                                   rdtgrp->plr->r->name);
+                        size = rdtgroup_cbm_to_size(rdtgrp->plr->r,
+                                                    rdtgrp->plr->d,
+                                                    rdtgrp->plr->cbm);
+                        seq_printf(s, "%d=%u\n", rdtgrp->plr->d->id, size);
+                }
                 goto out;
         }
 
@@ -1220,7 +1344,7 @@ static int rdtgroup_size_show(struct kernfs_open_file *of,
 out:
         rdtgroup_kn_unlock(of->kn);
 
-        return 0;
+        return ret;
 }
 
 /* rdtgroup information files for one cache resource. */
@@ -2354,14 +2478,16 @@ static void cbm_ensure_valid(u32 *_val, struct rdt_resource *r)
  */
 static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp)
 {
+        struct rdt_resource *r_cdp = NULL;
+        struct rdt_domain *d_cdp = NULL;
         u32 used_b = 0, unused_b = 0;
         u32 closid = rdtgrp->closid;
         struct rdt_resource *r;
         unsigned long tmp_cbm;
         enum rdtgrp_mode mode;
         struct rdt_domain *d;
+        u32 peer_ctl, *ctrl;
         int i, ret;
-        u32 *ctrl;
 
         for_each_alloc_enabled_rdt_resource(r) {
                 /*
@@ -2371,6 +2497,7 @@ static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp)
                 if (r->rid == RDT_RESOURCE_MBA)
                         continue;
                 list_for_each_entry(d, &r->domains, list) {
+                        rdt_cdp_peer_get(r, d, &r_cdp, &d_cdp);
                         d->have_new_ctrl = false;
                         d->new_ctrl = r->cache.shareable_bits;
                         used_b = r->cache.shareable_bits;
@@ -2380,9 +2507,19 @@ static int rdtgroup_init_alloc(struct rdtgroup *rdtgrp)
                                         mode = rdtgroup_mode_by_closid(i);
                                         if (mode == RDT_MODE_PSEUDO_LOCKSETUP)
                                                 break;
-                                        used_b |= *ctrl;
+                                        /*
+                                         * If CDP is active include peer
+                                         * domain's usage to ensure there
+                                         * is no overlap with an exclusive
+                                         * group.
+                                         */
+                                        if (d_cdp)
+                                                peer_ctl = d_cdp->ctrl_val[i];
+                                        else
+                                                peer_ctl = 0;
+                                        used_b |= *ctrl | peer_ctl;
                                         if (mode == RDT_MODE_SHAREABLE)
-                                                d->new_ctrl |= *ctrl;
+                                                d->new_ctrl |= *ctrl | peer_ctl;
                                 }
                         }
                         if (d->plr && d->plr->cbm > 0)
@@ -2805,6 +2942,13 @@ static int rdtgroup_show_options(struct seq_file *seq, struct kernfs_root *kf)
 {
         if (rdt_resources_all[RDT_RESOURCE_L3DATA].alloc_enabled)
                 seq_puts(seq, ",cdp");
+
+        if (rdt_resources_all[RDT_RESOURCE_L2DATA].alloc_enabled)
+                seq_puts(seq, ",cdpl2");
+
+        if (is_mba_sc(&rdt_resources_all[RDT_RESOURCE_MBA]))
+                seq_puts(seq, ",mba_MBps");
+
         return 0;
 }
 
diff --git a/arch/x86/kernel/kprobes/opt.c b/arch/x86/kernel/kprobes/opt.c
index eaf02f2e7300..40b16b270656 100644
--- a/arch/x86/kernel/kprobes/opt.c
+++ b/arch/x86/kernel/kprobes/opt.c
@@ -179,7 +179,7 @@ optimized_callback(struct optimized_kprobe *op, struct pt_regs *regs)
                 opt_pre_handler(&op->kp, regs);
                 __this_cpu_write(current_kprobe, NULL);
         }
-        preempt_enable_no_resched();
+        preempt_enable();
 }
 NOKPROBE_SYMBOL(optimized_callback);
 
diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c
index 6d5dc5dabfd7..03b7529333a6 100644
--- a/arch/x86/kernel/tsc.c
+++ b/arch/x86/kernel/tsc.c
@@ -636,7 +636,7 @@ unsigned long native_calibrate_tsc(void)
                 case INTEL_FAM6_KABYLAKE_DESKTOP:
                         crystal_khz = 24000;    /* 24.0 MHz */
                         break;
-                case INTEL_FAM6_ATOM_DENVERTON:
+                case INTEL_FAM6_ATOM_GOLDMONT_X:
                         crystal_khz = 25000;    /* 25.0 MHz */
                         break;
                 case INTEL_FAM6_ATOM_GOLDMONT:
diff --git a/arch/x86/kernel/tsc_msr.c b/arch/x86/kernel/tsc_msr.c
index 27ef714d886c..3d0e9aeea7c8 100644
--- a/arch/x86/kernel/tsc_msr.c
+++ b/arch/x86/kernel/tsc_msr.c
@@ -59,12 +59,12 @@ static const struct freq_desc freq_desc_ann = {
 };
 
 static const struct x86_cpu_id tsc_msr_cpu_ids[] = {
-        INTEL_CPU_FAM6(ATOM_PENWELL,            freq_desc_pnw),
-        INTEL_CPU_FAM6(ATOM_CLOVERVIEW,         freq_desc_clv),
-        INTEL_CPU_FAM6(ATOM_SILVERMONT1,        freq_desc_byt),
+        INTEL_CPU_FAM6(ATOM_SALTWELL_MID,       freq_desc_pnw),
+        INTEL_CPU_FAM6(ATOM_SALTWELL_TABLET,    freq_desc_clv),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT,         freq_desc_byt),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT_MID,     freq_desc_tng),
         INTEL_CPU_FAM6(ATOM_AIRMONT,            freq_desc_cht),
-        INTEL_CPU_FAM6(ATOM_MERRIFIELD,         freq_desc_tng),
-        INTEL_CPU_FAM6(ATOM_MOOREFIELD,         freq_desc_ann),
+        INTEL_CPU_FAM6(ATOM_AIRMONT_MID,        freq_desc_ann),
         {}
 };
 
diff --git a/arch/x86/platform/atom/punit_atom_debug.c b/arch/x86/platform/atom/punit_atom_debug.c
index 034813d4ab1e..6cb6076223ba 100644
--- a/arch/x86/platform/atom/punit_atom_debug.c
+++ b/arch/x86/platform/atom/punit_atom_debug.c
@@ -115,7 +115,7 @@ static struct dentry *punit_dbg_file;
 
 static int punit_dbgfs_register(struct punit_device *punit_device)
 {
-        static struct dentry *dev_state;
+        struct dentry *dev_state;
 
         punit_dbg_file = debugfs_create_dir("punit_atom", NULL);
         if (!punit_dbg_file)
@@ -143,8 +143,8 @@ static void punit_dbgfs_unregister(void)
           (kernel_ulong_t)&drv_data }
 
 static const struct x86_cpu_id intel_punit_cpu_ids[] = {
-        ICPU(INTEL_FAM6_ATOM_SILVERMONT1, punit_device_byt),
-        ICPU(INTEL_FAM6_ATOM_MERRIFIELD,  punit_device_tng),
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT, punit_device_byt),
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT_MID,  punit_device_tng),
         ICPU(INTEL_FAM6_ATOM_AIRMONT,     punit_device_cht),
         {}
 };
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_bt.c b/arch/x86/platform/intel-mid/device_libs/platform_bt.c
index 5a0483e7bf66..31dce781364c 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_bt.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_bt.c
@@ -68,7 +68,7 @@ static struct bt_sfi_data tng_bt_sfi_data __initdata = {
         { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, (kernel_ulong_t)&ddata }
 
 static const struct x86_cpu_id bt_sfi_cpu_ids[] = {
-        ICPU(INTEL_FAM6_ATOM_MERRIFIELD, tng_bt_sfi_data),
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT_MID, tng_bt_sfi_data),
         {}
 };
 
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 10adb8cb3a3f..b9bda06d344d 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -314,7 +314,7 @@ static const struct lpss_device_desc bsw_spi_dev_desc = {
 #define ICPU(model)     { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, }
 
 static const struct x86_cpu_id lpss_cpu_ids[] = {
-        ICPU(INTEL_FAM6_ATOM_SILVERMONT1),      /* Valleyview, Bay Trail */
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT),       /* Valleyview, Bay Trail */
         ICPU(INTEL_FAM6_ATOM_AIRMONT),  /* Braswell, Cherry Trail */
         {}
 };
diff --git a/drivers/acpi/x86/utils.c b/drivers/acpi/x86/utils.c
index 06c31ec3cc70..9a8e286dd86f 100644
--- a/drivers/acpi/x86/utils.c
+++ b/drivers/acpi/x86/utils.c
@@ -54,7 +54,7 @@ static const struct always_present_id always_present_ids[] = {
          * Bay / Cherry Trail PWM directly poked by GPU driver in win10,
          * but Linux uses a separate PWM driver, harmless if not used.
          */
-        ENTRY("80860F09", "1", ICPU(INTEL_FAM6_ATOM_SILVERMONT1), {}),
+        ENTRY("80860F09", "1", ICPU(INTEL_FAM6_ATOM_SILVERMONT), {}),
         ENTRY("80862288", "1", ICPU(INTEL_FAM6_ATOM_AIRMONT), {}),
         /*
          * The INT0002 device is necessary to clear wakeup interrupt sources
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 2a99e2fd9412..49c0abf2d48f 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -1816,7 +1816,7 @@ static const struct pstate_funcs knl_funcs = {
 static const struct x86_cpu_id intel_pstate_cpu_ids[] = {
         ICPU(INTEL_FAM6_SANDYBRIDGE,            core_funcs),
         ICPU(INTEL_FAM6_SANDYBRIDGE_X,          core_funcs),
-        ICPU(INTEL_FAM6_ATOM_SILVERMONT1,       silvermont_funcs),
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT,        silvermont_funcs),
         ICPU(INTEL_FAM6_IVYBRIDGE,              core_funcs),
         ICPU(INTEL_FAM6_HASWELL_CORE,           core_funcs),
         ICPU(INTEL_FAM6_BROADWELL_CORE,         core_funcs),
@@ -1833,7 +1833,7 @@ static const struct x86_cpu_id intel_pstate_cpu_ids[] = {
         ICPU(INTEL_FAM6_XEON_PHI_KNL,           knl_funcs),
         ICPU(INTEL_FAM6_XEON_PHI_KNM,           knl_funcs),
         ICPU(INTEL_FAM6_ATOM_GOLDMONT,          core_funcs),
-        ICPU(INTEL_FAM6_ATOM_GEMINI_LAKE,       core_funcs),
+        ICPU(INTEL_FAM6_ATOM_GOLDMONT_PLUS,     core_funcs),
         ICPU(INTEL_FAM6_SKYLAKE_X,              core_funcs),
         {}
 };
diff --git a/drivers/edac/pnd2_edac.c b/drivers/edac/pnd2_edac.c
index df28b65358d2..903a4f1fadcc 100644
--- a/drivers/edac/pnd2_edac.c
+++ b/drivers/edac/pnd2_edac.c
@@ -1541,7 +1541,7 @@ static struct dunit_ops dnv_ops = {
 
 static const struct x86_cpu_id pnd2_cpuids[] = {
         { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_GOLDMONT, 0, (kernel_ulong_t)&apl_ops },
-        { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_DENVERTON, 0, (kernel_ulong_t)&dnv_ops },
+        { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_GOLDMONT_X, 0, (kernel_ulong_t)&dnv_ops },
         { }
 };
 MODULE_DEVICE_TABLE(x86cpu, pnd2_cpuids);
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 791b8a366e6e..8b5d85c91e9d 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -1073,14 +1073,14 @@ static const struct x86_cpu_id intel_idle_ids[] __initconst = {
         INTEL_CPU_FAM6(WESTMERE,                idle_cpu_nehalem),
         INTEL_CPU_FAM6(WESTMERE_EP,             idle_cpu_nehalem),
         INTEL_CPU_FAM6(NEHALEM_EX,              idle_cpu_nehalem),
-        INTEL_CPU_FAM6(ATOM_PINEVIEW,           idle_cpu_atom),
-        INTEL_CPU_FAM6(ATOM_LINCROFT,           idle_cpu_lincroft),
+        INTEL_CPU_FAM6(ATOM_BONNELL,            idle_cpu_atom),
+        INTEL_CPU_FAM6(ATOM_BONNELL_MID,        idle_cpu_lincroft),
         INTEL_CPU_FAM6(WESTMERE_EX,             idle_cpu_nehalem),
         INTEL_CPU_FAM6(SANDYBRIDGE,             idle_cpu_snb),
         INTEL_CPU_FAM6(SANDYBRIDGE_X,           idle_cpu_snb),
-        INTEL_CPU_FAM6(ATOM_CEDARVIEW,          idle_cpu_atom),
-        INTEL_CPU_FAM6(ATOM_SILVERMONT1,        idle_cpu_byt),
-        INTEL_CPU_FAM6(ATOM_MERRIFIELD,         idle_cpu_tangier),
+        INTEL_CPU_FAM6(ATOM_SALTWELL,           idle_cpu_atom),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT,         idle_cpu_byt),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT_MID,     idle_cpu_tangier),
         INTEL_CPU_FAM6(ATOM_AIRMONT,            idle_cpu_cht),
         INTEL_CPU_FAM6(IVYBRIDGE,               idle_cpu_ivb),
         INTEL_CPU_FAM6(IVYBRIDGE_X,             idle_cpu_ivt),
@@ -1088,7 +1088,7 @@ static const struct x86_cpu_id intel_idle_ids[] __initconst = {
         INTEL_CPU_FAM6(HASWELL_X,               idle_cpu_hsw),
         INTEL_CPU_FAM6(HASWELL_ULT,             idle_cpu_hsw),
         INTEL_CPU_FAM6(HASWELL_GT3E,            idle_cpu_hsw),
-        INTEL_CPU_FAM6(ATOM_SILVERMONT2,        idle_cpu_avn),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT_X,       idle_cpu_avn),
         INTEL_CPU_FAM6(BROADWELL_CORE,          idle_cpu_bdw),
         INTEL_CPU_FAM6(BROADWELL_GT3E,          idle_cpu_bdw),
         INTEL_CPU_FAM6(BROADWELL_X,             idle_cpu_bdw),
@@ -1101,8 +1101,8 @@ static const struct x86_cpu_id intel_idle_ids[] __initconst = {
         INTEL_CPU_FAM6(XEON_PHI_KNL,            idle_cpu_knl),
         INTEL_CPU_FAM6(XEON_PHI_KNM,            idle_cpu_knl),
         INTEL_CPU_FAM6(ATOM_GOLDMONT,           idle_cpu_bxt),
-        INTEL_CPU_FAM6(ATOM_GEMINI_LAKE,        idle_cpu_bxt),
-        INTEL_CPU_FAM6(ATOM_DENVERTON,          idle_cpu_dnv),
+        INTEL_CPU_FAM6(ATOM_GOLDMONT_PLUS,      idle_cpu_bxt),
+        INTEL_CPU_FAM6(ATOM_GOLDMONT_X,         idle_cpu_dnv),
         {}
 };
 
@@ -1319,7 +1319,7 @@ static void intel_idle_state_table_update(void)
                 ivt_idle_state_table_update();
                 break;
         case INTEL_FAM6_ATOM_GOLDMONT:
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
                 bxt_idle_state_table_update();
                 break;
         case INTEL_FAM6_SKYLAKE_DESKTOP:
diff --git a/drivers/mmc/host/sdhci-acpi.c b/drivers/mmc/host/sdhci-acpi.c
index 82c9b9326e9e..057e24f4a620 100644
--- a/drivers/mmc/host/sdhci-acpi.c
+++ b/drivers/mmc/host/sdhci-acpi.c
@@ -247,7 +247,7 @@ static const struct sdhci_acpi_chip sdhci_acpi_chip_int = {
 static bool sdhci_acpi_byt(void)
 {
         static const struct x86_cpu_id byt[] = {
-                { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT1 },
+                { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT },
                 {}
         };
 
diff --git a/drivers/pci/pci-mid.c b/drivers/pci/pci-mid.c
index 314e135014dc..30fbe2ea6eab 100644
--- a/drivers/pci/pci-mid.c
+++ b/drivers/pci/pci-mid.c
@@ -62,8 +62,8 @@ static const struct pci_platform_pm_ops mid_pci_platform_pm = {
  * arch/x86/platform/intel-mid/pwr.c.
  */
 static const struct x86_cpu_id lpss_cpu_ids[] = {
-        ICPU(INTEL_FAM6_ATOM_PENWELL),
-        ICPU(INTEL_FAM6_ATOM_MERRIFIELD),
+        ICPU(INTEL_FAM6_ATOM_SALTWELL_MID),
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT_MID),
         {}
 };
 
diff --git a/drivers/platform/x86/intel_int0002_vgpio.c b/drivers/platform/x86/intel_int0002_vgpio.c
index a473dc51b18d..e89ad4964dc1 100644
--- a/drivers/platform/x86/intel_int0002_vgpio.c
+++ b/drivers/platform/x86/intel_int0002_vgpio.c
@@ -60,7 +60,7 @@ static const struct x86_cpu_id int0002_cpu_ids[] = {
 /*
  * Limit ourselves to Cherry Trail for now, until testing shows we
  * need to handle the INT0002 device on Baytrail too.
- *      ICPU(INTEL_FAM6_ATOM_SILVERMONT1),       * Valleyview, Bay Trail *
+ *      ICPU(INTEL_FAM6_ATOM_SILVERMONT),        * Valleyview, Bay Trail *
  */
         ICPU(INTEL_FAM6_ATOM_AIRMONT),          /* Braswell, Cherry Trail */
         {}
diff --git a/drivers/platform/x86/intel_mid_powerbtn.c b/drivers/platform/x86/intel_mid_powerbtn.c
index d79fbf924b13..5ad44204a9c3 100644
--- a/drivers/platform/x86/intel_mid_powerbtn.c
+++ b/drivers/platform/x86/intel_mid_powerbtn.c
@@ -125,8 +125,8 @@ static const struct mid_pb_ddata mrfld_ddata = {
         { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, (kernel_ulong_t)&ddata }
 
 static const struct x86_cpu_id mid_pb_cpu_ids[] = {
-        ICPU(INTEL_FAM6_ATOM_PENWELL,           mfld_ddata),
-        ICPU(INTEL_FAM6_ATOM_MERRIFIELD,        mrfld_ddata),
+        ICPU(INTEL_FAM6_ATOM_SALTWELL_MID,              mfld_ddata),
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT_MID,    mrfld_ddata),
         {}
 };
 
diff --git a/drivers/platform/x86/intel_telemetry_debugfs.c b/drivers/platform/x86/intel_telemetry_debugfs.c
index ffd0474b0531..cee08f236292 100644
--- a/drivers/platform/x86/intel_telemetry_debugfs.c
+++ b/drivers/platform/x86/intel_telemetry_debugfs.c
@@ -320,7 +320,7 @@ static struct telemetry_debugfs_conf telem_apl_debugfs_conf = {
 
 static const struct x86_cpu_id telemetry_debugfs_cpu_ids[] = {
         TELEM_DEBUGFS_CPU(INTEL_FAM6_ATOM_GOLDMONT, telem_apl_debugfs_conf),
-        TELEM_DEBUGFS_CPU(INTEL_FAM6_ATOM_GEMINI_LAKE, telem_apl_debugfs_conf),
+        TELEM_DEBUGFS_CPU(INTEL_FAM6_ATOM_GOLDMONT_PLUS, telem_apl_debugfs_conf),
         {}
 };
 
diff --git a/drivers/platform/x86/intel_telemetry_pltdrv.c b/drivers/platform/x86/intel_telemetry_pltdrv.c
index 2f889d6c270e..fcc6bee51a42 100644
--- a/drivers/platform/x86/intel_telemetry_pltdrv.c
+++ b/drivers/platform/x86/intel_telemetry_pltdrv.c
@@ -192,7 +192,7 @@ static struct telemetry_plt_config telem_glk_config = {
 
 static const struct x86_cpu_id telemetry_cpu_ids[] = {
         TELEM_CPU(INTEL_FAM6_ATOM_GOLDMONT, telem_apl_config),
-        TELEM_CPU(INTEL_FAM6_ATOM_GEMINI_LAKE, telem_glk_config),
+        TELEM_CPU(INTEL_FAM6_ATOM_GOLDMONT_PLUS, telem_glk_config),
         {}
 };
 
diff --git a/drivers/powercap/intel_rapl.c b/drivers/powercap/intel_rapl.c
index bb92874b1175..6cdb2c14eee4 100644
--- a/drivers/powercap/intel_rapl.c
+++ b/drivers/powercap/intel_rapl.c
@@ -1157,13 +1157,13 @@ static const struct x86_cpu_id rapl_ids[] __initconst = {
         INTEL_CPU_FAM6(KABYLAKE_DESKTOP,        rapl_defaults_core),
         INTEL_CPU_FAM6(CANNONLAKE_MOBILE,       rapl_defaults_core),
 
-        INTEL_CPU_FAM6(ATOM_SILVERMONT1,        rapl_defaults_byt),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT,         rapl_defaults_byt),
         INTEL_CPU_FAM6(ATOM_AIRMONT,            rapl_defaults_cht),
-        INTEL_CPU_FAM6(ATOM_MERRIFIELD,         rapl_defaults_tng),
-        INTEL_CPU_FAM6(ATOM_MOOREFIELD,         rapl_defaults_ann),
+        INTEL_CPU_FAM6(ATOM_SILVERMONT_MID,     rapl_defaults_tng),
+        INTEL_CPU_FAM6(ATOM_AIRMONT_MID,        rapl_defaults_ann),
         INTEL_CPU_FAM6(ATOM_GOLDMONT,           rapl_defaults_core),
-        INTEL_CPU_FAM6(ATOM_GEMINI_LAKE,        rapl_defaults_core),
-        INTEL_CPU_FAM6(ATOM_DENVERTON,          rapl_defaults_core),
+        INTEL_CPU_FAM6(ATOM_GOLDMONT_PLUS,      rapl_defaults_core),
+        INTEL_CPU_FAM6(ATOM_GOLDMONT_X,         rapl_defaults_core),
 
         INTEL_CPU_FAM6(XEON_PHI_KNL,            rapl_defaults_hsw_server),
         INTEL_CPU_FAM6(XEON_PHI_KNM,            rapl_defaults_hsw_server),
diff --git a/drivers/thermal/intel_soc_dts_thermal.c b/drivers/thermal/intel_soc_dts_thermal.c
index 1e47511a6bd5..d748527d7a38 100644
--- a/drivers/thermal/intel_soc_dts_thermal.c
+++ b/drivers/thermal/intel_soc_dts_thermal.c
@@ -45,7 +45,7 @@ static irqreturn_t soc_irq_thread_fn(int irq, void *dev_data)
 }
 
 static const struct x86_cpu_id soc_thermal_ids[] = {
-        { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT1, 0,
+        { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT, 0,
                 BYT_SOC_DTS_APIC_IRQ},
         {}
 };
diff --git a/kernel/events/ring_buffer.c b/kernel/events/ring_buffer.c
index 5d3cf407e374..4a9937076331 100644
--- a/kernel/events/ring_buffer.c
+++ b/kernel/events/ring_buffer.c
@@ -459,10 +459,20 @@ void perf_aux_output_end(struct perf_output_handle *handle, unsigned long size)
         if (size || handle->aux_flags) {
                 /*
                  * Only send RECORD_AUX if we have something useful to communicate
+                 *
+                 * Note: the OVERWRITE records by themselves are not considered
+                 * useful, as they don't communicate any *new* information,
+                 * aside from the short-lived offset, that becomes history at
+                 * the next event sched-in and therefore isn't useful.
+                 * The userspace that needs to copy out AUX data in overwrite
+                 * mode should know to use user_page::aux_head for the actual
+                 * offset. So, from now on we don't output AUX records that
+                 * have *only* OVERWRITE flag set.
                  */
 
-                perf_event_aux_event(handle->event, aux_head, size,
-                                     handle->aux_flags);
+                if (handle->aux_flags & ~(u64)PERF_AUX_FLAG_OVERWRITE)
+                        perf_event_aux_event(handle->event, aux_head, size,
+                                             handle->aux_flags);
         }
 
         rb->user_page->aux_head = rb->aux_head;
diff --git a/kernel/kprobes.c b/kernel/kprobes.c
index ab257be4d924..90e98e233647 100644
--- a/kernel/kprobes.c
+++ b/kernel/kprobes.c
@@ -546,8 +546,14 @@ static void do_free_cleaned_kprobes(void)
         struct optimized_kprobe *op, *tmp;
 
         list_for_each_entry_safe(op, tmp, &freeing_list, list) {
-                BUG_ON(!kprobe_unused(&op->kp));
                 list_del_init(&op->list);
+                if (WARN_ON_ONCE(!kprobe_unused(&op->kp))) {
+                        /*
+                         * This must not happen, but if there is a kprobe
+                         * still in use, keep it on kprobes hash list.
+                         */
+                        continue;
+                }
                 free_aggr_kprobe(&op->kp);
         }
 }
@@ -700,11 +706,11 @@ static void unoptimize_kprobe(struct kprobe *p, bool force)
 }
 
 /* Cancel unoptimizing for reusing */
-static void reuse_unused_kprobe(struct kprobe *ap)
+static int reuse_unused_kprobe(struct kprobe *ap)
 {
         struct optimized_kprobe *op;
+        int ret;
 
-        BUG_ON(!kprobe_unused(ap));
         /*
          * Unused kprobe MUST be on the way of delayed unoptimizing (means
          * there is still a relative jump) and disabled.
@@ -714,8 +720,12 @@ static void reuse_unused_kprobe(struct kprobe *ap)
         /* Enable the probe again */
         ap->flags &= ~KPROBE_FLAG_DISABLED;
         /* Optimize it again (remove from op->list) */
-        BUG_ON(!kprobe_optready(ap));
+        ret = kprobe_optready(ap);
+        if (ret)
+                return ret;
+
         optimize_kprobe(ap);
+        return 0;
 }
 
 /* Remove optimized instructions */
@@ -940,11 +950,16 @@ static void __disarm_kprobe(struct kprobe *p, bool reopt)
 #define kprobe_disarmed(p)                      kprobe_disabled(p)
 #define wait_for_kprobe_optimizer()             do {} while (0)
 
-/* There should be no unused kprobes can be reused without optimization */
-static void reuse_unused_kprobe(struct kprobe *ap)
+static int reuse_unused_kprobe(struct kprobe *ap)
 {
+        /*
+         * If the optimized kprobe is NOT supported, the aggr kprobe is
+         * released at the same time that the last aggregated kprobe is
+         * unregistered.
+         * Thus there should be no chance to reuse unused kprobe.
+         */
         printk(KERN_ERR "Error: There should be no unused kprobe here.\n");
-        BUG_ON(kprobe_unused(ap));
+        return -EINVAL;
 }
 
 static void free_aggr_kprobe(struct kprobe *p)
@@ -1259,8 +1274,6 @@ NOKPROBE_SYMBOL(cleanup_rp_inst);
 /* Add the new probe to ap->list */
 static int add_new_kprobe(struct kprobe *ap, struct kprobe *p)
 {
-        BUG_ON(kprobe_gone(ap) || kprobe_gone(p));
-
         if (p->post_handler)
                 unoptimize_kprobe(ap, true);    /* Fall back to normal kprobe */
 
@@ -1318,9 +1331,12 @@ static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p)
                         goto out;
                 }
                 init_aggr_kprobe(ap, orig_p);
-        } else if (kprobe_unused(ap))
+        } else if (kprobe_unused(ap)) {
                 /* This probe is going to die. Rescue it */
-                reuse_unused_kprobe(ap);
+                ret = reuse_unused_kprobe(ap);
+                if (ret)
+                        goto out;
+        }
 
         if (kprobe_gone(ap)) {
                 /*
@@ -1704,7 +1720,6 @@ noclean:
         return 0;
 
 disarmed:
-        BUG_ON(!kprobe_disarmed(ap));
         hlist_del_rcu(&ap->hlist);
         return 0;
 }
diff --git a/sound/soc/intel/boards/bytcr_rt5651.c b/sound/soc/intel/boards/bytcr_rt5651.c
index f8a68bdb3885..6af02bf879ac 100644
--- a/sound/soc/intel/boards/bytcr_rt5651.c
+++ b/sound/soc/intel/boards/bytcr_rt5651.c
@@ -787,7 +787,7 @@ static struct snd_soc_card byt_rt5651_card = {
 };
 
 static const struct x86_cpu_id baytrail_cpu_ids[] = {
-        { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT1 }, /* Valleyview */
+        { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT }, /* Valleyview */
         {}
 };
 
diff --git a/tools/include/linux/bitops.h b/tools/include/linux/bitops.h
index acc704bd3998..0b0ef3abc966 100644
--- a/tools/include/linux/bitops.h
+++ b/tools/include/linux/bitops.h
@@ -3,8 +3,6 @@
 #define _TOOLS_LINUX_BITOPS_H_
 
 #include <asm/types.h>
-#include <linux/compiler.h>
-
 #ifndef __WORDSIZE
 #define __WORDSIZE (__SIZEOF_LONG__ * 8)
 #endif
@@ -12,10 +10,9 @@
 #ifndef BITS_PER_LONG
 # define BITS_PER_LONG __WORDSIZE
 #endif
+#include <linux/bits.h>
+#include <linux/compiler.h>
 
-#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
-#define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
-#define BITS_PER_BYTE           8
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #define BITS_TO_U64(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64))
 #define BITS_TO_U32(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32))
diff --git a/tools/include/linux/bits.h b/tools/include/linux/bits.h
new file mode 100644
index 000000000000..2b7b532c1d51
--- /dev/null
+++ b/tools/include/linux/bits.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __LINUX_BITS_H
+#define __LINUX_BITS_H
+#include <asm/bitsperlong.h>
+
+#define BIT(nr)                 (1UL << (nr))
+#define BIT_ULL(nr)             (1ULL << (nr))
+#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
+#define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
+#define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
+#define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
+#define BITS_PER_BYTE           8
+
+/*
+ * Create a contiguous bitmask starting at bit position @l and ending at
+ * position @h. For example
+ * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.
+ */
+#define GENMASK(h, l) \
+        (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
+
+#define GENMASK_ULL(h, l) \
+        (((~0ULL) - (1ULL << (l)) + 1) & \
+         (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h))))
+
+#endif  /* __LINUX_BITS_H */
diff --git a/tools/include/linux/err.h b/tools/include/linux/err.h
index 7a8b61ad44cb..094649667bae 100644
--- a/tools/include/linux/err.h
+++ b/tools/include/linux/err.h
@@ -52,4 +52,11 @@ static inline bool __must_check IS_ERR_OR_NULL(__force const void *ptr)
         return unlikely(!ptr) || IS_ERR_VALUE((unsigned long)ptr);
 }
 
+static inline int __must_check PTR_ERR_OR_ZERO(__force const void *ptr)
+{
+        if (IS_ERR(ptr))
+                return PTR_ERR(ptr);
+        else
+                return 0;
+}
 #endif /* _LINUX_ERR_H */
diff --git a/tools/lib/subcmd/pager.c b/tools/lib/subcmd/pager.c
index 9997a8805a82..e3d47b59b14d 100644
--- a/tools/lib/subcmd/pager.c
+++ b/tools/lib/subcmd/pager.c
@@ -23,6 +23,13 @@ void pager_init(const char *pager_env)
         subcmd_config.pager_env = pager_env;
 }
 
+static const char *forced_pager;
+
+void force_pager(const char *pager)
+{
+        forced_pager = pager;
+}
+
 static void pager_preexec(void)
 {
         /*
@@ -66,7 +73,9 @@ void setup_pager(void)
         const char *pager = getenv(subcmd_config.pager_env);
         struct winsize sz;
 
-        if (!isatty(1))
+        if (forced_pager)
+                pager = forced_pager;
+        if (!isatty(1) && !forced_pager)
                 return;
         if (ioctl(1, TIOCGWINSZ, &sz) == 0)
                 pager_columns = sz.ws_col;
diff --git a/tools/lib/subcmd/pager.h b/tools/lib/subcmd/pager.h
index f1a53cf29880..a818964693ab 100644
--- a/tools/lib/subcmd/pager.h
+++ b/tools/lib/subcmd/pager.h
@@ -7,5 +7,6 @@ extern void pager_init(const char *pager_env);
 extern void setup_pager(void);
 extern int pager_in_use(void);
 extern int pager_get_columns(void);
+extern void force_pager(const char *);
 
 #endif /* __SUBCMD_PAGER_H */
diff --git a/tools/lib/traceevent/Build b/tools/lib/traceevent/Build
index c681d0575d16..ba54bfce0b0b 100644
--- a/tools/lib/traceevent/Build
+++ b/tools/lib/traceevent/Build
@@ -4,6 +4,8 @@ libtraceevent-y += trace-seq.o
 libtraceevent-y += parse-filter.o
 libtraceevent-y += parse-utils.o
 libtraceevent-y += kbuffer-parse.o
+libtraceevent-y += tep_strerror.o
+libtraceevent-y += event-parse-api.o
 
 plugin_jbd2-y         += plugin_jbd2.o
 plugin_hrtimer-y      += plugin_hrtimer.o
diff --git a/tools/lib/traceevent/event-parse-api.c b/tools/lib/traceevent/event-parse-api.c
new file mode 100644
index 000000000000..61f7149085ee
--- /dev/null
+++ b/tools/lib/traceevent/event-parse-api.c
@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: LGPL-2.1
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+#include "event-parse.h"
+#include "event-parse-local.h"
+#include "event-utils.h"
+
+/**
+ * tep_get_first_event - returns the first event in the events array
+ * @tep: a handle to the tep_handle
+ *
+ * This returns pointer to the first element of the events array
+ * If @tep is NULL, NULL is returned.
+ */
+struct tep_event_format *tep_get_first_event(struct tep_handle *tep)
+{
+        if (tep && tep->events)
+                return tep->events[0];
+
+        return NULL;
+}
+
+/**
+ * tep_get_events_count - get the number of defined events
+ * @tep: a handle to the tep_handle
+ *
+ * This returns number of elements in event array
+ * If @tep is NULL, 0 is returned.
+ */
+int tep_get_events_count(struct tep_handle *tep)
+{
+        if(tep)
+                return tep->nr_events;
+        return 0;
+}
+
+/**
+ * tep_set_flag - set event parser flag
+ * @tep: a handle to the tep_handle
+ * @flag: flag, or combination of flags to be set
+ * can be any combination from enum tep_flag
+ *
+ * This sets a flag or mbination of flags  from enum tep_flag
+  */
+void tep_set_flag(struct tep_handle *tep, int flag)
+{
+        if(tep)
+                tep->flags |= flag;
+}
+
+unsigned short __tep_data2host2(struct tep_handle *pevent, unsigned short data)
+{
+        unsigned short swap;
+
+        if (!pevent || pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 8) |
+                ((data & (0xffULL << 8)) >> 8);
+
+        return swap;
+}
+
+unsigned int __tep_data2host4(struct tep_handle *pevent, unsigned int data)
+{
+        unsigned int swap;
+
+        if (!pevent || pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 24) |
+                ((data & (0xffULL << 8)) << 8) |
+                ((data & (0xffULL << 16)) >> 8) |
+                ((data & (0xffULL << 24)) >> 24);
+
+        return swap;
+}
+
+unsigned long long
+__tep_data2host8(struct tep_handle *pevent, unsigned long long data)
+{
+        unsigned long long swap;
+
+        if (!pevent || pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 56) |
+                ((data & (0xffULL << 8)) << 40) |
+                ((data & (0xffULL << 16)) << 24) |
+                ((data & (0xffULL << 24)) << 8) |
+                ((data & (0xffULL << 32)) >> 8) |
+                ((data & (0xffULL << 40)) >> 24) |
+                ((data & (0xffULL << 48)) >> 40) |
+                ((data & (0xffULL << 56)) >> 56);
+
+        return swap;
+}
+
+/**
+ * tep_get_header_page_size - get size of the header page
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns size of the header page
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_header_page_size(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->header_page_size_size;
+        return 0;
+}
+
+/**
+ * tep_get_cpus - get the number of CPUs
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns the number of CPUs
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_cpus(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->cpus;
+        return 0;
+}
+
+/**
+ * tep_set_cpus - set the number of CPUs
+ * @pevent: a handle to the tep_handle
+ *
+ * This sets the number of CPUs
+ */
+void tep_set_cpus(struct tep_handle *pevent, int cpus)
+{
+        if(pevent)
+                pevent->cpus = cpus;
+}
+
+/**
+ * tep_get_long_size - get the size of a long integer on the current machine
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns the size of a long integer on the current machine
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_long_size(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->long_size;
+        return 0;
+}
+
+/**
+ * tep_set_long_size - set the size of a long integer on the current machine
+ * @pevent: a handle to the tep_handle
+ * @size: size, in bytes, of a long integer
+ *
+ * This sets the size of a long integer on the current machine
+ */
+void tep_set_long_size(struct tep_handle *pevent, int long_size)
+{
+        if(pevent)
+                pevent->long_size = long_size;
+}
+
+/**
+ * tep_get_page_size - get the size of a memory page on the current machine
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns the size of a memory page on the current machine
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_page_size(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->page_size;
+        return 0;
+}
+
+/**
+ * tep_set_page_size - set the size of a memory page on the current machine
+ * @pevent: a handle to the tep_handle
+ * @_page_size: size of a memory page, in bytes
+ *
+ * This sets the size of a memory page on the current machine
+ */
+void tep_set_page_size(struct tep_handle *pevent, int _page_size)
+{
+        if(pevent)
+                pevent->page_size = _page_size;
+}
+
+/**
+ * tep_is_file_bigendian - get if the file is in big endian order
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns if the file is in big endian order
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_is_file_bigendian(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->file_bigendian;
+        return 0;
+}
+
+/**
+ * tep_set_file_bigendian - set if the file is in big endian order
+ * @pevent: a handle to the tep_handle
+ * @endian: non zero, if the file is in big endian order
+ *
+ * This sets if the file is in big endian order
+ */
+void tep_set_file_bigendian(struct tep_handle *pevent, enum tep_endian endian)
+{
+        if(pevent)
+                pevent->file_bigendian = endian;
+}
+
+/**
+ * tep_is_host_bigendian - get if the order of the current host is big endian
+ * @pevent: a handle to the tep_handle
+ *
+ * This gets if the order of the current host is big endian
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_is_host_bigendian(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->host_bigendian;
+        return 0;
+}
+
+/**
+ * tep_set_host_bigendian - set the order of the local host
+ * @pevent: a handle to the tep_handle
+ * @endian: non zero, if the local host has big endian order
+ *
+ * This sets the order of the local host
+ */
+void tep_set_host_bigendian(struct tep_handle *pevent, enum tep_endian endian)
+{
+        if(pevent)
+                pevent->host_bigendian = endian;
+}
+
+/**
+ * tep_is_latency_format - get if the latency output format is configured
+ * @pevent: a handle to the tep_handle
+ *
+ * This gets if the latency output format is configured
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_is_latency_format(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->latency_format;
+        return 0;
+}
+
+/**
+ * tep_set_latency_format - set the latency output format
+ * @pevent: a handle to the tep_handle
+ * @lat: non zero for latency output format
+ *
+ * This sets the latency output format
+  */
+void tep_set_latency_format(struct tep_handle *pevent, int lat)
+{
+        if(pevent)
+                pevent->latency_format = lat;
+}
diff --git a/tools/lib/traceevent/event-parse-local.h b/tools/lib/traceevent/event-parse-local.h
new file mode 100644
index 000000000000..b9bddde577f8
--- /dev/null
+++ b/tools/lib/traceevent/event-parse-local.h
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: LGPL-2.1
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+#ifndef _PARSE_EVENTS_INT_H
+#define _PARSE_EVENTS_INT_H
+
+struct cmdline;
+struct cmdline_list;
+struct func_map;
+struct func_list;
+struct event_handler;
+struct func_resolver;
+
+struct tep_handle {
+        int ref_count;
+
+        int header_page_ts_offset;
+        int header_page_ts_size;
+        int header_page_size_offset;
+        int header_page_size_size;
+        int header_page_data_offset;
+        int header_page_data_size;
+        int header_page_overwrite;
+
+        enum tep_endian file_bigendian;
+        enum tep_endian host_bigendian;
+
+        int latency_format;
+
+        int old_format;
+
+        int cpus;
+        int long_size;
+        int page_size;
+
+        struct cmdline *cmdlines;
+        struct cmdline_list *cmdlist;
+        int cmdline_count;
+
+        struct func_map *func_map;
+        struct func_resolver *func_resolver;
+        struct func_list *funclist;
+        unsigned int func_count;
+
+        struct printk_map *printk_map;
+        struct printk_list *printklist;
+        unsigned int printk_count;
+
+
+        struct tep_event_format **events;
+        int nr_events;
+        struct tep_event_format **sort_events;
+        enum tep_event_sort_type last_type;
+
+        int type_offset;
+        int type_size;
+
+        int pid_offset;
+        int pid_size;
+
+        int pc_offset;
+        int pc_size;
+
+        int flags_offset;
+        int flags_size;
+
+        int ld_offset;
+        int ld_size;
+
+        int print_raw;
+
+        int test_filters;
+
+        int flags;
+
+        struct tep_format_field *bprint_ip_field;
+        struct tep_format_field *bprint_fmt_field;
+        struct tep_format_field *bprint_buf_field;
+
+        struct event_handler *handlers;
+        struct tep_function_handler *func_handlers;
+
+        /* cache */
+        struct tep_event_format *last_event;
+
+        char *trace_clock;
+};
+
+#endif /* _PARSE_EVENTS_INT_H */
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index ce1e20227c64..3692f29fee46 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -18,12 +18,14 @@
 #include <errno.h>
 #include <stdint.h>
 #include <limits.h>
-#include <linux/string.h>
 #include <linux/time64.h>
 
 #include <netinet/in.h>
 #include "event-parse.h"
+
+#include "event-parse-local.h"
 #include "event-utils.h"
+#include "trace-seq.h"
 
 static const char *input_buf;
 static unsigned long long input_buf_ptr;
@@ -94,7 +96,7 @@ struct tep_function_handler {
 
 static unsigned long long
 process_defined_func(struct trace_seq *s, void *data, int size,
-                     struct event_format *event, struct print_arg *arg);
+                     struct tep_event_format *event, struct tep_print_arg *arg);
 
 static void free_func_handle(struct tep_function_handler *func);
 
@@ -117,9 +119,9 @@ void breakpoint(void)
         x++;
 }
 
-struct print_arg *alloc_arg(void)
+struct tep_print_arg *alloc_arg(void)
 {
-        return calloc(1, sizeof(struct print_arg));
+        return calloc(1, sizeof(struct tep_print_arg));
 }
 
 struct cmdline {
@@ -737,16 +739,16 @@ void tep_print_printk(struct tep_handle *pevent)
         }
 }
 
-static struct event_format *alloc_event(void)
+static struct tep_event_format *alloc_event(void)
 {
-        return calloc(1, sizeof(struct event_format));
+        return calloc(1, sizeof(struct tep_event_format));
 }
 
-static int add_event(struct tep_handle *pevent, struct event_format *event)
+static int add_event(struct tep_handle *pevent, struct tep_event_format *event)
 {
         int i;
-        struct event_format **events = realloc(pevent->events, sizeof(event) *
-                                               (pevent->nr_events + 1));
+        struct tep_event_format **events = realloc(pevent->events, sizeof(event) *
+                                                  (pevent->nr_events + 1));
         if (!events)
                 return -1;
 
@@ -769,20 +771,20 @@ static int add_event(struct tep_handle *pevent, struct event_format *event)
         return 0;
 }
 
-static int event_item_type(enum event_type type)
+static int event_item_type(enum tep_event_type type)
 {
         switch (type) {
-        case EVENT_ITEM ... EVENT_SQUOTE:
+        case TEP_EVENT_ITEM ... TEP_EVENT_SQUOTE:
                 return 1;
-        case EVENT_ERROR ... EVENT_DELIM:
+        case TEP_EVENT_ERROR ... TEP_EVENT_DELIM:
         default:
                 return 0;
         }
 }
 
-static void free_flag_sym(struct print_flag_sym *fsym)
+static void free_flag_sym(struct tep_print_flag_sym *fsym)
 {
-        struct print_flag_sym *next;
+        struct tep_print_flag_sym *next;
 
         while (fsym) {
                 next = fsym->next;
@@ -793,60 +795,60 @@ static void free_flag_sym(struct print_flag_sym *fsym)
         }
 }
 
-static void free_arg(struct print_arg *arg)
+static void free_arg(struct tep_print_arg *arg)
 {
-        struct print_arg *farg;
+        struct tep_print_arg *farg;
 
         if (!arg)
                 return;
 
         switch (arg->type) {
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 free(arg->atom.atom);
                 break;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 free(arg->field.name);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 free_arg(arg->flags.field);
                 free(arg->flags.delim);
                 free_flag_sym(arg->flags.flags);
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 free_arg(arg->symbol.field);
                 free_flag_sym(arg->symbol.symbols);
                 break;
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
                 free_arg(arg->hex.field);
                 free_arg(arg->hex.size);
                 break;
-        case PRINT_INT_ARRAY:
+        case TEP_PRINT_INT_ARRAY:
                 free_arg(arg->int_array.field);
                 free_arg(arg->int_array.count);
                 free_arg(arg->int_array.el_size);
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 free(arg->typecast.type);
                 free_arg(arg->typecast.item);
                 break;
-        case PRINT_STRING:
-        case PRINT_BSTRING:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BSTRING:
                 free(arg->string.string);
                 break;
-        case PRINT_BITMASK:
+        case TEP_PRINT_BITMASK:
                 free(arg->bitmask.bitmask);
                 break;
-        case PRINT_DYNAMIC_ARRAY:
-        case PRINT_DYNAMIC_ARRAY_LEN:
+        case TEP_PRINT_DYNAMIC_ARRAY:
+        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
                 free(arg->dynarray.index);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 free(arg->op.op);
                 free_arg(arg->op.left);
                 free_arg(arg->op.right);
                 break;
-        case PRINT_FUNC:
+        case TEP_PRINT_FUNC:
                 while (arg->func.args) {
                         farg = arg->func.args;
                         arg->func.args = farg->next;
@@ -854,7 +856,7 @@ static void free_arg(struct print_arg *arg)
                 }
                 break;
 
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
         default:
                 break;
         }
@@ -862,24 +864,24 @@ static void free_arg(struct print_arg *arg)
         free(arg);
 }
 
-static enum event_type get_type(int ch)
+static enum tep_event_type get_type(int ch)
 {
         if (ch == '\n')
-                return EVENT_NEWLINE;
+                return TEP_EVENT_NEWLINE;
         if (isspace(ch))
-                return EVENT_SPACE;
+                return TEP_EVENT_SPACE;
         if (isalnum(ch) || ch == '_')
-                return EVENT_ITEM;
+                return TEP_EVENT_ITEM;
         if (ch == '\'')
-                return EVENT_SQUOTE;
+                return TEP_EVENT_SQUOTE;
         if (ch == '"')
-                return EVENT_DQUOTE;
+                return TEP_EVENT_DQUOTE;
         if (!isprint(ch))
-                return EVENT_NONE;
+                return TEP_EVENT_NONE;
         if (ch == '(' || ch == ')' || ch == ',')
-                return EVENT_DELIM;
+                return TEP_EVENT_DELIM;
 
-        return EVENT_OP;
+        return TEP_EVENT_OP;
 }
 
 static int __read_char(void)
@@ -927,38 +929,38 @@ static int extend_token(char **tok, char *buf, int size)
         return 0;
 }
 
-static enum event_type force_token(const char *str, char **tok);
+static enum tep_event_type force_token(const char *str, char **tok);
 
-static enum event_type __read_token(char **tok)
+static enum tep_event_type __read_token(char **tok)
 {
         char buf[BUFSIZ];
         int ch, last_ch, quote_ch, next_ch;
         int i = 0;
         int tok_size = 0;
-        enum event_type type;
+        enum tep_event_type type;
 
         *tok = NULL;
 
 
         ch = __read_char();
         if (ch < 0)
-                return EVENT_NONE;
+                return TEP_EVENT_NONE;
 
         type = get_type(ch);
-        if (type == EVENT_NONE)
+        if (type == TEP_EVENT_NONE)
                 return type;
 
         buf[i++] = ch;
 
         switch (type) {
-        case EVENT_NEWLINE:
-        case EVENT_DELIM:
+        case TEP_EVENT_NEWLINE:
+        case TEP_EVENT_DELIM:
                 if (asprintf(tok, "%c", ch) < 0)
-                        return EVENT_ERROR;
+                        return TEP_EVENT_ERROR;
 
                 return type;
 
-        case EVENT_OP:
+        case TEP_EVENT_OP:
                 switch (ch) {
                 case '-':
                         next_ch = __peek_char();
@@ -1001,8 +1003,8 @@ static enum event_type __read_token(char **tok)
                         buf[i++] = __read_char();
                 goto out;
 
-        case EVENT_DQUOTE:
-        case EVENT_SQUOTE:
+        case TEP_EVENT_DQUOTE:
+        case TEP_EVENT_SQUOTE:
                 /* don't keep quotes */
                 i--;
                 quote_ch = ch;
@@ -1014,7 +1016,7 @@ static enum event_type __read_token(char **tok)
                                 tok_size += BUFSIZ;
 
                                 if (extend_token(tok, buf, tok_size) < 0)
-                                        return EVENT_NONE;
+                                        return TEP_EVENT_NONE;
                                 i = 0;
                         }
                         last_ch = ch;
@@ -1031,7 +1033,7 @@ static enum event_type __read_token(char **tok)
                  * For strings (double quotes) check the next token.
                  * If it is another string, concatinate the two.
                  */
-                if (type == EVENT_DQUOTE) {
+                if (type == TEP_EVENT_DQUOTE) {
                         unsigned long long save_input_buf_ptr = input_buf_ptr;
 
                         do {
@@ -1044,8 +1046,8 @@ static enum event_type __read_token(char **tok)
 
                 goto out;
 
-        case EVENT_ERROR ... EVENT_SPACE:
-        case EVENT_ITEM:
+        case TEP_EVENT_ERROR ... TEP_EVENT_SPACE:
+        case TEP_EVENT_ITEM:
         default:
                 break;
         }
@@ -1056,7 +1058,7 @@ static enum event_type __read_token(char **tok)
                         tok_size += BUFSIZ;
 
                         if (extend_token(tok, buf, tok_size) < 0)
-                                return EVENT_NONE;
+                                return TEP_EVENT_NONE;
                         i = 0;
                 }
                 ch = __read_char();
@@ -1066,9 +1068,9 @@ static enum event_type __read_token(char **tok)
  out:
         buf[i] = 0;
         if (extend_token(tok, buf, tok_size + i + 1) < 0)
-                return EVENT_NONE;
+                return TEP_EVENT_NONE;
 
-        if (type == EVENT_ITEM) {
+        if (type == TEP_EVENT_ITEM) {
                 /*
                  * Older versions of the kernel has a bug that
                  * creates invalid symbols and will break the mac80211
@@ -1095,12 +1097,12 @@ static enum event_type __read_token(char **tok)
         return type;
 }
 
-static enum event_type force_token(const char *str, char **tok)
+static enum tep_event_type force_token(const char *str, char **tok)
 {
         const char *save_input_buf;
         unsigned long long save_input_buf_ptr;
         unsigned long long save_input_buf_siz;
-        enum event_type type;
+        enum tep_event_type type;
         
         /* save off the current input pointers */
         save_input_buf = input_buf;
@@ -1125,13 +1127,13 @@ static void free_token(char *tok)
                 free(tok);
 }
 
-static enum event_type read_token(char **tok)
+static enum tep_event_type read_token(char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
 
         for (;;) {
                 type = __read_token(tok);
-                if (type != EVENT_SPACE)
+                if (type != TEP_EVENT_SPACE)
                         return type;
 
                 free_token(*tok);
@@ -1139,7 +1141,7 @@ static enum event_type read_token(char **tok)
 
         /* not reached */
         *tok = NULL;
-        return EVENT_NONE;
+        return TEP_EVENT_NONE;
 }
 
 /**
@@ -1151,7 +1153,7 @@ static enum event_type read_token(char **tok)
  *
  * Returns the token type.
  */
-enum event_type tep_read_token(char **tok)
+enum tep_event_type tep_read_token(char **tok)
 {
         return read_token(tok);
 }
@@ -1166,13 +1168,13 @@ void tep_free_token(char *token)
 }
 
 /* no newline */
-static enum event_type read_token_item(char **tok)
+static enum tep_event_type read_token_item(char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
 
         for (;;) {
                 type = __read_token(tok);
-                if (type != EVENT_SPACE && type != EVENT_NEWLINE)
+                if (type != TEP_EVENT_SPACE && type != TEP_EVENT_NEWLINE)
                         return type;
                 free_token(*tok);
                 *tok = NULL;
@@ -1180,10 +1182,10 @@ static enum event_type read_token_item(char **tok)
 
         /* not reached */
         *tok = NULL;
-        return EVENT_NONE;
+        return TEP_EVENT_NONE;
 }
 
-static int test_type(enum event_type type, enum event_type expect)
+static int test_type(enum tep_event_type type, enum tep_event_type expect)
 {
         if (type != expect) {
                 do_warning("Error: expected type %d but read %d",
@@ -1193,8 +1195,8 @@ static int test_type(enum event_type type, enum event_type expect)
         return 0;
 }
 
-static int test_type_token(enum event_type type, const char *token,
-                    enum event_type expect, const char *expect_tok)
+static int test_type_token(enum tep_event_type type, const char *token,
+                    enum tep_event_type expect, const char *expect_tok)
 {
         if (type != expect) {
                 do_warning("Error: expected type %d but read %d",
@@ -1210,9 +1212,9 @@ static int test_type_token(enum event_type type, const char *token,
         return 0;
 }
 
-static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
+static int __read_expect_type(enum tep_event_type expect, char **tok, int newline_ok)
 {
-        enum event_type type;
+        enum tep_event_type type;
 
         if (newline_ok)
                 type = read_token(tok);
@@ -1221,15 +1223,15 @@ static int __read_expect_type(enum event_type expect, char **tok, int newline_ok
         return test_type(type, expect);
 }
 
-static int read_expect_type(enum event_type expect, char **tok)
+static int read_expect_type(enum tep_event_type expect, char **tok)
 {
         return __read_expect_type(expect, tok, 1);
 }
 
-static int __read_expected(enum event_type expect, const char *str,
+static int __read_expected(enum tep_event_type expect, const char *str,
                            int newline_ok)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token;
         int ret;
 
@@ -1245,12 +1247,12 @@ static int __read_expected(enum event_type expect, const char *str,
         return ret;
 }
 
-static int read_expected(enum event_type expect, const char *str)
+static int read_expected(enum tep_event_type expect, const char *str)
 {
         return __read_expected(expect, str, 1);
 }
 
-static int read_expected_item(enum event_type expect, const char *str)
+static int read_expected_item(enum tep_event_type expect, const char *str)
 {
         return __read_expected(expect, str, 0);
 }
@@ -1259,13 +1261,13 @@ static char *event_read_name(void)
 {
         char *token;
 
-        if (read_expected(EVENT_ITEM, "name") < 0)
+        if (read_expected(TEP_EVENT_ITEM, "name") < 0)
                 return NULL;
 
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return NULL;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto fail;
 
         return token;
@@ -1280,13 +1282,13 @@ static int event_read_id(void)
         char *token;
         int id;
 
-        if (read_expected_item(EVENT_ITEM, "ID") < 0)
+        if (read_expected_item(TEP_EVENT_ITEM, "ID") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return -1;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto fail;
 
         id = strtoul(token, NULL, 0);
@@ -1298,9 +1300,9 @@ static int event_read_id(void)
         return -1;
 }
 
-static int field_is_string(struct format_field *field)
+static int field_is_string(struct tep_format_field *field)
 {
-        if ((field->flags & FIELD_IS_ARRAY) &&
+        if ((field->flags & TEP_FIELD_IS_ARRAY) &&
             (strstr(field->type, "char") || strstr(field->type, "u8") ||
              strstr(field->type, "s8")))
                 return 1;
@@ -1308,7 +1310,7 @@ static int field_is_string(struct format_field *field)
         return 0;
 }
 
-static int field_is_dynamic(struct format_field *field)
+static int field_is_dynamic(struct tep_format_field *field)
 {
         if (strncmp(field->type, "__data_loc", 10) == 0)
                 return 1;
@@ -1316,7 +1318,7 @@ static int field_is_dynamic(struct format_field *field)
         return 0;
 }
 
-static int field_is_long(struct format_field *field)
+static int field_is_long(struct tep_format_field *field)
 {
         /* includes long long */
         if (strstr(field->type, "long"))
@@ -1327,7 +1329,7 @@ static int field_is_long(struct format_field *field)
 
 static unsigned int type_size(const char *name)
 {
-        /* This covers all FIELD_IS_STRING types. */
+        /* This covers all TEP_FIELD_IS_STRING types. */
         static struct {
                 const char *type;
                 unsigned int size;
@@ -1353,10 +1355,10 @@ static unsigned int type_size(const char *name)
         return 0;
 }
 
-static int event_read_fields(struct event_format *event, struct format_field **fields)
+static int event_read_fields(struct tep_event_format *event, struct tep_format_field **fields)
 {
-        struct format_field *field = NULL;
-        enum event_type type;
+        struct tep_format_field *field = NULL;
+        enum tep_event_type type;
         char *token;
         char *last_token;
         int count = 0;
@@ -1365,14 +1367,14 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                 unsigned int size_dynamic = 0;
 
                 type = read_token(&token);
-                if (type == EVENT_NEWLINE) {
+                if (type == TEP_EVENT_NEWLINE) {
                         free_token(token);
                         return count;
                 }
 
                 count++;
 
-                if (test_type_token(type, token, EVENT_ITEM, "field"))
+                if (test_type_token(type, token, TEP_EVENT_ITEM, "field"))
                         goto fail;
                 free_token(token);
 
@@ -1381,17 +1383,17 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                  * The ftrace fields may still use the "special" name.
                  * Just ignore it.
                  */
-                if (event->flags & EVENT_FL_ISFTRACE &&
-                    type == EVENT_ITEM && strcmp(token, "special") == 0) {
+                if (event->flags & TEP_EVENT_FL_ISFTRACE &&
+                    type == TEP_EVENT_ITEM && strcmp(token, "special") == 0) {
                         free_token(token);
                         type = read_token(&token);
                 }
 
-                if (test_type_token(type, token, EVENT_OP, ":") < 0)
+                if (test_type_token(type, token, TEP_EVENT_OP, ":") < 0)
                         goto fail;
 
                 free_token(token);
-                if (read_expect_type(EVENT_ITEM, &token) < 0)
+                if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                         goto fail;
 
                 last_token = token;
@@ -1405,17 +1407,17 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                 /* read the rest of the type */
                 for (;;) {
                         type = read_token(&token);
-                        if (type == EVENT_ITEM ||
-                            (type == EVENT_OP && strcmp(token, "*") == 0) ||
+                        if (type == TEP_EVENT_ITEM ||
+                            (type == TEP_EVENT_OP && strcmp(token, "*") == 0) ||
                             /*
                              * Some of the ftrace fields are broken and have
                              * an illegal "." in them.
                              */
-                            (event->flags & EVENT_FL_ISFTRACE &&
-                             type == EVENT_OP && strcmp(token, ".") == 0)) {
+                            (event->flags & TEP_EVENT_FL_ISFTRACE &&
+                             type == TEP_EVENT_OP && strcmp(token, ".") == 0)) {
 
                                 if (strcmp(token, "*") == 0)
-                                        field->flags |= FIELD_IS_POINTER;
+                                        field->flags |= TEP_FIELD_IS_POINTER;
 
                                 if (field->type) {
                                         char *new_type;
@@ -1445,27 +1447,27 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                 }
                 field->name = field->alias = last_token;
 
-                if (test_type(type, EVENT_OP))
+                if (test_type(type, TEP_EVENT_OP))
                         goto fail;
 
                 if (strcmp(token, "[") == 0) {
-                        enum event_type last_type = type;
+                        enum tep_event_type last_type = type;
                         char *brackets = token;
                         char *new_brackets;
                         int len;
 
-                        field->flags |= FIELD_IS_ARRAY;
+                        field->flags |= TEP_FIELD_IS_ARRAY;
 
                         type = read_token(&token);
 
-                        if (type == EVENT_ITEM)
+                        if (type == TEP_EVENT_ITEM)
                                 field->arraylen = strtoul(token, NULL, 0);
                         else
                                 field->arraylen = 0;
 
                         while (strcmp(token, "]") != 0) {
-                                if (last_type == EVENT_ITEM &&
-                                    type == EVENT_ITEM)
+                                if (last_type == TEP_EVENT_ITEM &&
+                                    type == TEP_EVENT_ITEM)
                                         len = 2;
                                 else
                                         len = 1;
@@ -1486,7 +1488,7 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                 field->arraylen = strtoul(token, NULL, 0);
                                 free_token(token);
                                 type = read_token(&token);
-                                if (type == EVENT_NONE) {
+                                if (type == TEP_EVENT_NONE) {
                                         do_warning_event(event, "failed to find token");
                                         goto fail;
                                 }
@@ -1509,7 +1511,7 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                          * If the next token is not an OP, then it is of
                          * the format: type [] item;
                          */
-                        if (type == EVENT_ITEM) {
+                        if (type == TEP_EVENT_ITEM) {
                                 char *new_type;
                                 new_type = realloc(field->type,
                                                    strlen(field->type) +
@@ -1543,79 +1545,79 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                 }
 
                 if (field_is_string(field))
-                        field->flags |= FIELD_IS_STRING;
+                        field->flags |= TEP_FIELD_IS_STRING;
                 if (field_is_dynamic(field))
-                        field->flags |= FIELD_IS_DYNAMIC;
+                        field->flags |= TEP_FIELD_IS_DYNAMIC;
                 if (field_is_long(field))
-                        field->flags |= FIELD_IS_LONG;
+                        field->flags |= TEP_FIELD_IS_LONG;
 
-                if (test_type_token(type, token,  EVENT_OP, ";"))
+                if (test_type_token(type, token,  TEP_EVENT_OP, ";"))
                         goto fail;
                 free_token(token);
 
-                if (read_expected(EVENT_ITEM, "offset") < 0)
+                if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_OP, ":") < 0)
+                if (read_expected(TEP_EVENT_OP, ":") < 0)
                         goto fail_expect;
 
-                if (read_expect_type(EVENT_ITEM, &token))
+                if (read_expect_type(TEP_EVENT_ITEM, &token))
                         goto fail;
                 field->offset = strtoul(token, NULL, 0);
                 free_token(token);
 
-                if (read_expected(EVENT_OP, ";") < 0)
+                if (read_expected(TEP_EVENT_OP, ";") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_ITEM, "size") < 0)
+                if (read_expected(TEP_EVENT_ITEM, "size") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_OP, ":") < 0)
+                if (read_expected(TEP_EVENT_OP, ":") < 0)
                         goto fail_expect;
 
-                if (read_expect_type(EVENT_ITEM, &token))
+                if (read_expect_type(TEP_EVENT_ITEM, &token))
                         goto fail;
                 field->size = strtoul(token, NULL, 0);
                 free_token(token);
 
-                if (read_expected(EVENT_OP, ";") < 0)
+                if (read_expected(TEP_EVENT_OP, ";") < 0)
                         goto fail_expect;
 
                 type = read_token(&token);
-                if (type != EVENT_NEWLINE) {
+                if (type != TEP_EVENT_NEWLINE) {
                         /* newer versions of the kernel have a "signed" type */
-                        if (test_type_token(type, token, EVENT_ITEM, "signed"))
+                        if (test_type_token(type, token, TEP_EVENT_ITEM, "signed"))
                                 goto fail;
 
                         free_token(token);
 
-                        if (read_expected(EVENT_OP, ":") < 0)
+                        if (read_expected(TEP_EVENT_OP, ":") < 0)
                                 goto fail_expect;
 
-                        if (read_expect_type(EVENT_ITEM, &token))
+                        if (read_expect_type(TEP_EVENT_ITEM, &token))
                                 goto fail;
 
                         if (strtoul(token, NULL, 0))
-                                field->flags |= FIELD_IS_SIGNED;
+                                field->flags |= TEP_FIELD_IS_SIGNED;
 
                         free_token(token);
-                        if (read_expected(EVENT_OP, ";") < 0)
+                        if (read_expected(TEP_EVENT_OP, ";") < 0)
                                 goto fail_expect;
 
-                        if (read_expect_type(EVENT_NEWLINE, &token))
+                        if (read_expect_type(TEP_EVENT_NEWLINE, &token))
                                 goto fail;
                 }
 
                 free_token(token);
 
-                if (field->flags & FIELD_IS_ARRAY) {
+                if (field->flags & TEP_FIELD_IS_ARRAY) {
                         if (field->arraylen)
                                 field->elementsize = field->size / field->arraylen;
-                        else if (field->flags & FIELD_IS_DYNAMIC)
+                        else if (field->flags & TEP_FIELD_IS_DYNAMIC)
                                 field->elementsize = size_dynamic;
-                        else if (field->flags & FIELD_IS_STRING)
+                        else if (field->flags & TEP_FIELD_IS_STRING)
                                 field->elementsize = 1;
-                        else if (field->flags & FIELD_IS_LONG)
+                        else if (field->flags & TEP_FIELD_IS_LONG)
                                 field->elementsize = event->pevent ?
                                                      event->pevent->long_size :
                                                      sizeof(long);
@@ -1640,18 +1642,18 @@ fail_expect:
         return -1;
 }
 
-static int event_read_format(struct event_format *event)
+static int event_read_format(struct tep_event_format *event)
 {
         char *token;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, "format") < 0)
+        if (read_expected_item(TEP_EVENT_ITEM, "format") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return -1;
 
-        if (read_expect_type(EVENT_NEWLINE, &token))
+        if (read_expect_type(TEP_EVENT_NEWLINE, &token))
                 goto fail;
         free_token(token);
 
@@ -1672,14 +1674,14 @@ static int event_read_format(struct event_format *event)
         return -1;
 }
 
-static enum event_type
-process_arg_token(struct event_format *event, struct print_arg *arg,
-                  char **tok, enum event_type type);
+static enum tep_event_type
+process_arg_token(struct tep_event_format *event, struct tep_print_arg *arg,
+                  char **tok, enum tep_event_type type);
 
-static enum event_type
-process_arg(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_arg(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token;
 
         type = read_token(&token);
@@ -1688,32 +1690,32 @@ process_arg(struct event_format *event, struct print_arg *arg, char **tok)
         return process_arg_token(event, arg, tok, type);
 }
 
-static enum event_type
-process_op(struct event_format *event, struct print_arg *arg, char **tok);
+static enum tep_event_type
+process_op(struct tep_event_format *event, struct tep_print_arg *arg, char **tok);
 
 /*
  * For __print_symbolic() and __print_flags, we need to completely
  * evaluate the first argument, which defines what to print next.
  */
-static enum event_type
-process_field_arg(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_field_arg(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
 
         type = process_arg(event, arg, tok);
 
-        while (type == EVENT_OP) {
+        while (type == TEP_EVENT_OP) {
                 type = process_op(event, arg, tok);
         }
 
         return type;
 }
 
-static enum event_type
-process_cond(struct event_format *event, struct print_arg *top, char **tok)
+static enum tep_event_type
+process_cond(struct tep_event_format *event, struct tep_print_arg *top, char **tok)
 {
-        struct print_arg *arg, *left, *right;
-        enum event_type type;
+        struct tep_print_arg *arg, *left, *right;
+        enum tep_event_type type;
         char *token = NULL;
 
         arg = alloc_arg();
@@ -1728,7 +1730,7 @@ process_cond(struct event_format *event, struct print_arg *top, char **tok)
                 goto out_free;
         }
 
-        arg->type = PRINT_OP;
+        arg->type = TEP_PRINT_OP;
         arg->op.left = left;
         arg->op.right = right;
 
@@ -1736,16 +1738,16 @@ process_cond(struct event_format *event, struct print_arg *top, char **tok)
         type = process_arg(event, left, &token);
 
  again:
-        if (type == EVENT_ERROR)
+        if (type == TEP_EVENT_ERROR)
                 goto out_free;
 
         /* Handle other operations in the arguments */
-        if (type == EVENT_OP && strcmp(token, ":") != 0) {
+        if (type == TEP_EVENT_OP && strcmp(token, ":") != 0) {
                 type = process_op(event, left, &token);
                 goto again;
         }
 
-        if (test_type_token(type, token, EVENT_OP, ":"))
+        if (test_type_token(type, token, TEP_EVENT_OP, ":"))
                 goto out_free;
 
         arg->op.op = token;
@@ -1762,14 +1764,14 @@ out_free:
         top->op.right = NULL;
         free_token(token);
         free_arg(arg);
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_array(struct event_format *event, struct print_arg *top, char **tok)
+static enum tep_event_type
+process_array(struct tep_event_format *event, struct tep_print_arg *top, char **tok)
 {
-        struct print_arg *arg;
-        enum event_type type;
+        struct tep_print_arg *arg;
+        enum tep_event_type type;
         char *token = NULL;
 
         arg = alloc_arg();
@@ -1777,12 +1779,12 @@ process_array(struct event_format *event, struct print_arg *top, char **tok)
                 do_warning_event(event, "%s: not enough memory!", __func__);
                 /* '*tok' is set to top->op.op.  No need to free. */
                 *tok = NULL;
-                return EVENT_ERROR;
+                return TEP_EVENT_ERROR;
         }
 
         *tok = NULL;
         type = process_arg(event, arg, &token);
-        if (test_type_token(type, token, EVENT_OP, "]"))
+        if (test_type_token(type, token, TEP_EVENT_OP, "]"))
                 goto out_free;
 
         top->op.right = arg;
@@ -1796,7 +1798,7 @@ process_array(struct event_format *event, struct print_arg *top, char **tok)
 out_free:
         free_token(token);
         free_arg(arg);
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
 static int get_op_prio(char *op)
@@ -1854,11 +1856,11 @@ static int get_op_prio(char *op)
         }
 }
 
-static int set_op_prio(struct print_arg *arg)
+static int set_op_prio(struct tep_print_arg *arg)
 {
 
         /* single ops are the greatest */
-        if (!arg->op.left || arg->op.left->type == PRINT_NULL)
+        if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
                 arg->op.prio = 0;
         else
                 arg->op.prio = get_op_prio(arg->op.op);
@@ -1867,17 +1869,17 @@ static int set_op_prio(struct print_arg *arg)
 }
 
 /* Note, *tok does not get freed, but will most likely be saved */
-static enum event_type
-process_op(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_op(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        struct print_arg *left, *right = NULL;
-        enum event_type type;
+        struct tep_print_arg *left, *right = NULL;
+        enum tep_event_type type;
         char *token;
 
         /* the op is passed in via tok */
         token = *tok;
 
-        if (arg->type == PRINT_OP && !arg->op.left) {
+        if (arg->type == TEP_PRINT_OP && !arg->op.left) {
                 /* handle single op */
                 if (token[1]) {
                         do_warning_event(event, "bad op token %s", token);
@@ -1900,7 +1902,7 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
                 if (!left)
                         goto out_warn_free;
 
-                left->type = PRINT_NULL;
+                left->type = TEP_PRINT_NULL;
                 arg->op.left = left;
 
                 right = alloc_arg();
@@ -1922,7 +1924,7 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
                 /* copy the top arg to the left */
                 *left = *arg;
 
-                arg->type = PRINT_OP;
+                arg->type = TEP_PRINT_OP;
                 arg->op.op = token;
                 arg->op.left = left;
                 arg->op.prio = 0;
@@ -1956,13 +1958,13 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
                 /* copy the top arg to the left */
                 *left = *arg;
 
-                arg->type = PRINT_OP;
+                arg->type = TEP_PRINT_OP;
                 arg->op.op = token;
                 arg->op.left = left;
                 arg->op.right = NULL;
 
                 if (set_op_prio(arg) == -1) {
-                        event->flags |= EVENT_FL_FAILED;
+                        event->flags |= TEP_EVENT_FL_FAILED;
                         /* arg->op.op (= token) will be freed at out_free */
                         arg->op.op = NULL;
                         goto out_free;
@@ -1973,10 +1975,10 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
 
                 /* could just be a type pointer */
                 if ((strcmp(arg->op.op, "*") == 0) &&
-                    type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
+                    type == TEP_EVENT_DELIM && (strcmp(token, ")") == 0)) {
                         char *new_atom;
 
-                        if (left->type != PRINT_ATOM) {
+                        if (left->type != TEP_PRINT_ATOM) {
                                 do_warning_event(event, "bad pointer type");
                                 goto out_free;
                         }
@@ -1999,16 +2001,16 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
                         goto out_warn_free;
 
                 type = process_arg_token(event, right, tok, type);
-                if (type == EVENT_ERROR) {
+                if (type == TEP_EVENT_ERROR) {
                         free_arg(right);
                         /* token was freed in process_arg_token() via *tok */
                         token = NULL;
                         goto out_free;
                 }
 
-                if (right->type == PRINT_OP &&
+                if (right->type == TEP_PRINT_OP &&
                     get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
-                        struct print_arg tmp;
+                        struct tep_print_arg tmp;
 
                         /* rotate ops according to the priority */
                         arg->op.right = right->op.left;
@@ -2030,7 +2032,7 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
 
                 *left = *arg;
 
-                arg->type = PRINT_OP;
+                arg->type = TEP_PRINT_OP;
                 arg->op.op = token;
                 arg->op.left = left;
 
@@ -2041,12 +2043,12 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
 
         } else {
                 do_warning_event(event, "unknown op '%s'", token);
-                event->flags |= EVENT_FL_FAILED;
+                event->flags |= TEP_EVENT_FL_FAILED;
                 /* the arg is now the left side */
                 goto out_free;
         }
 
-        if (type == EVENT_OP && strcmp(*tok, ":") != 0) {
+        if (type == TEP_EVENT_OP && strcmp(*tok, ":") != 0) {
                 int prio;
 
                 /* higher prios need to be closer to the root */
@@ -2065,34 +2067,34 @@ out_warn_free:
 out_free:
         free_token(token);
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_entry(struct event_format *event __maybe_unused, struct print_arg *arg,
+static enum tep_event_type
+process_entry(struct tep_event_format *event __maybe_unused, struct tep_print_arg *arg,
               char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *field;
         char *token;
 
-        if (read_expected(EVENT_OP, "->") < 0)
+        if (read_expected(TEP_EVENT_OP, "->") < 0)
                 goto out_err;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto out_free;
         field = token;
 
-        arg->type = PRINT_FIELD;
+        arg->type = TEP_PRINT_FIELD;
         arg->field.name = field;
 
         if (is_flag_field) {
                 arg->field.field = tep_find_any_field(event, arg->field.name);
-                arg->field.field->flags |= FIELD_IS_FLAG;
+                arg->field.field->flags |= TEP_FIELD_IS_FLAG;
                 is_flag_field = 0;
         } else if (is_symbolic_field) {
                 arg->field.field = tep_find_any_field(event, arg->field.name);
-                arg->field.field->flags |= FIELD_IS_SYMBOLIC;
+                arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
                 is_symbolic_field = 0;
         }
 
@@ -2105,14 +2107,14 @@ process_entry(struct event_format *event __maybe_unused, struct print_arg *arg,
         free_token(token);
  out_err:
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static int alloc_and_process_delim(struct event_format *event, char *next_token,
-                                   struct print_arg **print_arg)
+static int alloc_and_process_delim(struct tep_event_format *event, char *next_token,
+                                   struct tep_print_arg **print_arg)
 {
-        struct print_arg *field;
-        enum event_type type;
+        struct tep_print_arg *field;
+        enum tep_event_type type;
         char *token;
         int ret = 0;
 
@@ -2125,7 +2127,7 @@ static int alloc_and_process_delim(struct event_format *event, char *next_token,
 
         type = process_arg(event, field, &token);
 
-        if (test_type_token(type, token, EVENT_DELIM, next_token)) {
+        if (test_type_token(type, token, TEP_EVENT_DELIM, next_token)) {
                 errno = EINVAL;
                 ret = -1;
                 free_arg(field);
@@ -2140,7 +2142,7 @@ out_free_token:
         return ret;
 }
 
-static char *arg_eval (struct print_arg *arg);
+static char *arg_eval (struct tep_print_arg *arg);
 
 static unsigned long long
 eval_type_str(unsigned long long val, const char *type, int pointer)
@@ -2237,9 +2239,9 @@ eval_type_str(unsigned long long val, const char *type, int pointer)
  * Try to figure out the type.
  */
 static unsigned long long
-eval_type(unsigned long long val, struct print_arg *arg, int pointer)
+eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
 {
-        if (arg->type != PRINT_TYPE) {
+        if (arg->type != TEP_PRINT_TYPE) {
                 do_warning("expected type argument");
                 return 0;
         }
@@ -2247,22 +2249,22 @@ eval_type(unsigned long long val, struct print_arg *arg, int pointer)
         return eval_type_str(val, arg->typecast.type, pointer);
 }
 
-static int arg_num_eval(struct print_arg *arg, long long *val)
+static int arg_num_eval(struct tep_print_arg *arg, long long *val)
 {
         long long left, right;
         int ret = 1;
 
         switch (arg->type) {
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 *val = strtoll(arg->atom.atom, NULL, 0);
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 ret = arg_num_eval(arg->typecast.item, val);
                 if (!ret)
                         break;
                 *val = eval_type(*val, arg, 0);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 switch (arg->op.op[0]) {
                 case '|':
                         ret = arg_num_eval(arg->op.left, &left);
@@ -2365,7 +2367,7 @@ static int arg_num_eval(struct print_arg *arg, long long *val)
                         break;
                 case '-':
                         /* check for negative */
-                        if (arg->op.left->type == PRINT_NULL)
+                        if (arg->op.left->type == TEP_PRINT_NULL)
                                 left = 0;
                         else
                                 ret = arg_num_eval(arg->op.left, &left);
@@ -2377,7 +2379,7 @@ static int arg_num_eval(struct print_arg *arg, long long *val)
                         *val = left - right;
                         break;
                 case '+':
-                        if (arg->op.left->type == PRINT_NULL)
+                        if (arg->op.left->type == TEP_PRINT_NULL)
                                 left = 0;
                         else
                                 ret = arg_num_eval(arg->op.left, &left);
@@ -2400,11 +2402,11 @@ static int arg_num_eval(struct print_arg *arg, long long *val)
                 }
                 break;
 
-        case PRINT_NULL:
-        case PRINT_FIELD ... PRINT_SYMBOL:
-        case PRINT_STRING:
-        case PRINT_BSTRING:
-        case PRINT_BITMASK:
+        case TEP_PRINT_NULL:
+        case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_BITMASK:
         default:
                 do_warning("invalid eval type %d", arg->type);
                 ret = 0;
@@ -2413,27 +2415,27 @@ static int arg_num_eval(struct print_arg *arg, long long *val)
         return ret;
 }
 
-static char *arg_eval (struct print_arg *arg)
+static char *arg_eval (struct tep_print_arg *arg)
 {
         long long val;
         static char buf[20];
 
         switch (arg->type) {
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 return arg->atom.atom;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 return arg_eval(arg->typecast.item);
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (!arg_num_eval(arg, &val))
                         break;
                 sprintf(buf, "%lld", val);
                 return buf;
 
-        case PRINT_NULL:
-        case PRINT_FIELD ... PRINT_SYMBOL:
-        case PRINT_STRING:
-        case PRINT_BSTRING:
-        case PRINT_BITMASK:
+        case TEP_PRINT_NULL:
+        case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_BITMASK:
         default:
                 do_warning("invalid eval type %d", arg->type);
                 break;
@@ -2442,19 +2444,19 @@ static char *arg_eval (struct print_arg *arg)
         return NULL;
 }
 
-static enum event_type
-process_fields(struct event_format *event, struct print_flag_sym **list, char **tok)
+static enum tep_event_type
+process_fields(struct tep_event_format *event, struct tep_print_flag_sym **list, char **tok)
 {
-        enum event_type type;
-        struct print_arg *arg = NULL;
-        struct print_flag_sym *field;
+        enum tep_event_type type;
+        struct tep_print_arg *arg = NULL;
+        struct tep_print_flag_sym *field;
         char *token = *tok;
         char *value;
 
         do {
                 free_token(token);
                 type = read_token_item(&token);
-                if (test_type_token(type, token, EVENT_OP, "{"))
+                if (test_type_token(type, token, TEP_EVENT_OP, "{"))
                         break;
 
                 arg = alloc_arg();
@@ -2464,13 +2466,13 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                 free_token(token);
                 type = process_arg(event, arg, &token);
 
-                if (type == EVENT_OP)
+                if (type == TEP_EVENT_OP)
                         type = process_op(event, arg, &token);
 
-                if (type == EVENT_ERROR)
+                if (type == TEP_EVENT_ERROR)
                         goto out_free;
 
-                if (test_type_token(type, token, EVENT_DELIM, ","))
+                if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
                         goto out_free;
 
                 field = calloc(1, sizeof(*field));
@@ -2491,7 +2493,7 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
 
                 free_token(token);
                 type = process_arg(event, arg, &token);
-                if (test_type_token(type, token, EVENT_OP, "}"))
+                if (test_type_token(type, token, TEP_EVENT_OP, "}"))
                         goto out_free_field;
 
                 value = arg_eval(arg);
@@ -2508,7 +2510,7 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
 
                 free_token(token);
                 type = read_token_item(&token);
-        } while (type == EVENT_DELIM && strcmp(token, ",") == 0);
+        } while (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0);
 
         *tok = token;
         return type;
@@ -2520,18 +2522,18 @@ out_free:
         free_token(token);
         *tok = NULL;
 
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_flags(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_flags(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        struct print_arg *field;
-        enum event_type type;
+        struct tep_print_arg *field;
+        enum tep_event_type type;
         char *token = NULL;
 
         memset(arg, 0, sizeof(*arg));
-        arg->type = PRINT_FLAGS;
+        arg->type = TEP_PRINT_FLAGS;
 
         field = alloc_arg();
         if (!field) {
@@ -2542,10 +2544,10 @@ process_flags(struct event_format *event, struct print_arg *arg, char **tok)
         type = process_field_arg(event, field, &token);
 
         /* Handle operations in the first argument */
-        while (type == EVENT_OP)
+        while (type == TEP_EVENT_OP)
                 type = process_op(event, field, &token);
 
-        if (test_type_token(type, token, EVENT_DELIM, ","))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
                 goto out_free_field;
         free_token(token);
 
@@ -2557,11 +2559,11 @@ process_flags(struct event_format *event, struct print_arg *arg, char **tok)
                 type = read_token_item(&token);
         }
 
-        if (test_type_token(type, token, EVENT_DELIM, ","))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
                 goto out_free;
 
         type = process_fields(event, &arg->flags.flags, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -2573,18 +2575,18 @@ out_free_field:
 out_free:
         free_token(token);
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_symbols(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_symbols(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        struct print_arg *field;
-        enum event_type type;
+        struct tep_print_arg *field;
+        enum tep_event_type type;
         char *token = NULL;
 
         memset(arg, 0, sizeof(*arg));
-        arg->type = PRINT_SYMBOL;
+        arg->type = TEP_PRINT_SYMBOL;
 
         field = alloc_arg();
         if (!field) {
@@ -2594,13 +2596,13 @@ process_symbols(struct event_format *event, struct print_arg *arg, char **tok)
 
         type = process_field_arg(event, field, &token);
 
-        if (test_type_token(type, token, EVENT_DELIM, ","))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
                 goto out_free_field;
 
         arg->symbol.field = field;
 
         type = process_fields(event, &arg->symbol.symbols, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -2612,12 +2614,12 @@ out_free_field:
 out_free:
         free_token(token);
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_hex_common(struct event_format *event, struct print_arg *arg,
-                   char **tok, enum print_arg_type type)
+static enum tep_event_type
+process_hex_common(struct tep_event_format *event, struct tep_print_arg *arg,
+                   char **tok, enum tep_print_arg_type type)
 {
         memset(arg, 0, sizeof(*arg));
         arg->type = type;
@@ -2635,27 +2637,27 @@ free_field:
         arg->hex.field = NULL;
 out:
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_hex(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_hex(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        return process_hex_common(event, arg, tok, PRINT_HEX);
+        return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
 }
 
-static enum event_type
-process_hex_str(struct event_format *event, struct print_arg *arg,
+static enum tep_event_type
+process_hex_str(struct tep_event_format *event, struct tep_print_arg *arg,
                 char **tok)
 {
-        return process_hex_common(event, arg, tok, PRINT_HEX_STR);
+        return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
 }
 
-static enum event_type
-process_int_array(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_int_array(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
         memset(arg, 0, sizeof(*arg));
-        arg->type = PRINT_INT_ARRAY;
+        arg->type = TEP_PRINT_INT_ARRAY;
 
         if (alloc_and_process_delim(event, ",", &arg->int_array.field))
                 goto out;
@@ -2676,18 +2678,18 @@ free_field:
         arg->int_array.field = NULL;
 out:
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_dynamic_array(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_dynamic_array(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        struct format_field *field;
-        enum event_type type;
+        struct tep_format_field *field;
+        enum tep_event_type type;
         char *token;
 
         memset(arg, 0, sizeof(*arg));
-        arg->type = PRINT_DYNAMIC_ARRAY;
+        arg->type = TEP_PRINT_DYNAMIC_ARRAY;
 
         /*
          * The item within the parenthesis is another field that holds
@@ -2695,7 +2697,7 @@ process_dynamic_array(struct event_format *event, struct print_arg *arg, char **
          */
         type = read_token(&token);
         *tok = token;
-        if (type != EVENT_ITEM)
+        if (type != TEP_EVENT_ITEM)
                 goto out_free;
 
         /* Find the field */
@@ -2707,13 +2709,13 @@ process_dynamic_array(struct event_format *event, struct print_arg *arg, char **
         arg->dynarray.field = field;
         arg->dynarray.index = 0;
 
-        if (read_expected(EVENT_DELIM, ")") < 0)
+        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
                 goto out_free;
 
         free_token(token);
         type = read_token_item(&token);
         *tok = token;
-        if (type != EVENT_OP || strcmp(token, "[") != 0)
+        if (type != TEP_EVENT_OP || strcmp(token, "[") != 0)
                 return type;
 
         free_token(token);
@@ -2721,14 +2723,14 @@ process_dynamic_array(struct event_format *event, struct print_arg *arg, char **
         if (!arg) {
                 do_warning_event(event, "%s: not enough memory!", __func__);
                 *tok = NULL;
-                return EVENT_ERROR;
+                return TEP_EVENT_ERROR;
         }
 
         type = process_arg(event, arg, &token);
-        if (type == EVENT_ERROR)
+        if (type == TEP_EVENT_ERROR)
                 goto out_free_arg;
 
-        if (!test_type_token(type, token, EVENT_OP, "]"))
+        if (!test_type_token(type, token, TEP_EVENT_OP, "]"))
                 goto out_free_arg;
 
         free_token(token);
@@ -2740,21 +2742,21 @@ process_dynamic_array(struct event_format *event, struct print_arg *arg, char **
  out_free:
         free_token(token);
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_dynamic_array_len(struct event_format *event, struct print_arg *arg,
+static enum tep_event_type
+process_dynamic_array_len(struct tep_event_format *event, struct tep_print_arg *arg,
                           char **tok)
 {
-        struct format_field *field;
-        enum event_type type;
+        struct tep_format_field *field;
+        enum tep_event_type type;
         char *token;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto out_free;
 
-        arg->type = PRINT_DYNAMIC_ARRAY_LEN;
+        arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
 
         /* Find the field */
         field = tep_find_field(event, token);
@@ -2764,7 +2766,7 @@ process_dynamic_array_len(struct event_format *event, struct print_arg *arg,
         arg->dynarray.field = field;
         arg->dynarray.index = 0;
 
-        if (read_expected(EVENT_DELIM, ")") < 0)
+        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
                 goto out_err;
 
         type = read_token(&token);
@@ -2776,28 +2778,28 @@ process_dynamic_array_len(struct event_format *event, struct print_arg *arg,
         free_token(token);
  out_err:
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_paren(struct event_format *event, struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_paren(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
 {
-        struct print_arg *item_arg;
-        enum event_type type;
+        struct tep_print_arg *item_arg;
+        enum tep_event_type type;
         char *token;
 
         type = process_arg(event, arg, &token);
 
-        if (type == EVENT_ERROR)
+        if (type == TEP_EVENT_ERROR)
                 goto out_free;
 
-        if (type == EVENT_OP)
+        if (type == TEP_EVENT_OP)
                 type = process_op(event, arg, &token);
 
-        if (type == EVENT_ERROR)
+        if (type == TEP_EVENT_ERROR)
                 goto out_free;
 
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -2808,13 +2810,13 @@ process_paren(struct event_format *event, struct print_arg *arg, char **tok)
          * this was a typecast.
          */
         if (event_item_type(type) ||
-            (type == EVENT_DELIM && strcmp(token, "(") == 0)) {
+            (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0)) {
 
                 /* make this a typecast and contine */
 
                 /* prevous must be an atom */
-                if (arg->type != PRINT_ATOM) {
-                        do_warning_event(event, "previous needed to be PRINT_ATOM");
+                if (arg->type != TEP_PRINT_ATOM) {
+                        do_warning_event(event, "previous needed to be TEP_PRINT_ATOM");
                         goto out_free;
                 }
 
@@ -2825,7 +2827,7 @@ process_paren(struct event_format *event, struct print_arg *arg, char **tok)
                         goto out_free;
                 }
 
-                arg->type = PRINT_TYPE;
+                arg->type = TEP_PRINT_TYPE;
                 arg->typecast.type = arg->atom.atom;
                 arg->typecast.item = item_arg;
                 type = process_arg_token(event, item_arg, &token, type);
@@ -2838,25 +2840,25 @@ process_paren(struct event_format *event, struct print_arg *arg, char **tok)
  out_free:
         free_token(token);
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
 
-static enum event_type
-process_str(struct event_format *event __maybe_unused, struct print_arg *arg,
+static enum tep_event_type
+process_str(struct tep_event_format *event __maybe_unused, struct tep_print_arg *arg,
             char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto out_free;
 
-        arg->type = PRINT_STRING;
+        arg->type = TEP_PRINT_STRING;
         arg->string.string = token;
         arg->string.offset = -1;
 
-        if (read_expected(EVENT_DELIM, ")") < 0)
+        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
                 goto out_err;
 
         type = read_token(&token);
@@ -2868,24 +2870,24 @@ process_str(struct event_format *event __maybe_unused, struct print_arg *arg,
         free_token(token);
  out_err:
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_bitmask(struct event_format *event __maybe_unused, struct print_arg *arg,
-            char **tok)
+static enum tep_event_type
+process_bitmask(struct tep_event_format *event __maybe_unused, struct tep_print_arg *arg,
+                char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto out_free;
 
-        arg->type = PRINT_BITMASK;
+        arg->type = TEP_PRINT_BITMASK;
         arg->bitmask.bitmask = token;
         arg->bitmask.offset = -1;
 
-        if (read_expected(EVENT_DELIM, ")") < 0)
+        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
                 goto out_err;
 
         type = read_token(&token);
@@ -2897,7 +2899,7 @@ process_bitmask(struct event_format *event __maybe_unused, struct print_arg *arg
         free_token(token);
  out_err:
         *tok = NULL;
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
 static struct tep_function_handler *
@@ -2932,17 +2934,17 @@ static void remove_func_handler(struct tep_handle *pevent, char *func_name)
         }
 }
 
-static enum event_type
-process_func_handler(struct event_format *event, struct tep_function_handler *func,
-                     struct print_arg *arg, char **tok)
+static enum tep_event_type
+process_func_handler(struct tep_event_format *event, struct tep_function_handler *func,
+                     struct tep_print_arg *arg, char **tok)
 {
-        struct print_arg **next_arg;
-        struct print_arg *farg;
-        enum event_type type;
+        struct tep_print_arg **next_arg;
+        struct tep_print_arg *farg;
+        enum tep_event_type type;
         char *token;
         int i;
 
-        arg->type = PRINT_FUNC;
+        arg->type = TEP_PRINT_FUNC;
         arg->func.func = func;
 
         *tok = NULL;
@@ -2953,12 +2955,12 @@ process_func_handler(struct event_format *event, struct tep_function_handler *fu
                 if (!farg) {
                         do_warning_event(event, "%s: not enough memory!",
                                          __func__);
-                        return EVENT_ERROR;
+                        return TEP_EVENT_ERROR;
                 }
 
                 type = process_arg(event, farg, &token);
                 if (i < (func->nr_args - 1)) {
-                        if (type != EVENT_DELIM || strcmp(token, ",") != 0) {
+                        if (type != TEP_EVENT_DELIM || strcmp(token, ",") != 0) {
                                 do_warning_event(event,
                                         "Error: function '%s()' expects %d arguments but event %s only uses %d",
                                         func->name, func->nr_args,
@@ -2966,7 +2968,7 @@ process_func_handler(struct event_format *event, struct tep_function_handler *fu
                                 goto err;
                         }
                 } else {
-                        if (type != EVENT_DELIM || strcmp(token, ")") != 0) {
+                        if (type != TEP_EVENT_DELIM || strcmp(token, ")") != 0) {
                                 do_warning_event(event,
                                         "Error: function '%s()' only expects %d arguments but event %s has more",
                                         func->name, func->nr_args, event->name);
@@ -2987,11 +2989,11 @@ process_func_handler(struct event_format *event, struct tep_function_handler *fu
 err:
         free_arg(farg);
         free_token(token);
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_function(struct event_format *event, struct print_arg *arg,
+static enum tep_event_type
+process_function(struct tep_event_format *event, struct tep_print_arg *arg,
                  char *token, char **tok)
 {
         struct tep_function_handler *func;
@@ -3043,12 +3045,12 @@ process_function(struct event_format *event, struct print_arg *arg,
 
         do_warning_event(event, "function %s not defined", token);
         free_token(token);
-        return EVENT_ERROR;
+        return TEP_EVENT_ERROR;
 }
 
-static enum event_type
-process_arg_token(struct event_format *event, struct print_arg *arg,
-                  char **tok, enum event_type type)
+static enum tep_event_type
+process_arg_token(struct tep_event_format *event, struct tep_print_arg *arg,
+                  char **tok, enum tep_event_type type)
 {
         char *token;
         char *atom;
@@ -3056,7 +3058,7 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
         token = *tok;
 
         switch (type) {
-        case EVENT_ITEM:
+        case TEP_EVENT_ITEM:
                 if (strcmp(token, "REC") == 0) {
                         free_token(token);
                         type = process_entry(event, arg, &token);
@@ -3070,7 +3072,7 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
                  * If the next token is a parenthesis, then this
                  * is a function.
                  */
-                if (type == EVENT_DELIM && strcmp(token, "(") == 0) {
+                if (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0) {
                         free_token(token);
                         token = NULL;
                         /* this will free atom. */
@@ -3078,7 +3080,7 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
                         break;
                 }
                 /* atoms can be more than one token long */
-                while (type == EVENT_ITEM) {
+                while (type == TEP_EVENT_ITEM) {
                         char *new_atom;
                         new_atom = realloc(atom,
                                            strlen(atom) + strlen(token) + 2);
@@ -3086,7 +3088,7 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
                                 free(atom);
                                 *tok = NULL;
                                 free_token(token);
-                                return EVENT_ERROR;
+                                return TEP_EVENT_ERROR;
                         }
                         atom = new_atom;
                         strcat(atom, " ");
@@ -3095,55 +3097,55 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
                         type = read_token_item(&token);
                 }
 
-                arg->type = PRINT_ATOM;
+                arg->type = TEP_PRINT_ATOM;
                 arg->atom.atom = atom;
                 break;
 
-        case EVENT_DQUOTE:
-        case EVENT_SQUOTE:
-                arg->type = PRINT_ATOM;
+        case TEP_EVENT_DQUOTE:
+        case TEP_EVENT_SQUOTE:
+                arg->type = TEP_PRINT_ATOM;
                 arg->atom.atom = token;
                 type = read_token_item(&token);
                 break;
-        case EVENT_DELIM:
+        case TEP_EVENT_DELIM:
                 if (strcmp(token, "(") == 0) {
                         free_token(token);
                         type = process_paren(event, arg, &token);
                         break;
                 }
-        case EVENT_OP:
+        case TEP_EVENT_OP:
                 /* handle single ops */
-                arg->type = PRINT_OP;
+                arg->type = TEP_PRINT_OP;
                 arg->op.op = token;
                 arg->op.left = NULL;
                 type = process_op(event, arg, &token);
 
                 /* On error, the op is freed */
-                if (type == EVENT_ERROR)
+                if (type == TEP_EVENT_ERROR)
                         arg->op.op = NULL;
 
                 /* return error type if errored */
                 break;
 
-        case EVENT_ERROR ... EVENT_NEWLINE:
+        case TEP_EVENT_ERROR ... TEP_EVENT_NEWLINE:
         default:
                 do_warning_event(event, "unexpected type %d", type);
-                return EVENT_ERROR;
+                return TEP_EVENT_ERROR;
         }
         *tok = token;
 
         return type;
 }
 
-static int event_read_print_args(struct event_format *event, struct print_arg **list)
+static int event_read_print_args(struct tep_event_format *event, struct tep_print_arg **list)
 {
-        enum event_type type = EVENT_ERROR;
-        struct print_arg *arg;
+        enum tep_event_type type = TEP_EVENT_ERROR;
+        struct tep_print_arg *arg;
         char *token;
         int args = 0;
 
         do {
-                if (type == EVENT_NEWLINE) {
+                if (type == TEP_EVENT_NEWLINE) {
                         type = read_token_item(&token);
                         continue;
                 }
@@ -3157,7 +3159,7 @@ static int event_read_print_args(struct event_format *event, struct print_arg **
 
                 type = process_arg(event, arg, &token);
 
-                if (type == EVENT_ERROR) {
+                if (type == TEP_EVENT_ERROR) {
                         free_token(token);
                         free_arg(arg);
                         return -1;
@@ -3166,10 +3168,10 @@ static int event_read_print_args(struct event_format *event, struct print_arg **
                 *list = arg;
                 args++;
 
-                if (type == EVENT_OP) {
+                if (type == TEP_EVENT_OP) {
                         type = process_op(event, arg, &token);
                         free_token(token);
-                        if (type == EVENT_ERROR) {
+                        if (type == TEP_EVENT_ERROR) {
                                 *list = NULL;
                                 free_arg(arg);
                                 return -1;
@@ -3178,37 +3180,37 @@ static int event_read_print_args(struct event_format *event, struct print_arg **
                         continue;
                 }
 
-                if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
+                if (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0) {
                         free_token(token);
                         *list = arg;
                         list = &arg->next;
                         continue;
                 }
                 break;
-        } while (type != EVENT_NONE);
+        } while (type != TEP_EVENT_NONE);
 
-        if (type != EVENT_NONE && type != EVENT_ERROR)
+        if (type != TEP_EVENT_NONE && type != TEP_EVENT_ERROR)
                 free_token(token);
 
         return args;
 }
 
-static int event_read_print(struct event_format *event)
+static int event_read_print(struct tep_event_format *event)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, "print") < 0)
+        if (read_expected_item(TEP_EVENT_ITEM, "print") < 0)
                 return -1;
 
-        if (read_expected(EVENT_ITEM, "fmt") < 0)
+        if (read_expected(TEP_EVENT_ITEM, "fmt") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return -1;
 
-        if (read_expect_type(EVENT_DQUOTE, &token) < 0)
+        if (read_expect_type(TEP_EVENT_DQUOTE, &token) < 0)
                 goto fail;
 
  concat:
@@ -3218,11 +3220,11 @@ static int event_read_print(struct event_format *event)
         /* ok to have no arg */
         type = read_token_item(&token);
 
-        if (type == EVENT_NONE)
+        if (type == TEP_EVENT_NONE)
                 return 0;
 
         /* Handle concatenation of print lines */
-        if (type == EVENT_DQUOTE) {
+        if (type == TEP_EVENT_DQUOTE) {
                 char *cat;
 
                 if (asprintf(&cat, "%s%s", event->print_fmt.format, token) < 0)
@@ -3234,7 +3236,7 @@ static int event_read_print(struct event_format *event)
                 goto concat;
         }
                              
-        if (test_type_token(type, token, EVENT_DELIM, ","))
+        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
                 goto fail;
 
         free_token(token);
@@ -3258,10 +3260,10 @@ static int event_read_print(struct event_format *event)
  * Returns a common field from the event by the given @name.
  * This only searchs the common fields and not all field.
  */
-struct format_field *
-tep_find_common_field(struct event_format *event, const char *name)
+struct tep_format_field *
+tep_find_common_field(struct tep_event_format *event, const char *name)
 {
-        struct format_field *format;
+        struct tep_format_field *format;
 
         for (format = event->format.common_fields;
              format; format = format->next) {
@@ -3280,10 +3282,10 @@ tep_find_common_field(struct event_format *event, const char *name)
  * Returns a non-common field by the given @name.
  * This does not search common fields.
  */
-struct format_field *
-tep_find_field(struct event_format *event, const char *name)
+struct tep_format_field *
+tep_find_field(struct tep_event_format *event, const char *name)
 {
-        struct format_field *format;
+        struct tep_format_field *format;
 
         for (format = event->format.fields;
              format; format = format->next) {
@@ -3303,10 +3305,10 @@ tep_find_field(struct event_format *event, const char *name)
  * This searchs the common field names first, then
  * the non-common ones if a common one was not found.
  */
-struct format_field *
-tep_find_any_field(struct event_format *event, const char *name)
+struct tep_format_field *
+tep_find_any_field(struct tep_event_format *event, const char *name)
 {
-        struct format_field *format;
+        struct tep_format_field *format;
 
         format = tep_find_common_field(event, name);
         if (format)
@@ -3330,11 +3332,11 @@ unsigned long long tep_read_number(struct tep_handle *pevent,
         case 1:
                 return *(unsigned char *)ptr;
         case 2:
-                return data2host2(pevent, ptr);
+                return tep_data2host2(pevent, ptr);
         case 4:
-                return data2host4(pevent, ptr);
+                return tep_data2host4(pevent, ptr);
         case 8:
-                return data2host8(pevent, ptr);
+                return tep_data2host8(pevent, ptr);
         default:
                 /* BUG! */
                 return 0;
@@ -3352,7 +3354,7 @@ unsigned long long tep_read_number(struct tep_handle *pevent,
  *
  * Returns 0 on success, -1 otherwise.
  */
-int tep_read_number_field(struct format_field *field, const void *data,
+int tep_read_number_field(struct tep_format_field *field, const void *data,
                           unsigned long long *value)
 {
         if (!field)
@@ -3373,8 +3375,8 @@ int tep_read_number_field(struct format_field *field, const void *data,
 static int get_common_info(struct tep_handle *pevent,
                            const char *type, int *offset, int *size)
 {
-        struct event_format *event;
-        struct format_field *field;
+        struct tep_event_format *event;
+        struct tep_format_field *field;
 
         /*
          * All events should have the same common elements.
@@ -3460,11 +3462,11 @@ static int events_id_cmp(const void *a, const void *b);
  *
  * Returns an event that has a given @id.
  */
-struct event_format *tep_find_event(struct tep_handle *pevent, int id)
+struct tep_event_format *tep_find_event(struct tep_handle *pevent, int id)
 {
-        struct event_format **eventptr;
-        struct event_format key;
-        struct event_format *pkey = &key;
+        struct tep_event_format **eventptr;
+        struct tep_event_format key;
+        struct tep_event_format *pkey = &key;
 
         /* Check cache first */
         if (pevent->last_event && pevent->last_event->id == id)
@@ -3492,11 +3494,11 @@ struct event_format *tep_find_event(struct tep_handle *pevent, int id)
  * This returns an event with a given @name and under the system
  * @sys. If @sys is NULL the first event with @name is returned.
  */
-struct event_format *
+struct tep_event_format *
 tep_find_event_by_name(struct tep_handle *pevent,
                        const char *sys, const char *name)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         int i;
 
         if (pevent->last_event &&
@@ -3521,23 +3523,23 @@ tep_find_event_by_name(struct tep_handle *pevent,
 }
 
 static unsigned long long
-eval_num_arg(void *data, int size, struct event_format *event, struct print_arg *arg)
+eval_num_arg(void *data, int size, struct tep_event_format *event, struct tep_print_arg *arg)
 {
         struct tep_handle *pevent = event->pevent;
         unsigned long long val = 0;
         unsigned long long left, right;
-        struct print_arg *typearg = NULL;
-        struct print_arg *larg;
+        struct tep_print_arg *typearg = NULL;
+        struct tep_print_arg *larg;
         unsigned long offset;
         unsigned int field_size;
 
         switch (arg->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 /* ?? */
                 return 0;
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 return strtoull(arg->atom.atom, NULL, 0);
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 if (!arg->field.field) {
                         arg->field.field = tep_find_any_field(event, arg->field.name);
                         if (!arg->field.field)
@@ -3548,27 +3550,27 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                 val = tep_read_number(pevent, data + arg->field.field->offset,
                                       arg->field.field->size);
                 break;
-        case PRINT_FLAGS:
-        case PRINT_SYMBOL:
-        case PRINT_INT_ARRAY:
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
+        case TEP_PRINT_FLAGS:
+        case TEP_PRINT_SYMBOL:
+        case TEP_PRINT_INT_ARRAY:
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 val = eval_num_arg(data, size, event, arg->typecast.item);
                 return eval_type(val, arg, 0);
-        case PRINT_STRING:
-        case PRINT_BSTRING:
-        case PRINT_BITMASK:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_BITMASK:
                 return 0;
-        case PRINT_FUNC: {
+        case TEP_PRINT_FUNC: {
                 struct trace_seq s;
                 trace_seq_init(&s);
                 val = process_defined_func(&s, data, size, event, arg);
                 trace_seq_destroy(&s);
                 return val;
         }
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (strcmp(arg->op.op, "[") == 0) {
                         /*
                          * Arrays are special, since we don't want
@@ -3578,7 +3580,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
 
                         /* handle typecasts */
                         larg = arg->op.left;
-                        while (larg->type == PRINT_TYPE) {
+                        while (larg->type == TEP_PRINT_TYPE) {
                                 if (!typearg)
                                         typearg = larg;
                                 larg = larg->typecast.item;
@@ -3588,7 +3590,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                         field_size = pevent->long_size;
 
                         switch (larg->type) {
-                        case PRINT_DYNAMIC_ARRAY:
+                        case TEP_PRINT_DYNAMIC_ARRAY:
                                 offset = tep_read_number(pevent,
                                                    data + larg->dynarray.field->offset,
                                                    larg->dynarray.field->size);
@@ -3602,7 +3604,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                                 offset &= 0xffff;
                                 offset += right;
                                 break;
-                        case PRINT_FIELD:
+                        case TEP_PRINT_FIELD:
                                 if (!larg->field.field) {
                                         larg->field.field =
                                                 tep_find_any_field(event, larg->field.name);
@@ -3718,7 +3720,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                         goto out_warning_op;
                 }
                 break;
-        case PRINT_DYNAMIC_ARRAY_LEN:
+        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
                 offset = tep_read_number(pevent,
                                          data + arg->dynarray.field->offset,
                                          arg->dynarray.field->size);
@@ -3729,7 +3731,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                  */
                 val = (unsigned long long)(offset >> 16);
                 break;
-        case PRINT_DYNAMIC_ARRAY:
+        case TEP_PRINT_DYNAMIC_ARRAY:
                 /* Without [], we pass the address to the dynamic data */
                 offset = tep_read_number(pevent,
                                          data + arg->dynarray.field->offset,
@@ -3861,12 +3863,12 @@ static void print_bitmask_to_seq(struct tep_handle *pevent,
 }
 
 static void print_str_arg(struct trace_seq *s, void *data, int size,
-                          struct event_format *event, const char *format,
-                          int len_arg, struct print_arg *arg)
+                          struct tep_event_format *event, const char *format,
+                          int len_arg, struct tep_print_arg *arg)
 {
         struct tep_handle *pevent = event->pevent;
-        struct print_flag_sym *flag;
-        struct format_field *field;
+        struct tep_print_flag_sym *flag;
+        struct tep_format_field *field;
         struct printk_map *printk;
         long long val, fval;
         unsigned long long addr;
@@ -3876,13 +3878,13 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
         int i, len;
 
         switch (arg->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 /* ?? */
                 return;
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 print_str_to_seq(s, format, len_arg, arg->atom.atom);
                 return;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 field = arg->field.field;
                 if (!field) {
                         field = tep_find_any_field(event, arg->field.name);
@@ -3900,7 +3902,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                  * and the size is the same as long_size, assume that it
                  * is a pointer.
                  */
-                if (!(field->flags & FIELD_IS_ARRAY) &&
+                if (!(field->flags & TEP_FIELD_IS_ARRAY) &&
                     field->size == pevent->long_size) {
 
                         /* Handle heterogeneous recording and processing
@@ -3939,7 +3941,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 print_str_to_seq(s, format, len_arg, str);
                 free(str);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 val = eval_num_arg(data, size, event, arg->flags.field);
                 print = 0;
                 for (flag = arg->flags.flags; flag; flag = flag->next) {
@@ -3962,7 +3964,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                         trace_seq_printf(s, "0x%llx", val);
                 }
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 val = eval_num_arg(data, size, event, arg->symbol.field);
                 for (flag = arg->symbol.symbols; flag; flag = flag->next) {
                         fval = eval_flag(flag->value);
@@ -3974,9 +3976,9 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 if (!flag)
                         trace_seq_printf(s, "0x%llx", val);
                 break;
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
-                if (arg->hex.field->type == PRINT_DYNAMIC_ARRAY) {
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
+                if (arg->hex.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
                         unsigned long offset;
                         offset = tep_read_number(pevent,
                                 data + arg->hex.field->dynarray.field->offset,
@@ -3995,19 +3997,19 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 }
                 len = eval_num_arg(data, size, event, arg->hex.size);
                 for (i = 0; i < len; i++) {
-                        if (i && arg->type == PRINT_HEX)
+                        if (i && arg->type == TEP_PRINT_HEX)
                                 trace_seq_putc(s, ' ');
                         trace_seq_printf(s, "%02x", hex[i]);
                 }
                 break;
 
-        case PRINT_INT_ARRAY: {
+        case TEP_PRINT_INT_ARRAY: {
                 void *num;
                 int el_size;
 
-                if (arg->int_array.field->type == PRINT_DYNAMIC_ARRAY) {
+                if (arg->int_array.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
                         unsigned long offset;
-                        struct format_field *field =
+                        struct tep_format_field *field =
                                 arg->int_array.field->dynarray.field;
                         offset = tep_read_number(pevent,
                                                  data + field->offset,
@@ -4049,43 +4051,43 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 }
                 break;
         }
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 break;
-        case PRINT_STRING: {
+        case TEP_PRINT_STRING: {
                 int str_offset;
 
                 if (arg->string.offset == -1) {
-                        struct format_field *f;
+                        struct tep_format_field *f;
 
                         f = tep_find_any_field(event, arg->string.string);
                         arg->string.offset = f->offset;
                 }
-                str_offset = data2host4(pevent, data + arg->string.offset);
+                str_offset = tep_data2host4(pevent, data + arg->string.offset);
                 str_offset &= 0xffff;
                 print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
                 break;
         }
-        case PRINT_BSTRING:
+        case TEP_PRINT_BSTRING:
                 print_str_to_seq(s, format, len_arg, arg->string.string);
                 break;
-        case PRINT_BITMASK: {
+        case TEP_PRINT_BITMASK: {
                 int bitmask_offset;
                 int bitmask_size;
 
                 if (arg->bitmask.offset == -1) {
-                        struct format_field *f;
+                        struct tep_format_field *f;
 
                         f = tep_find_any_field(event, arg->bitmask.bitmask);
                         arg->bitmask.offset = f->offset;
                 }
-                bitmask_offset = data2host4(pevent, data + arg->bitmask.offset);
+                bitmask_offset = tep_data2host4(pevent, data + arg->bitmask.offset);
                 bitmask_size = bitmask_offset >> 16;
                 bitmask_offset &= 0xffff;
                 print_bitmask_to_seq(pevent, s, format, len_arg,
                                      data + bitmask_offset, bitmask_size);
                 break;
         }
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 /*
                  * The only op for string should be ? :
                  */
@@ -4099,7 +4101,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                         print_str_arg(s, data, size, event,
                                       format, len_arg, arg->op.right->op.right);
                 break;
-        case PRINT_FUNC:
+        case TEP_PRINT_FUNC:
                 process_defined_func(s, data, size, event, arg);
                 break;
         default:
@@ -4116,13 +4118,13 @@ out_warning_field:
 
 static unsigned long long
 process_defined_func(struct trace_seq *s, void *data, int size,
-                     struct event_format *event, struct print_arg *arg)
+                     struct tep_event_format *event, struct tep_print_arg *arg)
 {
         struct tep_function_handler *func_handle = arg->func.func;
         struct func_params *param;
         unsigned long long *args;
         unsigned long long ret;
-        struct print_arg *farg;
+        struct tep_print_arg *farg;
         struct trace_seq str;
         struct save_str {
                 struct save_str *next;
@@ -4199,9 +4201,9 @@ out_free:
         return ret;
 }
 
-static void free_args(struct print_arg *args)
+static void free_args(struct tep_print_arg *args)
 {
-        struct print_arg *next;
+        struct tep_print_arg *next;
 
         while (args) {
                 next = args->next;
@@ -4211,11 +4213,11 @@ static void free_args(struct print_arg *args)
         }
 }
 
-static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event_format *event)
+static struct tep_print_arg *make_bprint_args(char *fmt, void *data, int size, struct tep_event_format *event)
 {
         struct tep_handle *pevent = event->pevent;
-        struct format_field *field, *ip_field;
-        struct print_arg *args, *arg, **next;
+        struct tep_format_field *field, *ip_field;
+        struct tep_print_arg *args, *arg, **next;
         unsigned long long ip, val;
         char *ptr;
         void *bptr;
@@ -4254,7 +4256,7 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
         arg->next = NULL;
         next = &arg->next;
 
-        arg->type = PRINT_ATOM;
+        arg->type = TEP_PRINT_ATOM;
                 
         if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
                 goto out_free;
@@ -4342,7 +4344,7 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                         goto out_free;
                                 }
                                 arg->next = NULL;
-                                arg->type = PRINT_ATOM;
+                                arg->type = TEP_PRINT_ATOM;
                                 if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
                                         free(arg);
                                         goto out_free;
@@ -4366,7 +4368,7 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                         goto out_free;
                                 }
                                 arg->next = NULL;
-                                arg->type = PRINT_BSTRING;
+                                arg->type = TEP_PRINT_BSTRING;
                                 arg->string.string = strdup(bptr);
                                 if (!arg->string.string)
                                         goto out_free;
@@ -4388,11 +4390,11 @@ out_free:
 
 static char *
 get_bprint_format(void *data, int size __maybe_unused,
-                  struct event_format *event)
+                  struct tep_event_format *event)
 {
         struct tep_handle *pevent = event->pevent;
         unsigned long long addr;
-        struct format_field *field;
+        struct tep_format_field *field;
         struct printk_map *printk;
         char *format;
 
@@ -4423,17 +4425,17 @@ get_bprint_format(void *data, int size __maybe_unused,
 }
 
 static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
-                          struct event_format *event, struct print_arg *arg)
+                          struct tep_event_format *event, struct tep_print_arg *arg)
 {
         unsigned char *buf;
         const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
 
-        if (arg->type == PRINT_FUNC) {
+        if (arg->type == TEP_PRINT_FUNC) {
                 process_defined_func(s, data, size, event, arg);
                 return;
         }
 
-        if (arg->type != PRINT_FIELD) {
+        if (arg->type != TEP_PRINT_FIELD) {
                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
                                  arg->type);
                 return;
@@ -4576,17 +4578,17 @@ static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
  * %pISpc print an IP address based on sockaddr; p adds port.
  */
 static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
-                          void *data, int size, struct event_format *event,
-                          struct print_arg *arg)
+                          void *data, int size, struct tep_event_format *event,
+                          struct tep_print_arg *arg)
 {
         unsigned char *buf;
 
-        if (arg->type == PRINT_FUNC) {
+        if (arg->type == TEP_PRINT_FUNC) {
                 process_defined_func(s, data, size, event, arg);
                 return 0;
         }
 
-        if (arg->type != PRINT_FIELD) {
+        if (arg->type != TEP_PRINT_FIELD) {
                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
                 return 0;
         }
@@ -4613,8 +4615,8 @@ static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
 }
 
 static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
-                          void *data, int size, struct event_format *event,
-                          struct print_arg *arg)
+                          void *data, int size, struct tep_event_format *event,
+                          struct tep_print_arg *arg)
 {
         char have_c = 0;
         unsigned char *buf;
@@ -4627,12 +4629,12 @@ static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
                 rc++;
         }
 
-        if (arg->type == PRINT_FUNC) {
+        if (arg->type == TEP_PRINT_FUNC) {
                 process_defined_func(s, data, size, event, arg);
                 return rc;
         }
 
-        if (arg->type != PRINT_FIELD) {
+        if (arg->type != TEP_PRINT_FIELD) {
                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
                 return rc;
         }
@@ -4663,8 +4665,8 @@ static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
 }
 
 static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
-                          void *data, int size, struct event_format *event,
-                          struct print_arg *arg)
+                          void *data, int size, struct tep_event_format *event,
+                          struct tep_print_arg *arg)
 {
         char have_c = 0, have_p = 0;
         unsigned char *buf;
@@ -4685,12 +4687,12 @@ static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
                 }
         }
 
-        if (arg->type == PRINT_FUNC) {
+        if (arg->type == TEP_PRINT_FUNC) {
                 process_defined_func(s, data, size, event, arg);
                 return rc;
         }
 
-        if (arg->type != PRINT_FIELD) {
+        if (arg->type != TEP_PRINT_FIELD) {
                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
                 return rc;
         }
@@ -4745,8 +4747,8 @@ static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
 }
 
 static int print_ip_arg(struct trace_seq *s, const char *ptr,
-                        void *data, int size, struct event_format *event,
-                        struct print_arg *arg)
+                        void *data, int size, struct tep_event_format *event,
+                        struct tep_print_arg *arg)
 {
         char i = *ptr;  /* 'i' or 'I' */
         char ver;
@@ -4787,22 +4789,22 @@ static int is_printable_array(char *p, unsigned int len)
 }
 
 void tep_print_field(struct trace_seq *s, void *data,
-                     struct format_field *field)
+                     struct tep_format_field *field)
 {
         unsigned long long val;
         unsigned int offset, len, i;
         struct tep_handle *pevent = field->event->pevent;
 
-        if (field->flags & FIELD_IS_ARRAY) {
+        if (field->flags & TEP_FIELD_IS_ARRAY) {
                 offset = field->offset;
                 len = field->size;
-                if (field->flags & FIELD_IS_DYNAMIC) {
+                if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                         val = tep_read_number(pevent, data + offset, len);
                         offset = val;
                         len = offset >> 16;
                         offset &= 0xffff;
                 }
-                if (field->flags & FIELD_IS_STRING &&
+                if (field->flags & TEP_FIELD_IS_STRING &&
                     is_printable_array(data + offset, len)) {
                         trace_seq_printf(s, "%s", (char *)data + offset);
                 } else {
@@ -4814,21 +4816,21 @@ void tep_print_field(struct trace_seq *s, void *data,
                                                  *((unsigned char *)data + offset + i));
                         }
                         trace_seq_putc(s, ']');
-                        field->flags &= ~FIELD_IS_STRING;
+                        field->flags &= ~TEP_FIELD_IS_STRING;
                 }
         } else {
                 val = tep_read_number(pevent, data + field->offset,
                                       field->size);
-                if (field->flags & FIELD_IS_POINTER) {
+                if (field->flags & TEP_FIELD_IS_POINTER) {
                         trace_seq_printf(s, "0x%llx", val);
-                } else if (field->flags & FIELD_IS_SIGNED) {
+                } else if (field->flags & TEP_FIELD_IS_SIGNED) {
                         switch (field->size) {
                         case 4:
                                 /*
                                  * If field is long then print it in hex.
                                  * A long usually stores pointers.
                                  */
-                                if (field->flags & FIELD_IS_LONG)
+                                if (field->flags & TEP_FIELD_IS_LONG)
                                         trace_seq_printf(s, "0x%x", (int)val);
                                 else
                                         trace_seq_printf(s, "%d", (int)val);
@@ -4843,7 +4845,7 @@ void tep_print_field(struct trace_seq *s, void *data,
                                 trace_seq_printf(s, "%lld", val);
                         }
                 } else {
-                        if (field->flags & FIELD_IS_LONG)
+                        if (field->flags & TEP_FIELD_IS_LONG)
                                 trace_seq_printf(s, "0x%llx", val);
                         else
                                 trace_seq_printf(s, "%llu", val);
@@ -4852,9 +4854,9 @@ void tep_print_field(struct trace_seq *s, void *data,
 }
 
 void tep_print_fields(struct trace_seq *s, void *data,
-                      int size __maybe_unused, struct event_format *event)
+                      int size __maybe_unused, struct tep_event_format *event)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
 
         field = event->format.fields;
         while (field) {
@@ -4864,12 +4866,12 @@ void tep_print_fields(struct trace_seq *s, void *data,
         }
 }
 
-static void pretty_print(struct trace_seq *s, void *data, int size, struct event_format *event)
+static void pretty_print(struct trace_seq *s, void *data, int size, struct tep_event_format *event)
 {
         struct tep_handle *pevent = event->pevent;
-        struct print_fmt *print_fmt = &event->print_fmt;
-        struct print_arg *arg = print_fmt->args;
-        struct print_arg *args = NULL;
+        struct tep_print_fmt *print_fmt = &event->print_fmt;
+        struct tep_print_arg *arg = print_fmt->args;
+        struct tep_print_arg *args = NULL;
         const char *ptr = print_fmt->format;
         unsigned long long val;
         struct func_map *func;
@@ -4883,13 +4885,13 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
         int len;
         int ls;
 
-        if (event->flags & EVENT_FL_FAILED) {
+        if (event->flags & TEP_EVENT_FL_FAILED) {
                 trace_seq_printf(s, "[FAILED TO PARSE]");
                 tep_print_fields(s, data, size, event);
                 return;
         }
 
-        if (event->flags & EVENT_FL_ISBPRINT) {
+        if (event->flags & TEP_EVENT_FL_ISBPRINT) {
                 bprint_fmt = get_bprint_format(data, size, event);
                 args = make_bprint_args(bprint_fmt, data, size, event);
                 arg = args;
@@ -4944,7 +4946,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                 /* The argument is the length. */
                                 if (!arg) {
                                         do_warning_event(event, "no argument match");
-                                        event->flags |= EVENT_FL_FAILED;
+                                        event->flags |= TEP_EVENT_FL_FAILED;
                                         goto out_failed;
                                 }
                                 len_arg = eval_num_arg(data, size, event, arg);
@@ -4966,7 +4968,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                 if (isalnum(ptr[1]))
                                         ptr++;
 
-                                if (arg->type == PRINT_BSTRING) {
+                                if (arg->type == TEP_PRINT_BSTRING) {
                                         trace_seq_puts(s, arg->string.string);
                                         break;
                                 }
@@ -4997,7 +4999,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                         case 'u':
                                 if (!arg) {
                                         do_warning_event(event, "no argument match");
-                                        event->flags |= EVENT_FL_FAILED;
+                                        event->flags |= TEP_EVENT_FL_FAILED;
                                         goto out_failed;
                                 }
 
@@ -5007,7 +5009,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                 /* should never happen */
                                 if (len > 31) {
                                         do_warning_event(event, "bad format!");
-                                        event->flags |= EVENT_FL_FAILED;
+                                        event->flags |= TEP_EVENT_FL_FAILED;
                                         len = 31;
                                 }
 
@@ -5073,13 +5075,13 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                         break;
                                 default:
                                         do_warning_event(event, "bad count (%d)", ls);
-                                        event->flags |= EVENT_FL_FAILED;
+                                        event->flags |= TEP_EVENT_FL_FAILED;
                                 }
                                 break;
                         case 's':
                                 if (!arg) {
                                         do_warning_event(event, "no matching argument");
-                                        event->flags |= EVENT_FL_FAILED;
+                                        event->flags |= TEP_EVENT_FL_FAILED;
                                         goto out_failed;
                                 }
 
@@ -5089,7 +5091,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                 /* should never happen */
                                 if (len > 31) {
                                         do_warning_event(event, "bad format!");
-                                        event->flags |= EVENT_FL_FAILED;
+                                        event->flags |= TEP_EVENT_FL_FAILED;
                                         len = 31;
                                 }
 
@@ -5114,7 +5116,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                         trace_seq_putc(s, *ptr);
         }
 
-        if (event->flags & EVENT_FL_FAILED) {
+        if (event->flags & TEP_EVENT_FL_FAILED) {
 out_failed:
                 trace_seq_printf(s, "[FAILED TO PARSE]");
         }
@@ -5227,7 +5229,7 @@ int tep_data_type(struct tep_handle *pevent, struct tep_record *rec)
  *
  * This returns the event form a given @type;
  */
-struct event_format *tep_data_event_from_type(struct tep_handle *pevent, int type)
+struct tep_event_format *tep_data_event_from_type(struct tep_handle *pevent, int type)
 {
         return tep_find_event(pevent, type);
 }
@@ -5385,16 +5387,16 @@ int tep_cmdline_pid(struct tep_handle *pevent, struct cmdline *cmdline)
  * This parses the raw @data using the given @event information and
  * writes the print format into the trace_seq.
  */
-void tep_event_info(struct trace_seq *s, struct event_format *event,
+void tep_event_info(struct trace_seq *s, struct tep_event_format *event,
                     struct tep_record *record)
 {
         int print_pretty = 1;
 
-        if (event->pevent->print_raw || (event->flags & EVENT_FL_PRINTRAW))
+        if (event->pevent->print_raw || (event->flags & TEP_EVENT_FL_PRINTRAW))
                 tep_print_fields(s, record->data, record->size, event);
         else {
 
-                if (event->handler && !(event->flags & EVENT_FL_NOHANDLE))
+                if (event->handler && !(event->flags & TEP_EVENT_FL_NOHANDLE))
                         print_pretty = event->handler(s, record, event,
                                                       event->context);
 
@@ -5426,7 +5428,7 @@ static bool is_timestamp_in_us(char *trace_clock, bool use_trace_clock)
  * Returns the associated event for a given record, or NULL if non is
  * is found.
  */
-struct event_format *
+struct tep_event_format *
 tep_find_event_by_record(struct tep_handle *pevent, struct tep_record *record)
 {
         int type;
@@ -5451,7 +5453,7 @@ tep_find_event_by_record(struct tep_handle *pevent, struct tep_record *record)
  * Writes the tasks comm, pid and CPU to @s.
  */
 void tep_print_event_task(struct tep_handle *pevent, struct trace_seq *s,
-                          struct event_format *event,
+                          struct tep_event_format *event,
                           struct tep_record *record)
 {
         void *data = record->data;
@@ -5479,7 +5481,7 @@ void tep_print_event_task(struct tep_handle *pevent, struct trace_seq *s,
  * Writes the timestamp of the record into @s.
  */
 void tep_print_event_time(struct tep_handle *pevent, struct trace_seq *s,
-                          struct event_format *event,
+                          struct tep_event_format *event,
                           struct tep_record *record,
                           bool use_trace_clock)
 {
@@ -5529,7 +5531,7 @@ void tep_print_event_time(struct tep_handle *pevent, struct trace_seq *s,
  * Writes the parsing of the record's data to @s.
  */
 void tep_print_event_data(struct tep_handle *pevent, struct trace_seq *s,
-                          struct event_format *event,
+                          struct tep_event_format *event,
                           struct tep_record *record)
 {
         static const char *spaces = "                    "; /* 20 spaces */
@@ -5548,7 +5550,7 @@ void tep_print_event_data(struct tep_handle *pevent, struct trace_seq *s,
 void tep_print_event(struct tep_handle *pevent, struct trace_seq *s,
                      struct tep_record *record, bool use_trace_clock)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
 
         event = tep_find_event_by_record(pevent, record);
         if (!event) {
@@ -5570,8 +5572,8 @@ void tep_print_event(struct tep_handle *pevent, struct trace_seq *s,
 
 static int events_id_cmp(const void *a, const void *b)
 {
-        struct event_format * const * ea = a;
-        struct event_format * const * eb = b;
+        struct tep_event_format * const * ea = a;
+        struct tep_event_format * const * eb = b;
 
         if ((*ea)->id < (*eb)->id)
                 return -1;
@@ -5584,8 +5586,8 @@ static int events_id_cmp(const void *a, const void *b)
 
 static int events_name_cmp(const void *a, const void *b)
 {
-        struct event_format * const * ea = a;
-        struct event_format * const * eb = b;
+        struct tep_event_format * const * ea = a;
+        struct tep_event_format * const * eb = b;
         int res;
 
         res = strcmp((*ea)->name, (*eb)->name);
@@ -5601,8 +5603,8 @@ static int events_name_cmp(const void *a, const void *b)
 
 static int events_system_cmp(const void *a, const void *b)
 {
-        struct event_format * const * ea = a;
-        struct event_format * const * eb = b;
+        struct tep_event_format * const * ea = a;
+        struct tep_event_format * const * eb = b;
         int res;
 
         res = strcmp((*ea)->system, (*eb)->system);
@@ -5616,9 +5618,9 @@ static int events_system_cmp(const void *a, const void *b)
         return events_id_cmp(a, b);
 }
 
-struct event_format **tep_list_events(struct tep_handle *pevent, enum event_sort_type sort_type)
+struct tep_event_format **tep_list_events(struct tep_handle *pevent, enum tep_event_sort_type sort_type)
 {
-        struct event_format **events;
+        struct tep_event_format **events;
         int (*sort)(const void *a, const void *b);
 
         events = pevent->sort_events;
@@ -5637,20 +5639,20 @@ struct event_format **tep_list_events(struct tep_handle *pevent, enum event_sort
                 pevent->sort_events = events;
 
                 /* the internal events are sorted by id */
-                if (sort_type == EVENT_SORT_ID) {
+                if (sort_type == TEP_EVENT_SORT_ID) {
                         pevent->last_type = sort_type;
                         return events;
                 }
         }
 
         switch (sort_type) {
-        case EVENT_SORT_ID:
+        case TEP_EVENT_SORT_ID:
                 sort = events_id_cmp;
                 break;
-        case EVENT_SORT_NAME:
+        case TEP_EVENT_SORT_NAME:
                 sort = events_name_cmp;
                 break;
-        case EVENT_SORT_SYSTEM:
+        case TEP_EVENT_SORT_SYSTEM:
                 sort = events_system_cmp;
                 break;
         default:
@@ -5663,12 +5665,12 @@ struct event_format **tep_list_events(struct tep_handle *pevent, enum event_sort
         return events;
 }
 
-static struct format_field **
+static struct tep_format_field **
 get_event_fields(const char *type, const char *name,
-                 int count, struct format_field *list)
+                 int count, struct tep_format_field *list)
 {
-        struct format_field **fields;
-        struct format_field *field;
+        struct tep_format_field **fields;
+        struct tep_format_field *field;
         int i = 0;
 
         fields = malloc(sizeof(*fields) * (count + 1));
@@ -5701,7 +5703,7 @@ get_event_fields(const char *type, const char *name,
  * Returns an allocated array of fields. The last item in the array is NULL.
  * The array must be freed with free().
  */
-struct format_field **tep_event_common_fields(struct event_format *event)
+struct tep_format_field **tep_event_common_fields(struct tep_event_format *event)
 {
         return get_event_fields("common", event->name,
                                 event->format.nr_common,
@@ -5715,14 +5717,14 @@ struct format_field **tep_event_common_fields(struct event_format *event)
  * Returns an allocated array of fields. The last item in the array is NULL.
  * The array must be freed with free().
  */
-struct format_field **tep_event_fields(struct event_format *event)
+struct tep_format_field **tep_event_fields(struct tep_event_format *event)
 {
         return get_event_fields("event", event->name,
                                 event->format.nr_fields,
                                 event->format.fields);
 }
 
-static void print_fields(struct trace_seq *s, struct print_flag_sym *field)
+static void print_fields(struct trace_seq *s, struct tep_print_flag_sym *field)
 {
         trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
         if (field->next) {
@@ -5732,22 +5734,22 @@ static void print_fields(struct trace_seq *s, struct print_flag_sym *field)
 }
 
 /* for debugging */
-static void print_args(struct print_arg *args)
+static void print_args(struct tep_print_arg *args)
 {
         int print_paren = 1;
         struct trace_seq s;
 
         switch (args->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 printf("null");
                 break;
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 printf("%s", args->atom.atom);
                 break;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 printf("REC->%s", args->field.name);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 printf("__print_flags(");
                 print_args(args->flags.field);
                 printf(", %s, ", args->flags.delim);
@@ -5757,7 +5759,7 @@ static void print_args(struct print_arg *args)
                 trace_seq_destroy(&s);
                 printf(")");
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 printf("__print_symbolic(");
                 print_args(args->symbol.field);
                 printf(", ");
@@ -5767,21 +5769,21 @@ static void print_args(struct print_arg *args)
                 trace_seq_destroy(&s);
                 printf(")");
                 break;
-        case PRINT_HEX:
+        case TEP_PRINT_HEX:
                 printf("__print_hex(");
                 print_args(args->hex.field);
                 printf(", ");
                 print_args(args->hex.size);
                 printf(")");
                 break;
-        case PRINT_HEX_STR:
+        case TEP_PRINT_HEX_STR:
                 printf("__print_hex_str(");
                 print_args(args->hex.field);
                 printf(", ");
                 print_args(args->hex.size);
                 printf(")");
                 break;
-        case PRINT_INT_ARRAY:
+        case TEP_PRINT_INT_ARRAY:
                 printf("__print_array(");
                 print_args(args->int_array.field);
                 printf(", ");
@@ -5790,18 +5792,18 @@ static void print_args(struct print_arg *args)
                 print_args(args->int_array.el_size);
                 printf(")");
                 break;
-        case PRINT_STRING:
-        case PRINT_BSTRING:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BSTRING:
                 printf("__get_str(%s)", args->string.string);
                 break;
-        case PRINT_BITMASK:
+        case TEP_PRINT_BITMASK:
                 printf("__get_bitmask(%s)", args->bitmask.bitmask);
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 printf("(%s)", args->typecast.type);
                 print_args(args->typecast.item);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (strcmp(args->op.op, ":") == 0)
                         print_paren = 0;
                 if (print_paren)
@@ -5833,13 +5835,13 @@ static void parse_header_field(const char *field,
         save_input_buf_ptr = input_buf_ptr;
         save_input_buf_siz = input_buf_siz;
 
-        if (read_expected(EVENT_ITEM, "field") < 0)
+        if (read_expected(TEP_EVENT_ITEM, "field") < 0)
                 return;
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return;
 
         /* type */
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto fail;
         free_token(token);
 
@@ -5847,42 +5849,42 @@ static void parse_header_field(const char *field,
          * If this is not a mandatory field, then test it first.
          */
         if (mandatory) {
-                if (read_expected(EVENT_ITEM, field) < 0)
+                if (read_expected(TEP_EVENT_ITEM, field) < 0)
                         return;
         } else {
-                if (read_expect_type(EVENT_ITEM, &token) < 0)
+                if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                         goto fail;
                 if (strcmp(token, field) != 0)
                         goto discard;
                 free_token(token);
         }
 
-        if (read_expected(EVENT_OP, ";") < 0)
+        if (read_expected(TEP_EVENT_OP, ";") < 0)
                 return;
-        if (read_expected(EVENT_ITEM, "offset") < 0)
+        if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
                 return;
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto fail;
         *offset = atoi(token);
         free_token(token);
-        if (read_expected(EVENT_OP, ";") < 0)
+        if (read_expected(TEP_EVENT_OP, ";") < 0)
                 return;
-        if (read_expected(EVENT_ITEM, "size") < 0)
+        if (read_expected(TEP_EVENT_ITEM, "size") < 0)
                 return;
-        if (read_expected(EVENT_OP, ":") < 0)
+        if (read_expected(TEP_EVENT_OP, ":") < 0)
                 return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
+        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
                 goto fail;
         *size = atoi(token);
         free_token(token);
-        if (read_expected(EVENT_OP, ";") < 0)
+        if (read_expected(TEP_EVENT_OP, ";") < 0)
                 return;
         type = read_token(&token);
-        if (type != EVENT_NEWLINE) {
+        if (type != TEP_EVENT_NEWLINE) {
                 /* newer versions of the kernel have a "signed" type */
-                if (type != EVENT_ITEM)
+                if (type != TEP_EVENT_ITEM)
                         goto fail;
 
                 if (strcmp(token, "signed") != 0)
@@ -5890,17 +5892,17 @@ static void parse_header_field(const char *field,
 
                 free_token(token);
 
-                if (read_expected(EVENT_OP, ":") < 0)
+                if (read_expected(TEP_EVENT_OP, ":") < 0)
                         return;
 
-                if (read_expect_type(EVENT_ITEM, &token))
+                if (read_expect_type(TEP_EVENT_ITEM, &token))
                         goto fail;
 
                 free_token(token);
-                if (read_expected(EVENT_OP, ";") < 0)
+                if (read_expected(TEP_EVENT_OP, ";") < 0)
                         return;
 
-                if (read_expect_type(EVENT_NEWLINE, &token))
+                if (read_expect_type(TEP_EVENT_NEWLINE, &token))
                         goto fail;
         }
  fail:
@@ -5957,7 +5959,7 @@ int tep_parse_header_page(struct tep_handle *pevent, char *buf, unsigned long si
         return 0;
 }
 
-static int event_matches(struct event_format *event,
+static int event_matches(struct tep_event_format *event,
                          int id, const char *sys_name,
                          const char *event_name)
 {
@@ -5980,7 +5982,7 @@ static void free_handler(struct event_handler *handle)
         free(handle);
 }
 
-static int find_event_handle(struct tep_handle *pevent, struct event_format *event)
+static int find_event_handle(struct tep_handle *pevent, struct tep_event_format *event)
 {
         struct event_handler *handle, **next;
 
@@ -6021,11 +6023,11 @@ static int find_event_handle(struct tep_handle *pevent, struct event_format *eve
  *
  * /sys/kernel/debug/tracing/events/.../.../format
  */
-enum tep_errno __tep_parse_format(struct event_format **eventp,
+enum tep_errno __tep_parse_format(struct tep_event_format **eventp,
                                   struct tep_handle *pevent, const char *buf,
                                   unsigned long size, const char *sys)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         int ret;
 
         init_input_buf(buf, size);
@@ -6042,10 +6044,10 @@ enum tep_errno __tep_parse_format(struct event_format **eventp,
         }
 
         if (strcmp(sys, "ftrace") == 0) {
-                event->flags |= EVENT_FL_ISFTRACE;
+                event->flags |= TEP_EVENT_FL_ISFTRACE;
 
                 if (strcmp(event->name, "bprint") == 0)
-                        event->flags |= EVENT_FL_ISBPRINT;
+                        event->flags |= TEP_EVENT_FL_ISBPRINT;
         }
                 
         event->id = event_read_id();
@@ -6088,22 +6090,22 @@ enum tep_errno __tep_parse_format(struct event_format **eventp,
                 goto event_parse_failed;
         }
 
-        if (!ret && (event->flags & EVENT_FL_ISFTRACE)) {
-                struct format_field *field;
-                struct print_arg *arg, **list;
+        if (!ret && (event->flags & TEP_EVENT_FL_ISFTRACE)) {
+                struct tep_format_field *field;
+                struct tep_print_arg *arg, **list;
 
                 /* old ftrace had no args */
                 list = &event->print_fmt.args;
                 for (field = event->format.fields; field; field = field->next) {
                         arg = alloc_arg();
                         if (!arg) {
-                                event->flags |= EVENT_FL_FAILED;
+                                event->flags |= TEP_EVENT_FL_FAILED;
                                 return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
                         }
-                        arg->type = PRINT_FIELD;
+                        arg->type = TEP_PRINT_FIELD;
                         arg->field.name = strdup(field->name);
                         if (!arg->field.name) {
-                                event->flags |= EVENT_FL_FAILED;
+                                event->flags |= TEP_EVENT_FL_FAILED;
                                 free_arg(arg);
                                 return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
                         }
@@ -6117,7 +6119,7 @@ enum tep_errno __tep_parse_format(struct event_format **eventp,
         return 0;
 
  event_parse_failed:
-        event->flags |= EVENT_FL_FAILED;
+        event->flags |= TEP_EVENT_FL_FAILED;
         return ret;
 
  event_alloc_failed:
@@ -6130,12 +6132,12 @@ enum tep_errno __tep_parse_format(struct event_format **eventp,
 
 static enum tep_errno
 __parse_event(struct tep_handle *pevent,
-              struct event_format **eventp,
+              struct tep_event_format **eventp,
               const char *buf, unsigned long size,
               const char *sys)
 {
         int ret = __tep_parse_format(eventp, pevent, buf, size, sys);
-        struct event_format *event = *eventp;
+        struct tep_event_format *event = *eventp;
 
         if (event == NULL)
                 return ret;
@@ -6172,7 +6174,7 @@ event_add_failed:
  * /sys/kernel/debug/tracing/events/.../.../format
  */
 enum tep_errno tep_parse_format(struct tep_handle *pevent,
-                                struct event_format **eventp,
+                                struct tep_event_format **eventp,
                                 const char *buf,
                                 unsigned long size, const char *sys)
 {
@@ -6196,40 +6198,11 @@ enum tep_errno tep_parse_format(struct tep_handle *pevent,
 enum tep_errno tep_parse_event(struct tep_handle *pevent, const char *buf,
                                unsigned long size, const char *sys)
 {
-        struct event_format *event = NULL;
+        struct tep_event_format *event = NULL;
         return __parse_event(pevent, &event, buf, size, sys);
 }
 
-#undef _PE
-#define _PE(code, str) str
-static const char * const tep_error_str[] = {
-        TEP_ERRORS
-};
-#undef _PE
-
-int tep_strerror(struct tep_handle *pevent __maybe_unused,
-                 enum tep_errno errnum, char *buf, size_t buflen)
-{
-        int idx;
-        const char *msg;
-
-        if (errnum >= 0) {
-                str_error_r(errnum, buf, buflen);
-                return 0;
-        }
-
-        if (errnum <= __TEP_ERRNO__START ||
-            errnum >= __TEP_ERRNO__END)
-                return -1;
-
-        idx = errnum - __TEP_ERRNO__START - 1;
-        msg = tep_error_str[idx];
-        snprintf(buf, buflen, "%s", msg);
-
-        return 0;
-}
-
-int get_field_val(struct trace_seq *s, struct format_field *field,
+int get_field_val(struct trace_seq *s, struct tep_format_field *field,
                   const char *name, struct tep_record *record,
                   unsigned long long *val, int err)
 {
@@ -6262,11 +6235,11 @@ int get_field_val(struct trace_seq *s, struct format_field *field,
  *
  * On failure, it returns NULL.
  */
-void *tep_get_field_raw(struct trace_seq *s, struct event_format *event,
+void *tep_get_field_raw(struct trace_seq *s, struct tep_event_format *event,
                         const char *name, struct tep_record *record,
                         int *len, int err)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         void *data = record->data;
         unsigned offset;
         int dummy;
@@ -6287,7 +6260,7 @@ void *tep_get_field_raw(struct trace_seq *s, struct event_format *event,
                 len = &dummy;
 
         offset = field->offset;
-        if (field->flags & FIELD_IS_DYNAMIC) {
+        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                 offset = tep_read_number(event->pevent,
                                             data + offset, field->size);
                 *len = offset >> 16;
@@ -6309,11 +6282,11 @@ void *tep_get_field_raw(struct trace_seq *s, struct event_format *event,
  *
  * Returns 0 on success -1 on field not found.
  */
-int tep_get_field_val(struct trace_seq *s, struct event_format *event,
+int tep_get_field_val(struct trace_seq *s, struct tep_event_format *event,
                       const char *name, struct tep_record *record,
                       unsigned long long *val, int err)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
 
         if (!event)
                 return -1;
@@ -6334,11 +6307,11 @@ int tep_get_field_val(struct trace_seq *s, struct event_format *event,
  *
  * Returns 0 on success -1 on field not found.
  */
-int tep_get_common_field_val(struct trace_seq *s, struct event_format *event,
+int tep_get_common_field_val(struct trace_seq *s, struct tep_event_format *event,
                              const char *name, struct tep_record *record,
                              unsigned long long *val, int err)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
 
         if (!event)
                 return -1;
@@ -6359,11 +6332,11 @@ int tep_get_common_field_val(struct trace_seq *s, struct event_format *event,
  *
  * Returns 0 on success -1 on field not found.
  */
-int tep_get_any_field_val(struct trace_seq *s, struct event_format *event,
+int tep_get_any_field_val(struct trace_seq *s, struct tep_event_format *event,
                           const char *name, struct tep_record *record,
                           unsigned long long *val, int err)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
 
         if (!event)
                 return -1;
@@ -6385,10 +6358,10 @@ int tep_get_any_field_val(struct trace_seq *s, struct event_format *event,
  * Returns: 0 on success, -1 field not found, or 1 if buffer is full.
  */
 int tep_print_num_field(struct trace_seq *s, const char *fmt,
-                        struct event_format *event, const char *name,
+                        struct tep_event_format *event, const char *name,
                         struct tep_record *record, int err)
 {
-        struct format_field *field = tep_find_field(event, name);
+        struct tep_format_field *field = tep_find_field(event, name);
         unsigned long long val;
 
         if (!field)
@@ -6417,10 +6390,10 @@ int tep_print_num_field(struct trace_seq *s, const char *fmt,
  * Returns: 0 on success, -1 field not found, or 1 if buffer is full.
  */
 int tep_print_func_field(struct trace_seq *s, const char *fmt,
-                         struct event_format *event, const char *name,
+                         struct tep_event_format *event, const char *name,
                          struct tep_record *record, int err)
 {
-        struct format_field *field = tep_find_field(event, name);
+        struct tep_format_field *field = tep_find_field(event, name);
         struct tep_handle *pevent = event->pevent;
         unsigned long long val;
         struct func_map *func;
@@ -6577,11 +6550,11 @@ int tep_unregister_print_function(struct tep_handle *pevent,
         return -1;
 }
 
-static struct event_format *search_event(struct tep_handle *pevent, int id,
+static struct tep_event_format *search_event(struct tep_handle *pevent, int id,
                                          const char *sys_name,
                                          const char *event_name)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
 
         if (id >= 0) {
                 /* search by id */
@@ -6621,7 +6594,7 @@ int tep_register_event_handler(struct tep_handle *pevent, int id,
                                const char *sys_name, const char *event_name,
                                tep_event_handler_func func, void *context)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         struct event_handler *handle;
 
         event = search_event(pevent, id, sys_name, event_name);
@@ -6705,7 +6678,7 @@ int tep_unregister_event_handler(struct tep_handle *pevent, int id,
                                  const char *sys_name, const char *event_name,
                                  tep_event_handler_func func, void *context)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         struct event_handler *handle;
         struct event_handler **next;
 
@@ -6757,7 +6730,7 @@ void tep_ref(struct tep_handle *pevent)
         pevent->ref_count++;
 }
 
-void tep_free_format_field(struct format_field *field)
+void tep_free_format_field(struct tep_format_field *field)
 {
         free(field->type);
         if (field->alias != field->name)
@@ -6766,9 +6739,9 @@ void tep_free_format_field(struct format_field *field)
         free(field);
 }
 
-static void free_format_fields(struct format_field *field)
+static void free_format_fields(struct tep_format_field *field)
 {
-        struct format_field *next;
+        struct tep_format_field *next;
 
         while (field) {
                 next = field->next;
@@ -6777,13 +6750,13 @@ static void free_format_fields(struct format_field *field)
         }
 }
 
-static void free_formats(struct format *format)
+static void free_formats(struct tep_format *format)
 {
         free_format_fields(format->common_fields);
         free_format_fields(format->fields);
 }
 
-void tep_free_format(struct event_format *event)
+void tep_free_format(struct tep_event_format *event)
 {
         free(event->name);
         free(event->system);
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index 44b7c2d41f9f..16bf4c890b6f 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -26,17 +26,12 @@
 #include <regex.h>
 #include <string.h>
 
+#include "trace-seq.h"
+
 #ifndef __maybe_unused
 #define __maybe_unused __attribute__((unused))
 #endif
 
-/* ----------------------- trace_seq ----------------------- */
-
-
-#ifndef TRACE_SEQ_BUF_SIZE
-#define TRACE_SEQ_BUF_SIZE 4096
-#endif
-
 #ifndef DEBUG_RECORD
 #define DEBUG_RECORD 0
 #endif
@@ -59,51 +54,14 @@ struct tep_record {
 #endif
 };
 
-enum trace_seq_fail {
-        TRACE_SEQ__GOOD,
-        TRACE_SEQ__BUFFER_POISONED,
-        TRACE_SEQ__MEM_ALLOC_FAILED,
-};
-
-/*
- * Trace sequences are used to allow a function to call several other functions
- * to create a string of data to use (up to a max of PAGE_SIZE).
- */
-
-struct trace_seq {
-        char                    *buffer;
-        unsigned int            buffer_size;
-        unsigned int            len;
-        unsigned int            readpos;
-        enum trace_seq_fail     state;
-};
-
-void trace_seq_init(struct trace_seq *s);
-void trace_seq_reset(struct trace_seq *s);
-void trace_seq_destroy(struct trace_seq *s);
-
-extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
-        __attribute__ ((format (printf, 2, 3)));
-extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
-        __attribute__ ((format (printf, 2, 0)));
-
-extern int trace_seq_puts(struct trace_seq *s, const char *str);
-extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
-
-extern void trace_seq_terminate(struct trace_seq *s);
-
-extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp);
-extern int trace_seq_do_printf(struct trace_seq *s);
-
-
-/* ----------------------- pevent ----------------------- */
+/* ----------------------- tep ----------------------- */
 
 struct tep_handle;
-struct event_format;
+struct tep_event_format;
 
 typedef int (*tep_event_handler_func)(struct trace_seq *s,
                                       struct tep_record *record,
-                                      struct event_format *event,
+                                      struct tep_event_format *event,
                                       void *context);
 
 typedef int (*tep_plugin_load_func)(struct tep_handle *pevent);
@@ -172,20 +130,20 @@ struct tep_plugin_option {
 #define TEP_PLUGIN_OPTIONS_NAME MAKE_STR(TEP_PLUGIN_OPTIONS)
 #define TEP_PLUGIN_ALIAS_NAME MAKE_STR(TEP_PLUGIN_ALIAS)
 
-enum format_flags {
-        FIELD_IS_ARRAY          = 1,
-        FIELD_IS_POINTER        = 2,
-        FIELD_IS_SIGNED         = 4,
-        FIELD_IS_STRING         = 8,
-        FIELD_IS_DYNAMIC        = 16,
-        FIELD_IS_LONG           = 32,
-        FIELD_IS_FLAG           = 64,
-        FIELD_IS_SYMBOLIC       = 128,
+enum tep_format_flags {
+        TEP_FIELD_IS_ARRAY      = 1,
+        TEP_FIELD_IS_POINTER    = 2,
+        TEP_FIELD_IS_SIGNED     = 4,
+        TEP_FIELD_IS_STRING     = 8,
+        TEP_FIELD_IS_DYNAMIC    = 16,
+        TEP_FIELD_IS_LONG       = 32,
+        TEP_FIELD_IS_FLAG       = 64,
+        TEP_FIELD_IS_SYMBOLIC   = 128,
 };
 
-struct format_field {
-        struct format_field     *next;
-        struct event_format     *event;
+struct tep_format_field {
+        struct tep_format_field *next;
+        struct tep_event_format *event;
         char                    *type;
         char                    *name;
         char                    *alias;
@@ -196,169 +154,169 @@ struct format_field {
         unsigned long           flags;
 };
 
-struct format {
+struct tep_format {
         int                     nr_common;
         int                     nr_fields;
-        struct format_field     *common_fields;
-        struct format_field     *fields;
+        struct tep_format_field *common_fields;
+        struct tep_format_field *fields;
 };
 
-struct print_arg_atom {
+struct tep_print_arg_atom {
         char                    *atom;
 };
 
-struct print_arg_string {
+struct tep_print_arg_string {
         char                    *string;
         int                     offset;
 };
 
-struct print_arg_bitmask {
+struct tep_print_arg_bitmask {
         char                    *bitmask;
         int                     offset;
 };
 
-struct print_arg_field {
+struct tep_print_arg_field {
         char                    *name;
-        struct format_field     *field;
+        struct tep_format_field *field;
 };
 
-struct print_flag_sym {
-        struct print_flag_sym   *next;
-        char                    *value;
-        char                    *str;
+struct tep_print_flag_sym {
+        struct tep_print_flag_sym       *next;
+        char                            *value;
+        char                            *str;
 };
 
-struct print_arg_typecast {
+struct tep_print_arg_typecast {
         char                    *type;
-        struct print_arg        *item;
+        struct tep_print_arg    *item;
 };
 
-struct print_arg_flags {
-        struct print_arg        *field;
-        char                    *delim;
-        struct print_flag_sym   *flags;
+struct tep_print_arg_flags {
+        struct tep_print_arg            *field;
+        char                            *delim;
+        struct tep_print_flag_sym       *flags;
 };
 
-struct print_arg_symbol {
-        struct print_arg        *field;
-        struct print_flag_sym   *symbols;
+struct tep_print_arg_symbol {
+        struct tep_print_arg            *field;
+        struct tep_print_flag_sym       *symbols;
 };
 
-struct print_arg_hex {
-        struct print_arg        *field;
-        struct print_arg        *size;
+struct tep_print_arg_hex {
+        struct tep_print_arg    *field;
+        struct tep_print_arg    *size;
 };
 
-struct print_arg_int_array {
-        struct print_arg        *field;
-        struct print_arg        *count;
-        struct print_arg        *el_size;
+struct tep_print_arg_int_array {
+        struct tep_print_arg    *field;
+        struct tep_print_arg    *count;
+        struct tep_print_arg    *el_size;
 };
 
-struct print_arg_dynarray {
-        struct format_field     *field;
-        struct print_arg        *index;
+struct tep_print_arg_dynarray {
+        struct tep_format_field *field;
+        struct tep_print_arg    *index;
 };
 
-struct print_arg;
+struct tep_print_arg;
 
-struct print_arg_op {
+struct tep_print_arg_op {
         char                    *op;
         int                     prio;
-        struct print_arg        *left;
-        struct print_arg        *right;
+        struct tep_print_arg    *left;
+        struct tep_print_arg    *right;
 };
 
 struct tep_function_handler;
 
-struct print_arg_func {
+struct tep_print_arg_func {
         struct tep_function_handler     *func;
-        struct print_arg                *args;
-};
-
-enum print_arg_type {
-        PRINT_NULL,
-        PRINT_ATOM,
-        PRINT_FIELD,
-        PRINT_FLAGS,
-        PRINT_SYMBOL,
-        PRINT_HEX,
-        PRINT_INT_ARRAY,
-        PRINT_TYPE,
-        PRINT_STRING,
-        PRINT_BSTRING,
-        PRINT_DYNAMIC_ARRAY,
-        PRINT_OP,
-        PRINT_FUNC,
-        PRINT_BITMASK,
-        PRINT_DYNAMIC_ARRAY_LEN,
-        PRINT_HEX_STR,
-};
-
-struct print_arg {
-        struct print_arg                *next;
-        enum print_arg_type             type;
+        struct tep_print_arg            *args;
+};
+
+enum tep_print_arg_type {
+        TEP_PRINT_NULL,
+        TEP_PRINT_ATOM,
+        TEP_PRINT_FIELD,
+        TEP_PRINT_FLAGS,
+        TEP_PRINT_SYMBOL,
+        TEP_PRINT_HEX,
+        TEP_PRINT_INT_ARRAY,
+        TEP_PRINT_TYPE,
+        TEP_PRINT_STRING,
+        TEP_PRINT_BSTRING,
+        TEP_PRINT_DYNAMIC_ARRAY,
+        TEP_PRINT_OP,
+        TEP_PRINT_FUNC,
+        TEP_PRINT_BITMASK,
+        TEP_PRINT_DYNAMIC_ARRAY_LEN,
+        TEP_PRINT_HEX_STR,
+};
+
+struct tep_print_arg {
+        struct tep_print_arg            *next;
+        enum tep_print_arg_type         type;
         union {
-                struct print_arg_atom           atom;
-                struct print_arg_field          field;
-                struct print_arg_typecast       typecast;
-                struct print_arg_flags          flags;
-                struct print_arg_symbol         symbol;
-                struct print_arg_hex            hex;
-                struct print_arg_int_array      int_array;
-                struct print_arg_func           func;
-                struct print_arg_string         string;
-                struct print_arg_bitmask        bitmask;
-                struct print_arg_op             op;
-                struct print_arg_dynarray       dynarray;
+                struct tep_print_arg_atom       atom;
+                struct tep_print_arg_field      field;
+                struct tep_print_arg_typecast   typecast;
+                struct tep_print_arg_flags      flags;
+                struct tep_print_arg_symbol     symbol;
+                struct tep_print_arg_hex        hex;
+                struct tep_print_arg_int_array  int_array;
+                struct tep_print_arg_func       func;
+                struct tep_print_arg_string     string;
+                struct tep_print_arg_bitmask    bitmask;
+                struct tep_print_arg_op         op;
+                struct tep_print_arg_dynarray   dynarray;
         };
 };
 
-struct print_fmt {
+struct tep_print_fmt {
         char                    *format;
-        struct print_arg        *args;
+        struct tep_print_arg    *args;
 };
 
-struct event_format {
+struct tep_event_format {
         struct tep_handle       *pevent;
         char                    *name;
         int                     id;
         int                     flags;
-        struct format           format;
-        struct print_fmt        print_fmt;
+        struct tep_format       format;
+        struct tep_print_fmt    print_fmt;
         char                    *system;
         tep_event_handler_func  handler;
         void                    *context;
 };
 
 enum {
-        EVENT_FL_ISFTRACE       = 0x01,
-        EVENT_FL_ISPRINT        = 0x02,
-        EVENT_FL_ISBPRINT       = 0x04,
-        EVENT_FL_ISFUNCENT      = 0x10,
-        EVENT_FL_ISFUNCRET      = 0x20,
-        EVENT_FL_NOHANDLE       = 0x40,
-        EVENT_FL_PRINTRAW       = 0x80,
+        TEP_EVENT_FL_ISFTRACE   = 0x01,
+        TEP_EVENT_FL_ISPRINT    = 0x02,
+        TEP_EVENT_FL_ISBPRINT   = 0x04,
+        TEP_EVENT_FL_ISFUNCENT  = 0x10,
+        TEP_EVENT_FL_ISFUNCRET  = 0x20,
+        TEP_EVENT_FL_NOHANDLE   = 0x40,
+        TEP_EVENT_FL_PRINTRAW   = 0x80,
 
-        EVENT_FL_FAILED         = 0x80000000
+        TEP_EVENT_FL_FAILED     = 0x80000000
 };
 
-enum event_sort_type {
-        EVENT_SORT_ID,
-        EVENT_SORT_NAME,
-        EVENT_SORT_SYSTEM,
+enum tep_event_sort_type {
+        TEP_EVENT_SORT_ID,
+        TEP_EVENT_SORT_NAME,
+        TEP_EVENT_SORT_SYSTEM,
 };
 
-enum event_type {
-        EVENT_ERROR,
-        EVENT_NONE,
-        EVENT_SPACE,
-        EVENT_NEWLINE,
-        EVENT_OP,
-        EVENT_DELIM,
-        EVENT_ITEM,
-        EVENT_DQUOTE,
-        EVENT_SQUOTE,
+enum tep_event_type {
+        TEP_EVENT_ERROR,
+        TEP_EVENT_NONE,
+        TEP_EVENT_SPACE,
+        TEP_EVENT_NEWLINE,
+        TEP_EVENT_OP,
+        TEP_EVENT_DELIM,
+        TEP_EVENT_ITEM,
+        TEP_EVENT_DQUOTE,
+        TEP_EVENT_SQUOTE,
 };
 
 typedef unsigned long long (*tep_func_handler)(struct trace_seq *s,
@@ -431,12 +389,12 @@ enum tep_errno {
 };
 #undef _PE
 
-struct plugin_list;
+struct tep_plugin_list;
 
 #define INVALID_PLUGIN_LIST_OPTION      ((char **)((unsigned long)-1))
 
-struct plugin_list *tep_load_plugins(struct tep_handle *pevent);
-void tep_unload_plugins(struct plugin_list *plugin_list,
+struct tep_plugin_list *tep_load_plugins(struct tep_handle *pevent);
+void tep_unload_plugins(struct tep_plugin_list *plugin_list,
                         struct tep_handle *pevent);
 char **tep_plugin_list_options(void);
 void tep_plugin_free_options_list(char **list);
@@ -445,156 +403,25 @@ int tep_plugin_add_options(const char *name,
 void tep_plugin_remove_options(struct tep_plugin_option *options);
 void tep_print_plugins(struct trace_seq *s,
                         const char *prefix, const char *suffix,
-                        const struct plugin_list *list);
-
-struct cmdline;
-struct cmdline_list;
-struct func_map;
-struct func_list;
-struct event_handler;
-struct func_resolver;
+                        const struct tep_plugin_list *list);
 
+/* tep_handle */
 typedef char *(tep_func_resolver_t)(void *priv,
                                     unsigned long long *addrp, char **modp);
+void tep_set_flag(struct tep_handle *tep, int flag);
+unsigned short __tep_data2host2(struct tep_handle *pevent, unsigned short data);
+unsigned int __tep_data2host4(struct tep_handle *pevent, unsigned int data);
+unsigned long long
+__tep_data2host8(struct tep_handle *pevent, unsigned long long data);
 
-struct tep_handle {
-        int ref_count;
-
-        int header_page_ts_offset;
-        int header_page_ts_size;
-        int header_page_size_offset;
-        int header_page_size_size;
-        int header_page_data_offset;
-        int header_page_data_size;
-        int header_page_overwrite;
-
-        int file_bigendian;
-        int host_bigendian;
-
-        int latency_format;
-
-        int old_format;
-
-        int cpus;
-        int long_size;
-        int page_size;
-
-        struct cmdline *cmdlines;
-        struct cmdline_list *cmdlist;
-        int cmdline_count;
-
-        struct func_map *func_map;
-        struct func_resolver *func_resolver;
-        struct func_list *funclist;
-        unsigned int func_count;
-
-        struct printk_map *printk_map;
-        struct printk_list *printklist;
-        unsigned int printk_count;
-
-
-        struct event_format **events;
-        int nr_events;
-        struct event_format **sort_events;
-        enum event_sort_type last_type;
-
-        int type_offset;
-        int type_size;
-
-        int pid_offset;
-        int pid_size;
-
-        int pc_offset;
-        int pc_size;
-
-        int flags_offset;
-        int flags_size;
-
-        int ld_offset;
-        int ld_size;
-
-        int print_raw;
-
-        int test_filters;
-
-        int flags;
-
-        struct format_field *bprint_ip_field;
-        struct format_field *bprint_fmt_field;
-        struct format_field *bprint_buf_field;
-
-        struct event_handler *handlers;
-        struct tep_function_handler *func_handlers;
-
-        /* cache */
-        struct event_format *last_event;
-
-        char *trace_clock;
-};
-
-static inline void tep_set_flag(struct tep_handle *pevent, int flag)
-{
-        pevent->flags |= flag;
-}
-
-static inline unsigned short
-__data2host2(struct tep_handle *pevent, unsigned short data)
-{
-        unsigned short swap;
-
-        if (pevent->host_bigendian == pevent->file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 8) |
-                ((data & (0xffULL << 8)) >> 8);
-
-        return swap;
-}
-
-static inline unsigned int
-__data2host4(struct tep_handle *pevent, unsigned int data)
-{
-        unsigned int swap;
-
-        if (pevent->host_bigendian == pevent->file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 24) |
-                ((data & (0xffULL << 8)) << 8) |
-                ((data & (0xffULL << 16)) >> 8) |
-                ((data & (0xffULL << 24)) >> 24);
-
-        return swap;
-}
-
-static inline unsigned long long
-__data2host8(struct tep_handle *pevent, unsigned long long data)
-{
-        unsigned long long swap;
-
-        if (pevent->host_bigendian == pevent->file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 56) |
-                ((data & (0xffULL << 8)) << 40) |
-                ((data & (0xffULL << 16)) << 24) |
-                ((data & (0xffULL << 24)) << 8) |
-                ((data & (0xffULL << 32)) >> 8) |
-                ((data & (0xffULL << 40)) >> 24) |
-                ((data & (0xffULL << 48)) >> 40) |
-                ((data & (0xffULL << 56)) >> 56);
-
-        return swap;
-}
-
-#define data2host2(pevent, ptr)         __data2host2(pevent, *(unsigned short *)(ptr))
-#define data2host4(pevent, ptr)         __data2host4(pevent, *(unsigned int *)(ptr))
-#define data2host8(pevent, ptr)                                 \
+#define tep_data2host2(pevent, ptr)     __tep_data2host2(pevent, *(unsigned short *)(ptr))
+#define tep_data2host4(pevent, ptr)     __tep_data2host4(pevent, *(unsigned int *)(ptr))
+#define tep_data2host8(pevent, ptr)     \
 ({                                                              \
         unsigned long long __val;                               \
                                                                 \
         memcpy(&__val, (ptr), sizeof(unsigned long long));      \
-        __data2host8(pevent, __val);                            \
+        __tep_data2host8(pevent, __val);                                \
 })
 
 static inline int tep_host_bigendian(void)
@@ -627,14 +454,14 @@ int tep_register_print_string(struct tep_handle *pevent, const char *fmt,
 int tep_pid_is_registered(struct tep_handle *pevent, int pid);
 
 void tep_print_event_task(struct tep_handle *pevent, struct trace_seq *s,
-                          struct event_format *event,
+                          struct tep_event_format *event,
                           struct tep_record *record);
 void tep_print_event_time(struct tep_handle *pevent, struct trace_seq *s,
-                          struct event_format *event,
+                          struct tep_event_format *event,
                           struct tep_record *record,
                           bool use_trace_clock);
 void tep_print_event_data(struct tep_handle *pevent, struct trace_seq *s,
-                          struct event_format *event,
+                          struct tep_event_format *event,
                           struct tep_record *record);
 void tep_print_event(struct tep_handle *pevent, struct trace_seq *s,
                      struct tep_record *record, bool use_trace_clock);
@@ -645,32 +472,32 @@ int tep_parse_header_page(struct tep_handle *pevent, char *buf, unsigned long si
 enum tep_errno tep_parse_event(struct tep_handle *pevent, const char *buf,
                                unsigned long size, const char *sys);
 enum tep_errno tep_parse_format(struct tep_handle *pevent,
-                                struct event_format **eventp,
+                                struct tep_event_format **eventp,
                                 const char *buf,
                                 unsigned long size, const char *sys);
-void tep_free_format(struct event_format *event);
-void tep_free_format_field(struct format_field *field);
+void tep_free_format(struct tep_event_format *event);
+void tep_free_format_field(struct tep_format_field *field);
 
-void *tep_get_field_raw(struct trace_seq *s, struct event_format *event,
+void *tep_get_field_raw(struct trace_seq *s, struct tep_event_format *event,
                         const char *name, struct tep_record *record,
                         int *len, int err);
 
-int tep_get_field_val(struct trace_seq *s, struct event_format *event,
+int tep_get_field_val(struct trace_seq *s, struct tep_event_format *event,
                       const char *name, struct tep_record *record,
                       unsigned long long *val, int err);
-int tep_get_common_field_val(struct trace_seq *s, struct event_format *event,
+int tep_get_common_field_val(struct trace_seq *s, struct tep_event_format *event,
                              const char *name, struct tep_record *record,
                              unsigned long long *val, int err);
-int tep_get_any_field_val(struct trace_seq *s, struct event_format *event,
+int tep_get_any_field_val(struct trace_seq *s, struct tep_event_format *event,
                           const char *name, struct tep_record *record,
                           unsigned long long *val, int err);
 
 int tep_print_num_field(struct trace_seq *s, const char *fmt,
-                           struct event_format *event, const char *name,
-                           struct tep_record *record, int err);
+                        struct tep_event_format *event, const char *name,
+                        struct tep_record *record, int err);
 
 int tep_print_func_field(struct trace_seq *s, const char *fmt,
-                         struct event_format *event, const char *name,
+                         struct tep_event_format *event, const char *name,
                          struct tep_record *record, int err);
 
 int tep_register_event_handler(struct tep_handle *pevent, int id,
@@ -686,29 +513,30 @@ int tep_register_print_function(struct tep_handle *pevent,
 int tep_unregister_print_function(struct tep_handle *pevent,
                                   tep_func_handler func, char *name);
 
-struct format_field *tep_find_common_field(struct event_format *event, const char *name);
-struct format_field *tep_find_field(struct event_format *event, const char *name);
-struct format_field *tep_find_any_field(struct event_format *event, const char *name);
+struct tep_format_field *tep_find_common_field(struct tep_event_format *event, const char *name);
+struct tep_format_field *tep_find_field(struct tep_event_format *event, const char *name);
+struct tep_format_field *tep_find_any_field(struct tep_event_format *event, const char *name);
 
 const char *tep_find_function(struct tep_handle *pevent, unsigned long long addr);
 unsigned long long
 tep_find_function_address(struct tep_handle *pevent, unsigned long long addr);
 unsigned long long tep_read_number(struct tep_handle *pevent, const void *ptr, int size);
-int tep_read_number_field(struct format_field *field, const void *data,
+int tep_read_number_field(struct tep_format_field *field, const void *data,
                           unsigned long long *value);
 
-struct event_format *tep_find_event(struct tep_handle *pevent, int id);
+struct tep_event_format *tep_get_first_event(struct tep_handle *tep);
+int tep_get_events_count(struct tep_handle *tep);
+struct tep_event_format *tep_find_event(struct tep_handle *pevent, int id);
 
-struct event_format *
+struct tep_event_format *
 tep_find_event_by_name(struct tep_handle *pevent, const char *sys, const char *name);
-
-struct event_format *
+struct tep_event_format *
 tep_find_event_by_record(struct tep_handle *pevent, struct tep_record *record);
 
 void tep_data_lat_fmt(struct tep_handle *pevent,
                       struct trace_seq *s, struct tep_record *record);
 int tep_data_type(struct tep_handle *pevent, struct tep_record *rec);
-struct event_format *tep_data_event_from_type(struct tep_handle *pevent, int type);
+struct tep_event_format *tep_data_event_from_type(struct tep_handle *pevent, int type);
 int tep_data_pid(struct tep_handle *pevent, struct tep_record *rec);
 int tep_data_preempt_count(struct tep_handle *pevent, struct tep_record *rec);
 int tep_data_flags(struct tep_handle *pevent, struct tep_record *rec);
@@ -719,77 +547,35 @@ struct cmdline *tep_data_pid_from_comm(struct tep_handle *pevent, const char *co
 int tep_cmdline_pid(struct tep_handle *pevent, struct cmdline *cmdline);
 
 void tep_print_field(struct trace_seq *s, void *data,
-                     struct format_field *field);
+                     struct tep_format_field *field);
 void tep_print_fields(struct trace_seq *s, void *data,
-                      int size __maybe_unused, struct event_format *event);
-void tep_event_info(struct trace_seq *s, struct event_format *event,
+                      int size __maybe_unused, struct tep_event_format *event);
+void tep_event_info(struct trace_seq *s, struct tep_event_format *event,
                        struct tep_record *record);
 int tep_strerror(struct tep_handle *pevent, enum tep_errno errnum,
                     char *buf, size_t buflen);
 
-struct event_format **tep_list_events(struct tep_handle *pevent, enum event_sort_type);
-struct format_field **tep_event_common_fields(struct event_format *event);
-struct format_field **tep_event_fields(struct event_format *event);
-
-static inline int tep_get_cpus(struct tep_handle *pevent)
-{
-        return pevent->cpus;
-}
-
-static inline void tep_set_cpus(struct tep_handle *pevent, int cpus)
-{
-        pevent->cpus = cpus;
-}
-
-static inline int tep_get_long_size(struct tep_handle *pevent)
-{
-        return pevent->long_size;
-}
-
-static inline void tep_set_long_size(struct tep_handle *pevent, int long_size)
-{
-        pevent->long_size = long_size;
-}
-
-static inline int tep_get_page_size(struct tep_handle *pevent)
-{
-        return pevent->page_size;
-}
-
-static inline void tep_set_page_size(struct tep_handle *pevent, int _page_size)
-{
-        pevent->page_size = _page_size;
-}
-
-static inline int tep_is_file_bigendian(struct tep_handle *pevent)
-{
-        return pevent->file_bigendian;
-}
-
-static inline void tep_set_file_bigendian(struct tep_handle *pevent, int endian)
-{
-        pevent->file_bigendian = endian;
-}
-
-static inline int tep_is_host_bigendian(struct tep_handle *pevent)
-{
-        return pevent->host_bigendian;
-}
-
-static inline void tep_set_host_bigendian(struct tep_handle *pevent, int endian)
-{
-        pevent->host_bigendian = endian;
-}
-
-static inline int tep_is_latency_format(struct tep_handle *pevent)
-{
-        return pevent->latency_format;
-}
-
-static inline void tep_set_latency_format(struct tep_handle *pevent, int lat)
-{
-        pevent->latency_format = lat;
-}
+struct tep_event_format **tep_list_events(struct tep_handle *pevent, enum tep_event_sort_type);
+struct tep_format_field **tep_event_common_fields(struct tep_event_format *event);
+struct tep_format_field **tep_event_fields(struct tep_event_format *event);
+
+enum tep_endian {
+        TEP_LITTLE_ENDIAN = 0,
+        TEP_BIG_ENDIAN
+};
+int tep_get_cpus(struct tep_handle *pevent);
+void tep_set_cpus(struct tep_handle *pevent, int cpus);
+int tep_get_long_size(struct tep_handle *pevent);
+void tep_set_long_size(struct tep_handle *pevent, int long_size);
+int tep_get_page_size(struct tep_handle *pevent);
+void tep_set_page_size(struct tep_handle *pevent, int _page_size);
+int tep_is_file_bigendian(struct tep_handle *pevent);
+void tep_set_file_bigendian(struct tep_handle *pevent, enum tep_endian endian);
+int tep_is_host_bigendian(struct tep_handle *pevent);
+void tep_set_host_bigendian(struct tep_handle *pevent, enum tep_endian endian);
+int tep_is_latency_format(struct tep_handle *pevent);
+void tep_set_latency_format(struct tep_handle *pevent, int lat);
+int tep_get_header_page_size(struct tep_handle *pevent);
 
 struct tep_handle *tep_alloc(void);
 void tep_free(struct tep_handle *pevent);
@@ -798,7 +584,7 @@ void tep_unref(struct tep_handle *pevent);
 
 /* access to the internal parser */
 void tep_buffer_init(const char *buf, unsigned long long size);
-enum event_type tep_read_token(char **tok);
+enum tep_event_type tep_read_token(char **tok);
 void tep_free_token(char *token);
 int tep_peek_char(void);
 const char *tep_get_input_buf(void);
@@ -810,136 +596,136 @@ void tep_print_printk(struct tep_handle *pevent);
 
 /* ----------------------- filtering ----------------------- */
 
-enum filter_boolean_type {
-        FILTER_FALSE,
-        FILTER_TRUE,
+enum tep_filter_boolean_type {
+        TEP_FILTER_FALSE,
+        TEP_FILTER_TRUE,
 };
 
-enum filter_op_type {
-        FILTER_OP_AND = 1,
-        FILTER_OP_OR,
-        FILTER_OP_NOT,
+enum tep_filter_op_type {
+        TEP_FILTER_OP_AND = 1,
+        TEP_FILTER_OP_OR,
+        TEP_FILTER_OP_NOT,
 };
 
-enum filter_cmp_type {
-        FILTER_CMP_NONE,
-        FILTER_CMP_EQ,
-        FILTER_CMP_NE,
-        FILTER_CMP_GT,
-        FILTER_CMP_LT,
-        FILTER_CMP_GE,
-        FILTER_CMP_LE,
-        FILTER_CMP_MATCH,
-        FILTER_CMP_NOT_MATCH,
-        FILTER_CMP_REGEX,
-        FILTER_CMP_NOT_REGEX,
+enum tep_filter_cmp_type {
+        TEP_FILTER_CMP_NONE,
+        TEP_FILTER_CMP_EQ,
+        TEP_FILTER_CMP_NE,
+        TEP_FILTER_CMP_GT,
+        TEP_FILTER_CMP_LT,
+        TEP_FILTER_CMP_GE,
+        TEP_FILTER_CMP_LE,
+        TEP_FILTER_CMP_MATCH,
+        TEP_FILTER_CMP_NOT_MATCH,
+        TEP_FILTER_CMP_REGEX,
+        TEP_FILTER_CMP_NOT_REGEX,
 };
 
-enum filter_exp_type {
-        FILTER_EXP_NONE,
-        FILTER_EXP_ADD,
-        FILTER_EXP_SUB,
-        FILTER_EXP_MUL,
-        FILTER_EXP_DIV,
-        FILTER_EXP_MOD,
-        FILTER_EXP_RSHIFT,
-        FILTER_EXP_LSHIFT,
-        FILTER_EXP_AND,
-        FILTER_EXP_OR,
-        FILTER_EXP_XOR,
-        FILTER_EXP_NOT,
+enum tep_filter_exp_type {
+        TEP_FILTER_EXP_NONE,
+        TEP_FILTER_EXP_ADD,
+        TEP_FILTER_EXP_SUB,
+        TEP_FILTER_EXP_MUL,
+        TEP_FILTER_EXP_DIV,
+        TEP_FILTER_EXP_MOD,
+        TEP_FILTER_EXP_RSHIFT,
+        TEP_FILTER_EXP_LSHIFT,
+        TEP_FILTER_EXP_AND,
+        TEP_FILTER_EXP_OR,
+        TEP_FILTER_EXP_XOR,
+        TEP_FILTER_EXP_NOT,
 };
 
-enum filter_arg_type {
-        FILTER_ARG_NONE,
-        FILTER_ARG_BOOLEAN,
-        FILTER_ARG_VALUE,
-        FILTER_ARG_FIELD,
-        FILTER_ARG_EXP,
-        FILTER_ARG_OP,
-        FILTER_ARG_NUM,
-        FILTER_ARG_STR,
+enum tep_filter_arg_type {
+        TEP_FILTER_ARG_NONE,
+        TEP_FILTER_ARG_BOOLEAN,
+        TEP_FILTER_ARG_VALUE,
+        TEP_FILTER_ARG_FIELD,
+        TEP_FILTER_ARG_EXP,
+        TEP_FILTER_ARG_OP,
+        TEP_FILTER_ARG_NUM,
+        TEP_FILTER_ARG_STR,
 };
 
-enum filter_value_type {
-        FILTER_NUMBER,
-        FILTER_STRING,
-        FILTER_CHAR
+enum tep_filter_value_type {
+        TEP_FILTER_NUMBER,
+        TEP_FILTER_STRING,
+        TEP_FILTER_CHAR
 };
 
-struct fliter_arg;
+struct tep_filter_arg;
 
-struct filter_arg_boolean {
-        enum filter_boolean_type        value;
+struct tep_filter_arg_boolean {
+        enum tep_filter_boolean_type    value;
 };
 
-struct filter_arg_field {
-        struct format_field     *field;
+struct tep_filter_arg_field {
+        struct tep_format_field         *field;
 };
 
-struct filter_arg_value {
-        enum filter_value_type  type;
+struct tep_filter_arg_value {
+        enum tep_filter_value_type      type;
         union {
                 char                    *str;
                 unsigned long long      val;
         };
 };
 
-struct filter_arg_op {
-        enum filter_op_type     type;
-        struct filter_arg       *left;
-        struct filter_arg       *right;
+struct tep_filter_arg_op {
+        enum tep_filter_op_type         type;
+        struct tep_filter_arg           *left;
+        struct tep_filter_arg           *right;
 };
 
-struct filter_arg_exp {
-        enum filter_exp_type    type;
-        struct filter_arg       *left;
-        struct filter_arg       *right;
+struct tep_filter_arg_exp {
+        enum tep_filter_exp_type        type;
+        struct tep_filter_arg           *left;
+        struct tep_filter_arg           *right;
 };
 
-struct filter_arg_num {
-        enum filter_cmp_type    type;
-        struct filter_arg       *left;
-        struct filter_arg       *right;
+struct tep_filter_arg_num {
+        enum tep_filter_cmp_type        type;
+        struct tep_filter_arg           *left;
+        struct tep_filter_arg           *right;
 };
 
-struct filter_arg_str {
-        enum filter_cmp_type    type;
-        struct format_field     *field;
-        char                    *val;
-        char                    *buffer;
-        regex_t                 reg;
+struct tep_filter_arg_str {
+        enum tep_filter_cmp_type        type;
+        struct tep_format_field         *field;
+        char                            *val;
+        char                            *buffer;
+        regex_t                         reg;
 };
 
-struct filter_arg {
-        enum filter_arg_type    type;
+struct tep_filter_arg {
+        enum tep_filter_arg_type                type;
         union {
-                struct filter_arg_boolean       boolean;
-                struct filter_arg_field         field;
-                struct filter_arg_value         value;
-                struct filter_arg_op            op;
-                struct filter_arg_exp           exp;
-                struct filter_arg_num           num;
-                struct filter_arg_str           str;
+                struct tep_filter_arg_boolean   boolean;
+                struct tep_filter_arg_field     field;
+                struct tep_filter_arg_value     value;
+                struct tep_filter_arg_op        op;
+                struct tep_filter_arg_exp       exp;
+                struct tep_filter_arg_num       num;
+                struct tep_filter_arg_str       str;
         };
 };
 
-struct filter_type {
+struct tep_filter_type {
         int                     event_id;
-        struct event_format     *event;
-        struct filter_arg       *filter;
+        struct tep_event_format *event;
+        struct tep_filter_arg   *filter;
 };
 
 #define TEP_FILTER_ERROR_BUFSZ  1024
 
-struct event_filter {
+struct tep_event_filter {
         struct tep_handle       *pevent;
         int                     filters;
-        struct filter_type      *event_filters;
+        struct tep_filter_type  *event_filters;
         char                    error_buffer[TEP_FILTER_ERROR_BUFSZ];
 };
 
-struct event_filter *tep_filter_alloc(struct tep_handle *pevent);
+struct tep_event_filter *tep_filter_alloc(struct tep_handle *pevent);
 
 /* for backward compatibility */
 #define FILTER_NONE             TEP_ERRNO__NO_FILTER
@@ -947,45 +733,45 @@ struct event_filter *tep_filter_alloc(struct tep_handle *pevent);
 #define FILTER_MISS             TEP_ERRNO__FILTER_MISS
 #define FILTER_MATCH            TEP_ERRNO__FILTER_MATCH
 
-enum filter_trivial_type {
-        FILTER_TRIVIAL_FALSE,
-        FILTER_TRIVIAL_TRUE,
-        FILTER_TRIVIAL_BOTH,
+enum tep_filter_trivial_type {
+        TEP_FILTER_TRIVIAL_FALSE,
+        TEP_FILTER_TRIVIAL_TRUE,
+        TEP_FILTER_TRIVIAL_BOTH,
 };
 
-enum tep_errno tep_filter_add_filter_str(struct event_filter *filter,
+enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter,
                                          const char *filter_str);
 
-enum tep_errno tep_filter_match(struct event_filter *filter,
+enum tep_errno tep_filter_match(struct tep_event_filter *filter,
                                 struct tep_record *record);
 
-int tep_filter_strerror(struct event_filter *filter, enum tep_errno err,
+int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err,
                         char *buf, size_t buflen);
 
-int tep_event_filtered(struct event_filter *filter,
+int tep_event_filtered(struct tep_event_filter *filter,
                        int event_id);
 
-void tep_filter_reset(struct event_filter *filter);
+void tep_filter_reset(struct tep_event_filter *filter);
 
-int tep_filter_clear_trivial(struct event_filter *filter,
-                             enum filter_trivial_type type);
+int tep_filter_clear_trivial(struct tep_event_filter *filter,
+                             enum tep_filter_trivial_type type);
 
-void tep_filter_free(struct event_filter *filter);
+void tep_filter_free(struct tep_event_filter *filter);
 
-char *tep_filter_make_string(struct event_filter *filter, int event_id);
+char *tep_filter_make_string(struct tep_event_filter *filter, int event_id);
 
-int tep_filter_remove_event(struct event_filter *filter,
+int tep_filter_remove_event(struct tep_event_filter *filter,
                             int event_id);
 
-int tep_filter_event_has_trivial(struct event_filter *filter,
+int tep_filter_event_has_trivial(struct tep_event_filter *filter,
                                  int event_id,
-                                 enum filter_trivial_type type);
+                                 enum tep_filter_trivial_type type);
 
-int tep_filter_copy(struct event_filter *dest, struct event_filter *source);
+int tep_filter_copy(struct tep_event_filter *dest, struct tep_event_filter *source);
 
-int tep_update_trivial(struct event_filter *dest, struct event_filter *source,
-                        enum filter_trivial_type type);
+int tep_update_trivial(struct tep_event_filter *dest, struct tep_event_filter *source,
+                        enum tep_filter_trivial_type type);
 
-int tep_filter_compare(struct event_filter *filter1, struct event_filter *filter2);
+int tep_filter_compare(struct tep_event_filter *filter1, struct tep_event_filter *filter2);
 
 #endif /* _PARSE_EVENTS_H */
diff --git a/tools/lib/traceevent/event-plugin.c b/tools/lib/traceevent/event-plugin.c
index f17e25097e1e..e74f16c88398 100644
--- a/tools/lib/traceevent/event-plugin.c
+++ b/tools/lib/traceevent/event-plugin.c
@@ -14,7 +14,9 @@
 #include <unistd.h>
 #include <dirent.h>
 #include "event-parse.h"
+#include "event-parse-local.h"
 #include "event-utils.h"
+#include "trace-seq.h"
 
 #define LOCAL_PLUGIN_DIR ".traceevent/plugins"
 
@@ -30,8 +32,8 @@ static struct trace_plugin_options {
         char                            *value;
 } *trace_plugin_options;
 
-struct plugin_list {
-        struct plugin_list      *next;
+struct tep_plugin_list {
+        struct tep_plugin_list  *next;
         char                    *name;
         void                    *handle;
 };
@@ -258,7 +260,7 @@ void tep_plugin_remove_options(struct tep_plugin_option *options)
  */
 void tep_print_plugins(struct trace_seq *s,
                        const char *prefix, const char *suffix,
-                       const struct plugin_list *list)
+                       const struct tep_plugin_list *list)
 {
         while (list) {
                 trace_seq_printf(s, "%s%s%s", prefix, list->name, suffix);
@@ -270,9 +272,9 @@ static void
 load_plugin(struct tep_handle *pevent, const char *path,
             const char *file, void *data)
 {
-        struct plugin_list **plugin_list = data;
+        struct tep_plugin_list **plugin_list = data;
         tep_plugin_load_func func;
-        struct plugin_list *list;
+        struct tep_plugin_list *list;
         const char *alias;
         char *plugin;
         void *handle;
@@ -416,20 +418,20 @@ load_plugins(struct tep_handle *pevent, const char *suffix,
         free(path);
 }
 
-struct plugin_list*
+struct tep_plugin_list*
 tep_load_plugins(struct tep_handle *pevent)
 {
-        struct plugin_list *list = NULL;
+        struct tep_plugin_list *list = NULL;
 
         load_plugins(pevent, ".so", load_plugin, &list);
         return list;
 }
 
 void
-tep_unload_plugins(struct plugin_list *plugin_list, struct tep_handle *pevent)
+tep_unload_plugins(struct tep_plugin_list *plugin_list, struct tep_handle *pevent)
 {
         tep_plugin_unload_func func;
-        struct plugin_list *list;
+        struct tep_plugin_list *list;
 
         while (plugin_list) {
                 list = plugin_list;
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index e76154c02ee7..ed87cb56713d 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -11,22 +11,23 @@
 #include <sys/types.h>
 
 #include "event-parse.h"
+#include "event-parse-local.h"
 #include "event-utils.h"
 
 #define COMM "COMM"
 #define CPU "CPU"
 
-static struct format_field comm = {
+static struct tep_format_field comm = {
         .name = "COMM",
 };
 
-static struct format_field cpu = {
+static struct tep_format_field cpu = {
         .name = "CPU",
 };
 
 struct event_list {
         struct event_list       *next;
-        struct event_format     *event;
+        struct tep_event_format *event;
 };
 
 static void show_error(char *error_buf, const char *fmt, ...)
@@ -61,15 +62,15 @@ static void free_token(char *token)
         tep_free_token(token);
 }
 
-static enum event_type read_token(char **tok)
+static enum tep_event_type read_token(char **tok)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token = NULL;
 
         do {
                 free_token(token);
                 type = tep_read_token(&token);
-        } while (type == EVENT_NEWLINE || type == EVENT_SPACE);
+        } while (type == TEP_EVENT_NEWLINE || type == TEP_EVENT_SPACE);
 
         /* If token is = or ! check to see if the next char is ~ */
         if (token &&
@@ -79,7 +80,7 @@ static enum event_type read_token(char **tok)
                 *tok = malloc(3);
                 if (*tok == NULL) {
                         free_token(token);
-                        return EVENT_ERROR;
+                        return TEP_EVENT_ERROR;
                 }
                 sprintf(*tok, "%c%c", *token, '~');
                 free_token(token);
@@ -94,8 +95,8 @@ static enum event_type read_token(char **tok)
 
 static int filter_cmp(const void *a, const void *b)
 {
-        const struct filter_type *ea = a;
-        const struct filter_type *eb = b;
+        const struct tep_filter_type *ea = a;
+        const struct tep_filter_type *eb = b;
 
         if (ea->event_id < eb->event_id)
                 return -1;
@@ -106,11 +107,11 @@ static int filter_cmp(const void *a, const void *b)
         return 0;
 }
 
-static struct filter_type *
-find_filter_type(struct event_filter *filter, int id)
+static struct tep_filter_type *
+find_filter_type(struct tep_event_filter *filter, int id)
 {
-        struct filter_type *filter_type;
-        struct filter_type key;
+        struct tep_filter_type *filter_type;
+        struct tep_filter_type key;
 
         key.event_id = id;
 
@@ -122,10 +123,10 @@ find_filter_type(struct event_filter *filter, int id)
         return filter_type;
 }
 
-static struct filter_type *
-add_filter_type(struct event_filter *filter, int id)
+static struct tep_filter_type *
+add_filter_type(struct tep_event_filter *filter, int id)
 {
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
         int i;
 
         filter_type = find_filter_type(filter, id);
@@ -165,9 +166,9 @@ add_filter_type(struct event_filter *filter, int id)
  * tep_filter_alloc - create a new event filter
  * @pevent: The pevent that this filter is associated with
  */
-struct event_filter *tep_filter_alloc(struct tep_handle *pevent)
+struct tep_event_filter *tep_filter_alloc(struct tep_handle *pevent)
 {
-        struct event_filter *filter;
+        struct tep_event_filter *filter;
 
         filter = malloc(sizeof(*filter));
         if (filter == NULL)
@@ -180,44 +181,44 @@ struct event_filter *tep_filter_alloc(struct tep_handle *pevent)
         return filter;
 }
 
-static struct filter_arg *allocate_arg(void)
+static struct tep_filter_arg *allocate_arg(void)
 {
-        return calloc(1, sizeof(struct filter_arg));
+        return calloc(1, sizeof(struct tep_filter_arg));
 }
 
-static void free_arg(struct filter_arg *arg)
+static void free_arg(struct tep_filter_arg *arg)
 {
         if (!arg)
                 return;
 
         switch (arg->type) {
-        case FILTER_ARG_NONE:
-        case FILTER_ARG_BOOLEAN:
+        case TEP_FILTER_ARG_NONE:
+        case TEP_FILTER_ARG_BOOLEAN:
                 break;
 
-        case FILTER_ARG_NUM:
+        case TEP_FILTER_ARG_NUM:
                 free_arg(arg->num.left);
                 free_arg(arg->num.right);
                 break;
 
-        case FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_EXP:
                 free_arg(arg->exp.left);
                 free_arg(arg->exp.right);
                 break;
 
-        case FILTER_ARG_STR:
+        case TEP_FILTER_ARG_STR:
                 free(arg->str.val);
                 regfree(&arg->str.reg);
                 free(arg->str.buffer);
                 break;
 
-        case FILTER_ARG_VALUE:
-                if (arg->value.type == FILTER_STRING ||
-                    arg->value.type == FILTER_CHAR)
+        case TEP_FILTER_ARG_VALUE:
+                if (arg->value.type == TEP_FILTER_STRING ||
+                    arg->value.type == TEP_FILTER_CHAR)
                         free(arg->value.str);
                 break;
 
-        case FILTER_ARG_OP:
+        case TEP_FILTER_ARG_OP:
                 free_arg(arg->op.left);
                 free_arg(arg->op.right);
         default:
@@ -228,7 +229,7 @@ static void free_arg(struct filter_arg *arg)
 }
 
 static int add_event(struct event_list **events,
-                      struct event_format *event)
+                     struct tep_event_format *event)
 {
         struct event_list *list;
 
@@ -242,7 +243,7 @@ static int add_event(struct event_list **events,
         return 0;
 }
 
-static int event_match(struct event_format *event,
+static int event_match(struct tep_event_format *event,
                        regex_t *sreg, regex_t *ereg)
 {
         if (sreg) {
@@ -258,7 +259,7 @@ static enum tep_errno
 find_event(struct tep_handle *pevent, struct event_list **events,
            char *sys_name, char *event_name)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         regex_t ereg;
         regex_t sreg;
         int match = 0;
@@ -333,11 +334,11 @@ static void free_events(struct event_list *events)
 }
 
 static enum tep_errno
-create_arg_item(struct event_format *event, const char *token,
-                enum event_type type, struct filter_arg **parg, char *error_str)
+create_arg_item(struct tep_event_format *event, const char *token,
+                enum tep_event_type type, struct tep_filter_arg **parg, char *error_str)
 {
-        struct format_field *field;
-        struct filter_arg *arg;
+        struct tep_format_field *field;
+        struct tep_filter_arg *arg;
 
         arg = allocate_arg();
         if (arg == NULL) {
@@ -347,11 +348,11 @@ create_arg_item(struct event_format *event, const char *token,
 
         switch (type) {
 
-        case EVENT_SQUOTE:
-        case EVENT_DQUOTE:
-                arg->type = FILTER_ARG_VALUE;
+        case TEP_EVENT_SQUOTE:
+        case TEP_EVENT_DQUOTE:
+                arg->type = TEP_FILTER_ARG_VALUE;
                 arg->value.type =
-                        type == EVENT_DQUOTE ? FILTER_STRING : FILTER_CHAR;
+                        type == TEP_EVENT_DQUOTE ? TEP_FILTER_STRING : TEP_FILTER_CHAR;
                 arg->value.str = strdup(token);
                 if (!arg->value.str) {
                         free_arg(arg);
@@ -359,11 +360,11 @@ create_arg_item(struct event_format *event, const char *token,
                         return TEP_ERRNO__MEM_ALLOC_FAILED;
                 }
                 break;
-        case EVENT_ITEM:
+        case TEP_EVENT_ITEM:
                 /* if it is a number, then convert it */
                 if (isdigit(token[0])) {
-                        arg->type = FILTER_ARG_VALUE;
-                        arg->value.type = FILTER_NUMBER;
+                        arg->type = TEP_FILTER_ARG_VALUE;
+                        arg->value.type = TEP_FILTER_NUMBER;
                         arg->value.val = strtoull(token, NULL, 0);
                         break;
                 }
@@ -377,12 +378,12 @@ create_arg_item(struct event_format *event, const char *token,
                                 field = &cpu;
                         } else {
                                 /* not a field, Make it false */
-                                arg->type = FILTER_ARG_BOOLEAN;
-                                arg->boolean.value = FILTER_FALSE;
+                                arg->type = TEP_FILTER_ARG_BOOLEAN;
+                                arg->boolean.value = TEP_FILTER_FALSE;
                                 break;
                         }
                 }
-                arg->type = FILTER_ARG_FIELD;
+                arg->type = TEP_FILTER_ARG_FIELD;
                 arg->field.field = field;
                 break;
         default:
@@ -394,82 +395,82 @@ create_arg_item(struct event_format *event, const char *token,
         return 0;
 }
 
-static struct filter_arg *
-create_arg_op(enum filter_op_type btype)
+static struct tep_filter_arg *
+create_arg_op(enum tep_filter_op_type btype)
 {
-        struct filter_arg *arg;
+        struct tep_filter_arg *arg;
 
         arg = allocate_arg();
         if (!arg)
                 return NULL;
 
-        arg->type = FILTER_ARG_OP;
+        arg->type = TEP_FILTER_ARG_OP;
         arg->op.type = btype;
 
         return arg;
 }
 
-static struct filter_arg *
-create_arg_exp(enum filter_exp_type etype)
+static struct tep_filter_arg *
+create_arg_exp(enum tep_filter_exp_type etype)
 {
-        struct filter_arg *arg;
+        struct tep_filter_arg *arg;
 
         arg = allocate_arg();
         if (!arg)
                 return NULL;
 
-        arg->type = FILTER_ARG_EXP;
+        arg->type = TEP_FILTER_ARG_EXP;
         arg->exp.type = etype;
 
         return arg;
 }
 
-static struct filter_arg *
-create_arg_cmp(enum filter_cmp_type ctype)
+static struct tep_filter_arg *
+create_arg_cmp(enum tep_filter_cmp_type ctype)
 {
-        struct filter_arg *arg;
+        struct tep_filter_arg *arg;
 
         arg = allocate_arg();
         if (!arg)
                 return NULL;
 
         /* Use NUM and change if necessary */
-        arg->type = FILTER_ARG_NUM;
+        arg->type = TEP_FILTER_ARG_NUM;
         arg->num.type = ctype;
 
         return arg;
 }
 
 static enum tep_errno
-add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
+add_right(struct tep_filter_arg *op, struct tep_filter_arg *arg, char *error_str)
 {
-        struct filter_arg *left;
+        struct tep_filter_arg *left;
         char *str;
         int op_type;
         int ret;
 
         switch (op->type) {
-        case FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_EXP:
                 if (op->exp.right)
                         goto out_fail;
                 op->exp.right = arg;
                 break;
 
-        case FILTER_ARG_OP:
+        case TEP_FILTER_ARG_OP:
                 if (op->op.right)
                         goto out_fail;
                 op->op.right = arg;
                 break;
 
-        case FILTER_ARG_NUM:
+        case TEP_FILTER_ARG_NUM:
                 if (op->op.right)
                         goto out_fail;
                 /*
                  * The arg must be num, str, or field
                  */
                 switch (arg->type) {
-                case FILTER_ARG_VALUE:
-                case FILTER_ARG_FIELD:
+                case TEP_FILTER_ARG_VALUE:
+                case TEP_FILTER_ARG_FIELD:
                         break;
                 default:
                         show_error(error_str, "Illegal rvalue");
@@ -481,20 +482,20 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
                  * convert this to a string or regex.
                  */
                 switch (arg->value.type) {
-                case FILTER_CHAR:
+                case TEP_FILTER_CHAR:
                         /*
                          * A char should be converted to number if
                          * the string is 1 byte, and the compare
                          * is not a REGEX.
                          */
                         if (strlen(arg->value.str) == 1 &&
-                            op->num.type != FILTER_CMP_REGEX &&
-                            op->num.type != FILTER_CMP_NOT_REGEX) {
-                                arg->value.type = FILTER_NUMBER;
+                            op->num.type != TEP_FILTER_CMP_REGEX &&
+                            op->num.type != TEP_FILTER_CMP_NOT_REGEX) {
+                                arg->value.type = TEP_FILTER_NUMBER;
                                 goto do_int;
                         }
                         /* fall through */
-                case FILTER_STRING:
+                case TEP_FILTER_STRING:
 
                         /* convert op to a string arg */
                         op_type = op->num.type;
@@ -508,16 +509,16 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
                          * If left arg was a field not found then
                          * NULL the entire op.
                          */
-                        if (left->type == FILTER_ARG_BOOLEAN) {
+                        if (left->type == TEP_FILTER_ARG_BOOLEAN) {
                                 free_arg(left);
                                 free_arg(arg);
-                                op->type = FILTER_ARG_BOOLEAN;
-                                op->boolean.value = FILTER_FALSE;
+                                op->type = TEP_FILTER_ARG_BOOLEAN;
+                                op->boolean.value = TEP_FILTER_FALSE;
                                 break;
                         }
 
                         /* Left arg must be a field */
-                        if (left->type != FILTER_ARG_FIELD) {
+                        if (left->type != TEP_FILTER_ARG_FIELD) {
                                 show_error(error_str,
                                            "Illegal lvalue for string comparison");
                                 return TEP_ERRNO__ILLEGAL_LVALUE;
@@ -525,15 +526,15 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
 
                         /* Make sure this is a valid string compare */
                         switch (op_type) {
-                        case FILTER_CMP_EQ:
-                                op_type = FILTER_CMP_MATCH;
+                        case TEP_FILTER_CMP_EQ:
+                                op_type = TEP_FILTER_CMP_MATCH;
                                 break;
-                        case FILTER_CMP_NE:
-                                op_type = FILTER_CMP_NOT_MATCH;
+                        case TEP_FILTER_CMP_NE:
+                                op_type = TEP_FILTER_CMP_NOT_MATCH;
                                 break;
 
-                        case FILTER_CMP_REGEX:
-                        case FILTER_CMP_NOT_REGEX:
+                        case TEP_FILTER_CMP_REGEX:
+                        case TEP_FILTER_CMP_NOT_REGEX:
                                 ret = regcomp(&op->str.reg, str, REG_ICASE|REG_NOSUB);
                                 if (ret) {
                                         show_error(error_str,
@@ -548,7 +549,7 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
                                 return TEP_ERRNO__ILLEGAL_STRING_CMP;
                         }
 
-                        op->type = FILTER_ARG_STR;
+                        op->type = TEP_FILTER_ARG_STR;
                         op->str.type = op_type;
                         op->str.field = left->field.field;
                         op->str.val = strdup(str);
@@ -573,12 +574,12 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
 
                         break;
 
-                case FILTER_NUMBER:
+                case TEP_FILTER_NUMBER:
 
  do_int:
                         switch (op->num.type) {
-                        case FILTER_CMP_REGEX:
-                        case FILTER_CMP_NOT_REGEX:
+                        case TEP_FILTER_CMP_REGEX:
+                        case TEP_FILTER_CMP_NOT_REGEX:
                                 show_error(error_str,
                                            "Op not allowed with integers");
                                 return TEP_ERRNO__ILLEGAL_INTEGER_CMP;
@@ -605,35 +606,35 @@ add_right(struct filter_arg *op, struct filter_arg *arg, char *error_str)
         return TEP_ERRNO__SYNTAX_ERROR;
 }
 
-static struct filter_arg *
-rotate_op_right(struct filter_arg *a, struct filter_arg *b)
+static struct tep_filter_arg *
+rotate_op_right(struct tep_filter_arg *a, struct tep_filter_arg *b)
 {
-        struct filter_arg *arg;
+        struct tep_filter_arg *arg;
 
         arg = a->op.right;
         a->op.right = b;
         return arg;
 }
 
-static enum tep_errno add_left(struct filter_arg *op, struct filter_arg *arg)
+static enum tep_errno add_left(struct tep_filter_arg *op, struct tep_filter_arg *arg)
 {
         switch (op->type) {
-        case FILTER_ARG_EXP:
-                if (arg->type == FILTER_ARG_OP)
+        case TEP_FILTER_ARG_EXP:
+                if (arg->type == TEP_FILTER_ARG_OP)
                         arg = rotate_op_right(arg, op);
                 op->exp.left = arg;
                 break;
 
-        case FILTER_ARG_OP:
+        case TEP_FILTER_ARG_OP:
                 op->op.left = arg;
                 break;
-        case FILTER_ARG_NUM:
-                if (arg->type == FILTER_ARG_OP)
+        case TEP_FILTER_ARG_NUM:
+                if (arg->type == TEP_FILTER_ARG_OP)
                         arg = rotate_op_right(arg, op);
 
                 /* left arg of compares must be a field */
-                if (arg->type != FILTER_ARG_FIELD &&
-                    arg->type != FILTER_ARG_BOOLEAN)
+                if (arg->type != TEP_FILTER_ARG_FIELD &&
+                    arg->type != TEP_FILTER_ARG_BOOLEAN)
                         return TEP_ERRNO__INVALID_ARG_TYPE;
                 op->num.left = arg;
                 break;
@@ -652,91 +653,91 @@ enum op_type {
 };
 
 static enum op_type process_op(const char *token,
-                               enum filter_op_type *btype,
-                               enum filter_cmp_type *ctype,
-                               enum filter_exp_type *etype)
+                               enum tep_filter_op_type *btype,
+                               enum tep_filter_cmp_type *ctype,
+                               enum tep_filter_exp_type *etype)
 {
-        *btype = FILTER_OP_NOT;
-        *etype = FILTER_EXP_NONE;
-        *ctype = FILTER_CMP_NONE;
+        *btype = TEP_FILTER_OP_NOT;
+        *etype = TEP_FILTER_EXP_NONE;
+        *ctype = TEP_FILTER_CMP_NONE;
 
         if (strcmp(token, "&&") == 0)
-                *btype = FILTER_OP_AND;
+                *btype = TEP_FILTER_OP_AND;
         else if (strcmp(token, "||") == 0)
-                *btype = FILTER_OP_OR;
+                *btype = TEP_FILTER_OP_OR;
         else if (strcmp(token, "!") == 0)
                 return OP_NOT;
 
-        if (*btype != FILTER_OP_NOT)
+        if (*btype != TEP_FILTER_OP_NOT)
                 return OP_BOOL;
 
         /* Check for value expressions */
         if (strcmp(token, "+") == 0) {
-                *etype = FILTER_EXP_ADD;
+                *etype = TEP_FILTER_EXP_ADD;
         } else if (strcmp(token, "-") == 0) {
-                *etype = FILTER_EXP_SUB;
+                *etype = TEP_FILTER_EXP_SUB;
         } else if (strcmp(token, "*") == 0) {
-                *etype = FILTER_EXP_MUL;
+                *etype = TEP_FILTER_EXP_MUL;
         } else if (strcmp(token, "/") == 0) {
-                *etype = FILTER_EXP_DIV;
+                *etype = TEP_FILTER_EXP_DIV;
         } else if (strcmp(token, "%") == 0) {
-                *etype = FILTER_EXP_MOD;
+                *etype = TEP_FILTER_EXP_MOD;
         } else if (strcmp(token, ">>") == 0) {
-                *etype = FILTER_EXP_RSHIFT;
+                *etype = TEP_FILTER_EXP_RSHIFT;
         } else if (strcmp(token, "<<") == 0) {
-                *etype = FILTER_EXP_LSHIFT;
+                *etype = TEP_FILTER_EXP_LSHIFT;
         } else if (strcmp(token, "&") == 0) {
-                *etype = FILTER_EXP_AND;
+                *etype = TEP_FILTER_EXP_AND;
         } else if (strcmp(token, "|") == 0) {
-                *etype = FILTER_EXP_OR;
+                *etype = TEP_FILTER_EXP_OR;
         } else if (strcmp(token, "^") == 0) {
-                *etype = FILTER_EXP_XOR;
+                *etype = TEP_FILTER_EXP_XOR;
         } else if (strcmp(token, "~") == 0)
-                *etype = FILTER_EXP_NOT;
+                *etype = TEP_FILTER_EXP_NOT;
 
-        if (*etype != FILTER_EXP_NONE)
+        if (*etype != TEP_FILTER_EXP_NONE)
                 return OP_EXP;
 
         /* Check for compares */
         if (strcmp(token, "==") == 0)
-                *ctype = FILTER_CMP_EQ;
+                *ctype = TEP_FILTER_CMP_EQ;
         else if (strcmp(token, "!=") == 0)
-                *ctype = FILTER_CMP_NE;
+                *ctype = TEP_FILTER_CMP_NE;
         else if (strcmp(token, "<") == 0)
-                *ctype = FILTER_CMP_LT;
+                *ctype = TEP_FILTER_CMP_LT;
         else if (strcmp(token, ">") == 0)
-                *ctype = FILTER_CMP_GT;
+                *ctype = TEP_FILTER_CMP_GT;
         else if (strcmp(token, "<=") == 0)
-                *ctype = FILTER_CMP_LE;
+                *ctype = TEP_FILTER_CMP_LE;
         else if (strcmp(token, ">=") == 0)
-                *ctype = FILTER_CMP_GE;
+                *ctype = TEP_FILTER_CMP_GE;
         else if (strcmp(token, "=~") == 0)
-                *ctype = FILTER_CMP_REGEX;
+                *ctype = TEP_FILTER_CMP_REGEX;
         else if (strcmp(token, "!~") == 0)
-                *ctype = FILTER_CMP_NOT_REGEX;
+                *ctype = TEP_FILTER_CMP_NOT_REGEX;
         else
                 return OP_NONE;
 
         return OP_CMP;
 }
 
-static int check_op_done(struct filter_arg *arg)
+static int check_op_done(struct tep_filter_arg *arg)
 {
         switch (arg->type) {
-        case FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_EXP:
                 return arg->exp.right != NULL;
 
-        case FILTER_ARG_OP:
+        case TEP_FILTER_ARG_OP:
                 return arg->op.right != NULL;
 
-        case FILTER_ARG_NUM:
+        case TEP_FILTER_ARG_NUM:
                 return arg->num.right != NULL;
 
-        case FILTER_ARG_STR:
+        case TEP_FILTER_ARG_STR:
                 /* A string conversion is always done */
                 return 1;
 
-        case FILTER_ARG_BOOLEAN:
+        case TEP_FILTER_ARG_BOOLEAN:
                 /* field not found, is ok */
                 return 1;
 
@@ -752,14 +753,14 @@ enum filter_vals {
 };
 
 static enum tep_errno
-reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
-                struct filter_arg *arg, char *error_str)
+reparent_op_arg(struct tep_filter_arg *parent, struct tep_filter_arg *old_child,
+                struct tep_filter_arg *arg, char *error_str)
 {
-        struct filter_arg *other_child;
-        struct filter_arg **ptr;
+        struct tep_filter_arg *other_child;
+        struct tep_filter_arg **ptr;
 
-        if (parent->type != FILTER_ARG_OP &&
-            arg->type != FILTER_ARG_OP) {
+        if (parent->type != TEP_FILTER_ARG_OP &&
+            arg->type != TEP_FILTER_ARG_OP) {
                 show_error(error_str, "can not reparent other than OP");
                 return TEP_ERRNO__REPARENT_NOT_OP;
         }
@@ -804,7 +805,7 @@ reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
 }
 
 /* Returns either filter_vals (success) or tep_errno (failfure) */
-static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
+static int test_arg(struct tep_filter_arg *parent, struct tep_filter_arg *arg,
                     char *error_str)
 {
         int lval, rval;
@@ -812,16 +813,16 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
         switch (arg->type) {
 
                 /* bad case */
-        case FILTER_ARG_BOOLEAN:
+        case TEP_FILTER_ARG_BOOLEAN:
                 return FILTER_VAL_FALSE + arg->boolean.value;
 
                 /* good cases: */
-        case FILTER_ARG_STR:
-        case FILTER_ARG_VALUE:
-        case FILTER_ARG_FIELD:
+        case TEP_FILTER_ARG_STR:
+        case TEP_FILTER_ARG_VALUE:
+        case TEP_FILTER_ARG_FIELD:
                 return FILTER_VAL_NORM;
 
-        case FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_EXP:
                 lval = test_arg(arg, arg->exp.left, error_str);
                 if (lval != FILTER_VAL_NORM)
                         return lval;
@@ -830,7 +831,7 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
                         return rval;
                 return FILTER_VAL_NORM;
 
-        case FILTER_ARG_NUM:
+        case TEP_FILTER_ARG_NUM:
                 lval = test_arg(arg, arg->num.left, error_str);
                 if (lval != FILTER_VAL_NORM)
                         return lval;
@@ -839,14 +840,14 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
                         return rval;
                 return FILTER_VAL_NORM;
 
-        case FILTER_ARG_OP:
-                if (arg->op.type != FILTER_OP_NOT) {
+        case TEP_FILTER_ARG_OP:
+                if (arg->op.type != TEP_FILTER_OP_NOT) {
                         lval = test_arg(arg, arg->op.left, error_str);
                         switch (lval) {
                         case FILTER_VAL_NORM:
                                 break;
                         case FILTER_VAL_TRUE:
-                                if (arg->op.type == FILTER_OP_OR)
+                                if (arg->op.type == TEP_FILTER_OP_OR)
                                         return FILTER_VAL_TRUE;
                                 rval = test_arg(arg, arg->op.right, error_str);
                                 if (rval != FILTER_VAL_NORM)
@@ -856,7 +857,7 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
                                                        error_str);
 
                         case FILTER_VAL_FALSE:
-                                if (arg->op.type == FILTER_OP_AND)
+                                if (arg->op.type == TEP_FILTER_OP_AND)
                                         return FILTER_VAL_FALSE;
                                 rval = test_arg(arg, arg->op.right, error_str);
                                 if (rval != FILTER_VAL_NORM)
@@ -877,18 +878,18 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
                         break;
 
                 case FILTER_VAL_TRUE:
-                        if (arg->op.type == FILTER_OP_OR)
+                        if (arg->op.type == TEP_FILTER_OP_OR)
                                 return FILTER_VAL_TRUE;
-                        if (arg->op.type == FILTER_OP_NOT)
+                        if (arg->op.type == TEP_FILTER_OP_NOT)
                                 return FILTER_VAL_FALSE;
 
                         return reparent_op_arg(parent, arg, arg->op.left,
                                                error_str);
 
                 case FILTER_VAL_FALSE:
-                        if (arg->op.type == FILTER_OP_AND)
+                        if (arg->op.type == TEP_FILTER_OP_AND)
                                 return FILTER_VAL_FALSE;
-                        if (arg->op.type == FILTER_OP_NOT)
+                        if (arg->op.type == TEP_FILTER_OP_NOT)
                                 return FILTER_VAL_TRUE;
 
                         return reparent_op_arg(parent, arg, arg->op.left,
@@ -904,8 +905,8 @@ static int test_arg(struct filter_arg *parent, struct filter_arg *arg,
 }
 
 /* Remove any unknown event fields */
-static int collapse_tree(struct filter_arg *arg,
-                         struct filter_arg **arg_collapsed, char *error_str)
+static int collapse_tree(struct tep_filter_arg *arg,
+                         struct tep_filter_arg **arg_collapsed, char *error_str)
 {
         int ret;
 
@@ -919,7 +920,7 @@ static int collapse_tree(struct filter_arg *arg,
                 free_arg(arg);
                 arg = allocate_arg();
                 if (arg) {
-                        arg->type = FILTER_ARG_BOOLEAN;
+                        arg->type = TEP_FILTER_ARG_BOOLEAN;
                         arg->boolean.value = ret == FILTER_VAL_TRUE;
                 } else {
                         show_error(error_str, "Failed to allocate filter arg");
@@ -939,19 +940,19 @@ static int collapse_tree(struct filter_arg *arg,
 }
 
 static enum tep_errno
-process_filter(struct event_format *event, struct filter_arg **parg,
+process_filter(struct tep_event_format *event, struct tep_filter_arg **parg,
                char *error_str, int not)
 {
-        enum event_type type;
+        enum tep_event_type type;
         char *token = NULL;
-        struct filter_arg *current_op = NULL;
-        struct filter_arg *current_exp = NULL;
-        struct filter_arg *left_item = NULL;
-        struct filter_arg *arg = NULL;
+        struct tep_filter_arg *current_op = NULL;
+        struct tep_filter_arg *current_exp = NULL;
+        struct tep_filter_arg *left_item = NULL;
+        struct tep_filter_arg *arg = NULL;
         enum op_type op_type;
-        enum filter_op_type btype;
-        enum filter_exp_type etype;
-        enum filter_cmp_type ctype;
+        enum tep_filter_op_type btype;
+        enum tep_filter_exp_type etype;
+        enum tep_filter_cmp_type ctype;
         enum tep_errno ret;
 
         *parg = NULL;
@@ -960,9 +961,9 @@ process_filter(struct event_format *event, struct filter_arg **parg,
                 free(token);
                 type = read_token(&token);
                 switch (type) {
-                case EVENT_SQUOTE:
-                case EVENT_DQUOTE:
-                case EVENT_ITEM:
+                case TEP_EVENT_SQUOTE:
+                case TEP_EVENT_DQUOTE:
+                case TEP_EVENT_ITEM:
                         ret = create_arg_item(event, token, type, &arg, error_str);
                         if (ret < 0)
                                 goto fail;
@@ -987,7 +988,7 @@ process_filter(struct event_format *event, struct filter_arg **parg,
                         arg = NULL;
                         break;
 
-                case EVENT_DELIM:
+                case TEP_EVENT_DELIM:
                         if (*token == ',') {
                                 show_error(error_str, "Illegal token ','");
                                 ret = TEP_ERRNO__ILLEGAL_TOKEN;
@@ -1054,7 +1055,7 @@ process_filter(struct event_format *event, struct filter_arg **parg,
                         }
                         break;
 
-                case EVENT_OP:
+                case TEP_EVENT_OP:
                         op_type = process_op(token, &btype, &ctype, &etype);
 
                         /* All expect a left arg except for NOT */
@@ -1139,14 +1140,14 @@ process_filter(struct event_format *event, struct filter_arg **parg,
                         if (ret < 0)
                                 goto fail_syntax;
                         break;
-                case EVENT_NONE:
+                case TEP_EVENT_NONE:
                         break;
-                case EVENT_ERROR:
+                case TEP_EVENT_ERROR:
                         goto fail_alloc;
                 default:
                         goto fail_syntax;
                 }
-        } while (type != EVENT_NONE);
+        } while (type != TEP_EVENT_NONE);
 
         if (!current_op && !current_exp)
                 goto fail_syntax;
@@ -1179,8 +1180,8 @@ process_filter(struct event_format *event, struct filter_arg **parg,
 }
 
 static enum tep_errno
-process_event(struct event_format *event, const char *filter_str,
-              struct filter_arg **parg, char *error_str)
+process_event(struct tep_event_format *event, const char *filter_str,
+              struct tep_filter_arg **parg, char *error_str)
 {
         int ret;
 
@@ -1196,19 +1197,19 @@ process_event(struct event_format *event, const char *filter_str,
                 if (*parg == NULL)
                         return TEP_ERRNO__MEM_ALLOC_FAILED;
 
-                (*parg)->type = FILTER_ARG_BOOLEAN;
-                (*parg)->boolean.value = FILTER_FALSE;
+                (*parg)->type = TEP_FILTER_ARG_BOOLEAN;
+                (*parg)->boolean.value = TEP_FILTER_FALSE;
         }
 
         return 0;
 }
 
 static enum tep_errno
-filter_event(struct event_filter *filter, struct event_format *event,
+filter_event(struct tep_event_filter *filter, struct tep_event_format *event,
              const char *filter_str, char *error_str)
 {
-        struct filter_type *filter_type;
-        struct filter_arg *arg;
+        struct tep_filter_type *filter_type;
+        struct tep_filter_arg *arg;
         enum tep_errno ret;
 
         if (filter_str) {
@@ -1222,8 +1223,8 @@ filter_event(struct event_filter *filter, struct event_format *event,
                 if (arg == NULL)
                         return TEP_ERRNO__MEM_ALLOC_FAILED;
 
-                arg->type = FILTER_ARG_BOOLEAN;
-                arg->boolean.value = FILTER_TRUE;
+                arg->type = TEP_FILTER_ARG_BOOLEAN;
+                arg->boolean.value = TEP_FILTER_TRUE;
         }
 
         filter_type = add_filter_type(filter, event->id);
@@ -1237,7 +1238,7 @@ filter_event(struct event_filter *filter, struct event_format *event,
         return 0;
 }
 
-static void filter_init_error_buf(struct event_filter *filter)
+static void filter_init_error_buf(struct tep_event_filter *filter)
 {
         /* clear buffer to reset show error */
         tep_buffer_init("", 0);
@@ -1253,7 +1254,7 @@ static void filter_init_error_buf(struct event_filter *filter)
  * negative error code.  Use tep_filter_strerror() to see
  * actual error message in case of error.
  */
-enum tep_errno tep_filter_add_filter_str(struct event_filter *filter,
+enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter,
                                          const char *filter_str)
 {
         struct tep_handle *pevent = filter->pevent;
@@ -1351,7 +1352,7 @@ enum tep_errno tep_filter_add_filter_str(struct event_filter *filter,
         return rtn;
 }
 
-static void free_filter_type(struct filter_type *filter_type)
+static void free_filter_type(struct tep_filter_type *filter_type)
 {
         free_arg(filter_type->filter);
 }
@@ -1365,7 +1366,7 @@ static void free_filter_type(struct filter_type *filter_type)
  *
  * Returns 0 if message was filled successfully, -1 if error
  */
-int tep_filter_strerror(struct event_filter *filter, enum tep_errno err,
+int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err,
                         char *buf, size_t buflen)
 {
         if (err <= __TEP_ERRNO__START || err >= __TEP_ERRNO__END)
@@ -1393,10 +1394,10 @@ int tep_filter_strerror(struct event_filter *filter, enum tep_errno err,
  * Returns 1: if an event was removed
  *   0: if the event was not found
  */
-int tep_filter_remove_event(struct event_filter *filter,
+int tep_filter_remove_event(struct tep_event_filter *filter,
                             int event_id)
 {
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
         unsigned long len;
 
         if (!filter->filters)
@@ -1428,7 +1429,7 @@ int tep_filter_remove_event(struct event_filter *filter,
  *
  * Removes all filters from a filter and resets it.
  */
-void tep_filter_reset(struct event_filter *filter)
+void tep_filter_reset(struct tep_event_filter *filter)
 {
         int i;
 
@@ -1440,7 +1441,7 @@ void tep_filter_reset(struct event_filter *filter)
         filter->event_filters = NULL;
 }
 
-void tep_filter_free(struct event_filter *filter)
+void tep_filter_free(struct tep_event_filter *filter)
 {
         tep_unref(filter->pevent);
 
@@ -1449,14 +1450,14 @@ void tep_filter_free(struct event_filter *filter)
         free(filter);
 }
 
-static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg);
+static char *arg_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg);
 
-static int copy_filter_type(struct event_filter *filter,
-                             struct event_filter *source,
-                             struct filter_type *filter_type)
+static int copy_filter_type(struct tep_event_filter *filter,
+                            struct tep_event_filter *source,
+                            struct tep_filter_type *filter_type)
 {
-        struct filter_arg *arg;
-        struct event_format *event;
+        struct tep_filter_arg *arg;
+        struct tep_event_format *event;
         const char *sys;
         const char *name;
         char *str;
@@ -1478,7 +1479,7 @@ static int copy_filter_type(struct event_filter *filter,
                 if (arg == NULL)
                         return -1;
 
-                arg->type = FILTER_ARG_BOOLEAN;
+                arg->type = TEP_FILTER_ARG_BOOLEAN;
                 if (strcmp(str, "TRUE") == 0)
                         arg->boolean.value = 1;
                 else
@@ -1507,7 +1508,7 @@ static int copy_filter_type(struct event_filter *filter,
  *
  * Returns 0 on success and -1 if not all filters were copied
  */
-int tep_filter_copy(struct event_filter *dest, struct event_filter *source)
+int tep_filter_copy(struct tep_event_filter *dest, struct tep_event_filter *source)
 {
         int ret = 0;
         int i;
@@ -1533,14 +1534,14 @@ int tep_filter_copy(struct event_filter *dest, struct event_filter *source)
  * Returns 0 on success and -1 if there was a problem updating, but
  *   events may have still been updated on error.
  */
-int tep_update_trivial(struct event_filter *dest, struct event_filter *source,
-                       enum filter_trivial_type type)
+int tep_update_trivial(struct tep_event_filter *dest, struct tep_event_filter *source,
+                       enum tep_filter_trivial_type type)
 {
         struct tep_handle *src_pevent;
         struct tep_handle *dest_pevent;
-        struct event_format *event;
-        struct filter_type *filter_type;
-        struct filter_arg *arg;
+        struct tep_event_format *event;
+        struct tep_filter_type *filter_type;
+        struct tep_filter_arg *arg;
         char *str;
         int i;
 
@@ -1554,10 +1555,10 @@ int tep_update_trivial(struct event_filter *dest, struct event_filter *source,
         for (i = 0; i < dest->filters; i++) {
                 filter_type = &dest->event_filters[i];
                 arg = filter_type->filter;
-                if (arg->type != FILTER_ARG_BOOLEAN)
+                if (arg->type != TEP_FILTER_ARG_BOOLEAN)
                         continue;
-                if ((arg->boolean.value && type == FILTER_TRIVIAL_FALSE) ||
-                    (!arg->boolean.value && type == FILTER_TRIVIAL_TRUE))
+                if ((arg->boolean.value && type == TEP_FILTER_TRIVIAL_FALSE) ||
+                    (!arg->boolean.value && type == TEP_FILTER_TRIVIAL_TRUE))
                         continue;
 
                 event = filter_type->event;
@@ -1592,10 +1593,10 @@ int tep_update_trivial(struct event_filter *dest, struct event_filter *source,
  *
  * Returns 0 on success and -1 if there was a problem.
  */
-int tep_filter_clear_trivial(struct event_filter *filter,
-                             enum filter_trivial_type type)
+int tep_filter_clear_trivial(struct tep_event_filter *filter,
+                             enum tep_filter_trivial_type type)
 {
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
         int count = 0;
         int *ids = NULL;
         int i;
@@ -1611,14 +1612,14 @@ int tep_filter_clear_trivial(struct event_filter *filter,
                 int *new_ids;
 
                 filter_type = &filter->event_filters[i];
-                if (filter_type->filter->type != FILTER_ARG_BOOLEAN)
+                if (filter_type->filter->type != TEP_FILTER_ARG_BOOLEAN)
                         continue;
                 switch (type) {
-                case FILTER_TRIVIAL_FALSE:
+                case TEP_FILTER_TRIVIAL_FALSE:
                         if (filter_type->filter->boolean.value)
                                 continue;
                         break;
-                case FILTER_TRIVIAL_TRUE:
+                case TEP_FILTER_TRIVIAL_TRUE:
                         if (!filter_type->filter->boolean.value)
                                 continue;
                 default:
@@ -1654,11 +1655,11 @@ int tep_filter_clear_trivial(struct event_filter *filter,
  * Returns 1 if the event contains a matching trivial type
  *  otherwise 0.
  */
-int tep_filter_event_has_trivial(struct event_filter *filter,
+int tep_filter_event_has_trivial(struct tep_event_filter *filter,
                                  int event_id,
-                                 enum filter_trivial_type type)
+                                 enum tep_filter_trivial_type type)
 {
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
 
         if (!filter->filters)
                 return 0;
@@ -1668,25 +1669,25 @@ int tep_filter_event_has_trivial(struct event_filter *filter,
         if (!filter_type)
                 return 0;
 
-        if (filter_type->filter->type != FILTER_ARG_BOOLEAN)
+        if (filter_type->filter->type != TEP_FILTER_ARG_BOOLEAN)
                 return 0;
 
         switch (type) {
-        case FILTER_TRIVIAL_FALSE:
+        case TEP_FILTER_TRIVIAL_FALSE:
                 return !filter_type->filter->boolean.value;
 
-        case FILTER_TRIVIAL_TRUE:
+        case TEP_FILTER_TRIVIAL_TRUE:
                 return filter_type->filter->boolean.value;
         default:
                 return 1;
         }
 }
 
-static int test_filter(struct event_format *event, struct filter_arg *arg,
+static int test_filter(struct tep_event_format *event, struct tep_filter_arg *arg,
                        struct tep_record *record, enum tep_errno *err);
 
 static const char *
-get_comm(struct event_format *event, struct tep_record *record)
+get_comm(struct tep_event_format *event, struct tep_record *record)
 {
         const char *comm;
         int pid;
@@ -1697,8 +1698,8 @@ get_comm(struct event_format *event, struct tep_record *record)
 }
 
 static unsigned long long
-get_value(struct event_format *event,
-          struct format_field *field, struct tep_record *record)
+get_value(struct tep_event_format *event,
+          struct tep_format_field *field, struct tep_record *record)
 {
         unsigned long long val;
 
@@ -1716,7 +1717,7 @@ get_value(struct event_format *event,
 
         tep_read_number_field(field, record->data, &val);
 
-        if (!(field->flags & FIELD_IS_SIGNED))
+        if (!(field->flags & TEP_FIELD_IS_SIGNED))
                 return val;
 
         switch (field->size) {
@@ -1733,11 +1734,11 @@ get_value(struct event_format *event,
 }
 
 static unsigned long long
-get_arg_value(struct event_format *event, struct filter_arg *arg,
+get_arg_value(struct tep_event_format *event, struct tep_filter_arg *arg,
               struct tep_record *record, enum tep_errno *err);
 
 static unsigned long long
-get_exp_value(struct event_format *event, struct filter_arg *arg,
+get_exp_value(struct tep_event_format *event, struct tep_filter_arg *arg,
               struct tep_record *record, enum tep_errno *err)
 {
         unsigned long long lval, rval;
@@ -1753,37 +1754,37 @@ get_exp_value(struct event_format *event, struct filter_arg *arg,
         }
 
         switch (arg->exp.type) {
-        case FILTER_EXP_ADD:
+        case TEP_FILTER_EXP_ADD:
                 return lval + rval;
 
-        case FILTER_EXP_SUB:
+        case TEP_FILTER_EXP_SUB:
                 return lval - rval;
 
-        case FILTER_EXP_MUL:
+        case TEP_FILTER_EXP_MUL:
                 return lval * rval;
 
-        case FILTER_EXP_DIV:
+        case TEP_FILTER_EXP_DIV:
                 return lval / rval;
 
-        case FILTER_EXP_MOD:
+        case TEP_FILTER_EXP_MOD:
                 return lval % rval;
 
-        case FILTER_EXP_RSHIFT:
+        case TEP_FILTER_EXP_RSHIFT:
                 return lval >> rval;
 
-        case FILTER_EXP_LSHIFT:
+        case TEP_FILTER_EXP_LSHIFT:
                 return lval << rval;
 
-        case FILTER_EXP_AND:
+        case TEP_FILTER_EXP_AND:
                 return lval & rval;
 
-        case FILTER_EXP_OR:
+        case TEP_FILTER_EXP_OR:
                 return lval | rval;
 
-        case FILTER_EXP_XOR:
+        case TEP_FILTER_EXP_XOR:
                 return lval ^ rval;
 
-        case FILTER_EXP_NOT:
+        case TEP_FILTER_EXP_NOT:
         default:
                 if (!*err)
                         *err = TEP_ERRNO__INVALID_EXP_TYPE;
@@ -1792,21 +1793,21 @@ get_exp_value(struct event_format *event, struct filter_arg *arg,
 }
 
 static unsigned long long
-get_arg_value(struct event_format *event, struct filter_arg *arg,
+get_arg_value(struct tep_event_format *event, struct tep_filter_arg *arg,
               struct tep_record *record, enum tep_errno *err)
 {
         switch (arg->type) {
-        case FILTER_ARG_FIELD:
+        case TEP_FILTER_ARG_FIELD:
                 return get_value(event, arg->field.field, record);
 
-        case FILTER_ARG_VALUE:
-                if (arg->value.type != FILTER_NUMBER) {
+        case TEP_FILTER_ARG_VALUE:
+                if (arg->value.type != TEP_FILTER_NUMBER) {
                         if (!*err)
                                 *err = TEP_ERRNO__NOT_A_NUMBER;
                 }
                 return arg->value.val;
 
-        case FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_EXP:
                 return get_exp_value(event, arg, record, err);
 
         default:
@@ -1816,7 +1817,7 @@ get_arg_value(struct event_format *event, struct filter_arg *arg,
         return 0;
 }
 
-static int test_num(struct event_format *event, struct filter_arg *arg,
+static int test_num(struct tep_event_format *event, struct tep_filter_arg *arg,
                     struct tep_record *record, enum tep_errno *err)
 {
         unsigned long long lval, rval;
@@ -1832,22 +1833,22 @@ static int test_num(struct event_format *event, struct filter_arg *arg,
         }
 
         switch (arg->num.type) {
-        case FILTER_CMP_EQ:
+        case TEP_FILTER_CMP_EQ:
                 return lval == rval;
 
-        case FILTER_CMP_NE:
+        case TEP_FILTER_CMP_NE:
                 return lval != rval;
 
-        case FILTER_CMP_GT:
+        case TEP_FILTER_CMP_GT:
                 return lval > rval;
 
-        case FILTER_CMP_LT:
+        case TEP_FILTER_CMP_LT:
                 return lval < rval;
 
-        case FILTER_CMP_GE:
+        case TEP_FILTER_CMP_GE:
                 return lval >= rval;
 
-        case FILTER_CMP_LE:
+        case TEP_FILTER_CMP_LE:
                 return lval <= rval;
 
         default:
@@ -1857,9 +1858,9 @@ static int test_num(struct event_format *event, struct filter_arg *arg,
         }
 }
 
-static const char *get_field_str(struct filter_arg *arg, struct tep_record *record)
+static const char *get_field_str(struct tep_filter_arg *arg, struct tep_record *record)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         struct tep_handle *pevent;
         unsigned long long addr;
         const char *val = NULL;
@@ -1867,11 +1868,11 @@ static const char *get_field_str(struct filter_arg *arg, struct tep_record *reco
         char hex[64];
 
         /* If the field is not a string convert it */
-        if (arg->str.field->flags & FIELD_IS_STRING) {
+        if (arg->str.field->flags & TEP_FIELD_IS_STRING) {
                 val = record->data + arg->str.field->offset;
                 size = arg->str.field->size;
 
-                if (arg->str.field->flags & FIELD_IS_DYNAMIC) {
+                if (arg->str.field->flags & TEP_FIELD_IS_DYNAMIC) {
                         addr = *(unsigned int *)val;
                         val = record->data + (addr & 0xffff);
                         size = addr >> 16;
@@ -1893,7 +1894,7 @@ static const char *get_field_str(struct filter_arg *arg, struct tep_record *reco
                 pevent = event->pevent;
                 addr = get_value(event, arg->str.field, record);
 
-                if (arg->str.field->flags & (FIELD_IS_POINTER | FIELD_IS_LONG))
+                if (arg->str.field->flags & (TEP_FIELD_IS_POINTER | TEP_FIELD_IS_LONG))
                         /* convert to a kernel symbol */
                         val = tep_find_function(pevent, addr);
 
@@ -1907,7 +1908,7 @@ static const char *get_field_str(struct filter_arg *arg, struct tep_record *reco
         return val;
 }
 
-static int test_str(struct event_format *event, struct filter_arg *arg,
+static int test_str(struct tep_event_format *event, struct tep_filter_arg *arg,
                     struct tep_record *record, enum tep_errno *err)
 {
         const char *val;
@@ -1918,17 +1919,17 @@ static int test_str(struct event_format *event, struct filter_arg *arg,
                 val = get_field_str(arg, record);
 
         switch (arg->str.type) {
-        case FILTER_CMP_MATCH:
+        case TEP_FILTER_CMP_MATCH:
                 return strcmp(val, arg->str.val) == 0;
 
-        case FILTER_CMP_NOT_MATCH:
+        case TEP_FILTER_CMP_NOT_MATCH:
                 return strcmp(val, arg->str.val) != 0;
 
-        case FILTER_CMP_REGEX:
+        case TEP_FILTER_CMP_REGEX:
                 /* Returns zero on match */
                 return !regexec(&arg->str.reg, val, 0, NULL, 0);
 
-        case FILTER_CMP_NOT_REGEX:
+        case TEP_FILTER_CMP_NOT_REGEX:
                 return regexec(&arg->str.reg, val, 0, NULL, 0);
 
         default:
@@ -1938,19 +1939,19 @@ static int test_str(struct event_format *event, struct filter_arg *arg,
         }
 }
 
-static int test_op(struct event_format *event, struct filter_arg *arg,
+static int test_op(struct tep_event_format *event, struct tep_filter_arg *arg,
                    struct tep_record *record, enum tep_errno *err)
 {
         switch (arg->op.type) {
-        case FILTER_OP_AND:
+        case TEP_FILTER_OP_AND:
                 return test_filter(event, arg->op.left, record, err) &&
                         test_filter(event, arg->op.right, record, err);
 
-        case FILTER_OP_OR:
+        case TEP_FILTER_OP_OR:
                 return test_filter(event, arg->op.left, record, err) ||
                         test_filter(event, arg->op.right, record, err);
 
-        case FILTER_OP_NOT:
+        case TEP_FILTER_OP_NOT:
                 return !test_filter(event, arg->op.right, record, err);
 
         default:
@@ -1960,7 +1961,7 @@ static int test_op(struct event_format *event, struct filter_arg *arg,
         }
 }
 
-static int test_filter(struct event_format *event, struct filter_arg *arg,
+static int test_filter(struct tep_event_format *event, struct tep_filter_arg *arg,
                        struct tep_record *record, enum tep_errno *err)
 {
         if (*err) {
@@ -1971,22 +1972,22 @@ static int test_filter(struct event_format *event, struct filter_arg *arg,
         }
 
         switch (arg->type) {
-        case FILTER_ARG_BOOLEAN:
+        case TEP_FILTER_ARG_BOOLEAN:
                 /* easy case */
                 return arg->boolean.value;
 
-        case FILTER_ARG_OP:
+        case TEP_FILTER_ARG_OP:
                 return test_op(event, arg, record, err);
 
-        case FILTER_ARG_NUM:
+        case TEP_FILTER_ARG_NUM:
                 return test_num(event, arg, record, err);
 
-        case FILTER_ARG_STR:
+        case TEP_FILTER_ARG_STR:
                 return test_str(event, arg, record, err);
 
-        case FILTER_ARG_EXP:
-        case FILTER_ARG_VALUE:
-        case FILTER_ARG_FIELD:
+        case TEP_FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_VALUE:
+        case TEP_FILTER_ARG_FIELD:
                 /*
                  * Expressions, fields and values evaluate
                  * to true if they return non zero
@@ -2008,9 +2009,9 @@ static int test_filter(struct event_format *event, struct filter_arg *arg,
  * Returns 1 if filter found for @event_id
  *   otherwise 0;
  */
-int tep_event_filtered(struct event_filter *filter, int event_id)
+int tep_event_filtered(struct tep_event_filter *filter, int event_id)
 {
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
 
         if (!filter->filters)
                 return 0;
@@ -2032,11 +2033,11 @@ int tep_event_filtered(struct event_filter *filter, int event_id)
  * NO_FILTER - if no filters exist
  * otherwise - error occurred during test
  */
-enum tep_errno tep_filter_match(struct event_filter *filter,
+enum tep_errno tep_filter_match(struct tep_event_filter *filter,
                                 struct tep_record *record)
 {
         struct tep_handle *pevent = filter->pevent;
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
         int event_id;
         int ret;
         enum tep_errno err = 0;
@@ -2059,7 +2060,7 @@ enum tep_errno tep_filter_match(struct event_filter *filter,
         return ret ? TEP_ERRNO__FILTER_MATCH : TEP_ERRNO__FILTER_MISS;
 }
 
-static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *op_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         char *str = NULL;
         char *left = NULL;
@@ -2070,10 +2071,10 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
         int val;
 
         switch (arg->op.type) {
-        case FILTER_OP_AND:
+        case TEP_FILTER_OP_AND:
                 op = "&&";
                 /* fall through */
-        case FILTER_OP_OR:
+        case TEP_FILTER_OP_OR:
                 if (!op)
                         op = "||";
 
@@ -2094,8 +2095,8 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
                         right_val = 0;
 
                 if (left_val >= 0) {
-                        if ((arg->op.type == FILTER_OP_AND && !left_val) ||
-                            (arg->op.type == FILTER_OP_OR && left_val)) {
+                        if ((arg->op.type == TEP_FILTER_OP_AND && !left_val) ||
+                            (arg->op.type == TEP_FILTER_OP_OR && left_val)) {
                                 /* Just return left value */
                                 str = left;
                                 left = NULL;
@@ -2105,10 +2106,10 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
                                 /* just evaluate this. */
                                 val = 0;
                                 switch (arg->op.type) {
-                                case FILTER_OP_AND:
+                                case TEP_FILTER_OP_AND:
                                         val = left_val && right_val;
                                         break;
-                                case FILTER_OP_OR:
+                                case TEP_FILTER_OP_OR:
                                         val = left_val || right_val;
                                         break;
                                 default:
@@ -2119,8 +2120,8 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
                         }
                 }
                 if (right_val >= 0) {
-                        if ((arg->op.type == FILTER_OP_AND && !right_val) ||
-                            (arg->op.type == FILTER_OP_OR && right_val)) {
+                        if ((arg->op.type == TEP_FILTER_OP_AND && !right_val) ||
+                            (arg->op.type == TEP_FILTER_OP_OR && right_val)) {
                                 /* Just return right value */
                                 str = right;
                                 right = NULL;
@@ -2135,7 +2136,7 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
                 asprintf(&str, "(%s) %s (%s)", left, op, right);
                 break;
 
-        case FILTER_OP_NOT:
+        case TEP_FILTER_OP_NOT:
                 op = "!";
                 right = arg_to_str(filter, arg->op.right);
                 if (!right)
@@ -2163,7 +2164,7 @@ static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
         return str;
 }
 
-static char *val_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *val_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         char *str = NULL;
 
@@ -2172,12 +2173,12 @@ static char *val_to_str(struct event_filter *filter, struct filter_arg *arg)
         return str;
 }
 
-static char *field_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *field_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         return strdup(arg->field.field->name);
 }
 
-static char *exp_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *exp_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         char *lstr;
         char *rstr;
@@ -2190,34 +2191,34 @@ static char *exp_to_str(struct event_filter *filter, struct filter_arg *arg)
                 goto out;
 
         switch (arg->exp.type) {
-        case FILTER_EXP_ADD:
+        case TEP_FILTER_EXP_ADD:
                 op = "+";
                 break;
-        case FILTER_EXP_SUB:
+        case TEP_FILTER_EXP_SUB:
                 op = "-";
                 break;
-        case FILTER_EXP_MUL:
+        case TEP_FILTER_EXP_MUL:
                 op = "*";
                 break;
-        case FILTER_EXP_DIV:
+        case TEP_FILTER_EXP_DIV:
                 op = "/";
                 break;
-        case FILTER_EXP_MOD:
+        case TEP_FILTER_EXP_MOD:
                 op = "%";
                 break;
-        case FILTER_EXP_RSHIFT:
+        case TEP_FILTER_EXP_RSHIFT:
                 op = ">>";
                 break;
-        case FILTER_EXP_LSHIFT:
+        case TEP_FILTER_EXP_LSHIFT:
                 op = "<<";
                 break;
-        case FILTER_EXP_AND:
+        case TEP_FILTER_EXP_AND:
                 op = "&";
                 break;
-        case FILTER_EXP_OR:
+        case TEP_FILTER_EXP_OR:
                 op = "|";
                 break;
-        case FILTER_EXP_XOR:
+        case TEP_FILTER_EXP_XOR:
                 op = "^";
                 break;
         default:
@@ -2233,7 +2234,7 @@ out:
         return str;
 }
 
-static char *num_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *num_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         char *lstr;
         char *rstr;
@@ -2246,26 +2247,26 @@ static char *num_to_str(struct event_filter *filter, struct filter_arg *arg)
                 goto out;
 
         switch (arg->num.type) {
-        case FILTER_CMP_EQ:
+        case TEP_FILTER_CMP_EQ:
                 op = "==";
                 /* fall through */
-        case FILTER_CMP_NE:
+        case TEP_FILTER_CMP_NE:
                 if (!op)
                         op = "!=";
                 /* fall through */
-        case FILTER_CMP_GT:
+        case TEP_FILTER_CMP_GT:
                 if (!op)
                         op = ">";
                 /* fall through */
-        case FILTER_CMP_LT:
+        case TEP_FILTER_CMP_LT:
                 if (!op)
                         op = "<";
                 /* fall through */
-        case FILTER_CMP_GE:
+        case TEP_FILTER_CMP_GE:
                 if (!op)
                         op = ">=";
                 /* fall through */
-        case FILTER_CMP_LE:
+        case TEP_FILTER_CMP_LE:
                 if (!op)
                         op = "<=";
 
@@ -2283,24 +2284,24 @@ out:
         return str;
 }
 
-static char *str_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *str_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         char *str = NULL;
         char *op = NULL;
 
         switch (arg->str.type) {
-        case FILTER_CMP_MATCH:
+        case TEP_FILTER_CMP_MATCH:
                 op = "==";
                 /* fall through */
-        case FILTER_CMP_NOT_MATCH:
+        case TEP_FILTER_CMP_NOT_MATCH:
                 if (!op)
                         op = "!=";
                 /* fall through */
-        case FILTER_CMP_REGEX:
+        case TEP_FILTER_CMP_REGEX:
                 if (!op)
                         op = "=~";
                 /* fall through */
-        case FILTER_CMP_NOT_REGEX:
+        case TEP_FILTER_CMP_NOT_REGEX:
                 if (!op)
                         op = "!~";
 
@@ -2315,31 +2316,31 @@ static char *str_to_str(struct event_filter *filter, struct filter_arg *arg)
         return str;
 }
 
-static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg)
+static char *arg_to_str(struct tep_event_filter *filter, struct tep_filter_arg *arg)
 {
         char *str = NULL;
 
         switch (arg->type) {
-        case FILTER_ARG_BOOLEAN:
+        case TEP_FILTER_ARG_BOOLEAN:
                 asprintf(&str, arg->boolean.value ? "TRUE" : "FALSE");
                 return str;
 
-        case FILTER_ARG_OP:
+        case TEP_FILTER_ARG_OP:
                 return op_to_str(filter, arg);
 
-        case FILTER_ARG_NUM:
+        case TEP_FILTER_ARG_NUM:
                 return num_to_str(filter, arg);
 
-        case FILTER_ARG_STR:
+        case TEP_FILTER_ARG_STR:
                 return str_to_str(filter, arg);
 
-        case FILTER_ARG_VALUE:
+        case TEP_FILTER_ARG_VALUE:
                 return val_to_str(filter, arg);
 
-        case FILTER_ARG_FIELD:
+        case TEP_FILTER_ARG_FIELD:
                 return field_to_str(filter, arg);
 
-        case FILTER_ARG_EXP:
+        case TEP_FILTER_ARG_EXP:
                 return exp_to_str(filter, arg);
 
         default:
@@ -2359,9 +2360,9 @@ static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg)
  *  NULL is returned if no filter is found or allocation failed.
  */
 char *
-tep_filter_make_string(struct event_filter *filter, int event_id)
+tep_filter_make_string(struct tep_event_filter *filter, int event_id)
 {
-        struct filter_type *filter_type;
+        struct tep_filter_type *filter_type;
 
         if (!filter->filters)
                 return NULL;
@@ -2383,10 +2384,10 @@ tep_filter_make_string(struct event_filter *filter, int event_id)
  *  1 if the two filters hold the same content.
  *  0 if they do not.
  */
-int tep_filter_compare(struct event_filter *filter1, struct event_filter *filter2)
+int tep_filter_compare(struct tep_event_filter *filter1, struct tep_event_filter *filter2)
 {
-        struct filter_type *filter_type1;
-        struct filter_type *filter_type2;
+        struct tep_filter_type *filter_type1;
+        struct tep_filter_type *filter_type2;
         char *str1, *str2;
         int result;
         int i;
@@ -2409,8 +2410,8 @@ int tep_filter_compare(struct event_filter *filter1, struct event_filter *filter
                 if (filter_type1->filter->type != filter_type2->filter->type)
                         break;
                 switch (filter_type1->filter->type) {
-                case FILTER_TRIVIAL_FALSE:
-                case FILTER_TRIVIAL_TRUE:
+                case TEP_FILTER_TRIVIAL_FALSE:
+                case TEP_FILTER_TRIVIAL_TRUE:
                         /* trivial types just need the type compared */
                         continue;
                 default:
diff --git a/tools/lib/traceevent/plugin_function.c b/tools/lib/traceevent/plugin_function.c
index 424747475d37..528acc75d81a 100644
--- a/tools/lib/traceevent/plugin_function.c
+++ b/tools/lib/traceevent/plugin_function.c
@@ -23,6 +23,7 @@
 
 #include "event-parse.h"
 #include "event-utils.h"
+#include "trace-seq.h"
 
 static struct func_stack {
         int size;
@@ -123,7 +124,7 @@ static int add_and_get_index(const char *parent, const char *child, int cpu)
 }
 
 static int function_handler(struct trace_seq *s, struct tep_record *record,
-                            struct event_format *event, void *context)
+                            struct tep_event_format *event, void *context)
 {
         struct tep_handle *pevent = event->pevent;
         unsigned long long function;
diff --git a/tools/lib/traceevent/plugin_hrtimer.c b/tools/lib/traceevent/plugin_hrtimer.c
index b43bfec565d8..9aa05b4ca811 100644
--- a/tools/lib/traceevent/plugin_hrtimer.c
+++ b/tools/lib/traceevent/plugin_hrtimer.c
@@ -23,10 +23,11 @@
 #include <string.h>
 
 #include "event-parse.h"
+#include "trace-seq.h"
 
 static int timer_expire_handler(struct trace_seq *s,
                                 struct tep_record *record,
-                                struct event_format *event, void *context)
+                                struct tep_event_format *event, void *context)
 {
         trace_seq_printf(s, "hrtimer=");
 
@@ -46,7 +47,7 @@ static int timer_expire_handler(struct trace_seq *s,
 
 static int timer_start_handler(struct trace_seq *s,
                                struct tep_record *record,
-                               struct event_format *event, void *context)
+                               struct tep_event_format *event, void *context)
 {
         trace_seq_printf(s, "hrtimer=");
 
diff --git a/tools/lib/traceevent/plugin_jbd2.c b/tools/lib/traceevent/plugin_jbd2.c
index 45a9acd19640..a5e34135dd6a 100644
--- a/tools/lib/traceevent/plugin_jbd2.c
+++ b/tools/lib/traceevent/plugin_jbd2.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "event-parse.h"
+#include "trace-seq.h"
 
 #define MINORBITS       20
 #define MINORMASK       ((1U << MINORBITS) - 1)
diff --git a/tools/lib/traceevent/plugin_kmem.c b/tools/lib/traceevent/plugin_kmem.c
index 73966b05abce..1beb4eaddfdf 100644
--- a/tools/lib/traceevent/plugin_kmem.c
+++ b/tools/lib/traceevent/plugin_kmem.c
@@ -22,11 +22,12 @@
 #include <string.h>
 
 #include "event-parse.h"
+#include "trace-seq.h"
 
 static int call_site_handler(struct trace_seq *s, struct tep_record *record,
-                             struct event_format *event, void *context)
+                             struct tep_event_format *event, void *context)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long long val, addr;
         void *data = record->data;
         const char *func;
diff --git a/tools/lib/traceevent/plugin_kvm.c b/tools/lib/traceevent/plugin_kvm.c
index 1d0d15906225..d13c22846fa9 100644
--- a/tools/lib/traceevent/plugin_kvm.c
+++ b/tools/lib/traceevent/plugin_kvm.c
@@ -23,6 +23,7 @@
 #include <stdint.h>
 
 #include "event-parse.h"
+#include "trace-seq.h"
 
 #ifdef HAVE_UDIS86
 
@@ -248,7 +249,7 @@ static const char *find_exit_reason(unsigned isa, int val)
 }
 
 static int print_exit_reason(struct trace_seq *s, struct tep_record *record,
-                             struct event_format *event, const char *field)
+                             struct tep_event_format *event, const char *field)
 {
         unsigned long long isa;
         unsigned long long val;
@@ -269,7 +270,7 @@ static int print_exit_reason(struct trace_seq *s, struct tep_record *record,
 }
 
 static int kvm_exit_handler(struct trace_seq *s, struct tep_record *record,
-                            struct event_format *event, void *context)
+                            struct tep_event_format *event, void *context)
 {
         unsigned long long info1 = 0, info2 = 0;
 
@@ -292,7 +293,7 @@ static int kvm_exit_handler(struct trace_seq *s, struct tep_record *record,
 
 static int kvm_emulate_insn_handler(struct trace_seq *s,
                                     struct tep_record *record,
-                                    struct event_format *event, void *context)
+                                    struct tep_event_format *event, void *context)
 {
         unsigned long long rip, csbase, len, flags, failed;
         int llen;
@@ -331,7 +332,7 @@ static int kvm_emulate_insn_handler(struct trace_seq *s,
 
 
 static int kvm_nested_vmexit_inject_handler(struct trace_seq *s, struct tep_record *record,
-                                            struct event_format *event, void *context)
+                                            struct tep_event_format *event, void *context)
 {
         if (print_exit_reason(s, record, event, "exit_code") < 0)
                 return -1;
@@ -345,7 +346,7 @@ static int kvm_nested_vmexit_inject_handler(struct trace_seq *s, struct tep_reco
 }
 
 static int kvm_nested_vmexit_handler(struct trace_seq *s, struct tep_record *record,
-                                     struct event_format *event, void *context)
+                                     struct tep_event_format *event, void *context)
 {
         tep_print_num_field(s, "rip %llx ", event, "rip", record, 1);
 
@@ -371,7 +372,7 @@ union kvm_mmu_page_role {
 };
 
 static int kvm_mmu_print_role(struct trace_seq *s, struct tep_record *record,
-                              struct event_format *event, void *context)
+                              struct tep_event_format *event, void *context)
 {
         unsigned long long val;
         static const char *access_str[] = {
@@ -418,7 +419,7 @@ static int kvm_mmu_print_role(struct trace_seq *s, struct tep_record *record,
 
 static int kvm_mmu_get_page_handler(struct trace_seq *s,
                                     struct tep_record *record,
-                                    struct event_format *event, void *context)
+                                    struct tep_event_format *event, void *context)
 {
         unsigned long long val;
 
diff --git a/tools/lib/traceevent/plugin_mac80211.c b/tools/lib/traceevent/plugin_mac80211.c
index de50a5316203..da3855e7b86f 100644
--- a/tools/lib/traceevent/plugin_mac80211.c
+++ b/tools/lib/traceevent/plugin_mac80211.c
@@ -22,13 +22,14 @@
 #include <string.h>
 
 #include "event-parse.h"
+#include "trace-seq.h"
 
 #define INDENT 65
 
-static void print_string(struct trace_seq *s, struct event_format *event,
+static void print_string(struct trace_seq *s, struct tep_event_format *event,
                          const char *name, const void *data)
 {
-        struct format_field *f = tep_find_field(event, name);
+        struct tep_format_field *f = tep_find_field(event, name);
         int offset;
         int length;
 
@@ -59,7 +60,7 @@ static void print_string(struct trace_seq *s, struct event_format *event,
 
 static int drv_bss_info_changed(struct trace_seq *s,
                                 struct tep_record *record,
-                                struct event_format *event, void *context)
+                                struct tep_event_format *event, void *context)
 {
         void *data = record->data;
 
diff --git a/tools/lib/traceevent/plugin_sched_switch.c b/tools/lib/traceevent/plugin_sched_switch.c
index eecb4bd95c11..77882272672f 100644
--- a/tools/lib/traceevent/plugin_sched_switch.c
+++ b/tools/lib/traceevent/plugin_sched_switch.c
@@ -22,6 +22,7 @@
 #include <string.h>
 
 #include "event-parse.h"
+#include "trace-seq.h"
 
 static void write_state(struct trace_seq *s, int val)
 {
@@ -44,7 +45,7 @@ static void write_state(struct trace_seq *s, int val)
                 trace_seq_putc(s, 'R');
 }
 
-static void write_and_save_comm(struct format_field *field,
+static void write_and_save_comm(struct tep_format_field *field,
                                 struct tep_record *record,
                                 struct trace_seq *s, int pid)
 {
@@ -66,9 +67,9 @@ static void write_and_save_comm(struct format_field *field,
 
 static int sched_wakeup_handler(struct trace_seq *s,
                                 struct tep_record *record,
-                                struct event_format *event, void *context)
+                                struct tep_event_format *event, void *context)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long long val;
 
         if (tep_get_field_val(s, event, "pid", record, &val, 1))
@@ -95,9 +96,9 @@ static int sched_wakeup_handler(struct trace_seq *s,
 
 static int sched_switch_handler(struct trace_seq *s,
                                 struct tep_record *record,
-                                struct event_format *event, void *context)
+                                struct tep_event_format *event, void *context)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long long val;
 
         if (tep_get_field_val(s, event, "prev_pid", record, &val, 1))
diff --git a/tools/lib/traceevent/plugin_scsi.c b/tools/lib/traceevent/plugin_scsi.c
index 5ec346f6b842..4eba25cc1431 100644
--- a/tools/lib/traceevent/plugin_scsi.c
+++ b/tools/lib/traceevent/plugin_scsi.c
@@ -3,6 +3,7 @@
 #include <string.h>
 #include <inttypes.h>
 #include "event-parse.h"
+#include "trace-seq.h"
 
 typedef unsigned long sector_t;
 typedef uint64_t u64;
diff --git a/tools/lib/traceevent/plugin_xen.c b/tools/lib/traceevent/plugin_xen.c
index b2acbd6e9c86..bc0496e4c296 100644
--- a/tools/lib/traceevent/plugin_xen.c
+++ b/tools/lib/traceevent/plugin_xen.c
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "event-parse.h"
+#include "trace-seq.h"
 
 #define __HYPERVISOR_set_trap_table                     0
 #define __HYPERVISOR_mmu_update                         1
diff --git a/tools/lib/traceevent/tep_strerror.c b/tools/lib/traceevent/tep_strerror.c
new file mode 100644
index 000000000000..4ac26445b2f6
--- /dev/null
+++ b/tools/lib/traceevent/tep_strerror.c
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: LGPL-2.1
+#undef _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+
+#include "event-parse.h"
+
+#undef _PE
+#define _PE(code, str) str
+static const char * const tep_error_str[] = {
+        TEP_ERRORS
+};
+#undef _PE
+
+/*
+ * The tools so far have been using the strerror_r() GNU variant, that returns
+ * a string, be it the buffer passed or something else.
+ *
+ * But that, besides being tricky in cases where we expect that the function
+ * using strerror_r() returns the error formatted in a provided buffer (we have
+ * to check if it returned something else and copy that instead), breaks the
+ * build on systems not using glibc, like Alpine Linux, where musl libc is
+ * used.
+ *
+ * So, introduce yet another wrapper, str_error_r(), that has the GNU
+ * interface, but uses the portable XSI variant of strerror_r(), so that users
+ * rest asured that the provided buffer is used and it is what is returned.
+ */
+int tep_strerror(struct tep_handle *tep __maybe_unused,
+                 enum tep_errno errnum, char *buf, size_t buflen)
+{
+        const char *msg;
+        int idx;
+
+        if (!buflen)
+                return 0;
+
+        if (errnum >= 0) {
+                int err = strerror_r(errnum, buf, buflen);
+                buf[buflen - 1] = 0;
+                return err;
+        }
+
+        if (errnum <= __TEP_ERRNO__START ||
+            errnum >= __TEP_ERRNO__END)
+                return -1;
+
+        idx = errnum - __TEP_ERRNO__START - 1;
+        msg = tep_error_str[idx];
+        snprintf(buf, buflen, "%s", msg);
+
+        return 0;
+}
diff --git a/tools/lib/traceevent/trace-seq.c b/tools/lib/traceevent/trace-seq.c
index e3bac4543d3b..8ff1d55954d1 100644
--- a/tools/lib/traceevent/trace-seq.c
+++ b/tools/lib/traceevent/trace-seq.c
@@ -3,6 +3,8 @@
  * Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
  *
  */
+#include "trace-seq.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/tools/lib/traceevent/trace-seq.h b/tools/lib/traceevent/trace-seq.h
new file mode 100644
index 000000000000..d68ec69f8d1a
--- /dev/null
+++ b/tools/lib/traceevent/trace-seq.h
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: LGPL-2.1
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+#ifndef _TRACE_SEQ_H
+#define _TRACE_SEQ_H
+
+#include <stdarg.h>
+#include <stdio.h>
+
+/* ----------------------- trace_seq ----------------------- */
+
+#ifndef TRACE_SEQ_BUF_SIZE
+#define TRACE_SEQ_BUF_SIZE 4096
+#endif
+
+enum trace_seq_fail {
+        TRACE_SEQ__GOOD,
+        TRACE_SEQ__BUFFER_POISONED,
+        TRACE_SEQ__MEM_ALLOC_FAILED,
+};
+
+/*
+ * Trace sequences are used to allow a function to call several other functions
+ * to create a string of data to use (up to a max of PAGE_SIZE).
+ */
+
+struct trace_seq {
+        char                    *buffer;
+        unsigned int            buffer_size;
+        unsigned int            len;
+        unsigned int            readpos;
+        enum trace_seq_fail     state;
+};
+
+void trace_seq_init(struct trace_seq *s);
+void trace_seq_reset(struct trace_seq *s);
+void trace_seq_destroy(struct trace_seq *s);
+
+extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+        __attribute__ ((format (printf, 2, 0)));
+
+extern int trace_seq_puts(struct trace_seq *s, const char *str);
+extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
+
+extern void trace_seq_terminate(struct trace_seq *s);
+
+extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp);
+extern int trace_seq_do_printf(struct trace_seq *s);
+
+#endif /* _TRACE_SEQ_H */
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index 0be411695379..2f3bf025e305 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -779,7 +779,9 @@ endif
 ifndef NO_LIBBPF
         $(call QUIET_INSTALL, bpf-headers) \
                 $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf'; \
-                $(INSTALL) include/bpf/*.h -t '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf'
+                $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf/linux'; \
+                $(INSTALL) include/bpf/*.h -t '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf'; \
+                $(INSTALL) include/bpf/linux/*.h -t '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf/linux'
         $(call QUIET_INSTALL, bpf-examples) \
                 $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perf_examples_instdir_SQ)/bpf'; \
                 $(INSTALL) examples/bpf/*.c -t '$(DESTDIR_SQ)$(perf_examples_instdir_SQ)/bpf'
diff --git a/tools/perf/arch/arm64/annotate/instructions.c b/tools/perf/arch/arm64/annotate/instructions.c
index 6688977e4ac7..76c6345a57d5 100644
--- a/tools/perf/arch/arm64/annotate/instructions.c
+++ b/tools/perf/arch/arm64/annotate/instructions.c
@@ -8,6 +8,63 @@ struct arm64_annotate {
                 jump_insn;
 };
 
+static int arm64_mov__parse(struct arch *arch __maybe_unused,
+                            struct ins_operands *ops,
+                            struct map_symbol *ms __maybe_unused)
+{
+        char *s = strchr(ops->raw, ','), *target, *endptr;
+
+        if (s == NULL)
+                return -1;
+
+        *s = '\0';
+        ops->source.raw = strdup(ops->raw);
+        *s = ',';
+
+        if (ops->source.raw == NULL)
+                return -1;
+
+        target = ++s;
+        ops->target.raw = strdup(target);
+        if (ops->target.raw == NULL)
+                goto out_free_source;
+
+        ops->target.addr = strtoull(target, &endptr, 16);
+        if (endptr == target)
+                goto out_free_target;
+
+        s = strchr(endptr, '<');
+        if (s == NULL)
+                goto out_free_target;
+        endptr = strchr(s + 1, '>');
+        if (endptr == NULL)
+                goto out_free_target;
+
+        *endptr = '\0';
+        *s = ' ';
+        ops->target.name = strdup(s);
+        *s = '<';
+        *endptr = '>';
+        if (ops->target.name == NULL)
+                goto out_free_target;
+
+        return 0;
+
+out_free_target:
+        zfree(&ops->target.raw);
+out_free_source:
+        zfree(&ops->source.raw);
+        return -1;
+}
+
+static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
+                          struct ins_operands *ops);
+
+static struct ins_ops arm64_mov_ops = {
+        .parse     = arm64_mov__parse,
+        .scnprintf = mov__scnprintf,
+};
+
 static struct ins_ops *arm64__associate_instruction_ops(struct arch *arch, const char *name)
 {
         struct arm64_annotate *arm = arch->priv;
@@ -21,7 +78,7 @@ static struct ins_ops *arm64__associate_instruction_ops(struct arch *arch, const
         else if (!strcmp(name, "ret"))
                 ops = &ret_ops;
         else
-                return NULL;
+                ops = &arm64_mov_ops;
 
         arch__associate_ins_ops(arch, name, ops);
         return ops;
diff --git a/tools/perf/arch/s390/annotate/instructions.c b/tools/perf/arch/s390/annotate/instructions.c
index cee4e2f7c057..de0dd66dbb48 100644
--- a/tools/perf/arch/s390/annotate/instructions.c
+++ b/tools/perf/arch/s390/annotate/instructions.c
@@ -100,8 +100,6 @@ out_free_source:
         return -1;
 }
 
-static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops);
 
 static struct ins_ops s390_mov_ops = {
         .parse     = s390_mov__parse,
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 830481b8db26..93d679eaf1f4 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -283,12 +283,11 @@ out_put:
         return ret;
 }
 
-static int process_feature_event(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+static int process_feature_event(struct perf_session *session,
+                                 union perf_event *event)
 {
         if (event->feat.feat_id < HEADER_LAST_FEATURE)
-                return perf_event__process_feature(tool, event, session);
+                return perf_event__process_feature(session, event);
         return 0;
 }
 
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index a3b346359ba0..eda41673c4f3 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -86,12 +86,10 @@ static int perf_event__drop_oe(struct perf_tool *tool __maybe_unused,
 }
 #endif
 
-static int perf_event__repipe_op2_synth(struct perf_tool *tool,
-                                        union perf_event *event,
-                                        struct perf_session *session
-                                        __maybe_unused)
+static int perf_event__repipe_op2_synth(struct perf_session *session,
+                                        union perf_event *event)
 {
-        return perf_event__repipe_synth(tool, event);
+        return perf_event__repipe_synth(session->tool, event);
 }
 
 static int perf_event__repipe_attr(struct perf_tool *tool,
@@ -133,10 +131,10 @@ static int copy_bytes(struct perf_inject *inject, int fd, off_t size)
         return 0;
 }
 
-static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
-                                       union perf_event *event,
-                                       struct perf_session *session)
+static s64 perf_event__repipe_auxtrace(struct perf_session *session,
+                                       union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_inject *inject = container_of(tool, struct perf_inject,
                                                   tool);
         int ret;
@@ -174,9 +172,8 @@ static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
 #else
 
 static s64
-perf_event__repipe_auxtrace(struct perf_tool *tool __maybe_unused,
-                            union perf_event *event __maybe_unused,
-                            struct perf_session *session __maybe_unused)
+perf_event__repipe_auxtrace(struct perf_session *session __maybe_unused,
+                            union perf_event *event __maybe_unused)
 {
         pr_err("AUX area tracing not supported\n");
         return -EINVAL;
@@ -362,26 +359,24 @@ static int perf_event__repipe_exit(struct perf_tool *tool,
         return err;
 }
 
-static int perf_event__repipe_tracing_data(struct perf_tool *tool,
-                                           union perf_event *event,
-                                           struct perf_session *session)
+static int perf_event__repipe_tracing_data(struct perf_session *session,
+                                           union perf_event *event)
 {
         int err;
 
-        perf_event__repipe_synth(tool, event);
-        err = perf_event__process_tracing_data(tool, event, session);
+        perf_event__repipe_synth(session->tool, event);
+        err = perf_event__process_tracing_data(session, event);
 
         return err;
 }
 
-static int perf_event__repipe_id_index(struct perf_tool *tool,
-                                       union perf_event *event,
-                                       struct perf_session *session)
+static int perf_event__repipe_id_index(struct perf_session *session,
+                                       union perf_event *event)
 {
         int err;
 
-        perf_event__repipe_synth(tool, event);
-        err = perf_event__process_id_index(tool, event, session);
+        perf_event__repipe_synth(session->tool, event);
+        err = perf_event__process_id_index(session, event);
 
         return err;
 }
@@ -803,7 +798,8 @@ int cmd_inject(int argc, const char **argv)
                            "kallsyms pathname"),
                 OPT_BOOLEAN('f', "force", &data.force, "don't complain, do it"),
                 OPT_CALLBACK_OPTARG(0, "itrace", &inject.itrace_synth_opts,
-                                    NULL, "opts", "Instruction Tracing options",
+                                    NULL, "opts", "Instruction Tracing options\n"
+                                    ITRACE_HELP,
                                     itrace_parse_synth_opts),
                 OPT_BOOLEAN(0, "strip", &inject.strip,
                             "strip non-synthesized events (use with --itrace)"),
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 22ebeb92ac51..0980dfe3396b 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -106,9 +106,12 @@ static bool switch_output_time(struct record *rec)
                trigger_is_ready(&switch_output_trigger);
 }
 
-static int record__write(struct record *rec, void *bf, size_t size)
+static int record__write(struct record *rec, struct perf_mmap *map __maybe_unused,
+                         void *bf, size_t size)
 {
-        if (perf_data__write(rec->session->data, bf, size) < 0) {
+        struct perf_data_file *file = &rec->session->data->file;
+
+        if (perf_data_file__write(file, bf, size) < 0) {
                 pr_err("failed to write perf data, error: %m\n");
                 return -1;
         }
@@ -127,15 +130,15 @@ static int process_synthesized_event(struct perf_tool *tool,
                                      struct machine *machine __maybe_unused)
 {
         struct record *rec = container_of(tool, struct record, tool);
-        return record__write(rec, event, event->header.size);
+        return record__write(rec, NULL, event, event->header.size);
 }
 
-static int record__pushfn(void *to, void *bf, size_t size)
+static int record__pushfn(struct perf_mmap *map, void *to, void *bf, size_t size)
 {
         struct record *rec = to;
 
         rec->samples++;
-        return record__write(rec, bf, size);
+        return record__write(rec, map, bf, size);
 }
 
 static volatile int done;
@@ -170,6 +173,7 @@ static void record__sig_exit(void)
 #ifdef HAVE_AUXTRACE_SUPPORT
 
 static int record__process_auxtrace(struct perf_tool *tool,
+                                    struct perf_mmap *map,
                                     union perf_event *event, void *data1,
                                     size_t len1, void *data2, size_t len2)
 {
@@ -197,21 +201,21 @@ static int record__process_auxtrace(struct perf_tool *tool,
         if (padding)
                 padding = 8 - padding;
 
-        record__write(rec, event, event->header.size);
-        record__write(rec, data1, len1);
+        record__write(rec, map, event, event->header.size);
+        record__write(rec, map, data1, len1);
         if (len2)
-                record__write(rec, data2, len2);
-        record__write(rec, &pad, padding);
+                record__write(rec, map, data2, len2);
+        record__write(rec, map, &pad, padding);
 
         return 0;
 }
 
 static int record__auxtrace_mmap_read(struct record *rec,
-                                      struct auxtrace_mmap *mm)
+                                      struct perf_mmap *map)
 {
         int ret;
 
-        ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
+        ret = auxtrace_mmap__read(map, rec->itr, &rec->tool,
                                   record__process_auxtrace);
         if (ret < 0)
                 return ret;
@@ -223,11 +227,11 @@ static int record__auxtrace_mmap_read(struct record *rec,
 }
 
 static int record__auxtrace_mmap_read_snapshot(struct record *rec,
-                                               struct auxtrace_mmap *mm)
+                                               struct perf_mmap *map)
 {
         int ret;
 
-        ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
+        ret = auxtrace_mmap__read_snapshot(map, rec->itr, &rec->tool,
                                            record__process_auxtrace,
                                            rec->opts.auxtrace_snapshot_size);
         if (ret < 0)
@@ -245,13 +249,12 @@ static int record__auxtrace_read_snapshot_all(struct record *rec)
         int rc = 0;
 
         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
-                struct auxtrace_mmap *mm =
-                                &rec->evlist->mmap[i].auxtrace_mmap;
+                struct perf_mmap *map = &rec->evlist->mmap[i];
 
-                if (!mm->base)
+                if (!map->auxtrace_mmap.base)
                         continue;
 
-                if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
+                if (record__auxtrace_mmap_read_snapshot(rec, map) != 0) {
                         rc = -1;
                         goto out;
                 }
@@ -295,7 +298,7 @@ static int record__auxtrace_init(struct record *rec)
 
 static inline
 int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
-                               struct auxtrace_mmap *mm __maybe_unused)
+                               struct perf_mmap *map __maybe_unused)
 {
         return 0;
 }
@@ -529,17 +532,17 @@ static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evli
                 return 0;
 
         for (i = 0; i < evlist->nr_mmaps; i++) {
-                struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
+                struct perf_mmap *map = &maps[i];
 
-                if (maps[i].base) {
-                        if (perf_mmap__push(&maps[i], rec, record__pushfn) != 0) {
+                if (map->base) {
+                        if (perf_mmap__push(map, rec, record__pushfn) != 0) {
                                 rc = -1;
                                 goto out;
                         }
                 }
 
-                if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
-                    record__auxtrace_mmap_read(rec, mm) != 0) {
+                if (map->auxtrace_mmap.base && !rec->opts.auxtrace_snapshot_mode &&
+                    record__auxtrace_mmap_read(rec, map) != 0) {
                         rc = -1;
                         goto out;
                 }
@@ -550,7 +553,7 @@ static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evli
          * at least one event.
          */
         if (bytes_written != rec->bytes_written)
-                rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
+                rc = record__write(rec, NULL, &finished_round_event, sizeof(finished_round_event));
 
         if (overwrite)
                 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
@@ -758,7 +761,7 @@ static int record__synthesize(struct record *rec, bool tail)
                  * We need to synthesize events first, because some
                  * features works on top of them (on report side).
                  */
-                err = perf_event__synthesize_attrs(tool, session,
+                err = perf_event__synthesize_attrs(tool, rec->evlist,
                                                    process_synthesized_event);
                 if (err < 0) {
                         pr_err("Couldn't synthesize attrs.\n");
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index b2188e623e22..257c9c18cb7e 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -201,14 +201,13 @@ static void setup_forced_leader(struct report *report,
                 perf_evlist__force_leader(evlist);
 }
 
-static int process_feature_event(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session __maybe_unused)
+static int process_feature_event(struct perf_session *session,
+                                 union perf_event *event)
 {
-        struct report *rep = container_of(tool, struct report, tool);
+        struct report *rep = container_of(session->tool, struct report, tool);
 
         if (event->feat.feat_id < HEADER_LAST_FEATURE)
-                return perf_event__process_feature(tool, event, session);
+                return perf_event__process_feature(session, event);
 
         if (event->feat.feat_id != HEADER_LAST_FEATURE) {
                 pr_err("failed: wrong feature ID: %" PRIu64 "\n",
@@ -1106,7 +1105,7 @@ int cmd_report(int argc, const char **argv)
         OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
                      "how to display percentage of filtered entries", parse_filter_percentage),
         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
-                            "Instruction Tracing options",
+                            "Instruction Tracing options\n" ITRACE_HELP,
                             itrace_parse_synth_opts),
         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
                         "Show full source file name path for source lines"),
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index ba481d73f910..4da5e32b9e03 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -406,9 +406,10 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                                         PERF_OUTPUT_WEIGHT))
                 return -EINVAL;
 
-        if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
+        if (PRINT_FIELD(SYM) &&
+                !(evsel->attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
                 pr_err("Display of symbols requested but neither sample IP nor "
-                           "sample address\nis selected. Hence, no addresses to convert "
+                           "sample address\navailable. Hence, no addresses to convert "
                        "to symbols.\n");
                 return -EINVAL;
         }
@@ -417,10 +418,9 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                        "selected.\n");
                 return -EINVAL;
         }
-        if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR) &&
-            !PRINT_FIELD(BRSTACK) && !PRINT_FIELD(BRSTACKSYM) && !PRINT_FIELD(BRSTACKOFF)) {
-                pr_err("Display of DSO requested but no address to convert.  Select\n"
-                       "sample IP, sample address, brstack, brstacksym, or brstackoff.\n");
+        if (PRINT_FIELD(DSO) &&
+                !(evsel->attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
+                pr_err("Display of DSO requested but no address to convert.\n");
                 return -EINVAL;
         }
         if (PRINT_FIELD(SRCLINE) && !PRINT_FIELD(IP)) {
@@ -1115,6 +1115,7 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample,
         const char *name = NULL;
         static int spacing;
         int len = 0;
+        int dlen = 0;
         u64 ip = 0;
 
         /*
@@ -1141,6 +1142,12 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample,
                         ip = sample->ip;
         }
 
+        if (PRINT_FIELD(DSO) && !(PRINT_FIELD(IP) || PRINT_FIELD(ADDR))) {
+                dlen += fprintf(fp, "(");
+                dlen += map__fprintf_dsoname(al->map, fp);
+                dlen += fprintf(fp, ")\t");
+        }
+
         if (name)
                 len = fprintf(fp, "%*s%s", (int)depth * 4, "", name);
         else if (ip)
@@ -1159,7 +1166,7 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample,
         if (len < spacing)
                 len += fprintf(fp, "%*s", spacing - len, "");
 
-        return len;
+        return len + dlen;
 }
 
 static int perf_sample__fprintf_insn(struct perf_sample *sample,
@@ -1255,6 +1262,18 @@ static struct {
         {0, NULL}
 };
 
+static const char *sample_flags_to_name(u32 flags)
+{
+        int i;
+
+        for (i = 0; sample_flags[i].name ; i++) {
+                if (sample_flags[i].flags == flags)
+                        return sample_flags[i].name;
+        }
+
+        return NULL;
+}
+
 static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
 {
         const char *chars = PERF_IP_FLAG_CHARS;
@@ -1264,11 +1283,20 @@ static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
         char str[33];
         int i, pos = 0;
 
-        for (i = 0; sample_flags[i].name ; i++) {
-                if (sample_flags[i].flags == (flags & ~PERF_IP_FLAG_IN_TX)) {
-                        name = sample_flags[i].name;
-                        break;
-                }
+        name = sample_flags_to_name(flags & ~PERF_IP_FLAG_IN_TX);
+        if (name)
+                return fprintf(fp, "  %-15s%4s ", name, in_tx ? "(x)" : "");
+
+        if (flags & PERF_IP_FLAG_TRACE_BEGIN) {
+                name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_BEGIN));
+                if (name)
+                        return fprintf(fp, "  tr strt %-7s%4s ", name, in_tx ? "(x)" : "");
+        }
+
+        if (flags & PERF_IP_FLAG_TRACE_END) {
+                name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_END));
+                if (name)
+                        return fprintf(fp, "  tr end  %-7s%4s ", name, in_tx ? "(x)" : "");
         }
 
         for (i = 0; i < n; i++, flags >>= 1) {
@@ -1281,10 +1309,7 @@ static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
         }
         str[pos] = 0;
 
-        if (name)
-                return fprintf(fp, "  %-7s%4s ", name, in_tx ? "(x)" : "");
-
-        return fprintf(fp, "  %-11s ", str);
+        return fprintf(fp, "  %-19s ", str);
 }
 
 struct printer_data {
@@ -1544,7 +1569,8 @@ struct metric_ctx {
         FILE                    *fp;
 };
 
-static void script_print_metric(void *ctx, const char *color,
+static void script_print_metric(struct perf_stat_config *config __maybe_unused,
+                                void *ctx, const char *color,
                                 const char *fmt,
                                 const char *unit, double val)
 {
@@ -1562,7 +1588,8 @@ static void script_print_metric(void *ctx, const char *color,
         fprintf(mctx->fp, " %s\n", unit);
 }
 
-static void script_new_line(void *ctx)
+static void script_new_line(struct perf_stat_config *config __maybe_unused,
+                            void *ctx)
 {
         struct metric_ctx *mctx = ctx;
 
@@ -1608,7 +1635,7 @@ static void perf_sample__fprint_metric(struct perf_script *script,
         evsel_script(evsel)->val = val;
         if (evsel_script(evsel->leader)->gnum == evsel->leader->nr_members) {
                 for_each_group_member (ev2, evsel->leader) {
-                        perf_stat__print_shadow_stats(ev2,
+                        perf_stat__print_shadow_stats(&stat_config, ev2,
                                                       evsel_script(ev2)->val,
                                                       sample->cpu,
                                                       &ctx,
@@ -2489,6 +2516,8 @@ parse:
                                                 output[j].fields &= ~all_output_options[i].field;
                                         else
                                                 output[j].fields |= all_output_options[i].field;
+                                        output[j].user_set = true;
+                                        output[j].wildcard_set = true;
                                 }
                         }
                 } else {
@@ -2499,7 +2528,8 @@ parse:
                                 rc = -EINVAL;
                                 goto out;
                         }
-                        output[type].fields |= all_output_options[i].field;
+                        output[type].user_set = true;
+                        output[type].wildcard_set = true;
                 }
         }
 
@@ -2963,9 +2993,8 @@ static void script__setup_sample_type(struct perf_script *script)
         }
 }
 
-static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
-                                    union perf_event *event,
-                                    struct perf_session *session)
+static int process_stat_round_event(struct perf_session *session,
+                                    union perf_event *event)
 {
         struct stat_round_event *round = &event->stat_round;
         struct perf_evsel *counter;
@@ -2979,9 +3008,8 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_stat_config_event(struct perf_tool *tool __maybe_unused,
-                                     union perf_event *event,
-                                     struct perf_session *session __maybe_unused)
+static int process_stat_config_event(struct perf_session *session __maybe_unused,
+                                     union perf_event *event)
 {
         perf_event__read_stat_config(&stat_config, &event->stat_config);
         return 0;
@@ -3007,10 +3035,10 @@ static int set_maps(struct perf_script *script)
 }
 
 static
-int process_thread_map_event(struct perf_tool *tool,
-                             union perf_event *event,
-                             struct perf_session *session __maybe_unused)
+int process_thread_map_event(struct perf_session *session,
+                             union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_script *script = container_of(tool, struct perf_script, tool);
 
         if (script->threads) {
@@ -3026,10 +3054,10 @@ int process_thread_map_event(struct perf_tool *tool,
 }
 
 static
-int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
-                          union perf_event *event,
-                          struct perf_session *session __maybe_unused)
+int process_cpu_map_event(struct perf_session *session,
+                          union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_script *script = container_of(tool, struct perf_script, tool);
 
         if (script->cpus) {
@@ -3044,21 +3072,21 @@ int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
         return set_maps(script);
 }
 
-static int process_feature_event(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+static int process_feature_event(struct perf_session *session,
+                                 union perf_event *event)
 {
         if (event->feat.feat_id < HEADER_LAST_FEATURE)
-                return perf_event__process_feature(tool, event, session);
+                return perf_event__process_feature(session, event);
         return 0;
 }
 
 #ifdef HAVE_AUXTRACE_SUPPORT
-static int perf_script__process_auxtrace_info(struct perf_tool *tool,
-                                              union perf_event *event,
-                                              struct perf_session *session)
+static int perf_script__process_auxtrace_info(struct perf_session *session,
+                                              union perf_event *event)
 {
-        int ret = perf_event__process_auxtrace_info(tool, event, session);
+        struct perf_tool *tool = session->tool;
+
+        int ret = perf_event__process_auxtrace_info(session, event);
 
         if (ret == 0) {
                 struct perf_script *script = container_of(tool, struct perf_script, tool);
@@ -3193,7 +3221,7 @@ int cmd_script(int argc, const char **argv)
         OPT_BOOLEAN(0, "ns", &nanosecs,
                     "Use 9 decimal places when displaying time"),
         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
-                            "Instruction Tracing options",
+                            "Instruction Tracing options\n" ITRACE_HELP,
                             itrace_parse_synth_opts),
         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
                         "Show full source file name path for source lines"),
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index d097b5b47eb8..b86aba1c8028 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -88,8 +88,6 @@
 #include "sane_ctype.h"
 
 #define DEFAULT_SEPARATOR       " "
-#define CNTR_NOT_SUPPORTED      "<not supported>"
-#define CNTR_NOT_COUNTED        "<not counted>"
 #define FREEZE_ON_SMI_PATH      "devices/cpu/freeze_on_smi"
 
 static void print_counters(struct timespec *ts, int argc, const char **argv);
@@ -137,54 +135,30 @@ static const char *smi_cost_attrs = {
 
 static struct perf_evlist       *evsel_list;
 
-static struct rblist             metric_events;
-
 static struct target target = {
         .uid    = UINT_MAX,
 };
 
-typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu);
-
 #define METRIC_ONLY_LEN 20
 
-static int                      run_count                       =  1;
-static bool                     no_inherit                      = false;
 static volatile pid_t           child_pid                       = -1;
-static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
 static bool                     transaction_run;
 static bool                     topdown_run                     = false;
 static bool                     smi_cost                        = false;
 static bool                     smi_reset                       = false;
-static bool                     big_num                         =  true;
 static int                      big_num_opt                     =  -1;
-static const char               *csv_sep                        = NULL;
-static bool                     csv_output                      = false;
 static bool                     group                           = false;
 static const char               *pre_cmd                        = NULL;
 static const char               *post_cmd                       = NULL;
 static bool                     sync_run                        = false;
-static unsigned int             initial_delay                   = 0;
-static unsigned int             unit_width                      = 4; /* strlen("unit") */
 static bool                     forever                         = false;
-static bool                     metric_only                     = false;
 static bool                     force_metric_only               = false;
-static bool                     no_merge                        = false;
-static bool                     walltime_run_table              = false;
 static struct timespec          ref_time;
-static struct cpu_map           *aggr_map;
-static aggr_get_id_t            aggr_get_id;
 static bool                     append_file;
 static bool                     interval_count;
-static bool                     interval_clear;
 static const char               *output_name;
 static int                      output_fd;
-static int                      print_free_counters_hint;
-static int                      print_mixed_hw_group_error;
-static u64                      *walltime_run;
-static bool                     ru_display                      = false;
-static struct rusage            ru_data;
-static unsigned int             metric_only_len                 = METRIC_ONLY_LEN;
 
 struct perf_stat {
         bool                     record;
@@ -204,15 +178,15 @@ static struct perf_stat		perf_stat;
 static volatile int done = 0;
 
 static struct perf_stat_config stat_config = {
-        .aggr_mode      = AGGR_GLOBAL,
-        .scale          = true,
+        .aggr_mode              = AGGR_GLOBAL,
+        .scale                  = true,
+        .unit_width             = 4, /* strlen("unit") */
+        .run_count              = 1,
+        .metric_only_len        = METRIC_ONLY_LEN,
+        .walltime_nsecs_stats   = &walltime_nsecs_stats,
+        .big_num                = true,
 };
 
-static bool is_duration_time(struct perf_evsel *evsel)
-{
-        return !strcmp(evsel->name, "duration_time");
-}
-
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
                                  struct timespec *b)
 {
@@ -236,66 +210,6 @@ static void perf_stat__reset_stats(void)
                 perf_stat__reset_shadow_per_stat(&stat_config.stats[i]);
 }
 
-static int create_perf_stat_counter(struct perf_evsel *evsel)
-{
-        struct perf_event_attr *attr = &evsel->attr;
-        struct perf_evsel *leader = evsel->leader;
-
-        if (stat_config.scale) {
-                attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
-                                    PERF_FORMAT_TOTAL_TIME_RUNNING;
-        }
-
-        /*
-         * The event is part of non trivial group, let's enable
-         * the group read (for leader) and ID retrieval for all
-         * members.
-         */
-        if (leader->nr_members > 1)
-                attr->read_format |= PERF_FORMAT_ID|PERF_FORMAT_GROUP;
-
-        attr->inherit = !no_inherit;
-
-        /*
-         * Some events get initialized with sample_(period/type) set,
-         * like tracepoints. Clear it up for counting.
-         */
-        attr->sample_period = 0;
-
-        /*
-         * But set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
-         * while avoiding that older tools show confusing messages.
-         *
-         * However for pipe sessions we need to keep it zero,
-         * because script's perf_evsel__check_attr is triggered
-         * by attr->sample_type != 0, and we can't run it on
-         * stat sessions.
-         */
-        if (!(STAT_RECORD && perf_stat.data.is_pipe))
-                attr->sample_type = PERF_SAMPLE_IDENTIFIER;
-
-        /*
-         * Disabling all counters initially, they will be enabled
-         * either manually by us or by kernel via enable_on_exec
-         * set later.
-         */
-        if (perf_evsel__is_group_leader(evsel)) {
-                attr->disabled = 1;
-
-                /*
-                 * In case of initial_delay we enable tracee
-                 * events manually.
-                 */
-                if (target__none(&target) && !initial_delay)
-                        attr->enable_on_exec = 1;
-        }
-
-        if (target__has_cpu(&target) && !target__has_per_thread(&target))
-                return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
-
-        return perf_evsel__open_per_thread(evsel, evsel_list->threads);
-}
-
 static int process_synthesized_event(struct perf_tool *tool __maybe_unused,
                                      union perf_event *event,
                                      struct perf_sample *sample __maybe_unused,
@@ -428,15 +342,15 @@ static void process_interval(void)
 
 static void enable_counters(void)
 {
-        if (initial_delay)
-                usleep(initial_delay * USEC_PER_MSEC);
+        if (stat_config.initial_delay)
+                usleep(stat_config.initial_delay * USEC_PER_MSEC);
 
         /*
          * We need to enable counters only if:
          * - we don't have tracee (attaching to task or cpu)
          * - we have initial delay configured
          */
-        if (!target__none(&target) || initial_delay)
+        if (!target__none(&target) || stat_config.initial_delay)
                 perf_evlist__enable(evsel_list);
 }
 
@@ -464,80 +378,6 @@ static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *inf
         workload_exec_errno = info->si_value.sival_int;
 }
 
-static int perf_stat_synthesize_config(bool is_pipe)
-{
-        int err;
-
-        if (is_pipe) {
-                err = perf_event__synthesize_attrs(NULL, perf_stat.session,
-                                                   process_synthesized_event);
-                if (err < 0) {
-                        pr_err("Couldn't synthesize attrs.\n");
-                        return err;
-                }
-        }
-
-        err = perf_event__synthesize_extra_attr(NULL,
-                                                evsel_list,
-                                                process_synthesized_event,
-                                                is_pipe);
-
-        err = perf_event__synthesize_thread_map2(NULL, evsel_list->threads,
-                                                process_synthesized_event,
-                                                NULL);
-        if (err < 0) {
-                pr_err("Couldn't synthesize thread map.\n");
-                return err;
-        }
-
-        err = perf_event__synthesize_cpu_map(NULL, evsel_list->cpus,
-                                             process_synthesized_event, NULL);
-        if (err < 0) {
-                pr_err("Couldn't synthesize thread map.\n");
-                return err;
-        }
-
-        err = perf_event__synthesize_stat_config(NULL, &stat_config,
-                                                 process_synthesized_event, NULL);
-        if (err < 0) {
-                pr_err("Couldn't synthesize config.\n");
-                return err;
-        }
-
-        return 0;
-}
-
-#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
-
-static int __store_counter_ids(struct perf_evsel *counter)
-{
-        int cpu, thread;
-
-        for (cpu = 0; cpu < xyarray__max_x(counter->fd); cpu++) {
-                for (thread = 0; thread < xyarray__max_y(counter->fd);
-                     thread++) {
-                        int fd = FD(counter, cpu, thread);
-
-                        if (perf_evlist__id_add_fd(evsel_list, counter,
-                                                   cpu, thread, fd) < 0)
-                                return -1;
-                }
-        }
-
-        return 0;
-}
-
-static int store_counter_ids(struct perf_evsel *counter)
-{
-        struct cpu_map *cpus = counter->cpus;
-        struct thread_map *threads = counter->threads;
-
-        if (perf_evsel__alloc_id(counter, cpus->nr, threads->nr))
-                return -ENOMEM;
-
-        return __store_counter_ids(counter);
-}
-
 static bool perf_evsel__should_store_id(struct perf_evsel *counter)
 {
         return STAT_RECORD || counter->attr.read_format & PERF_FORMAT_ID;
@@ -609,7 +449,7 @@ static int __run_perf_stat(int argc, const char **argv, int run_idx)
 
         evlist__for_each_entry(evsel_list, counter) {
 try_again:
-                if (create_perf_stat_counter(counter) < 0) {
+                if (create_perf_stat_counter(counter, &stat_config, &target) < 0) {
 
                         /* Weak group failed. Reset the group. */
                         if ((errno == EINVAL || errno == EBADF) &&
@@ -664,11 +504,11 @@ try_again:
                 counter->supported = true;
 
                 l = strlen(counter->unit);
-                if (l > unit_width)
-                        unit_width = l;
+                if (l > stat_config.unit_width)
+                        stat_config.unit_width = l;
 
                 if (perf_evsel__should_store_id(counter) &&
-                    store_counter_ids(counter))
+                    perf_evsel__store_ids(counter, evsel_list))
                         return -1;
         }
 
@@ -699,7 +539,8 @@ try_again:
                 if (err < 0)
                         return err;
 
-                err = perf_stat_synthesize_config(is_pipe);
+                err = perf_stat_synthesize_config(&stat_config, NULL, evsel_list,
+                                                  process_synthesized_event, is_pipe);
                 if (err < 0)
                         return err;
         }
@@ -724,7 +565,7 @@ try_again:
                                         break;
                         }
                 }
-                wait4(child_pid, &status, 0, &ru_data);
+                wait4(child_pid, &status, 0, &stat_config.ru_data);
 
                 if (workload_exec_errno) {
                         const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
@@ -752,8 +593,8 @@ try_again:
 
         t1 = rdclock();
 
-        if (walltime_run_table)
-                walltime_run[run_idx] = t1 - t0;
+        if (stat_config.walltime_run_table)
+                stat_config.walltime_run[run_idx] = t1 - t0;
 
         update_stats(&walltime_nsecs_stats, t1 - t0);
 
@@ -795,1105 +636,14 @@ static int run_perf_stat(int argc, const char **argv, int run_idx)
         return ret;
 }
 
-static void print_running(u64 run, u64 ena)
-{
-        if (csv_output) {
-                fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f",
-                                        csv_sep,
-                                        run,
-                                        csv_sep,
-                                        ena ? 100.0 * run / ena : 100.0);
-        } else if (run != ena) {
-                fprintf(stat_config.output, "  (%.2f%%)", 100.0 * run / ena);
-        }
-}
-
-static void print_noise_pct(double total, double avg)
-{
-        double pct = rel_stddev_stats(total, avg);
-
-        if (csv_output)
-                fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct);
-        else if (pct)
-                fprintf(stat_config.output, "  ( +-%6.2f%% )", pct);
-}
-
-static void print_noise(struct perf_evsel *evsel, double avg)
-{
-        struct perf_stat_evsel *ps;
-
-        if (run_count == 1)
-                return;
-
-        ps = evsel->stats;
-        print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
-}
-
-static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
-{
-        switch (stat_config.aggr_mode) {
-        case AGGR_CORE:
-                fprintf(stat_config.output, "S%d-C%*d%s%*d%s",
-                        cpu_map__id_to_socket(id),
-                        csv_output ? 0 : -8,
-                        cpu_map__id_to_cpu(id),
-                        csv_sep,
-                        csv_output ? 0 : 4,
-                        nr,
-                        csv_sep);
-                break;
-        case AGGR_SOCKET:
-                fprintf(stat_config.output, "S%*d%s%*d%s",
-                        csv_output ? 0 : -5,
-                        id,
-                        csv_sep,
-                        csv_output ? 0 : 4,
-                        nr,
-                        csv_sep);
-                        break;
-        case AGGR_NONE:
-                fprintf(stat_config.output, "CPU%*d%s",
-                        csv_output ? 0 : -4,
-                        perf_evsel__cpus(evsel)->map[id], csv_sep);
-                break;
-        case AGGR_THREAD:
-                fprintf(stat_config.output, "%*s-%*d%s",
-                        csv_output ? 0 : 16,
-                        thread_map__comm(evsel->threads, id),
-                        csv_output ? 0 : -8,
-                        thread_map__pid(evsel->threads, id),
-                        csv_sep);
-                break;
-        case AGGR_GLOBAL:
-        case AGGR_UNSET:
-        default:
-                break;
-        }
-}
-
-struct outstate {
-        FILE *fh;
-        bool newline;
-        const char *prefix;
-        int  nfields;
-        int  id, nr;
-        struct perf_evsel *evsel;
-};
-
-#define METRIC_LEN  35
-
-static void new_line_std(void *ctx)
-{
-        struct outstate *os = ctx;
-
-        os->newline = true;
-}
-
-static void do_new_line_std(struct outstate *os)
-{
-        fputc('\n', os->fh);
-        fputs(os->prefix, os->fh);
-        aggr_printout(os->evsel, os->id, os->nr);
-        if (stat_config.aggr_mode == AGGR_NONE)
-                fprintf(os->fh, "        ");
-        fprintf(os->fh, "                                                 ");
-}
-
-static void print_metric_std(void *ctx, const char *color, const char *fmt,
-                             const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        int n;
-        bool newline = os->newline;
-
-        os->newline = false;
-
-        if (unit == NULL || fmt == NULL) {
-                fprintf(out, "%-*s", METRIC_LEN, "");
-                return;
-        }
-
-        if (newline)
-                do_new_line_std(os);
-
-        n = fprintf(out, " # ");
-        if (color)
-                n += color_fprintf(out, color, fmt, val);
-        else
-                n += fprintf(out, fmt, val);
-        fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
-}
-
-static void new_line_csv(void *ctx)
-{
-        struct outstate *os = ctx;
-        int i;
-
-        fputc('\n', os->fh);
-        if (os->prefix)
-                fprintf(os->fh, "%s%s", os->prefix, csv_sep);
-        aggr_printout(os->evsel, os->id, os->nr);
-        for (i = 0; i < os->nfields; i++)
-                fputs(csv_sep, os->fh);
-}
-
-static void print_metric_csv(void *ctx,
-                             const char *color __maybe_unused,
-                             const char *fmt, const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        char buf[64], *vals, *ends;
-
-        if (unit == NULL || fmt == NULL) {
-                fprintf(out, "%s%s", csv_sep, csv_sep);
-                return;
-        }
-        snprintf(buf, sizeof(buf), fmt, val);
-        ends = vals = ltrim(buf);
-        while (isdigit(*ends) || *ends == '.')
-                ends++;
-        *ends = 0;
-        while (isspace(*unit))
-                unit++;
-        fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit);
-}
-
-/* Filter out some columns that don't work well in metrics only mode */
-
-static bool valid_only_metric(const char *unit)
-{
-        if (!unit)
-                return false;
-        if (strstr(unit, "/sec") ||
-            strstr(unit, "hz") ||
-            strstr(unit, "Hz") ||
-            strstr(unit, "CPUs utilized"))
-                return false;
-        return true;
-}
-
-static const char *fixunit(char *buf, struct perf_evsel *evsel,
-                           const char *unit)
-{
-        if (!strncmp(unit, "of all", 6)) {
-                snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel),
-                         unit);
-                return buf;
-        }
-        return unit;
-}
-
-static void print_metric_only(void *ctx, const char *color, const char *fmt,
-                              const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        char buf[1024], str[1024];
-        unsigned mlen = metric_only_len;
-
-        if (!valid_only_metric(unit))
-                return;
-        unit = fixunit(buf, os->evsel, unit);
-        if (mlen < strlen(unit))
-                mlen = strlen(unit) + 1;
-
-        if (color)
-                mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
-
-        color_snprintf(str, sizeof(str), color ?: "", fmt, val);
-        fprintf(out, "%*s ", mlen, str);
-}
-
-static void print_metric_only_csv(void *ctx, const char *color __maybe_unused,
-                                  const char *fmt,
-                                  const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        char buf[64], *vals, *ends;
-        char tbuf[1024];
-
-        if (!valid_only_metric(unit))
-                return;
-        unit = fixunit(tbuf, os->evsel, unit);
-        snprintf(buf, sizeof buf, fmt, val);
-        ends = vals = ltrim(buf);
-        while (isdigit(*ends) || *ends == '.')
-                ends++;
-        *ends = 0;
-        fprintf(out, "%s%s", vals, csv_sep);
-}
-
-static void new_line_metric(void *ctx __maybe_unused)
-{
-}
-
-static void print_metric_header(void *ctx, const char *color __maybe_unused,
-                                const char *fmt __maybe_unused,
-                                const char *unit, double val __maybe_unused)
-{
-        struct outstate *os = ctx;
-        char tbuf[1024];
-
-        if (!valid_only_metric(unit))
-                return;
-        unit = fixunit(tbuf, os->evsel, unit);
-        if (csv_output)
-                fprintf(os->fh, "%s%s", unit, csv_sep);
-        else
-                fprintf(os->fh, "%*s ", metric_only_len, unit);
-}
-
-static int first_shadow_cpu(struct perf_evsel *evsel, int id)
-{
-        int i;
-
-        if (!aggr_get_id)
-                return 0;
-
-        if (stat_config.aggr_mode == AGGR_NONE)
-                return id;
-
-        if (stat_config.aggr_mode == AGGR_GLOBAL)
-                return 0;
-
-        for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) {
-                int cpu2 = perf_evsel__cpus(evsel)->map[i];
-
-                if (aggr_get_id(evsel_list->cpus, cpu2) == id)
-                        return cpu2;
-        }
-        return 0;
-}
-
-static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
-{
-        FILE *output = stat_config.output;
-        double sc =  evsel->scale;
-        const char *fmt;
-
-        if (csv_output) {
-                fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
-        } else {
-                if (big_num)
-                        fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
-                else
-                        fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
-        }
-
-        aggr_printout(evsel, id, nr);
-
-        fprintf(output, fmt, avg, csv_sep);
-
-        if (evsel->unit)
-                fprintf(output, "%-*s%s",
-                        csv_output ? 0 : unit_width,
-                        evsel->unit, csv_sep);
-
-        fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel));
-
-        if (evsel->cgrp)
-                fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
-}
-
-static bool is_mixed_hw_group(struct perf_evsel *counter)
-{
-        struct perf_evlist *evlist = counter->evlist;
-        u32 pmu_type = counter->attr.type;
-        struct perf_evsel *pos;
-
-        if (counter->nr_members < 2)
-                return false;
-
-        evlist__for_each_entry(evlist, pos) {
-                /* software events can be part of any hardware group */
-                if (pos->attr.type == PERF_TYPE_SOFTWARE)
-                        continue;
-                if (pmu_type == PERF_TYPE_SOFTWARE) {
-                        pmu_type = pos->attr.type;
-                        continue;
-                }
-                if (pmu_type != pos->attr.type)
-                        return true;
-        }
-
-        return false;
-}
-
-static void printout(int id, int nr, struct perf_evsel *counter, double uval,
-                     char *prefix, u64 run, u64 ena, double noise,
-                     struct runtime_stat *st)
-{
-        struct perf_stat_output_ctx out;
-        struct outstate os = {
-                .fh = stat_config.output,
-                .prefix = prefix ? prefix : "",
-                .id = id,
-                .nr = nr,
-                .evsel = counter,
-        };
-        print_metric_t pm = print_metric_std;
-        void (*nl)(void *);
-
-        if (metric_only) {
-                nl = new_line_metric;
-                if (csv_output)
-                        pm = print_metric_only_csv;
-                else
-                        pm = print_metric_only;
-        } else
-                nl = new_line_std;
-
-        if (csv_output && !metric_only) {
-                static int aggr_fields[] = {
-                        [AGGR_GLOBAL] = 0,
-                        [AGGR_THREAD] = 1,
-                        [AGGR_NONE] = 1,
-                        [AGGR_SOCKET] = 2,
-                        [AGGR_CORE] = 2,
-                };
-
-                pm = print_metric_csv;
-                nl = new_line_csv;
-                os.nfields = 3;
-                os.nfields += aggr_fields[stat_config.aggr_mode];
-                if (counter->cgrp)
-                        os.nfields++;
-        }
-        if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
-                if (metric_only) {
-                        pm(&os, NULL, "", "", 0);
-                        return;
-                }
-                aggr_printout(counter, id, nr);
-
-                fprintf(stat_config.output, "%*s%s",
-                        csv_output ? 0 : 18,
-                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
-                        csv_sep);
-
-                if (counter->supported) {
-                        print_free_counters_hint = 1;
-                        if (is_mixed_hw_group(counter))
-                                print_mixed_hw_group_error = 1;
-                }
-
-                fprintf(stat_config.output, "%-*s%s",
-                        csv_output ? 0 : unit_width,
-                        counter->unit, csv_sep);
-
-                fprintf(stat_config.output, "%*s",
-                        csv_output ? 0 : -25,
-                        perf_evsel__name(counter));
-
-                if (counter->cgrp)
-                        fprintf(stat_config.output, "%s%s",
-                                csv_sep, counter->cgrp->name);
-
-                if (!csv_output)
-                        pm(&os, NULL, NULL, "", 0);
-                print_noise(counter, noise);
-                print_running(run, ena);
-                if (csv_output)
-                        pm(&os, NULL, NULL, "", 0);
-                return;
-        }
-
-        if (!metric_only)
-                abs_printout(id, nr, counter, uval);
-
-        out.print_metric = pm;
-        out.new_line = nl;
-        out.ctx = &os;
-        out.force_header = false;
-
-        if (csv_output && !metric_only) {
-                print_noise(counter, noise);
-                print_running(run, ena);
-        }
-
-        perf_stat__print_shadow_stats(counter, uval,
-                                first_shadow_cpu(counter, id),
-                                &out, &metric_events, st);
-        if (!csv_output && !metric_only) {
-                print_noise(counter, noise);
-                print_running(run, ena);
-        }
-}
-
-static void aggr_update_shadow(void)
-{
-        int cpu, s2, id, s;
-        u64 val;
-        struct perf_evsel *counter;
-
-        for (s = 0; s < aggr_map->nr; s++) {
-                id = aggr_map->map[s];
-                evlist__for_each_entry(evsel_list, counter) {
-                        val = 0;
-                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                                s2 = aggr_get_id(evsel_list->cpus, cpu);
-                                if (s2 != id)
-                                        continue;
-                                val += perf_counts(counter->counts, cpu, 0)->val;
-                        }
-                        perf_stat__update_shadow_stats(counter, val,
-                                        first_shadow_cpu(counter, id),
-                                        &rt_stat);
-                }
-        }
-}
-
-static void uniquify_event_name(struct perf_evsel *counter)
-{
-        char *new_name;
-        char *config;
-
-        if (counter->uniquified_name ||
-            !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
-                                           strlen(counter->pmu_name)))
-                return;
-
-        config = strchr(counter->name, '/');
-        if (config) {
-                if (asprintf(&new_name,
-                             "%s%s", counter->pmu_name, config) > 0) {
-                        free(counter->name);
-                        counter->name = new_name;
-                }
-        } else {
-                if (asprintf(&new_name,
-                             "%s [%s]", counter->name, counter->pmu_name) > 0) {
-                        free(counter->name);
-                        counter->name = new_name;
-                }
-        }
-
-        counter->uniquified_name = true;
-}
-
-static void collect_all_aliases(struct perf_evsel *counter,
-                            void (*cb)(struct perf_evsel *counter, void *data,
-                                       bool first),
-                            void *data)
-{
-        struct perf_evsel *alias;
-
-        alias = list_prepare_entry(counter, &(evsel_list->entries), node);
-        list_for_each_entry_continue (alias, &evsel_list->entries, node) {
-                if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
-                    alias->scale != counter->scale ||
-                    alias->cgrp != counter->cgrp ||
-                    strcmp(alias->unit, counter->unit) ||
-                    perf_evsel__is_clock(alias) != perf_evsel__is_clock(counter))
-                        break;
-                alias->merged_stat = true;
-                cb(alias, data, false);
-        }
-}
-
-static bool collect_data(struct perf_evsel *counter,
-                            void (*cb)(struct perf_evsel *counter, void *data,
-                                       bool first),
-                            void *data)
-{
-        if (counter->merged_stat)
-                return false;
-        cb(counter, data, true);
-        if (no_merge)
-                uniquify_event_name(counter);
-        else if (counter->auto_merge_stats)
-                collect_all_aliases(counter, cb, data);
-        return true;
-}
-
-struct aggr_data {
-        u64 ena, run, val;
-        int id;
-        int nr;
-        int cpu;
-};
-
-static void aggr_cb(struct perf_evsel *counter, void *data, bool first)
-{
-        struct aggr_data *ad = data;
-        int cpu, s2;
-
-        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                struct perf_counts_values *counts;
-
-                s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
-                if (s2 != ad->id)
-                        continue;
-                if (first)
-                        ad->nr++;
-                counts = perf_counts(counter->counts, cpu, 0);
-                /*
-                 * When any result is bad, make them all to give
-                 * consistent output in interval mode.
-                 */
-                if (counts->ena == 0 || counts->run == 0 ||
-                    counter->counts->scaled == -1) {
-                        ad->ena = 0;
-                        ad->run = 0;
-                        break;
-                }
-                ad->val += counts->val;
-                ad->ena += counts->ena;
-                ad->run += counts->run;
-        }
-}
-
-static void print_aggr(char *prefix)
-{
-        FILE *output = stat_config.output;
-        struct perf_evsel *counter;
-        int s, id, nr;
-        double uval;
-        u64 ena, run, val;
-        bool first;
-
-        if (!(aggr_map || aggr_get_id))
-                return;
-
-        aggr_update_shadow();
-
-        /*
-         * With metric_only everything is on a single line.
-         * Without each counter has its own line.
-         */
-        for (s = 0; s < aggr_map->nr; s++) {
-                struct aggr_data ad;
-                if (prefix && metric_only)
-                        fprintf(output, "%s", prefix);
-
-                ad.id = id = aggr_map->map[s];
-                first = true;
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-
-                        ad.val = ad.ena = ad.run = 0;
-                        ad.nr = 0;
-                        if (!collect_data(counter, aggr_cb, &ad))
-                                continue;
-                        nr = ad.nr;
-                        ena = ad.ena;
-                        run = ad.run;
-                        val = ad.val;
-                        if (first && metric_only) {
-                                first = false;
-                                aggr_printout(counter, id, nr);
-                        }
-                        if (prefix && !metric_only)
-                                fprintf(output, "%s", prefix);
-
-                        uval = val * counter->scale;
-                        printout(id, nr, counter, uval, prefix, run, ena, 1.0,
-                                 &rt_stat);
-                        if (!metric_only)
-                                fputc('\n', output);
-                }
-                if (metric_only)
-                        fputc('\n', output);
-        }
-}
-
-static int cmp_val(const void *a, const void *b)
-{
-        return ((struct perf_aggr_thread_value *)b)->val -
-                ((struct perf_aggr_thread_value *)a)->val;
-}
-
-static struct perf_aggr_thread_value *sort_aggr_thread(
-                                        struct perf_evsel *counter,
-                                        int nthreads, int ncpus,
-                                        int *ret)
-{
-        int cpu, thread, i = 0;
-        double uval;
-        struct perf_aggr_thread_value *buf;
-
-        buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
-        if (!buf)
-                return NULL;
-
-        for (thread = 0; thread < nthreads; thread++) {
-                u64 ena = 0, run = 0, val = 0;
-
-                for (cpu = 0; cpu < ncpus; cpu++) {
-                        val += perf_counts(counter->counts, cpu, thread)->val;
-                        ena += perf_counts(counter->counts, cpu, thread)->ena;
-                        run += perf_counts(counter->counts, cpu, thread)->run;
-                }
-
-                uval = val * counter->scale;
-
-                /*
-                 * Skip value 0 when enabling --per-thread globally,
-                 * otherwise too many 0 output.
-                 */
-                if (uval == 0.0 && target__has_per_thread(&target))
-                        continue;
-
-                buf[i].counter = counter;
-                buf[i].id = thread;
-                buf[i].uval = uval;
-                buf[i].val = val;
-                buf[i].run = run;
-                buf[i].ena = ena;
-                i++;
-        }
-
-        qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);
-
-        if (ret)
-                *ret = i;
-
-        return buf;
-}
-
-static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
-{
-        FILE *output = stat_config.output;
-        int nthreads = thread_map__nr(counter->threads);
-        int ncpus = cpu_map__nr(counter->cpus);
-        int thread, sorted_threads, id;
-        struct perf_aggr_thread_value *buf;
-
-        buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads);
-        if (!buf) {
-                perror("cannot sort aggr thread");
-                return;
-        }
-
-        for (thread = 0; thread < sorted_threads; thread++) {
-                if (prefix)
-                        fprintf(output, "%s", prefix);
-
-                id = buf[thread].id;
-                if (stat_config.stats)
-                        printout(id, 0, buf[thread].counter, buf[thread].uval,
-                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
-                                 &stat_config.stats[id]);
-                else
-                        printout(id, 0, buf[thread].counter, buf[thread].uval,
-                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
-                                 &rt_stat);
-                fputc('\n', output);
-        }
-
-        free(buf);
-}
-
-struct caggr_data {
-        double avg, avg_enabled, avg_running;
-};
-
-static void counter_aggr_cb(struct perf_evsel *counter, void *data,
-                            bool first __maybe_unused)
-{
-        struct caggr_data *cd = data;
-        struct perf_stat_evsel *ps = counter->stats;
-
-        cd->avg += avg_stats(&ps->res_stats[0]);
-        cd->avg_enabled += avg_stats(&ps->res_stats[1]);
-        cd->avg_running += avg_stats(&ps->res_stats[2]);
-}
-
-/*
- * Print out the results of a single counter:
- * aggregated counts in system-wide mode
- */
-static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
-{
-        FILE *output = stat_config.output;
-        double uval;
-        struct caggr_data cd = { .avg = 0.0 };
-
-        if (!collect_data(counter, counter_aggr_cb, &cd))
-                return;
-
-        if (prefix && !metric_only)
-                fprintf(output, "%s", prefix);
-
-        uval = cd.avg * counter->scale;
-        printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
-                 cd.avg, &rt_stat);
-        if (!metric_only)
-                fprintf(output, "\n");
-}
-
-static void counter_cb(struct perf_evsel *counter, void *data,
-                       bool first __maybe_unused)
-{
-        struct aggr_data *ad = data;
-
-        ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
-        ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
-        ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
-}
-
-/*
- * Print out the results of a single counter:
- * does not use aggregated count in system-wide
- */
-static void print_counter(struct perf_evsel *counter, char *prefix)
-{
-        FILE *output = stat_config.output;
-        u64 ena, run, val;
-        double uval;
-        int cpu;
-
-        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                struct aggr_data ad = { .cpu = cpu };
-
-                if (!collect_data(counter, counter_cb, &ad))
-                        return;
-                val = ad.val;
-                ena = ad.ena;
-                run = ad.run;
-
-                if (prefix)
-                        fprintf(output, "%s", prefix);
-
-                uval = val * counter->scale;
-                printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
-                         &rt_stat);
-
-                fputc('\n', output);
-        }
-}
-
-static void print_no_aggr_metric(char *prefix)
-{
-        int cpu;
-        int nrcpus = 0;
-        struct perf_evsel *counter;
-        u64 ena, run, val;
-        double uval;
-
-        nrcpus = evsel_list->cpus->nr;
-        for (cpu = 0; cpu < nrcpus; cpu++) {
-                bool first = true;
-
-                if (prefix)
-                        fputs(prefix, stat_config.output);
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-                        if (first) {
-                                aggr_printout(counter, cpu, 0);
-                                first = false;
-                        }
-                        val = perf_counts(counter->counts, cpu, 0)->val;
-                        ena = perf_counts(counter->counts, cpu, 0)->ena;
-                        run = perf_counts(counter->counts, cpu, 0)->run;
-
-                        uval = val * counter->scale;
-                        printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
-                                 &rt_stat);
-                }
-                fputc('\n', stat_config.output);
-        }
-}
-
-static int aggr_header_lens[] = {
-        [AGGR_CORE] = 18,
-        [AGGR_SOCKET] = 12,
-        [AGGR_NONE] = 6,
-        [AGGR_THREAD] = 24,
-        [AGGR_GLOBAL] = 0,
-};
-
-static const char *aggr_header_csv[] = {
-        [AGGR_CORE]     =       "core,cpus,",
-        [AGGR_SOCKET]   =       "socket,cpus",
-        [AGGR_NONE]     =       "cpu,",
-        [AGGR_THREAD]   =       "comm-pid,",
-        [AGGR_GLOBAL]   =       ""
-};
-
-static void print_metric_headers(const char *prefix, bool no_indent)
-{
-        struct perf_stat_output_ctx out;
-        struct perf_evsel *counter;
-        struct outstate os = {
-                .fh = stat_config.output
-        };
-
-        if (prefix)
-                fprintf(stat_config.output, "%s", prefix);
-
-        if (!csv_output && !no_indent)
-                fprintf(stat_config.output, "%*s",
-                        aggr_header_lens[stat_config.aggr_mode], "");
-        if (csv_output) {
-                if (stat_config.interval)
-                        fputs("time,", stat_config.output);
-                fputs(aggr_header_csv[stat_config.aggr_mode],
-                        stat_config.output);
-        }
-
-        /* Print metrics headers only */
-        evlist__for_each_entry(evsel_list, counter) {
-                if (is_duration_time(counter))
-                        continue;
-                os.evsel = counter;
-                out.ctx = &os;
-                out.print_metric = print_metric_header;
-                out.new_line = new_line_metric;
-                out.force_header = true;
-                os.evsel = counter;
-                perf_stat__print_shadow_stats(counter, 0,
-                                              0,
-                                              &out,
-                                              &metric_events,
-                                              &rt_stat);
-        }
-        fputc('\n', stat_config.output);
-}
-
-static void print_interval(char *prefix, struct timespec *ts)
-{
-        FILE *output = stat_config.output;
-        static int num_print_interval;
-
-        if (interval_clear)
-                puts(CONSOLE_CLEAR);
-
-        sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep);
-
-        if ((num_print_interval == 0 && !csv_output) || interval_clear) {
-                switch (stat_config.aggr_mode) {
-                case AGGR_SOCKET:
-                        fprintf(output, "#           time socket cpus");
-                        if (!metric_only)
-                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_CORE:
-                        fprintf(output, "#           time core         cpus");
-                        if (!metric_only)
-                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_NONE:
-                        fprintf(output, "#           time CPU    ");
-                        if (!metric_only)
-                                fprintf(output, "                counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_THREAD:
-                        fprintf(output, "#           time             comm-pid");
-                        if (!metric_only)
-                                fprintf(output, "                  counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_GLOBAL:
-                default:
-                        fprintf(output, "#           time");
-                        if (!metric_only)
-                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
-                case AGGR_UNSET:
-                        break;
-                }
-        }
-
-        if ((num_print_interval == 0 || interval_clear) && metric_only)
-                print_metric_headers(" ", true);
-        if (++num_print_interval == 25)
-                num_print_interval = 0;
-}
-
-static void print_header(int argc, const char **argv)
-{
-        FILE *output = stat_config.output;
-        int i;
-
-        fflush(stdout);
-
-        if (!csv_output) {
-                fprintf(output, "\n");
-                fprintf(output, " Performance counter stats for ");
-                if (target.system_wide)
-                        fprintf(output, "\'system wide");
-                else if (target.cpu_list)
-                        fprintf(output, "\'CPU(s) %s", target.cpu_list);
-                else if (!target__has_task(&target)) {
-                        fprintf(output, "\'%s", argv ? argv[0] : "pipe");
-                        for (i = 1; argv && (i < argc); i++)
-                                fprintf(output, " %s", argv[i]);
-                } else if (target.pid)
-                        fprintf(output, "process id \'%s", target.pid);
-                else
-                        fprintf(output, "thread id \'%s", target.tid);
-
-                fprintf(output, "\'");
-                if (run_count > 1)
-                        fprintf(output, " (%d runs)", run_count);
-                fprintf(output, ":\n\n");
-        }
-}
-
-static int get_precision(double num)
-{
-        if (num > 1)
-                return 0;
-
-        return lround(ceil(-log10(num)));
-}
-
-static void print_table(FILE *output, int precision, double avg)
-{
-        char tmp[64];
-        int idx, indent = 0;
-
-        scnprintf(tmp, 64, " %17.*f", precision, avg);
-        while (tmp[indent] == ' ')
-                indent++;
-
-        fprintf(output, "%*s# Table of individual measurements:\n", indent, "");
-
-        for (idx = 0; idx < run_count; idx++) {
-                double run = (double) walltime_run[idx] / NSEC_PER_SEC;
-                int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
-
-                fprintf(output, " %17.*f (%+.*f) ",
-                        precision, run, precision, run - avg);
-
-                for (h = 0; h < n; h++)
-                        fprintf(output, "#");
-
-                fprintf(output, "\n");
-        }
-
-        fprintf(output, "\n%*s# Final result:\n", indent, "");
-}
-
-static double timeval2double(struct timeval *t)
-{
-        return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
-}
-
-static void print_footer(void)
-{
-        double avg = avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC;
-        FILE *output = stat_config.output;
-        int n;
-
-        if (!null_run)
-                fprintf(output, "\n");
-
-        if (run_count == 1) {
-                fprintf(output, " %17.9f seconds time elapsed", avg);
-
-                if (ru_display) {
-                        double ru_utime = timeval2double(&ru_data.ru_utime);
-                        double ru_stime = timeval2double(&ru_data.ru_stime);
-
-                        fprintf(output, "\n\n");
-                        fprintf(output, " %17.9f seconds user\n", ru_utime);
-                        fprintf(output, " %17.9f seconds sys\n", ru_stime);
-                }
-        } else {
-                double sd = stddev_stats(&walltime_nsecs_stats) / NSEC_PER_SEC;
-                /*
-                 * Display at most 2 more significant
-                 * digits than the stddev inaccuracy.
-                 */
-                int precision = get_precision(sd) + 2;
-
-                if (walltime_run_table)
-                        print_table(output, precision, avg);
-
-                fprintf(output, " %17.*f +- %.*f seconds time elapsed",
-                        precision, avg, precision, sd);
-
-                print_noise_pct(sd, avg);
-        }
-        fprintf(output, "\n\n");
-
-        if (print_free_counters_hint &&
-            sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
-            n > 0)
-                fprintf(output,
-"Some events weren't counted. Try disabling the NMI watchdog:\n"
-"       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
-"       perf stat ...\n"
-"       echo 1 > /proc/sys/kernel/nmi_watchdog\n");
-
-        if (print_mixed_hw_group_error)
-                fprintf(output,
-                        "The events in group usually have to be from "
-                        "the same PMU. Try reorganizing the group.\n");
-}
-
 static void print_counters(struct timespec *ts, int argc, const char **argv)
 {
-        int interval = stat_config.interval;
-        struct perf_evsel *counter;
-        char buf[64], *prefix = NULL;
-
         /* Do not print anything if we record to the pipe. */
         if (STAT_RECORD && perf_stat.data.is_pipe)
                 return;
 
-        if (interval)
-                print_interval(prefix = buf, ts);
-        else
-                print_header(argc, argv);
-
-        if (metric_only) {
-                static int num_print_iv;
-
-                if (num_print_iv == 0 && !interval)
-                        print_metric_headers(prefix, false);
-                if (num_print_iv++ == 25)
-                        num_print_iv = 0;
-                if (stat_config.aggr_mode == AGGR_GLOBAL && prefix)
-                        fprintf(stat_config.output, "%s", prefix);
-        }
-
-        switch (stat_config.aggr_mode) {
-        case AGGR_CORE:
-        case AGGR_SOCKET:
-                print_aggr(prefix);
-                break;
-        case AGGR_THREAD:
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-                        print_aggr_thread(counter, prefix);
-                }
-                break;
-        case AGGR_GLOBAL:
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-                        print_counter_aggr(counter, prefix);
-                }
-                if (metric_only)
-                        fputc('\n', stat_config.output);
-                break;
-        case AGGR_NONE:
-                if (metric_only)
-                        print_no_aggr_metric(prefix);
-                else {
-                        evlist__for_each_entry(evsel_list, counter) {
-                                if (is_duration_time(counter))
-                                        continue;
-                                print_counter(counter, prefix);
-                        }
-                }
-                break;
-        case AGGR_UNSET:
-        default:
-                break;
-        }
-
-        if (!interval && !csv_output)
-                print_footer();
-
-        fflush(stat_config.output);
+        perf_evlist__print_counters(evsel_list, &stat_config, &target,
+                                    ts, argc, argv);
 }
 
 static volatile int signr = -1;
@@ -1950,7 +700,7 @@ static int enable_metric_only(const struct option *opt __maybe_unused,
                               const char *s __maybe_unused, int unset)
 {
         force_metric_only = true;
-        metric_only = !unset;
+        stat_config.metric_only = !unset;
         return 0;
 }
 
@@ -1958,7 +708,7 @@ static int parse_metric_groups(const struct option *opt,
                                const char *str,
                                int unset __maybe_unused)
 {
-        return metricgroup__parse_groups(opt, str, &metric_events);
+        return metricgroup__parse_groups(opt, str, &stat_config.metric_events);
 }
 
 static const struct option stat_options[] = {
@@ -1969,7 +719,7 @@ static const struct option stat_options[] = {
                      parse_events_option),
         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
                      "event filter", parse_filter),
-        OPT_BOOLEAN('i', "no-inherit", &no_inherit,
+        OPT_BOOLEAN('i', "no-inherit", &stat_config.no_inherit,
                     "child tasks do not inherit counters"),
         OPT_STRING('p', "pid", &target.pid, "pid",
                    "stat events on existing process id"),
@@ -1982,11 +732,11 @@ static const struct option stat_options[] = {
         OPT_BOOLEAN('c', "scale", &stat_config.scale, "scale/normalize counters"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
-        OPT_INTEGER('r', "repeat", &run_count,
+        OPT_INTEGER('r', "repeat", &stat_config.run_count,
                     "repeat command and print average + stddev (max: 100, forever: 0)"),
-        OPT_BOOLEAN(0, "table", &walltime_run_table,
+        OPT_BOOLEAN(0, "table", &stat_config.walltime_run_table,
                     "display details about each run (only with -r option)"),
-        OPT_BOOLEAN('n', "null", &null_run,
+        OPT_BOOLEAN('n', "null", &stat_config.null_run,
                     "null run - dont start any counters"),
         OPT_INCR('d', "detailed", &detailed_run,
                     "detailed run - start a lot of events"),
@@ -1999,8 +749,8 @@ static const struct option stat_options[] = {
                     "list of cpus to monitor in system-wide"),
         OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
                     "disable CPU count aggregation", AGGR_NONE),
-        OPT_BOOLEAN(0, "no-merge", &no_merge, "Do not merge identical named events"),
-        OPT_STRING('x', "field-separator", &csv_sep, "separator",
+        OPT_BOOLEAN(0, "no-merge", &stat_config.no_merge, "Do not merge identical named events"),
+        OPT_STRING('x', "field-separator", &stat_config.csv_sep, "separator",
                    "print counts with custom separator"),
         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
                      "monitor event in cgroup name only", parse_cgroups),
@@ -2017,7 +767,7 @@ static const struct option stat_options[] = {
                     "(overhead is possible for values <= 100ms)"),
         OPT_INTEGER(0, "interval-count", &stat_config.times,
                     "print counts for fixed number of times"),
-        OPT_BOOLEAN(0, "interval-clear", &interval_clear,
+        OPT_BOOLEAN(0, "interval-clear", &stat_config.interval_clear,
                     "clear screen in between new interval"),
         OPT_UINTEGER(0, "timeout", &stat_config.timeout,
                     "stop workload and print counts after a timeout period in ms (>= 10ms)"),
@@ -2027,9 +777,9 @@ static const struct option stat_options[] = {
                      "aggregate counts per physical processor core", AGGR_CORE),
         OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode,
                      "aggregate counts per thread", AGGR_THREAD),
-        OPT_UINTEGER('D', "delay", &initial_delay,
+        OPT_UINTEGER('D', "delay", &stat_config.initial_delay,
                      "ms to wait before starting measurement after program start"),
-        OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL,
+        OPT_CALLBACK_NOOPT(0, "metric-only", &stat_config.metric_only, NULL,
                         "Only print computed metrics. No raw values", enable_metric_only),
         OPT_BOOLEAN(0, "topdown", &topdown_run,
                         "measure topdown level 1 statistics"),
@@ -2041,12 +791,14 @@ static const struct option stat_options[] = {
         OPT_END()
 };
 
-static int perf_stat__get_socket(struct cpu_map *map, int cpu)
+static int perf_stat__get_socket(struct perf_stat_config *config __maybe_unused,
+                                 struct cpu_map *map, int cpu)
 {
         return cpu_map__get_socket(map, cpu, NULL);
 }
 
-static int perf_stat__get_core(struct cpu_map *map, int cpu)
+static int perf_stat__get_core(struct perf_stat_config *config __maybe_unused,
+                               struct cpu_map *map, int cpu)
 {
         return cpu_map__get_core(map, cpu, NULL);
 }
@@ -2063,9 +815,8 @@ static int cpu_map__get_max(struct cpu_map *map)
         return max;
 }
 
-static struct cpu_map *cpus_aggr_map;
-
-static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int idx)
+static int perf_stat__get_aggr(struct perf_stat_config *config,
+                               aggr_get_id_t get_id, struct cpu_map *map, int idx)
 {
         int cpu;
 
@@ -2074,20 +825,22 @@ static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int id
 
         cpu = map->map[idx];
 
-        if (cpus_aggr_map->map[cpu] == -1)
-                cpus_aggr_map->map[cpu] = get_id(map, idx);
+        if (config->cpus_aggr_map->map[cpu] == -1)
+                config->cpus_aggr_map->map[cpu] = get_id(config, map, idx);
 
-        return cpus_aggr_map->map[cpu];
+        return config->cpus_aggr_map->map[cpu];
 }
 
-static int perf_stat__get_socket_cached(struct cpu_map *map, int idx)
+static int perf_stat__get_socket_cached(struct perf_stat_config *config,
+                                        struct cpu_map *map, int idx)
 {
-        return perf_stat__get_aggr(perf_stat__get_socket, map, idx);
+        return perf_stat__get_aggr(config, perf_stat__get_socket, map, idx);
 }
 
-static int perf_stat__get_core_cached(struct cpu_map *map, int idx)
+static int perf_stat__get_core_cached(struct perf_stat_config *config,
+                                      struct cpu_map *map, int idx)
 {
-        return perf_stat__get_aggr(perf_stat__get_core, map, idx);
+        return perf_stat__get_aggr(config, perf_stat__get_core, map, idx);
 }
 
 static int perf_stat_init_aggr_mode(void)
@@ -2096,18 +849,18 @@ static int perf_stat_init_aggr_mode(void)
 
         switch (stat_config.aggr_mode) {
         case AGGR_SOCKET:
-                if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
+                if (cpu_map__build_socket_map(evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build socket map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_socket_cached;
+                stat_config.aggr_get_id = perf_stat__get_socket_cached;
                 break;
         case AGGR_CORE:
-                if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
+                if (cpu_map__build_core_map(evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build core map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_core_cached;
+                stat_config.aggr_get_id = perf_stat__get_core_cached;
                 break;
         case AGGR_NONE:
         case AGGR_GLOBAL:
@@ -2123,16 +876,16 @@ static int perf_stat_init_aggr_mode(void)
          * the aggregation translate cpumap.
          */
         nr = cpu_map__get_max(evsel_list->cpus);
-        cpus_aggr_map = cpu_map__empty_new(nr + 1);
-        return cpus_aggr_map ? 0 : -ENOMEM;
+        stat_config.cpus_aggr_map = cpu_map__empty_new(nr + 1);
+        return stat_config.cpus_aggr_map ? 0 : -ENOMEM;
 }
 
 static void perf_stat__exit_aggr_mode(void)
 {
-        cpu_map__put(aggr_map);
-        cpu_map__put(cpus_aggr_map);
-        aggr_map = NULL;
-        cpus_aggr_map = NULL;
+        cpu_map__put(stat_config.aggr_map);
+        cpu_map__put(stat_config.cpus_aggr_map);
+        stat_config.aggr_map = NULL;
+        stat_config.cpus_aggr_map = NULL;
 }
 
 static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, int idx)
@@ -2190,12 +943,14 @@ static int perf_env__build_core_map(struct perf_env *env, struct cpu_map *cpus,
         return cpu_map__build_map(cpus, corep, perf_env__get_core, env);
 }
 
-static int perf_stat__get_socket_file(struct cpu_map *map, int idx)
+static int perf_stat__get_socket_file(struct perf_stat_config *config __maybe_unused,
+                                      struct cpu_map *map, int idx)
 {
         return perf_env__get_socket(map, idx, &perf_stat.session->header.env);
 }
 
-static int perf_stat__get_core_file(struct cpu_map *map, int idx)
+static int perf_stat__get_core_file(struct perf_stat_config *config __maybe_unused,
+                                    struct cpu_map *map, int idx)
 {
         return perf_env__get_core(map, idx, &perf_stat.session->header.env);
 }
@@ -2206,18 +961,18 @@ static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
 
         switch (stat_config.aggr_mode) {
         case AGGR_SOCKET:
-                if (perf_env__build_socket_map(env, evsel_list->cpus, &aggr_map)) {
+                if (perf_env__build_socket_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build socket map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_socket_file;
+                stat_config.aggr_get_id = perf_stat__get_socket_file;
                 break;
         case AGGR_CORE:
-                if (perf_env__build_core_map(env, evsel_list->cpus, &aggr_map)) {
+                if (perf_env__build_core_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build core map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_core_file;
+                stat_config.aggr_get_id = perf_stat__get_core_file;
                 break;
         case AGGR_NONE:
         case AGGR_GLOBAL:
@@ -2401,7 +1156,7 @@ static int add_default_attributes(void)
         struct parse_events_error errinfo;
 
         /* Set attrs if no event is selected and !null_run: */
-        if (null_run)
+        if (stat_config.null_run)
                 return 0;
 
         if (transaction_run) {
@@ -2414,7 +1169,7 @@ static int add_default_attributes(void)
                         struct option opt = { .value = &evsel_list };
 
                         return metricgroup__parse_groups(&opt, "transaction",
-                                                         &metric_events);
+                                                         &stat_config.metric_events);
                 }
 
                 if (pmu_have_event("cpu", "cycles-ct") &&
@@ -2452,7 +1207,7 @@ static int add_default_attributes(void)
                 if (pmu_have_event("msr", "aperf") &&
                     pmu_have_event("msr", "smi")) {
                         if (!force_metric_only)
-                                metric_only = true;
+                                stat_config.metric_only = true;
                         err = parse_events(evsel_list, smi_cost_attrs, &errinfo);
                 } else {
                         fprintf(stderr, "To measure SMI cost, it needs "
@@ -2483,7 +1238,7 @@ static int add_default_attributes(void)
                 }
 
                 if (!force_metric_only)
-                        metric_only = true;
+                        stat_config.metric_only = true;
                 if (topdown_filter_events(topdown_attrs, &str,
                                 arch_topdown_check_group(&warn)) < 0) {
                         pr_err("Out of memory\n");
@@ -2580,7 +1335,7 @@ static int __cmd_record(int argc, const char **argv)
         if (output_name)
                 data->file.path = output_name;
 
-        if (run_count != 1 || forever) {
+        if (stat_config.run_count != 1 || forever) {
                 pr_err("Cannot use -r option with perf stat record.\n");
                 return -1;
         }
@@ -2599,9 +1354,8 @@ static int __cmd_record(int argc, const char **argv)
         return argc;
 }
 
-static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
-                                    union perf_event *event,
-                                    struct perf_session *session)
+static int process_stat_round_event(struct perf_session *session,
+                                    union perf_event *event)
 {
         struct stat_round_event *stat_round = &event->stat_round;
         struct perf_evsel *counter;
@@ -2626,10 +1380,10 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
 }
 
 static
-int process_stat_config_event(struct perf_tool *tool,
-                              union perf_event *event,
-                              struct perf_session *session __maybe_unused)
+int process_stat_config_event(struct perf_session *session,
+                              union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
 
         perf_event__read_stat_config(&stat_config, &event->stat_config);
@@ -2669,10 +1423,10 @@ static int set_maps(struct perf_stat *st)
 }
 
 static
-int process_thread_map_event(struct perf_tool *tool,
-                             union perf_event *event,
-                             struct perf_session *session __maybe_unused)
+int process_thread_map_event(struct perf_session *session,
+                             union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
 
         if (st->threads) {
@@ -2688,10 +1442,10 @@ int process_thread_map_event(struct perf_tool *tool,
 }
 
 static
-int process_cpu_map_event(struct perf_tool *tool,
-                          union perf_event *event,
-                          struct perf_session *session __maybe_unused)
+int process_cpu_map_event(struct perf_session *session,
+                          union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
         struct cpu_map *cpus;
 
@@ -2853,12 +1607,12 @@ int cmd_stat(int argc, const char **argv)
         perf_stat__collect_metric_expr(evsel_list);
         perf_stat__init_shadow_stats();
 
-        if (csv_sep) {
-                csv_output = true;
-                if (!strcmp(csv_sep, "\\t"))
-                        csv_sep = "\t";
+        if (stat_config.csv_sep) {
+                stat_config.csv_output = true;
+                if (!strcmp(stat_config.csv_sep, "\\t"))
+                        stat_config.csv_sep = "\t";
         } else
-                csv_sep = DEFAULT_SEPARATOR;
+                stat_config.csv_sep = DEFAULT_SEPARATOR;
 
         if (argc && !strncmp(argv[0], "rec", 3)) {
                 argc = __cmd_record(argc, argv);
@@ -2883,17 +1637,17 @@ int cmd_stat(int argc, const char **argv)
                 goto out;
         }
 
-        if (metric_only && stat_config.aggr_mode == AGGR_THREAD) {
+        if (stat_config.metric_only && stat_config.aggr_mode == AGGR_THREAD) {
                 fprintf(stderr, "--metric-only is not supported with --per-thread\n");
                 goto out;
         }
 
-        if (metric_only && run_count > 1) {
+        if (stat_config.metric_only && stat_config.run_count > 1) {
                 fprintf(stderr, "--metric-only is not supported with -r\n");
                 goto out;
         }
 
-        if (walltime_run_table && run_count <= 1) {
+        if (stat_config.walltime_run_table && stat_config.run_count <= 1) {
                 fprintf(stderr, "--table is only supported with -r\n");
                 parse_options_usage(stat_usage, stat_options, "r", 1);
                 parse_options_usage(NULL, stat_options, "table", 0);
@@ -2931,7 +1685,7 @@ int cmd_stat(int argc, const char **argv)
         /*
          * let the spreadsheet do the pretty-printing
          */
-        if (csv_output) {
+        if (stat_config.csv_output) {
                 /* User explicitly passed -B? */
                 if (big_num_opt == 1) {
                         fprintf(stderr, "-B option not supported with -x\n");
@@ -2939,9 +1693,9 @@ int cmd_stat(int argc, const char **argv)
                         parse_options_usage(NULL, stat_options, "x", 1);
                         goto out;
                 } else /* Nope, so disable big number formatting */
-                        big_num = false;
+                        stat_config.big_num = false;
         } else if (big_num_opt == 0) /* User passed --no-big-num */
-                big_num = false;
+                stat_config.big_num = false;
 
         setup_system_wide(argc);
 
@@ -2949,21 +1703,21 @@ int cmd_stat(int argc, const char **argv)
          * Display user/system times only for single
          * run and when there's specified tracee.
          */
-        if ((run_count == 1) && target__none(&target))
-                ru_display = true;
+        if ((stat_config.run_count == 1) && target__none(&target))
+                stat_config.ru_display = true;
 
-        if (run_count < 0) {
+        if (stat_config.run_count < 0) {
                 pr_err("Run count must be a positive number\n");
                 parse_options_usage(stat_usage, stat_options, "r", 1);
                 goto out;
-        } else if (run_count == 0) {
+        } else if (stat_config.run_count == 0) {
                 forever = true;
-                run_count = 1;
+                stat_config.run_count = 1;
         }
 
-        if (walltime_run_table) {
-                walltime_run = zalloc(run_count * sizeof(walltime_run[0]));
-                if (!walltime_run) {
+        if (stat_config.walltime_run_table) {
+                stat_config.walltime_run = zalloc(stat_config.run_count * sizeof(stat_config.walltime_run[0]));
+                if (!stat_config.walltime_run) {
                         pr_err("failed to setup -r option");
                         goto out;
                 }
@@ -3066,6 +1820,17 @@ int cmd_stat(int argc, const char **argv)
                 goto out;
 
         /*
+         * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
+         * while avoiding that older tools show confusing messages.
+         *
+         * However for pipe sessions we need to keep it zero,
+         * because script's perf_evsel__check_attr is triggered
+         * by attr->sample_type != 0, and we can't run it on
+         * stat sessions.
+         */
+        stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe);
+
+        /*
          * We dont want to block the signals - that would cause
          * child tasks to inherit that and Ctrl-C would not work.
          * What we want is for Ctrl-C to work in the exec()-ed
@@ -3079,8 +1844,8 @@ int cmd_stat(int argc, const char **argv)
         signal(SIGABRT, skip_signal);
 
         status = 0;
-        for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
-                if (run_count != 1 && verbose > 0)
+        for (run_idx = 0; forever || run_idx < stat_config.run_count; run_idx++) {
+                if (stat_config.run_count != 1 && verbose > 0)
                         fprintf(output, "[ perf stat: executing run #%d ... ]\n",
                                 run_idx + 1);
 
@@ -3132,7 +1897,7 @@ int cmd_stat(int argc, const char **argv)
         perf_stat__exit_aggr_mode();
         perf_evlist__free_stats(evsel_list);
 out:
-        free(walltime_run);
+        free(stat_config.walltime_run);
 
         if (smi_cost && smi_reset)
                 sysfs__write_int(FREEZE_ON_SMI_PATH, 0);
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 22ab8e67c760..90289f31dd87 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -181,7 +181,7 @@ static int __tp_field__init_uint(struct tp_field *field, int size, int offset, b
         return 0;
 }
 
-static int tp_field__init_uint(struct tp_field *field, struct format_field *format_field, bool needs_swap)
+static int tp_field__init_uint(struct tp_field *field, struct tep_format_field *format_field, bool needs_swap)
 {
         return __tp_field__init_uint(field, format_field->size, format_field->offset, needs_swap);
 }
@@ -198,7 +198,7 @@ static int __tp_field__init_ptr(struct tp_field *field, int offset)
         return 0;
 }
 
-static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
+static int tp_field__init_ptr(struct tp_field *field, struct tep_format_field *format_field)
 {
         return __tp_field__init_ptr(field, format_field->offset);
 }
@@ -214,7 +214,7 @@ static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
                                           struct tp_field *field,
                                           const char *name)
 {
-        struct format_field *format_field = perf_evsel__field(evsel, name);
+        struct tep_format_field *format_field = perf_evsel__field(evsel, name);
 
         if (format_field == NULL)
                 return -1;
@@ -230,7 +230,7 @@ static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
                                          struct tp_field *field,
                                          const char *name)
 {
-        struct format_field *format_field = perf_evsel__field(evsel, name);
+        struct tep_format_field *format_field = perf_evsel__field(evsel, name);
 
         if (format_field == NULL)
                 return -1;
@@ -288,6 +288,13 @@ static int perf_evsel__init_augmented_syscall_tp_args(struct perf_evsel *evsel)
         return __tp_field__init_ptr(&sc->args, sc->id.offset + sizeof(u64));
 }
 
+static int perf_evsel__init_augmented_syscall_tp_ret(struct perf_evsel *evsel)
+{
+        struct syscall_tp *sc = evsel->priv;
+
+        return __tp_field__init_uint(&sc->ret, sizeof(u64), sc->id.offset + sizeof(u64), evsel->needs_swap);
+}
+
 static int perf_evsel__init_raw_syscall_tp(struct perf_evsel *evsel, void *handler)
 {
         evsel->priv = malloc(sizeof(struct syscall_tp));
@@ -498,16 +505,6 @@ static const char *clockid[] = {
 };
 static DEFINE_STRARRAY(clockid);
 
-static const char *socket_families[] = {
-        "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
-        "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
-        "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
-        "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
-        "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
-        "ALG", "NFC", "VSOCK",
-};
-static DEFINE_STRARRAY(socket_families);
-
 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
                                                  struct syscall_arg *arg)
 {
@@ -631,6 +628,8 @@ static struct syscall_fmt {
 } syscall_fmts[] = {
         { .name     = "access",
           .arg = { [1] = { .scnprintf = SCA_ACCMODE,  /* mode */ }, }, },
+        { .name     = "bind",
+          .arg = { [1] = { .scnprintf = SCA_SOCKADDR, /* umyaddr */ }, }, },
         { .name     = "bpf",
           .arg = { [0] = STRARRAY(cmd, bpf_cmd), }, },
         { .name     = "brk",        .hexret = true,
@@ -645,6 +644,8 @@ static struct syscall_fmt {
                    [4] = { .name = "tls",           .scnprintf = SCA_HEX, }, }, },
         { .name     = "close",
           .arg = { [0] = { .scnprintf = SCA_CLOSE_FD, /* fd */ }, }, },
+        { .name     = "connect",
+          .arg = { [1] = { .scnprintf = SCA_SOCKADDR, /* servaddr */ }, }, },
         { .name     = "epoll_ctl",
           .arg = { [1] = STRARRAY(op, epoll_ctl_ops), }, },
         { .name     = "eventfd2",
@@ -801,7 +802,8 @@ static struct syscall_fmt {
         { .name     = "sendmsg",
           .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
         { .name     = "sendto",
-          .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
+          .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ },
+                   [4] = { .scnprintf = SCA_SOCKADDR, /* addr */ }, }, },
         { .name     = "set_tid_address", .errpid = true, },
         { .name     = "setitimer",
           .arg = { [0] = STRARRAY(which, itimers), }, },
@@ -830,6 +832,7 @@ static struct syscall_fmt {
           .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
         { .name     = "tkill",
           .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
+        { .name     = "umount2", .alias = "umount", },
         { .name     = "uname", .alias = "newuname", },
         { .name     = "unlinkat",
           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
@@ -856,13 +859,15 @@ static struct syscall_fmt *syscall_fmt__find(const char *name)
 /*
  * is_exit: is this "exit" or "exit_group"?
  * is_open: is this "open" or "openat"? To associate the fd returned in sys_exit with the pathname in sys_enter.
+ * args_size: sum of the sizes of the syscall arguments, anything after that is augmented stuff: pathname for openat, etc.
  */
 struct syscall {
-        struct event_format *tp_format;
+        struct tep_event_format *tp_format;
         int                 nr_args;
+        int                 args_size;
         bool                is_exit;
         bool                is_open;
-        struct format_field *args;
+        struct tep_format_field *args;
         const char          *name;
         struct syscall_fmt  *fmt;
         struct syscall_arg_fmt *arg_fmt;
@@ -1095,11 +1100,21 @@ static void thread__set_filename_pos(struct thread *thread, const char *bf,
         ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
 }
 
+static size_t syscall_arg__scnprintf_augmented_string(struct syscall_arg *arg, char *bf, size_t size)
+{
+        struct augmented_arg *augmented_arg = arg->augmented.args;
+
+        return scnprintf(bf, size, "%.*s", augmented_arg->size, augmented_arg->value);
+}
+
 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
                                               struct syscall_arg *arg)
 {
         unsigned long ptr = arg->val;
 
+        if (arg->augmented.args)
+                return syscall_arg__scnprintf_augmented_string(arg, bf, size);
+
         if (!arg->trace->vfs_getname)
                 return scnprintf(bf, size, "%#x", ptr);
 
@@ -1142,11 +1157,9 @@ static void sig_handler(int sig)
         interrupted = sig == SIGINT;
 }
 
-static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
-                                        u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
+static size_t trace__fprintf_comm_tid(struct trace *trace, struct thread *thread, FILE *fp)
 {
-        size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
-        printed += fprintf_duration(duration, duration_calculated, fp);
+        size_t printed = 0;
 
         if (trace->multiple_threads) {
                 if (trace->show_comm)
@@ -1157,6 +1170,14 @@ static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thre
         return printed;
 }
 
+static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
+                                        u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
+{
+        size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
+        printed += fprintf_duration(duration, duration_calculated, fp);
+        return printed + trace__fprintf_comm_tid(trace, thread, fp);
+}
+
 static int trace__process_event(struct trace *trace, struct machine *machine,
                                 union perf_event *event, struct perf_sample *sample)
 {
@@ -1258,10 +1279,12 @@ static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 
 static int syscall__set_arg_fmts(struct syscall *sc)
 {
-        struct format_field *field;
+        struct tep_format_field *field, *last_field = NULL;
         int idx = 0, len;
 
         for (field = sc->args; field; field = field->next, ++idx) {
+                last_field = field;
+
                 if (sc->fmt && sc->fmt->arg[idx].scnprintf)
                         continue;
 
@@ -1270,7 +1293,7 @@ static int syscall__set_arg_fmts(struct syscall *sc)
                           strcmp(field->name, "path") == 0 ||
                           strcmp(field->name, "pathname") == 0))
                         sc->arg_fmt[idx].scnprintf = SCA_FILENAME;
-                else if (field->flags & FIELD_IS_POINTER)
+                else if (field->flags & TEP_FIELD_IS_POINTER)
                         sc->arg_fmt[idx].scnprintf = syscall_arg__scnprintf_hex;
                 else if (strcmp(field->type, "pid_t") == 0)
                         sc->arg_fmt[idx].scnprintf = SCA_PID;
@@ -1292,6 +1315,9 @@ static int syscall__set_arg_fmts(struct syscall *sc)
                 }
         }
 
+        if (last_field)
+                sc->args_size = last_field->offset + last_field->size;
+
         return 0;
 }
 
@@ -1472,14 +1498,18 @@ static size_t syscall__scnprintf_val(struct syscall *sc, char *bf, size_t size,
 }
 
 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
-                                      unsigned char *args, struct trace *trace,
-                                      struct thread *thread)
+                                      unsigned char *args, void *augmented_args, int augmented_args_size,
+                                      struct trace *trace, struct thread *thread)
 {
         size_t printed = 0;
         unsigned long val;
         u8 bit = 1;
         struct syscall_arg arg = {
                 .args   = args,
+                .augmented = {
+                        .size = augmented_args_size,
+                        .args = augmented_args,
+                },
                 .idx    = 0,
                 .mask   = 0,
                 .trace  = trace,
@@ -1495,7 +1525,7 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
         ttrace->ret_scnprintf = NULL;
 
         if (sc->args != NULL) {
-                struct format_field *field;
+                struct tep_format_field *field;
 
                 for (field = sc->args; field;
                      field = field->next, ++arg.idx, bit <<= 1) {
@@ -1654,6 +1684,17 @@ static int trace__fprintf_sample(struct trace *trace, struct perf_evsel *evsel,
         return printed;
 }
 
+static void *syscall__augmented_args(struct syscall *sc, struct perf_sample *sample, int *augmented_args_size)
+{
+        void *augmented_args = NULL;
+
+        *augmented_args_size = sample->raw_size - sc->args_size;
+        if (*augmented_args_size > 0)
+                augmented_args = sample->raw_data + sc->args_size;
+
+        return augmented_args;
+}
+
 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                             union perf_event *event __maybe_unused,
                             struct perf_sample *sample)
@@ -1663,6 +1704,8 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
         size_t printed = 0;
         struct thread *thread;
         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
+        int augmented_args_size = 0;
+        void *augmented_args = NULL;
         struct syscall *sc = trace__syscall_info(trace, evsel, id);
         struct thread_trace *ttrace;
 
@@ -1686,13 +1729,24 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
 
         if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
                 trace__printf_interrupted_entry(trace);
-
+        /*
+         * If this is raw_syscalls.sys_enter, then it always comes with the 6 possible
+         * arguments, even if the syscall being handled, say "openat", uses only 4 arguments
+         * this breaks syscall__augmented_args() check for augmented args, as we calculate
+         * syscall->args_size using each syscalls:sys_enter_NAME tracefs format file,
+         * so when handling, say the openat syscall, we end up getting 6 args for the
+         * raw_syscalls:sys_enter event, when we expected just 4, we end up mistakenly
+         * thinking that the extra 2 u64 args are the augmented filename, so just check
+         * here and avoid using augmented syscalls when the evsel is the raw_syscalls one.
+         */
+        if (evsel != trace->syscalls.events.sys_enter)
+                augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size);
         ttrace->entry_time = sample->time;
         msg = ttrace->entry_str;
         printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
 
         printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
-                                           args, trace, thread);
+                                           args, augmented_args, augmented_args_size, trace, thread);
 
         if (sc->is_exit) {
                 if (!(trace->duration_filter || trace->summary_only || trace->failure_only || trace->min_stack)) {
@@ -1723,7 +1777,8 @@ static int trace__fprintf_sys_enter(struct trace *trace, struct perf_evsel *evse
         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
         struct syscall *sc = trace__syscall_info(trace, evsel, id);
         char msg[1024];
-        void *args;
+        void *args, *augmented_args = NULL;
+        int augmented_args_size;
 
         if (sc == NULL)
                 return -1;
@@ -1738,7 +1793,8 @@ static int trace__fprintf_sys_enter(struct trace *trace, struct perf_evsel *evse
                 goto out_put;
 
         args = perf_evsel__sc_tp_ptr(evsel, args, sample);
-        syscall__scnprintf_args(sc, msg, sizeof(msg), args, trace, thread);
+        augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size);
+        syscall__scnprintf_args(sc, msg, sizeof(msg), args, augmented_args, augmented_args_size, trace, thread);
         fprintf(trace->output, "%s", msg);
         err = 0;
 out_put:
@@ -2022,6 +2078,7 @@ static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
                                 union perf_event *event __maybe_unused,
                                 struct perf_sample *sample)
 {
+        struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
         int callchain_ret = 0;
 
         if (sample->callchain) {
@@ -2039,13 +2096,31 @@ static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
         if (trace->trace_syscalls)
                 fprintf(trace->output, "(         ): ");
 
+        if (thread)
+                trace__fprintf_comm_tid(trace, thread, trace->output);
+
+        if (evsel == trace->syscalls.events.augmented) {
+                int id = perf_evsel__sc_tp_uint(evsel, id, sample);
+                struct syscall *sc = trace__syscall_info(trace, evsel, id);
+
+                if (sc) {
+                        fprintf(trace->output, "%s(", sc->name);
+                        trace__fprintf_sys_enter(trace, evsel, sample);
+                        fputc(')', trace->output);
+                        goto newline;
+                }
+
+                /*
+                 * XXX: Not having the associated syscall info or not finding/adding
+                 *      the thread should never happen, but if it does...
+                 *      fall thru and print it as a bpf_output event.
+                 */
+        }
+
         fprintf(trace->output, "%s:", evsel->name);
 
         if (perf_evsel__is_bpf_output(evsel)) {
-                if (evsel == trace->syscalls.events.augmented)
-                        trace__fprintf_sys_enter(trace, evsel, sample);
-                else
-                        bpf_output__fprintf(trace, sample);
+                bpf_output__fprintf(trace, sample);
         } else if (evsel->tp_format) {
                 if (strncmp(evsel->tp_format->name, "sys_enter_", 10) ||
                     trace__fprintf_sys_enter(trace, evsel, sample)) {
@@ -2055,12 +2130,14 @@ static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
                 }
         }
 
+newline:
         fprintf(trace->output, "\n");
 
         if (callchain_ret > 0)
                 trace__fprintf_callchain(trace, sample);
         else if (callchain_ret < 0)
                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
+        thread__put(thread);
 out:
         return 0;
 }
@@ -3276,12 +3353,8 @@ int cmd_trace(int argc, const char **argv)
                 goto out;
         }
 
-        if (evsel) {
-                if (perf_evsel__init_augmented_syscall_tp(evsel) ||
-                    perf_evsel__init_augmented_syscall_tp_args(evsel))
-                        goto out;
+        if (evsel)
                 trace.syscalls.events.augmented = evsel;
-        }
 
         err = bpf__setup_stdout(trace.evlist);
         if (err) {
@@ -3326,6 +3399,34 @@ int cmd_trace(int argc, const char **argv)
                 }
         }
 
+        /*
+         * If we are augmenting syscalls, then combine what we put in the
+         * __augmented_syscalls__ BPF map with what is in the
+         * syscalls:sys_exit_FOO tracepoints, i.e. just like we do without BPF,
+         * combining raw_syscalls:sys_enter with raw_syscalls:sys_exit.
+         *
+         * We'll switch to look at two BPF maps, one for sys_enter and the
+         * other for sys_exit when we start augmenting the sys_exit paths with
+         * buffers that are being copied from kernel to userspace, think 'read'
+         * syscall.
+         */
+        if (trace.syscalls.events.augmented) {
+                evsel = trace.syscalls.events.augmented;
+
+                if (perf_evsel__init_augmented_syscall_tp(evsel) ||
+                    perf_evsel__init_augmented_syscall_tp_args(evsel))
+                        goto out;
+                evsel->handler = trace__sys_enter;
+
+                evlist__for_each_entry(trace.evlist, evsel) {
+                        if (strstarts(perf_evsel__name(evsel), "syscalls:sys_exit_")) {
+                                perf_evsel__init_augmented_syscall_tp(evsel);
+                                perf_evsel__init_augmented_syscall_tp_ret(evsel);
+                                evsel->handler = trace__sys_exit;
+                        }
+                }
+        }
+
         if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
                 return trace__record(&trace, argc-1, &argv[1]);
 
diff --git a/tools/perf/check-headers.sh b/tools/perf/check-headers.sh
index 466540ee8ea7..c72cc73a6b09 100755
--- a/tools/perf/check-headers.sh
+++ b/tools/perf/check-headers.sh
@@ -14,6 +14,7 @@ include/uapi/linux/sched.h
 include/uapi/linux/stat.h
 include/uapi/linux/vhost.h
 include/uapi/sound/asound.h
+include/linux/bits.h
 include/linux/hash.h
 include/uapi/linux/hw_breakpoint.h
 arch/x86/include/asm/disabled-features.h
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 2d0caf20ff3a..bc6c585f74fc 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -30,3 +30,4 @@ perf-test			mainporcelain common
 perf-timechart                  mainporcelain common
 perf-top                        mainporcelain common
 perf-trace                      mainporcelain audit
+perf-version                    mainporcelain common
diff --git a/tools/perf/examples/bpf/augmented_syscalls.c b/tools/perf/examples/bpf/augmented_syscalls.c
index 69a31386d8cd..2ae44813ef2d 100644
--- a/tools/perf/examples/bpf/augmented_syscalls.c
+++ b/tools/perf/examples/bpf/augmented_syscalls.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * Augment the openat syscall with the contents of the filename pointer argument.
+ * Augment syscalls with the contents of the pointer arguments.
  *
  * Test it with:
  *
@@ -10,15 +10,14 @@
  * the last one should be the one for '/etc/passwd'.
  *
  * This matches what is marshalled into the raw_syscall:sys_enter payload
- * expected by the 'perf trace' beautifiers, and can be used by them unmodified,
- * which will be done as that feature is implemented in the next csets, for now
- * it will appear in a dump done by the default tracepoint handler in 'perf trace',
- * that uses bpf_output__fprintf() to just dump those contents, as done with
- * the bpf-output event associated with the __bpf_output__ map declared in
- * tools/perf/include/bpf/stdio.h.
+ * expected by the 'perf trace' beautifiers, and can be used by them, that will
+ * check if perf_sample->raw_data is more than what is expected for each
+ * syscalls:sys_{enter,exit}_SYSCALL tracepoint, uing the extra data as the
+ * contents of pointer arguments.
  */
 
 #include <stdio.h>
+#include <linux/socket.h>
 
 struct bpf_map SEC("maps") __augmented_syscalls__ = {
        .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
@@ -27,6 +26,44 @@ struct bpf_map SEC("maps") __augmented_syscalls__ = {
        .max_entries = __NR_CPUS__,
 };
 
+struct syscall_exit_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               ret;
+};
+
+struct augmented_filename {
+        unsigned int    size;
+        int             reserved;
+        char            value[256];
+};
+
+#define augmented_filename_syscall(syscall)                                                     \
+struct augmented_enter_##syscall##_args {                                                       \
+        struct syscall_enter_##syscall##_args   args;                                           \
+        struct augmented_filename               filename;                                       \
+};                                                                                              \
+int syscall_enter(syscall)(struct syscall_enter_##syscall##_args *args)                         \
+{                                                                                               \
+        struct augmented_enter_##syscall##_args augmented_args = { .filename.reserved = 0, };   \
+        unsigned int len = sizeof(augmented_args);                                              \
+        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);                    \
+        augmented_args.filename.size = probe_read_str(&augmented_args.filename.value,           \
+                                                      sizeof(augmented_args.filename.value),    \
+                                                      args->filename_ptr);                      \
+        if (augmented_args.filename.size < sizeof(augmented_args.filename.value)) {             \
+                len -= sizeof(augmented_args.filename.value) - augmented_args.filename.size;    \
+                len &= sizeof(augmented_args.filename.value) - 1;                               \
+        }                                                                                       \
+        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,                     \
+                          &augmented_args, len);                                                \
+        return 0;                                                                               \
+}                                                                                               \
+int syscall_exit(syscall)(struct syscall_exit_args *args)                                       \
+{                                                                                               \
+       return 1; /* 0 as soon as we start copying data returned by the kernel, e.g. 'read' */   \
+}
+
 struct syscall_enter_openat_args {
         unsigned long long common_tp_fields;
         long               syscall_nr;
@@ -36,20 +73,101 @@ struct syscall_enter_openat_args {
         long               mode;
 };
 
-struct augmented_enter_openat_args {
-        struct syscall_enter_openat_args args;
-        char                             filename[64];
+augmented_filename_syscall(openat);
+
+struct syscall_enter_open_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        char               *filename_ptr;
+        long               flags;
+        long               mode;
+};
+
+augmented_filename_syscall(open);
+
+struct syscall_enter_inotify_add_watch_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        char               *filename_ptr;
+        long               mask;
+};
+
+augmented_filename_syscall(inotify_add_watch);
+
+struct statbuf;
+
+struct syscall_enter_newstat_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        char               *filename_ptr;
+        struct stat        *statbuf;
 };
 
-int syscall_enter(openat)(struct syscall_enter_openat_args *args)
-{
-        struct augmented_enter_openat_args augmented_args;
+augmented_filename_syscall(newstat);
+
+#ifndef _K_SS_MAXSIZE
+#define _K_SS_MAXSIZE 128
+#endif
 
-        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);
-        probe_read_str(&augmented_args.filename, sizeof(augmented_args.filename), args->filename_ptr);
-        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,
-                          &augmented_args, sizeof(augmented_args));
-        return 1;
+#define augmented_sockaddr_syscall(syscall)                                             \
+struct augmented_enter_##syscall##_args {                                                       \
+        struct syscall_enter_##syscall##_args   args;                                           \
+        struct sockaddr_storage                 addr;                                           \
+};                                                                                              \
+int syscall_enter(syscall)(struct syscall_enter_##syscall##_args *args)                         \
+{                                                                                               \
+        struct augmented_enter_##syscall##_args augmented_args;                                 \
+        unsigned long addrlen = sizeof(augmented_args.addr);                                    \
+        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);                    \
+/* FIXME_CLANG_OPTIMIZATION_THAT_ACCESSES_USER_CONTROLLED_ADDRLEN_DESPITE_THIS_CHECK */         \
+/*      if (addrlen > augmented_args.args.addrlen)                                   */         \
+/*              addrlen = augmented_args.args.addrlen;                               */         \
+/*                                                                                   */         \
+        probe_read(&augmented_args.addr, addrlen, args->addr_ptr);                              \
+        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,                     \
+                          &augmented_args,                                                      \
+                          sizeof(augmented_args) - sizeof(augmented_args.addr) + addrlen);      \
+        return 0;                                                                               \
+}                                                                                               \
+int syscall_exit(syscall)(struct syscall_exit_args *args)                                       \
+{                                                                                               \
+       return 1; /* 0 as soon as we start copying data returned by the kernel, e.g. 'read' */   \
 }
 
+struct sockaddr;
+
+struct syscall_enter_bind_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        struct sockaddr    *addr_ptr;
+        unsigned long      addrlen;
+};
+
+augmented_sockaddr_syscall(bind);
+
+struct syscall_enter_connect_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        struct sockaddr    *addr_ptr;
+        unsigned long      addrlen;
+};
+
+augmented_sockaddr_syscall(connect);
+
+struct syscall_enter_sendto_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        void               *buff;
+        long               len;
+        unsigned long      flags;
+        struct sockaddr    *addr_ptr;
+        long               addr_len;
+};
+
+augmented_sockaddr_syscall(sendto);
+
 license(GPL);
diff --git a/tools/perf/examples/bpf/etcsnoop.c b/tools/perf/examples/bpf/etcsnoop.c
new file mode 100644
index 000000000000..b59e8812ee8c
--- /dev/null
+++ b/tools/perf/examples/bpf/etcsnoop.c
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Augment the filename syscalls with the contents of the filename pointer argument
+ * filtering only those that do not start with /etc/.
+ *
+ * Test it with:
+ *
+ * perf trace -e tools/perf/examples/bpf/augmented_syscalls.c cat /etc/passwd > /dev/null
+ *
+ * It'll catch some openat syscalls related to the dynamic linked and
+ * the last one should be the one for '/etc/passwd'.
+ *
+ * This matches what is marshalled into the raw_syscall:sys_enter payload
+ * expected by the 'perf trace' beautifiers, and can be used by them unmodified,
+ * which will be done as that feature is implemented in the next csets, for now
+ * it will appear in a dump done by the default tracepoint handler in 'perf trace',
+ * that uses bpf_output__fprintf() to just dump those contents, as done with
+ * the bpf-output event associated with the __bpf_output__ map declared in
+ * tools/perf/include/bpf/stdio.h.
+ */
+
+#include <stdio.h>
+
+struct bpf_map SEC("maps") __augmented_syscalls__ = {
+       .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
+       .key_size = sizeof(int),
+       .value_size = sizeof(u32),
+       .max_entries = __NR_CPUS__,
+};
+
+struct augmented_filename {
+        int     size;
+        int     reserved;
+        char    value[64];
+};
+
+#define augmented_filename_syscall_enter(syscall)                                               \
+struct augmented_enter_##syscall##_args {                                                       \
+        struct syscall_enter_##syscall##_args   args;                                           \
+        struct augmented_filename               filename;                                       \
+};                                                                                              \
+int syscall_enter(syscall)(struct syscall_enter_##syscall##_args *args)                         \
+{                                                                                               \
+        char etc[6] = "/etc/";                                                                  \
+        struct augmented_enter_##syscall##_args augmented_args = { .filename.reserved = 0, };   \
+        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);                    \
+        augmented_args.filename.size = probe_read_str(&augmented_args.filename.value,           \
+                                                      sizeof(augmented_args.filename.value),    \
+                                                      args->filename_ptr);                      \
+        if (__builtin_memcmp(augmented_args.filename.value, etc, 4) != 0)                       \
+                return 0;                                                                       \
+        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,                     \
+                          &augmented_args,                                                      \
+                          (sizeof(augmented_args) - sizeof(augmented_args.filename.value) +     \
+                           augmented_args.filename.size));                                      \
+        return 0;                                                                               \
+}
+
+struct syscall_enter_openat_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               dfd;
+        char               *filename_ptr;
+        long               flags;
+        long               mode;
+};
+
+augmented_filename_syscall_enter(openat);
+
+struct syscall_enter_open_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        char               *filename_ptr;
+        long               flags;
+        long               mode;
+};
+
+augmented_filename_syscall_enter(open);
+
+license(GPL);
diff --git a/tools/perf/include/bpf/bpf.h b/tools/perf/include/bpf/bpf.h
index 47897d65e799..52b6d87fe822 100644
--- a/tools/perf/include/bpf/bpf.h
+++ b/tools/perf/include/bpf/bpf.h
@@ -26,6 +26,9 @@ struct bpf_map {
 #define syscall_enter(name) \
         SEC("syscalls:sys_enter_" #name) syscall_enter_ ## name
 
+#define syscall_exit(name) \
+        SEC("syscalls:sys_exit_" #name) syscall_exit_ ## name
+
 #define license(name) \
 char _license[] SEC("license") = #name; \
 int _version SEC("version") = LINUX_VERSION_CODE;
diff --git a/tools/perf/include/bpf/linux/socket.h b/tools/perf/include/bpf/linux/socket.h
new file mode 100644
index 000000000000..7f844568dab8
--- /dev/null
+++ b/tools/perf/include/bpf/linux/socket.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_SOCKET_H
+#define _UAPI_LINUX_SOCKET_H
+
+/*
+ * Desired design of maximum size and alignment (see RFC2553)
+ */
+#define _K_SS_MAXSIZE   128     /* Implementation specific max size */
+#define _K_SS_ALIGNSIZE (__alignof__ (struct sockaddr *))
+                                /* Implementation specific desired alignment */
+
+typedef unsigned short __kernel_sa_family_t;
+
+struct __kernel_sockaddr_storage {
+        __kernel_sa_family_t    ss_family;              /* address family */
+        /* Following field(s) are implementation specific */
+        char            __data[_K_SS_MAXSIZE - sizeof(unsigned short)];
+                                /* space to achieve desired size, */
+                                /* _SS_MAXSIZE value minus size of ss_family */
+} __attribute__ ((aligned(_K_SS_ALIGNSIZE)));   /* force desired alignment */
+
+#define sockaddr_storage __kernel_sockaddr_storage
+
+#endif /* _UAPI_LINUX_SOCKET_H */
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/branch.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/branch.json
new file mode 100644
index 000000000000..abc98b018446
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/branch.json
@@ -0,0 +1,23 @@
+[
+    {
+        "ArchStdEvent": "BR_IMMED_SPEC",
+    },
+    {
+        "ArchStdEvent": "BR_RETURN_SPEC",
+    },
+    {
+        "ArchStdEvent": "BR_INDIRECT_SPEC",
+    },
+    {
+        "PublicDescription": "Mispredicted or not predicted branch speculatively executed",
+        "EventCode": "0x10",
+        "EventName": "BR_MIS_PRED",
+        "BriefDescription": "Branch mispredicted"
+    },
+    {
+        "PublicDescription": "Predictable branch speculatively executed",
+        "EventCode": "0x12",
+        "EventName": "BR_PRED",
+        "BriefDescription": "Predictable branch"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/bus.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/bus.json
new file mode 100644
index 000000000000..687b2629e1d1
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/bus.json
@@ -0,0 +1,26 @@
+[
+    {
+        "ArchStdEvent": "BUS_ACCESS_RD",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_WR",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_SHARED",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_NOT_SHARED",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_NORMAL",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_PERIPH",
+    },
+    {
+        "PublicDescription": "Bus access",
+        "EventCode": "0x19",
+        "EventName": "BUS_ACCESS",
+        "BriefDescription": "Bus access"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/cache.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/cache.json
new file mode 100644
index 000000000000..df9201434cb6
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/cache.json
@@ -0,0 +1,191 @@
+[
+    {
+        "ArchStdEvent": "L1D_CACHE_RD",
+    },
+    {
+        "ArchStdEvent": "L1D_CACHE_WR",
+    },
+    {
+        "ArchStdEvent": "L1D_CACHE_REFILL_RD",
+    },
+    {
+        "ArchStdEvent": "L1D_CACHE_INVAL",
+    },
+    {
+        "ArchStdEvent": "L1D_TLB_REFILL_RD",
+    },
+    {
+        "ArchStdEvent": "L1D_TLB_REFILL_WR",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_RD",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_WR",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_REFILL_RD",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_REFILL_WR",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_WB_VICTIM",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_WB_CLEAN",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_INVAL",
+    },
+    {
+        "PublicDescription": "Level 1 instruction cache refill",
+        "EventCode": "0x01",
+        "EventName": "L1I_CACHE_REFILL",
+        "BriefDescription": "L1I cache refill"
+    },
+    {
+        "PublicDescription": "Level 1 instruction TLB refill",
+        "EventCode": "0x02",
+        "EventName": "L1I_TLB_REFILL",
+        "BriefDescription": "L1I TLB refill"
+    },
+    {
+        "PublicDescription": "Level 1 data cache refill",
+        "EventCode": "0x03",
+        "EventName": "L1D_CACHE_REFILL",
+        "BriefDescription": "L1D cache refill"
+    },
+    {
+        "PublicDescription": "Level 1 data cache access",
+        "EventCode": "0x04",
+        "EventName": "L1D_CACHE_ACCESS",
+        "BriefDescription": "L1D cache access"
+    },
+    {
+        "PublicDescription": "Level 1 data TLB refill",
+        "EventCode": "0x05",
+        "EventName": "L1D_TLB_REFILL",
+        "BriefDescription": "L1D TLB refill"
+    },
+    {
+        "PublicDescription": "Level 1 instruction cache access",
+        "EventCode": "0x14",
+        "EventName": "L1I_CACHE_ACCESS",
+        "BriefDescription": "L1I cache access"
+    },
+    {
+        "PublicDescription": "Level 2 data cache access",
+        "EventCode": "0x16",
+        "EventName": "L2D_CACHE_ACCESS",
+        "BriefDescription": "L2D cache access"
+    },
+    {
+        "PublicDescription": "Level 2 data refill",
+        "EventCode": "0x17",
+        "EventName": "L2D_CACHE_REFILL",
+        "BriefDescription": "L2D cache refill"
+    },
+    {
+        "PublicDescription": "Level 2 data cache, Write-Back",
+        "EventCode": "0x18",
+        "EventName": "L2D_CACHE_WB",
+        "BriefDescription": "L2D cache Write-Back"
+    },
+    {
+        "PublicDescription": "Level 1 data TLB access. This event counts any load or store operation which accesses the data L1 TLB",
+        "EventCode": "0x25",
+        "EventName": "L1D_TLB_ACCESS",
+        "BriefDescription": "L1D TLB access"
+    },
+    {
+        "PublicDescription": "Level 1 instruction TLB access. This event counts any instruction fetch which accesses the instruction L1 TLB",
+        "EventCode": "0x26",
+        "EventName": "L1I_TLB_ACCESS",
+        "BriefDescription": "L1I TLB access"
+    },
+    {
+        "PublicDescription": "Level 2 access to data TLB that caused a page table walk. This event counts on any data access which causes L2D_TLB_REFILL to count",
+        "EventCode": "0x34",
+        "EventName": "L2D_TLB_ACCESS",
+        "BriefDescription": "L2D TLB access"
+    },
+    {
+        "PublicDescription": "Level 2 access to instruciton TLB that caused a page table walk. This event counts on any instruciton access which causes L2I_TLB_REFILL to count",
+        "EventCode": "0x35",
+        "EventName": "L2I_TLB_ACCESS",
+        "BriefDescription": "L2D TLB access"
+    },
+    {
+        "PublicDescription": "Branch target buffer misprediction",
+        "EventCode": "0x102",
+        "EventName": "BTB_MIS_PRED",
+        "BriefDescription": "BTB misprediction"
+    },
+    {
+        "PublicDescription": "ITB miss",
+        "EventCode": "0x103",
+        "EventName": "ITB_MISS",
+        "BriefDescription": "ITB miss"
+    },
+    {
+        "PublicDescription": "DTB miss",
+        "EventCode": "0x104",
+        "EventName": "DTB_MISS",
+        "BriefDescription": "DTB miss"
+    },
+    {
+        "PublicDescription": "Level 1 data cache late miss",
+        "EventCode": "0x105",
+        "EventName": "L1D_CACHE_LATE_MISS",
+        "BriefDescription": "L1D cache late miss"
+    },
+    {
+        "PublicDescription": "Level 1 data cache prefetch request",
+        "EventCode": "0x106",
+        "EventName": "L1D_CACHE_PREFETCH",
+        "BriefDescription": "L1D cache prefetch"
+    },
+    {
+        "PublicDescription": "Level 2 data cache prefetch request",
+        "EventCode": "0x107",
+        "EventName": "L2D_CACHE_PREFETCH",
+        "BriefDescription": "L2D cache prefetch"
+    },
+    {
+        "PublicDescription": "Level 1 stage 2 TLB refill",
+        "EventCode": "0x111",
+        "EventName": "L1_STAGE2_TLB_REFILL",
+        "BriefDescription": "L1 stage 2 TLB refill"
+    },
+    {
+        "PublicDescription": "Page walk cache level-0 stage-1 hit",
+        "EventCode": "0x112",
+        "EventName": "PAGE_WALK_L0_STAGE1_HIT",
+        "BriefDescription": "Page walk, L0 stage-1 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-1 stage-1 hit",
+        "EventCode": "0x113",
+        "EventName": "PAGE_WALK_L1_STAGE1_HIT",
+        "BriefDescription": "Page walk, L1 stage-1 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-2 stage-1 hit",
+        "EventCode": "0x114",
+        "EventName": "PAGE_WALK_L2_STAGE1_HIT",
+        "BriefDescription": "Page walk, L2 stage-1 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-1 stage-2 hit",
+        "EventCode": "0x115",
+        "EventName": "PAGE_WALK_L1_STAGE2_HIT",
+        "BriefDescription": "Page walk, L1 stage-2 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-2 stage-2 hit",
+        "EventCode": "0x116",
+        "EventName": "PAGE_WALK_L2_STAGE2_HIT",
+        "BriefDescription": "Page walk, L2 stage-2 hit"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/clock.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/clock.json
new file mode 100644
index 000000000000..38cd1f1a70dc
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/clock.json
@@ -0,0 +1,20 @@
+[
+    {
+        "PublicDescription": "The number of core clock cycles",
+        "EventCode": "0x11",
+        "EventName": "CPU_CYCLES",
+        "BriefDescription": "Clock cycles"
+    },
+    {
+        "PublicDescription": "FSU clocking gated off cycle",
+        "EventCode": "0x101",
+        "EventName": "FSU_CLOCK_OFF_CYCLES",
+        "BriefDescription": "FSU clocking gated off cycle"
+    },
+    {
+        "PublicDescription": "Wait state cycle",
+        "EventCode": "0x110",
+        "EventName": "Wait_CYCLES",
+        "BriefDescription": "Wait state cycle"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/core-imp-def.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/core-imp-def.json
deleted file mode 100644
index bc03c06c3918..000000000000
--- a/tools/perf/pmu-events/arch/arm64/ampere/emag/core-imp-def.json
+++ /dev/null
@@ -1,32 +0,0 @@
-[
-    {
-        "ArchStdEvent": "L1D_CACHE_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_CACHE_WR",
-    },
-    {
-        "ArchStdEvent": "L1D_CACHE_REFILL_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_CACHE_REFILL_WR",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_REFILL_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_REFILL_WR",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_WR",
-    },
-    {
-        "ArchStdEvent": "BUS_ACCESS_RD",
-   },
-   {
-        "ArchStdEvent": "BUS_ACCESS_WR",
-   }
-]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/exception.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/exception.json
new file mode 100644
index 000000000000..3720dc28a15f
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/exception.json
@@ -0,0 +1,50 @@
+[
+    {
+        "ArchStdEvent": "EXC_UNDEF",
+    },
+    {
+        "ArchStdEvent": "EXC_SVC",
+    },
+    {
+        "ArchStdEvent": "EXC_PABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_DABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_IRQ",
+    },
+    {
+        "ArchStdEvent": "EXC_FIQ",
+    },
+    {
+        "ArchStdEvent": "EXC_HVC",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_PABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_DABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_OTHER",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_IRQ",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_FIQ",
+    },
+    {
+        "PublicDescription": "Exception taken",
+        "EventCode": "0x09",
+        "EventName": "EXC_TAKEN",
+        "BriefDescription": "Exception taken"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, condition check pass, exception return",
+        "EventCode": "0x0a",
+        "EventName": "EXC_RETURN",
+        "BriefDescription": "Exception return"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/instruction.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/instruction.json
new file mode 100644
index 000000000000..82cf753e6472
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/instruction.json
@@ -0,0 +1,89 @@
+[
+    {
+        "ArchStdEvent": "LD_SPEC",
+    },
+    {
+        "ArchStdEvent": "ST_SPEC",
+    },
+    {
+        "ArchStdEvent": "LDST_SPEC",
+    },
+    {
+        "ArchStdEvent": "DP_SPEC",
+    },
+    {
+        "ArchStdEvent": "ASE_SPEC",
+    },
+    {
+        "ArchStdEvent": "VFP_SPEC",
+    },
+    {
+        "ArchStdEvent": "PC_WRITE_SPEC",
+    },
+    {
+        "ArchStdEvent": "CRYPTO_SPEC",
+    },
+    {
+        "ArchStdEvent": "ISB_SPEC",
+    },
+    {
+        "ArchStdEvent": "DSB_SPEC",
+    },
+    {
+        "ArchStdEvent": "DMB_SPEC",
+    },
+    {
+        "ArchStdEvent": "RC_LD_SPEC",
+    },
+    {
+        "ArchStdEvent": "RC_ST_SPEC",
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, software increment",
+        "EventCode": "0x00",
+        "EventName": "SW_INCR",
+        "BriefDescription": "Software increment"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed",
+        "EventCode": "0x08",
+        "EventName": "INST_RETIRED",
+        "BriefDescription": "Instruction retired"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, condition code check pass, write to CONTEXTIDR",
+        "EventCode": "0x0b",
+        "EventName": "CID_WRITE_RETIRED",
+        "BriefDescription": "Write to CONTEXTIDR"
+    },
+    {
+        "PublicDescription": "Operation speculatively executed",
+        "EventCode": "0x1b",
+        "EventName": "INST_SPEC",
+        "BriefDescription": "Speculatively executed"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed (condition check pass), write to TTBR",
+        "EventCode": "0x1c",
+        "EventName": "TTBR_WRITE_RETIRED",
+        "BriefDescription": "Instruction executed, TTBR write"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, branch. This event counts all branches, taken or not. This excludes exception entries, debug entries and CCFAIL branches",
+        "EventCode": "0x21",
+        "EventName": "BR_RETIRED",
+        "BriefDescription": "Branch retired"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, mispredicted branch. This event counts any branch counted by BR_RETIRED which is not correctly predicted and causes a pipeline flush",
+        "EventCode": "0x22",
+        "EventName": "BR_MISPRED_RETIRED",
+        "BriefDescription": "Mispredicted branch retired"
+    },
+    {
+        "PublicDescription": "Operation speculatively executed, NOP",
+        "EventCode": "0x100",
+        "EventName": "NOP_SPEC",
+        "BriefDescription": "Speculatively executed, NOP"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/intrinsic.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/intrinsic.json
new file mode 100644
index 000000000000..2aecc5c2347d
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/intrinsic.json
@@ -0,0 +1,14 @@
+[
+    {
+        "ArchStdEvent": "LDREX_SPEC",
+    },
+    {
+        "ArchStdEvent": "STREX_PASS_SPEC",
+    },
+    {
+        "ArchStdEvent": "STREX_FAIL_SPEC",
+    },
+    {
+        "ArchStdEvent": "STREX_SPEC",
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/memory.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/memory.json
new file mode 100644
index 000000000000..08508697b318
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/memory.json
@@ -0,0 +1,29 @@
+[
+    {
+        "ArchStdEvent": "MEM_ACCESS_RD",
+    },
+    {
+        "ArchStdEvent": "MEM_ACCESS_WR",
+    },
+    {
+        "ArchStdEvent": "UNALIGNED_LD_SPEC",
+    },
+    {
+        "ArchStdEvent": "UNALIGNED_ST_SPEC",
+    },
+    {
+        "ArchStdEvent": "UNALIGNED_LDST_SPEC",
+    },
+    {
+        "PublicDescription": "Data memory access",
+        "EventCode": "0x13",
+        "EventName": "MEM_ACCESS",
+        "BriefDescription": "Memory access"
+    },
+    {
+        "PublicDescription": "Local memory error. This event counts any correctable or uncorrectable memory error (ECC or parity) in the protected core RAMs",
+        "EventCode": "0x1a",
+        "EventName": "MEM_ERROR",
+        "BriefDescription": "Memory error"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/pipeline.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/pipeline.json
new file mode 100644
index 000000000000..e2087de586bf
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/pipeline.json
@@ -0,0 +1,50 @@
+[
+    {
+        "PublicDescription": "Decode starved for instruction cycle",
+        "EventCode": "0x108",
+        "EventName": "DECODE_STALL",
+        "BriefDescription": "Decode starved"
+    },
+    {
+        "PublicDescription": "Op dispatch stalled cycle",
+        "EventCode": "0x109",
+        "EventName": "DISPATCH_STALL",
+        "BriefDescription": "Dispatch stalled"
+    },
+    {
+        "PublicDescription": "IXA Op non-issue",
+        "EventCode": "0x10a",
+        "EventName": "IXA_STALL",
+        "BriefDescription": "IXA stalled"
+    },
+    {
+        "PublicDescription": "IXB Op non-issue",
+        "EventCode": "0x10b",
+        "EventName": "IXB_STALL",
+        "BriefDescription": "IXB stalled"
+    },
+    {
+        "PublicDescription": "BX Op non-issue",
+        "EventCode": "0x10c",
+        "EventName": "BX_STALL",
+        "BriefDescription": "BX stalled"
+    },
+    {
+        "PublicDescription": "LX Op non-issue",
+        "EventCode": "0x10d",
+        "EventName": "LX_STALL",
+        "BriefDescription": "LX stalled"
+    },
+    {
+        "PublicDescription": "SX Op non-issue",
+        "EventCode": "0x10e",
+        "EventName": "SX_STALL",
+        "BriefDescription": "SX stalled"
+    },
+    {
+        "PublicDescription": "FX Op non-issue",
+        "EventCode": "0x10f",
+        "EventName": "FX_STALL",
+        "BriefDescription": "FX stalled"
+    },
+]
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 6c108fa79ae3..0b2b8305c965 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -21,6 +21,7 @@ perf-y += python-use.o
 perf-y += bp_signal.o
 perf-y += bp_signal_overflow.o
 perf-y += bp_account.o
+perf-y += wp.o
 perf-y += task-exit.o
 perf-y += sw-clock.o
 perf-y += mmap-thread-lookup.o
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index d7a5e1b9aa6f..12c09e0ece71 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -121,6 +121,16 @@ static struct test generic_tests[] = {
                 .is_supported = test__bp_signal_is_supported,
         },
         {
+                .desc = "Watchpoint",
+                .func = test__wp,
+                .is_supported = test__wp_is_supported,
+                .subtest = {
+                        .skip_if_fail   = false,
+                        .get_nr         = test__wp_subtest_get_nr,
+                        .get_desc       = test__wp_subtest_get_desc,
+                },
+        },
+        {
                 .desc = "Number of exit events of a simple workload",
                 .func = test__task_exit,
         },
diff --git a/tools/perf/tests/evsel-tp-sched.c b/tools/perf/tests/evsel-tp-sched.c
index 699561fa512c..5f8501c68da4 100644
--- a/tools/perf/tests/evsel-tp-sched.c
+++ b/tools/perf/tests/evsel-tp-sched.c
@@ -8,7 +8,7 @@
 static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
                                   int size, bool should_be_signed)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
+        struct tep_format_field *field = perf_evsel__field(evsel, name);
         int is_signed;
         int ret = 0;
 
@@ -17,7 +17,7 @@ static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
                 return -1;
         }
 
-        is_signed = !!(field->flags | FIELD_IS_SIGNED);
+        is_signed = !!(field->flags | TEP_FIELD_IS_SIGNED);
         if (should_be_signed && !is_signed) {
                 pr_debug("%s: \"%s\" signedness(%d) is wrong, should be %d\n",
                          evsel->name, name, is_signed, should_be_signed);
diff --git a/tools/perf/tests/shell/record+probe_libc_inet_pton.sh b/tools/perf/tests/shell/record+probe_libc_inet_pton.sh
index 3013ac8f83d0..cab7b0aea6ea 100755
--- a/tools/perf/tests/shell/record+probe_libc_inet_pton.sh
+++ b/tools/perf/tests/shell/record+probe_libc_inet_pton.sh
@@ -48,7 +48,7 @@ trace_libc_inet_pton_backtrace() {
         *)
                 eventattr='max-stack=3'
                 echo "getaddrinfo\+0x[[:xdigit:]]+[[:space:]]\($libc\)$" >> $expected
-                echo ".*\+0x[[:xdigit:]]+[[:space:]]\(.*/bin/ping.*\)$" >> $expected
+                echo ".*(\+0x[[:xdigit:]]+|\[unknown\])[[:space:]]\(.*/bin/ping.*\)$" >> $expected
                 ;;
         esac
 
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index a9760e790563..b82f55fcc294 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -59,6 +59,9 @@ int test__python_use(struct test *test, int subtest);
 int test__bp_signal(struct test *test, int subtest);
 int test__bp_signal_overflow(struct test *test, int subtest);
 int test__bp_accounting(struct test *test, int subtest);
+int test__wp(struct test *test, int subtest);
+const char *test__wp_subtest_get_desc(int subtest);
+int test__wp_subtest_get_nr(void);
 int test__task_exit(struct test *test, int subtest);
 int test__mem(struct test *test, int subtest);
 int test__sw_clock_freq(struct test *test, int subtest);
@@ -106,6 +109,7 @@ int test__unit_number__scnprint(struct test *test, int subtest);
 int test__mem2node(struct test *t, int subtest);
 
 bool test__bp_signal_is_supported(void);
+bool test__wp_is_supported(void);
 
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/tests/wp.c b/tools/perf/tests/wp.c
new file mode 100644
index 000000000000..f89e6806557b
--- /dev/null
+++ b/tools/perf/tests/wp.c
@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <linux/hw_breakpoint.h>
+#include "tests.h"
+#include "debug.h"
+#include "cloexec.h"
+
+#define WP_TEST_ASSERT_VAL(fd, text, val)       \
+do {                                            \
+        long long count;                        \
+        wp_read(fd, &count, sizeof(long long)); \
+        TEST_ASSERT_VAL(text, count == val);    \
+} while (0)
+
+volatile u64 data1;
+volatile u8 data2[3];
+
+static int wp_read(int fd, long long *count, int size)
+{
+        int ret = read(fd, count, size);
+
+        if (ret != size) {
+                pr_debug("failed to read: %d\n", ret);
+                return -1;
+        }
+        return 0;
+}
+
+static void get__perf_event_attr(struct perf_event_attr *attr, int wp_type,
+                                 void *wp_addr, unsigned long wp_len)
+{
+        memset(attr, 0, sizeof(struct perf_event_attr));
+        attr->type           = PERF_TYPE_BREAKPOINT;
+        attr->size           = sizeof(struct perf_event_attr);
+        attr->config         = 0;
+        attr->bp_type        = wp_type;
+        attr->bp_addr        = (unsigned long)wp_addr;
+        attr->bp_len         = wp_len;
+        attr->sample_period  = 1;
+        attr->sample_type    = PERF_SAMPLE_IP;
+        attr->exclude_kernel = 1;
+        attr->exclude_hv     = 1;
+}
+
+static int __event(int wp_type, void *wp_addr, unsigned long wp_len)
+{
+        int fd;
+        struct perf_event_attr attr;
+
+        get__perf_event_attr(&attr, wp_type, wp_addr, wp_len);
+        fd = sys_perf_event_open(&attr, 0, -1, -1,
+                                 perf_event_open_cloexec_flag());
+        if (fd < 0)
+                pr_debug("failed opening event %x\n", attr.bp_type);
+
+        return fd;
+}
+
+static int wp_ro_test(void)
+{
+        int fd;
+        unsigned long tmp, tmp1 = rand();
+
+        fd = __event(HW_BREAKPOINT_R, (void *)&data1, sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        tmp = data1;
+        WP_TEST_ASSERT_VAL(fd, "RO watchpoint", 1);
+
+        data1 = tmp1 + tmp;
+        WP_TEST_ASSERT_VAL(fd, "RO watchpoint", 1);
+
+        close(fd);
+        return 0;
+}
+
+static int wp_wo_test(void)
+{
+        int fd;
+        unsigned long tmp, tmp1 = rand();
+
+        fd = __event(HW_BREAKPOINT_W, (void *)&data1, sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        tmp = data1;
+        WP_TEST_ASSERT_VAL(fd, "WO watchpoint", 0);
+
+        data1 = tmp1 + tmp;
+        WP_TEST_ASSERT_VAL(fd, "WO watchpoint", 1);
+
+        close(fd);
+        return 0;
+}
+
+static int wp_rw_test(void)
+{
+        int fd;
+        unsigned long tmp, tmp1 = rand();
+
+        fd = __event(HW_BREAKPOINT_R | HW_BREAKPOINT_W, (void *)&data1,
+                     sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        tmp = data1;
+        WP_TEST_ASSERT_VAL(fd, "RW watchpoint", 1);
+
+        data1 = tmp1 + tmp;
+        WP_TEST_ASSERT_VAL(fd, "RW watchpoint", 2);
+
+        close(fd);
+        return 0;
+}
+
+static int wp_modify_test(void)
+{
+        int fd, ret;
+        unsigned long tmp = rand();
+        struct perf_event_attr new_attr;
+
+        fd = __event(HW_BREAKPOINT_W, (void *)&data1, sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        data1 = tmp;
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 1);
+
+        /* Modify watchpoint with disabled = 1 */
+        get__perf_event_attr(&new_attr, HW_BREAKPOINT_W, (void *)&data2[0],
+                             sizeof(u8) * 2);
+        new_attr.disabled = 1;
+        ret = ioctl(fd, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, &new_attr);
+        if (ret < 0) {
+                pr_debug("ioctl(PERF_EVENT_IOC_MODIFY_ATTRIBUTES) failed\n");
+                close(fd);
+                return ret;
+        }
+
+        data2[1] = tmp; /* Not Counted */
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 1);
+
+        /* Enable the event */
+        ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
+        if (ret < 0) {
+                pr_debug("Failed to enable event\n");
+                close(fd);
+                return ret;
+        }
+
+        data2[1] = tmp; /* Counted */
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 2);
+
+        data2[2] = tmp; /* Not Counted */
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 2);
+
+        close(fd);
+        return 0;
+}
+
+static bool wp_ro_supported(void)
+{
+#if defined (__x86_64__) || defined (__i386__)
+        return false;
+#else
+        return true;
+#endif
+}
+
+static void wp_ro_skip_msg(void)
+{
+#if defined (__x86_64__) || defined (__i386__)
+        pr_debug("Hardware does not support read only watchpoints.\n");
+#endif
+}
+
+static struct {
+        const char *desc;
+        int (*target_func)(void);
+        bool (*is_supported)(void);
+        void (*skip_msg)(void);
+} wp_testcase_table[] = {
+        {
+                .desc = "Read Only Watchpoint",
+                .target_func = &wp_ro_test,
+                .is_supported = &wp_ro_supported,
+                .skip_msg = &wp_ro_skip_msg,
+        },
+        {
+                .desc = "Write Only Watchpoint",
+                .target_func = &wp_wo_test,
+        },
+        {
+                .desc = "Read / Write Watchpoint",
+                .target_func = &wp_rw_test,
+        },
+        {
+                .desc = "Modify Watchpoint",
+                .target_func = &wp_modify_test,
+        },
+};
+
+int test__wp_subtest_get_nr(void)
+{
+        return (int)ARRAY_SIZE(wp_testcase_table);
+}
+
+const char *test__wp_subtest_get_desc(int i)
+{
+        if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
+                return NULL;
+        return wp_testcase_table[i].desc;
+}
+
+int test__wp(struct test *test __maybe_unused, int i)
+{
+        if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
+                return TEST_FAIL;
+
+        if (wp_testcase_table[i].is_supported &&
+            !wp_testcase_table[i].is_supported()) {
+                wp_testcase_table[i].skip_msg();
+                return TEST_SKIP;
+        }
+
+        return !wp_testcase_table[i].target_func() ? TEST_OK : TEST_FAIL;
+}
+
+/* The s390 so far does not have support for
+ * instruction breakpoint using the perf_event_open() system call.
+ */
+bool test__wp_is_supported(void)
+{
+#if defined(__s390x__)
+        return false;
+#else
+        return true;
+#endif
+}
diff --git a/tools/perf/trace/beauty/Build b/tools/perf/trace/beauty/Build
index f528ba35e140..c3b0afd67760 100644
--- a/tools/perf/trace/beauty/Build
+++ b/tools/perf/trace/beauty/Build
@@ -7,5 +7,6 @@ endif
 libperf-y += kcmp.o
 libperf-y += pkey_alloc.o
 libperf-y += prctl.o
+libperf-y += sockaddr.o
 libperf-y += socket.o
 libperf-y += statx.o
diff --git a/tools/perf/trace/beauty/beauty.h b/tools/perf/trace/beauty/beauty.h
index 9615af5d412b..2570152d3909 100644
--- a/tools/perf/trace/beauty/beauty.h
+++ b/tools/perf/trace/beauty/beauty.h
@@ -30,9 +30,36 @@ struct thread;
 
 size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_t size);
 
+extern struct strarray strarray__socket_families;
+
+/**
+ * augmented_arg: extra payload for syscall pointer arguments
+ 
+ * If perf_sample->raw_size is more than what a syscall sys_enter_FOO puts,
+ * then its the arguments contents, so that we can show more than just a
+ * pointer. This will be done initially with eBPF, the start of that is at the
+ * tools/perf/examples/bpf/augmented_syscalls.c example for the openat, but
+ * will eventually be done automagically caching the running kernel tracefs
+ * events data into an eBPF C script, that then gets compiled and its .o file
+ * cached for subsequent use. For char pointers like the ones for 'open' like
+ * syscalls its easy, for the rest we should use DWARF or better, BTF, much
+ * more compact.
+ *
+ * @size: 8 if all we need is an integer, otherwise all of the augmented arg.
+ * @int_arg: will be used for integer like pointer contents, like 'accept's 'upeer_addrlen'
+ * @value: u64 aligned, for structs, pathnames
+ */
+struct augmented_arg {
+        int  size;
+        int  int_arg;
+        u64  value[];
+};
+
 /**
  * @val: value of syscall argument being formatted
  * @args: All the args, use syscall_args__val(arg, nth) to access one
+ * @augmented_args: Extra data that can be collected, for instance, with eBPF for expanding the pathname for open, etc
+ * @augmented_args_size: augmented_args total payload size
  * @thread: tid state (maps, pid, tid, etc)
  * @trace: 'perf trace' internals: all threads, etc
  * @parm: private area, may be an strarray, for instance
@@ -43,6 +70,10 @@ size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_
 struct syscall_arg {
         unsigned long val;
         unsigned char *args;
+        struct {
+                struct augmented_arg *args;
+                int                  size;
+        } augmented;
         struct thread *thread;
         struct trace  *trace;
         void          *parm;
@@ -106,6 +137,9 @@ size_t syscall_arg__scnprintf_prctl_arg2(char *bf, size_t size, struct syscall_a
 size_t syscall_arg__scnprintf_prctl_arg3(char *bf, size_t size, struct syscall_arg *arg);
 #define SCA_PRCTL_ARG3 syscall_arg__scnprintf_prctl_arg3
 
+size_t syscall_arg__scnprintf_sockaddr(char *bf, size_t size, struct syscall_arg *arg);
+#define SCA_SOCKADDR syscall_arg__scnprintf_sockaddr
+
 size_t syscall_arg__scnprintf_socket_protocol(char *bf, size_t size, struct syscall_arg *arg);
 #define SCA_SK_PROTO syscall_arg__scnprintf_socket_protocol
 
diff --git a/tools/perf/trace/beauty/sockaddr.c b/tools/perf/trace/beauty/sockaddr.c
new file mode 100644
index 000000000000..71a79f72d9d9
--- /dev/null
+++ b/tools/perf/trace/beauty/sockaddr.c
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (C) 2018, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
+
+#include "trace/beauty/beauty.h"
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <arpa/inet.h>
+
+static const char *socket_families[] = {
+        "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
+        "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
+        "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
+        "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
+        "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
+        "ALG", "NFC", "VSOCK",
+};
+DEFINE_STRARRAY(socket_families);
+
+static size_t af_inet__scnprintf(struct sockaddr *sa, char *bf, size_t size)
+{
+        struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+        char tmp[16];
+        return scnprintf(bf, size, ", port: %d, addr: %s", ntohs(sin->sin_port),
+                         inet_ntop(sin->sin_family, &sin->sin_addr, tmp, sizeof(tmp)));
+}
+
+static size_t af_inet6__scnprintf(struct sockaddr *sa, char *bf, size_t size)
+{
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
+        u32 flowinfo = ntohl(sin6->sin6_flowinfo);
+        char tmp[512];
+        size_t printed = scnprintf(bf, size, ", port: %d, addr: %s", ntohs(sin6->sin6_port),
+                                   inet_ntop(sin6->sin6_family, &sin6->sin6_addr, tmp, sizeof(tmp)));
+        if (flowinfo != 0)
+                printed += scnprintf(bf + printed, size - printed, ", flowinfo: %lu", flowinfo);
+        if (sin6->sin6_scope_id != 0)
+                printed += scnprintf(bf + printed, size - printed, ", scope_id: %lu", sin6->sin6_scope_id);
+
+        return printed;
+}
+
+static size_t af_local__scnprintf(struct sockaddr *sa, char *bf, size_t size)
+{
+        struct sockaddr_un *sun = (struct sockaddr_un *)sa;
+        return scnprintf(bf, size, ", path: %s", sun->sun_path);
+}
+
+static size_t (*af_scnprintfs[])(struct sockaddr *sa, char *bf, size_t size) = {
+        [AF_LOCAL] = af_local__scnprintf,
+        [AF_INET]  = af_inet__scnprintf,
+        [AF_INET6] = af_inet6__scnprintf,
+};
+
+static size_t syscall_arg__scnprintf_augmented_sockaddr(struct syscall_arg *arg, char *bf, size_t size)
+{
+        struct sockaddr *sa = (struct sockaddr *)arg->augmented.args;
+        char family[32];
+        size_t printed;
+
+        strarray__scnprintf(&strarray__socket_families, family, sizeof(family), "%d", sa->sa_family);
+        printed = scnprintf(bf, size, "{ .family: %s", family);
+
+        if (sa->sa_family < ARRAY_SIZE(af_scnprintfs) && af_scnprintfs[sa->sa_family])
+                printed += af_scnprintfs[sa->sa_family](sa, bf + printed, size - printed);
+
+        return printed + scnprintf(bf + printed, size - printed, " }");
+}
+
+size_t syscall_arg__scnprintf_sockaddr(char *bf, size_t size, struct syscall_arg *arg)
+{
+        if (arg->augmented.args)
+                return syscall_arg__scnprintf_augmented_sockaddr(arg, bf, size);
+
+        return scnprintf(bf, size, "%#x", arg->val);
+}
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
index 7efe15b9618d..ecd9f9ceda77 100644
--- a/tools/perf/util/Build
+++ b/tools/perf/util/Build
@@ -73,6 +73,7 @@ libperf-y += vdso.o
 libperf-y += counts.o
 libperf-y += stat.o
 libperf-y += stat-shadow.o
+libperf-y += stat-display.o
 libperf-y += record.o
 libperf-y += srcline.o
 libperf-y += data.o
diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
index db1511359c5e..c4617bcfd521 100644
--- a/tools/perf/util/auxtrace.c
+++ b/tools/perf/util/auxtrace.c
@@ -906,9 +906,8 @@ out_free:
         return err;
 }
 
-int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused,
-                                      union perf_event *event,
-                                      struct perf_session *session)
+int perf_event__process_auxtrace_info(struct perf_session *session,
+                                      union perf_event *event)
 {
         enum auxtrace_type type = event->auxtrace_info.type;
 
@@ -932,9 +931,8 @@ int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused,
         }
 }
 
-s64 perf_event__process_auxtrace(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+s64 perf_event__process_auxtrace(struct perf_session *session,
+                                 union perf_event *event)
 {
         s64 err;
 
@@ -950,7 +948,7 @@ s64 perf_event__process_auxtrace(struct perf_tool *tool,
         if (!session->auxtrace || event->header.type != PERF_RECORD_AUXTRACE)
                 return -EINVAL;
 
-        err = session->auxtrace->process_auxtrace_event(session, event, tool);
+        err = session->auxtrace->process_auxtrace_event(session, event, session->tool);
         if (err < 0)
                 return err;
 
@@ -1185,9 +1183,8 @@ void events_stats__auxtrace_error_warn(const struct events_stats *stats)
         }
 }
 
-int perf_event__process_auxtrace_error(struct perf_tool *tool __maybe_unused,
-                                       union perf_event *event,
-                                       struct perf_session *session)
+int perf_event__process_auxtrace_error(struct perf_session *session,
+                                       union perf_event *event)
 {
         if (auxtrace__dont_decode(session))
                 return 0;
@@ -1196,11 +1193,12 @@ int perf_event__process_auxtrace_error(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
+static int __auxtrace_mmap__read(struct perf_mmap *map,
                                  struct auxtrace_record *itr,
                                  struct perf_tool *tool, process_auxtrace_t fn,
                                  bool snapshot, size_t snapshot_size)
 {
+        struct auxtrace_mmap *mm = &map->auxtrace_mmap;
         u64 head, old = mm->prev, offset, ref;
         unsigned char *data = mm->base;
         size_t size, head_off, old_off, len1, len2, padding;
@@ -1287,7 +1285,7 @@ static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
         ev.auxtrace.tid = mm->tid;
         ev.auxtrace.cpu = mm->cpu;
 
-        if (fn(tool, &ev, data1, len1, data2, len2))
+        if (fn(tool, map, &ev, data1, len1, data2, len2))
                 return -1;
 
         mm->prev = head;
@@ -1306,18 +1304,18 @@ static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
         return 1;
 }
 
-int auxtrace_mmap__read(struct auxtrace_mmap *mm, struct auxtrace_record *itr,
+int auxtrace_mmap__read(struct perf_mmap *map, struct auxtrace_record *itr,
                         struct perf_tool *tool, process_auxtrace_t fn)
 {
-        return __auxtrace_mmap__read(mm, itr, tool, fn, false, 0);
+        return __auxtrace_mmap__read(map, itr, tool, fn, false, 0);
 }
 
-int auxtrace_mmap__read_snapshot(struct auxtrace_mmap *mm,
+int auxtrace_mmap__read_snapshot(struct perf_mmap *map,
                                  struct auxtrace_record *itr,
                                  struct perf_tool *tool, process_auxtrace_t fn,
                                  size_t snapshot_size)
 {
-        return __auxtrace_mmap__read(mm, itr, tool, fn, true, snapshot_size);
+        return __auxtrace_mmap__read(map, itr, tool, fn, true, snapshot_size);
 }
 
 /**
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 71fc3bd74299..d88f6e9eb461 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -23,6 +23,7 @@
 #include <linux/list.h>
 #include <linux/perf_event.h>
 #include <linux/types.h>
+#include <asm/bitsperlong.h>
 
 #include "../perf.h"
 #include "event.h"
@@ -33,6 +34,7 @@ union perf_event;
 struct perf_session;
 struct perf_evlist;
 struct perf_tool;
+struct perf_mmap;
 struct option;
 struct record_opts;
 struct auxtrace_info_event;
@@ -434,13 +436,14 @@ void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp,
                                    bool per_cpu);
 
 typedef int (*process_auxtrace_t)(struct perf_tool *tool,
+                                  struct perf_mmap *map,
                                   union perf_event *event, void *data1,
                                   size_t len1, void *data2, size_t len2);
 
-int auxtrace_mmap__read(struct auxtrace_mmap *mm, struct auxtrace_record *itr,
+int auxtrace_mmap__read(struct perf_mmap *map, struct auxtrace_record *itr,
                         struct perf_tool *tool, process_auxtrace_t fn);
 
-int auxtrace_mmap__read_snapshot(struct auxtrace_mmap *mm,
+int auxtrace_mmap__read_snapshot(struct perf_mmap *map,
                                  struct auxtrace_record *itr,
                                  struct perf_tool *tool, process_auxtrace_t fn,
                                  size_t snapshot_size);
@@ -517,15 +520,12 @@ int perf_event__synthesize_auxtrace_info(struct auxtrace_record *itr,
                                          struct perf_tool *tool,
                                          struct perf_session *session,
                                          perf_event__handler_t process);
-int perf_event__process_auxtrace_info(struct perf_tool *tool,
-                                      union perf_event *event,
-                                      struct perf_session *session);
-s64 perf_event__process_auxtrace(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session);
-int perf_event__process_auxtrace_error(struct perf_tool *tool,
-                                       union perf_event *event,
-                                       struct perf_session *session);
+int perf_event__process_auxtrace_info(struct perf_session *session,
+                                      union perf_event *event);
+s64 perf_event__process_auxtrace(struct perf_session *session,
+                                 union perf_event *event);
+int perf_event__process_auxtrace_error(struct perf_session *session,
+                                       union perf_event *event);
 int itrace_parse_synth_opts(const struct option *opt, const char *str,
                             int unset);
 void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts);
@@ -577,6 +577,23 @@ static inline void auxtrace__free(struct perf_session *session)
         return session->auxtrace->free(session);
 }
 
+#define ITRACE_HELP \
+"                               i:                      synthesize instructions events\n"               \
+"                               b:                      synthesize branches events\n"           \
+"                               c:                      synthesize branches events (calls only)\n"      \
+"                               r:                      synthesize branches events (returns only)\n" \
+"                               x:                      synthesize transactions events\n"               \
+"                               w:                      synthesize ptwrite events\n"            \
+"                               p:                      synthesize power events\n"                      \
+"                               e:                      synthesize error events\n"                      \
+"                               d:                      create a debug log\n"                   \
+"                               g[len]:                 synthesize a call chain (use with i or x)\n" \
+"                               l[len]:                 synthesize last branch entries (use with i or x)\n" \
+"                               sNUMBER:                skip initial number of events\n"                \
+"                               PERIOD[ns|us|ms|i|t]:   specify period to sample stream\n" \
+"                               concatenate multiple options. Default is ibxwpe or cewp\n"
+
+
 #else
 
 static inline struct auxtrace_record *
@@ -717,6 +734,8 @@ void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp,
                                    struct perf_evlist *evlist, int idx,
                                    bool per_cpu);
 
+#define ITRACE_HELP ""
+
 #endif
 
 #endif
diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c
index 47aac41349a2..f9ae1a993806 100644
--- a/tools/perf/util/bpf-loader.c
+++ b/tools/perf/util/bpf-loader.c
@@ -1615,7 +1615,7 @@ struct perf_evsel *bpf__setup_output_event(struct perf_evlist *evlist, const cha
 int bpf__setup_stdout(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel = bpf__setup_output_event(evlist, "__bpf_stdout__");
-        return IS_ERR(evsel) ? PTR_ERR(evsel) : 0;
+        return PTR_ERR_OR_ZERO(evsel);
 }
 
 #define ERRNO_OFFSET(e)         ((e) - __BPF_LOADER_ERRNO__START)
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
index abd38abf1d91..2a36fab76994 100644
--- a/tools/perf/util/data-convert-bt.c
+++ b/tools/perf/util/data-convert-bt.c
@@ -182,20 +182,20 @@ err_put_field:
 }
 
 static struct bt_ctf_field_type*
-get_tracepoint_field_type(struct ctf_writer *cw, struct format_field *field)
+get_tracepoint_field_type(struct ctf_writer *cw, struct tep_format_field *field)
 {
         unsigned long flags = field->flags;
 
-        if (flags & FIELD_IS_STRING)
+        if (flags & TEP_FIELD_IS_STRING)
                 return cw->data.string;
 
-        if (!(flags & FIELD_IS_SIGNED)) {
+        if (!(flags & TEP_FIELD_IS_SIGNED)) {
                 /* unsigned long are mostly pointers */
-                if (flags & FIELD_IS_LONG || flags & FIELD_IS_POINTER)
+                if (flags & TEP_FIELD_IS_LONG || flags & TEP_FIELD_IS_POINTER)
                         return cw->data.u64_hex;
         }
 
-        if (flags & FIELD_IS_SIGNED) {
+        if (flags & TEP_FIELD_IS_SIGNED) {
                 if (field->size == 8)
                         return cw->data.s64;
                 else
@@ -287,7 +287,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                                       struct bt_ctf_event_class *event_class,
                                       struct bt_ctf_event *event,
                                       struct perf_sample *sample,
-                                      struct format_field *fmtf)
+                                      struct tep_format_field *fmtf)
 {
         struct bt_ctf_field_type *type;
         struct bt_ctf_field *array_field;
@@ -304,10 +304,10 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
         name = fmtf->alias;
         offset = fmtf->offset;
         len = fmtf->size;
-        if (flags & FIELD_IS_STRING)
-                flags &= ~FIELD_IS_ARRAY;
+        if (flags & TEP_FIELD_IS_STRING)
+                flags &= ~TEP_FIELD_IS_ARRAY;
 
-        if (flags & FIELD_IS_DYNAMIC) {
+        if (flags & TEP_FIELD_IS_DYNAMIC) {
                 unsigned long long tmp_val;
 
                 tmp_val = tep_read_number(fmtf->event->pevent,
@@ -317,7 +317,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                 offset &= 0xffff;
         }
 
-        if (flags & FIELD_IS_ARRAY) {
+        if (flags & TEP_FIELD_IS_ARRAY) {
 
                 type = bt_ctf_event_class_get_field_by_name(
                                 event_class, name);
@@ -338,7 +338,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
         type = get_tracepoint_field_type(cw, fmtf);
 
         for (i = 0; i < n_items; i++) {
-                if (flags & FIELD_IS_ARRAY)
+                if (flags & TEP_FIELD_IS_ARRAY)
                         field = bt_ctf_field_array_get_field(array_field, i);
                 else
                         field = bt_ctf_field_create(type);
@@ -348,7 +348,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                         return -1;
                 }
 
-                if (flags & FIELD_IS_STRING)
+                if (flags & TEP_FIELD_IS_STRING)
                         ret = string_set_value(field, data + offset + i * len);
                 else {
                         unsigned long long value_int;
@@ -357,7 +357,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                                         fmtf->event->pevent,
                                         data + offset + i * len, len);
 
-                        if (!(flags & FIELD_IS_SIGNED))
+                        if (!(flags & TEP_FIELD_IS_SIGNED))
                                 ret = bt_ctf_field_unsigned_integer_set_value(
                                                 field, value_int);
                         else
@@ -369,7 +369,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                         pr_err("failed to set file value %s\n", name);
                         goto err_put_field;
                 }
-                if (!(flags & FIELD_IS_ARRAY)) {
+                if (!(flags & TEP_FIELD_IS_ARRAY)) {
                         ret = bt_ctf_event_set_payload(event, name, field);
                         if (ret) {
                                 pr_err("failed to set payload %s\n", name);
@@ -378,7 +378,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                 }
                 bt_ctf_field_put(field);
         }
-        if (flags & FIELD_IS_ARRAY) {
+        if (flags & TEP_FIELD_IS_ARRAY) {
                 ret = bt_ctf_event_set_payload(event, name, array_field);
                 if (ret) {
                         pr_err("Failed add payload array %s\n", name);
@@ -396,10 +396,10 @@ err_put_field:
 static int add_tracepoint_fields_values(struct ctf_writer *cw,
                                         struct bt_ctf_event_class *event_class,
                                         struct bt_ctf_event *event,
-                                        struct format_field *fields,
+                                        struct tep_format_field *fields,
                                         struct perf_sample *sample)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         int ret;
 
         for (field = fields; field; field = field->next) {
@@ -417,8 +417,8 @@ static int add_tracepoint_values(struct ctf_writer *cw,
                                  struct perf_evsel *evsel,
                                  struct perf_sample *sample)
 {
-        struct format_field *common_fields = evsel->tp_format->format.common_fields;
-        struct format_field *fields        = evsel->tp_format->format.fields;
+        struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
+        struct tep_format_field *fields        = evsel->tp_format->format.fields;
         int ret;
 
         ret = add_tracepoint_fields_values(cw, event_class, event,
@@ -970,7 +970,7 @@ out:
 
 static int event_class_add_field(struct bt_ctf_event_class *event_class,
                 struct bt_ctf_field_type *type,
-                struct format_field *field)
+                struct tep_format_field *field)
 {
         struct bt_ctf_field_type *t = NULL;
         char *name;
@@ -1009,10 +1009,10 @@ static int event_class_add_field(struct bt_ctf_event_class *event_class,
 }
 
 static int add_tracepoint_fields_types(struct ctf_writer *cw,
-                                       struct format_field *fields,
+                                       struct tep_format_field *fields,
                                        struct bt_ctf_event_class *event_class)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         int ret;
 
         for (field = fields; field; field = field->next) {
@@ -1030,15 +1030,15 @@ static int add_tracepoint_fields_types(struct ctf_writer *cw,
                  * type and don't care that it is an array. What we don't
                  * support is an array of strings.
                  */
-                if (flags & FIELD_IS_STRING)
-                        flags &= ~FIELD_IS_ARRAY;
+                if (flags & TEP_FIELD_IS_STRING)
+                        flags &= ~TEP_FIELD_IS_ARRAY;
 
-                if (flags & FIELD_IS_ARRAY)
+                if (flags & TEP_FIELD_IS_ARRAY)
                         type = bt_ctf_field_type_array_create(type, field->arraylen);
 
                 ret = event_class_add_field(event_class, type, field);
 
-                if (flags & FIELD_IS_ARRAY)
+                if (flags & TEP_FIELD_IS_ARRAY)
                         bt_ctf_field_type_put(type);
 
                 if (ret) {
@@ -1055,8 +1055,8 @@ static int add_tracepoint_types(struct ctf_writer *cw,
                                 struct perf_evsel *evsel,
                                 struct bt_ctf_event_class *class)
 {
-        struct format_field *common_fields = evsel->tp_format->format.common_fields;
-        struct format_field *fields        = evsel->tp_format->format.fields;
+        struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
+        struct tep_format_field *fields        = evsel->tp_format->format.fields;
         int ret;
 
         ret = add_tracepoint_fields_types(cw, common_fields, class);
@@ -1578,7 +1578,7 @@ int bt_convert__perf2ctf(const char *input, const char *path,
 {
         struct perf_session *session;
         struct perf_data data = {
-                .file.path = input,
+                .file      = { .path = input, .fd = -1 },
                 .mode      = PERF_DATA_MODE_READ,
                 .force     = opts->force,
         };
diff --git a/tools/perf/util/db-export.c b/tools/perf/util/db-export.c
index 7123746edcf4..69fbb0a72d0c 100644
--- a/tools/perf/util/db-export.c
+++ b/tools/perf/util/db-export.c
@@ -463,6 +463,28 @@ int db_export__branch_types(struct db_export *dbe)
                 if (err)
                         break;
         }
+
+        /* Add trace begin / end variants */
+        for (i = 0; branch_types[i].name ; i++) {
+                const char *name = branch_types[i].name;
+                u32 type = branch_types[i].branch_type;
+                char buf[64];
+
+                if (type == PERF_IP_FLAG_BRANCH ||
+                    (type & (PERF_IP_FLAG_TRACE_BEGIN | PERF_IP_FLAG_TRACE_END)))
+                        continue;
+
+                snprintf(buf, sizeof(buf), "trace begin / %s", name);
+                err = db_export__branch_type(dbe, type | PERF_IP_FLAG_TRACE_BEGIN, buf);
+                if (err)
+                        break;
+
+                snprintf(buf, sizeof(buf), "%s / trace end", name);
+                err = db_export__branch_type(dbe, type | PERF_IP_FLAG_TRACE_END, buf);
+                if (err)
+                        break;
+        }
+
         return err;
 }
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index e596ae358c4d..29d7b97f66fb 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -2685,7 +2685,7 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
         return 0;
 }
 
-struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
+struct tep_format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
 {
         return tep_find_field(evsel->tp_format, name);
 }
@@ -2693,7 +2693,7 @@ struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *nam
 void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
                          const char *name)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
+        struct tep_format_field *field = perf_evsel__field(evsel, name);
         int offset;
 
         if (!field)
@@ -2701,7 +2701,7 @@ void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
 
         offset = field->offset;
 
-        if (field->flags & FIELD_IS_DYNAMIC) {
+        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                 offset = *(int *)(sample->raw_data + field->offset);
                 offset &= 0xffff;
         }
@@ -2709,7 +2709,7 @@ void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
         return sample->raw_data + offset;
 }
 
-u64 format_field__intval(struct format_field *field, struct perf_sample *sample,
+u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample,
                          bool needs_swap)
 {
         u64 value;
@@ -2751,7 +2751,7 @@ u64 format_field__intval(struct format_field *field, struct perf_sample *sample,
 u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                        const char *name)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
+        struct tep_format_field *field = perf_evsel__field(evsel, name);
 
         if (!field)
                 return 0;
@@ -2943,3 +2943,32 @@ struct perf_env *perf_evsel__env(struct perf_evsel *evsel)
                 return evsel->evlist->env;
         return NULL;
 }
+
+static int store_evsel_ids(struct perf_evsel *evsel, struct perf_evlist *evlist)
+{
+        int cpu, thread;
+
+        for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {
+                for (thread = 0; thread < xyarray__max_y(evsel->fd);
+                     thread++) {
+                        int fd = FD(evsel, cpu, thread);
+
+                        if (perf_evlist__id_add_fd(evlist, evsel,
+                                                   cpu, thread, fd) < 0)
+                                return -1;
+                }
+        }
+
+        return 0;
+}
+
+int perf_evsel__store_ids(struct perf_evsel *evsel, struct perf_evlist *evlist)
+{
+        struct cpu_map *cpus = evsel->cpus;
+        struct thread_map *threads = evsel->threads;
+
+        if (perf_evsel__alloc_id(evsel, cpus->nr, threads->nr))
+                return -ENOMEM;
+
+        return store_evsel_ids(evsel, evlist);
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 163c960614d3..4107c39f4a54 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -102,7 +102,7 @@ struct perf_evsel {
         char                    *name;
         double                  scale;
         const char              *unit;
-        struct event_format     *tp_format;
+        struct tep_event_format *tp_format;
         off_t                   id_offset;
         struct perf_stat_evsel  *stats;
         void                    *priv;
@@ -211,7 +211,7 @@ static inline struct perf_evsel *perf_evsel__newtp(const char *sys, const char *
 
 struct perf_evsel *perf_evsel__new_cycles(bool precise);
 
-struct event_format *event_format__new(const char *sys, const char *name);
+struct tep_event_format *event_format__new(const char *sys, const char *name);
 
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx);
@@ -296,11 +296,11 @@ static inline char *perf_evsel__strval(struct perf_evsel *evsel,
         return perf_evsel__rawptr(evsel, sample, name);
 }
 
-struct format_field;
+struct tep_format_field;
 
-u64 format_field__intval(struct format_field *field, struct perf_sample *sample, bool needs_swap);
+u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample, bool needs_swap);
 
-struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
+struct tep_format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
 
 #define perf_evsel__match(evsel, t, c)          \
         (evsel->attr.type == PERF_TYPE_##t &&   \
@@ -481,4 +481,5 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
 
 struct perf_env *perf_evsel__env(struct perf_evsel *evsel);
 
+int perf_evsel__store_ids(struct perf_evsel *evsel, struct perf_evlist *evlist);
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/evsel_fprintf.c b/tools/perf/util/evsel_fprintf.c
index 06dfb027879d..0d0a4c6f368b 100644
--- a/tools/perf/util/evsel_fprintf.c
+++ b/tools/perf/util/evsel_fprintf.c
@@ -73,7 +73,7 @@ int perf_evsel__fprintf(struct perf_evsel *evsel,
         }
 
         if (details->trace_fields) {
-                struct format_field *field;
+                struct tep_format_field *field;
 
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
                         printed += comma_fprintf(fp, &first, " (not a tracepoint)");
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 3cadc252dd89..1ec1d9bc2d63 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -3206,7 +3206,7 @@ static int read_attr(int fd, struct perf_header *ph,
 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
                                                 struct tep_handle *pevent)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         char bf[128];
 
         /* already prepared */
@@ -3448,10 +3448,10 @@ int perf_event__synthesize_features(struct perf_tool *tool,
         return ret;
 }
 
-int perf_event__process_feature(struct perf_tool *tool,
-                                union perf_event *event,
-                                struct perf_session *session __maybe_unused)
+int perf_event__process_feature(struct perf_session *session,
+                                union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct feat_fd ff = { .fd = 0 };
         struct feature_event *fe = (struct feature_event *)event;
         int type = fe->header.type;
@@ -3637,13 +3637,13 @@ size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
 }
 
 int perf_event__synthesize_attrs(struct perf_tool *tool,
-                                   struct perf_session *session,
-                                   perf_event__handler_t process)
+                                 struct perf_evlist *evlist,
+                                 perf_event__handler_t process)
 {
         struct perf_evsel *evsel;
         int err = 0;
 
-        evlist__for_each_entry(session->evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
                                                   evsel->id, process);
                 if (err) {
@@ -3856,9 +3856,8 @@ int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
         return aligned_size;
 }
 
-int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
-                                     union perf_event *event,
-                                     struct perf_session *session)
+int perf_event__process_tracing_data(struct perf_session *session,
+                                     union perf_event *event)
 {
         ssize_t size_read, padding, size = event->tracing_data.size;
         int fd = perf_data__fd(session->data);
@@ -3924,9 +3923,8 @@ int perf_event__synthesize_build_id(struct perf_tool *tool,
         return err;
 }
 
-int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+int perf_event__process_build_id(struct perf_session *session,
+                                 union perf_event *event)
 {
         __event_process_build_id(&event->build_id,
                                  event->build_id.filename,
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 6d7fe44aadc0..e17903caa71d 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -116,15 +116,14 @@ int perf_event__synthesize_extra_attr(struct perf_tool *tool,
                                       perf_event__handler_t process,
                                       bool is_pipe);
 
-int perf_event__process_feature(struct perf_tool *tool,
-                                union perf_event *event,
-                                struct perf_session *session);
+int perf_event__process_feature(struct perf_session *session,
+                                union perf_event *event);
 
 int perf_event__synthesize_attr(struct perf_tool *tool,
                                 struct perf_event_attr *attr, u32 ids, u64 *id,
                                 perf_event__handler_t process);
 int perf_event__synthesize_attrs(struct perf_tool *tool,
-                                 struct perf_session *session,
+                                 struct perf_evlist *evlist,
                                  perf_event__handler_t process);
 int perf_event__synthesize_event_update_unit(struct perf_tool *tool,
                                              struct perf_evsel *evsel,
@@ -148,17 +147,15 @@ size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp);
 int perf_event__synthesize_tracing_data(struct perf_tool *tool,
                                         int fd, struct perf_evlist *evlist,
                                         perf_event__handler_t process);
-int perf_event__process_tracing_data(struct perf_tool *tool,
-                                     union perf_event *event,
-                                     struct perf_session *session);
+int perf_event__process_tracing_data(struct perf_session *session,
+                                     union perf_event *event);
 
 int perf_event__synthesize_build_id(struct perf_tool *tool,
                                     struct dso *pos, u16 misc,
                                     perf_event__handler_t process,
                                     struct machine *machine);
-int perf_event__process_build_id(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session);
+int perf_event__process_build_id(struct perf_session *session,
+                                 union perf_event *event);
 bool is_perf_magic(u64 magic);
 
 #define NAME_ALIGN 64
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
index d404bed7003a..58f6a9ceb590 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
@@ -1165,7 +1165,7 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
                 decoder->pge = false;
                 decoder->continuous_period = false;
                 decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
-                decoder->state.to_ip = 0;
+                decoder->state.type |= INTEL_PT_TRACE_END;
                 return 0;
         }
         if (err == INTEL_PT_RETURN)
@@ -1179,9 +1179,13 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
                         decoder->continuous_period = false;
                         decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
                         decoder->state.from_ip = decoder->ip;
-                        decoder->state.to_ip = 0;
-                        if (decoder->packet.count != 0)
+                        if (decoder->packet.count == 0) {
+                                decoder->state.to_ip = 0;
+                        } else {
+                                decoder->state.to_ip = decoder->last_ip;
                                 decoder->ip = decoder->last_ip;
+                        }
+                        decoder->state.type |= INTEL_PT_TRACE_END;
                 } else {
                         decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
                         decoder->state.from_ip = decoder->ip;
@@ -1208,7 +1212,8 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
                         decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
                         decoder->ip = to_ip;
                         decoder->state.from_ip = decoder->ip;
-                        decoder->state.to_ip = 0;
+                        decoder->state.to_ip = to_ip;
+                        decoder->state.type |= INTEL_PT_TRACE_END;
                         return 0;
                 }
                 intel_pt_log_at("ERROR: Conditional branch when expecting indirect branch",
@@ -1640,14 +1645,15 @@ static int intel_pt_walk_fup_tip(struct intel_pt_decoder *decoder)
 
                 case INTEL_PT_TIP_PGD:
                         decoder->state.from_ip = decoder->ip;
-                        decoder->state.to_ip = 0;
-                        if (decoder->packet.count != 0) {
+                        if (decoder->packet.count == 0) {
+                                decoder->state.to_ip = 0;
+                        } else {
                                 intel_pt_set_ip(decoder);
-                                intel_pt_log("Omitting PGD ip " x64_fmt "\n",
-                                             decoder->ip);
+                                decoder->state.to_ip = decoder->ip;
                         }
                         decoder->pge = false;
                         decoder->continuous_period = false;
+                        decoder->state.type |= INTEL_PT_TRACE_END;
                         return 0;
 
                 case INTEL_PT_TIP_PGE:
@@ -1661,6 +1667,7 @@ static int intel_pt_walk_fup_tip(struct intel_pt_decoder *decoder)
                                 intel_pt_set_ip(decoder);
                                 decoder->state.to_ip = decoder->ip;
                         }
+                        decoder->state.type |= INTEL_PT_TRACE_BEGIN;
                         return 0;
 
                 case INTEL_PT_TIP:
@@ -1739,6 +1746,7 @@ next:
                         intel_pt_set_ip(decoder);
                         decoder->state.from_ip = 0;
                         decoder->state.to_ip = decoder->ip;
+                        decoder->state.type |= INTEL_PT_TRACE_BEGIN;
                         return 0;
                 }
 
@@ -2077,9 +2085,13 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                         decoder->pge = decoder->packet.type != INTEL_PT_TIP_PGD;
                         if (intel_pt_have_ip(decoder))
                                 intel_pt_set_ip(decoder);
-                        if (decoder->ip)
-                                return 0;
-                        break;
+                        if (!decoder->ip)
+                                break;
+                        if (decoder->packet.type == INTEL_PT_TIP_PGE)
+                                decoder->state.type |= INTEL_PT_TRACE_BEGIN;
+                        if (decoder->packet.type == INTEL_PT_TIP_PGD)
+                                decoder->state.type |= INTEL_PT_TRACE_END;
+                        return 0;
 
                 case INTEL_PT_FUP:
                         if (intel_pt_have_ip(decoder))
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
index 51c18d67f4ca..ed088d4726ba 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
@@ -37,6 +37,8 @@ enum intel_pt_sample_type {
         INTEL_PT_EX_STOP        = 1 << 6,
         INTEL_PT_PWR_EXIT       = 1 << 7,
         INTEL_PT_CBR_CHG        = 1 << 8,
+        INTEL_PT_TRACE_BEGIN    = 1 << 9,
+        INTEL_PT_TRACE_END      = 1 << 10,
 };
 
 enum intel_pt_period_type {
diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
index aec68908d604..48c1d415c6b0 100644
--- a/tools/perf/util/intel-pt.c
+++ b/tools/perf/util/intel-pt.c
@@ -908,6 +908,11 @@ static void intel_pt_sample_flags(struct intel_pt_queue *ptq)
                 ptq->insn_len = ptq->state->insn_len;
                 memcpy(ptq->insn, ptq->state->insn, INTEL_PT_INSN_BUF_SZ);
         }
+
+        if (ptq->state->type & INTEL_PT_TRACE_BEGIN)
+                ptq->flags |= PERF_IP_FLAG_TRACE_BEGIN;
+        if (ptq->state->type & INTEL_PT_TRACE_END)
+                ptq->flags |= PERF_IP_FLAG_TRACE_END;
 }
 
 static int intel_pt_setup_queue(struct intel_pt *pt,
diff --git a/tools/perf/util/llvm-utils.c b/tools/perf/util/llvm-utils.c
index 19262f98cd4e..5b0b60f00275 100644
--- a/tools/perf/util/llvm-utils.c
+++ b/tools/perf/util/llvm-utils.c
@@ -19,7 +19,7 @@
 #define CLANG_BPF_CMD_DEFAULT_TEMPLATE                          \
                 "$CLANG_EXEC -D__KERNEL__ -D__NR_CPUS__=$NR_CPUS "\
                 "-DLINUX_VERSION_CODE=$LINUX_VERSION_CODE "     \
-                "$CLANG_OPTIONS $KERNEL_INC_OPTIONS $PERF_BPF_INC_OPTIONS " \
+                "$CLANG_OPTIONS $PERF_BPF_INC_OPTIONS $KERNEL_INC_OPTIONS " \
                 "-Wno-unused-value -Wno-pointer-sign "          \
                 "-working-directory $WORKING_DIR "              \
                 "-c \"$CLANG_SOURCE\" -target bpf $CLANG_EMIT_LLVM -O2 -o - $LLVM_OPTIONS_PIPE"
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 6a6929f208b4..354e54550d2b 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -320,12 +320,11 @@ int map__load(struct map *map)
                         build_id__sprintf(map->dso->build_id,
                                           sizeof(map->dso->build_id),
                                           sbuild_id);
-                        pr_warning("%s with build id %s not found",
-                                   name, sbuild_id);
+                        pr_debug("%s with build id %s not found", name, sbuild_id);
                 } else
-                        pr_warning("Failed to open %s", name);
+                        pr_debug("Failed to open %s", name);
 
-                pr_warning(", continuing without symbols\n");
+                pr_debug(", continuing without symbols\n");
                 return -1;
         } else if (nr == 0) {
 #ifdef HAVE_LIBELF_SUPPORT
@@ -334,12 +333,11 @@ int map__load(struct map *map)
 
                 if (len > sizeof(DSO__DELETED) &&
                     strcmp(name + real_len + 1, DSO__DELETED) == 0) {
-                        pr_warning("%.*s was updated (is prelink enabled?). "
+                        pr_debug("%.*s was updated (is prelink enabled?). "
                                 "Restart the long running apps that use it!\n",
                                    (int)real_len, name);
                 } else {
-                        pr_warning("no symbols found in %s, maybe install "
-                                   "a debug package?\n", name);
+                        pr_debug("no symbols found in %s, maybe install a debug package?\n", name);
                 }
 #endif
                 return -1;
@@ -712,8 +710,7 @@ static int maps__fixup_overlappings(struct maps *maps, struct map *map, FILE *fp
                 if (verbose >= 2) {
 
                         if (use_browser) {
-                                pr_warning("overlapping maps in %s "
-                                           "(disable tui for more info)\n",
+                                pr_debug("overlapping maps in %s (disable tui for more info)\n",
                                            map->dso->name);
                         } else {
                                 fputs("overlapping maps:\n", fp);
diff --git a/tools/perf/util/mmap.c b/tools/perf/util/mmap.c
index 215f69f41672..cdb95b3a1213 100644
--- a/tools/perf/util/mmap.c
+++ b/tools/perf/util/mmap.c
@@ -281,7 +281,7 @@ int perf_mmap__read_init(struct perf_mmap *map)
 }
 
 int perf_mmap__push(struct perf_mmap *md, void *to,
-                    int push(void *to, void *buf, size_t size))
+                    int push(struct perf_mmap *map, void *to, void *buf, size_t size))
 {
         u64 head = perf_mmap__read_head(md);
         unsigned char *data = md->base + page_size;
@@ -300,7 +300,7 @@ int perf_mmap__push(struct perf_mmap *md, void *to,
                 size = md->mask + 1 - (md->start & md->mask);
                 md->start += size;
 
-                if (push(to, buf, size) < 0) {
+                if (push(md, to, buf, size) < 0) {
                         rc = -1;
                         goto out;
                 }
@@ -310,7 +310,7 @@ int perf_mmap__push(struct perf_mmap *md, void *to,
         size = md->end - md->start;
         md->start += size;
 
-        if (push(to, buf, size) < 0) {
+        if (push(md, to, buf, size) < 0) {
                 rc = -1;
                 goto out;
         }
diff --git a/tools/perf/util/mmap.h b/tools/perf/util/mmap.h
index 05a6d47c7956..e603314dc792 100644
--- a/tools/perf/util/mmap.h
+++ b/tools/perf/util/mmap.h
@@ -93,7 +93,7 @@ union perf_event *perf_mmap__read_forward(struct perf_mmap *map);
 union perf_event *perf_mmap__read_event(struct perf_mmap *map);
 
 int perf_mmap__push(struct perf_mmap *md, void *to,
-                    int push(void *to, void *buf, size_t size));
+                    int push(struct perf_mmap *map, void *to, void *buf, size_t size));
 
 size_t perf_mmap__mmap_len(struct perf_mmap *map);
 
diff --git a/tools/perf/util/ordered-events.c b/tools/perf/util/ordered-events.c
index bad9e0296e9a..1904e7f6ec84 100644
--- a/tools/perf/util/ordered-events.c
+++ b/tools/perf/util/ordered-events.c
@@ -80,14 +80,20 @@ static union perf_event *dup_event(struct ordered_events *oe,
         return oe->copy_on_queue ? __dup_event(oe, event) : event;
 }
 
-static void free_dup_event(struct ordered_events *oe, union perf_event *event)
+static void __free_dup_event(struct ordered_events *oe, union perf_event *event)
 {
-        if (event && oe->copy_on_queue) {
+        if (event) {
                 oe->cur_alloc_size -= event->header.size;
                 free(event);
         }
 }
 
+static void free_dup_event(struct ordered_events *oe, union perf_event *event)
+{
+        if (oe->copy_on_queue)
+                __free_dup_event(oe, event);
+}
+
 #define MAX_SAMPLE_BUFFER       (64 * 1024 / sizeof(struct ordered_event))
 static struct ordered_event *alloc_event(struct ordered_events *oe,
                                          union perf_event *event)
@@ -95,21 +101,49 @@ static struct ordered_event *alloc_event(struct ordered_events *oe,
         struct list_head *cache = &oe->cache;
         struct ordered_event *new = NULL;
         union perf_event *new_event;
+        size_t size;
 
         new_event = dup_event(oe, event);
         if (!new_event)
                 return NULL;
 
+        /*
+         * We maintain the following scheme of buffers for ordered
+         * event allocation:
+         *
+         *   to_free list -> buffer1 (64K)
+         *                   buffer2 (64K)
+         *                   ...
+         *
+         * Each buffer keeps an array of ordered events objects:
+         *    buffer -> event[0]
+         *              event[1]
+         *              ...
+         *
+         * Each allocated ordered event is linked to one of
+         * following lists:
+         *   - time ordered list 'events'
+         *   - list of currently removed events 'cache'
+         *
+         * Allocation of the ordered event uses the following order
+         * to get the memory:
+         *   - use recently removed object from 'cache' list
+         *   - use available object in current allocation buffer
+         *   - allocate new buffer if the current buffer is full
+         *
+         * Removal of ordered event object moves it from events to
+         * the cache list.
+         */
+        size = sizeof(*oe->buffer) + MAX_SAMPLE_BUFFER * sizeof(*new);
+
         if (!list_empty(cache)) {
                 new = list_entry(cache->next, struct ordered_event, list);
                 list_del(&new->list);
         } else if (oe->buffer) {
-                new = oe->buffer + oe->buffer_idx;
+                new = &oe->buffer->event[oe->buffer_idx];
                 if (++oe->buffer_idx == MAX_SAMPLE_BUFFER)
                         oe->buffer = NULL;
-        } else if (oe->cur_alloc_size < oe->max_alloc_size) {
-                size_t size = MAX_SAMPLE_BUFFER * sizeof(*new);
-
+        } else if ((oe->cur_alloc_size + size) < oe->max_alloc_size) {
                 oe->buffer = malloc(size);
                 if (!oe->buffer) {
                         free_dup_event(oe, new_event);
@@ -122,11 +156,11 @@ static struct ordered_event *alloc_event(struct ordered_events *oe,
                 oe->cur_alloc_size += size;
                 list_add(&oe->buffer->list, &oe->to_free);
 
-                /* First entry is abused to maintain the to_free list. */
-                oe->buffer_idx = 2;
-                new = oe->buffer + 1;
+                oe->buffer_idx = 1;
+                new = &oe->buffer->event[0];
         } else {
                 pr("allocation limit reached %" PRIu64 "B\n", oe->max_alloc_size);
+                return NULL;
         }
 
         new->event = new_event;
@@ -300,15 +334,38 @@ void ordered_events__init(struct ordered_events *oe, ordered_events__deliver_t d
         oe->deliver        = deliver;
 }
 
+static void
+ordered_events_buffer__free(struct ordered_events_buffer *buffer,
+                            unsigned int max, struct ordered_events *oe)
+{
+        if (oe->copy_on_queue) {
+                unsigned int i;
+
+                for (i = 0; i < max; i++)
+                        __free_dup_event(oe, buffer->event[i].event);
+        }
+
+        free(buffer);
+}
+
 void ordered_events__free(struct ordered_events *oe)
 {
-        while (!list_empty(&oe->to_free)) {
-                struct ordered_event *event;
+        struct ordered_events_buffer *buffer, *tmp;
 
-                event = list_entry(oe->to_free.next, struct ordered_event, list);
-                list_del(&event->list);
-                free_dup_event(oe, event->event);
-                free(event);
+        if (list_empty(&oe->to_free))
+                return;
+
+        /*
+         * Current buffer might not have all the events allocated
+         * yet, we need to free only allocated ones ...
+         */
+        list_del(&oe->buffer->list);
+        ordered_events_buffer__free(oe->buffer, oe->buffer_idx, oe);
+
+        /* ... and continue with the rest */
+        list_for_each_entry_safe(buffer, tmp, &oe->to_free, list) {
+                list_del(&buffer->list);
+                ordered_events_buffer__free(buffer, MAX_SAMPLE_BUFFER, oe);
         }
 }
 
diff --git a/tools/perf/util/ordered-events.h b/tools/perf/util/ordered-events.h
index 8c7a2948593e..1338d5c345dc 100644
--- a/tools/perf/util/ordered-events.h
+++ b/tools/perf/util/ordered-events.h
@@ -25,23 +25,28 @@ struct ordered_events;
 typedef int (*ordered_events__deliver_t)(struct ordered_events *oe,
                                          struct ordered_event *event);
 
+struct ordered_events_buffer {
+        struct list_head        list;
+        struct ordered_event    event[0];
+};
+
 struct ordered_events {
-        u64                     last_flush;
-        u64                     next_flush;
-        u64                     max_timestamp;
-        u64                     max_alloc_size;
-        u64                     cur_alloc_size;
-        struct list_head        events;
-        struct list_head        cache;
-        struct list_head        to_free;
-        struct ordered_event    *buffer;
-        struct ordered_event    *last;
-        ordered_events__deliver_t deliver;
-        int                     buffer_idx;
-        unsigned int            nr_events;
-        enum oe_flush           last_flush_type;
-        u32                     nr_unordered_events;
-        bool                    copy_on_queue;
+        u64                              last_flush;
+        u64                              next_flush;
+        u64                              max_timestamp;
+        u64                              max_alloc_size;
+        u64                              cur_alloc_size;
+        struct list_head                 events;
+        struct list_head                 cache;
+        struct list_head                 to_free;
+        struct ordered_events_buffer    *buffer;
+        struct ordered_event            *last;
+        ordered_events__deliver_t        deliver;
+        int                              buffer_idx;
+        unsigned int                     nr_events;
+        enum oe_flush                    last_flush_type;
+        u32                              nr_unordered_events;
+        bool                             copy_on_queue;
 };
 
 int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index ce501ba14b08..50150dfc0cdf 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -340,7 +340,7 @@ static bool is_tracepoint(struct pyrf_event *pevent)
 }
 
 static PyObject*
-tracepoint_field(struct pyrf_event *pe, struct format_field *field)
+tracepoint_field(struct pyrf_event *pe, struct tep_format_field *field)
 {
         struct tep_handle *pevent = field->event->pevent;
         void *data = pe->sample.raw_data;
@@ -348,28 +348,28 @@ tracepoint_field(struct pyrf_event *pe, struct format_field *field)
         unsigned long long val;
         unsigned int offset, len;
 
-        if (field->flags & FIELD_IS_ARRAY) {
+        if (field->flags & TEP_FIELD_IS_ARRAY) {
                 offset = field->offset;
                 len    = field->size;
-                if (field->flags & FIELD_IS_DYNAMIC) {
+                if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                         val     = tep_read_number(pevent, data + offset, len);
                         offset  = val;
                         len     = offset >> 16;
                         offset &= 0xffff;
                 }
-                if (field->flags & FIELD_IS_STRING &&
+                if (field->flags & TEP_FIELD_IS_STRING &&
                     is_printable_array(data + offset, len)) {
                         ret = _PyUnicode_FromString((char *)data + offset);
                 } else {
                         ret = PyByteArray_FromStringAndSize((const char *) data + offset, len);
-                        field->flags &= ~FIELD_IS_STRING;
+                        field->flags &= ~TEP_FIELD_IS_STRING;
                 }
         } else {
                 val = tep_read_number(pevent, data + field->offset,
                                       field->size);
-                if (field->flags & FIELD_IS_POINTER)
+                if (field->flags & TEP_FIELD_IS_POINTER)
                         ret = PyLong_FromUnsignedLong((unsigned long) val);
-                else if (field->flags & FIELD_IS_SIGNED)
+                else if (field->flags & TEP_FIELD_IS_SIGNED)
                         ret = PyLong_FromLong((long) val);
                 else
                         ret = PyLong_FromUnsignedLong((unsigned long) val);
@@ -383,10 +383,10 @@ get_tracepoint_field(struct pyrf_event *pevent, PyObject *attr_name)
 {
         const char *str = _PyUnicode_AsString(PyObject_Str(attr_name));
         struct perf_evsel *evsel = pevent->evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
 
         if (!evsel->tp_format) {
-                struct event_format *tp_format;
+                struct tep_event_format *tp_format;
 
                 tp_format = trace_event__tp_format_id(evsel->attr.config);
                 if (!tp_format)
@@ -1240,7 +1240,7 @@ static struct {
 static PyObject *pyrf__tracepoint(struct pyrf_evsel *pevsel,
                                   PyObject *args, PyObject *kwargs)
 {
-        struct event_format *tp_format;
+        struct tep_event_format *tp_format;
         static char *kwlist[] = { "sys", "name", NULL };
         char *sys  = NULL;
         char *name = NULL;
diff --git a/tools/perf/util/s390-cpumsf.c b/tools/perf/util/s390-cpumsf.c
index d2c78ffd9fee..a2eeebbfb25f 100644
--- a/tools/perf/util/s390-cpumsf.c
+++ b/tools/perf/util/s390-cpumsf.c
@@ -147,6 +147,9 @@
 #include <linux/bitops.h>
 #include <linux/log2.h>
 
+#include <sys/stat.h>
+#include <sys/types.h>
+
 #include "cpumap.h"
 #include "color.h"
 #include "evsel.h"
@@ -159,6 +162,7 @@
 #include "auxtrace.h"
 #include "s390-cpumsf.h"
 #include "s390-cpumsf-kernel.h"
+#include "config.h"
 
 struct s390_cpumsf {
         struct auxtrace         auxtrace;
@@ -170,6 +174,8 @@ struct s390_cpumsf {
         u32                     pmu_type;
         u16                     machine_type;
         bool                    data_queued;
+        bool                    use_logfile;
+        char                    *logdir;
 };
 
 struct s390_cpumsf_queue {
@@ -177,6 +183,7 @@ struct s390_cpumsf_queue {
         unsigned int            queue_nr;
         struct auxtrace_buffer  *buffer;
         int                     cpu;
+        FILE                    *logfile;
 };
 
 /* Display s390 CPU measurement facility basic-sampling data entry */
@@ -595,6 +602,12 @@ static int s390_cpumsf_run_decoder(struct s390_cpumsf_queue *sfq,
                         buffer->use_size = buffer->size;
                         buffer->use_data = buffer->data;
                 }
+                if (sfq->logfile) {     /* Write into log file */
+                        size_t rc = fwrite(buffer->data, buffer->size, 1,
+                                           sfq->logfile);
+                        if (rc != 1)
+                                pr_err("Failed to write auxiliary data\n");
+                }
         } else
                 buffer = sfq->buffer;
 
@@ -606,6 +619,13 @@ static int s390_cpumsf_run_decoder(struct s390_cpumsf_queue *sfq,
                         return -ENOMEM;
                 buffer->use_size = buffer->size;
                 buffer->use_data = buffer->data;
+
+                if (sfq->logfile) {     /* Write into log file */
+                        size_t rc = fwrite(buffer->data, buffer->size, 1,
+                                           sfq->logfile);
+                        if (rc != 1)
+                                pr_err("Failed to write auxiliary data\n");
+                }
         }
         pr_debug4("%s queue_nr:%d buffer:%" PRId64 " offset:%#" PRIx64 " size:%#zx rest:%#zx\n",
                   __func__, sfq->queue_nr, buffer->buffer_nr, buffer->offset,
@@ -640,6 +660,23 @@ s390_cpumsf_alloc_queue(struct s390_cpumsf *sf, unsigned int queue_nr)
         sfq->sf = sf;
         sfq->queue_nr = queue_nr;
         sfq->cpu = -1;
+        if (sf->use_logfile) {
+                char *name;
+                int rc;
+
+                rc = (sf->logdir)
+                        ? asprintf(&name, "%s/aux.smp.%02x",
+                                 sf->logdir, queue_nr)
+                        : asprintf(&name, "aux.smp.%02x", queue_nr);
+                if (rc > 0)
+                        sfq->logfile = fopen(name, "w");
+                if (sfq->logfile == NULL) {
+                        pr_err("Failed to open auxiliary log file %s,"
+                               "continue...\n", name);
+                        sf->use_logfile = false;
+                }
+                free(name);
+        }
         return sfq;
 }
 
@@ -850,8 +887,16 @@ static void s390_cpumsf_free_queues(struct perf_session *session)
         struct auxtrace_queues *queues = &sf->queues;
         unsigned int i;
 
-        for (i = 0; i < queues->nr_queues; i++)
+        for (i = 0; i < queues->nr_queues; i++) {
+                struct s390_cpumsf_queue *sfq = (struct s390_cpumsf_queue *)
+                                                queues->queue_array[i].priv;
+
+                if (sfq != NULL && sfq->logfile) {
+                        fclose(sfq->logfile);
+                        sfq->logfile = NULL;
+                }
                 zfree(&queues->queue_array[i].priv);
+        }
         auxtrace_queues__free(queues);
 }
 
@@ -864,6 +909,7 @@ static void s390_cpumsf_free(struct perf_session *session)
         auxtrace_heap__free(&sf->heap);
         s390_cpumsf_free_queues(session);
         session->auxtrace = NULL;
+        free(sf->logdir);
         free(sf);
 }
 
@@ -877,17 +923,55 @@ static int s390_cpumsf_get_type(const char *cpuid)
 
 /* Check itrace options set on perf report command.
  * Return true, if none are set or all options specified can be
- * handled on s390.
+ * handled on s390 (currently only option 'd' for logging.
  * Return false otherwise.
  */
 static bool check_auxtrace_itrace(struct itrace_synth_opts *itops)
 {
+        bool ison = false;
+
         if (!itops || !itops->set)
                 return true;
-        pr_err("No --itrace options supported\n");
+        ison = itops->inject || itops->instructions || itops->branches ||
+                itops->transactions || itops->ptwrites ||
+                itops->pwr_events || itops->errors ||
+                itops->dont_decode || itops->calls || itops->returns ||
+                itops->callchain || itops->thread_stack ||
+                itops->last_branch;
+        if (!ison)
+                return true;
+        pr_err("Unsupported --itrace options specified\n");
         return false;
 }
 
+/* Check for AUXTRACE dump directory if it is needed.
+ * On failure print an error message but continue.
+ * Return 0 on wrong keyword in config file and 1 otherwise.
+ */
+static int s390_cpumsf__config(const char *var, const char *value, void *cb)
+{
+        struct s390_cpumsf *sf = cb;
+        struct stat stbuf;
+        int rc;
+
+        if (strcmp(var, "auxtrace.dumpdir"))
+                return 0;
+        sf->logdir = strdup(value);
+        if (sf->logdir == NULL) {
+                pr_err("Failed to find auxtrace log directory %s,"
+                       " continue with current directory...\n", value);
+                return 1;
+        }
+        rc = stat(sf->logdir, &stbuf);
+        if (rc == -1 || !S_ISDIR(stbuf.st_mode)) {
+                pr_err("Missing auxtrace log directory %s,"
+                       " continue with current directory...\n", value);
+                free(sf->logdir);
+                sf->logdir = NULL;
+        }
+        return 1;
+}
+
 int s390_cpumsf_process_auxtrace_info(union perf_event *event,
                                       struct perf_session *session)
 {
@@ -906,6 +990,9 @@ int s390_cpumsf_process_auxtrace_info(union perf_event *event,
                 err = -EINVAL;
                 goto err_free;
         }
+        sf->use_logfile = session->itrace_synth_opts->log;
+        if (sf->use_logfile)
+                perf_config(s390_cpumsf__config, sf);
 
         err = auxtrace_queues__init(&sf->queues);
         if (err)
@@ -940,6 +1027,7 @@ err_free_queues:
         auxtrace_queues__free(&sf->queues);
         session->auxtrace = NULL;
 err_free:
+        free(sf->logdir);
         free(sf);
         return err;
 }
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 45484f0f7292..89cb887648f9 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -99,7 +99,7 @@ static void define_symbolic_value(const char *ev_name,
         LEAVE;
 }
 
-static void define_symbolic_values(struct print_flag_sym *field,
+static void define_symbolic_values(struct tep_print_flag_sym *field,
                                    const char *ev_name,
                                    const char *field_name)
 {
@@ -157,7 +157,7 @@ static void define_flag_value(const char *ev_name,
         LEAVE;
 }
 
-static void define_flag_values(struct print_flag_sym *field,
+static void define_flag_values(struct tep_print_flag_sym *field,
                                const char *ev_name,
                                const char *field_name)
 {
@@ -189,62 +189,62 @@ static void define_flag_field(const char *ev_name,
         LEAVE;
 }
 
-static void define_event_symbols(struct event_format *event,
+static void define_event_symbols(struct tep_event_format *event,
                                  const char *ev_name,
-                                 struct print_arg *args)
+                                 struct tep_print_arg *args)
 {
         if (args == NULL)
                 return;
 
         switch (args->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 break;
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 define_flag_value(ev_name, cur_field_name, "0",
                                   args->atom.atom);
                 zero_flag_atom = 0;
                 break;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 free(cur_field_name);
                 cur_field_name = strdup(args->field.name);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 define_event_symbols(event, ev_name, args->flags.field);
                 define_flag_field(ev_name, cur_field_name, args->flags.delim);
                 define_flag_values(args->flags.flags, ev_name, cur_field_name);
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 define_event_symbols(event, ev_name, args->symbol.field);
                 define_symbolic_field(ev_name, cur_field_name);
                 define_symbolic_values(args->symbol.symbols, ev_name,
                                        cur_field_name);
                 break;
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
                 define_event_symbols(event, ev_name, args->hex.field);
                 define_event_symbols(event, ev_name, args->hex.size);
                 break;
-        case PRINT_INT_ARRAY:
+        case TEP_PRINT_INT_ARRAY:
                 define_event_symbols(event, ev_name, args->int_array.field);
                 define_event_symbols(event, ev_name, args->int_array.count);
                 define_event_symbols(event, ev_name, args->int_array.el_size);
                 break;
-        case PRINT_BSTRING:
-        case PRINT_DYNAMIC_ARRAY:
-        case PRINT_DYNAMIC_ARRAY_LEN:
-        case PRINT_STRING:
-        case PRINT_BITMASK:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_DYNAMIC_ARRAY:
+        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BITMASK:
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 define_event_symbols(event, ev_name, args->typecast.item);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (strcmp(args->op.op, ":") == 0)
                         zero_flag_atom = 1;
                 define_event_symbols(event, ev_name, args->op.left);
                 define_event_symbols(event, ev_name, args->op.right);
                 break;
-        case PRINT_FUNC:
+        case TEP_PRINT_FUNC:
         default:
                 pr_err("Unsupported print arg type\n");
                 /* we should warn... */
@@ -338,8 +338,8 @@ static void perl_process_tracepoint(struct perf_sample *sample,
                                     struct addr_location *al)
 {
         struct thread *thread = al->thread;
-        struct event_format *event = evsel->tp_format;
-        struct format_field *field;
+        struct tep_event_format *event = evsel->tp_format;
+        struct tep_format_field *field;
         static char handler[256];
         unsigned long long val;
         unsigned long s, ns;
@@ -388,9 +388,9 @@ static void perl_process_tracepoint(struct perf_sample *sample,
         /* common fields other than pid can be accessed via xsub fns */
 
         for (field = event->format.fields; field; field = field->next) {
-                if (field->flags & FIELD_IS_STRING) {
+                if (field->flags & TEP_FIELD_IS_STRING) {
                         int offset;
-                        if (field->flags & FIELD_IS_DYNAMIC) {
+                        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                                 offset = *(int *)(data + field->offset);
                                 offset &= 0xffff;
                         } else
@@ -399,7 +399,7 @@ static void perl_process_tracepoint(struct perf_sample *sample,
                 } else { /* FIELD_IS_NUMERIC */
                         val = read_size(event, data + field->offset,
                                         field->size);
-                        if (field->flags & FIELD_IS_SIGNED) {
+                        if (field->flags & TEP_FIELD_IS_SIGNED) {
                                 XPUSHs(sv_2mortal(newSViv(val)));
                         } else {
                                 XPUSHs(sv_2mortal(newSVuv(val)));
@@ -537,8 +537,8 @@ static int perl_stop_script(void)
 
 static int perl_generate_script(struct tep_handle *pevent, const char *outfile)
 {
-        struct event_format *event = NULL;
-        struct format_field *f;
+        struct tep_event_format *event = NULL;
+        struct tep_format_field *f;
         char fname[PATH_MAX];
         int not_first, count;
         FILE *ofp;
@@ -646,11 +646,11 @@ sub print_backtrace\n\
                         count++;
 
                         fprintf(ofp, "%s=", f->name);
-                        if (f->flags & FIELD_IS_STRING ||
-                            f->flags & FIELD_IS_FLAG ||
-                            f->flags & FIELD_IS_SYMBOLIC)
+                        if (f->flags & TEP_FIELD_IS_STRING ||
+                            f->flags & TEP_FIELD_IS_FLAG ||
+                            f->flags & TEP_FIELD_IS_SYMBOLIC)
                                 fprintf(ofp, "%%s");
-                        else if (f->flags & FIELD_IS_SIGNED)
+                        else if (f->flags & TEP_FIELD_IS_SIGNED)
                                 fprintf(ofp, "%%d");
                         else
                                 fprintf(ofp, "%%u");
@@ -668,7 +668,7 @@ sub print_backtrace\n\
                         if (++count % 5 == 0)
                                 fprintf(ofp, "\n\t       ");
 
-                        if (f->flags & FIELD_IS_FLAG) {
+                        if (f->flags & TEP_FIELD_IS_FLAG) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t       ");
                                         count = 4;
@@ -678,7 +678,7 @@ sub print_backtrace\n\
                                         event->name);
                                 fprintf(ofp, "\"%s\", $%s)", f->name,
                                         f->name);
-                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                        } else if (f->flags & TEP_FIELD_IS_SYMBOLIC) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t       ");
                                         count = 4;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index dfc6093f118c..69aa93d4ee99 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -193,7 +193,7 @@ static void try_call_object(const char *handler_name, PyObject *args)
                 call_object(handler, args, handler_name);
 }
 
-static void define_value(enum print_arg_type field_type,
+static void define_value(enum tep_print_arg_type field_type,
                          const char *ev_name,
                          const char *field_name,
                          const char *field_value,
@@ -204,7 +204,7 @@ static void define_value(enum print_arg_type field_type,
         unsigned long long value;
         unsigned n = 0;
 
-        if (field_type == PRINT_SYMBOL)
+        if (field_type == TEP_PRINT_SYMBOL)
                 handler_name = "define_symbolic_value";
 
         t = PyTuple_New(4);
@@ -223,8 +223,8 @@ static void define_value(enum print_arg_type field_type,
         Py_DECREF(t);
 }
 
-static void define_values(enum print_arg_type field_type,
-                          struct print_flag_sym *field,
+static void define_values(enum tep_print_arg_type field_type,
+                          struct tep_print_flag_sym *field,
                           const char *ev_name,
                           const char *field_name)
 {
@@ -235,7 +235,7 @@ static void define_values(enum print_arg_type field_type,
                 define_values(field_type, field->next, ev_name, field_name);
 }
 
-static void define_field(enum print_arg_type field_type,
+static void define_field(enum tep_print_arg_type field_type,
                          const char *ev_name,
                          const char *field_name,
                          const char *delim)
@@ -244,10 +244,10 @@ static void define_field(enum print_arg_type field_type,
         PyObject *t;
         unsigned n = 0;
 
-        if (field_type == PRINT_SYMBOL)
+        if (field_type == TEP_PRINT_SYMBOL)
                 handler_name = "define_symbolic_field";
 
-        if (field_type == PRINT_FLAGS)
+        if (field_type == TEP_PRINT_FLAGS)
                 t = PyTuple_New(3);
         else
                 t = PyTuple_New(2);
@@ -256,7 +256,7 @@ static void define_field(enum print_arg_type field_type,
 
         PyTuple_SetItem(t, n++, _PyUnicode_FromString(ev_name));
         PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_name));
-        if (field_type == PRINT_FLAGS)
+        if (field_type == TEP_PRINT_FLAGS)
                 PyTuple_SetItem(t, n++, _PyUnicode_FromString(delim));
 
         try_call_object(handler_name, t);
@@ -264,54 +264,54 @@ static void define_field(enum print_arg_type field_type,
         Py_DECREF(t);
 }
 
-static void define_event_symbols(struct event_format *event,
+static void define_event_symbols(struct tep_event_format *event,
                                  const char *ev_name,
-                                 struct print_arg *args)
+                                 struct tep_print_arg *args)
 {
         if (args == NULL)
                 return;
 
         switch (args->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 break;
-        case PRINT_ATOM:
-                define_value(PRINT_FLAGS, ev_name, cur_field_name, "0",
+        case TEP_PRINT_ATOM:
+                define_value(TEP_PRINT_FLAGS, ev_name, cur_field_name, "0",
                              args->atom.atom);
                 zero_flag_atom = 0;
                 break;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 free(cur_field_name);
                 cur_field_name = strdup(args->field.name);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 define_event_symbols(event, ev_name, args->flags.field);
-                define_field(PRINT_FLAGS, ev_name, cur_field_name,
+                define_field(TEP_PRINT_FLAGS, ev_name, cur_field_name,
                              args->flags.delim);
-                define_values(PRINT_FLAGS, args->flags.flags, ev_name,
+                define_values(TEP_PRINT_FLAGS, args->flags.flags, ev_name,
                               cur_field_name);
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 define_event_symbols(event, ev_name, args->symbol.field);
-                define_field(PRINT_SYMBOL, ev_name, cur_field_name, NULL);
-                define_values(PRINT_SYMBOL, args->symbol.symbols, ev_name,
+                define_field(TEP_PRINT_SYMBOL, ev_name, cur_field_name, NULL);
+                define_values(TEP_PRINT_SYMBOL, args->symbol.symbols, ev_name,
                               cur_field_name);
                 break;
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
                 define_event_symbols(event, ev_name, args->hex.field);
                 define_event_symbols(event, ev_name, args->hex.size);
                 break;
-        case PRINT_INT_ARRAY:
+        case TEP_PRINT_INT_ARRAY:
                 define_event_symbols(event, ev_name, args->int_array.field);
                 define_event_symbols(event, ev_name, args->int_array.count);
                 define_event_symbols(event, ev_name, args->int_array.el_size);
                 break;
-        case PRINT_STRING:
+        case TEP_PRINT_STRING:
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 define_event_symbols(event, ev_name, args->typecast.item);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (strcmp(args->op.op, ":") == 0)
                         zero_flag_atom = 1;
                 define_event_symbols(event, ev_name, args->op.left);
@@ -319,11 +319,11 @@ static void define_event_symbols(struct event_format *event,
                 break;
         default:
                 /* gcc warns for these? */
-        case PRINT_BSTRING:
-        case PRINT_DYNAMIC_ARRAY:
-        case PRINT_DYNAMIC_ARRAY_LEN:
-        case PRINT_FUNC:
-        case PRINT_BITMASK:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_DYNAMIC_ARRAY:
+        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
+        case TEP_PRINT_FUNC:
+        case TEP_PRINT_BITMASK:
                 /* we should warn... */
                 return;
         }
@@ -332,10 +332,10 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static PyObject *get_field_numeric_entry(struct event_format *event,
-                struct format_field *field, void *data)
+static PyObject *get_field_numeric_entry(struct tep_event_format *event,
+                struct tep_format_field *field, void *data)
 {
-        bool is_array = field->flags & FIELD_IS_ARRAY;
+        bool is_array = field->flags & TEP_FIELD_IS_ARRAY;
         PyObject *obj = NULL, *list = NULL;
         unsigned long long val;
         unsigned int item_size, n_items, i;
@@ -353,7 +353,7 @@ static PyObject *get_field_numeric_entry(struct event_format *event,
 
                 val = read_size(event, data + field->offset + i * item_size,
                                 item_size);
-                if (field->flags & FIELD_IS_SIGNED) {
+                if (field->flags & TEP_FIELD_IS_SIGNED) {
                         if ((long long)val >= LONG_MIN &&
                                         (long long)val <= LONG_MAX)
                                 obj = _PyLong_FromLong(val);
@@ -790,11 +790,11 @@ static void python_process_tracepoint(struct perf_sample *sample,
                                       struct perf_evsel *evsel,
                                       struct addr_location *al)
 {
-        struct event_format *event = evsel->tp_format;
+        struct tep_event_format *event = evsel->tp_format;
         PyObject *handler, *context, *t, *obj = NULL, *callchain;
         PyObject *dict = NULL, *all_entries_dict = NULL;
         static char handler_name[256];
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long s, ns;
         unsigned n = 0;
         int pid;
@@ -867,22 +867,22 @@ static void python_process_tracepoint(struct perf_sample *sample,
                 unsigned int offset, len;
                 unsigned long long val;
 
-                if (field->flags & FIELD_IS_ARRAY) {
+                if (field->flags & TEP_FIELD_IS_ARRAY) {
                         offset = field->offset;
                         len    = field->size;
-                        if (field->flags & FIELD_IS_DYNAMIC) {
+                        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                                 val     = tep_read_number(scripting_context->pevent,
                                                           data + offset, len);
                                 offset  = val;
                                 len     = offset >> 16;
                                 offset &= 0xffff;
                         }
-                        if (field->flags & FIELD_IS_STRING &&
+                        if (field->flags & TEP_FIELD_IS_STRING &&
                             is_printable_array(data + offset, len)) {
                                 obj = _PyUnicode_FromString((char *) data + offset);
                         } else {
                                 obj = PyByteArray_FromStringAndSize((const char *) data + offset, len);
-                                field->flags &= ~FIELD_IS_STRING;
+                                field->flags &= ~TEP_FIELD_IS_STRING;
                         }
                 } else { /* FIELD_IS_NUMERIC */
                         obj = get_field_numeric_entry(event, field, data);
@@ -1590,8 +1590,8 @@ static int python_stop_script(void)
 
 static int python_generate_script(struct tep_handle *pevent, const char *outfile)
 {
-        struct event_format *event = NULL;
-        struct format_field *f;
+        struct tep_event_format *event = NULL;
+        struct tep_format_field *f;
         char fname[PATH_MAX];
         int not_first, count;
         FILE *ofp;
@@ -1686,12 +1686,12 @@ static int python_generate_script(struct tep_handle *pevent, const char *outfile
                         count++;
 
                         fprintf(ofp, "%s=", f->name);
-                        if (f->flags & FIELD_IS_STRING ||
-                            f->flags & FIELD_IS_FLAG ||
-                            f->flags & FIELD_IS_ARRAY ||
-                            f->flags & FIELD_IS_SYMBOLIC)
+                        if (f->flags & TEP_FIELD_IS_STRING ||
+                            f->flags & TEP_FIELD_IS_FLAG ||
+                            f->flags & TEP_FIELD_IS_ARRAY ||
+                            f->flags & TEP_FIELD_IS_SYMBOLIC)
                                 fprintf(ofp, "%%s");
-                        else if (f->flags & FIELD_IS_SIGNED)
+                        else if (f->flags & TEP_FIELD_IS_SIGNED)
                                 fprintf(ofp, "%%d");
                         else
                                 fprintf(ofp, "%%u");
@@ -1709,7 +1709,7 @@ static int python_generate_script(struct tep_handle *pevent, const char *outfile
                         if (++count % 5 == 0)
                                 fprintf(ofp, "\n\t\t");
 
-                        if (f->flags & FIELD_IS_FLAG) {
+                        if (f->flags & TEP_FIELD_IS_FLAG) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t\t");
                                         count = 4;
@@ -1719,7 +1719,7 @@ static int python_generate_script(struct tep_handle *pevent, const char *outfile
                                         event->name);
                                 fprintf(ofp, "\"%s\", %s)", f->name,
                                         f->name);
-                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                        } else if (f->flags & TEP_FIELD_IS_SYMBOLIC) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t\t");
                                         count = 4;
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 8b9369303561..7d2c8ce6cfad 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -199,12 +199,10 @@ void perf_session__delete(struct perf_session *session)
         free(session);
 }
 
-static int process_event_synth_tracing_data_stub(struct perf_tool *tool
+static int process_event_synth_tracing_data_stub(struct perf_session *session
                                                  __maybe_unused,
                                                  union perf_event *event
-                                                 __maybe_unused,
-                                                 struct perf_session *session
-                                                __maybe_unused)
+                                                 __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
@@ -277,10 +275,8 @@ static int skipn(int fd, off_t n)
         return 0;
 }
 
-static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
-                                       union perf_event *event,
-                                       struct perf_session *session
-                                       __maybe_unused)
+static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
+                                       union perf_event *event)
 {
         dump_printf(": unhandled!\n");
         if (perf_data__is_pipe(session->data))
@@ -288,9 +284,8 @@ static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
         return event->auxtrace.size;
 }
 
-static int process_event_op2_stub(struct perf_tool *tool __maybe_unused,
-                                  union perf_event *event __maybe_unused,
-                                  struct perf_session *session __maybe_unused)
+static int process_event_op2_stub(struct perf_session *session __maybe_unused,
+                                  union perf_event *event __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
@@ -298,9 +293,8 @@ static int process_event_op2_stub(struct perf_tool *tool __maybe_unused,
 
 
 static
-int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused,
-                                  union perf_event *event __maybe_unused,
-                                  struct perf_session *session __maybe_unused)
+int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
+                                  union perf_event *event __maybe_unused)
 {
         if (dump_trace)
                 perf_event__fprintf_thread_map(event, stdout);
@@ -310,9 +304,8 @@ int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused,
 }
 
 static
-int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused,
-                               union perf_event *event __maybe_unused,
-                               struct perf_session *session __maybe_unused)
+int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
+                               union perf_event *event __maybe_unused)
 {
         if (dump_trace)
                 perf_event__fprintf_cpu_map(event, stdout);
@@ -322,9 +315,8 @@ int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused,
 }
 
 static
-int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event __maybe_unused,
-                                   struct perf_session *session __maybe_unused)
+int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
+                                   union perf_event *event __maybe_unused)
 {
         if (dump_trace)
                 perf_event__fprintf_stat_config(event, stdout);
@@ -333,10 +325,8 @@ int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_stat_stub(struct perf_tool *tool __maybe_unused,
-                             union perf_event *event __maybe_unused,
-                             struct perf_session *perf_session
-                             __maybe_unused)
+static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
+                             union perf_event *event)
 {
         if (dump_trace)
                 perf_event__fprintf_stat(event, stdout);
@@ -345,10 +335,8 @@ static int process_stat_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_stat_round_stub(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event __maybe_unused,
-                                   struct perf_session *perf_session
-                                   __maybe_unused)
+static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
+                                   union perf_event *event)
 {
         if (dump_trace)
                 perf_event__fprintf_stat_round(event, stdout);
@@ -1374,37 +1362,37 @@ static s64 perf_session__process_user_event(struct perf_session *session,
         case PERF_RECORD_HEADER_TRACING_DATA:
                 /* setup for reading amidst mmap */
                 lseek(fd, file_offset, SEEK_SET);
-                return tool->tracing_data(tool, event, session);
+                return tool->tracing_data(session, event);
         case PERF_RECORD_HEADER_BUILD_ID:
-                return tool->build_id(tool, event, session);
+                return tool->build_id(session, event);
         case PERF_RECORD_FINISHED_ROUND:
                 return tool->finished_round(tool, event, oe);
         case PERF_RECORD_ID_INDEX:
-                return tool->id_index(tool, event, session);
+                return tool->id_index(session, event);
         case PERF_RECORD_AUXTRACE_INFO:
-                return tool->auxtrace_info(tool, event, session);
+                return tool->auxtrace_info(session, event);
         case PERF_RECORD_AUXTRACE:
                 /* setup for reading amidst mmap */
                 lseek(fd, file_offset + event->header.size, SEEK_SET);
-                return tool->auxtrace(tool, event, session);
+                return tool->auxtrace(session, event);
         case PERF_RECORD_AUXTRACE_ERROR:
                 perf_session__auxtrace_error_inc(session, event);
-                return tool->auxtrace_error(tool, event, session);
+                return tool->auxtrace_error(session, event);
         case PERF_RECORD_THREAD_MAP:
-                return tool->thread_map(tool, event, session);
+                return tool->thread_map(session, event);
         case PERF_RECORD_CPU_MAP:
-                return tool->cpu_map(tool, event, session);
+                return tool->cpu_map(session, event);
         case PERF_RECORD_STAT_CONFIG:
-                return tool->stat_config(tool, event, session);
+                return tool->stat_config(session, event);
         case PERF_RECORD_STAT:
-                return tool->stat(tool, event, session);
+                return tool->stat(session, event);
         case PERF_RECORD_STAT_ROUND:
-                return tool->stat_round(tool, event, session);
+                return tool->stat_round(session, event);
         case PERF_RECORD_TIME_CONV:
                 session->time_conv = event->time_conv;
-                return tool->time_conv(tool, event, session);
+                return tool->time_conv(session, event);
         case PERF_RECORD_HEADER_FEATURE:
-                return tool->feature(tool, event, session);
+                return tool->feature(session, event);
         default:
                 return -EINVAL;
         }
@@ -2133,9 +2121,8 @@ out:
         return err;
 }
 
-int perf_event__process_id_index(struct perf_tool *tool __maybe_unused,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+int perf_event__process_id_index(struct perf_session *session,
+                                 union perf_event *event)
 {
         struct perf_evlist *evlist = session->evlist;
         struct id_index_event *ie = &event->id_index;
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index da40b4b380ca..d96eccd7d27f 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -120,9 +120,8 @@ int perf_session__deliver_synth_event(struct perf_session *session,
                                       union perf_event *event,
                                       struct perf_sample *sample);
 
-int perf_event__process_id_index(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session);
+int perf_event__process_id_index(struct perf_session *session,
+                                 union perf_event *event);
 
 int perf_event__synthesize_id_index(struct perf_tool *tool,
                                     perf_event__handler_t process,
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 1942f6dd24f6..63f758c655d5 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -5,16 +5,18 @@ from subprocess import Popen, PIPE
 from re import sub
 
 def clang_has_option(option):
-    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if "unknown argument" in o] == [ ]
+    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if b"unknown argument" in o] == [ ]
 
 cc = getenv("CC")
 if cc == "clang":
-    from _sysconfigdata import build_time_vars
-    build_time_vars["CFLAGS"] = sub("-specs=[^ ]+", "", build_time_vars["CFLAGS"])
-    if not clang_has_option("-mcet"):
-        build_time_vars["CFLAGS"] = sub("-mcet", "", build_time_vars["CFLAGS"])
-    if not clang_has_option("-fcf-protection"):
-        build_time_vars["CFLAGS"] = sub("-fcf-protection", "", build_time_vars["CFLAGS"])
+    from distutils.sysconfig import get_config_vars
+    vars = get_config_vars()
+    for var in ('CFLAGS', 'OPT'):
+        vars[var] = sub("-specs=[^ ]+", "", vars[var])
+        if not clang_has_option("-mcet"):
+            vars[var] = sub("-mcet", "", vars[var])
+        if not clang_has_option("-fcf-protection"):
+            vars[var] = sub("-fcf-protection", "", vars[var])
 
 from distutils.core import setup, Extension
 
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index b284276ec963..f96c005b3c41 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1884,7 +1884,7 @@ static int __sort_dimension__add_hpp_output(struct sort_dimension *sd,
 struct hpp_dynamic_entry {
         struct perf_hpp_fmt hpp;
         struct perf_evsel *evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned dynamic_len;
         bool raw_trace;
 };
@@ -1899,7 +1899,7 @@ static int hde_width(struct hpp_dynamic_entry *hde)
                 if (namelen > len)
                         len = namelen;
 
-                if (!(hde->field->flags & FIELD_IS_STRING)) {
+                if (!(hde->field->flags & TEP_FIELD_IS_STRING)) {
                         /* length for print hex numbers */
                         fieldlen = hde->field->size * 2 + 2;
                 }
@@ -1915,7 +1915,7 @@ static void update_dynamic_len(struct hpp_dynamic_entry *hde,
                                struct hist_entry *he)
 {
         char *str, *pos;
-        struct format_field *field = hde->field;
+        struct tep_format_field *field = hde->field;
         size_t namelen;
         bool last = false;
 
@@ -2000,7 +2000,7 @@ static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
         struct hpp_dynamic_entry *hde;
         size_t len = fmt->user_len;
         char *str, *pos;
-        struct format_field *field;
+        struct tep_format_field *field;
         size_t namelen;
         bool last = false;
         int ret;
@@ -2060,7 +2060,7 @@ static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
                                struct hist_entry *a, struct hist_entry *b)
 {
         struct hpp_dynamic_entry *hde;
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned offset, size;
 
         hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
@@ -2071,7 +2071,7 @@ static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
         }
 
         field = hde->field;
-        if (field->flags & FIELD_IS_DYNAMIC) {
+        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                 unsigned long long dyn;
 
                 tep_read_number_field(field, a->raw_data, &dyn);
@@ -2117,7 +2117,7 @@ static void hde_free(struct perf_hpp_fmt *fmt)
 }
 
 static struct hpp_dynamic_entry *
-__alloc_dynamic_entry(struct perf_evsel *evsel, struct format_field *field,
+__alloc_dynamic_entry(struct perf_evsel *evsel, struct tep_format_field *field,
                       int level)
 {
         struct hpp_dynamic_entry *hde;
@@ -2252,7 +2252,7 @@ static struct perf_evsel *find_evsel(struct perf_evlist *evlist, char *event_nam
 }
 
 static int __dynamic_dimension__add(struct perf_evsel *evsel,
-                                    struct format_field *field,
+                                    struct tep_format_field *field,
                                     bool raw_trace, int level)
 {
         struct hpp_dynamic_entry *hde;
@@ -2270,7 +2270,7 @@ static int __dynamic_dimension__add(struct perf_evsel *evsel,
 static int add_evsel_fields(struct perf_evsel *evsel, bool raw_trace, int level)
 {
         int ret;
-        struct format_field *field;
+        struct tep_format_field *field;
 
         field = evsel->tp_format->format.fields;
         while (field) {
@@ -2305,7 +2305,7 @@ static int add_all_matching_fields(struct perf_evlist *evlist,
 {
         int ret = -ESRCH;
         struct perf_evsel *evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
 
         evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
@@ -2327,7 +2327,7 @@ static int add_dynamic_entry(struct perf_evlist *evlist, const char *tok,
 {
         char *str, *event_name, *field_name, *opt_name;
         struct perf_evsel *evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
         bool raw_trace = symbol_conf.raw_trace;
         int ret = 0;
 
diff --git a/tools/perf/util/stat-display.c b/tools/perf/util/stat-display.c
new file mode 100644
index 000000000000..e7b4c44ebb62
--- /dev/null
+++ b/tools/perf/util/stat-display.c
@@ -0,0 +1,1166 @@
+#include <stdio.h>
+#include <inttypes.h>
+#include <linux/time64.h>
+#include <math.h>
+#include "evlist.h"
+#include "evsel.h"
+#include "stat.h"
+#include "top.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "string2.h"
+#include "sane_ctype.h"
+#include "cgroup.h"
+#include <math.h>
+#include <api/fs/fs.h>
+
+#define CNTR_NOT_SUPPORTED      "<not supported>"
+#define CNTR_NOT_COUNTED        "<not counted>"
+
+static bool is_duration_time(struct perf_evsel *evsel)
+{
+        return !strcmp(evsel->name, "duration_time");
+}
+
+static void print_running(struct perf_stat_config *config,
+                          u64 run, u64 ena)
+{
+        if (config->csv_output) {
+                fprintf(config->output, "%s%" PRIu64 "%s%.2f",
+                                        config->csv_sep,
+                                        run,
+                                        config->csv_sep,
+                                        ena ? 100.0 * run / ena : 100.0);
+        } else if (run != ena) {
+                fprintf(config->output, "  (%.2f%%)", 100.0 * run / ena);
+        }
+}
+
+static void print_noise_pct(struct perf_stat_config *config,
+                            double total, double avg)
+{
+        double pct = rel_stddev_stats(total, avg);
+
+        if (config->csv_output)
+                fprintf(config->output, "%s%.2f%%", config->csv_sep, pct);
+        else if (pct)
+                fprintf(config->output, "  ( +-%6.2f%% )", pct);
+}
+
+static void print_noise(struct perf_stat_config *config,
+                        struct perf_evsel *evsel, double avg)
+{
+        struct perf_stat_evsel *ps;
+
+        if (config->run_count == 1)
+                return;
+
+        ps = evsel->stats;
+        print_noise_pct(config, stddev_stats(&ps->res_stats[0]), avg);
+}
+
+static void aggr_printout(struct perf_stat_config *config,
+                          struct perf_evsel *evsel, int id, int nr)
+{
+        switch (config->aggr_mode) {
+        case AGGR_CORE:
+                fprintf(config->output, "S%d-C%*d%s%*d%s",
+                        cpu_map__id_to_socket(id),
+                        config->csv_output ? 0 : -8,
+                        cpu_map__id_to_cpu(id),
+                        config->csv_sep,
+                        config->csv_output ? 0 : 4,
+                        nr,
+                        config->csv_sep);
+                break;
+        case AGGR_SOCKET:
+                fprintf(config->output, "S%*d%s%*d%s",
+                        config->csv_output ? 0 : -5,
+                        id,
+                        config->csv_sep,
+                        config->csv_output ? 0 : 4,
+                        nr,
+                        config->csv_sep);
+                        break;
+        case AGGR_NONE:
+                fprintf(config->output, "CPU%*d%s",
+                        config->csv_output ? 0 : -4,
+                        perf_evsel__cpus(evsel)->map[id], config->csv_sep);
+                break;
+        case AGGR_THREAD:
+                fprintf(config->output, "%*s-%*d%s",
+                        config->csv_output ? 0 : 16,
+                        thread_map__comm(evsel->threads, id),
+                        config->csv_output ? 0 : -8,
+                        thread_map__pid(evsel->threads, id),
+                        config->csv_sep);
+                break;
+        case AGGR_GLOBAL:
+        case AGGR_UNSET:
+        default:
+                break;
+        }
+}
+
+struct outstate {
+        FILE *fh;
+        bool newline;
+        const char *prefix;
+        int  nfields;
+        int  id, nr;
+        struct perf_evsel *evsel;
+};
+
+#define METRIC_LEN  35
+
+static void new_line_std(struct perf_stat_config *config __maybe_unused,
+                         void *ctx)
+{
+        struct outstate *os = ctx;
+
+        os->newline = true;
+}
+
+static void do_new_line_std(struct perf_stat_config *config,
+                            struct outstate *os)
+{
+        fputc('\n', os->fh);
+        fputs(os->prefix, os->fh);
+        aggr_printout(config, os->evsel, os->id, os->nr);
+        if (config->aggr_mode == AGGR_NONE)
+                fprintf(os->fh, "        ");
+        fprintf(os->fh, "                                                 ");
+}
+
+static void print_metric_std(struct perf_stat_config *config,
+                             void *ctx, const char *color, const char *fmt,
+                             const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        int n;
+        bool newline = os->newline;
+
+        os->newline = false;
+
+        if (unit == NULL || fmt == NULL) {
+                fprintf(out, "%-*s", METRIC_LEN, "");
+                return;
+        }
+
+        if (newline)
+                do_new_line_std(config, os);
+
+        n = fprintf(out, " # ");
+        if (color)
+                n += color_fprintf(out, color, fmt, val);
+        else
+                n += fprintf(out, fmt, val);
+        fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
+}
+
+static void new_line_csv(struct perf_stat_config *config, void *ctx)
+{
+        struct outstate *os = ctx;
+        int i;
+
+        fputc('\n', os->fh);
+        if (os->prefix)
+                fprintf(os->fh, "%s%s", os->prefix, config->csv_sep);
+        aggr_printout(config, os->evsel, os->id, os->nr);
+        for (i = 0; i < os->nfields; i++)
+                fputs(config->csv_sep, os->fh);
+}
+
+static void print_metric_csv(struct perf_stat_config *config __maybe_unused,
+                             void *ctx,
+                             const char *color __maybe_unused,
+                             const char *fmt, const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        char buf[64], *vals, *ends;
+
+        if (unit == NULL || fmt == NULL) {
+                fprintf(out, "%s%s", config->csv_sep, config->csv_sep);
+                return;
+        }
+        snprintf(buf, sizeof(buf), fmt, val);
+        ends = vals = ltrim(buf);
+        while (isdigit(*ends) || *ends == '.')
+                ends++;
+        *ends = 0;
+        while (isspace(*unit))
+                unit++;
+        fprintf(out, "%s%s%s%s", config->csv_sep, vals, config->csv_sep, unit);
+}
+
+/* Filter out some columns that don't work well in metrics only mode */
+
+static bool valid_only_metric(const char *unit)
+{
+        if (!unit)
+                return false;
+        if (strstr(unit, "/sec") ||
+            strstr(unit, "hz") ||
+            strstr(unit, "Hz") ||
+            strstr(unit, "CPUs utilized"))
+                return false;
+        return true;
+}
+
+static const char *fixunit(char *buf, struct perf_evsel *evsel,
+                           const char *unit)
+{
+        if (!strncmp(unit, "of all", 6)) {
+                snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel),
+                         unit);
+                return buf;
+        }
+        return unit;
+}
+
+static void print_metric_only(struct perf_stat_config *config,
+                              void *ctx, const char *color, const char *fmt,
+                              const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        char buf[1024], str[1024];
+        unsigned mlen = config->metric_only_len;
+
+        if (!valid_only_metric(unit))
+                return;
+        unit = fixunit(buf, os->evsel, unit);
+        if (mlen < strlen(unit))
+                mlen = strlen(unit) + 1;
+
+        if (color)
+                mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
+
+        color_snprintf(str, sizeof(str), color ?: "", fmt, val);
+        fprintf(out, "%*s ", mlen, str);
+}
+
+static void print_metric_only_csv(struct perf_stat_config *config __maybe_unused,
+                                  void *ctx, const char *color __maybe_unused,
+                                  const char *fmt,
+                                  const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        char buf[64], *vals, *ends;
+        char tbuf[1024];
+
+        if (!valid_only_metric(unit))
+                return;
+        unit = fixunit(tbuf, os->evsel, unit);
+        snprintf(buf, sizeof buf, fmt, val);
+        ends = vals = ltrim(buf);
+        while (isdigit(*ends) || *ends == '.')
+                ends++;
+        *ends = 0;
+        fprintf(out, "%s%s", vals, config->csv_sep);
+}
+
+static void new_line_metric(struct perf_stat_config *config __maybe_unused,
+                            void *ctx __maybe_unused)
+{
+}
+
+static void print_metric_header(struct perf_stat_config *config,
+                                void *ctx, const char *color __maybe_unused,
+                                const char *fmt __maybe_unused,
+                                const char *unit, double val __maybe_unused)
+{
+        struct outstate *os = ctx;
+        char tbuf[1024];
+
+        if (!valid_only_metric(unit))
+                return;
+        unit = fixunit(tbuf, os->evsel, unit);
+        if (config->csv_output)
+                fprintf(os->fh, "%s%s", unit, config->csv_sep);
+        else
+                fprintf(os->fh, "%*s ", config->metric_only_len, unit);
+}
+
+static int first_shadow_cpu(struct perf_stat_config *config,
+                            struct perf_evsel *evsel, int id)
+{
+        struct perf_evlist *evlist = evsel->evlist;
+        int i;
+
+        if (!config->aggr_get_id)
+                return 0;
+
+        if (config->aggr_mode == AGGR_NONE)
+                return id;
+
+        if (config->aggr_mode == AGGR_GLOBAL)
+                return 0;
+
+        for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) {
+                int cpu2 = perf_evsel__cpus(evsel)->map[i];
+
+                if (config->aggr_get_id(config, evlist->cpus, cpu2) == id)
+                        return cpu2;
+        }
+        return 0;
+}
+
+static void abs_printout(struct perf_stat_config *config,
+                         int id, int nr, struct perf_evsel *evsel, double avg)
+{
+        FILE *output = config->output;
+        double sc =  evsel->scale;
+        const char *fmt;
+
+        if (config->csv_output) {
+                fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
+        } else {
+                if (config->big_num)
+                        fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
+                else
+                        fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
+        }
+
+        aggr_printout(config, evsel, id, nr);
+
+        fprintf(output, fmt, avg, config->csv_sep);
+
+        if (evsel->unit)
+                fprintf(output, "%-*s%s",
+                        config->csv_output ? 0 : config->unit_width,
+                        evsel->unit, config->csv_sep);
+
+        fprintf(output, "%-*s", config->csv_output ? 0 : 25, perf_evsel__name(evsel));
+
+        if (evsel->cgrp)
+                fprintf(output, "%s%s", config->csv_sep, evsel->cgrp->name);
+}
+
+static bool is_mixed_hw_group(struct perf_evsel *counter)
+{
+        struct perf_evlist *evlist = counter->evlist;
+        u32 pmu_type = counter->attr.type;
+        struct perf_evsel *pos;
+
+        if (counter->nr_members < 2)
+                return false;
+
+        evlist__for_each_entry(evlist, pos) {
+                /* software events can be part of any hardware group */
+                if (pos->attr.type == PERF_TYPE_SOFTWARE)
+                        continue;
+                if (pmu_type == PERF_TYPE_SOFTWARE) {
+                        pmu_type = pos->attr.type;
+                        continue;
+                }
+                if (pmu_type != pos->attr.type)
+                        return true;
+        }
+
+        return false;
+}
+
+static void printout(struct perf_stat_config *config, int id, int nr,
+                     struct perf_evsel *counter, double uval,
+                     char *prefix, u64 run, u64 ena, double noise,
+                     struct runtime_stat *st)
+{
+        struct perf_stat_output_ctx out;
+        struct outstate os = {
+                .fh = config->output,
+                .prefix = prefix ? prefix : "",
+                .id = id,
+                .nr = nr,
+                .evsel = counter,
+        };
+        print_metric_t pm = print_metric_std;
+        new_line_t nl;
+
+        if (config->metric_only) {
+                nl = new_line_metric;
+                if (config->csv_output)
+                        pm = print_metric_only_csv;
+                else
+                        pm = print_metric_only;
+        } else
+                nl = new_line_std;
+
+        if (config->csv_output && !config->metric_only) {
+                static int aggr_fields[] = {
+                        [AGGR_GLOBAL] = 0,
+                        [AGGR_THREAD] = 1,
+                        [AGGR_NONE] = 1,
+                        [AGGR_SOCKET] = 2,
+                        [AGGR_CORE] = 2,
+                };
+
+                pm = print_metric_csv;
+                nl = new_line_csv;
+                os.nfields = 3;
+                os.nfields += aggr_fields[config->aggr_mode];
+                if (counter->cgrp)
+                        os.nfields++;
+        }
+        if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
+                if (config->metric_only) {
+                        pm(config, &os, NULL, "", "", 0);
+                        return;
+                }
+                aggr_printout(config, counter, id, nr);
+
+                fprintf(config->output, "%*s%s",
+                        config->csv_output ? 0 : 18,
+                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
+                        config->csv_sep);
+
+                if (counter->supported) {
+                        config->print_free_counters_hint = 1;
+                        if (is_mixed_hw_group(counter))
+                                config->print_mixed_hw_group_error = 1;
+                }
+
+                fprintf(config->output, "%-*s%s",
+                        config->csv_output ? 0 : config->unit_width,
+                        counter->unit, config->csv_sep);
+
+                fprintf(config->output, "%*s",
+                        config->csv_output ? 0 : -25,
+                        perf_evsel__name(counter));
+
+                if (counter->cgrp)
+                        fprintf(config->output, "%s%s",
+                                config->csv_sep, counter->cgrp->name);
+
+                if (!config->csv_output)
+                        pm(config, &os, NULL, NULL, "", 0);
+                print_noise(config, counter, noise);
+                print_running(config, run, ena);
+                if (config->csv_output)
+                        pm(config, &os, NULL, NULL, "", 0);
+                return;
+        }
+
+        if (!config->metric_only)
+                abs_printout(config, id, nr, counter, uval);
+
+        out.print_metric = pm;
+        out.new_line = nl;
+        out.ctx = &os;
+        out.force_header = false;
+
+        if (config->csv_output && !config->metric_only) {
+                print_noise(config, counter, noise);
+                print_running(config, run, ena);
+        }
+
+        perf_stat__print_shadow_stats(config, counter, uval,
+                                first_shadow_cpu(config, counter, id),
+                                &out, &config->metric_events, st);
+        if (!config->csv_output && !config->metric_only) {
+                print_noise(config, counter, noise);
+                print_running(config, run, ena);
+        }
+}
+
+static void aggr_update_shadow(struct perf_stat_config *config,
+                               struct perf_evlist *evlist)
+{
+        int cpu, s2, id, s;
+        u64 val;
+        struct perf_evsel *counter;
+
+        for (s = 0; s < config->aggr_map->nr; s++) {
+                id = config->aggr_map->map[s];
+                evlist__for_each_entry(evlist, counter) {
+                        val = 0;
+                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                                s2 = config->aggr_get_id(config, evlist->cpus, cpu);
+                                if (s2 != id)
+                                        continue;
+                                val += perf_counts(counter->counts, cpu, 0)->val;
+                        }
+                        perf_stat__update_shadow_stats(counter, val,
+                                        first_shadow_cpu(config, counter, id),
+                                        &rt_stat);
+                }
+        }
+}
+
+static void uniquify_event_name(struct perf_evsel *counter)
+{
+        char *new_name;
+        char *config;
+
+        if (counter->uniquified_name ||
+            !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
+                                           strlen(counter->pmu_name)))
+                return;
+
+        config = strchr(counter->name, '/');
+        if (config) {
+                if (asprintf(&new_name,
+                             "%s%s", counter->pmu_name, config) > 0) {
+                        free(counter->name);
+                        counter->name = new_name;
+                }
+        } else {
+                if (asprintf(&new_name,
+                             "%s [%s]", counter->name, counter->pmu_name) > 0) {
+                        free(counter->name);
+                        counter->name = new_name;
+                }
+        }
+
+        counter->uniquified_name = true;
+}
+
+static void collect_all_aliases(struct perf_stat_config *config, struct perf_evsel *counter,
+                            void (*cb)(struct perf_stat_config *config, struct perf_evsel *counter, void *data,
+                                       bool first),
+                            void *data)
+{
+        struct perf_evlist *evlist = counter->evlist;
+        struct perf_evsel *alias;
+
+        alias = list_prepare_entry(counter, &(evlist->entries), node);
+        list_for_each_entry_continue (alias, &evlist->entries, node) {
+                if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
+                    alias->scale != counter->scale ||
+                    alias->cgrp != counter->cgrp ||
+                    strcmp(alias->unit, counter->unit) ||
+                    perf_evsel__is_clock(alias) != perf_evsel__is_clock(counter))
+                        break;
+                alias->merged_stat = true;
+                cb(config, alias, data, false);
+        }
+}
+
+static bool collect_data(struct perf_stat_config *config, struct perf_evsel *counter,
+                            void (*cb)(struct perf_stat_config *config, struct perf_evsel *counter, void *data,
+                                       bool first),
+                            void *data)
+{
+        if (counter->merged_stat)
+                return false;
+        cb(config, counter, data, true);
+        if (config->no_merge)
+                uniquify_event_name(counter);
+        else if (counter->auto_merge_stats)
+                collect_all_aliases(config, counter, cb, data);
+        return true;
+}
+
+struct aggr_data {
+        u64 ena, run, val;
+        int id;
+        int nr;
+        int cpu;
+};
+
+static void aggr_cb(struct perf_stat_config *config,
+                    struct perf_evsel *counter, void *data, bool first)
+{
+        struct aggr_data *ad = data;
+        int cpu, s2;
+
+        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                struct perf_counts_values *counts;
+
+                s2 = config->aggr_get_id(config, perf_evsel__cpus(counter), cpu);
+                if (s2 != ad->id)
+                        continue;
+                if (first)
+                        ad->nr++;
+                counts = perf_counts(counter->counts, cpu, 0);
+                /*
+                 * When any result is bad, make them all to give
+                 * consistent output in interval mode.
+                 */
+                if (counts->ena == 0 || counts->run == 0 ||
+                    counter->counts->scaled == -1) {
+                        ad->ena = 0;
+                        ad->run = 0;
+                        break;
+                }
+                ad->val += counts->val;
+                ad->ena += counts->ena;
+                ad->run += counts->run;
+        }
+}
+
+static void print_aggr(struct perf_stat_config *config,
+                       struct perf_evlist *evlist,
+                       char *prefix)
+{
+        bool metric_only = config->metric_only;
+        FILE *output = config->output;
+        struct perf_evsel *counter;
+        int s, id, nr;
+        double uval;
+        u64 ena, run, val;
+        bool first;
+
+        if (!(config->aggr_map || config->aggr_get_id))
+                return;
+
+        aggr_update_shadow(config, evlist);
+
+        /*
+         * With metric_only everything is on a single line.
+         * Without each counter has its own line.
+         */
+        for (s = 0; s < config->aggr_map->nr; s++) {
+                struct aggr_data ad;
+                if (prefix && metric_only)
+                        fprintf(output, "%s", prefix);
+
+                ad.id = id = config->aggr_map->map[s];
+                first = true;
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+
+                        ad.val = ad.ena = ad.run = 0;
+                        ad.nr = 0;
+                        if (!collect_data(config, counter, aggr_cb, &ad))
+                                continue;
+                        nr = ad.nr;
+                        ena = ad.ena;
+                        run = ad.run;
+                        val = ad.val;
+                        if (first && metric_only) {
+                                first = false;
+                                aggr_printout(config, counter, id, nr);
+                        }
+                        if (prefix && !metric_only)
+                                fprintf(output, "%s", prefix);
+
+                        uval = val * counter->scale;
+                        printout(config, id, nr, counter, uval, prefix,
+                                 run, ena, 1.0, &rt_stat);
+                        if (!metric_only)
+                                fputc('\n', output);
+                }
+                if (metric_only)
+                        fputc('\n', output);
+        }
+}
+
+static int cmp_val(const void *a, const void *b)
+{
+        return ((struct perf_aggr_thread_value *)b)->val -
+                ((struct perf_aggr_thread_value *)a)->val;
+}
+
+static struct perf_aggr_thread_value *sort_aggr_thread(
+                                        struct perf_evsel *counter,
+                                        int nthreads, int ncpus,
+                                        int *ret,
+                                        struct target *_target)
+{
+        int cpu, thread, i = 0;
+        double uval;
+        struct perf_aggr_thread_value *buf;
+
+        buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
+        if (!buf)
+                return NULL;
+
+        for (thread = 0; thread < nthreads; thread++) {
+                u64 ena = 0, run = 0, val = 0;
+
+                for (cpu = 0; cpu < ncpus; cpu++) {
+                        val += perf_counts(counter->counts, cpu, thread)->val;
+                        ena += perf_counts(counter->counts, cpu, thread)->ena;
+                        run += perf_counts(counter->counts, cpu, thread)->run;
+                }
+
+                uval = val * counter->scale;
+
+                /*
+                 * Skip value 0 when enabling --per-thread globally,
+                 * otherwise too many 0 output.
+                 */
+                if (uval == 0.0 && target__has_per_thread(_target))
+                        continue;
+
+                buf[i].counter = counter;
+                buf[i].id = thread;
+                buf[i].uval = uval;
+                buf[i].val = val;
+                buf[i].run = run;
+                buf[i].ena = ena;
+                i++;
+        }
+
+        qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);
+
+        if (ret)
+                *ret = i;
+
+        return buf;
+}
+
+static void print_aggr_thread(struct perf_stat_config *config,
+                              struct target *_target,
+                              struct perf_evsel *counter, char *prefix)
+{
+        FILE *output = config->output;
+        int nthreads = thread_map__nr(counter->threads);
+        int ncpus = cpu_map__nr(counter->cpus);
+        int thread, sorted_threads, id;
+        struct perf_aggr_thread_value *buf;
+
+        buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads, _target);
+        if (!buf) {
+                perror("cannot sort aggr thread");
+                return;
+        }
+
+        for (thread = 0; thread < sorted_threads; thread++) {
+                if (prefix)
+                        fprintf(output, "%s", prefix);
+
+                id = buf[thread].id;
+                if (config->stats)
+                        printout(config, id, 0, buf[thread].counter, buf[thread].uval,
+                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
+                                 &config->stats[id]);
+                else
+                        printout(config, id, 0, buf[thread].counter, buf[thread].uval,
+                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
+                                 &rt_stat);
+                fputc('\n', output);
+        }
+
+        free(buf);
+}
+
+struct caggr_data {
+        double avg, avg_enabled, avg_running;
+};
+
+static void counter_aggr_cb(struct perf_stat_config *config __maybe_unused,
+                            struct perf_evsel *counter, void *data,
+                            bool first __maybe_unused)
+{
+        struct caggr_data *cd = data;
+        struct perf_stat_evsel *ps = counter->stats;
+
+        cd->avg += avg_stats(&ps->res_stats[0]);
+        cd->avg_enabled += avg_stats(&ps->res_stats[1]);
+        cd->avg_running += avg_stats(&ps->res_stats[2]);
+}
+
+/*
+ * Print out the results of a single counter:
+ * aggregated counts in system-wide mode
+ */
+static void print_counter_aggr(struct perf_stat_config *config,
+                               struct perf_evsel *counter, char *prefix)
+{
+        bool metric_only = config->metric_only;
+        FILE *output = config->output;
+        double uval;
+        struct caggr_data cd = { .avg = 0.0 };
+
+        if (!collect_data(config, counter, counter_aggr_cb, &cd))
+                return;
+
+        if (prefix && !metric_only)
+                fprintf(output, "%s", prefix);
+
+        uval = cd.avg * counter->scale;
+        printout(config, -1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
+                 cd.avg, &rt_stat);
+        if (!metric_only)
+                fprintf(output, "\n");
+}
+
+static void counter_cb(struct perf_stat_config *config __maybe_unused,
+                       struct perf_evsel *counter, void *data,
+                       bool first __maybe_unused)
+{
+        struct aggr_data *ad = data;
+
+        ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
+        ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
+        ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
+}
+
+/*
+ * Print out the results of a single counter:
+ * does not use aggregated count in system-wide
+ */
+static void print_counter(struct perf_stat_config *config,
+                          struct perf_evsel *counter, char *prefix)
+{
+        FILE *output = config->output;
+        u64 ena, run, val;
+        double uval;
+        int cpu;
+
+        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                struct aggr_data ad = { .cpu = cpu };
+
+                if (!collect_data(config, counter, counter_cb, &ad))
+                        return;
+                val = ad.val;
+                ena = ad.ena;
+                run = ad.run;
+
+                if (prefix)
+                        fprintf(output, "%s", prefix);
+
+                uval = val * counter->scale;
+                printout(config, cpu, 0, counter, uval, prefix, run, ena, 1.0,
+                         &rt_stat);
+
+                fputc('\n', output);
+        }
+}
+
+static void print_no_aggr_metric(struct perf_stat_config *config,
+                                 struct perf_evlist *evlist,
+                                 char *prefix)
+{
+        int cpu;
+        int nrcpus = 0;
+        struct perf_evsel *counter;
+        u64 ena, run, val;
+        double uval;
+
+        nrcpus = evlist->cpus->nr;
+        for (cpu = 0; cpu < nrcpus; cpu++) {
+                bool first = true;
+
+                if (prefix)
+                        fputs(prefix, config->output);
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+                        if (first) {
+                                aggr_printout(config, counter, cpu, 0);
+                                first = false;
+                        }
+                        val = perf_counts(counter->counts, cpu, 0)->val;
+                        ena = perf_counts(counter->counts, cpu, 0)->ena;
+                        run = perf_counts(counter->counts, cpu, 0)->run;
+
+                        uval = val * counter->scale;
+                        printout(config, cpu, 0, counter, uval, prefix, run, ena, 1.0,
+                                 &rt_stat);
+                }
+                fputc('\n', config->output);
+        }
+}
+
+static int aggr_header_lens[] = {
+        [AGGR_CORE] = 18,
+        [AGGR_SOCKET] = 12,
+        [AGGR_NONE] = 6,
+        [AGGR_THREAD] = 24,
+        [AGGR_GLOBAL] = 0,
+};
+
+static const char *aggr_header_csv[] = {
+        [AGGR_CORE]     =       "core,cpus,",
+        [AGGR_SOCKET]   =       "socket,cpus",
+        [AGGR_NONE]     =       "cpu,",
+        [AGGR_THREAD]   =       "comm-pid,",
+        [AGGR_GLOBAL]   =       ""
+};
+
+static void print_metric_headers(struct perf_stat_config *config,
+                                 struct perf_evlist *evlist,
+                                 const char *prefix, bool no_indent)
+{
+        struct perf_stat_output_ctx out;
+        struct perf_evsel *counter;
+        struct outstate os = {
+                .fh = config->output
+        };
+
+        if (prefix)
+                fprintf(config->output, "%s", prefix);
+
+        if (!config->csv_output && !no_indent)
+                fprintf(config->output, "%*s",
+                        aggr_header_lens[config->aggr_mode], "");
+        if (config->csv_output) {
+                if (config->interval)
+                        fputs("time,", config->output);
+                fputs(aggr_header_csv[config->aggr_mode], config->output);
+        }
+
+        /* Print metrics headers only */
+        evlist__for_each_entry(evlist, counter) {
+                if (is_duration_time(counter))
+                        continue;
+                os.evsel = counter;
+                out.ctx = &os;
+                out.print_metric = print_metric_header;
+                out.new_line = new_line_metric;
+                out.force_header = true;
+                os.evsel = counter;
+                perf_stat__print_shadow_stats(config, counter, 0,
+                                              0,
+                                              &out,
+                                              &config->metric_events,
+                                              &rt_stat);
+        }
+        fputc('\n', config->output);
+}
+
+static void print_interval(struct perf_stat_config *config,
+                           struct perf_evlist *evlist,
+                           char *prefix, struct timespec *ts)
+{
+        bool metric_only = config->metric_only;
+        unsigned int unit_width = config->unit_width;
+        FILE *output = config->output;
+        static int num_print_interval;
+
+        if (config->interval_clear)
+                puts(CONSOLE_CLEAR);
+
+        sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, config->csv_sep);
+
+        if ((num_print_interval == 0 && !config->csv_output) || config->interval_clear) {
+                switch (config->aggr_mode) {
+                case AGGR_SOCKET:
+                        fprintf(output, "#           time socket cpus");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_CORE:
+                        fprintf(output, "#           time core         cpus");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_NONE:
+                        fprintf(output, "#           time CPU    ");
+                        if (!metric_only)
+                                fprintf(output, "                counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_THREAD:
+                        fprintf(output, "#           time             comm-pid");
+                        if (!metric_only)
+                                fprintf(output, "                  counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_GLOBAL:
+                default:
+                        fprintf(output, "#           time");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
+                case AGGR_UNSET:
+                        break;
+                }
+        }
+
+        if ((num_print_interval == 0 || config->interval_clear) && metric_only)
+                print_metric_headers(config, evlist, " ", true);
+        if (++num_print_interval == 25)
+                num_print_interval = 0;
+}
+
+static void print_header(struct perf_stat_config *config,
+                         struct target *_target,
+                         int argc, const char **argv)
+{
+        FILE *output = config->output;
+        int i;
+
+        fflush(stdout);
+
+        if (!config->csv_output) {
+                fprintf(output, "\n");
+                fprintf(output, " Performance counter stats for ");
+                if (_target->system_wide)
+                        fprintf(output, "\'system wide");
+                else if (_target->cpu_list)
+                        fprintf(output, "\'CPU(s) %s", _target->cpu_list);
+                else if (!target__has_task(_target)) {
+                        fprintf(output, "\'%s", argv ? argv[0] : "pipe");
+                        for (i = 1; argv && (i < argc); i++)
+                                fprintf(output, " %s", argv[i]);
+                } else if (_target->pid)
+                        fprintf(output, "process id \'%s", _target->pid);
+                else
+                        fprintf(output, "thread id \'%s", _target->tid);
+
+                fprintf(output, "\'");
+                if (config->run_count > 1)
+                        fprintf(output, " (%d runs)", config->run_count);
+                fprintf(output, ":\n\n");
+        }
+}
+
+static int get_precision(double num)
+{
+        if (num > 1)
+                return 0;
+
+        return lround(ceil(-log10(num)));
+}
+
+static void print_table(struct perf_stat_config *config,
+                        FILE *output, int precision, double avg)
+{
+        char tmp[64];
+        int idx, indent = 0;
+
+        scnprintf(tmp, 64, " %17.*f", precision, avg);
+        while (tmp[indent] == ' ')
+                indent++;
+
+        fprintf(output, "%*s# Table of individual measurements:\n", indent, "");
+
+        for (idx = 0; idx < config->run_count; idx++) {
+                double run = (double) config->walltime_run[idx] / NSEC_PER_SEC;
+                int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
+
+                fprintf(output, " %17.*f (%+.*f) ",
+                        precision, run, precision, run - avg);
+
+                for (h = 0; h < n; h++)
+                        fprintf(output, "#");
+
+                fprintf(output, "\n");
+        }
+
+        fprintf(output, "\n%*s# Final result:\n", indent, "");
+}
+
+static double timeval2double(struct timeval *t)
+{
+        return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
+}
+
+static void print_footer(struct perf_stat_config *config)
+{
+        double avg = avg_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
+        FILE *output = config->output;
+        int n;
+
+        if (!config->null_run)
+                fprintf(output, "\n");
+
+        if (config->run_count == 1) {
+                fprintf(output, " %17.9f seconds time elapsed", avg);
+
+                if (config->ru_display) {
+                        double ru_utime = timeval2double(&config->ru_data.ru_utime);
+                        double ru_stime = timeval2double(&config->ru_data.ru_stime);
+
+                        fprintf(output, "\n\n");
+                        fprintf(output, " %17.9f seconds user\n", ru_utime);
+                        fprintf(output, " %17.9f seconds sys\n", ru_stime);
+                }
+        } else {
+                double sd = stddev_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
+                /*
+                 * Display at most 2 more significant
+                 * digits than the stddev inaccuracy.
+                 */
+                int precision = get_precision(sd) + 2;
+
+                if (config->walltime_run_table)
+                        print_table(config, output, precision, avg);
+
+                fprintf(output, " %17.*f +- %.*f seconds time elapsed",
+                        precision, avg, precision, sd);
+
+                print_noise_pct(config, sd, avg);
+        }
+        fprintf(output, "\n\n");
+
+        if (config->print_free_counters_hint &&
+            sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
+            n > 0)
+                fprintf(output,
+"Some events weren't counted. Try disabling the NMI watchdog:\n"
+"       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
+"       perf stat ...\n"
+"       echo 1 > /proc/sys/kernel/nmi_watchdog\n");
+
+        if (config->print_mixed_hw_group_error)
+                fprintf(output,
+                        "The events in group usually have to be from "
+                        "the same PMU. Try reorganizing the group.\n");
+}
+
+void
+perf_evlist__print_counters(struct perf_evlist *evlist,
+                            struct perf_stat_config *config,
+                            struct target *_target,
+                            struct timespec *ts,
+                            int argc, const char **argv)
+{
+        bool metric_only = config->metric_only;
+        int interval = config->interval;
+        struct perf_evsel *counter;
+        char buf[64], *prefix = NULL;
+
+        if (interval)
+                print_interval(config, evlist, prefix = buf, ts);
+        else
+                print_header(config, _target, argc, argv);
+
+        if (metric_only) {
+                static int num_print_iv;
+
+                if (num_print_iv == 0 && !interval)
+                        print_metric_headers(config, evlist, prefix, false);
+                if (num_print_iv++ == 25)
+                        num_print_iv = 0;
+                if (config->aggr_mode == AGGR_GLOBAL && prefix)
+                        fprintf(config->output, "%s", prefix);
+        }
+
+        switch (config->aggr_mode) {
+        case AGGR_CORE:
+        case AGGR_SOCKET:
+                print_aggr(config, evlist, prefix);
+                break;
+        case AGGR_THREAD:
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+                        print_aggr_thread(config, _target, counter, prefix);
+                }
+                break;
+        case AGGR_GLOBAL:
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+                        print_counter_aggr(config, counter, prefix);
+                }
+                if (metric_only)
+                        fputc('\n', config->output);
+                break;
+        case AGGR_NONE:
+                if (metric_only)
+                        print_no_aggr_metric(config, evlist, prefix);
+                else {
+                        evlist__for_each_entry(evlist, counter) {
+                                if (is_duration_time(counter))
+                                        continue;
+                                print_counter(config, counter, prefix);
+                        }
+                }
+                break;
+        case AGGR_UNSET:
+        default:
+                break;
+        }
+
+        if (!interval && !config->csv_output)
+                print_footer(config);
+
+        fflush(config->output);
+}
diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index 99990f5f2512..8ad32763cfff 100644
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -410,7 +410,8 @@ static double runtime_stat_n(struct runtime_stat *st,
         return v->stats.n;
 }
 
-static void print_stalled_cycles_frontend(int cpu,
+static void print_stalled_cycles_frontend(struct perf_stat_config *config,
+                                          int cpu,
                                           struct perf_evsel *evsel, double avg,
                                           struct perf_stat_output_ctx *out,
                                           struct runtime_stat *st)
@@ -427,13 +428,14 @@ static void print_stalled_cycles_frontend(int cpu,
         color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
 
         if (ratio)
-                out->print_metric(out->ctx, color, "%7.2f%%", "frontend cycles idle",
+                out->print_metric(config, out->ctx, color, "%7.2f%%", "frontend cycles idle",
                                   ratio);
         else
-                out->print_metric(out->ctx, NULL, NULL, "frontend cycles idle", 0);
+                out->print_metric(config, out->ctx, NULL, NULL, "frontend cycles idle", 0);
 }
 
-static void print_stalled_cycles_backend(int cpu,
+static void print_stalled_cycles_backend(struct perf_stat_config *config,
+                                         int cpu,
                                          struct perf_evsel *evsel, double avg,
                                          struct perf_stat_output_ctx *out,
                                          struct runtime_stat *st)
@@ -449,10 +451,11 @@ static void print_stalled_cycles_backend(int cpu,
 
         color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
 
-        out->print_metric(out->ctx, color, "%7.2f%%", "backend cycles idle", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "backend cycles idle", ratio);
 }
 
-static void print_branch_misses(int cpu,
+static void print_branch_misses(struct perf_stat_config *config,
+                                int cpu,
                                 struct perf_evsel *evsel,
                                 double avg,
                                 struct perf_stat_output_ctx *out,
@@ -469,10 +472,11 @@ static void print_branch_misses(int cpu,
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all branches", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all branches", ratio);
 }
 
-static void print_l1_dcache_misses(int cpu,
+static void print_l1_dcache_misses(struct perf_stat_config *config,
+                                   int cpu,
                                    struct perf_evsel *evsel,
                                    double avg,
                                    struct perf_stat_output_ctx *out,
@@ -490,10 +494,11 @@ static void print_l1_dcache_misses(int cpu,
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all L1-dcache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all L1-dcache hits", ratio);
 }
 
-static void print_l1_icache_misses(int cpu,
+static void print_l1_icache_misses(struct perf_stat_config *config,
+                                   int cpu,
                                    struct perf_evsel *evsel,
                                    double avg,
                                    struct perf_stat_output_ctx *out,
@@ -510,10 +515,11 @@ static void print_l1_icache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all L1-icache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all L1-icache hits", ratio);
 }
 
-static void print_dtlb_cache_misses(int cpu,
+static void print_dtlb_cache_misses(struct perf_stat_config *config,
+                                    int cpu,
                                     struct perf_evsel *evsel,
                                     double avg,
                                     struct perf_stat_output_ctx *out,
@@ -529,10 +535,11 @@ static void print_dtlb_cache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all dTLB cache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all dTLB cache hits", ratio);
 }
 
-static void print_itlb_cache_misses(int cpu,
+static void print_itlb_cache_misses(struct perf_stat_config *config,
+                                    int cpu,
                                     struct perf_evsel *evsel,
                                     double avg,
                                     struct perf_stat_output_ctx *out,
@@ -548,10 +555,11 @@ static void print_itlb_cache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all iTLB cache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all iTLB cache hits", ratio);
 }
 
-static void print_ll_cache_misses(int cpu,
+static void print_ll_cache_misses(struct perf_stat_config *config,
+                                  int cpu,
                                   struct perf_evsel *evsel,
                                   double avg,
                                   struct perf_stat_output_ctx *out,
@@ -567,7 +575,7 @@ static void print_ll_cache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all LL-cache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all LL-cache hits", ratio);
 }
 
 /*
@@ -674,7 +682,8 @@ static double td_be_bound(int ctx, int cpu, struct runtime_stat *st)
         return sanitize_val(1.0 - sum);
 }
 
-static void print_smi_cost(int cpu, struct perf_evsel *evsel,
+static void print_smi_cost(struct perf_stat_config *config,
+                           int cpu, struct perf_evsel *evsel,
                            struct perf_stat_output_ctx *out,
                            struct runtime_stat *st)
 {
@@ -694,11 +703,12 @@ static void print_smi_cost(int cpu, struct perf_evsel *evsel,
 
         if (cost > 10)
                 color = PERF_COLOR_RED;
-        out->print_metric(out->ctx, color, "%8.1f%%", "SMI cycles%", cost);
-        out->print_metric(out->ctx, NULL, "%4.0f", "SMI#", smi_num);
+        out->print_metric(config, out->ctx, color, "%8.1f%%", "SMI cycles%", cost);
+        out->print_metric(config, out->ctx, NULL, "%4.0f", "SMI#", smi_num);
 }
 
-static void generic_metric(const char *metric_expr,
+static void generic_metric(struct perf_stat_config *config,
+                           const char *metric_expr,
                            struct perf_evsel **metric_events,
                            char *name,
                            const char *metric_name,
@@ -737,20 +747,21 @@ static void generic_metric(const char *metric_expr,
                 const char *p = metric_expr;
 
                 if (expr__parse(&ratio, &pctx, &p) == 0)
-                        print_metric(ctxp, NULL, "%8.1f",
+                        print_metric(config, ctxp, NULL, "%8.1f",
                                 metric_name ?
                                 metric_name :
                                 out->force_header ?  name : "",
                                 ratio);
                 else
-                        print_metric(ctxp, NULL, NULL,
+                        print_metric(config, ctxp, NULL, NULL,
                                      out->force_header ?
                                      (metric_name ? metric_name : name) : "", 0);
         } else
-                print_metric(ctxp, NULL, NULL, "", 0);
+                print_metric(config, ctxp, NULL, NULL, "", 0);
 }
 
-void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
+void perf_stat__print_shadow_stats(struct perf_stat_config *config,
+                                   struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out,
                                    struct rblist *metric_events,
@@ -769,10 +780,10 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
 
                 if (total) {
                         ratio = avg / total;
-                        print_metric(ctxp, NULL, "%7.2f ",
+                        print_metric(config, ctxp, NULL, "%7.2f ",
                                         "insn per cycle", ratio);
                 } else {
-                        print_metric(ctxp, NULL, NULL, "insn per cycle", 0);
+                        print_metric(config, ctxp, NULL, NULL, "insn per cycle", 0);
                 }
 
                 total = runtime_stat_avg(st, STAT_STALLED_CYCLES_FRONT,
@@ -783,20 +794,20 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                                     ctx, cpu));
 
                 if (total && avg) {
-                        out->new_line(ctxp);
+                        out->new_line(config, ctxp);
                         ratio = total / avg;
-                        print_metric(ctxp, NULL, "%7.2f ",
+                        print_metric(config, ctxp, NULL, "%7.2f ",
                                         "stalled cycles per insn",
                                         ratio);
                 } else if (have_frontend_stalled) {
-                        print_metric(ctxp, NULL, NULL,
+                        print_metric(config, ctxp, NULL, NULL,
                                      "stalled cycles per insn", 0);
                 }
         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES)) {
                 if (runtime_stat_n(st, STAT_BRANCHES, ctx, cpu) != 0)
-                        print_branch_misses(cpu, evsel, avg, out, st);
+                        print_branch_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all branches", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all branches", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
@@ -804,9 +815,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_L1_DCACHE, ctx, cpu) != 0)
-                        print_l1_dcache_misses(cpu, evsel, avg, out, st);
+                        print_l1_dcache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all L1-dcache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all L1-dcache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
@@ -814,9 +825,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_L1_ICACHE, ctx, cpu) != 0)
-                        print_l1_icache_misses(cpu, evsel, avg, out, st);
+                        print_l1_icache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all L1-icache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all L1-icache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
@@ -824,9 +835,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_DTLB_CACHE, ctx, cpu) != 0)
-                        print_dtlb_cache_misses(cpu, evsel, avg, out, st);
+                        print_dtlb_cache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all dTLB cache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all dTLB cache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
@@ -834,9 +845,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_ITLB_CACHE, ctx, cpu) != 0)
-                        print_itlb_cache_misses(cpu, evsel, avg, out, st);
+                        print_itlb_cache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all iTLB cache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all iTLB cache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
@@ -844,9 +855,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_LL_CACHE, ctx, cpu) != 0)
-                        print_ll_cache_misses(cpu, evsel, avg, out, st);
+                        print_ll_cache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all LL-cache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all LL-cache hits", 0);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES)) {
                 total = runtime_stat_avg(st, STAT_CACHEREFS, ctx, cpu);
 
@@ -854,32 +865,32 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                         ratio = avg * 100 / total;
 
                 if (runtime_stat_n(st, STAT_CACHEREFS, ctx, cpu) != 0)
-                        print_metric(ctxp, NULL, "%8.3f %%",
+                        print_metric(config, ctxp, NULL, "%8.3f %%",
                                      "of all cache refs", ratio);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all cache refs", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all cache refs", 0);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
-                print_stalled_cycles_frontend(cpu, evsel, avg, out, st);
+                print_stalled_cycles_frontend(config, cpu, evsel, avg, out, st);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
-                print_stalled_cycles_backend(cpu, evsel, avg, out, st);
+                print_stalled_cycles_backend(config, cpu, evsel, avg, out, st);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
                 total = runtime_stat_avg(st, STAT_NSECS, 0, cpu);
 
                 if (total) {
                         ratio = avg / total;
-                        print_metric(ctxp, NULL, "%8.3f", "GHz", ratio);
+                        print_metric(config, ctxp, NULL, "%8.3f", "GHz", ratio);
                 } else {
-                        print_metric(ctxp, NULL, NULL, "Ghz", 0);
+                        print_metric(config, ctxp, NULL, NULL, "Ghz", 0);
                 }
         } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) {
                 total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
 
                 if (total)
-                        print_metric(ctxp, NULL,
+                        print_metric(config, ctxp, NULL,
                                         "%7.2f%%", "transactional cycles",
                                         100.0 * (avg / total));
                 else
-                        print_metric(ctxp, NULL, NULL, "transactional cycles",
+                        print_metric(config, ctxp, NULL, NULL, "transactional cycles",
                                      0);
         } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) {
                 total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
@@ -888,10 +899,10 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 if (total2 < avg)
                         total2 = avg;
                 if (total)
-                        print_metric(ctxp, NULL, "%7.2f%%", "aborted cycles",
+                        print_metric(config, ctxp, NULL, "%7.2f%%", "aborted cycles",
                                 100.0 * ((total2-avg) / total));
                 else
-                        print_metric(ctxp, NULL, NULL, "aborted cycles", 0);
+                        print_metric(config, ctxp, NULL, NULL, "aborted cycles", 0);
         } else if (perf_stat_evsel__is(evsel, TRANSACTION_START)) {
                 total = runtime_stat_avg(st, STAT_CYCLES_IN_TX,
                                          ctx, cpu);
@@ -900,10 +911,10 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                         ratio = total / avg;
 
                 if (runtime_stat_n(st, STAT_CYCLES_IN_TX, ctx, cpu) != 0)
-                        print_metric(ctxp, NULL, "%8.0f",
+                        print_metric(config, ctxp, NULL, "%8.0f",
                                      "cycles / transaction", ratio);
                 else
-                        print_metric(ctxp, NULL, NULL, "cycles / transaction",
+                        print_metric(config, ctxp, NULL, NULL, "cycles / transaction",
                                       0);
         } else if (perf_stat_evsel__is(evsel, ELISION_START)) {
                 total = runtime_stat_avg(st, STAT_CYCLES_IN_TX,
@@ -912,33 +923,33 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 if (avg)
                         ratio = total / avg;
 
-                print_metric(ctxp, NULL, "%8.0f", "cycles / elision", ratio);
+                print_metric(config, ctxp, NULL, "%8.0f", "cycles / elision", ratio);
         } else if (perf_evsel__is_clock(evsel)) {
                 if ((ratio = avg_stats(&walltime_nsecs_stats)) != 0)
-                        print_metric(ctxp, NULL, "%8.3f", "CPUs utilized",
+                        print_metric(config, ctxp, NULL, "%8.3f", "CPUs utilized",
                                      avg / (ratio * evsel->scale));
                 else
-                        print_metric(ctxp, NULL, NULL, "CPUs utilized", 0);
+                        print_metric(config, ctxp, NULL, NULL, "CPUs utilized", 0);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_FETCH_BUBBLES)) {
                 double fe_bound = td_fe_bound(ctx, cpu, st);
 
                 if (fe_bound > 0.2)
                         color = PERF_COLOR_RED;
-                print_metric(ctxp, color, "%8.1f%%", "frontend bound",
+                print_metric(config, ctxp, color, "%8.1f%%", "frontend bound",
                                 fe_bound * 100.);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_RETIRED)) {
                 double retiring = td_retiring(ctx, cpu, st);
 
                 if (retiring > 0.7)
                         color = PERF_COLOR_GREEN;
-                print_metric(ctxp, color, "%8.1f%%", "retiring",
+                print_metric(config, ctxp, color, "%8.1f%%", "retiring",
                                 retiring * 100.);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_RECOVERY_BUBBLES)) {
                 double bad_spec = td_bad_spec(ctx, cpu, st);
 
                 if (bad_spec > 0.1)
                         color = PERF_COLOR_RED;
-                print_metric(ctxp, color, "%8.1f%%", "bad speculation",
+                print_metric(config, ctxp, color, "%8.1f%%", "bad speculation",
                                 bad_spec * 100.);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_ISSUED)) {
                 double be_bound = td_be_bound(ctx, cpu, st);
@@ -955,12 +966,12 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 if (be_bound > 0.2)
                         color = PERF_COLOR_RED;
                 if (td_total_slots(ctx, cpu, st) > 0)
-                        print_metric(ctxp, color, "%8.1f%%", name,
+                        print_metric(config, ctxp, color, "%8.1f%%", name,
                                         be_bound * 100.);
                 else
-                        print_metric(ctxp, NULL, NULL, name, 0);
+                        print_metric(config, ctxp, NULL, NULL, name, 0);
         } else if (evsel->metric_expr) {
-                generic_metric(evsel->metric_expr, evsel->metric_events, evsel->name,
+                generic_metric(config, evsel->metric_expr, evsel->metric_events, evsel->name,
                                 evsel->metric_name, avg, cpu, out, st);
         } else if (runtime_stat_n(st, STAT_NSECS, 0, cpu) != 0) {
                 char unit = 'M';
@@ -975,9 +986,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                         unit = 'K';
                 }
                 snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit);
-                print_metric(ctxp, NULL, "%8.3f", unit_buf, ratio);
+                print_metric(config, ctxp, NULL, "%8.3f", unit_buf, ratio);
         } else if (perf_stat_evsel__is(evsel, SMI_NUM)) {
-                print_smi_cost(cpu, evsel, out, st);
+                print_smi_cost(config, cpu, evsel, out, st);
         } else {
                 num = 0;
         }
@@ -987,12 +998,12 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
 
                 list_for_each_entry (mexp, &me->head, nd) {
                         if (num++ > 0)
-                                out->new_line(ctxp);
-                        generic_metric(mexp->metric_expr, mexp->metric_events,
+                                out->new_line(config, ctxp);
+                        generic_metric(config, mexp->metric_expr, mexp->metric_events,
                                         evsel->name, mexp->metric_name,
                                         avg, cpu, out, st);
                 }
         }
         if (num == 0)
-                print_metric(ctxp, NULL, NULL, NULL, 0);
+                print_metric(config, ctxp, NULL, NULL, NULL, 0);
 }
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index a0061e0b0fad..4d40515307b8 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -374,9 +374,8 @@ int perf_stat_process_counter(struct perf_stat_config *config,
         return 0;
 }
 
-int perf_event__process_stat_event(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event,
-                                   struct perf_session *session)
+int perf_event__process_stat_event(struct perf_session *session,
+                                   union perf_event *event)
 {
         struct perf_counts_values count;
         struct stat_event *st = &event->stat;
@@ -435,3 +434,98 @@ size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp)
 
         return ret;
 }
+
+int create_perf_stat_counter(struct perf_evsel *evsel,
+                             struct perf_stat_config *config,
+                             struct target *target)
+{
+        struct perf_event_attr *attr = &evsel->attr;
+        struct perf_evsel *leader = evsel->leader;
+
+        if (config->scale) {
+                attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
+                                    PERF_FORMAT_TOTAL_TIME_RUNNING;
+        }
+
+        /*
+         * The event is part of non trivial group, let's enable
+         * the group read (for leader) and ID retrieval for all
+         * members.
+         */
+        if (leader->nr_members > 1)
+                attr->read_format |= PERF_FORMAT_ID|PERF_FORMAT_GROUP;
+
+        attr->inherit = !config->no_inherit;
+
+        /*
+         * Some events get initialized with sample_(period/type) set,
+         * like tracepoints. Clear it up for counting.
+         */
+        attr->sample_period = 0;
+
+        if (config->identifier)
+                attr->sample_type = PERF_SAMPLE_IDENTIFIER;
+
+        /*
+         * Disabling all counters initially, they will be enabled
+         * either manually by us or by kernel via enable_on_exec
+         * set later.
+         */
+        if (perf_evsel__is_group_leader(evsel)) {
+                attr->disabled = 1;
+
+                /*
+                 * In case of initial_delay we enable tracee
+                 * events manually.
+                 */
+                if (target__none(target) && !config->initial_delay)
+                        attr->enable_on_exec = 1;
+        }
+
+        if (target__has_cpu(target) && !target__has_per_thread(target))
+                return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
+
+        return perf_evsel__open_per_thread(evsel, evsel->threads);
+}
+
+int perf_stat_synthesize_config(struct perf_stat_config *config,
+                                struct perf_tool *tool,
+                                struct perf_evlist *evlist,
+                                perf_event__handler_t process,
+                                bool attrs)
+{
+        int err;
+
+        if (attrs) {
+                err = perf_event__synthesize_attrs(tool, evlist, process);
+                if (err < 0) {
+                        pr_err("Couldn't synthesize attrs.\n");
+                        return err;
+                }
+        }
+
+        err = perf_event__synthesize_extra_attr(tool, evlist, process,
+                                                attrs);
+
+        err = perf_event__synthesize_thread_map2(tool, evlist->threads,
+                                                 process, NULL);
+        if (err < 0) {
+                pr_err("Couldn't synthesize thread map.\n");
+                return err;
+        }
+
+        err = perf_event__synthesize_cpu_map(tool, evlist->cpus,
+                                             process, NULL);
+        if (err < 0) {
+                pr_err("Couldn't synthesize thread map.\n");
+                return err;
+        }
+
+        err = perf_event__synthesize_stat_config(tool, config, process, NULL);
+        if (err < 0) {
+                pr_err("Couldn't synthesize config.\n");
+                return err;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
index 36efb986f7fc..2f9c9159a364 100644
--- a/tools/perf/util/stat.h
+++ b/tools/perf/util/stat.h
@@ -4,8 +4,14 @@
 
 #include <linux/types.h>
 #include <stdio.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
 #include "xyarray.h"
 #include "rblist.h"
+#include "perf.h"
+#include "event.h"
 
 struct stats {
         double n, mean, M2;
@@ -84,15 +90,42 @@ struct runtime_stat {
         struct rblist value_list;
 };
 
+typedef int (*aggr_get_id_t)(struct perf_stat_config *config,
+                             struct cpu_map *m, int cpu);
+
 struct perf_stat_config {
-        enum aggr_mode  aggr_mode;
-        bool            scale;
-        FILE            *output;
-        unsigned int    interval;
-        unsigned int    timeout;
-        int             times;
-        struct runtime_stat *stats;
-        int             stats_num;
+        enum aggr_mode           aggr_mode;
+        bool                     scale;
+        bool                     no_inherit;
+        bool                     identifier;
+        bool                     csv_output;
+        bool                     interval_clear;
+        bool                     metric_only;
+        bool                     null_run;
+        bool                     ru_display;
+        bool                     big_num;
+        bool                     no_merge;
+        bool                     walltime_run_table;
+        FILE                    *output;
+        unsigned int             interval;
+        unsigned int             timeout;
+        unsigned int             initial_delay;
+        unsigned int             unit_width;
+        unsigned int             metric_only_len;
+        int                      times;
+        int                      run_count;
+        int                      print_free_counters_hint;
+        int                      print_mixed_hw_group_error;
+        struct runtime_stat     *stats;
+        int                      stats_num;
+        const char              *csv_sep;
+        struct stats            *walltime_nsecs_stats;
+        struct rusage            ru_data;
+        struct cpu_map          *aggr_map;
+        aggr_get_id_t            aggr_get_id;
+        struct cpu_map          *cpus_aggr_map;
+        u64                     *walltime_run;
+        struct rblist            metric_events;
 };
 
 void update_stats(struct stats *stats, u64 val);
@@ -130,9 +163,10 @@ bool __perf_evsel_stat__is(struct perf_evsel *evsel,
 extern struct runtime_stat rt_stat;
 extern struct stats walltime_nsecs_stats;
 
-typedef void (*print_metric_t)(void *ctx, const char *color, const char *unit,
+typedef void (*print_metric_t)(struct perf_stat_config *config,
+                               void *ctx, const char *color, const char *unit,
                                const char *fmt, double val);
-typedef void (*new_line_t )(void *ctx);
+typedef void (*new_line_t)(struct perf_stat_config *config, void *ctx);
 
 void runtime_stat__init(struct runtime_stat *st);
 void runtime_stat__exit(struct runtime_stat *st);
@@ -148,7 +182,8 @@ struct perf_stat_output_ctx {
         bool force_header;
 };
 
-void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
+void perf_stat__print_shadow_stats(struct perf_stat_config *config,
+                                   struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out,
                                    struct rblist *metric_events,
@@ -164,11 +199,25 @@ int perf_stat_process_counter(struct perf_stat_config *config,
 struct perf_tool;
 union perf_event;
 struct perf_session;
-int perf_event__process_stat_event(struct perf_tool *tool,
-                                   union perf_event *event,
-                                   struct perf_session *session);
+int perf_event__process_stat_event(struct perf_session *session,
+                                   union perf_event *event);
 
 size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp);
+
+int create_perf_stat_counter(struct perf_evsel *evsel,
+                             struct perf_stat_config *config,
+                             struct target *target);
+int perf_stat_synthesize_config(struct perf_stat_config *config,
+                                struct perf_tool *tool,
+                                struct perf_evlist *evlist,
+                                perf_event__handler_t process,
+                                bool attrs);
+void
+perf_evlist__print_counters(struct perf_evlist *evlist,
+                            struct perf_stat_config *config,
+                            struct target *_target,
+                            struct timespec *ts,
+                            int argc, const char **argv);
 #endif
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 3d1cf5bf7f18..9005fbe0780e 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -98,19 +98,25 @@ static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap)
 
         va_copy(ap_saved, ap);
         len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
-        if (len < 0)
+        if (len < 0) {
+                va_end(ap_saved);
                 return len;
+        }
         if (len > strbuf_avail(sb)) {
                 ret = strbuf_grow(sb, len);
-                if (ret)
+                if (ret) {
+                        va_end(ap_saved);
                         return ret;
+                }
                 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved);
                 va_end(ap_saved);
                 if (len > strbuf_avail(sb)) {
                         pr_debug("this should not happen, your vsnprintf is broken");
+                        va_end(ap_saved);
                         return -EINVAL;
                 }
         }
+        va_end(ap_saved);
         return strbuf_setlen(sb, sb->len + len);
 }
 
diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c
index dd17d6a38d3a..c091635bf7dc 100644
--- a/tools/perf/util/thread-stack.c
+++ b/tools/perf/util/thread-stack.c
@@ -36,6 +36,7 @@
  * @branch_count: the branch count when the entry was created
  * @cp: call path
  * @no_call: a 'call' was not seen
+ * @trace_end: a 'call' but trace ended
  */
 struct thread_stack_entry {
         u64 ret_addr;
@@ -44,6 +45,7 @@ struct thread_stack_entry {
         u64 branch_count;
         struct call_path *cp;
         bool no_call;
+        bool trace_end;
 };
 
 /**
@@ -112,7 +114,8 @@ static struct thread_stack *thread_stack__new(struct thread *thread,
         return ts;
 }
 
-static int thread_stack__push(struct thread_stack *ts, u64 ret_addr)
+static int thread_stack__push(struct thread_stack *ts, u64 ret_addr,
+                              bool trace_end)
 {
         int err = 0;
 
@@ -124,6 +127,7 @@ static int thread_stack__push(struct thread_stack *ts, u64 ret_addr)
                 }
         }
 
+        ts->stack[ts->cnt].trace_end = trace_end;
         ts->stack[ts->cnt++].ret_addr = ret_addr;
 
         return err;
@@ -150,6 +154,18 @@ static void thread_stack__pop(struct thread_stack *ts, u64 ret_addr)
         }
 }
 
+static void thread_stack__pop_trace_end(struct thread_stack *ts)
+{
+        size_t i;
+
+        for (i = ts->cnt; i; ) {
+                if (ts->stack[--i].trace_end)
+                        ts->cnt = i;
+                else
+                        return;
+        }
+}
+
 static bool thread_stack__in_kernel(struct thread_stack *ts)
 {
         if (!ts->cnt)
@@ -254,10 +270,19 @@ int thread_stack__event(struct thread *thread, u32 flags, u64 from_ip,
                 ret_addr = from_ip + insn_len;
                 if (ret_addr == to_ip)
                         return 0; /* Zero-length calls are excluded */
-                return thread_stack__push(thread->ts, ret_addr);
-        } else if (flags & PERF_IP_FLAG_RETURN) {
-                if (!from_ip)
-                        return 0;
+                return thread_stack__push(thread->ts, ret_addr,
+                                          flags & PERF_IP_FLAG_TRACE_END);
+        } else if (flags & PERF_IP_FLAG_TRACE_BEGIN) {
+                /*
+                 * If the caller did not change the trace number (which would
+                 * have flushed the stack) then try to make sense of the stack.
+                 * Possibly, tracing began after returning to the current
+                 * address, so try to pop that. Also, do not expect a call made
+                 * when the trace ended, to return, so pop that.
+                 */
+                thread_stack__pop(thread->ts, to_ip);
+                thread_stack__pop_trace_end(thread->ts);
+        } else if ((flags & PERF_IP_FLAG_RETURN) && from_ip) {
                 thread_stack__pop(thread->ts, to_ip);
         }
 
@@ -332,7 +357,7 @@ void call_return_processor__free(struct call_return_processor *crp)
 
 static int thread_stack__push_cp(struct thread_stack *ts, u64 ret_addr,
                                  u64 timestamp, u64 ref, struct call_path *cp,
-                                 bool no_call)
+                                 bool no_call, bool trace_end)
 {
         struct thread_stack_entry *tse;
         int err;
@@ -350,6 +375,7 @@ static int thread_stack__push_cp(struct thread_stack *ts, u64 ret_addr,
         tse->branch_count = ts->branch_count;
         tse->cp = cp;
         tse->no_call = no_call;
+        tse->trace_end = trace_end;
 
         return 0;
 }
@@ -423,7 +449,7 @@ static int thread_stack__bottom(struct thread *thread, struct thread_stack *ts,
                 return -ENOMEM;
 
         return thread_stack__push_cp(thread->ts, ip, sample->time, ref, cp,
-                                     true);
+                                     true, false);
 }
 
 static int thread_stack__no_call_return(struct thread *thread,
@@ -455,7 +481,7 @@ static int thread_stack__no_call_return(struct thread *thread,
                         if (!cp)
                                 return -ENOMEM;
                         return thread_stack__push_cp(ts, 0, sample->time, ref,
-                                                     cp, true);
+                                                     cp, true, false);
                 }
         } else if (thread_stack__in_kernel(ts) && sample->ip < ks) {
                 /* Return to userspace, so pop all kernel addresses */
@@ -480,7 +506,7 @@ static int thread_stack__no_call_return(struct thread *thread,
                 return -ENOMEM;
 
         err = thread_stack__push_cp(ts, sample->addr, sample->time, ref, cp,
-                                    true);
+                                    true, false);
         if (err)
                 return err;
 
@@ -500,7 +526,7 @@ static int thread_stack__trace_begin(struct thread *thread,
 
         /* Pop trace end */
         tse = &ts->stack[ts->cnt - 1];
-        if (tse->cp->sym == NULL && tse->cp->ip == 0) {
+        if (tse->trace_end) {
                 err = thread_stack__call_return(thread, ts, --ts->cnt,
                                                 timestamp, ref, false);
                 if (err)
@@ -529,7 +555,7 @@ static int thread_stack__trace_end(struct thread_stack *ts,
         ret_addr = sample->ip + sample->insn_len;
 
         return thread_stack__push_cp(ts, ret_addr, sample->time, ref, cp,
-                                     false);
+                                     false, true);
 }
 
 int thread_stack__process(struct thread *thread, struct comm *comm,
@@ -579,6 +605,7 @@ int thread_stack__process(struct thread *thread, struct comm *comm,
         ts->last_time = sample->time;
 
         if (sample->flags & PERF_IP_FLAG_CALL) {
+                bool trace_end = sample->flags & PERF_IP_FLAG_TRACE_END;
                 struct call_path_root *cpr = ts->crp->cpr;
                 struct call_path *cp;
                 u64 ret_addr;
@@ -596,7 +623,7 @@ int thread_stack__process(struct thread *thread, struct comm *comm,
                 if (!cp)
                         return -ENOMEM;
                 err = thread_stack__push_cp(ts, ret_addr, sample->time, ref,
-                                            cp, false);
+                                            cp, false, trace_end);
         } else if (sample->flags & PERF_IP_FLAG_RETURN) {
                 if (!sample->ip || !sample->addr)
                         return 0;
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index 183c91453522..56e4ca54020a 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -26,15 +26,12 @@ typedef int (*event_attr_op)(struct perf_tool *tool,
                              union perf_event *event,
                              struct perf_evlist **pevlist);
 
-typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
-                         struct perf_session *session);
+typedef int (*event_op2)(struct perf_session *session, union perf_event *event);
+typedef s64 (*event_op3)(struct perf_session *session, union perf_event *event);
 
 typedef int (*event_oe)(struct perf_tool *tool, union perf_event *event,
                         struct ordered_events *oe);
 
-typedef s64 (*event_op3)(struct perf_tool *tool, union perf_event *event,
-                         struct perf_session *session);
-
 enum show_feature_header {
         SHOW_FEAT_NO_HEADER = 0,
         SHOW_FEAT_HEADER,
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 7b0ca7cbb7de..8ad8e755127b 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -531,12 +531,14 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                          "/tmp/perf-XXXXXX");
                 if (!mkstemp(tdata->temp_file)) {
                         pr_debug("Can't make temp file");
+                        free(tdata);
                         return NULL;
                 }
 
                 temp_fd = open(tdata->temp_file, O_RDWR);
                 if (temp_fd < 0) {
                         pr_debug("Can't read '%s'", tdata->temp_file);
+                        free(tdata);
                         return NULL;
                 }
 
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index e76214f8d596..32e558a65af3 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -33,14 +33,15 @@ static int get_common_field(struct scripting_context *context,
                             int *offset, int *size, const char *type)
 {
         struct tep_handle *pevent = context->pevent;
-        struct event_format *event;
-        struct format_field *field;
+        struct tep_event_format *event;
+        struct tep_format_field *field;
 
         if (!*size) {
-                if (!pevent->events)
+
+                event = tep_get_first_event(pevent);
+                if (!event)
                         return 0;
 
-                event = pevent->events[0];
                 field = tep_find_common_field(event, type);
                 if (!field)
                         return 0;
@@ -94,9 +95,9 @@ int common_pc(struct scripting_context *context)
 }
 
 unsigned long long
-raw_field_value(struct event_format *event, const char *name, void *data)
+raw_field_value(struct tep_event_format *event, const char *name, void *data)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long long val;
 
         field = tep_find_any_field(event, name);
@@ -108,12 +109,12 @@ raw_field_value(struct event_format *event, const char *name, void *data)
         return val;
 }
 
-unsigned long long read_size(struct event_format *event, void *ptr, int size)
+unsigned long long read_size(struct tep_event_format *event, void *ptr, int size)
 {
         return tep_read_number(event->pevent, ptr, size);
 }
 
-void event_format__fprintf(struct event_format *event,
+void event_format__fprintf(struct tep_event_format *event,
                            int cpu, void *data, int size, FILE *fp)
 {
         struct tep_record record;
@@ -130,7 +131,7 @@ void event_format__fprintf(struct event_format *event,
         trace_seq_destroy(&s);
 }
 
-void event_format__print(struct event_format *event,
+void event_format__print(struct tep_event_format *event,
                          int cpu, void *data, int size)
 {
         return event_format__fprintf(event, cpu, data, size, stdout);
@@ -158,6 +159,7 @@ void parse_ftrace_printk(struct tep_handle *pevent,
                 printk = strdup(fmt+1);
                 line = strtok_r(NULL, "\n", &next);
                 tep_register_print_string(pevent, printk, addr);
+                free(printk);
         }
 }
 
@@ -188,29 +190,33 @@ int parse_event_file(struct tep_handle *pevent,
         return tep_parse_event(pevent, buf, size, sys);
 }
 
-struct event_format *trace_find_next_event(struct tep_handle *pevent,
-                                           struct event_format *event)
+struct tep_event_format *trace_find_next_event(struct tep_handle *pevent,
+                                               struct tep_event_format *event)
 {
         static int idx;
+        int events_count;
+        struct tep_event_format *all_events;
 
-        if (!pevent || !pevent->events)
+        all_events = tep_get_first_event(pevent);
+        events_count = tep_get_events_count(pevent);
+        if (!pevent || !all_events || events_count < 1)
                 return NULL;
 
         if (!event) {
                 idx = 0;
-                return pevent->events[0];
+                return all_events;
         }
 
-        if (idx < pevent->nr_events && event == pevent->events[idx]) {
+        if (idx < events_count && event == (all_events + idx)) {
                 idx++;
-                if (idx == pevent->nr_events)
+                if (idx == events_count)
                         return NULL;
-                return pevent->events[idx];
+                return (all_events + idx);
         }
 
-        for (idx = 1; idx < pevent->nr_events; idx++) {
-                if (event == pevent->events[idx - 1])
-                        return pevent->events[idx];
+        for (idx = 1; idx < events_count; idx++) {
+                if (event == (all_events + (idx - 1)))
+                        return (all_events + idx);
         }
         return NULL;
 }
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 3dfc1db6b25b..76f12c705ef9 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -102,7 +102,7 @@ static unsigned int read4(struct tep_handle *pevent)
 
         if (do_read(&data, 4) < 0)
                 return 0;
-        return __data2host4(pevent, data);
+        return __tep_data2host4(pevent, data);
 }
 
 static unsigned long long read8(struct tep_handle *pevent)
@@ -111,7 +111,7 @@ static unsigned long long read8(struct tep_handle *pevent)
 
         if (do_read(&data, 8) < 0)
                 return 0;
-        return __data2host8(pevent, data);
+        return __tep_data2host8(pevent, data);
 }
 
 static char *read_string(void)
@@ -241,7 +241,7 @@ static int read_header_files(struct tep_handle *pevent)
                  * The commit field in the page is of type long,
                  * use that instead, since it represents the kernel.
                  */
-                tep_set_long_size(pevent, pevent->header_page_size_size);
+                tep_set_long_size(pevent, tep_get_header_page_size(pevent));
         }
         free(header_page);
 
@@ -297,10 +297,8 @@ static int read_event_file(struct tep_handle *pevent, char *sys,
         }
 
         ret = do_read(buf, size);
-        if (ret < 0) {
-                free(buf);
+        if (ret < 0)
                 goto out;
-        }
 
         ret = parse_event_file(pevent, buf, size, sys);
         if (ret < 0)
@@ -349,9 +347,12 @@ static int read_event_files(struct tep_handle *pevent)
                 for (x=0; x < count; x++) {
                         size = read8(pevent);
                         ret = read_event_file(pevent, sys, size);
-                        if (ret)
+                        if (ret) {
+                                free(sys);
                                 return ret;
+                        }
                 }
+                free(sys);
         }
         return 0;
 }
diff --git a/tools/perf/util/trace-event.c b/tools/perf/util/trace-event.c
index 58bb72f266f3..95664b2f771e 100644
--- a/tools/perf/util/trace-event.c
+++ b/tools/perf/util/trace-event.c
@@ -72,12 +72,12 @@ void trace_event__cleanup(struct trace_event *t)
 /*
  * Returns pointer with encoded error via <linux/err.h> interface.
  */
-static struct event_format*
+static struct tep_event_format*
 tp_format(const char *sys, const char *name)
 {
         char *tp_dir = get_events_file(sys);
         struct tep_handle *pevent = tevent.pevent;
-        struct event_format *event = NULL;
+        struct tep_event_format *event = NULL;
         char path[PATH_MAX];
         size_t size;
         char *data;
@@ -102,7 +102,7 @@ tp_format(const char *sys, const char *name)
 /*
  * Returns pointer with encoded error via <linux/err.h> interface.
  */
-struct event_format*
+struct tep_event_format*
 trace_event__tp_format(const char *sys, const char *name)
 {
         if (!tevent_initialized && trace_event__init2())
@@ -111,7 +111,7 @@ trace_event__tp_format(const char *sys, const char *name)
         return tp_format(sys, name);
 }
 
-struct event_format *trace_event__tp_format_id(int id)
+struct tep_event_format *trace_event__tp_format_id(int id)
 {
         if (!tevent_initialized && trace_event__init2())
                 return ERR_PTR(-ENOMEM);
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 40204ec3a7a2..f024d73bfc40 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -3,6 +3,7 @@
 #define _PERF_UTIL_TRACE_EVENT_H
 
 #include <traceevent/event-parse.h>
+#include <traceevent/trace-seq.h>
 #include "parse-events.h"
 
 struct machine;
@@ -10,28 +11,28 @@ struct perf_sample;
 union perf_event;
 struct perf_tool;
 struct thread;
-struct plugin_list;
+struct tep_plugin_list;
 
 struct trace_event {
         struct tep_handle       *pevent;
-        struct plugin_list      *plugin_list;
+        struct tep_plugin_list  *plugin_list;
 };
 
 int trace_event__init(struct trace_event *t);
 void trace_event__cleanup(struct trace_event *t);
 int trace_event__register_resolver(struct machine *machine,
                                    tep_func_resolver_t *func);
-struct event_format*
+struct tep_event_format*
 trace_event__tp_format(const char *sys, const char *name);
 
-struct event_format *trace_event__tp_format_id(int id);
+struct tep_event_format *trace_event__tp_format_id(int id);
 
 int bigendian(void);
 
-void event_format__fprintf(struct event_format *event,
+void event_format__fprintf(struct tep_event_format *event,
                            int cpu, void *data, int size, FILE *fp);
 
-void event_format__print(struct event_format *event,
+void event_format__print(struct tep_event_format *event,
                          int cpu, void *data, int size);
 
 int parse_ftrace_file(struct tep_handle *pevent, char *buf, unsigned long size);
@@ -39,7 +40,7 @@ int parse_event_file(struct tep_handle *pevent,
                      char *buf, unsigned long size, char *sys);
 
 unsigned long long
-raw_field_value(struct event_format *event, const char *name, void *data);
+raw_field_value(struct tep_event_format *event, const char *name, void *data);
 
 void parse_proc_kallsyms(struct tep_handle *pevent, char *file, unsigned int size);
 void parse_ftrace_printk(struct tep_handle *pevent, char *file, unsigned int size);
@@ -47,9 +48,9 @@ void parse_saved_cmdline(struct tep_handle *pevent, char *file, unsigned int siz
 
 ssize_t trace_report(int fd, struct trace_event *tevent, bool repipe);
 
-struct event_format *trace_find_next_event(struct tep_handle *pevent,
-                                           struct event_format *event);
-unsigned long long read_size(struct event_format *event, void *ptr, int size);
+struct tep_event_format *trace_find_next_event(struct tep_handle *pevent,
+                                               struct tep_event_format *event);
+unsigned long long read_size(struct tep_event_format *event, void *ptr, int size);
 unsigned long long eval_flag(const char *flag);
 
 int read_tracing_data(int fd, struct list_head *pattrs);
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index eac5b858a371..093352e93d50 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -221,7 +221,7 @@ out:
         return err;
 }
 
-static int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
+int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
 {
         void *ptr;
         loff_t pgoff;
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index dc58254a2b69..14508ee7707a 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -6,6 +6,7 @@
 /* glibc 2.20 deprecates _BSD_SOURCE in favour of _DEFAULT_SOURCE */
 #define _DEFAULT_SOURCE 1
 
+#include <fcntl.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -35,6 +36,7 @@ bool lsdir_no_dot_filter(const char *name, struct dirent *d);
 int copyfile(const char *from, const char *to);
 int copyfile_mode(const char *from, const char *to, mode_t mode);
 int copyfile_ns(const char *from, const char *to, struct nsinfo *nsi);
+int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size);
 
 ssize_t readn(int fd, void *buf, size_t n);
 ssize_t writen(int fd, const void *buf, size_t n);
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 980bd9d20646..328f62e6ea02 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -2082,7 +2082,7 @@ int has_turbo_ratio_group_limits(int family, int model)
         switch (model) {
         case INTEL_FAM6_ATOM_GOLDMONT:
         case INTEL_FAM6_SKYLAKE_X:
-        case INTEL_FAM6_ATOM_DENVERTON:
+        case INTEL_FAM6_ATOM_GOLDMONT_X:
                 return 1;
         }
         return 0;
@@ -3149,9 +3149,9 @@ int probe_nhm_msrs(unsigned int family, unsigned int model)
                 pkg_cstate_limits = skx_pkg_cstate_limits;
                 has_misc_feature_control = 1;
                 break;
-        case INTEL_FAM6_ATOM_SILVERMONT1:       /* BYT */
+        case INTEL_FAM6_ATOM_SILVERMONT:        /* BYT */
                 no_MSR_MISC_PWR_MGMT = 1;
-        case INTEL_FAM6_ATOM_SILVERMONT2:       /* AVN */
+        case INTEL_FAM6_ATOM_SILVERMONT_X:      /* AVN */
                 pkg_cstate_limits = slv_pkg_cstate_limits;
                 break;
         case INTEL_FAM6_ATOM_AIRMONT:   /* AMT */
@@ -3163,8 +3163,8 @@ int probe_nhm_msrs(unsigned int family, unsigned int model)
                 pkg_cstate_limits = phi_pkg_cstate_limits;
                 break;
         case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
-        case INTEL_FAM6_ATOM_DENVERTON: /* DNV */
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
+        case INTEL_FAM6_ATOM_GOLDMONT_X:        /* DNV */
                 pkg_cstate_limits = bxt_pkg_cstate_limits;
                 break;
         default:
@@ -3193,9 +3193,9 @@ int has_slv_msrs(unsigned int family, unsigned int model)
                 return 0;
 
         switch (model) {
-        case INTEL_FAM6_ATOM_SILVERMONT1:
-        case INTEL_FAM6_ATOM_MERRIFIELD:
-        case INTEL_FAM6_ATOM_MOOREFIELD:
+        case INTEL_FAM6_ATOM_SILVERMONT:
+        case INTEL_FAM6_ATOM_SILVERMONT_MID:
+        case INTEL_FAM6_ATOM_AIRMONT_MID:
                 return 1;
         }
         return 0;
@@ -3207,7 +3207,7 @@ int is_dnv(unsigned int family, unsigned int model)
                 return 0;
 
         switch (model) {
-        case INTEL_FAM6_ATOM_DENVERTON:
+        case INTEL_FAM6_ATOM_GOLDMONT_X:
                 return 1;
         }
         return 0;
@@ -3724,8 +3724,8 @@ double get_tdp(unsigned int model)
                         return ((msr >> 0) & RAPL_POWER_GRANULARITY) * rapl_power_units;
 
         switch (model) {
-        case INTEL_FAM6_ATOM_SILVERMONT1:
-        case INTEL_FAM6_ATOM_SILVERMONT2:
+        case INTEL_FAM6_ATOM_SILVERMONT:
+        case INTEL_FAM6_ATOM_SILVERMONT_X:
                 return 30.0;
         default:
                 return 135.0;
@@ -3791,7 +3791,7 @@ void rapl_probe(unsigned int family, unsigned int model)
                 }
                 break;
         case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
                 do_rapl = RAPL_PKG | RAPL_PKG_POWER_INFO;
                 if (rapl_joules)
                         BIC_PRESENT(BIC_Pkg_J);
@@ -3850,8 +3850,8 @@ void rapl_probe(unsigned int family, unsigned int model)
                         BIC_PRESENT(BIC_RAMWatt);
                 }
                 break;
-        case INTEL_FAM6_ATOM_SILVERMONT1:       /* BYT */
-        case INTEL_FAM6_ATOM_SILVERMONT2:       /* AVN */
+        case INTEL_FAM6_ATOM_SILVERMONT:        /* BYT */
+        case INTEL_FAM6_ATOM_SILVERMONT_X:      /* AVN */
                 do_rapl = RAPL_PKG | RAPL_CORES;
                 if (rapl_joules) {
                         BIC_PRESENT(BIC_Pkg_J);
@@ -3861,7 +3861,7 @@ void rapl_probe(unsigned int family, unsigned int model)
                         BIC_PRESENT(BIC_CorWatt);
                 }
                 break;
-        case INTEL_FAM6_ATOM_DENVERTON: /* DNV */
+        case INTEL_FAM6_ATOM_GOLDMONT_X:        /* DNV */
                 do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_POWER_INFO | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO | RAPL_CORES_ENERGY_STATUS;
                 BIC_PRESENT(BIC_PKG__);
                 BIC_PRESENT(BIC_RAM__);
@@ -3884,7 +3884,7 @@ void rapl_probe(unsigned int family, unsigned int model)
                 return;
 
         rapl_power_units = 1.0 / (1 << (msr & 0xF));
-        if (model == INTEL_FAM6_ATOM_SILVERMONT1)
+        if (model == INTEL_FAM6_ATOM_SILVERMONT)
                 rapl_energy_units = 1.0 * (1 << (msr >> 8 & 0x1F)) / 1000000;
         else
                 rapl_energy_units = 1.0 / (1 << (msr >> 8 & 0x1F));
@@ -4141,8 +4141,8 @@ int has_snb_msrs(unsigned int family, unsigned int model)
         case INTEL_FAM6_CANNONLAKE_MOBILE:      /* CNL */
         case INTEL_FAM6_SKYLAKE_X:      /* SKX */
         case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
-        case INTEL_FAM6_ATOM_DENVERTON: /* DNV */
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
+        case INTEL_FAM6_ATOM_GOLDMONT_X:        /* DNV */
                 return 1;
         }
         return 0;
@@ -4174,7 +4174,7 @@ int has_hsw_msrs(unsigned int family, unsigned int model)
         case INTEL_FAM6_KABYLAKE_DESKTOP:       /* KBL */
         case INTEL_FAM6_CANNONLAKE_MOBILE:      /* CNL */
         case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
-        case INTEL_FAM6_ATOM_GEMINI_LAKE:
+        case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
                 return 1;
         }
         return 0;
@@ -4209,8 +4209,8 @@ int is_slm(unsigned int family, unsigned int model)
         if (!genuine_intel)
                 return 0;
         switch (model) {
-        case INTEL_FAM6_ATOM_SILVERMONT1:       /* BYT */
-        case INTEL_FAM6_ATOM_SILVERMONT2:       /* AVN */
+        case INTEL_FAM6_ATOM_SILVERMONT:        /* BYT */
+        case INTEL_FAM6_ATOM_SILVERMONT_X:      /* AVN */
                 return 1;
         }
         return 0;
@@ -4581,11 +4581,11 @@ void process_cpuid()
                                 case INTEL_FAM6_KABYLAKE_DESKTOP:       /* KBL */
                                         crystal_hz = 24000000;  /* 24.0 MHz */
                                         break;
-                                case INTEL_FAM6_ATOM_DENVERTON: /* DNV */
+                                case INTEL_FAM6_ATOM_GOLDMONT_X:        /* DNV */
                                         crystal_hz = 25000000;  /* 25.0 MHz */
                                         break;
                                 case INTEL_FAM6_ATOM_GOLDMONT:  /* BXT */
-                                case INTEL_FAM6_ATOM_GEMINI_LAKE:
+                                case INTEL_FAM6_ATOM_GOLDMONT_PLUS:
                                         crystal_hz = 19200000;  /* 19.2 MHz */
                                         break;
                                 default: