195 files changed, 5661 insertions, 3655 deletions

diff --git a/Documentation/devicetree/bindings/input/gpio-keys.txt b/Documentation/devicetree/bindings/input/gpio-keys.txt
index 996ce84352cb..7cccc49b6bea 100644
--- a/Documentation/devicetree/bindings/input/gpio-keys.txt
+++ b/Documentation/devicetree/bindings/input/gpio-keys.txt
@@ -1,4 +1,4 @@
-Device-Tree bindings for input/gpio_keys.c keyboard driver
+Device-Tree bindings for input/keyboard/gpio_keys.c keyboard driver
 
 Required properties:
         - compatible = "gpio-keys";
diff --git a/MAINTAINERS b/MAINTAINERS
index 02a39617ec82..a255240d1452 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9716,13 +9716,6 @@ Q:	http://patchwork.linuxtv.org/project/linux-media/list/
 S:      Maintained
 F:      drivers/media/dvb-frontends/mn88473*
 
-PCI DRIVER FOR MOBIVEIL PCIE IP
-M:      Subrahmanya Lingappa <l.subrahmanya@mobiveil.co.in>
-L:      linux-pci@vger.kernel.org
-S:      Supported
-F:      Documentation/devicetree/bindings/pci/mobiveil-pcie.txt
-F:      drivers/pci/controller/pcie-mobiveil.c
-
 MODULE SUPPORT
 M:      Jessica Yu <jeyu@kernel.org>
 T:      git git://git.kernel.org/pub/scm/linux/kernel/git/jeyu/linux.git modules-next
@@ -11137,6 +11130,13 @@ F:	include/uapi/linux/switchtec_ioctl.h
 F:      include/linux/switchtec.h
 F:      drivers/ntb/hw/mscc/
 
+PCI DRIVER FOR MOBIVEIL PCIE IP
+M:      Subrahmanya Lingappa <l.subrahmanya@mobiveil.co.in>
+L:      linux-pci@vger.kernel.org
+S:      Supported
+F:      Documentation/devicetree/bindings/pci/mobiveil-pcie.txt
+F:      drivers/pci/controller/pcie-mobiveil.c
+
 PCI DRIVER FOR MVEBU (Marvell Armada 370 and Armada XP SOC support)
 M:      Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
 M:      Jason Cooper <jason@lakedaemon.net>
@@ -11203,8 +11203,14 @@ F:	tools/pci/
 
 PCI ENHANCED ERROR HANDLING (EEH) FOR POWERPC
 M:      Russell Currey <ruscur@russell.cc>
+M:      Sam Bobroff <sbobroff@linux.ibm.com>
+M:      Oliver O'Halloran <oohall@gmail.com>
 L:      linuxppc-dev@lists.ozlabs.org
 S:      Supported
+F:      Documentation/PCI/pci-error-recovery.txt
+F:      drivers/pci/pcie/aer.c
+F:      drivers/pci/pcie/dpc.c
+F:      drivers/pci/pcie/err.c
 F:      Documentation/powerpc/eeh-pci-error-recovery.txt
 F:      arch/powerpc/kernel/eeh*.c
 F:      arch/powerpc/platforms/*/eeh*.c
diff --git a/arch/powerpc/include/asm/setup.h b/arch/powerpc/include/asm/setup.h
index 1a951b00465d..1fffbba8d6a5 100644
--- a/arch/powerpc/include/asm/setup.h
+++ b/arch/powerpc/include/asm/setup.h
@@ -9,6 +9,7 @@ extern void ppc_printk_progress(char *s, unsigned short hex);
 
 extern unsigned int rtas_data;
 extern unsigned long long memory_limit;
+extern bool init_mem_is_free;
 extern unsigned long klimit;
 extern void *zalloc_maybe_bootmem(size_t size, gfp_t mask);
 
diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S
index ea04dfb8c092..2d8fc8c9da7a 100644
--- a/arch/powerpc/kernel/exceptions-64s.S
+++ b/arch/powerpc/kernel/exceptions-64s.S
@@ -1314,9 +1314,7 @@ EXC_REAL_BEGIN(denorm_exception_hv, 0x1500, 0x100)
 
 #ifdef CONFIG_PPC_DENORMALISATION
         mfspr   r10,SPRN_HSRR1
-        mfspr   r11,SPRN_HSRR0          /* save HSRR0 */
         andis.  r10,r10,(HSRR1_DENORM)@h /* denorm? */
-        addi    r11,r11,-4              /* HSRR0 is next instruction */
         bne+    denorm_assist
 #endif
 
@@ -1382,6 +1380,8 @@ END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_207S)
  */
         XVCPSGNDP32(32)
 denorm_done:
+        mfspr   r11,SPRN_HSRR0
+        subi    r11,r11,4
         mtspr   SPRN_HSRR0,r11
         mtcrf   0x80,r9
         ld      r9,PACA_EXGEN+EX_R9(r13)
diff --git a/arch/powerpc/kernel/tm.S b/arch/powerpc/kernel/tm.S
index 6bffbc5affe7..7716374786bd 100644
--- a/arch/powerpc/kernel/tm.S
+++ b/arch/powerpc/kernel/tm.S
@@ -176,13 +176,27 @@ _GLOBAL(tm_reclaim)
         std     r1, PACATMSCRATCH(r13)
         ld      r1, PACAR1(r13)
 
-        /* Store the PPR in r11 and reset to decent value */
         std     r11, GPR11(r1)                  /* Temporary stash */
 
+        /*
+         * Move the saved user r1 to the kernel stack in case PACATMSCRATCH is
+         * clobbered by an exception once we turn on MSR_RI below.
+         */
+        ld      r11, PACATMSCRATCH(r13)
+        std     r11, GPR1(r1)
+
+        /*
+         * Store r13 away so we can free up the scratch SPR for the SLB fault
+         * handler (needed once we start accessing the thread_struct).
+         */
+        GET_SCRATCH0(r11)
+        std     r11, GPR13(r1)
+
         /* Reset MSR RI so we can take SLB faults again */
         li      r11, MSR_RI
         mtmsrd  r11, 1
 
+        /* Store the PPR in r11 and reset to decent value */
         mfspr   r11, SPRN_PPR
         HMT_MEDIUM
 
@@ -207,11 +221,11 @@ _GLOBAL(tm_reclaim)
         SAVE_GPR(8, r7)                         /* user r8 */
         SAVE_GPR(9, r7)                         /* user r9 */
         SAVE_GPR(10, r7)                        /* user r10 */
-        ld      r3, PACATMSCRATCH(r13)          /* user r1 */
+        ld      r3, GPR1(r1)                    /* user r1 */
         ld      r4, GPR7(r1)                    /* user r7 */
         ld      r5, GPR11(r1)                   /* user r11 */
         ld      r6, GPR12(r1)                   /* user r12 */
-        GET_SCRATCH0(8)                         /* user r13 */
+        ld      r8, GPR13(r1)                   /* user r13 */
         std     r3, GPR1(r7)
         std     r4, GPR7(r7)
         std     r5, GPR11(r7)
diff --git a/arch/powerpc/lib/checksum_64.S b/arch/powerpc/lib/checksum_64.S
index 886ed94b9c13..d05c8af4ac51 100644
--- a/arch/powerpc/lib/checksum_64.S
+++ b/arch/powerpc/lib/checksum_64.S
@@ -443,6 +443,9 @@ _GLOBAL(csum_ipv6_magic)
         addc    r0, r8, r9
         ld      r10, 0(r4)
         ld      r11, 8(r4)
+#ifdef CONFIG_CPU_LITTLE_ENDIAN
+        rotldi  r5, r5, 8
+#endif
         adde    r0, r0, r10
         add     r5, r5, r7
         adde    r0, r0, r11
diff --git a/arch/powerpc/lib/code-patching.c b/arch/powerpc/lib/code-patching.c
index 850f3b8f4da5..6ae2777c220d 100644
--- a/arch/powerpc/lib/code-patching.c
+++ b/arch/powerpc/lib/code-patching.c
@@ -28,6 +28,12 @@ static int __patch_instruction(unsigned int *exec_addr, unsigned int instr,
 {
         int err;
 
+        /* Make sure we aren't patching a freed init section */
+        if (init_mem_is_free && init_section_contains(exec_addr, 4)) {
+                pr_debug("Skipping init section patching addr: 0x%px\n", exec_addr);
+                return 0;
+        }
+
         __put_user_size(instr, patch_addr, 4, err);
         if (err)
                 return err;
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index 5c8530d0c611..04ccb274a620 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -63,6 +63,7 @@
 #endif
 
 unsigned long long memory_limit;
+bool init_mem_is_free;
 
 #ifdef CONFIG_HIGHMEM
 pte_t *kmap_pte;
@@ -396,6 +397,7 @@ void free_initmem(void)
 {
         ppc_md.progress = ppc_printk_progress;
         mark_initmem_nx();
+        init_mem_is_free = true;
         free_initmem_default(POISON_FREE_INITMEM);
 }
 
diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
index 35ac5422903a..59d07bd5374a 100644
--- a/arch/powerpc/mm/numa.c
+++ b/arch/powerpc/mm/numa.c
@@ -1204,7 +1204,9 @@ int find_and_online_cpu_nid(int cpu)
         int new_nid;
 
         /* Use associativity from first thread for all siblings */
-        vphn_get_associativity(cpu, associativity);
+        if (vphn_get_associativity(cpu, associativity))
+                return cpu_to_node(cpu);
+
         new_nid = associativity_to_nid(associativity);
         if (new_nid < 0 || !node_possible(new_nid))
                 new_nid = first_online_node;
@@ -1452,7 +1454,8 @@ static struct timer_list topology_timer;
 
 static void reset_topology_timer(void)
 {
-        mod_timer(&topology_timer, jiffies + topology_timer_secs * HZ);
+        if (vphn_enabled)
+                mod_timer(&topology_timer, jiffies + topology_timer_secs * HZ);
 }
 
 #ifdef CONFIG_SMP
diff --git a/arch/powerpc/mm/pkeys.c b/arch/powerpc/mm/pkeys.c
index 333b1f80c435..b271b283c785 100644
--- a/arch/powerpc/mm/pkeys.c
+++ b/arch/powerpc/mm/pkeys.c
@@ -45,7 +45,7 @@ static void scan_pkey_feature(void)
          * Since any pkey can be used for data or execute, we will just treat
          * all keys as equal and track them as one entity.
          */
-        pkeys_total = be32_to_cpu(vals[0]);
+        pkeys_total = vals[0];
         pkeys_devtree_defined = true;
 }
 
diff --git a/arch/powerpc/platforms/powernv/pci-ioda-tce.c b/arch/powerpc/platforms/powernv/pci-ioda-tce.c
index 6c5db1acbe8d..fe9691040f54 100644
--- a/arch/powerpc/platforms/powernv/pci-ioda-tce.c
+++ b/arch/powerpc/platforms/powernv/pci-ioda-tce.c
@@ -276,7 +276,7 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset,
         level_shift = entries_shift + 3;
         level_shift = max_t(unsigned int, level_shift, PAGE_SHIFT);
 
-        if ((level_shift - 3) * levels + page_shift >= 60)
+        if ((level_shift - 3) * levels + page_shift >= 55)
                 return -EINVAL;
 
         /* Allocate TCE table */
diff --git a/arch/riscv/include/asm/asm-prototypes.h b/arch/riscv/include/asm/asm-prototypes.h
new file mode 100644
index 000000000000..c9fecd120d18
--- /dev/null
+++ b/arch/riscv/include/asm/asm-prototypes.h
@@ -0,0 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_RISCV_PROTOTYPES_H
+
+#include <linux/ftrace.h>
+#include <asm-generic/asm-prototypes.h>
+
+#endif /* _ASM_RISCV_PROTOTYPES_H */
diff --git a/arch/x86/boot/compressed/mem_encrypt.S b/arch/x86/boot/compressed/mem_encrypt.S
index eaa843a52907..a480356e0ed8 100644
--- a/arch/x86/boot/compressed/mem_encrypt.S
+++ b/arch/x86/boot/compressed/mem_encrypt.S
@@ -25,20 +25,6 @@ ENTRY(get_sev_encryption_bit)
         push    %ebx
         push    %ecx
         push    %edx
-        push    %edi
-
-        /*
-         * RIP-relative addressing is needed to access the encryption bit
-         * variable. Since we are running in 32-bit mode we need this call/pop
-         * sequence to get the proper relative addressing.
-         */
-        call    1f
-1:      popl    %edi
-        subl    $1b, %edi
-
-        movl    enc_bit(%edi), %eax
-        cmpl    $0, %eax
-        jge     .Lsev_exit
 
         /* Check if running under a hypervisor */
         movl    $1, %eax
@@ -69,15 +55,12 @@ ENTRY(get_sev_encryption_bit)
 
         movl    %ebx, %eax
         andl    $0x3f, %eax             /* Return the encryption bit location */
-        movl    %eax, enc_bit(%edi)
         jmp     .Lsev_exit
 
 .Lno_sev:
         xor     %eax, %eax
-        movl    %eax, enc_bit(%edi)
 
 .Lsev_exit:
-        pop     %edi
         pop     %edx
         pop     %ecx
         pop     %ebx
@@ -113,8 +96,6 @@ ENTRY(set_sev_encryption_mask)
 ENDPROC(set_sev_encryption_mask)
 
         .data
-enc_bit:
-        .int    0xffffffff
 
 #ifdef CONFIG_AMD_MEM_ENCRYPT
         .balign 8
diff --git a/arch/x86/events/amd/uncore.c b/arch/x86/events/amd/uncore.c
index 981ba5e8241b..8671de126eac 100644
--- a/arch/x86/events/amd/uncore.c
+++ b/arch/x86/events/amd/uncore.c
@@ -36,6 +36,7 @@
 
 static int num_counters_llc;
 static int num_counters_nb;
+static bool l3_mask;
 
 static HLIST_HEAD(uncore_unused_list);
 
@@ -209,6 +210,13 @@ static int amd_uncore_event_init(struct perf_event *event)
         hwc->config = event->attr.config & AMD64_RAW_EVENT_MASK_NB;
         hwc->idx = -1;
 
+        /*
+         * SliceMask and ThreadMask need to be set for certain L3 events in
+         * Family 17h. For other events, the two fields do not affect the count.
+         */
+        if (l3_mask)
+                hwc->config |= (AMD64_L3_SLICE_MASK | AMD64_L3_THREAD_MASK);
+
         if (event->cpu < 0)
                 return -EINVAL;
 
@@ -525,6 +533,7 @@ static int __init amd_uncore_init(void)
                 amd_llc_pmu.name          = "amd_l3";
                 format_attr_event_df.show = &event_show_df;
                 format_attr_event_l3.show = &event_show_l3;
+                l3_mask                   = true;
         } else {
                 num_counters_nb           = NUM_COUNTERS_NB;
                 num_counters_llc          = NUM_COUNTERS_L2;
@@ -532,6 +541,7 @@ static int __init amd_uncore_init(void)
                 amd_llc_pmu.name          = "amd_l2";
                 format_attr_event_df      = format_attr_event;
                 format_attr_event_l3      = format_attr_event;
+                l3_mask                   = false;
         }
 
         amd_nb_pmu.attr_groups  = amd_uncore_attr_groups_df;
diff --git a/arch/x86/events/core.c b/arch/x86/events/core.c
index 3550d800b030..06b708494898 100644
--- a/arch/x86/events/core.c
+++ b/arch/x86/events/core.c
@@ -1605,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,
 };
@@ -1736,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,
 };
@@ -2251,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,
 };
 
@@ -2269,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/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/uncore_snbep.c b/arch/x86/events/intel/uncore_snbep.c
index 51d7c117e3c7..c07bee31abe8 100644
--- a/arch/x86/events/intel/uncore_snbep.c
+++ b/arch/x86/events/intel/uncore_snbep.c
@@ -3061,7 +3061,7 @@ static struct event_constraint bdx_uncore_pcu_constraints[] = {
 
 void bdx_uncore_cpu_init(void)
 {
-        int pkg = topology_phys_to_logical_pkg(0);
+        int pkg = topology_phys_to_logical_pkg(boot_cpu_data.phys_proc_id);
 
         if (bdx_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores)
                 bdx_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores;
@@ -3931,16 +3931,16 @@ static const struct pci_device_id skx_uncore_pci_ids[] = {
                 .driver_data = UNCORE_PCI_DEV_FULL_DATA(21, 5, SKX_PCI_UNCORE_M2PCIE, 3),
         },
         { /* M3UPI0 Link 0 */
-                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x204C),
-                .driver_data = UNCORE_PCI_DEV_FULL_DATA(18, 0, SKX_PCI_UNCORE_M3UPI, 0),
+                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x204D),
+                .driver_data = UNCORE_PCI_DEV_FULL_DATA(18, 1, SKX_PCI_UNCORE_M3UPI, 0),
         },
         { /* M3UPI0 Link 1 */
-                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x204D),
-                .driver_data = UNCORE_PCI_DEV_FULL_DATA(18, 1, SKX_PCI_UNCORE_M3UPI, 1),
+                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x204E),
+                .driver_data = UNCORE_PCI_DEV_FULL_DATA(18, 2, SKX_PCI_UNCORE_M3UPI, 1),
         },
         { /* M3UPI1 Link 2 */
-                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x204C),
-                .driver_data = UNCORE_PCI_DEV_FULL_DATA(18, 4, SKX_PCI_UNCORE_M3UPI, 2),
+                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x204D),
+                .driver_data = UNCORE_PCI_DEV_FULL_DATA(18, 5, SKX_PCI_UNCORE_M3UPI, 2),
         },
         { /* end: all zeroes */ }
 };
diff --git a/arch/x86/include/asm/perf_event.h b/arch/x86/include/asm/perf_event.h
index b2cf84c35a6d..8bdf74902293 100644
--- a/arch/x86/include/asm/perf_event.h
+++ b/arch/x86/include/asm/perf_event.h
@@ -46,6 +46,14 @@
 #define INTEL_ARCH_EVENT_MASK   \
         (ARCH_PERFMON_EVENTSEL_UMASK | ARCH_PERFMON_EVENTSEL_EVENT)
 
+#define AMD64_L3_SLICE_SHIFT                            48
+#define AMD64_L3_SLICE_MASK                             \
+        ((0xFULL) << AMD64_L3_SLICE_SHIFT)
+
+#define AMD64_L3_THREAD_SHIFT                           56
+#define AMD64_L3_THREAD_MASK                            \
+        ((0xFFULL) << AMD64_L3_THREAD_SHIFT)
+
 #define X86_RAW_EVENT_MASK              \
         (ARCH_PERFMON_EVENTSEL_EVENT |  \
          ARCH_PERFMON_EVENTSEL_UMASK |  \
diff --git a/block/blk-mq-tag.c b/block/blk-mq-tag.c
index 94e1ed667b6e..41317c50a446 100644
--- a/block/blk-mq-tag.c
+++ b/block/blk-mq-tag.c
@@ -322,16 +322,11 @@ void blk_mq_queue_tag_busy_iter(struct request_queue *q, busy_iter_fn *fn,
 
         /*
          * __blk_mq_update_nr_hw_queues will update the nr_hw_queues and
-         * queue_hw_ctx after freeze the queue. So we could use q_usage_counter
-         * to avoid race with it. __blk_mq_update_nr_hw_queues will users
-         * synchronize_rcu to ensure all of the users go out of the critical
-         * section below and see zeroed q_usage_counter.
+         * queue_hw_ctx after freeze the queue, so we use q_usage_counter
+         * to avoid race with it.
          */
-        rcu_read_lock();
-        if (percpu_ref_is_zero(&q->q_usage_counter)) {
-                rcu_read_unlock();
+        if (!percpu_ref_tryget(&q->q_usage_counter))
                 return;
-        }
 
         queue_for_each_hw_ctx(q, hctx, i) {
                 struct blk_mq_tags *tags = hctx->tags;
@@ -347,7 +342,7 @@ void blk_mq_queue_tag_busy_iter(struct request_queue *q, busy_iter_fn *fn,
                         bt_for_each(hctx, &tags->breserved_tags, fn, priv, true);
                 bt_for_each(hctx, &tags->bitmap_tags, fn, priv, false);
         }
-        rcu_read_unlock();
+        blk_queue_exit(q);
 }
 
 static int bt_alloc(struct sbitmap_queue *bt, unsigned int depth,
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 85a1c1a59c72..e3c39ea8e17b 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -1628,7 +1628,7 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)
                 BUG_ON(!rq->q);
                 if (rq->mq_ctx != this_ctx) {
                         if (this_ctx) {
-                                trace_block_unplug(this_q, depth, from_schedule);
+                                trace_block_unplug(this_q, depth, !from_schedule);
                                 blk_mq_sched_insert_requests(this_q, this_ctx,
                                                                 &ctx_list,
                                                                 from_schedule);
@@ -1648,7 +1648,7 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule)
          * on 'ctx_list'. Do those.
          */
         if (this_ctx) {
-                trace_block_unplug(this_q, depth, from_schedule);
+                trace_block_unplug(this_q, depth, !from_schedule);
                 blk_mq_sched_insert_requests(this_q, this_ctx, &ctx_list,
                                                 from_schedule);
         }
diff --git a/block/elevator.c b/block/elevator.c
index 6a06b5d040e5..fae58b2f906f 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -609,7 +609,7 @@ void elv_drain_elevator(struct request_queue *q)
 
         while (e->type->ops.sq.elevator_dispatch_fn(q, 1))
                 ;
-        if (q->nr_sorted && printed++ < 10) {
+        if (q->nr_sorted && !blk_queue_is_zoned(q) && printed++ < 10 ) {
                 printk(KERN_ERR "%s: forced dispatching is broken "
                        "(nr_sorted=%u), please report this\n",
                        q->elevator->type->elevator_name, q->nr_sorted);
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index a71d817e900d..429d20131c7e 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -2670,8 +2670,8 @@ static void purge_persistent_grants(struct blkfront_info *info)
                         list_del(&gnt_list_entry->node);
                         gnttab_end_foreign_access(gnt_list_entry->gref, 0, 0UL);
                         rinfo->persistent_gnts_c--;
-                        __free_page(gnt_list_entry->page);
-                        kfree(gnt_list_entry);
+                        gnt_list_entry->gref = GRANT_INVALID_REF;
+                        list_add_tail(&gnt_list_entry->node, &rinfo->grants);
                 }
 
                 spin_unlock_irqrestore(&rinfo->ring_lock, flags);
diff --git a/drivers/clocksource/timer-atmel-pit.c b/drivers/clocksource/timer-atmel-pit.c
index ec8a4376f74f..2fab18fae4fc 100644
--- a/drivers/clocksource/timer-atmel-pit.c
+++ b/drivers/clocksource/timer-atmel-pit.c
@@ -180,26 +180,29 @@ static int __init at91sam926x_pit_dt_init(struct device_node *node)
         data->base = of_iomap(node, 0);
         if (!data->base) {
                 pr_err("Could not map PIT address\n");
-                return -ENXIO;
+                ret = -ENXIO;
+                goto exit;
         }
 
         data->mck = of_clk_get(node, 0);
         if (IS_ERR(data->mck)) {
                 pr_err("Unable to get mck clk\n");
-                return PTR_ERR(data->mck);
+                ret = PTR_ERR(data->mck);
+                goto exit;
         }
 
         ret = clk_prepare_enable(data->mck);
         if (ret) {
                 pr_err("Unable to enable mck\n");
-                return ret;
+                goto exit;
         }
 
         /* Get the interrupts property */
         data->irq = irq_of_parse_and_map(node, 0);
         if (!data->irq) {
                 pr_err("Unable to get IRQ from DT\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto exit;
         }
 
         /*
@@ -227,7 +230,7 @@ static int __init at91sam926x_pit_dt_init(struct device_node *node)
         ret = clocksource_register_hz(&data->clksrc, pit_rate);
         if (ret) {
                 pr_err("Failed to register clocksource\n");
-                return ret;
+                goto exit;
         }
 
         /* Set up irq handler */
@@ -236,7 +239,8 @@ static int __init at91sam926x_pit_dt_init(struct device_node *node)
                           "at91_tick", data);
         if (ret) {
                 pr_err("Unable to setup IRQ\n");
-                return ret;
+                clocksource_unregister(&data->clksrc);
+                goto exit;
         }
 
         /* Set up and register clockevents */
@@ -254,6 +258,10 @@ static int __init at91sam926x_pit_dt_init(struct device_node *node)
         clockevents_register_device(&data->clkevt);
 
         return 0;
+
+exit:
+        kfree(data);
+        return ret;
 }
 TIMER_OF_DECLARE(at91sam926x_pit, "atmel,at91sam9260-pit",
                        at91sam926x_pit_dt_init);
diff --git a/drivers/clocksource/timer-fttmr010.c b/drivers/clocksource/timer-fttmr010.c
index c020038ebfab..cf93f6419b51 100644
--- a/drivers/clocksource/timer-fttmr010.c
+++ b/drivers/clocksource/timer-fttmr010.c
@@ -130,13 +130,17 @@ static int fttmr010_timer_set_next_event(unsigned long cycles,
         cr &= ~fttmr010->t1_enable_val;
         writel(cr, fttmr010->base + TIMER_CR);
 
-        /* Setup the match register forward/backward in time */
-        cr = readl(fttmr010->base + TIMER1_COUNT);
-        if (fttmr010->count_down)
-                cr -= cycles;
-        else
-                cr += cycles;
-        writel(cr, fttmr010->base + TIMER1_MATCH1);
+        if (fttmr010->count_down) {
+                /*
+                 * ASPEED Timer Controller will load TIMER1_LOAD register
+                 * into TIMER1_COUNT register when the timer is re-enabled.
+                 */
+                writel(cycles, fttmr010->base + TIMER1_LOAD);
+        } else {
+                /* Setup the match register forward in time */
+                cr = readl(fttmr010->base + TIMER1_COUNT);
+                writel(cr + cycles, fttmr010->base + TIMER1_MATCH1);
+        }
 
         /* Start */
         cr = readl(fttmr010->base + TIMER_CR);
diff --git a/drivers/clocksource/timer-ti-32k.c b/drivers/clocksource/timer-ti-32k.c
index 29e2e1a78a43..6949a9113dbb 100644
--- a/drivers/clocksource/timer-ti-32k.c
+++ b/drivers/clocksource/timer-ti-32k.c
@@ -97,6 +97,9 @@ static int __init ti_32k_timer_init(struct device_node *np)
                 return -ENXIO;
         }
 
+        if (!of_machine_is_compatible("ti,am43"))
+                ti_32k_timer.cs.flags |= CLOCK_SOURCE_SUSPEND_NONSTOP;
+
         ti_32k_timer.counter = ti_32k_timer.base;
 
         /*
diff --git a/drivers/cpufreq/qcom-cpufreq-kryo.c b/drivers/cpufreq/qcom-cpufreq-kryo.c
index a1830fa25fc5..2a3675c24032 100644
--- a/drivers/cpufreq/qcom-cpufreq-kryo.c
+++ b/drivers/cpufreq/qcom-cpufreq-kryo.c
@@ -44,7 +44,7 @@ enum _msm8996_version {
 
 struct platform_device *cpufreq_dt_pdev, *kryo_cpufreq_pdev;
 
-static enum _msm8996_version __init qcom_cpufreq_kryo_get_msm_id(void)
+static enum _msm8996_version qcom_cpufreq_kryo_get_msm_id(void)
 {
         size_t len;
         u32 *msm_id;
@@ -222,7 +222,7 @@ static int __init qcom_cpufreq_kryo_init(void)
 }
 module_init(qcom_cpufreq_kryo_init);
 
-static void __init qcom_cpufreq_kryo_exit(void)
+static void __exit qcom_cpufreq_kryo_exit(void)
 {
         platform_device_unregister(kryo_cpufreq_pdev);
         platform_driver_unregister(&qcom_cpufreq_kryo_driver);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
index 0cc5190f4f36..5f3f54073818 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
@@ -258,6 +258,8 @@ int amdgpu_vce_suspend(struct amdgpu_device *adev)
 {
         int i;
 
+        cancel_delayed_work_sync(&adev->vce.idle_work);
+
         if (adev->vce.vcpu_bo == NULL)
                 return 0;
 
@@ -268,7 +270,6 @@ int amdgpu_vce_suspend(struct amdgpu_device *adev)
         if (i == AMDGPU_MAX_VCE_HANDLES)
                 return 0;
 
-        cancel_delayed_work_sync(&adev->vce.idle_work);
         /* TODO: suspending running encoding sessions isn't supported */
         return -EINVAL;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c
index fd654a4406db..400fc74bbae2 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c
@@ -153,11 +153,11 @@ int amdgpu_vcn_suspend(struct amdgpu_device *adev)
         unsigned size;
         void *ptr;
 
+        cancel_delayed_work_sync(&adev->vcn.idle_work);
+
         if (adev->vcn.vcpu_bo == NULL)
                 return 0;
 
-        cancel_delayed_work_sync(&adev->vcn.idle_work);
-
         size = amdgpu_bo_size(adev->vcn.vcpu_bo);
         ptr = adev->vcn.cpu_addr;
 
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index 800f481a6995..96875950845a 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -641,6 +641,87 @@ amdgpu_dm_find_first_crtc_matching_connector(struct drm_atomic_state *state,
         return NULL;
 }
 
+static void emulated_link_detect(struct dc_link *link)
+{
+        struct dc_sink_init_data sink_init_data = { 0 };
+        struct display_sink_capability sink_caps = { 0 };
+        enum dc_edid_status edid_status;
+        struct dc_context *dc_ctx = link->ctx;
+        struct dc_sink *sink = NULL;
+        struct dc_sink *prev_sink = NULL;
+
+        link->type = dc_connection_none;
+        prev_sink = link->local_sink;
+
+        if (prev_sink != NULL)
+                dc_sink_retain(prev_sink);
+
+        switch (link->connector_signal) {
+        case SIGNAL_TYPE_HDMI_TYPE_A: {
+                sink_caps.transaction_type = DDC_TRANSACTION_TYPE_I2C;
+                sink_caps.signal = SIGNAL_TYPE_HDMI_TYPE_A;
+                break;
+        }
+
+        case SIGNAL_TYPE_DVI_SINGLE_LINK: {
+                sink_caps.transaction_type = DDC_TRANSACTION_TYPE_I2C;
+                sink_caps.signal = SIGNAL_TYPE_DVI_SINGLE_LINK;
+                break;
+        }
+
+        case SIGNAL_TYPE_DVI_DUAL_LINK: {
+                sink_caps.transaction_type = DDC_TRANSACTION_TYPE_I2C;
+                sink_caps.signal = SIGNAL_TYPE_DVI_DUAL_LINK;
+                break;
+        }
+
+        case SIGNAL_TYPE_LVDS: {
+                sink_caps.transaction_type = DDC_TRANSACTION_TYPE_I2C;
+                sink_caps.signal = SIGNAL_TYPE_LVDS;
+                break;
+        }
+
+        case SIGNAL_TYPE_EDP: {
+                sink_caps.transaction_type =
+                        DDC_TRANSACTION_TYPE_I2C_OVER_AUX;
+                sink_caps.signal = SIGNAL_TYPE_EDP;
+                break;
+        }
+
+        case SIGNAL_TYPE_DISPLAY_PORT: {
+                sink_caps.transaction_type =
+                        DDC_TRANSACTION_TYPE_I2C_OVER_AUX;
+                sink_caps.signal = SIGNAL_TYPE_VIRTUAL;
+                break;
+        }
+
+        default:
+                DC_ERROR("Invalid connector type! signal:%d\n",
+                        link->connector_signal);
+                return;
+        }
+
+        sink_init_data.link = link;
+        sink_init_data.sink_signal = sink_caps.signal;
+
+        sink = dc_sink_create(&sink_init_data);
+        if (!sink) {
+                DC_ERROR("Failed to create sink!\n");
+                return;
+        }
+
+        link->local_sink = sink;
+
+        edid_status = dm_helpers_read_local_edid(
+                        link->ctx,
+                        link,
+                        sink);
+
+        if (edid_status != EDID_OK)
+                DC_ERROR("Failed to read EDID");
+
+}
+
 static int dm_resume(void *handle)
 {
         struct amdgpu_device *adev = handle;
@@ -654,6 +735,7 @@ static int dm_resume(void *handle)
         struct drm_plane *plane;
         struct drm_plane_state *new_plane_state;
         struct dm_plane_state *dm_new_plane_state;
+        enum dc_connection_type new_connection_type = dc_connection_none;
         int ret;
         int i;
 
@@ -684,7 +766,13 @@ static int dm_resume(void *handle)
                         continue;
 
                 mutex_lock(&aconnector->hpd_lock);
-                dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD);
+                if (!dc_link_detect_sink(aconnector->dc_link, &new_connection_type))
+                        DRM_ERROR("KMS: Failed to detect connector\n");
+
+                if (aconnector->base.force && new_connection_type == dc_connection_none)
+                        emulated_link_detect(aconnector->dc_link);
+                else
+                        dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD);
 
                 if (aconnector->fake_enable && aconnector->dc_link->local_sink)
                         aconnector->fake_enable = false;
@@ -922,6 +1010,7 @@ static void handle_hpd_irq(void *param)
         struct amdgpu_dm_connector *aconnector = (struct amdgpu_dm_connector *)param;
         struct drm_connector *connector = &aconnector->base;
         struct drm_device *dev = connector->dev;
+        enum dc_connection_type new_connection_type = dc_connection_none;
 
         /* In case of failure or MST no need to update connector status or notify the OS
          * since (for MST case) MST does this in it's own context.
@@ -931,7 +1020,21 @@ static void handle_hpd_irq(void *param)
         if (aconnector->fake_enable)
                 aconnector->fake_enable = false;
 
-        if (dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD)) {
+        if (!dc_link_detect_sink(aconnector->dc_link, &new_connection_type))
+                DRM_ERROR("KMS: Failed to detect connector\n");
+
+        if (aconnector->base.force && new_connection_type == dc_connection_none) {
+                emulated_link_detect(aconnector->dc_link);
+
+
+                drm_modeset_lock_all(dev);
+                dm_restore_drm_connector_state(dev, connector);
+                drm_modeset_unlock_all(dev);
+
+                if (aconnector->base.force == DRM_FORCE_UNSPECIFIED)
+                        drm_kms_helper_hotplug_event(dev);
+
+        } else if (dc_link_detect(aconnector->dc_link, DETECT_REASON_HPD)) {
                 amdgpu_dm_update_connector_after_detect(aconnector);
 
 
@@ -1031,6 +1134,7 @@ static void handle_hpd_rx_irq(void *param)
         struct drm_device *dev = connector->dev;
         struct dc_link *dc_link = aconnector->dc_link;
         bool is_mst_root_connector = aconnector->mst_mgr.mst_state;
+        enum dc_connection_type new_connection_type = dc_connection_none;
 
         /* TODO:Temporary add mutex to protect hpd interrupt not have a gpio
          * conflict, after implement i2c helper, this mutex should be
@@ -1042,7 +1146,24 @@ static void handle_hpd_rx_irq(void *param)
         if (dc_link_handle_hpd_rx_irq(dc_link, NULL, NULL) &&
                         !is_mst_root_connector) {
                 /* Downstream Port status changed. */
-                if (dc_link_detect(dc_link, DETECT_REASON_HPDRX)) {
+                if (!dc_link_detect_sink(dc_link, &new_connection_type))
+                        DRM_ERROR("KMS: Failed to detect connector\n");
+
+                if (aconnector->base.force && new_connection_type == dc_connection_none) {
+                        emulated_link_detect(dc_link);
+
+                        if (aconnector->fake_enable)
+                                aconnector->fake_enable = false;
+
+                        amdgpu_dm_update_connector_after_detect(aconnector);
+
+
+                        drm_modeset_lock_all(dev);
+                        dm_restore_drm_connector_state(dev, connector);
+                        drm_modeset_unlock_all(dev);
+
+                        drm_kms_helper_hotplug_event(dev);
+                } else if (dc_link_detect(dc_link, DETECT_REASON_HPDRX)) {
 
                         if (aconnector->fake_enable)
                                 aconnector->fake_enable = false;
@@ -1433,6 +1554,7 @@ static int amdgpu_dm_initialize_drm_device(struct amdgpu_device *adev)
         struct amdgpu_mode_info *mode_info = &adev->mode_info;
         uint32_t link_cnt;
         int32_t total_overlay_planes, total_primary_planes;
+        enum dc_connection_type new_connection_type = dc_connection_none;
 
         link_cnt = dm->dc->caps.max_links;
         if (amdgpu_dm_mode_config_init(dm->adev)) {
@@ -1499,7 +1621,14 @@ static int amdgpu_dm_initialize_drm_device(struct amdgpu_device *adev)
 
                 link = dc_get_link_at_index(dm->dc, i);
 
-                if (dc_link_detect(link, DETECT_REASON_BOOT)) {
+                if (!dc_link_detect_sink(link, &new_connection_type))
+                        DRM_ERROR("KMS: Failed to detect connector\n");
+
+                if (aconnector->base.force && new_connection_type == dc_connection_none) {
+                        emulated_link_detect(link);
+                        amdgpu_dm_update_connector_after_detect(aconnector);
+
+                } else if (dc_link_detect(link, DETECT_REASON_BOOT)) {
                         amdgpu_dm_update_connector_after_detect(aconnector);
                         register_backlight_device(dm, link);
                 }
@@ -2494,7 +2623,7 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector,
         if (dm_state && dm_state->freesync_capable)
                 stream->ignore_msa_timing_param = true;
 finish:
-        if (sink && sink->sink_signal == SIGNAL_TYPE_VIRTUAL)
+        if (sink && sink->sink_signal == SIGNAL_TYPE_VIRTUAL && aconnector->base.force != DRM_FORCE_ON)
                 dc_sink_release(sink);
 
         return stream;
diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link.c b/drivers/gpu/drm/amd/display/dc/core/dc_link.c
index 37eaf72ace54..fced3c1c2ef5 100644
--- a/drivers/gpu/drm/amd/display/dc/core/dc_link.c
+++ b/drivers/gpu/drm/amd/display/dc/core/dc_link.c
@@ -195,7 +195,7 @@ static bool program_hpd_filter(
         return result;
 }
 
-static bool detect_sink(struct dc_link *link, enum dc_connection_type *type)
+bool dc_link_detect_sink(struct dc_link *link, enum dc_connection_type *type)
 {
         uint32_t is_hpd_high = 0;
         struct gpio *hpd_pin;
@@ -604,7 +604,7 @@ bool dc_link_detect(struct dc_link *link, enum dc_detect_reason reason)
         if (link->connector_signal == SIGNAL_TYPE_VIRTUAL)
                 return false;
 
-        if (false == detect_sink(link, &new_connection_type)) {
+        if (false == dc_link_detect_sink(link, &new_connection_type)) {
                 BREAK_TO_DEBUGGER();
                 return false;
         }
diff --git a/drivers/gpu/drm/amd/display/dc/dc_link.h b/drivers/gpu/drm/amd/display/dc/dc_link.h
index d43cefbc43d3..1b48ab9aea89 100644
--- a/drivers/gpu/drm/amd/display/dc/dc_link.h
+++ b/drivers/gpu/drm/amd/display/dc/dc_link.h
@@ -215,6 +215,7 @@ void dc_link_enable_hpd_filter(struct dc_link *link, bool enable);
 
 bool dc_link_is_dp_sink_present(struct dc_link *link);
 
+bool dc_link_detect_sink(struct dc_link *link, enum dc_connection_type *type);
 /*
  * DPCD access interfaces
  */
diff --git a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c
index 14384d9675a8..b2f308766a9e 100644
--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c
+++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c
@@ -2560,7 +2560,7 @@ static void pplib_apply_display_requirements(
         dc->prev_display_config = *pp_display_cfg;
 }
 
-void dce110_set_bandwidth(
+static void dce110_set_bandwidth(
                 struct dc *dc,
                 struct dc_state *context,
                 bool decrease_allowed)
diff --git a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.h b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.h
index e4c5db75c4c6..d6db3dbd9015 100644
--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.h
+++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.h
@@ -68,11 +68,6 @@ void dce110_fill_display_configs(
         const struct dc_state *context,
         struct dm_pp_display_configuration *pp_display_cfg);
 
-void dce110_set_bandwidth(
-                struct dc *dc,
-                struct dc_state *context,
-                bool decrease_allowed);
-
 uint32_t dce110_get_min_vblank_time_us(const struct dc_state *context);
 
 void dp_receiver_power_ctrl(struct dc_link *link, bool on);
diff --git a/drivers/gpu/drm/amd/display/dc/dce120/dce120_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dce120/dce120_hw_sequencer.c
index 5853522a6182..eb0f5f9a973b 100644
--- a/drivers/gpu/drm/amd/display/dc/dce120/dce120_hw_sequencer.c
+++ b/drivers/gpu/drm/amd/display/dc/dce120/dce120_hw_sequencer.c
@@ -244,17 +244,6 @@ static void dce120_update_dchub(
         dh_data->dchub_info_valid = false;
 }
 
-static void dce120_set_bandwidth(
-                struct dc *dc,
-                struct dc_state *context,
-                bool decrease_allowed)
-{
-        if (context->stream_count <= 0)
-                return;
-
-        dce110_set_bandwidth(dc, context, decrease_allowed);
-}
-
 void dce120_hw_sequencer_construct(struct dc *dc)
 {
         /* All registers used by dce11.2 match those in dce11 in offset and
@@ -263,6 +252,5 @@ void dce120_hw_sequencer_construct(struct dc *dc)
         dce110_hw_sequencer_construct(dc);
         dc->hwss.enable_display_power_gating = dce120_enable_display_power_gating;
         dc->hwss.update_dchub = dce120_update_dchub;
-        dc->hwss.set_bandwidth = dce120_set_bandwidth;
 }
 
diff --git a/drivers/gpu/drm/arm/malidp_drv.c b/drivers/gpu/drm/arm/malidp_drv.c
index 08b5bb219816..94d6dabec2dc 100644
--- a/drivers/gpu/drm/arm/malidp_drv.c
+++ b/drivers/gpu/drm/arm/malidp_drv.c
@@ -754,6 +754,7 @@ static int malidp_bind(struct device *dev)
         drm->irq_enabled = true;
 
         ret = drm_vblank_init(drm, drm->mode_config.num_crtc);
+        drm_crtc_vblank_reset(&malidp->crtc);
         if (ret < 0) {
                 DRM_ERROR("failed to initialise vblank\n");
                 goto vblank_fail;
diff --git a/drivers/gpu/drm/arm/malidp_hw.c b/drivers/gpu/drm/arm/malidp_hw.c
index c94a4422e0e9..2781e462c1ed 100644
--- a/drivers/gpu/drm/arm/malidp_hw.c
+++ b/drivers/gpu/drm/arm/malidp_hw.c
@@ -384,7 +384,8 @@ static long malidp500_se_calc_mclk(struct malidp_hw_device *hwdev,
 
 static int malidp500_enable_memwrite(struct malidp_hw_device *hwdev,
                                      dma_addr_t *addrs, s32 *pitches,
-                                     int num_planes, u16 w, u16 h, u32 fmt_id)
+                                     int num_planes, u16 w, u16 h, u32 fmt_id,
+                                     const s16 *rgb2yuv_coeffs)
 {
         u32 base = MALIDP500_SE_MEMWRITE_BASE;
         u32 de_base = malidp_get_block_base(hwdev, MALIDP_DE_BLOCK);
@@ -416,6 +417,16 @@ static int malidp500_enable_memwrite(struct malidp_hw_device *hwdev,
 
         malidp_hw_write(hwdev, MALIDP_DE_H_ACTIVE(w) | MALIDP_DE_V_ACTIVE(h),
                         MALIDP500_SE_MEMWRITE_OUT_SIZE);
+
+        if (rgb2yuv_coeffs) {
+                int i;
+
+                for (i = 0; i < MALIDP_COLORADJ_NUM_COEFFS; i++) {
+                        malidp_hw_write(hwdev, rgb2yuv_coeffs[i],
+                                        MALIDP500_SE_RGB_YUV_COEFFS + i * 4);
+                }
+        }
+
         malidp_hw_setbits(hwdev, MALIDP_SE_MEMWRITE_EN, MALIDP500_SE_CONTROL);
 
         return 0;
@@ -658,7 +669,8 @@ static long malidp550_se_calc_mclk(struct malidp_hw_device *hwdev,
 
 static int malidp550_enable_memwrite(struct malidp_hw_device *hwdev,
                                      dma_addr_t *addrs, s32 *pitches,
-                                     int num_planes, u16 w, u16 h, u32 fmt_id)
+                                     int num_planes, u16 w, u16 h, u32 fmt_id,
+                                     const s16 *rgb2yuv_coeffs)
 {
         u32 base = MALIDP550_SE_MEMWRITE_BASE;
         u32 de_base = malidp_get_block_base(hwdev, MALIDP_DE_BLOCK);
@@ -689,6 +701,15 @@ static int malidp550_enable_memwrite(struct malidp_hw_device *hwdev,
         malidp_hw_setbits(hwdev, MALIDP550_SE_MEMWRITE_ONESHOT | MALIDP_SE_MEMWRITE_EN,
                           MALIDP550_SE_CONTROL);
 
+        if (rgb2yuv_coeffs) {
+                int i;
+
+                for (i = 0; i < MALIDP_COLORADJ_NUM_COEFFS; i++) {
+                        malidp_hw_write(hwdev, rgb2yuv_coeffs[i],
+                                        MALIDP550_SE_RGB_YUV_COEFFS + i * 4);
+                }
+        }
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/arm/malidp_hw.h b/drivers/gpu/drm/arm/malidp_hw.h
index ad2e96915d44..9fc94c08190f 100644
--- a/drivers/gpu/drm/arm/malidp_hw.h
+++ b/drivers/gpu/drm/arm/malidp_hw.h
@@ -191,7 +191,8 @@ struct malidp_hw {
          * @param fmt_id - internal format ID of output buffer
          */
         int (*enable_memwrite)(struct malidp_hw_device *hwdev, dma_addr_t *addrs,
-                               s32 *pitches, int num_planes, u16 w, u16 h, u32 fmt_id);
+                               s32 *pitches, int num_planes, u16 w, u16 h, u32 fmt_id,
+                               const s16 *rgb2yuv_coeffs);
 
         /*
          * Disable the writing to memory of the next frame's content.
diff --git a/drivers/gpu/drm/arm/malidp_mw.c b/drivers/gpu/drm/arm/malidp_mw.c
index ba6ae66387c9..91472e5e0c8b 100644
--- a/drivers/gpu/drm/arm/malidp_mw.c
+++ b/drivers/gpu/drm/arm/malidp_mw.c
@@ -26,6 +26,8 @@ struct malidp_mw_connector_state {
         s32 pitches[2];
         u8 format;
         u8 n_planes;
+        bool rgb2yuv_initialized;
+        const s16 *rgb2yuv_coeffs;
 };
 
 static int malidp_mw_connector_get_modes(struct drm_connector *connector)
@@ -84,7 +86,7 @@ static void malidp_mw_connector_destroy(struct drm_connector *connector)
 static struct drm_connector_state *
 malidp_mw_connector_duplicate_state(struct drm_connector *connector)
 {
-        struct malidp_mw_connector_state *mw_state;
+        struct malidp_mw_connector_state *mw_state, *mw_current_state;
 
         if (WARN_ON(!connector->state))
                 return NULL;
@@ -93,7 +95,10 @@ malidp_mw_connector_duplicate_state(struct drm_connector *connector)
         if (!mw_state)
                 return NULL;
 
-        /* No need to preserve any of our driver-local data */
+        mw_current_state = to_mw_state(connector->state);
+        mw_state->rgb2yuv_coeffs = mw_current_state->rgb2yuv_coeffs;
+        mw_state->rgb2yuv_initialized = mw_current_state->rgb2yuv_initialized;
+
         __drm_atomic_helper_connector_duplicate_state(connector, &mw_state->base);
 
         return &mw_state->base;
@@ -108,6 +113,13 @@ static const struct drm_connector_funcs malidp_mw_connector_funcs = {
         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
 };
 
+static const s16 rgb2yuv_coeffs_bt709_limited[MALIDP_COLORADJ_NUM_COEFFS] = {
+        47,  157,   16,
+        -26,  -87,  112,
+        112, -102,  -10,
+        16,  128,  128
+};
+
 static int
 malidp_mw_encoder_atomic_check(struct drm_encoder *encoder,
                                struct drm_crtc_state *crtc_state,
@@ -157,6 +169,9 @@ malidp_mw_encoder_atomic_check(struct drm_encoder *encoder,
         }
         mw_state->n_planes = n_planes;
 
+        if (fb->format->is_yuv)
+                mw_state->rgb2yuv_coeffs = rgb2yuv_coeffs_bt709_limited;
+
         return 0;
 }
 
@@ -239,10 +254,12 @@ void malidp_mw_atomic_commit(struct drm_device *drm,
 
                 drm_writeback_queue_job(mw_conn, conn_state->writeback_job);
                 conn_state->writeback_job = NULL;
-
                 hwdev->hw->enable_memwrite(hwdev, mw_state->addrs,
                                            mw_state->pitches, mw_state->n_planes,
-                                           fb->width, fb->height, mw_state->format);
+                                           fb->width, fb->height, mw_state->format,
+                                           !mw_state->rgb2yuv_initialized ?
+                                           mw_state->rgb2yuv_coeffs : NULL);
+                mw_state->rgb2yuv_initialized = !!mw_state->rgb2yuv_coeffs;
         } else {
                 DRM_DEV_DEBUG_DRIVER(drm->dev, "Disable memwrite\n");
                 hwdev->hw->disable_memwrite(hwdev);
diff --git a/drivers/gpu/drm/arm/malidp_regs.h b/drivers/gpu/drm/arm/malidp_regs.h
index 3579d36b2a71..6ffe849774f2 100644
--- a/drivers/gpu/drm/arm/malidp_regs.h
+++ b/drivers/gpu/drm/arm/malidp_regs.h
@@ -205,6 +205,7 @@
 #define MALIDP500_SE_BASE               0x00c00
 #define MALIDP500_SE_CONTROL            0x00c0c
 #define MALIDP500_SE_MEMWRITE_OUT_SIZE  0x00c2c
+#define MALIDP500_SE_RGB_YUV_COEFFS     0x00C74
 #define MALIDP500_SE_MEMWRITE_BASE      0x00e00
 #define MALIDP500_DC_IRQ_BASE           0x00f00
 #define MALIDP500_CONFIG_VALID          0x00f00
@@ -238,6 +239,7 @@
 #define MALIDP550_SE_CONTROL            0x08010
 #define   MALIDP550_SE_MEMWRITE_ONESHOT (1 << 7)
 #define MALIDP550_SE_MEMWRITE_OUT_SIZE  0x08030
+#define MALIDP550_SE_RGB_YUV_COEFFS     0x08078
 #define MALIDP550_SE_MEMWRITE_BASE      0x08100
 #define MALIDP550_DC_BASE               0x0c000
 #define MALIDP550_DC_CONTROL            0x0c010
diff --git a/drivers/gpu/drm/drm_panel.c b/drivers/gpu/drm/drm_panel.c
index b902361dee6e..1d9a9d2fe0e0 100644
--- a/drivers/gpu/drm/drm_panel.c
+++ b/drivers/gpu/drm/drm_panel.c
@@ -24,7 +24,6 @@
 #include <linux/err.h>
 #include <linux/module.h>
 
-#include <drm/drm_device.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_panel.h>
 
@@ -105,13 +104,6 @@ int drm_panel_attach(struct drm_panel *panel, struct drm_connector *connector)
         if (panel->connector)
                 return -EBUSY;
 
-        panel->link = device_link_add(connector->dev->dev, panel->dev, 0);
-        if (!panel->link) {
-                dev_err(panel->dev, "failed to link panel to %s\n",
-                        dev_name(connector->dev->dev));
-                return -EINVAL;
-        }
-
         panel->connector = connector;
         panel->drm = connector->dev;
 
@@ -133,8 +125,6 @@ EXPORT_SYMBOL(drm_panel_attach);
  */
 int drm_panel_detach(struct drm_panel *panel)
 {
-        device_link_del(panel->link);
-
         panel->connector = NULL;
         panel->drm = NULL;
 
diff --git a/drivers/gpu/drm/drm_syncobj.c b/drivers/gpu/drm/drm_syncobj.c
index adb3cb27d31e..759278fef35a 100644
--- a/drivers/gpu/drm/drm_syncobj.c
+++ b/drivers/gpu/drm/drm_syncobj.c
@@ -97,6 +97,8 @@ static int drm_syncobj_fence_get_or_add_callback(struct drm_syncobj *syncobj,
 {
         int ret;
 
+        WARN_ON(*fence);
+
         *fence = drm_syncobj_fence_get(syncobj);
         if (*fence)
                 return 1;
@@ -743,6 +745,9 @@ static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs,
 
         if (flags & DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT) {
                 for (i = 0; i < count; ++i) {
+                        if (entries[i].fence)
+                                continue;
+
                         drm_syncobj_fence_get_or_add_callback(syncobjs[i],
                                                               &entries[i].fence,
                                                               &entries[i].syncobj_cb,
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.c b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
index 9b2720b41571..83c1f46670bf 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_drv.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
@@ -592,8 +592,6 @@ static int etnaviv_pdev_probe(struct platform_device *pdev)
         struct device *dev = &pdev->dev;
         struct component_match *match = NULL;
 
-        dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
-
         if (!dev->platform_data) {
                 struct device_node *core_node;
 
@@ -655,13 +653,30 @@ static int __init etnaviv_init(void)
         for_each_compatible_node(np, NULL, "vivante,gc") {
                 if (!of_device_is_available(np))
                         continue;
-                pdev = platform_device_register_simple("etnaviv", -1,
-                                                       NULL, 0);
-                if (IS_ERR(pdev)) {
-                        ret = PTR_ERR(pdev);
+
+                pdev = platform_device_alloc("etnaviv", -1);
+                if (!pdev) {
+                        ret = -ENOMEM;
+                        of_node_put(np);
+                        goto unregister_platform_driver;
+                }
+                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(40);
+                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
+
+                /*
+                 * Apply the same DMA configuration to the virtual etnaviv
+                 * device as the GPU we found. This assumes that all Vivante
+                 * GPUs in the system share the same DMA constraints.
+                 */
+                of_dma_configure(&pdev->dev, np, true);
+
+                ret = platform_device_add(pdev);
+                if (ret) {
+                        platform_device_put(pdev);
                         of_node_put(np);
                         goto unregister_platform_driver;
                 }
+
                 etnaviv_drm = pdev;
                 of_node_put(np);
                 break;
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index 0bee1f4b914e..3208ad6ad540 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -338,6 +338,39 @@ static int add_roce_gid(struct ib_gid_table_entry *entry)
 }
 
 /**
+ * del_gid - Delete GID table entry
+ *
+ * @ib_dev:     IB device whose GID entry to be deleted
+ * @port:       Port number of the IB device
+ * @table:      GID table of the IB device for a port
+ * @ix:         GID entry index to delete
+ *
+ */
+static void del_gid(struct ib_device *ib_dev, u8 port,
+                    struct ib_gid_table *table, int ix)
+{
+        struct ib_gid_table_entry *entry;
+
+        lockdep_assert_held(&table->lock);
+
+        pr_debug("%s device=%s port=%d index=%d gid %pI6\n", __func__,
+                 ib_dev->name, port, ix,
+                 table->data_vec[ix]->attr.gid.raw);
+
+        write_lock_irq(&table->rwlock);
+        entry = table->data_vec[ix];
+        entry->state = GID_TABLE_ENTRY_PENDING_DEL;
+        /*
+         * For non RoCE protocol, GID entry slot is ready to use.
+         */
+        if (!rdma_protocol_roce(ib_dev, port))
+                table->data_vec[ix] = NULL;
+        write_unlock_irq(&table->rwlock);
+
+        put_gid_entry_locked(entry);
+}
+
+/**
  * add_modify_gid - Add or modify GID table entry
  *
  * @table:      GID table in which GID to be added or modified
@@ -358,7 +391,7 @@ static int add_modify_gid(struct ib_gid_table *table,
          * this index.
          */
         if (is_gid_entry_valid(table->data_vec[attr->index]))
-                put_gid_entry(table->data_vec[attr->index]);
+                del_gid(attr->device, attr->port_num, table, attr->index);
 
         /*
          * Some HCA's report multiple GID entries with only one valid GID, and
@@ -386,39 +419,6 @@ done:
         return ret;
 }
 
-/**
- * del_gid - Delete GID table entry
- *
- * @ib_dev:     IB device whose GID entry to be deleted
- * @port:       Port number of the IB device
- * @table:      GID table of the IB device for a port
- * @ix:         GID entry index to delete
- *
- */
-static void del_gid(struct ib_device *ib_dev, u8 port,
-                    struct ib_gid_table *table, int ix)
-{
-        struct ib_gid_table_entry *entry;
-
-        lockdep_assert_held(&table->lock);
-
-        pr_debug("%s device=%s port=%d index=%d gid %pI6\n", __func__,
-                 ib_dev->name, port, ix,
-                 table->data_vec[ix]->attr.gid.raw);
-
-        write_lock_irq(&table->rwlock);
-        entry = table->data_vec[ix];
-        entry->state = GID_TABLE_ENTRY_PENDING_DEL;
-        /*
-         * For non RoCE protocol, GID entry slot is ready to use.
-         */
-        if (!rdma_protocol_roce(ib_dev, port))
-                table->data_vec[ix] = NULL;
-        write_unlock_irq(&table->rwlock);
-
-        put_gid_entry_locked(entry);
-}
-
 /* rwlock should be read locked, or lock should be held */
 static int find_gid(struct ib_gid_table *table, const union ib_gid *gid,
                     const struct ib_gid_attr *val, bool default_gid,
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index 5f437d1570fb..21863ddde63e 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -1759,6 +1759,8 @@ static int ucma_close(struct inode *inode, struct file *filp)
                 mutex_lock(&mut);
                 if (!ctx->closing) {
                         mutex_unlock(&mut);
+                        ucma_put_ctx(ctx);
+                        wait_for_completion(&ctx->comp);
                         /* rdma_destroy_id ensures that no event handlers are
                          * inflight for that id before releasing it.
                          */
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index a21d5214afc3..e012ca80f9d1 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -2027,33 +2027,55 @@ static int modify_qp(struct ib_uverbs_file *file,
 
         if ((cmd->base.attr_mask & IB_QP_CUR_STATE &&
             cmd->base.cur_qp_state > IB_QPS_ERR) ||
-            cmd->base.qp_state > IB_QPS_ERR) {
+            (cmd->base.attr_mask & IB_QP_STATE &&
+            cmd->base.qp_state > IB_QPS_ERR)) {
                 ret = -EINVAL;
                 goto release_qp;
         }
 
-        attr->qp_state            = cmd->base.qp_state;
-        attr->cur_qp_state        = cmd->base.cur_qp_state;
-        attr->path_mtu            = cmd->base.path_mtu;
-        attr->path_mig_state      = cmd->base.path_mig_state;
-        attr->qkey                = cmd->base.qkey;
-        attr->rq_psn              = cmd->base.rq_psn;
-        attr->sq_psn              = cmd->base.sq_psn;
-        attr->dest_qp_num         = cmd->base.dest_qp_num;
-        attr->qp_access_flags     = cmd->base.qp_access_flags;
-        attr->pkey_index          = cmd->base.pkey_index;
-        attr->alt_pkey_index      = cmd->base.alt_pkey_index;
-        attr->en_sqd_async_notify = cmd->base.en_sqd_async_notify;
-        attr->max_rd_atomic       = cmd->base.max_rd_atomic;
-        attr->max_dest_rd_atomic  = cmd->base.max_dest_rd_atomic;
-        attr->min_rnr_timer       = cmd->base.min_rnr_timer;
-        attr->port_num            = cmd->base.port_num;
-        attr->timeout             = cmd->base.timeout;
-        attr->retry_cnt           = cmd->base.retry_cnt;
-        attr->rnr_retry           = cmd->base.rnr_retry;
-        attr->alt_port_num        = cmd->base.alt_port_num;
-        attr->alt_timeout         = cmd->base.alt_timeout;
-        attr->rate_limit          = cmd->rate_limit;
+        if (cmd->base.attr_mask & IB_QP_STATE)
+                attr->qp_state = cmd->base.qp_state;
+        if (cmd->base.attr_mask & IB_QP_CUR_STATE)
+                attr->cur_qp_state = cmd->base.cur_qp_state;
+        if (cmd->base.attr_mask & IB_QP_PATH_MTU)
+                attr->path_mtu = cmd->base.path_mtu;
+        if (cmd->base.attr_mask & IB_QP_PATH_MIG_STATE)
+                attr->path_mig_state = cmd->base.path_mig_state;
+        if (cmd->base.attr_mask & IB_QP_QKEY)
+                attr->qkey = cmd->base.qkey;
+        if (cmd->base.attr_mask & IB_QP_RQ_PSN)
+                attr->rq_psn = cmd->base.rq_psn;
+        if (cmd->base.attr_mask & IB_QP_SQ_PSN)
+                attr->sq_psn = cmd->base.sq_psn;
+        if (cmd->base.attr_mask & IB_QP_DEST_QPN)
+                attr->dest_qp_num = cmd->base.dest_qp_num;
+        if (cmd->base.attr_mask & IB_QP_ACCESS_FLAGS)
+                attr->qp_access_flags = cmd->base.qp_access_flags;
+        if (cmd->base.attr_mask & IB_QP_PKEY_INDEX)
+                attr->pkey_index = cmd->base.pkey_index;
+        if (cmd->base.attr_mask & IB_QP_EN_SQD_ASYNC_NOTIFY)
+                attr->en_sqd_async_notify = cmd->base.en_sqd_async_notify;
+        if (cmd->base.attr_mask & IB_QP_MAX_QP_RD_ATOMIC)
+                attr->max_rd_atomic = cmd->base.max_rd_atomic;
+        if (cmd->base.attr_mask & IB_QP_MAX_DEST_RD_ATOMIC)
+                attr->max_dest_rd_atomic = cmd->base.max_dest_rd_atomic;
+        if (cmd->base.attr_mask & IB_QP_MIN_RNR_TIMER)
+                attr->min_rnr_timer = cmd->base.min_rnr_timer;
+        if (cmd->base.attr_mask & IB_QP_PORT)
+                attr->port_num = cmd->base.port_num;
+        if (cmd->base.attr_mask & IB_QP_TIMEOUT)
+                attr->timeout = cmd->base.timeout;
+        if (cmd->base.attr_mask & IB_QP_RETRY_CNT)
+                attr->retry_cnt = cmd->base.retry_cnt;
+        if (cmd->base.attr_mask & IB_QP_RNR_RETRY)
+                attr->rnr_retry = cmd->base.rnr_retry;
+        if (cmd->base.attr_mask & IB_QP_ALT_PATH) {
+                attr->alt_port_num = cmd->base.alt_port_num;
+                attr->alt_timeout = cmd->base.alt_timeout;
+                attr->alt_pkey_index = cmd->base.alt_pkey_index;
+        }
+        if (cmd->base.attr_mask & IB_QP_RATE_LIMIT)
+                attr->rate_limit = cmd->rate_limit;
 
         if (cmd->base.attr_mask & IB_QP_AV)
                 copy_ah_attr_from_uverbs(qp->device, &attr->ah_attr,
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 6d974e2363df..50152c1b1004 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -440,6 +440,7 @@ static int ib_uverbs_comp_event_close(struct inode *inode, struct file *filp)
                         list_del(&entry->obj_list);
                 kfree(entry);
         }
+        file->ev_queue.is_closed = 1;
         spin_unlock_irq(&file->ev_queue.lock);
 
         uverbs_close_fd(filp);
diff --git a/drivers/infiniband/core/uverbs_uapi.c b/drivers/infiniband/core/uverbs_uapi.c
index 73ea6f0db88f..be854628a7c6 100644
--- a/drivers/infiniband/core/uverbs_uapi.c
+++ b/drivers/infiniband/core/uverbs_uapi.c
@@ -248,6 +248,7 @@ void uverbs_destroy_api(struct uverbs_api *uapi)
                 kfree(rcu_dereference_protected(*slot, true));
                 radix_tree_iter_delete(&uapi->radix, &iter, slot);
         }
+        kfree(uapi);
 }
 
 struct uverbs_api *uverbs_alloc_api(
diff --git a/drivers/infiniband/hw/bnxt_re/main.c b/drivers/infiniband/hw/bnxt_re/main.c
index 20b9f31052bf..85cd1a3593d6 100644
--- a/drivers/infiniband/hw/bnxt_re/main.c
+++ b/drivers/infiniband/hw/bnxt_re/main.c
@@ -78,7 +78,7 @@ static struct list_head bnxt_re_dev_list = LIST_HEAD_INIT(bnxt_re_dev_list);
 /* Mutex to protect the list of bnxt_re devices added */
 static DEFINE_MUTEX(bnxt_re_dev_lock);
 static struct workqueue_struct *bnxt_re_wq;
-static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev, bool lock_wait);
+static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev);
 
 /* SR-IOV helper functions */
 
@@ -182,7 +182,7 @@ static void bnxt_re_shutdown(void *p)
         if (!rdev)
                 return;
 
-        bnxt_re_ib_unreg(rdev, false);
+        bnxt_re_ib_unreg(rdev);
 }
 
 static void bnxt_re_stop_irq(void *handle)
@@ -251,7 +251,7 @@ static struct bnxt_ulp_ops bnxt_re_ulp_ops = {
 /* Driver registration routines used to let the networking driver (bnxt_en)
  * to know that the RoCE driver is now installed
  */
-static int bnxt_re_unregister_netdev(struct bnxt_re_dev *rdev, bool lock_wait)
+static int bnxt_re_unregister_netdev(struct bnxt_re_dev *rdev)
 {
         struct bnxt_en_dev *en_dev;
         int rc;
@@ -260,14 +260,9 @@ static int bnxt_re_unregister_netdev(struct bnxt_re_dev *rdev, bool lock_wait)
                 return -EINVAL;
 
         en_dev = rdev->en_dev;
-        /* Acquire rtnl lock if it is not invokded from netdev event */
-        if (lock_wait)
-                rtnl_lock();
 
         rc = en_dev->en_ops->bnxt_unregister_device(rdev->en_dev,
                                                     BNXT_ROCE_ULP);
-        if (lock_wait)
-                rtnl_unlock();
         return rc;
 }
 
@@ -281,14 +276,12 @@ static int bnxt_re_register_netdev(struct bnxt_re_dev *rdev)
 
         en_dev = rdev->en_dev;
 
-        rtnl_lock();
         rc = en_dev->en_ops->bnxt_register_device(en_dev, BNXT_ROCE_ULP,
                                                   &bnxt_re_ulp_ops, rdev);
-        rtnl_unlock();
         return rc;
 }
 
-static int bnxt_re_free_msix(struct bnxt_re_dev *rdev, bool lock_wait)
+static int bnxt_re_free_msix(struct bnxt_re_dev *rdev)
 {
         struct bnxt_en_dev *en_dev;
         int rc;
@@ -298,13 +291,9 @@ static int bnxt_re_free_msix(struct bnxt_re_dev *rdev, bool lock_wait)
 
         en_dev = rdev->en_dev;
 
-        if (lock_wait)
-                rtnl_lock();
 
         rc = en_dev->en_ops->bnxt_free_msix(rdev->en_dev, BNXT_ROCE_ULP);
 
-        if (lock_wait)
-                rtnl_unlock();
         return rc;
 }
 
@@ -320,7 +309,6 @@ static int bnxt_re_request_msix(struct bnxt_re_dev *rdev)
 
         num_msix_want = min_t(u32, BNXT_RE_MAX_MSIX, num_online_cpus());
 
-        rtnl_lock();
         num_msix_got = en_dev->en_ops->bnxt_request_msix(en_dev, BNXT_ROCE_ULP,
                                                          rdev->msix_entries,
                                                          num_msix_want);
@@ -335,7 +323,6 @@ static int bnxt_re_request_msix(struct bnxt_re_dev *rdev)
         }
         rdev->num_msix = num_msix_got;
 done:
-        rtnl_unlock();
         return rc;
 }
 
@@ -358,24 +345,18 @@ static void bnxt_re_fill_fw_msg(struct bnxt_fw_msg *fw_msg, void *msg,
         fw_msg->timeout = timeout;
 }
 
-static int bnxt_re_net_ring_free(struct bnxt_re_dev *rdev, u16 fw_ring_id,
-                                 bool lock_wait)
+static int bnxt_re_net_ring_free(struct bnxt_re_dev *rdev, u16 fw_ring_id)
 {
         struct bnxt_en_dev *en_dev = rdev->en_dev;
         struct hwrm_ring_free_input req = {0};
         struct hwrm_ring_free_output resp;
         struct bnxt_fw_msg fw_msg;
-        bool do_unlock = false;
         int rc = -EINVAL;
 
         if (!en_dev)
                 return rc;
 
         memset(&fw_msg, 0, sizeof(fw_msg));
-        if (lock_wait) {
-                rtnl_lock();
-                do_unlock = true;
-        }
 
         bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_RING_FREE, -1, -1);
         req.ring_type = RING_ALLOC_REQ_RING_TYPE_L2_CMPL;
@@ -386,8 +367,6 @@ static int bnxt_re_net_ring_free(struct bnxt_re_dev *rdev, u16 fw_ring_id,
         if (rc)
                 dev_err(rdev_to_dev(rdev),
                         "Failed to free HW ring:%d :%#x", req.ring_id, rc);
-        if (do_unlock)
-                rtnl_unlock();
         return rc;
 }
 
@@ -405,7 +384,6 @@ static int bnxt_re_net_ring_alloc(struct bnxt_re_dev *rdev, dma_addr_t *dma_arr,
                 return rc;
 
         memset(&fw_msg, 0, sizeof(fw_msg));
-        rtnl_lock();
         bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_RING_ALLOC, -1, -1);
         req.enables = 0;
         req.page_tbl_addr =  cpu_to_le64(dma_arr[0]);
@@ -426,27 +404,21 @@ static int bnxt_re_net_ring_alloc(struct bnxt_re_dev *rdev, dma_addr_t *dma_arr,
         if (!rc)
                 *fw_ring_id = le16_to_cpu(resp.ring_id);
 
-        rtnl_unlock();
         return rc;
 }
 
 static int bnxt_re_net_stats_ctx_free(struct bnxt_re_dev *rdev,
-                                      u32 fw_stats_ctx_id, bool lock_wait)
+                                      u32 fw_stats_ctx_id)
 {
         struct bnxt_en_dev *en_dev = rdev->en_dev;
         struct hwrm_stat_ctx_free_input req = {0};
         struct bnxt_fw_msg fw_msg;
-        bool do_unlock = false;
         int rc = -EINVAL;
 
         if (!en_dev)
                 return rc;
 
         memset(&fw_msg, 0, sizeof(fw_msg));
-        if (lock_wait) {
-                rtnl_lock();
-                do_unlock = true;
-        }
 
         bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_STAT_CTX_FREE, -1, -1);
         req.stat_ctx_id = cpu_to_le32(fw_stats_ctx_id);
@@ -457,8 +429,6 @@ static int bnxt_re_net_stats_ctx_free(struct bnxt_re_dev *rdev,
                 dev_err(rdev_to_dev(rdev),
                         "Failed to free HW stats context %#x", rc);
 
-        if (do_unlock)
-                rtnl_unlock();
         return rc;
 }
 
@@ -478,7 +448,6 @@ static int bnxt_re_net_stats_ctx_alloc(struct bnxt_re_dev *rdev,
                 return rc;
 
         memset(&fw_msg, 0, sizeof(fw_msg));
-        rtnl_lock();
 
         bnxt_re_init_hwrm_hdr(rdev, (void *)&req, HWRM_STAT_CTX_ALLOC, -1, -1);
         req.update_period_ms = cpu_to_le32(1000);
@@ -490,7 +459,6 @@ static int bnxt_re_net_stats_ctx_alloc(struct bnxt_re_dev *rdev,
         if (!rc)
                 *fw_stats_ctx_id = le32_to_cpu(resp.stat_ctx_id);
 
-        rtnl_unlock();
         return rc;
 }
 
@@ -929,19 +897,19 @@ fail:
         return rc;
 }
 
-static void bnxt_re_free_nq_res(struct bnxt_re_dev *rdev, bool lock_wait)
+static void bnxt_re_free_nq_res(struct bnxt_re_dev *rdev)
 {
         int i;
 
         for (i = 0; i < rdev->num_msix - 1; i++) {
-                bnxt_re_net_ring_free(rdev, rdev->nq[i].ring_id, lock_wait);
+                bnxt_re_net_ring_free(rdev, rdev->nq[i].ring_id);
                 bnxt_qplib_free_nq(&rdev->nq[i]);
         }
 }
 
-static void bnxt_re_free_res(struct bnxt_re_dev *rdev, bool lock_wait)
+static void bnxt_re_free_res(struct bnxt_re_dev *rdev)
 {
-        bnxt_re_free_nq_res(rdev, lock_wait);
+        bnxt_re_free_nq_res(rdev);
 
         if (rdev->qplib_res.dpi_tbl.max) {
                 bnxt_qplib_dealloc_dpi(&rdev->qplib_res,
@@ -1219,7 +1187,7 @@ static int bnxt_re_setup_qos(struct bnxt_re_dev *rdev)
         return 0;
 }
 
-static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev, bool lock_wait)
+static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev)
 {
         int i, rc;
 
@@ -1234,28 +1202,27 @@ static void bnxt_re_ib_unreg(struct bnxt_re_dev *rdev, bool lock_wait)
                 cancel_delayed_work(&rdev->worker);
 
         bnxt_re_cleanup_res(rdev);
-        bnxt_re_free_res(rdev, lock_wait);
+        bnxt_re_free_res(rdev);
 
         if (test_and_clear_bit(BNXT_RE_FLAG_RCFW_CHANNEL_EN, &rdev->flags)) {
                 rc = bnxt_qplib_deinit_rcfw(&rdev->rcfw);
                 if (rc)
                         dev_warn(rdev_to_dev(rdev),
                                  "Failed to deinitialize RCFW: %#x", rc);
-                bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id,
-                                           lock_wait);
+                bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id);
                 bnxt_qplib_free_ctx(rdev->en_dev->pdev, &rdev->qplib_ctx);
                 bnxt_qplib_disable_rcfw_channel(&rdev->rcfw);
-                bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id, lock_wait);
+                bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id);
                 bnxt_qplib_free_rcfw_channel(&rdev->rcfw);
         }
         if (test_and_clear_bit(BNXT_RE_FLAG_GOT_MSIX, &rdev->flags)) {
-                rc = bnxt_re_free_msix(rdev, lock_wait);
+                rc = bnxt_re_free_msix(rdev);
                 if (rc)
                         dev_warn(rdev_to_dev(rdev),
                                  "Failed to free MSI-X vectors: %#x", rc);
         }
         if (test_and_clear_bit(BNXT_RE_FLAG_NETDEV_REGISTERED, &rdev->flags)) {
-                rc = bnxt_re_unregister_netdev(rdev, lock_wait);
+                rc = bnxt_re_unregister_netdev(rdev);
                 if (rc)
                         dev_warn(rdev_to_dev(rdev),
                                  "Failed to unregister with netdev: %#x", rc);
@@ -1276,6 +1243,12 @@ static int bnxt_re_ib_reg(struct bnxt_re_dev *rdev)
 {
         int i, j, rc;
 
+        bool locked;
+
+        /* Acquire rtnl lock through out this function */
+        rtnl_lock();
+        locked = true;
+
         /* Registered a new RoCE device instance to netdev */
         rc = bnxt_re_register_netdev(rdev);
         if (rc) {
@@ -1374,12 +1347,16 @@ static int bnxt_re_ib_reg(struct bnxt_re_dev *rdev)
                 schedule_delayed_work(&rdev->worker, msecs_to_jiffies(30000));
         }
 
+        rtnl_unlock();
+        locked = false;
+
         /* Register ib dev */
         rc = bnxt_re_register_ib(rdev);
         if (rc) {
                 pr_err("Failed to register with IB: %#x\n", rc);
                 goto fail;
         }
+        set_bit(BNXT_RE_FLAG_IBDEV_REGISTERED, &rdev->flags);
         dev_info(rdev_to_dev(rdev), "Device registered successfully");
         for (i = 0; i < ARRAY_SIZE(bnxt_re_attributes); i++) {
                 rc = device_create_file(&rdev->ibdev.dev,
@@ -1395,7 +1372,6 @@ static int bnxt_re_ib_reg(struct bnxt_re_dev *rdev)
                         goto fail;
                 }
         }
-        set_bit(BNXT_RE_FLAG_IBDEV_REGISTERED, &rdev->flags);
         ib_get_eth_speed(&rdev->ibdev, 1, &rdev->active_speed,
                          &rdev->active_width);
         set_bit(BNXT_RE_FLAG_ISSUE_ROCE_STATS, &rdev->flags);
@@ -1404,17 +1380,21 @@ static int bnxt_re_ib_reg(struct bnxt_re_dev *rdev)
 
         return 0;
 free_sctx:
-        bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id, true);
+        bnxt_re_net_stats_ctx_free(rdev, rdev->qplib_ctx.stats.fw_id);
 free_ctx:
         bnxt_qplib_free_ctx(rdev->en_dev->pdev, &rdev->qplib_ctx);
 disable_rcfw:
         bnxt_qplib_disable_rcfw_channel(&rdev->rcfw);
 free_ring:
-        bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id, true);
+        bnxt_re_net_ring_free(rdev, rdev->rcfw.creq_ring_id);
 free_rcfw:
         bnxt_qplib_free_rcfw_channel(&rdev->rcfw);
 fail:
-        bnxt_re_ib_unreg(rdev, true);
+        if (!locked)
+                rtnl_lock();
+        bnxt_re_ib_unreg(rdev);
+        rtnl_unlock();
+
         return rc;
 }
 
@@ -1567,7 +1547,7 @@ static int bnxt_re_netdev_event(struct notifier_block *notifier,
                  */
                 if (atomic_read(&rdev->sched_count) > 0)
                         goto exit;
-                bnxt_re_ib_unreg(rdev, false);
+                bnxt_re_ib_unreg(rdev);
                 bnxt_re_remove_one(rdev);
                 bnxt_re_dev_unreg(rdev);
                 break;
@@ -1646,7 +1626,10 @@ static void __exit bnxt_re_mod_exit(void)
                  */
                 flush_workqueue(bnxt_re_wq);
                 bnxt_re_dev_stop(rdev);
-                bnxt_re_ib_unreg(rdev, true);
+                /* Acquire the rtnl_lock as the L2 resources are freed here */
+                rtnl_lock();
+                bnxt_re_ib_unreg(rdev);
+                rtnl_unlock();
                 bnxt_re_remove_one(rdev);
                 bnxt_re_dev_unreg(rdev);
         }
diff --git a/drivers/infiniband/hw/hfi1/chip.c b/drivers/infiniband/hw/hfi1/chip.c
index 2c19bf772451..e1668bcc2d13 100644
--- a/drivers/infiniband/hw/hfi1/chip.c
+++ b/drivers/infiniband/hw/hfi1/chip.c
@@ -6733,6 +6733,7 @@ void start_freeze_handling(struct hfi1_pportdata *ppd, int flags)
         struct hfi1_devdata *dd = ppd->dd;
         struct send_context *sc;
         int i;
+        int sc_flags;
 
         if (flags & FREEZE_SELF)
                 write_csr(dd, CCE_CTRL, CCE_CTRL_SPC_FREEZE_SMASK);
@@ -6743,11 +6744,13 @@ void start_freeze_handling(struct hfi1_pportdata *ppd, int flags)
         /* notify all SDMA engines that they are going into a freeze */
         sdma_freeze_notify(dd, !!(flags & FREEZE_LINK_DOWN));
 
+        sc_flags = SCF_FROZEN | SCF_HALTED | (flags & FREEZE_LINK_DOWN ?
+                                              SCF_LINK_DOWN : 0);
         /* do halt pre-handling on all enabled send contexts */
         for (i = 0; i < dd->num_send_contexts; i++) {
                 sc = dd->send_contexts[i].sc;
                 if (sc && (sc->flags & SCF_ENABLED))
-                        sc_stop(sc, SCF_FROZEN | SCF_HALTED);
+                        sc_stop(sc, sc_flags);
         }
 
         /* Send context are frozen. Notify user space */
@@ -10674,6 +10677,7 @@ int set_link_state(struct hfi1_pportdata *ppd, u32 state)
                 add_rcvctrl(dd, RCV_CTRL_RCV_PORT_ENABLE_SMASK);
 
                 handle_linkup_change(dd, 1);
+                pio_kernel_linkup(dd);
 
                 /*
                  * After link up, a new link width will have been set.
diff --git a/drivers/infiniband/hw/hfi1/pio.c b/drivers/infiniband/hw/hfi1/pio.c
index c2c1cba5b23b..752057647f09 100644
--- a/drivers/infiniband/hw/hfi1/pio.c
+++ b/drivers/infiniband/hw/hfi1/pio.c
@@ -86,6 +86,7 @@ void pio_send_control(struct hfi1_devdata *dd, int op)
         unsigned long flags;
         int write = 1;  /* write sendctrl back */
         int flush = 0;  /* re-read sendctrl to make sure it is flushed */
+        int i;
 
         spin_lock_irqsave(&dd->sendctrl_lock, flags);
 
@@ -95,9 +96,13 @@ void pio_send_control(struct hfi1_devdata *dd, int op)
                 reg |= SEND_CTRL_SEND_ENABLE_SMASK;
         /* Fall through */
         case PSC_DATA_VL_ENABLE:
+                mask = 0;
+                for (i = 0; i < ARRAY_SIZE(dd->vld); i++)
+                        if (!dd->vld[i].mtu)
+                                mask |= BIT_ULL(i);
                 /* Disallow sending on VLs not enabled */
-                mask = (((~0ull) << num_vls) & SEND_CTRL_UNSUPPORTED_VL_MASK) <<
-                                SEND_CTRL_UNSUPPORTED_VL_SHIFT;
+                mask = (mask & SEND_CTRL_UNSUPPORTED_VL_MASK) <<
+                        SEND_CTRL_UNSUPPORTED_VL_SHIFT;
                 reg = (reg & ~SEND_CTRL_UNSUPPORTED_VL_SMASK) | mask;
                 break;
         case PSC_GLOBAL_DISABLE:
@@ -921,20 +926,18 @@ void sc_free(struct send_context *sc)
 void sc_disable(struct send_context *sc)
 {
         u64 reg;
-        unsigned long flags;
         struct pio_buf *pbuf;
 
         if (!sc)
                 return;
 
         /* do all steps, even if already disabled */
-        spin_lock_irqsave(&sc->alloc_lock, flags);
+        spin_lock_irq(&sc->alloc_lock);
         reg = read_kctxt_csr(sc->dd, sc->hw_context, SC(CTRL));
         reg &= ~SC(CTRL_CTXT_ENABLE_SMASK);
         sc->flags &= ~SCF_ENABLED;
         sc_wait_for_packet_egress(sc, 1);
         write_kctxt_csr(sc->dd, sc->hw_context, SC(CTRL), reg);
-        spin_unlock_irqrestore(&sc->alloc_lock, flags);
 
         /*
          * Flush any waiters.  Once the context is disabled,
@@ -944,7 +947,7 @@ void sc_disable(struct send_context *sc)
          * proceed with the flush.
          */
         udelay(1);
-        spin_lock_irqsave(&sc->release_lock, flags);
+        spin_lock(&sc->release_lock);
         if (sc->sr) {   /* this context has a shadow ring */
                 while (sc->sr_tail != sc->sr_head) {
                         pbuf = &sc->sr[sc->sr_tail].pbuf;
@@ -955,7 +958,8 @@ void sc_disable(struct send_context *sc)
                                 sc->sr_tail = 0;
                 }
         }
-        spin_unlock_irqrestore(&sc->release_lock, flags);
+        spin_unlock(&sc->release_lock);
+        spin_unlock_irq(&sc->alloc_lock);
 }
 
 /* return SendEgressCtxtStatus.PacketOccupancy */
@@ -1178,11 +1182,39 @@ void pio_kernel_unfreeze(struct hfi1_devdata *dd)
                 sc = dd->send_contexts[i].sc;
                 if (!sc || !(sc->flags & SCF_FROZEN) || sc->type == SC_USER)
                         continue;
+                if (sc->flags & SCF_LINK_DOWN)
+                        continue;
 
                 sc_enable(sc);  /* will clear the sc frozen flag */
         }
 }
 
+/**
+ * pio_kernel_linkup() - Re-enable send contexts after linkup event
+ * @dd: valid devive data
+ *
+ * When the link goes down, the freeze path is taken.  However, a link down
+ * event is different from a freeze because if the send context is re-enabled
+ * whowever is sending data will start sending data again, which will hang
+ * any QP that is sending data.
+ *
+ * The freeze path now looks at the type of event that occurs and takes this
+ * path for link down event.
+ */
+void pio_kernel_linkup(struct hfi1_devdata *dd)
+{
+        struct send_context *sc;
+        int i;
+
+        for (i = 0; i < dd->num_send_contexts; i++) {
+                sc = dd->send_contexts[i].sc;
+                if (!sc || !(sc->flags & SCF_LINK_DOWN) || sc->type == SC_USER)
+                        continue;
+
+                sc_enable(sc);  /* will clear the sc link down flag */
+        }
+}
+
 /*
  * Wait for the SendPioInitCtxt.PioInitInProgress bit to clear.
  * Returns:
@@ -1382,11 +1414,10 @@ void sc_stop(struct send_context *sc, int flag)
 {
         unsigned long flags;
 
-        /* mark the context */
-        sc->flags |= flag;
-
         /* stop buffer allocations */
         spin_lock_irqsave(&sc->alloc_lock, flags);
+        /* mark the context */
+        sc->flags |= flag;
         sc->flags &= ~SCF_ENABLED;
         spin_unlock_irqrestore(&sc->alloc_lock, flags);
         wake_up(&sc->halt_wait);
diff --git a/drivers/infiniband/hw/hfi1/pio.h b/drivers/infiniband/hw/hfi1/pio.h
index 058b08f459ab..aaf372c3e5d6 100644
--- a/drivers/infiniband/hw/hfi1/pio.h
+++ b/drivers/infiniband/hw/hfi1/pio.h
@@ -139,6 +139,7 @@ struct send_context {
 #define SCF_IN_FREE 0x02
 #define SCF_HALTED  0x04
 #define SCF_FROZEN  0x08
+#define SCF_LINK_DOWN 0x10
 
 struct send_context_info {
         struct send_context *sc;        /* allocated working context */
@@ -306,6 +307,7 @@ void set_pio_integrity(struct send_context *sc);
 void pio_reset_all(struct hfi1_devdata *dd);
 void pio_freeze(struct hfi1_devdata *dd);
 void pio_kernel_unfreeze(struct hfi1_devdata *dd);
+void pio_kernel_linkup(struct hfi1_devdata *dd);
 
 /* global PIO send control operations */
 #define PSC_GLOBAL_ENABLE 0
diff --git a/drivers/infiniband/hw/hfi1/user_sdma.c b/drivers/infiniband/hw/hfi1/user_sdma.c
index a3a7b33196d6..5c88706121c1 100644
--- a/drivers/infiniband/hw/hfi1/user_sdma.c
+++ b/drivers/infiniband/hw/hfi1/user_sdma.c
@@ -828,7 +828,7 @@ static int user_sdma_send_pkts(struct user_sdma_request *req, unsigned maxpkts)
                         if (READ_ONCE(iovec->offset) == iovec->iov.iov_len) {
                                 if (++req->iov_idx == req->data_iovs) {
                                         ret = -EFAULT;
-                                        goto free_txreq;
+                                        goto free_tx;
                                 }
                                 iovec = &req->iovs[req->iov_idx];
                                 WARN_ON(iovec->offset);
diff --git a/drivers/infiniband/hw/hfi1/verbs.c b/drivers/infiniband/hw/hfi1/verbs.c
index 13374c727b14..a7c586a5589d 100644
--- a/drivers/infiniband/hw/hfi1/verbs.c
+++ b/drivers/infiniband/hw/hfi1/verbs.c
@@ -1582,6 +1582,7 @@ static int hfi1_check_ah(struct ib_device *ibdev, struct rdma_ah_attr *ah_attr)
         struct hfi1_pportdata *ppd;
         struct hfi1_devdata *dd;
         u8 sc5;
+        u8 sl;
 
         if (hfi1_check_mcast(rdma_ah_get_dlid(ah_attr)) &&
             !(rdma_ah_get_ah_flags(ah_attr) & IB_AH_GRH))
@@ -1590,8 +1591,13 @@ static int hfi1_check_ah(struct ib_device *ibdev, struct rdma_ah_attr *ah_attr)
         /* test the mapping for validity */
         ibp = to_iport(ibdev, rdma_ah_get_port_num(ah_attr));
         ppd = ppd_from_ibp(ibp);
-        sc5 = ibp->sl_to_sc[rdma_ah_get_sl(ah_attr)];
         dd = dd_from_ppd(ppd);
+
+        sl = rdma_ah_get_sl(ah_attr);
+        if (sl >= ARRAY_SIZE(ibp->sl_to_sc))
+                return -EINVAL;
+
+        sc5 = ibp->sl_to_sc[sl];
         if (sc_to_vlt(dd, sc5) > num_vls && sc_to_vlt(dd, sc5) != 0xf)
                 return -EINVAL;
         return 0;
diff --git a/drivers/infiniband/hw/mlx5/devx.c b/drivers/infiniband/hw/mlx5/devx.c
index ac116d63e466..f2f11e652dcd 100644
--- a/drivers/infiniband/hw/mlx5/devx.c
+++ b/drivers/infiniband/hw/mlx5/devx.c
@@ -723,6 +723,7 @@ static int UVERBS_HANDLER(MLX5_IB_METHOD_DEVX_OBJ_CREATE)(
                 attrs, MLX5_IB_ATTR_DEVX_OBJ_CREATE_HANDLE);
         struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
         struct mlx5_ib_dev *dev = to_mdev(c->ibucontext.device);
+        u32 out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)];
         struct devx_obj *obj;
         int err;
 
@@ -754,10 +755,12 @@ static int UVERBS_HANDLER(MLX5_IB_METHOD_DEVX_OBJ_CREATE)(
 
         err = uverbs_copy_to(attrs, MLX5_IB_ATTR_DEVX_OBJ_CREATE_CMD_OUT, cmd_out, cmd_out_len);
         if (err)
-                goto obj_free;
+                goto obj_destroy;
 
         return 0;
 
+obj_destroy:
+        mlx5_cmd_exec(obj->mdev, obj->dinbox, obj->dinlen, out, sizeof(out));
 obj_free:
         kfree(obj);
         return err;
diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 444d16520506..0b34e909505f 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -2951,7 +2951,7 @@ static int srp_reset_device(struct scsi_cmnd *scmnd)
 {
         struct srp_target_port *target = host_to_target(scmnd->device->host);
         struct srp_rdma_ch *ch;
-        int i;
+        int i, j;
         u8 status;
 
         shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
@@ -2965,8 +2965,8 @@ static int srp_reset_device(struct scsi_cmnd *scmnd)
 
         for (i = 0; i < target->ch_count; i++) {
                 ch = &target->ch[i];
-                for (i = 0; i < target->req_ring_size; ++i) {
-                        struct srp_request *req = &ch->req_ring[i];
+                for (j = 0; j < target->req_ring_size; ++j) {
+                        struct srp_request *req = &ch->req_ring[j];
 
                         srp_finish_req(ch, req, scmnd->device, DID_RESET << 16);
                 }
diff --git a/drivers/input/keyboard/atakbd.c b/drivers/input/keyboard/atakbd.c
index 6f62da2909ec..6caee807cafa 100644
--- a/drivers/input/keyboard/atakbd.c
+++ b/drivers/input/keyboard/atakbd.c
@@ -75,8 +75,7 @@ MODULE_LICENSE("GPL");
  */
 
 
-static unsigned char atakbd_keycode[0x72] = {   /* American layout */
-        [0]      = KEY_GRAVE,
+static unsigned char atakbd_keycode[0x73] = {   /* American layout */
         [1]      = KEY_ESC,
         [2]      = KEY_1,
         [3]      = KEY_2,
@@ -117,9 +116,9 @@ static unsigned char atakbd_keycode[0x72] = {	/* American layout */
         [38]     = KEY_L,
         [39]     = KEY_SEMICOLON,
         [40]     = KEY_APOSTROPHE,
-        [41]     = KEY_BACKSLASH,       /* FIXME, '#' */
+        [41]     = KEY_GRAVE,
         [42]     = KEY_LEFTSHIFT,
-        [43]     = KEY_GRAVE,           /* FIXME: '~' */
+        [43]     = KEY_BACKSLASH,
         [44]     = KEY_Z,
         [45]     = KEY_X,
         [46]     = KEY_C,
@@ -145,45 +144,34 @@ static unsigned char atakbd_keycode[0x72] = {	/* American layout */
         [66]     = KEY_F8,
         [67]     = KEY_F9,
         [68]     = KEY_F10,
-        [69]     = KEY_ESC,
-        [70]     = KEY_DELETE,
-        [71]     = KEY_KP7,
-        [72]     = KEY_KP8,
-        [73]     = KEY_KP9,
+        [71]     = KEY_HOME,
+        [72]     = KEY_UP,
         [74]     = KEY_KPMINUS,
-        [75]     = KEY_KP4,
-        [76]     = KEY_KP5,
-        [77]     = KEY_KP6,
+        [75]     = KEY_LEFT,
+        [77]     = KEY_RIGHT,
         [78]     = KEY_KPPLUS,
-        [79]     = KEY_KP1,
-        [80]     = KEY_KP2,
-        [81]     = KEY_KP3,
-        [82]     = KEY_KP0,
-        [83]     = KEY_KPDOT,
-        [90]     = KEY_KPLEFTPAREN,
-        [91]     = KEY_KPRIGHTPAREN,
-        [92]     = KEY_KPASTERISK,      /* FIXME */
-        [93]     = KEY_KPASTERISK,
-        [94]     = KEY_KPPLUS,
-        [95]     = KEY_HELP,
+        [80]     = KEY_DOWN,
+        [82]     = KEY_INSERT,
+        [83]     = KEY_DELETE,
         [96]     = KEY_102ND,
-        [97]     = KEY_KPASTERISK,      /* FIXME */
-        [98]     = KEY_KPSLASH,
+        [97]     = KEY_UNDO,
+        [98]     = KEY_HELP,
         [99]     = KEY_KPLEFTPAREN,
         [100]    = KEY_KPRIGHTPAREN,
         [101]    = KEY_KPSLASH,
         [102]    = KEY_KPASTERISK,
-        [103]    = KEY_UP,
-        [104]    = KEY_KPASTERISK,      /* FIXME */
-        [105]    = KEY_LEFT,
-        [106]    = KEY_RIGHT,
-        [107]    = KEY_KPASTERISK,      /* FIXME */
-        [108]    = KEY_DOWN,
-        [109]    = KEY_KPASTERISK,      /* FIXME */
-        [110]    = KEY_KPASTERISK,      /* FIXME */
-        [111]    = KEY_KPASTERISK,      /* FIXME */
-        [112]    = KEY_KPASTERISK,      /* FIXME */
-        [113]    = KEY_KPASTERISK       /* FIXME */
+        [103]    = KEY_KP7,
+        [104]    = KEY_KP8,
+        [105]    = KEY_KP9,
+        [106]    = KEY_KP4,
+        [107]    = KEY_KP5,
+        [108]    = KEY_KP6,
+        [109]    = KEY_KP1,
+        [110]    = KEY_KP2,
+        [111]    = KEY_KP3,
+        [112]    = KEY_KP0,
+        [113]    = KEY_KPDOT,
+        [114]    = KEY_KPENTER,
 };
 
 static struct input_dev *atakbd_dev;
@@ -191,21 +179,15 @@ static struct input_dev *atakbd_dev;
 static void atakbd_interrupt(unsigned char scancode, char down)
 {
 
-        if (scancode < 0x72) {          /* scancodes < 0xf2 are keys */
+        if (scancode < 0x73) {          /* scancodes < 0xf3 are keys */
 
                 // report raw events here?
 
                 scancode = atakbd_keycode[scancode];
 
-                if (scancode == KEY_CAPSLOCK) { /* CapsLock is a toggle switch key on Amiga */
-                        input_report_key(atakbd_dev, scancode, 1);
-                        input_report_key(atakbd_dev, scancode, 0);
-                        input_sync(atakbd_dev);
-                } else {
-                        input_report_key(atakbd_dev, scancode, down);
-                        input_sync(atakbd_dev);
-                }
-        } else                          /* scancodes >= 0xf2 are mouse data, most likely */
+                input_report_key(atakbd_dev, scancode, down);
+                input_sync(atakbd_dev);
+        } else                          /* scancodes >= 0xf3 are mouse data, most likely */
                 printk(KERN_INFO "atakbd: unhandled scancode %x\n", scancode);
 
         return;
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 96a887f33698..eb14ddf69346 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -410,7 +410,7 @@ static int uinput_validate_absinfo(struct input_dev *dev, unsigned int code,
         min = abs->minimum;
         max = abs->maximum;
 
-        if ((min != 0 || max != 0) && max <= min) {
+        if ((min != 0 || max != 0) && max < min) {
                 printk(KERN_DEBUG
                        "%s: invalid abs[%02x] min:%d max:%d\n",
                        UINPUT_NAME, code, min, max);
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c
index 44f57cf6675b..2d95e8d93cc7 100644
--- a/drivers/input/mouse/elantech.c
+++ b/drivers/input/mouse/elantech.c
@@ -1178,6 +1178,8 @@ static const struct dmi_system_id elantech_dmi_has_middle_button[] = {
 static const char * const middle_button_pnp_ids[] = {
         "LEN2131", /* ThinkPad P52 w/ NFC */
         "LEN2132", /* ThinkPad P52 */
+        "LEN2133", /* ThinkPad P72 w/ NFC */
+        "LEN2134", /* ThinkPad P72 */
         NULL
 };
 
diff --git a/drivers/input/touchscreen/egalax_ts.c b/drivers/input/touchscreen/egalax_ts.c
index 80e69bb8283e..83ac8c128192 100644
--- a/drivers/input/touchscreen/egalax_ts.c
+++ b/drivers/input/touchscreen/egalax_ts.c
@@ -241,6 +241,9 @@ static int __maybe_unused egalax_ts_suspend(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         int ret;
 
+        if (device_may_wakeup(dev))
+                return enable_irq_wake(client->irq);
+
         ret = i2c_master_send(client, suspend_cmd, MAX_I2C_DATA_LEN);
         return ret > 0 ? 0 : ret;
 }
@@ -249,6 +252,9 @@ static int __maybe_unused egalax_ts_resume(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
 
+        if (device_may_wakeup(dev))
+                return disable_irq_wake(client->irq);
+
         return egalax_wake_up_device(client);
 }
 
diff --git a/drivers/md/bcache/bcache.h b/drivers/md/bcache/bcache.h
index 83504dd8100a..954dad29e6e8 100644
--- a/drivers/md/bcache/bcache.h
+++ b/drivers/md/bcache/bcache.h
@@ -965,6 +965,7 @@ void bch_prio_write(struct cache *ca);
 void bch_write_bdev_super(struct cached_dev *dc, struct closure *parent);
 
 extern struct workqueue_struct *bcache_wq;
+extern struct workqueue_struct *bch_journal_wq;
 extern struct mutex bch_register_lock;
 extern struct list_head bch_cache_sets;
 
diff --git a/drivers/md/bcache/journal.c b/drivers/md/bcache/journal.c
index 6116bbf870d8..522c7426f3a0 100644
--- a/drivers/md/bcache/journal.c
+++ b/drivers/md/bcache/journal.c
@@ -485,7 +485,7 @@ static void do_journal_discard(struct cache *ca)
 
                 closure_get(&ca->set->cl);
                 INIT_WORK(&ja->discard_work, journal_discard_work);
-                schedule_work(&ja->discard_work);
+                queue_work(bch_journal_wq, &ja->discard_work);
         }
 }
 
@@ -592,7 +592,7 @@ static void journal_write_done(struct closure *cl)
                 : &j->w[0];
 
         __closure_wake_up(&w->wait);
-        continue_at_nobarrier(cl, journal_write, system_wq);
+        continue_at_nobarrier(cl, journal_write, bch_journal_wq);
 }
 
 static void journal_write_unlock(struct closure *cl)
@@ -627,7 +627,7 @@ static void journal_write_unlocked(struct closure *cl)
                 spin_unlock(&c->journal.lock);
 
                 btree_flush_write(c);
-                continue_at(cl, journal_write, system_wq);
+                continue_at(cl, journal_write, bch_journal_wq);
                 return;
         }
 
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index 94c756c66bd7..30ba9aeb5ee8 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -47,6 +47,7 @@ static int bcache_major;
 static DEFINE_IDA(bcache_device_idx);
 static wait_queue_head_t unregister_wait;
 struct workqueue_struct *bcache_wq;
+struct workqueue_struct *bch_journal_wq;
 
 #define BTREE_MAX_PAGES         (256 * 1024 / PAGE_SIZE)
 /* limitation of partitions number on single bcache device */
@@ -2341,6 +2342,9 @@ static void bcache_exit(void)
                 kobject_put(bcache_kobj);
         if (bcache_wq)
                 destroy_workqueue(bcache_wq);
+        if (bch_journal_wq)
+                destroy_workqueue(bch_journal_wq);
+
         if (bcache_major)
                 unregister_blkdev(bcache_major, "bcache");
         unregister_reboot_notifier(&reboot);
@@ -2370,6 +2374,10 @@ static int __init bcache_init(void)
         if (!bcache_wq)
                 goto err;
 
+        bch_journal_wq = alloc_workqueue("bch_journal", WQ_MEM_RECLAIM, 0);
+        if (!bch_journal_wq)
+                goto err;
+
         bcache_kobj = kobject_create_and_add("bcache", fs_kobj);
         if (!bcache_kobj)
                 goto err;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
index b8f75a22fb6c..f152da1ce046 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_msg.h
@@ -753,7 +753,6 @@ struct cpl_abort_req_rss {
 };
 
 struct cpl_abort_req_rss6 {
-        WR_HDR;
         union opcode_tid ot;
         __be32 srqidx_status;
 };
diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
index 5a9562881d4e..9fe3fff818b8 100644
--- a/drivers/nvme/host/multipath.c
+++ b/drivers/nvme/host/multipath.c
@@ -537,8 +537,10 @@ int nvme_mpath_init(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id)
 
         INIT_WORK(&ctrl->ana_work, nvme_ana_work);
         ctrl->ana_log_buf = kmalloc(ctrl->ana_log_size, GFP_KERNEL);
-        if (!ctrl->ana_log_buf)
+        if (!ctrl->ana_log_buf) {
+                error = -ENOMEM;
                 goto out;
+        }
 
         error = nvme_read_ana_log(ctrl, true);
         if (error)
@@ -547,7 +549,7 @@ int nvme_mpath_init(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id)
 out_free_ana_log_buf:
         kfree(ctrl->ana_log_buf);
 out:
-        return -ENOMEM;
+        return error;
 }
 
 void nvme_mpath_uninit(struct nvme_ctrl *ctrl)
diff --git a/drivers/pci/controller/dwc/pcie-designware.c b/drivers/pci/controller/dwc/pcie-designware.c
index 778c4f76a884..2153956a0b20 100644
--- a/drivers/pci/controller/dwc/pcie-designware.c
+++ b/drivers/pci/controller/dwc/pcie-designware.c
@@ -135,7 +135,7 @@ static void dw_pcie_prog_outbound_atu_unroll(struct dw_pcie *pci, int index,
                 if (val & PCIE_ATU_ENABLE)
                         return;
 
-                usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
+                mdelay(LINK_WAIT_IATU);
         }
         dev_err(pci->dev, "Outbound iATU is not being enabled\n");
 }
@@ -178,7 +178,7 @@ void dw_pcie_prog_outbound_atu(struct dw_pcie *pci, int index, int type,
                 if (val & PCIE_ATU_ENABLE)
                         return;
 
-                usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
+                mdelay(LINK_WAIT_IATU);
         }
         dev_err(pci->dev, "Outbound iATU is not being enabled\n");
 }
@@ -236,7 +236,7 @@ static int dw_pcie_prog_inbound_atu_unroll(struct dw_pcie *pci, int index,
                 if (val & PCIE_ATU_ENABLE)
                         return 0;
 
-                usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
+                mdelay(LINK_WAIT_IATU);
         }
         dev_err(pci->dev, "Inbound iATU is not being enabled\n");
 
@@ -282,7 +282,7 @@ int dw_pcie_prog_inbound_atu(struct dw_pcie *pci, int index, int bar,
                 if (val & PCIE_ATU_ENABLE)
                         return 0;
 
-                usleep_range(LINK_WAIT_IATU_MIN, LINK_WAIT_IATU_MAX);
+                mdelay(LINK_WAIT_IATU);
         }
         dev_err(pci->dev, "Inbound iATU is not being enabled\n");
 
diff --git a/drivers/pci/controller/dwc/pcie-designware.h b/drivers/pci/controller/dwc/pcie-designware.h
index 96126fd8403c..9f1a5e399b70 100644
--- a/drivers/pci/controller/dwc/pcie-designware.h
+++ b/drivers/pci/controller/dwc/pcie-designware.h
@@ -26,8 +26,7 @@
 
 /* Parameters for the waiting for iATU enabled routine */
 #define LINK_WAIT_MAX_IATU_RETRIES      5
-#define LINK_WAIT_IATU_MIN              9000
-#define LINK_WAIT_IATU_MAX              10000
+#define LINK_WAIT_IATU                  9
 
 /* Synopsys-specific PCIe configuration registers */
 #define PCIE_PORT_LINK_CONTROL          0x710
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index ef0b1b6ba86f..12afa7fdf77e 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -457,17 +457,18 @@ static void acpiphp_native_scan_bridge(struct pci_dev *bridge)
 /**
  * enable_slot - enable, configure a slot
  * @slot: slot to be enabled
+ * @bridge: true if enable is for the whole bridge (not a single slot)
  *
  * This function should be called per *physical slot*,
  * not per each slot object in ACPI namespace.
  */
-static void enable_slot(struct acpiphp_slot *slot)
+static void enable_slot(struct acpiphp_slot *slot, bool bridge)
 {
         struct pci_dev *dev;
         struct pci_bus *bus = slot->bus;
         struct acpiphp_func *func;
 
-        if (bus->self && hotplug_is_native(bus->self)) {
+        if (bridge && bus->self && hotplug_is_native(bus->self)) {
                 /*
                  * If native hotplug is used, it will take care of hotplug
                  * slot management and resource allocation for hotplug
@@ -701,7 +702,7 @@ static void acpiphp_check_bridge(struct acpiphp_bridge *bridge)
                                         trim_stale_devices(dev);
 
                         /* configure all functions */
-                        enable_slot(slot);
+                        enable_slot(slot, true);
                 } else {
                         disable_slot(slot);
                 }
@@ -785,7 +786,7 @@ static void hotplug_event(u32 type, struct acpiphp_context *context)
                 if (bridge)
                         acpiphp_check_bridge(bridge);
                 else if (!(slot->flags & SLOT_IS_GOING_AWAY))
-                        enable_slot(slot);
+                        enable_slot(slot, false);
 
                 break;
 
@@ -973,7 +974,7 @@ int acpiphp_enable_slot(struct acpiphp_slot *slot)
 
         /* configure all functions */
         if (!(slot->flags & SLOT_ENABLED))
-                enable_slot(slot);
+                enable_slot(slot, false);
 
         pci_unlock_rescan_remove();
         return 0;
diff --git a/drivers/pinctrl/intel/pinctrl-cannonlake.c b/drivers/pinctrl/intel/pinctrl-cannonlake.c
index 8d48371caaa2..e7f45d96b0cb 100644
--- a/drivers/pinctrl/intel/pinctrl-cannonlake.c
+++ b/drivers/pinctrl/intel/pinctrl-cannonlake.c
@@ -15,10 +15,11 @@
 
 #include "pinctrl-intel.h"
 
-#define CNL_PAD_OWN     0x020
-#define CNL_PADCFGLOCK  0x080
-#define CNL_HOSTSW_OWN  0x0b0
-#define CNL_GPI_IE      0x120
+#define CNL_PAD_OWN             0x020
+#define CNL_PADCFGLOCK          0x080
+#define CNL_LP_HOSTSW_OWN       0x0b0
+#define CNL_H_HOSTSW_OWN        0x0c0
+#define CNL_GPI_IE              0x120
 
 #define CNL_GPP(r, s, e, g)                             \
         {                                               \
@@ -30,12 +31,12 @@
 
 #define CNL_NO_GPIO     -1
 
-#define CNL_COMMUNITY(b, s, e, g)                       \
+#define CNL_COMMUNITY(b, s, e, o, g)                    \
         {                                               \
                 .barno = (b),                           \
                 .padown_offset = CNL_PAD_OWN,           \
                 .padcfglock_offset = CNL_PADCFGLOCK,    \
-                .hostown_offset = CNL_HOSTSW_OWN,       \
+                .hostown_offset = (o),                  \
                 .ie_offset = CNL_GPI_IE,                \
                 .pin_base = (s),                        \
                 .npins = ((e) - (s) + 1),               \
@@ -43,6 +44,12 @@
                 .ngpps = ARRAY_SIZE(g),                 \
         }
 
+#define CNLLP_COMMUNITY(b, s, e, g)                     \
+        CNL_COMMUNITY(b, s, e, CNL_LP_HOSTSW_OWN, g)
+
+#define CNLH_COMMUNITY(b, s, e, g)                      \
+        CNL_COMMUNITY(b, s, e, CNL_H_HOSTSW_OWN, g)
+
 /* Cannon Lake-H */
 static const struct pinctrl_pin_desc cnlh_pins[] = {
         /* GPP_A */
@@ -442,10 +449,10 @@ static const struct intel_function cnlh_functions[] = {
 };
 
 static const struct intel_community cnlh_communities[] = {
-        CNL_COMMUNITY(0, 0, 50, cnlh_community0_gpps),
-        CNL_COMMUNITY(1, 51, 154, cnlh_community1_gpps),
-        CNL_COMMUNITY(2, 155, 248, cnlh_community3_gpps),
-        CNL_COMMUNITY(3, 249, 298, cnlh_community4_gpps),
+        CNLH_COMMUNITY(0, 0, 50, cnlh_community0_gpps),
+        CNLH_COMMUNITY(1, 51, 154, cnlh_community1_gpps),
+        CNLH_COMMUNITY(2, 155, 248, cnlh_community3_gpps),
+        CNLH_COMMUNITY(3, 249, 298, cnlh_community4_gpps),
 };
 
 static const struct intel_pinctrl_soc_data cnlh_soc_data = {
@@ -803,9 +810,9 @@ static const struct intel_padgroup cnllp_community4_gpps[] = {
 };
 
 static const struct intel_community cnllp_communities[] = {
-        CNL_COMMUNITY(0, 0, 67, cnllp_community0_gpps),
-        CNL_COMMUNITY(1, 68, 180, cnllp_community1_gpps),
-        CNL_COMMUNITY(2, 181, 243, cnllp_community4_gpps),
+        CNLLP_COMMUNITY(0, 0, 67, cnllp_community0_gpps),
+        CNLLP_COMMUNITY(1, 68, 180, cnllp_community1_gpps),
+        CNLLP_COMMUNITY(2, 181, 243, cnllp_community4_gpps),
 };
 
 static const struct intel_pinctrl_soc_data cnllp_soc_data = {
diff --git a/drivers/pinctrl/intel/pinctrl-intel.c b/drivers/pinctrl/intel/pinctrl-intel.c
index ec8dafc94694..1ea3438ea67e 100644
--- a/drivers/pinctrl/intel/pinctrl-intel.c
+++ b/drivers/pinctrl/intel/pinctrl-intel.c
@@ -887,36 +887,6 @@ static const struct gpio_chip intel_gpio_chip = {
         .set_config = gpiochip_generic_config,
 };
 
-static int intel_gpio_irq_reqres(struct irq_data *d)
-{
-        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
-        int pin;
-        int ret;
-
-        pin = intel_gpio_to_pin(pctrl, irqd_to_hwirq(d), NULL, NULL);
-        if (pin >= 0) {
-                ret = gpiochip_lock_as_irq(gc, pin);
-                if (ret) {
-                        dev_err(pctrl->dev, "unable to lock HW IRQ %d for IRQ\n",
-                                pin);
-                        return ret;
-                }
-        }
-        return 0;
-}
-
-static void intel_gpio_irq_relres(struct irq_data *d)
-{
-        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
-        int pin;
-
-        pin = intel_gpio_to_pin(pctrl, irqd_to_hwirq(d), NULL, NULL);
-        if (pin >= 0)
-                gpiochip_unlock_as_irq(gc, pin);
-}
-
 static void intel_gpio_irq_ack(struct irq_data *d)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
@@ -1132,8 +1102,6 @@ static irqreturn_t intel_gpio_irq(int irq, void *data)
 
 static struct irq_chip intel_gpio_irqchip = {
         .name = "intel-gpio",
-        .irq_request_resources = intel_gpio_irq_reqres,
-        .irq_release_resources = intel_gpio_irq_relres,
         .irq_enable = intel_gpio_irq_enable,
         .irq_ack = intel_gpio_irq_ack,
         .irq_mask = intel_gpio_irq_mask,
diff --git a/drivers/pinctrl/pinctrl-amd.c b/drivers/pinctrl/pinctrl-amd.c
index 41ccc759b8b8..1425c2874d40 100644
--- a/drivers/pinctrl/pinctrl-amd.c
+++ b/drivers/pinctrl/pinctrl-amd.c
@@ -348,21 +348,12 @@ static void amd_gpio_irq_enable(struct irq_data *d)
         unsigned long flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
-        u32 mask = BIT(INTERRUPT_ENABLE_OFF) | BIT(INTERRUPT_MASK_OFF);
 
         raw_spin_lock_irqsave(&gpio_dev->lock, flags);
         pin_reg = readl(gpio_dev->base + (d->hwirq)*4);
         pin_reg |= BIT(INTERRUPT_ENABLE_OFF);
         pin_reg |= BIT(INTERRUPT_MASK_OFF);
         writel(pin_reg, gpio_dev->base + (d->hwirq)*4);
-        /*
-         * When debounce logic is enabled it takes ~900 us before interrupts
-         * can be enabled.  During this "debounce warm up" period the
-         * "INTERRUPT_ENABLE" bit will read as 0. Poll the bit here until it
-         * reads back as 1, signaling that interrupts are now enabled.
-         */
-        while ((readl(gpio_dev->base + (d->hwirq)*4) & mask) != mask)
-                continue;
         raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
 }
 
@@ -426,7 +417,7 @@ static void amd_gpio_irq_eoi(struct irq_data *d)
 static int amd_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
         int ret = 0;
-        u32 pin_reg;
+        u32 pin_reg, pin_reg_irq_en, mask;
         unsigned long flags, irq_flags;
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
         struct amd_gpio *gpio_dev = gpiochip_get_data(gc);
@@ -495,6 +486,28 @@ static int amd_gpio_irq_set_type(struct irq_data *d, unsigned int type)
         }
 
         pin_reg |= CLR_INTR_STAT << INTERRUPT_STS_OFF;
+        /*
+         * If WAKE_INT_MASTER_REG.MaskStsEn is set, a software write to the
+         * debounce registers of any GPIO will block wake/interrupt status
+         * generation for *all* GPIOs for a lenght of time that depends on
+         * WAKE_INT_MASTER_REG.MaskStsLength[11:0].  During this period the
+         * INTERRUPT_ENABLE bit will read as 0.
+         *
+         * We temporarily enable irq for the GPIO whose configuration is
+         * changing, and then wait for it to read back as 1 to know when
+         * debounce has settled and then disable the irq again.
+         * We do this polling with the spinlock held to ensure other GPIO
+         * access routines do not read an incorrect value for the irq enable
+         * bit of other GPIOs.  We keep the GPIO masked while polling to avoid
+         * spurious irqs, and disable the irq again after polling.
+         */
+        mask = BIT(INTERRUPT_ENABLE_OFF);
+        pin_reg_irq_en = pin_reg;
+        pin_reg_irq_en |= mask;
+        pin_reg_irq_en &= ~BIT(INTERRUPT_MASK_OFF);
+        writel(pin_reg_irq_en, gpio_dev->base + (d->hwirq)*4);
+        while ((readl(gpio_dev->base + (d->hwirq)*4) & mask) != mask)
+                continue;
         writel(pin_reg, gpio_dev->base + (d->hwirq)*4);
         raw_spin_unlock_irqrestore(&gpio_dev->lock, flags);
 
diff --git a/drivers/regulator/bd71837-regulator.c b/drivers/regulator/bd71837-regulator.c
index 0f8ac8dec3e1..a1bd8aaf4d98 100644
--- a/drivers/regulator/bd71837-regulator.c
+++ b/drivers/regulator/bd71837-regulator.c
@@ -569,6 +569,25 @@ static int bd71837_probe(struct platform_device *pdev)
                         BD71837_REG_REGLOCK);
         }
 
+        /*
+         * There is a HW quirk in BD71837. The shutdown sequence timings for
+         * bucks/LDOs which are controlled via register interface are changed.
+         * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
+         * beginning of shut-down sequence. As bucks 6 and 7 are parent
+         * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
+         * monitoring to errorneously detect under voltage and force PMIC to
+         * emergency state instead of poweroff. In order to avoid this we
+         * disable voltage monitoring for LDO5 and LDO6
+         */
+        err = regmap_update_bits(pmic->mfd->regmap, BD718XX_REG_MVRFLTMASK2,
+                                 BD718XX_LDO5_VRMON80 | BD718XX_LDO6_VRMON80,
+                                 BD718XX_LDO5_VRMON80 | BD718XX_LDO6_VRMON80);
+        if (err) {
+                dev_err(&pmic->pdev->dev,
+                        "Failed to disable voltage monitoring\n");
+                goto err;
+        }
+
         for (i = 0; i < ARRAY_SIZE(pmic_regulator_inits); i++) {
 
                 struct regulator_desc *desc;
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index bb1324f93143..9577d8941846 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -3161,7 +3161,7 @@ static inline int regulator_suspend_toggle(struct regulator_dev *rdev,
         if (!rstate->changeable)
                 return -EPERM;
 
-        rstate->enabled = en;
+        rstate->enabled = (en) ? ENABLE_IN_SUSPEND : DISABLE_IN_SUSPEND;
 
         return 0;
 }
@@ -4395,13 +4395,13 @@ regulator_register(const struct regulator_desc *regulator_desc,
             !rdev->desc->fixed_uV)
                 rdev->is_switch = true;
 
+        dev_set_drvdata(&rdev->dev, rdev);
         ret = device_register(&rdev->dev);
         if (ret != 0) {
                 put_device(&rdev->dev);
                 goto unset_supplies;
         }
 
-        dev_set_drvdata(&rdev->dev, rdev);
         rdev_init_debugfs(rdev);
 
         /* try to resolve regulators supply since a new one was registered */
diff --git a/drivers/regulator/of_regulator.c b/drivers/regulator/of_regulator.c
index 638f17d4c848..210fc20f7de7 100644
--- a/drivers/regulator/of_regulator.c
+++ b/drivers/regulator/of_regulator.c
@@ -213,8 +213,6 @@ static void of_get_regulation_constraints(struct device_node *np,
                 else if (of_property_read_bool(suspend_np,
                                         "regulator-off-in-suspend"))
                         suspend_state->enabled = DISABLE_IN_SUSPEND;
-                else
-                        suspend_state->enabled = DO_NOTHING_IN_SUSPEND;
 
                 if (!of_property_read_u32(np, "regulator-suspend-min-microvolt",
                                           &pval))
diff --git a/drivers/spi/spi-gpio.c b/drivers/spi/spi-gpio.c
index 0626e6e3ea0c..421bfc7dda67 100644
--- a/drivers/spi/spi-gpio.c
+++ b/drivers/spi/spi-gpio.c
@@ -300,8 +300,8 @@ static int spi_gpio_request(struct device *dev,
                 *mflags |= SPI_MASTER_NO_RX;
 
         spi_gpio->sck = devm_gpiod_get(dev, "sck", GPIOD_OUT_LOW);
-        if (IS_ERR(spi_gpio->mosi))
-                return PTR_ERR(spi_gpio->mosi);
+        if (IS_ERR(spi_gpio->sck))
+                return PTR_ERR(spi_gpio->sck);
 
         for (i = 0; i < num_chipselects; i++) {
                 spi_gpio->cs_gpios[i] = devm_gpiod_get_index(dev, "cs",
diff --git a/drivers/spi/spi-rspi.c b/drivers/spi/spi-rspi.c
index 95dc4d78618d..b37de1d991d6 100644
--- a/drivers/spi/spi-rspi.c
+++ b/drivers/spi/spi-rspi.c
@@ -598,11 +598,13 @@ static int rspi_dma_transfer(struct rspi_data *rspi, struct sg_table *tx,
 
         ret = wait_event_interruptible_timeout(rspi->wait,
                                                rspi->dma_callbacked, HZ);
-        if (ret > 0 && rspi->dma_callbacked)
+        if (ret > 0 && rspi->dma_callbacked) {
                 ret = 0;
-        else if (!ret) {
-                dev_err(&rspi->master->dev, "DMA timeout\n");
-                ret = -ETIMEDOUT;
+        } else {
+                if (!ret) {
+                        dev_err(&rspi->master->dev, "DMA timeout\n");
+                        ret = -ETIMEDOUT;
+                }
                 if (tx)
                         dmaengine_terminate_all(rspi->master->dma_tx);
                 if (rx)
@@ -1350,12 +1352,36 @@ static const struct platform_device_id spi_driver_ids[] = {
 
 MODULE_DEVICE_TABLE(platform, spi_driver_ids);
 
+#ifdef CONFIG_PM_SLEEP
+static int rspi_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rspi_data *rspi = platform_get_drvdata(pdev);
+
+        return spi_master_suspend(rspi->master);
+}
+
+static int rspi_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rspi_data *rspi = platform_get_drvdata(pdev);
+
+        return spi_master_resume(rspi->master);
+}
+
+static SIMPLE_DEV_PM_OPS(rspi_pm_ops, rspi_suspend, rspi_resume);
+#define DEV_PM_OPS      &rspi_pm_ops
+#else
+#define DEV_PM_OPS      NULL
+#endif /* CONFIG_PM_SLEEP */
+
 static struct platform_driver rspi_driver = {
         .probe =        rspi_probe,
         .remove =       rspi_remove,
         .id_table =     spi_driver_ids,
         .driver         = {
                 .name = "renesas_spi",
+                .pm = DEV_PM_OPS,
                 .of_match_table = of_match_ptr(rspi_of_match),
         },
 };
diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c
index 539d6d1a277a..101cd6aae2ea 100644
--- a/drivers/spi/spi-sh-msiof.c
+++ b/drivers/spi/spi-sh-msiof.c
@@ -397,7 +397,8 @@ static void sh_msiof_spi_set_mode_regs(struct sh_msiof_spi_priv *p,
 
 static void sh_msiof_reset_str(struct sh_msiof_spi_priv *p)
 {
-        sh_msiof_write(p, STR, sh_msiof_read(p, STR));
+        sh_msiof_write(p, STR,
+                       sh_msiof_read(p, STR) & ~(STR_TDREQ | STR_RDREQ));
 }
 
 static void sh_msiof_spi_write_fifo_8(struct sh_msiof_spi_priv *p,
@@ -1426,12 +1427,37 @@ static const struct platform_device_id spi_driver_ids[] = {
 };
 MODULE_DEVICE_TABLE(platform, spi_driver_ids);
 
+#ifdef CONFIG_PM_SLEEP
+static int sh_msiof_spi_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_msiof_spi_priv *p = platform_get_drvdata(pdev);
+
+        return spi_master_suspend(p->master);
+}
+
+static int sh_msiof_spi_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_msiof_spi_priv *p = platform_get_drvdata(pdev);
+
+        return spi_master_resume(p->master);
+}
+
+static SIMPLE_DEV_PM_OPS(sh_msiof_spi_pm_ops, sh_msiof_spi_suspend,
+                         sh_msiof_spi_resume);
+#define DEV_PM_OPS      &sh_msiof_spi_pm_ops
+#else
+#define DEV_PM_OPS      NULL
+#endif /* CONFIG_PM_SLEEP */
+
 static struct platform_driver sh_msiof_spi_drv = {
         .probe          = sh_msiof_spi_probe,
         .remove         = sh_msiof_spi_remove,
         .id_table       = spi_driver_ids,
         .driver         = {
                 .name           = "spi_sh_msiof",
+                .pm             = DEV_PM_OPS,
                 .of_match_table = of_match_ptr(sh_msiof_match),
         },
 };
diff --git a/drivers/spi/spi-tegra20-slink.c b/drivers/spi/spi-tegra20-slink.c
index 6f7b946b5ced..1427f343b39a 100644
--- a/drivers/spi/spi-tegra20-slink.c
+++ b/drivers/spi/spi-tegra20-slink.c
@@ -1063,6 +1063,24 @@ static int tegra_slink_probe(struct platform_device *pdev)
                 goto exit_free_master;
         }
 
+        /* disabled clock may cause interrupt storm upon request */
+        tspi->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(tspi->clk)) {
+                ret = PTR_ERR(tspi->clk);
+                dev_err(&pdev->dev, "Can not get clock %d\n", ret);
+                goto exit_free_master;
+        }
+        ret = clk_prepare(tspi->clk);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Clock prepare failed %d\n", ret);
+                goto exit_free_master;
+        }
+        ret = clk_enable(tspi->clk);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Clock enable failed %d\n", ret);
+                goto exit_free_master;
+        }
+
         spi_irq = platform_get_irq(pdev, 0);
         tspi->irq = spi_irq;
         ret = request_threaded_irq(tspi->irq, tegra_slink_isr,
@@ -1071,14 +1089,7 @@ static int tegra_slink_probe(struct platform_device *pdev)
         if (ret < 0) {
                 dev_err(&pdev->dev, "Failed to register ISR for IRQ %d\n",
                                         tspi->irq);
-                goto exit_free_master;
-        }
-
-        tspi->clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(tspi->clk)) {
-                dev_err(&pdev->dev, "can not get clock\n");
-                ret = PTR_ERR(tspi->clk);
-                goto exit_free_irq;
+                goto exit_clk_disable;
         }
 
         tspi->rst = devm_reset_control_get_exclusive(&pdev->dev, "spi");
@@ -1138,6 +1149,8 @@ exit_rx_dma_free:
         tegra_slink_deinit_dma_param(tspi, true);
 exit_free_irq:
         free_irq(spi_irq, tspi);
+exit_clk_disable:
+        clk_disable(tspi->clk);
 exit_free_master:
         spi_master_put(master);
         return ret;
@@ -1150,6 +1163,8 @@ static int tegra_slink_remove(struct platform_device *pdev)
 
         free_irq(tspi->irq, tspi);
 
+        clk_disable(tspi->clk);
+
         if (tspi->tx_dma_chan)
                 tegra_slink_deinit_dma_param(tspi, false);
 
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 7f7ee18fe179..e4bb9386c045 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1448,6 +1448,7 @@ struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
         }
         inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
         ei->i_flags = le32_to_cpu(raw_inode->i_flags);
+        ext2_set_inode_flags(inode);
         ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
         ei->i_frag_no = raw_inode->i_frag;
         ei->i_frag_size = raw_inode->i_fsize;
@@ -1517,7 +1518,6 @@ struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
                            new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
         }
         brelse (bh);
-        ext2_set_inode_flags(inode);
         unlock_new_inode(inode);
         return inode;
         
diff --git a/include/drm/drm_panel.h b/include/drm/drm_panel.h
index 582a0ec0aa70..777814755fa6 100644
--- a/include/drm/drm_panel.h
+++ b/include/drm/drm_panel.h
@@ -89,7 +89,6 @@ struct drm_panel {
         struct drm_device *drm;
         struct drm_connector *connector;
         struct device *dev;
-        struct device_link *link;
 
         const struct drm_panel_funcs *funcs;
 
diff --git a/include/linux/mfd/rohm-bd718x7.h b/include/linux/mfd/rohm-bd718x7.h
index a528747f8aed..e8338e5dc10b 100644
--- a/include/linux/mfd/rohm-bd718x7.h
+++ b/include/linux/mfd/rohm-bd718x7.h
@@ -78,9 +78,9 @@ enum {
         BD71837_REG_TRANS_COND0        = 0x1F,
         BD71837_REG_TRANS_COND1        = 0x20,
         BD71837_REG_VRFAULTEN          = 0x21,
-        BD71837_REG_MVRFLTMASK0        = 0x22,
-        BD71837_REG_MVRFLTMASK1        = 0x23,
-        BD71837_REG_MVRFLTMASK2        = 0x24,
+        BD718XX_REG_MVRFLTMASK0        = 0x22,
+        BD718XX_REG_MVRFLTMASK1        = 0x23,
+        BD718XX_REG_MVRFLTMASK2        = 0x24,
         BD71837_REG_RCVCFG             = 0x25,
         BD71837_REG_RCVNUM             = 0x26,
         BD71837_REG_PWRONCONFIG0       = 0x27,
@@ -159,6 +159,33 @@ enum {
 #define BUCK8_MASK              0x3F
 #define BUCK8_DEFAULT           0x1E
 
+/* BD718XX Voltage monitoring masks */
+#define BD718XX_BUCK1_VRMON80           0x1
+#define BD718XX_BUCK1_VRMON130          0x2
+#define BD718XX_BUCK2_VRMON80           0x4
+#define BD718XX_BUCK2_VRMON130          0x8
+#define BD718XX_1ST_NODVS_BUCK_VRMON80  0x1
+#define BD718XX_1ST_NODVS_BUCK_VRMON130 0x2
+#define BD718XX_2ND_NODVS_BUCK_VRMON80  0x4
+#define BD718XX_2ND_NODVS_BUCK_VRMON130 0x8
+#define BD718XX_3RD_NODVS_BUCK_VRMON80  0x10
+#define BD718XX_3RD_NODVS_BUCK_VRMON130 0x20
+#define BD718XX_4TH_NODVS_BUCK_VRMON80  0x40
+#define BD718XX_4TH_NODVS_BUCK_VRMON130 0x80
+#define BD718XX_LDO1_VRMON80            0x1
+#define BD718XX_LDO2_VRMON80            0x2
+#define BD718XX_LDO3_VRMON80            0x4
+#define BD718XX_LDO4_VRMON80            0x8
+#define BD718XX_LDO5_VRMON80            0x10
+#define BD718XX_LDO6_VRMON80            0x20
+
+/* BD71837 specific voltage monitoring masks */
+#define BD71837_BUCK3_VRMON80           0x10
+#define BD71837_BUCK3_VRMON130          0x20
+#define BD71837_BUCK4_VRMON80           0x40
+#define BD71837_BUCK4_VRMON130          0x80
+#define BD71837_LDO7_VRMON80            0x40
+
 /* BD71837_REG_IRQ bits */
 #define IRQ_SWRST               0x40
 #define IRQ_PWRON_S             0x20
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 3468703d663a..a459a5e973a7 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -48,9 +48,9 @@ struct regulator;
  * DISABLE_IN_SUSPEND   - turn off regulator in suspend states
  * ENABLE_IN_SUSPEND    - keep regulator on in suspend states
  */
-#define DO_NOTHING_IN_SUSPEND   (-1)
-#define DISABLE_IN_SUSPEND      0
-#define ENABLE_IN_SUSPEND       1
+#define DO_NOTHING_IN_SUSPEND   0
+#define DISABLE_IN_SUSPEND      1
+#define ENABLE_IN_SUSPEND       2
 
 /* Regulator active discharge flags */
 enum regulator_active_discharge {
diff --git a/include/linux/spi/spi-mem.h b/include/linux/spi/spi-mem.h
index b2bd4b4127c4..69ee30456864 100644
--- a/include/linux/spi/spi-mem.h
+++ b/include/linux/spi/spi-mem.h
@@ -81,8 +81,10 @@ enum spi_mem_data_dir {
  * @dummy.buswidth: number of IO lanes used to transmit the dummy bytes
  * @data.buswidth: number of IO lanes used to send/receive the data
  * @data.dir: direction of the transfer
- * @data.buf.in: input buffer
- * @data.buf.out: output buffer
+ * @data.nbytes: number of data bytes to send/receive. Can be zero if the
+ *               operation does not involve transferring data
+ * @data.buf.in: input buffer (must be DMA-able)
+ * @data.buf.out: output buffer (must be DMA-able)
  */
 struct spi_mem_op {
         struct {
@@ -105,7 +107,6 @@ struct spi_mem_op {
                 u8 buswidth;
                 enum spi_mem_data_dir dir;
                 unsigned int nbytes;
-                /* buf.{in,out} must be DMA-able. */
                 union {
                         void *in;
                         const void *out;
diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig
index 9bd54304446f..1b1d63b3634b 100644
--- a/kernel/dma/Kconfig
+++ b/kernel/dma/Kconfig
@@ -23,6 +23,9 @@ config ARCH_HAS_SYNC_DMA_FOR_CPU
         bool
         select NEED_DMA_MAP_STATE
 
+config ARCH_HAS_SYNC_DMA_FOR_CPU_ALL
+        bool
+
 config DMA_DIRECT_OPS
         bool
         depends on HAS_DMA
diff --git a/kernel/events/core.c b/kernel/events/core.c
index dcb093e7b377..5a97f34bc14c 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -8314,6 +8314,8 @@ void perf_tp_event(u16 event_type, u64 count, void *record, int entry_size,
                         goto unlock;
 
                 list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
+                        if (event->cpu != smp_processor_id())
+                                continue;
                         if (event->attr.type != PERF_TYPE_TRACEPOINT)
                                 continue;
                         if (event->attr.config != entry->type)
@@ -9431,9 +9433,7 @@ static void free_pmu_context(struct pmu *pmu)
         if (pmu->task_ctx_nr > perf_invalid_context)
                 return;
 
-        mutex_lock(&pmus_lock);
         free_percpu(pmu->pmu_cpu_context);
-        mutex_unlock(&pmus_lock);
 }
 
 /*
@@ -9689,12 +9689,8 @@ EXPORT_SYMBOL_GPL(perf_pmu_register);
 
 void perf_pmu_unregister(struct pmu *pmu)
 {
-        int remove_device;
-
         mutex_lock(&pmus_lock);
-        remove_device = pmu_bus_running;
         list_del_rcu(&pmu->entry);
-        mutex_unlock(&pmus_lock);
 
         /*
          * We dereference the pmu list under both SRCU and regular RCU, so
@@ -9706,13 +9702,14 @@ void perf_pmu_unregister(struct pmu *pmu)
         free_percpu(pmu->pmu_disable_count);
         if (pmu->type >= PERF_TYPE_MAX)
                 idr_remove(&pmu_idr, pmu->type);
-        if (remove_device) {
+        if (pmu_bus_running) {
                 if (pmu->nr_addr_filters)
                         device_remove_file(pmu->dev, &dev_attr_nr_addr_filters);
                 device_del(pmu->dev);
                 put_device(pmu->dev);
         }
         free_pmu_context(pmu);
+        mutex_unlock(&pmus_lock);
 }
 EXPORT_SYMBOL_GPL(perf_pmu_unregister);
 
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/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/event-parse.c b/tools/lib/traceevent/event-parse.c
index ce1e20227c64..7980fc6c3bac 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -24,6 +24,7 @@
 #include <netinet/in.h>
 #include "event-parse.h"
 #include "event-utils.h"
+#include "trace-seq.h"
 
 static const char *input_buf;
 static unsigned long long input_buf_ptr;
@@ -94,7 +95,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 +118,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 +738,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 +770,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 +794,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 +855,7 @@ static void free_arg(struct print_arg *arg)
                 }
                 break;
 
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
         default:
                 break;
         }
@@ -862,24 +863,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 +928,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 +1002,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 +1015,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 +1032,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 +1045,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 +1057,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 +1067,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 +1096,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 +1126,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 +1140,7 @@ static enum event_type read_token(char **tok)
 
         /* not reached */
         *tok = NULL;
-        return EVENT_NONE;
+        return TEP_EVENT_NONE;
 }
 
 /**
@@ -1151,7 +1152,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 +1167,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 +1181,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 +1194,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 +1211,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 +1222,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 +1246,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 +1260,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 +1281,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 +1299,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 +1309,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 +1317,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 +1328,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 +1354,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 +1366,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 +1382,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 +1406,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 +1446,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 +1487,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 +1510,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 +1544,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 +1641,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 +1673,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 +1689,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 +1729,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 +1737,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 +1763,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 +1778,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 +1797,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 +1855,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 +1868,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 +1901,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 +1923,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 +1957,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 +1974,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 +2000,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 +2031,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 +2042,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 +2066,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 +2106,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 +2126,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 +2141,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 +2238,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 +2248,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 +2366,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 +2378,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 +2401,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 +2414,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 +2443,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 +2465,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 +2492,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 +2509,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 +2521,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 +2543,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 +2558,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 +2574,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 +2595,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 +2613,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 +2636,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 +2677,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 +2696,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 +2708,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 +2722,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 +2741,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 +2765,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 +2777,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 +2809,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 +2826,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 +2839,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 +2869,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 +2898,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 +2933,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 +2954,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 +2967,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 +2988,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 +3044,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 +3057,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 +3071,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 +3079,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 +3087,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 +3096,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 +3158,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 +3167,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 +3179,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 +3219,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 +3235,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 +3259,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 +3281,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 +3304,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 +3331,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 +3353,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 +3374,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 +3461,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 +3493,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 +3522,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 +3549,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 +3579,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 +3589,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 +3603,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 +3719,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 +3730,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 +3862,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 +3877,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 +3901,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 +3940,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 +3963,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 +3975,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 +3996,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 +4050,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 +4100,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 +4117,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 +4200,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 +4212,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 +4255,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 +4343,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 +4367,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 +4389,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 +4424,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 +4577,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 +4614,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 +4628,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 +4664,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 +4686,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 +4746,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 +4788,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 +4815,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 +4844,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 +4853,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 +4865,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 +4884,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 +4945,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 +4967,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 +4998,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 +5008,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 +5074,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 +5090,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 +5115,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 +5228,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 +5386,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 +5427,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 +5452,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 +5480,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 +5530,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 +5549,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 +5571,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 +5585,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 +5602,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 +5617,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 +5638,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 +5664,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 +5702,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 +5716,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 +5733,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 +5758,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 +5768,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 +5791,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 +5834,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 +5848,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 +5891,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 +5958,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 +5981,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 +6022,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 +6043,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 +6089,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 +6118,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 +6131,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 +6173,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,7 +6197,7 @@ 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);
 }
 
@@ -6229,7 +6230,7 @@ int tep_strerror(struct tep_handle *pevent __maybe_unused,
         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 +6263,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 +6288,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 +6310,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 +6335,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 +6360,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 +6386,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 +6418,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 +6578,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 +6622,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 +6706,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 +6758,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 +6767,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 +6778,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..9c29a5f7aa39 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,7 +403,7 @@ 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);
+                        const struct tep_plugin_list *list);
 
 struct cmdline;
 struct cmdline_list;
@@ -493,10 +451,10 @@ struct tep_handle {
         unsigned int printk_count;
 
 
-        struct event_format **events;
+        struct tep_event_format **events;
         int nr_events;
-        struct event_format **sort_events;
-        enum event_sort_type last_type;
+        struct tep_event_format **sort_events;
+        enum tep_event_sort_type last_type;
 
         int type_offset;
         int type_size;
@@ -519,15 +477,15 @@ struct tep_handle {
 
         int flags;
 
-        struct format_field *bprint_ip_field;
-        struct format_field *bprint_fmt_field;
-        struct format_field *bprint_buf_field;
+        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 event_format *last_event;
+        struct tep_event_format *last_event;
 
         char *trace_clock;
 };
@@ -538,7 +496,7 @@ static inline void tep_set_flag(struct tep_handle *pevent, int flag)
 }
 
 static inline unsigned short
-__data2host2(struct tep_handle *pevent, unsigned short data)
+__tep_data2host2(struct tep_handle *pevent, unsigned short data)
 {
         unsigned short swap;
 
@@ -552,7 +510,7 @@ __data2host2(struct tep_handle *pevent, unsigned short data)
 }
 
 static inline unsigned int
-__data2host4(struct tep_handle *pevent, unsigned int data)
+__tep_data2host4(struct tep_handle *pevent, unsigned int data)
 {
         unsigned int swap;
 
@@ -568,7 +526,7 @@ __data2host4(struct tep_handle *pevent, unsigned int data)
 }
 
 static inline unsigned long long
-__data2host8(struct tep_handle *pevent, unsigned long long data)
+__tep_data2host8(struct tep_handle *pevent, unsigned long long data)
 {
         unsigned long long swap;
 
@@ -587,14 +545,14 @@ __data2host8(struct tep_handle *pevent, unsigned long long data)
         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 +585,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 +603,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 +644,29 @@ 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_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,17 +677,17 @@ 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);
+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);
 
 static inline int tep_get_cpus(struct tep_handle *pevent)
 {
@@ -798,7 +756,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 +768,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 +905,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..46eb64eb0c2e 100644
--- a/tools/lib/traceevent/event-plugin.c
+++ b/tools/lib/traceevent/event-plugin.c
@@ -15,6 +15,7 @@
 #include <dirent.h>
 #include "event-parse.h"
 #include "event-utils.h"
+#include "trace-seq.h"
 
 #define LOCAL_PLUGIN_DIR ".traceevent/plugins"
 
@@ -30,8 +31,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 +259,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 +271,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 +417,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..d64b6128fa7d 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -16,17 +16,17 @@
 #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 +61,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 +79,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 +94,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 +106,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 +122,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 +165,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 +180,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 +228,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 +242,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 +258,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 +333,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 +347,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 +359,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 +377,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 +394,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 +481,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 +508,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 +525,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 +548,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 +573,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 +605,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 +652,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 +752,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 +804,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 +812,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 +830,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 +839,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 +856,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 +877,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 +904,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 +919,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 +939,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 +960,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 +987,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 +1054,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 +1139,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 +1179,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 +1196,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 +1222,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 +1237,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 +1253,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 +1351,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 +1365,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 +1393,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 +1428,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 +1440,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 +1449,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 +1478,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 +1507,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 +1533,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 +1554,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 +1592,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 +1611,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 +1654,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 +1668,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 +1697,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 +1716,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 +1733,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 +1753,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 +1792,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 +1816,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 +1832,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 +1857,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 +1867,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 +1893,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 +1907,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 +1918,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 +1938,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 +1960,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 +1971,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 +2008,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 +2032,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 +2059,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 +2070,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 +2094,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 +2105,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 +2119,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 +2135,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 +2163,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 +2172,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 +2190,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 +2233,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 +2246,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 +2283,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 +2315,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 +2359,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 +2383,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 +2409,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/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 5224ade3d5af..92514fb3689f 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 76e12bcd1765..c0703979c51d 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",
@@ -1105,7 +1104,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/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..54ca7d87236f 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -121,6 +121,15 @@ static struct test generic_tests[] = {
                 .is_supported = test__bp_signal_is_supported,
         },
         {
+                .desc = "Watchpoint",
+                .func = test__wp,
+                .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..8e26a4148f30 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);
diff --git a/tools/perf/tests/wp.c b/tools/perf/tests/wp.c
new file mode 100644
index 000000000000..017a99317f94
--- /dev/null
+++ b/tools/perf/tests/wp.c
@@ -0,0 +1,229 @@
+// 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;
+}
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..0a6ce9c4fc11 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -33,6 +33,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 +435,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 +519,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 +576,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 +733,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 1a61628a1c12..cb7f01059940 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -2682,7 +2682,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);
 }
@@ -2690,7 +2690,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)
@@ -2698,7 +2698,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;
         }
@@ -2706,7 +2706,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;
@@ -2748,7 +2748,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;
@@ -2940,3 +2940,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 97efbcad076e..1942f6dd24f6 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -35,7 +35,7 @@ class install_lib(_install_lib):
 
 cflags = getenv('CFLAGS', '').split()
 # switch off several checks (need to be at the end of cflags list)
-cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter' ]
+cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter', '-Wno-redundant-decls' ]
 if cc != "clang":
     cflags += ['-Wno-cast-function-type' ]
 
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/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-parse.c b/tools/perf/util/trace-event-parse.c
index e76214f8d596..a4d7de1c96d1 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -33,8 +33,8 @@ 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)
@@ -94,9 +94,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 +108,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 +130,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);
@@ -188,8 +188,8 @@ 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;
 
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 3dfc1db6b25b..b98ee2a2eb44 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)
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/testing/selftests/powerpc/alignment/Makefile b/tools/testing/selftests/powerpc/alignment/Makefile
index 93baacab7693..d056486f49de 100644
--- a/tools/testing/selftests/powerpc/alignment/Makefile
+++ b/tools/testing/selftests/powerpc/alignment/Makefile
@@ -1,5 +1,6 @@
 TEST_GEN_PROGS := copy_first_unaligned alignment_handler
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c ../utils.c
diff --git a/tools/testing/selftests/powerpc/benchmarks/Makefile b/tools/testing/selftests/powerpc/benchmarks/Makefile
index b4d7432a0ecd..d40300a65b42 100644
--- a/tools/testing/selftests/powerpc/benchmarks/Makefile
+++ b/tools/testing/selftests/powerpc/benchmarks/Makefile
@@ -4,6 +4,7 @@ TEST_GEN_FILES := exec_target
 
 CFLAGS += -O2
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c
diff --git a/tools/testing/selftests/powerpc/cache_shape/Makefile b/tools/testing/selftests/powerpc/cache_shape/Makefile
index 1be547434a49..ede4d3dae750 100644
--- a/tools/testing/selftests/powerpc/cache_shape/Makefile
+++ b/tools/testing/selftests/powerpc/cache_shape/Makefile
@@ -5,6 +5,7 @@ all: $(TEST_PROGS)
 
 $(TEST_PROGS): ../harness.c ../utils.c
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 clean:
diff --git a/tools/testing/selftests/powerpc/copyloops/Makefile b/tools/testing/selftests/powerpc/copyloops/Makefile
index 1cf89a34d97c..44574f3818b3 100644
--- a/tools/testing/selftests/powerpc/copyloops/Makefile
+++ b/tools/testing/selftests/powerpc/copyloops/Makefile
@@ -17,6 +17,7 @@ TEST_GEN_PROGS := copyuser_64_t0 copyuser_64_t1 copyuser_64_t2 \
 
 EXTRA_SOURCES := validate.c ../harness.c stubs.S
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(OUTPUT)/copyuser_64_t%:       copyuser_64.S $(EXTRA_SOURCES)
diff --git a/tools/testing/selftests/powerpc/dscr/Makefile b/tools/testing/selftests/powerpc/dscr/Makefile
index 55d7db7a616b..5df476364b4d 100644
--- a/tools/testing/selftests/powerpc/dscr/Makefile
+++ b/tools/testing/selftests/powerpc/dscr/Makefile
@@ -3,6 +3,7 @@ TEST_GEN_PROGS := dscr_default_test dscr_explicit_test dscr_user_test	\
               dscr_inherit_test dscr_inherit_exec_test dscr_sysfs_test  \
               dscr_sysfs_thread_test
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(OUTPUT)/dscr_default_test: LDLIBS += -lpthread
diff --git a/tools/testing/selftests/powerpc/math/Makefile b/tools/testing/selftests/powerpc/math/Makefile
index 0dd3a01fdab9..11a10d7a2bbd 100644
--- a/tools/testing/selftests/powerpc/math/Makefile
+++ b/tools/testing/selftests/powerpc/math/Makefile
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0
 TEST_GEN_PROGS := fpu_syscall fpu_preempt fpu_signal vmx_syscall vmx_preempt vmx_signal vsx_preempt
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c
diff --git a/tools/testing/selftests/powerpc/mm/Makefile b/tools/testing/selftests/powerpc/mm/Makefile
index 8ebbe96d80a8..33ced6e0ad25 100644
--- a/tools/testing/selftests/powerpc/mm/Makefile
+++ b/tools/testing/selftests/powerpc/mm/Makefile
@@ -5,6 +5,7 @@ noarg:
 TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors
 TEST_GEN_FILES := tempfile
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c
diff --git a/tools/testing/selftests/powerpc/pmu/Makefile b/tools/testing/selftests/powerpc/pmu/Makefile
index 6e1629bf5b09..19046db995fe 100644
--- a/tools/testing/selftests/powerpc/pmu/Makefile
+++ b/tools/testing/selftests/powerpc/pmu/Makefile
@@ -5,6 +5,7 @@ noarg:
 TEST_GEN_PROGS := count_instructions l3_bank_test per_event_excludes
 EXTRA_SOURCES := ../harness.c event.c lib.c ../utils.c
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 all: $(TEST_GEN_PROGS) ebb
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/Makefile b/tools/testing/selftests/powerpc/pmu/ebb/Makefile
index c4e64bc2e265..bd5dfa509272 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/Makefile
+++ b/tools/testing/selftests/powerpc/pmu/ebb/Makefile
@@ -17,6 +17,7 @@ TEST_GEN_PROGS := reg_access_test event_attributes_test cycles_test	\
          lost_exception_test no_handler_test                    \
          cycles_with_mmcr2_test
 
+top_srcdir = ../../../../../..
 include ../../../lib.mk
 
 $(TEST_GEN_PROGS): ../../harness.c ../../utils.c ../event.c ../lib.c \
diff --git a/tools/testing/selftests/powerpc/primitives/Makefile b/tools/testing/selftests/powerpc/primitives/Makefile
index 175366db7be8..ea2b7bd09e36 100644
--- a/tools/testing/selftests/powerpc/primitives/Makefile
+++ b/tools/testing/selftests/powerpc/primitives/Makefile
@@ -2,6 +2,7 @@ CFLAGS += -I$(CURDIR)
 
 TEST_GEN_PROGS := load_unaligned_zeropad
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c
diff --git a/tools/testing/selftests/powerpc/ptrace/Makefile b/tools/testing/selftests/powerpc/ptrace/Makefile
index 28f5b781a553..923d531265f8 100644
--- a/tools/testing/selftests/powerpc/ptrace/Makefile
+++ b/tools/testing/selftests/powerpc/ptrace/Makefile
@@ -4,6 +4,7 @@ TEST_PROGS := ptrace-gpr ptrace-tm-gpr ptrace-tm-spd-gpr \
               ptrace-tm-spd-vsx ptrace-tm-spr ptrace-hwbreak ptrace-pkey core-pkey \
               perf-hwbreak
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 all: $(TEST_PROGS)
diff --git a/tools/testing/selftests/powerpc/signal/Makefile b/tools/testing/selftests/powerpc/signal/Makefile
index a7cbd5082e27..1fca25c6ace0 100644
--- a/tools/testing/selftests/powerpc/signal/Makefile
+++ b/tools/testing/selftests/powerpc/signal/Makefile
@@ -8,6 +8,7 @@ $(TEST_PROGS): ../harness.c ../utils.c signal.S
 CFLAGS += -maltivec
 signal_tm: CFLAGS += -mhtm
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 clean:
diff --git a/tools/testing/selftests/powerpc/stringloops/Makefile b/tools/testing/selftests/powerpc/stringloops/Makefile
index 10b35c87a4f4..7fc0623d85c3 100644
--- a/tools/testing/selftests/powerpc/stringloops/Makefile
+++ b/tools/testing/selftests/powerpc/stringloops/Makefile
@@ -29,6 +29,7 @@ endif
 
 ASFLAGS = $(CFLAGS)
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): $(EXTRA_SOURCES)
diff --git a/tools/testing/selftests/powerpc/switch_endian/Makefile b/tools/testing/selftests/powerpc/switch_endian/Makefile
index 30b8ff8fb82e..fcd2dcb8972b 100644
--- a/tools/testing/selftests/powerpc/switch_endian/Makefile
+++ b/tools/testing/selftests/powerpc/switch_endian/Makefile
@@ -5,6 +5,7 @@ ASFLAGS += -O2 -Wall -g -nostdlib -m64
 
 EXTRA_CLEAN = $(OUTPUT)/*.o $(OUTPUT)/check-reversed.S
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(OUTPUT)/switch_endian_test: $(OUTPUT)/check-reversed.S
diff --git a/tools/testing/selftests/powerpc/syscalls/Makefile b/tools/testing/selftests/powerpc/syscalls/Makefile
index da22ca7c38c1..161b8846336f 100644
--- a/tools/testing/selftests/powerpc/syscalls/Makefile
+++ b/tools/testing/selftests/powerpc/syscalls/Makefile
@@ -2,6 +2,7 @@ TEST_GEN_PROGS := ipc_unmuxed
 
 CFLAGS += -I../../../../../usr/include
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c
diff --git a/tools/testing/selftests/powerpc/tm/Makefile b/tools/testing/selftests/powerpc/tm/Makefile
index c0e45d2dde25..9fc2cf6fbc92 100644
--- a/tools/testing/selftests/powerpc/tm/Makefile
+++ b/tools/testing/selftests/powerpc/tm/Makefile
@@ -6,6 +6,7 @@ TEST_GEN_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack
         tm-vmxcopy tm-fork tm-tar tm-tmspr tm-vmx-unavail tm-unavailable tm-trap \
         $(SIGNAL_CONTEXT_CHK_TESTS) tm-sigreturn
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c ../utils.c
diff --git a/tools/testing/selftests/powerpc/vphn/Makefile b/tools/testing/selftests/powerpc/vphn/Makefile
index f8ced26748f8..fb82068c9fda 100644
--- a/tools/testing/selftests/powerpc/vphn/Makefile
+++ b/tools/testing/selftests/powerpc/vphn/Makefile
@@ -2,6 +2,7 @@ TEST_GEN_PROGS := test-vphn
 
 CFLAGS += -m64
 
+top_srcdir = ../../../../..
 include ../../lib.mk
 
 $(TEST_GEN_PROGS): ../harness.c