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

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

  Kernel side changes:

   - Kprobes and uprobes changes:
      - Make their trampolines read-only while they are used
      - Make UPROBES_EVENTS default-y which is the distro practice
      - Apply misc fixes and robustization to probe point insertion.

   - add support for AMD IOMMU events

   - extend hw events on Intel Goldmont CPUs

   - ... plus misc fixes and updates.

  Tooling side changes:

   - support s390 jump instructions in perf annotate (Christian
     Borntraeger)

   - vendor hardware events updates (Andi Kleen)

   - add argument support for SDT events in powerpc (Ravi Bangoria)

   - beautify the statx syscall arguments in 'perf trace' (Arnaldo
     Carvalho de Melo)

   - handle inline functions in callchains (Jin Yao)

   - enable sorting by srcline as key (Milian Wolff)

   - add 'brstackinsn' field in 'perf script' to reuse the x86
     instruction decoder used in the Intel PT code to study hot paths to
     samples (Andi Kleen)

   - add PERF_RECORD_NAMESPACES so that the kernel can record
     information required to associate samples to namespaces, helping in
     container problem characterization. (Hari Bathini)

   - allow sorting by symbol_size in 'perf report' and 'perf top'
     (Charles Baylis)

   - in perf stat, make system wide (-a) the default option if no target
     was specified and one of following conditions is met:
      - no workload specified (current behaviour)
      - a workload is specified but all requested events are system wide
        ones, like uncore ones. (Jiri Olsa)

   - ... plus lots of other updates, enhancements, cleanups and fixes"

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (235 commits)
  perf tools: Fix the code to strip command name
  tools arch x86: Sync cpufeatures.h
  tools arch: Sync arch/x86/lib/memcpy_64.S with the kernel
  tools: Update asm-generic/mman-common.h copy from the kernel
  perf tools: Use just forward declarations for struct thread where possible
  perf tools: Add the right header to obtain PERF_ALIGN()
  perf tools: Remove poll.h and wait.h from util.h
  perf tools: Remove string.h, unistd.h and sys/stat.h from util.h
  perf tools: Remove stale prototypes from builtin.h
  perf tools: Remove string.h from util.h
  perf tools: Remove sys/ioctl.h from util.h
  perf tools: Remove a few more needless includes from util.h
  perf tools: Include sys/param.h where needed
  perf callchain: Move callchain specific routines from util.[ch]
  perf tools: Add compress.h for the *_decompress_to_file() headers
  perf mem: Fix display of data source snoop indication
  perf debug: Move dump_stack() and sighandler_dump_stack() to debug.h
  perf kvm: Make function only used by 'perf kvm' static
  perf tools: Move timestamp routines from util.h to time-utils.h
  perf tools: Move units conversion/formatting routines to separate object
  ...

325 files changed, 7363 insertions, 1753 deletions

diff --git a/tools/arch/arm/include/uapi/asm/kvm.h b/tools/arch/arm/include/uapi/asm/kvm.h
index af05f8e0903e..6ebd3e6a1fd1 100644
--- a/tools/arch/arm/include/uapi/asm/kvm.h
+++ b/tools/arch/arm/include/uapi/asm/kvm.h
@@ -181,10 +181,23 @@ struct kvm_arch_memory_slot {
 #define KVM_DEV_ARM_VGIC_GRP_CPU_REGS   2
 #define   KVM_DEV_ARM_VGIC_CPUID_SHIFT  32
 #define   KVM_DEV_ARM_VGIC_CPUID_MASK   (0xffULL << KVM_DEV_ARM_VGIC_CPUID_SHIFT)
+#define   KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT 32
+#define   KVM_DEV_ARM_VGIC_V3_MPIDR_MASK \
+                        (0xffffffffULL << KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT)
 #define   KVM_DEV_ARM_VGIC_OFFSET_SHIFT 0
 #define   KVM_DEV_ARM_VGIC_OFFSET_MASK  (0xffffffffULL << KVM_DEV_ARM_VGIC_OFFSET_SHIFT)
+#define   KVM_DEV_ARM_VGIC_SYSREG_INSTR_MASK (0xffff)
 #define KVM_DEV_ARM_VGIC_GRP_NR_IRQS    3
 #define KVM_DEV_ARM_VGIC_GRP_CTRL       4
+#define KVM_DEV_ARM_VGIC_GRP_REDIST_REGS 5
+#define KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS 6
+#define KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO  7
+#define KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_SHIFT  10
+#define KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_MASK \
+                        (0x3fffffULL << KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_SHIFT)
+#define KVM_DEV_ARM_VGIC_LINE_LEVEL_INTID_MASK 0x3ff
+#define VGIC_LEVEL_INFO_LINE_LEVEL      0
+
 #define   KVM_DEV_ARM_VGIC_CTRL_INIT    0
 
 /* KVM_IRQ_LINE irq field index values */
diff --git a/tools/arch/arm64/include/uapi/asm/kvm.h b/tools/arch/arm64/include/uapi/asm/kvm.h
index 3051f86a9b5f..c2860358ae3e 100644
--- a/tools/arch/arm64/include/uapi/asm/kvm.h
+++ b/tools/arch/arm64/include/uapi/asm/kvm.h
@@ -201,10 +201,23 @@ struct kvm_arch_memory_slot {
 #define KVM_DEV_ARM_VGIC_GRP_CPU_REGS   2
 #define   KVM_DEV_ARM_VGIC_CPUID_SHIFT  32
 #define   KVM_DEV_ARM_VGIC_CPUID_MASK   (0xffULL << KVM_DEV_ARM_VGIC_CPUID_SHIFT)
+#define   KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT 32
+#define   KVM_DEV_ARM_VGIC_V3_MPIDR_MASK \
+                        (0xffffffffULL << KVM_DEV_ARM_VGIC_V3_MPIDR_SHIFT)
 #define   KVM_DEV_ARM_VGIC_OFFSET_SHIFT 0
 #define   KVM_DEV_ARM_VGIC_OFFSET_MASK  (0xffffffffULL << KVM_DEV_ARM_VGIC_OFFSET_SHIFT)
+#define   KVM_DEV_ARM_VGIC_SYSREG_INSTR_MASK (0xffff)
 #define KVM_DEV_ARM_VGIC_GRP_NR_IRQS    3
 #define KVM_DEV_ARM_VGIC_GRP_CTRL       4
+#define KVM_DEV_ARM_VGIC_GRP_REDIST_REGS 5
+#define KVM_DEV_ARM_VGIC_GRP_CPU_SYSREGS 6
+#define KVM_DEV_ARM_VGIC_GRP_LEVEL_INFO  7
+#define KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_SHIFT  10
+#define KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_MASK \
+                        (0x3fffffULL << KVM_DEV_ARM_VGIC_LINE_LEVEL_INFO_SHIFT)
+#define KVM_DEV_ARM_VGIC_LINE_LEVEL_INTID_MASK  0x3ff
+#define VGIC_LEVEL_INFO_LINE_LEVEL      0
+
 #define   KVM_DEV_ARM_VGIC_CTRL_INIT    0
 
 /* Device Control API on vcpu fd */
diff --git a/tools/arch/powerpc/include/uapi/asm/kvm.h b/tools/arch/powerpc/include/uapi/asm/kvm.h
index 3603b6f51b11..4edbe4bb0e8b 100644
--- a/tools/arch/powerpc/include/uapi/asm/kvm.h
+++ b/tools/arch/powerpc/include/uapi/asm/kvm.h
@@ -413,6 +413,26 @@ struct kvm_get_htab_header {
         __u16   n_invalid;
 };
 
+/* For KVM_PPC_CONFIGURE_V3_MMU */
+struct kvm_ppc_mmuv3_cfg {
+        __u64   flags;
+        __u64   process_table;  /* second doubleword of partition table entry */
+};
+
+/* Flag values for KVM_PPC_CONFIGURE_V3_MMU */
+#define KVM_PPC_MMUV3_RADIX     1       /* 1 = radix mode, 0 = HPT */
+#define KVM_PPC_MMUV3_GTSE      2       /* global translation shootdown enb. */
+
+/* For KVM_PPC_GET_RMMU_INFO */
+struct kvm_ppc_rmmu_info {
+        struct kvm_ppc_radix_geom {
+                __u8    page_shift;
+                __u8    level_bits[4];
+                __u8    pad[3];
+        }       geometries[8];
+        __u32   ap_encodings[8];
+};
+
 /* Per-vcpu XICS interrupt controller state */
 #define KVM_REG_PPC_ICP_STATE   (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x8c)
 
@@ -613,5 +633,7 @@ struct kvm_get_htab_header {
 #define  KVM_XICS_LEVEL_SENSITIVE       (1ULL << 40)
 #define  KVM_XICS_MASKED                (1ULL << 41)
 #define  KVM_XICS_PENDING               (1ULL << 42)
+#define  KVM_XICS_PRESENTED             (1ULL << 43)
+#define  KVM_XICS_QUEUED                (1ULL << 44)
 
 #endif /* __LINUX_KVM_POWERPC_H */
diff --git a/tools/arch/x86/include/asm/atomic.h b/tools/arch/x86/include/asm/atomic.h
index 059e33e94260..328eeceec709 100644
--- a/tools/arch/x86/include/asm/atomic.h
+++ b/tools/arch/x86/include/asm/atomic.h
@@ -7,6 +7,8 @@
 
 #define LOCK_PREFIX "\n\tlock; "
 
+#include <asm/cmpxchg.h>
+
 /*
  * Atomic operations that C can't guarantee us.  Useful for
  * resource counting etc..
@@ -62,4 +64,9 @@ static inline int atomic_dec_and_test(atomic_t *v)
         GEN_UNARY_RMWcc(LOCK_PREFIX "decl", v->counter, "%0", "e");
 }
 
+static __always_inline int atomic_cmpxchg(atomic_t *v, int old, int new)
+{
+        return cmpxchg(&v->counter, old, new);
+}
+
 #endif /* _TOOLS_LINUX_ASM_X86_ATOMIC_H */
diff --git a/tools/arch/x86/include/asm/cmpxchg.h b/tools/arch/x86/include/asm/cmpxchg.h
new file mode 100644
index 000000000000..f5253260f3cc
--- /dev/null
+++ b/tools/arch/x86/include/asm/cmpxchg.h
@@ -0,0 +1,89 @@
+#ifndef TOOLS_ASM_X86_CMPXCHG_H
+#define TOOLS_ASM_X86_CMPXCHG_H
+
+#include <linux/compiler.h>
+
+/*
+ * Non-existant functions to indicate usage errors at link time
+ * (or compile-time if the compiler implements __compiletime_error().
+ */
+extern void __cmpxchg_wrong_size(void)
+        __compiletime_error("Bad argument size for cmpxchg");
+
+/*
+ * Constants for operation sizes. On 32-bit, the 64-bit size it set to
+ * -1 because sizeof will never return -1, thereby making those switch
+ * case statements guaranteeed dead code which the compiler will
+ * eliminate, and allowing the "missing symbol in the default case" to
+ * indicate a usage error.
+ */
+#define __X86_CASE_B    1
+#define __X86_CASE_W    2
+#define __X86_CASE_L    4
+#ifdef __x86_64__
+#define __X86_CASE_Q    8
+#else
+#define __X86_CASE_Q    -1              /* sizeof will never return -1 */
+#endif
+
+/*
+ * Atomic compare and exchange.  Compare OLD with MEM, if identical,
+ * store NEW in MEM.  Return the initial value in MEM.  Success is
+ * indicated by comparing RETURN with OLD.
+ */
+#define __raw_cmpxchg(ptr, old, new, size, lock)                        \
+({                                                                      \
+        __typeof__(*(ptr)) __ret;                                       \
+        __typeof__(*(ptr)) __old = (old);                               \
+        __typeof__(*(ptr)) __new = (new);                               \
+        switch (size) {                                                 \
+        case __X86_CASE_B:                                              \
+        {                                                               \
+                volatile u8 *__ptr = (volatile u8 *)(ptr);              \
+                asm volatile(lock "cmpxchgb %2,%1"                      \
+                             : "=a" (__ret), "+m" (*__ptr)              \
+                             : "q" (__new), "0" (__old)                 \
+                             : "memory");                               \
+                break;                                                  \
+        }                                                               \
+        case __X86_CASE_W:                                              \
+        {                                                               \
+                volatile u16 *__ptr = (volatile u16 *)(ptr);            \
+                asm volatile(lock "cmpxchgw %2,%1"                      \
+                             : "=a" (__ret), "+m" (*__ptr)              \
+                             : "r" (__new), "0" (__old)                 \
+                             : "memory");                               \
+                break;                                                  \
+        }                                                               \
+        case __X86_CASE_L:                                              \
+        {                                                               \
+                volatile u32 *__ptr = (volatile u32 *)(ptr);            \
+                asm volatile(lock "cmpxchgl %2,%1"                      \
+                             : "=a" (__ret), "+m" (*__ptr)              \
+                             : "r" (__new), "0" (__old)                 \
+                             : "memory");                               \
+                break;                                                  \
+        }                                                               \
+        case __X86_CASE_Q:                                              \
+        {                                                               \
+                volatile u64 *__ptr = (volatile u64 *)(ptr);            \
+                asm volatile(lock "cmpxchgq %2,%1"                      \
+                             : "=a" (__ret), "+m" (*__ptr)              \
+                             : "r" (__new), "0" (__old)                 \
+                             : "memory");                               \
+                break;                                                  \
+        }                                                               \
+        default:                                                        \
+                __cmpxchg_wrong_size();                                 \
+        }                                                               \
+        __ret;                                                          \
+})
+
+#define __cmpxchg(ptr, old, new, size)                                  \
+        __raw_cmpxchg((ptr), (old), (new), (size), LOCK_PREFIX)
+
+#define cmpxchg(ptr, old, new)                                          \
+        __cmpxchg(ptr, old, new, sizeof(*(ptr)))
+
+
+#endif  /* TOOLS_ASM_X86_CMPXCHG_H */
diff --git a/tools/arch/x86/include/asm/cpufeatures.h b/tools/arch/x86/include/asm/cpufeatures.h
index 293149a1c6a1..0fe00446f9ca 100644
--- a/tools/arch/x86/include/asm/cpufeatures.h
+++ b/tools/arch/x86/include/asm/cpufeatures.h
@@ -100,7 +100,7 @@
 #define X86_FEATURE_XTOPOLOGY   ( 3*32+22) /* cpu topology enum extensions */
 #define X86_FEATURE_TSC_RELIABLE ( 3*32+23) /* TSC is known to be reliable */
 #define X86_FEATURE_NONSTOP_TSC ( 3*32+24) /* TSC does not stop in C states */
-/* free, was #define X86_FEATURE_CLFLUSH_MONITOR ( 3*32+25) * "" clflush reqd with monitor */
+#define X86_FEATURE_CPUID       ( 3*32+25) /* CPU has CPUID instruction itself */
 #define X86_FEATURE_EXTD_APICID ( 3*32+26) /* has extended APICID (8 bits) */
 #define X86_FEATURE_AMD_DCM     ( 3*32+27) /* multi-node processor */
 #define X86_FEATURE_APERFMPERF  ( 3*32+28) /* APERFMPERF */
@@ -186,7 +186,8 @@
  *
  * Reuse free bits when adding new feature flags!
  */
-
+#define X86_FEATURE_RING3MWAIT  ( 7*32+ 0) /* Ring 3 MONITOR/MWAIT */
+#define X86_FEATURE_CPUID_FAULT ( 7*32+ 1) /* Intel CPUID faulting */
 #define X86_FEATURE_CPB         ( 7*32+ 2) /* AMD Core Performance Boost */
 #define X86_FEATURE_EPB         ( 7*32+ 3) /* IA32_ENERGY_PERF_BIAS support */
 #define X86_FEATURE_CAT_L3      ( 7*32+ 4) /* Cache Allocation Technology L3 */
@@ -289,7 +290,8 @@
 #define X86_FEATURE_PKU         (16*32+ 3) /* Protection Keys for Userspace */
 #define X86_FEATURE_OSPKE       (16*32+ 4) /* OS Protection Keys Enable */
 #define X86_FEATURE_AVX512_VPOPCNTDQ (16*32+14) /* POPCNT for vectors of DW/QW */
-#define X86_FEATURE_RDPID       (16*32+ 22) /* RDPID instruction */
+#define X86_FEATURE_LA57        (16*32+16) /* 5-level page tables */
+#define X86_FEATURE_RDPID       (16*32+22) /* RDPID instruction */
 
 /* AMD-defined CPU features, CPUID level 0x80000007 (ebx), word 17 */
 #define X86_FEATURE_OVERFLOW_RECOV (17*32+0) /* MCA overflow recovery support */
@@ -321,5 +323,4 @@
 #define X86_BUG_SWAPGS_FENCE    X86_BUG(11) /* SWAPGS without input dep on GS */
 #define X86_BUG_MONITOR         X86_BUG(12) /* IPI required to wake up remote CPU */
 #define X86_BUG_AMD_E400        X86_BUG(13) /* CPU is among the affected by Erratum 400 */
-
 #endif /* _ASM_X86_CPUFEATURES_H */
diff --git a/tools/arch/x86/lib/memcpy_64.S b/tools/arch/x86/lib/memcpy_64.S
index 49e6ebac7e73..98dcc112b363 100644
--- a/tools/arch/x86/lib/memcpy_64.S
+++ b/tools/arch/x86/lib/memcpy_64.S
@@ -286,7 +286,7 @@ ENDPROC(memcpy_mcsafe_unrolled)
         _ASM_EXTABLE_FAULT(.L_copy_leading_bytes, .L_memcpy_mcsafe_fail)
         _ASM_EXTABLE_FAULT(.L_cache_w0, .L_memcpy_mcsafe_fail)
         _ASM_EXTABLE_FAULT(.L_cache_w1, .L_memcpy_mcsafe_fail)
-        _ASM_EXTABLE_FAULT(.L_cache_w3, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w2, .L_memcpy_mcsafe_fail)
         _ASM_EXTABLE_FAULT(.L_cache_w3, .L_memcpy_mcsafe_fail)
         _ASM_EXTABLE_FAULT(.L_cache_w4, .L_memcpy_mcsafe_fail)
         _ASM_EXTABLE_FAULT(.L_cache_w5, .L_memcpy_mcsafe_fail)
diff --git a/tools/build/Makefile.feature b/tools/build/Makefile.feature
index e3fb5ecbdcb6..523911f316ce 100644
--- a/tools/build/Makefile.feature
+++ b/tools/build/Makefile.feature
@@ -63,6 +63,7 @@ FEATURE_TESTS_BASIC :=                  \
         lzma                            \
         get_cpuid                       \
         bpf                             \
+        sched_getcpu                    \
         sdt
 
 # FEATURE_TESTS_BASIC + FEATURE_TESTS_EXTRA is the complete list
diff --git a/tools/build/feature/Makefile b/tools/build/feature/Makefile
index b564a2eea039..e35e4e5ad192 100644
--- a/tools/build/feature/Makefile
+++ b/tools/build/feature/Makefile
@@ -48,21 +48,22 @@ FILES=                                          \
          test-get_cpuid.bin                     \
          test-sdt.bin                           \
          test-cxx.bin                           \
-         test-jvmti.bin
+         test-jvmti.bin                         \
+         test-sched_getcpu.bin
 
 FILES := $(addprefix $(OUTPUT),$(FILES))
 
-CC := $(CROSS_COMPILE)gcc -MD
-CXX := $(CROSS_COMPILE)g++ -MD
-PKG_CONFIG := $(CROSS_COMPILE)pkg-config
+CC ?= $(CROSS_COMPILE)gcc
+CXX ?= $(CROSS_COMPILE)g++
+PKG_CONFIG ?= $(CROSS_COMPILE)pkg-config
 LLVM_CONFIG ?= llvm-config
 
 all: $(FILES)
 
-__BUILD = $(CC) $(CFLAGS) -Wall -Werror -o $@ $(patsubst %.bin,%.c,$(@F)) $(LDFLAGS)
+__BUILD = $(CC) $(CFLAGS) -MD -Wall -Werror -o $@ $(patsubst %.bin,%.c,$(@F)) $(LDFLAGS)
   BUILD = $(__BUILD) > $(@:.bin=.make.output) 2>&1
 
-__BUILDXX = $(CXX) $(CXXFLAGS) -Wall -Werror -o $@ $(patsubst %.bin,%.cpp,$(@F)) $(LDFLAGS)
+__BUILDXX = $(CXX) $(CXXFLAGS) -MD -Wall -Werror -o $@ $(patsubst %.bin,%.cpp,$(@F)) $(LDFLAGS)
   BUILDXX = $(__BUILDXX) > $(@:.bin=.make.output) 2>&1
 
 ###############################
@@ -91,6 +92,9 @@ $(OUTPUT)test-libelf.bin:
 $(OUTPUT)test-glibc.bin:
         $(BUILD)
 
+$(OUTPUT)test-sched_getcpu.bin:
+        $(BUILD)
+
 DWARFLIBS := -ldw
 ifeq ($(findstring -static,${LDFLAGS}),-static)
 DWARFLIBS += -lelf -lebl -lz -llzma -lbz2
@@ -171,7 +175,7 @@ $(OUTPUT)test-libperl.bin:
         $(BUILD) $(FLAGS_PERL_EMBED)
 
 $(OUTPUT)test-libpython.bin:
-        $(BUILD)
+        $(BUILD) $(FLAGS_PYTHON_EMBED)
 
 $(OUTPUT)test-libpython-version.bin:
         $(BUILD)
diff --git a/tools/build/feature/test-all.c b/tools/build/feature/test-all.c
index 699e43627397..cc6c7c01f4ca 100644
--- a/tools/build/feature/test-all.c
+++ b/tools/build/feature/test-all.c
@@ -117,6 +117,10 @@
 # include "test-pthread-attr-setaffinity-np.c"
 #undef main
 
+#define main main_test_sched_getcpu
+# include "test-sched_getcpu.c"
+#undef main
+
 # if 0
 /*
  * Disable libbabeltrace check for test-all, because the requested
@@ -182,6 +186,7 @@ int main(int argc, char *argv[])
         main_test_get_cpuid();
         main_test_bpf();
         main_test_libcrypto();
+        main_test_sched_getcpu();
         main_test_sdt();
 
         return 0;
diff --git a/tools/build/feature/test-sched_getcpu.c b/tools/build/feature/test-sched_getcpu.c
new file mode 100644
index 000000000000..c4a148dd7104
--- /dev/null
+++ b/tools/build/feature/test-sched_getcpu.c
@@ -0,0 +1,7 @@
+#define _GNU_SOURCE
+#include <sched.h>
+
+int main(void)
+{
+        return sched_getcpu();
+}
diff --git a/tools/include/asm-generic/atomic-gcc.h b/tools/include/asm-generic/atomic-gcc.h
index 2ba78c9f5701..5e9738f97bf3 100644
--- a/tools/include/asm-generic/atomic-gcc.h
+++ b/tools/include/asm-generic/atomic-gcc.h
@@ -60,4 +60,12 @@ static inline int atomic_dec_and_test(atomic_t *v)
         return __sync_sub_and_fetch(&v->counter, 1) == 0;
 }
 
+#define cmpxchg(ptr, oldval, newval) \
+        __sync_val_compare_and_swap(ptr, oldval, newval)
+
+static inline int atomic_cmpxchg(atomic_t *v, int oldval, int newval)
+{
+        return cmpxchg(&(v)->counter, oldval, newval);
+}
+
 #endif /* __TOOLS_ASM_GENERIC_ATOMIC_H */
diff --git a/tools/include/linux/atomic.h b/tools/include/linux/atomic.h
index 4e3d3d18ebab..9f21fc2b092b 100644
--- a/tools/include/linux/atomic.h
+++ b/tools/include/linux/atomic.h
@@ -3,4 +3,10 @@
 
 #include <asm/atomic.h>
 
+/* atomic_cmpxchg_relaxed */
+#ifndef atomic_cmpxchg_relaxed
+#define  atomic_cmpxchg_relaxed         atomic_cmpxchg
+#define  atomic_cmpxchg_release         atomic_cmpxchg
+#endif /* atomic_cmpxchg_relaxed */
+
 #endif /* __TOOLS_LINUX_ATOMIC_H */
diff --git a/tools/include/linux/bug.h b/tools/include/linux/bug.h
new file mode 100644
index 000000000000..8e4a4f49135d
--- /dev/null
+++ b/tools/include/linux/bug.h
@@ -0,0 +1,10 @@
+#ifndef _TOOLS_PERF_LINUX_BUG_H
+#define _TOOLS_PERF_LINUX_BUG_H
+
+/* Force a compilation error if condition is true, but also produce a
+   result (of value 0 and type size_t), so the expression can be used
+   e.g. in a structure initializer (or where-ever else comma expressions
+   aren't permitted). */
+#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
+
+#endif  /* _TOOLS_PERF_LINUX_BUG_H */
diff --git a/tools/include/linux/compiler-gcc.h b/tools/include/linux/compiler-gcc.h
index 48af2f10a42d..825d44f89a29 100644
--- a/tools/include/linux/compiler-gcc.h
+++ b/tools/include/linux/compiler-gcc.h
@@ -12,3 +12,10 @@
 #if GCC_VERSION >= 70000 && !defined(__CHECKER__)
 # define __fallthrough __attribute__ ((fallthrough))
 #endif
+
+#if GCC_VERSION >= 40300
+# define __compiletime_error(message) __attribute__((error(message)))
+#endif /* GCC_VERSION >= 40300 */
+
+/* &a[0] degrades to a pointer: a different type from an array */
+#define __must_be_array(a)      BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
diff --git a/tools/include/linux/compiler.h b/tools/include/linux/compiler.h
index 8de163b17c0d..23299d7e7160 100644
--- a/tools/include/linux/compiler.h
+++ b/tools/include/linux/compiler.h
@@ -5,6 +5,10 @@
 #include <linux/compiler-gcc.h>
 #endif
 
+#ifndef __compiletime_error
+# define __compiletime_error(message)
+#endif
+
 /* Optimization barrier */
 /* The "volatile" is due to gcc bugs */
 #define barrier() __asm__ __volatile__("": : :"memory")
@@ -13,6 +17,11 @@
 # define __always_inline        inline __attribute__((always_inline))
 #endif
 
+/* Are two types/vars the same type (ignoring qualifiers)? */
+#ifndef __same_type
+# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
+#endif
+
 #ifdef __ANDROID__
 /*
  * FIXME: Big hammer to get rid of tons of:
diff --git a/tools/include/linux/hashtable.h b/tools/include/linux/hashtable.h
index c65cc0aa2659..251eabf2a05e 100644
--- a/tools/include/linux/hashtable.h
+++ b/tools/include/linux/hashtable.h
@@ -13,10 +13,6 @@
 #include <linux/hash.h>
 #include <linux/log2.h>
 
-#ifndef ARRAY_SIZE
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-#endif
-
 #define DEFINE_HASHTABLE(name, bits)                                            \
         struct hlist_head name[1 << (bits)] =                                   \
                         { [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT }
diff --git a/tools/include/linux/kernel.h b/tools/include/linux/kernel.h
index 28607db02bd3..73ccc48126bb 100644
--- a/tools/include/linux/kernel.h
+++ b/tools/include/linux/kernel.h
@@ -4,6 +4,11 @@
 #include <stdarg.h>
 #include <stddef.h>
 #include <assert.h>
+#include <linux/compiler.h>
+
+#ifndef UINT_MAX
+#define UINT_MAX        (~0U)
+#endif
 
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 
@@ -72,6 +77,8 @@
 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
 int scnprintf(char * buf, size_t size, const char * fmt, ...);
 
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
+
 /*
  * This looks more complex than it should be. But we need to
  * get the type for the ~ right in round_down (it needs to be
diff --git a/tools/include/linux/log2.h b/tools/include/linux/log2.h
index d5677d39c1e4..0325cefc2220 100644
--- a/tools/include/linux/log2.h
+++ b/tools/include/linux/log2.h
@@ -12,6 +12,9 @@
 #ifndef _TOOLS_LINUX_LOG2_H
 #define _TOOLS_LINUX_LOG2_H
 
+#include <linux/bitops.h>
+#include <linux/types.h>
+
 /*
  * non-constant log of base 2 calculators
  * - the arch may override these in asm/bitops.h if they can be implemented
diff --git a/tools/include/linux/refcount.h b/tools/include/linux/refcount.h
new file mode 100644
index 000000000000..a0177c1f55b1
--- /dev/null
+++ b/tools/include/linux/refcount.h
@@ -0,0 +1,151 @@
+#ifndef _TOOLS_LINUX_REFCOUNT_H
+#define _TOOLS_LINUX_REFCOUNT_H
+
+/*
+ * Variant of atomic_t specialized for reference counts.
+ *
+ * The interface matches the atomic_t interface (to aid in porting) but only
+ * provides the few functions one should use for reference counting.
+ *
+ * It differs in that the counter saturates at UINT_MAX and will not move once
+ * there. This avoids wrapping the counter and causing 'spurious'
+ * use-after-free issues.
+ *
+ * Memory ordering rules are slightly relaxed wrt regular atomic_t functions
+ * and provide only what is strictly required for refcounts.
+ *
+ * The increments are fully relaxed; these will not provide ordering. The
+ * rationale is that whatever is used to obtain the object we're increasing the
+ * reference count on will provide the ordering. For locked data structures,
+ * its the lock acquire, for RCU/lockless data structures its the dependent
+ * load.
+ *
+ * Do note that inc_not_zero() provides a control dependency which will order
+ * future stores against the inc, this ensures we'll never modify the object
+ * if we did not in fact acquire a reference.
+ *
+ * The decrements will provide release order, such that all the prior loads and
+ * stores will be issued before, it also provides a control dependency, which
+ * will order us against the subsequent free().
+ *
+ * The control dependency is against the load of the cmpxchg (ll/sc) that
+ * succeeded. This means the stores aren't fully ordered, but this is fine
+ * because the 1->0 transition indicates no concurrency.
+ *
+ * Note that the allocator is responsible for ordering things between free()
+ * and alloc().
+ *
+ */
+
+#include <linux/atomic.h>
+#include <linux/kernel.h>
+
+#ifdef NDEBUG
+#define REFCOUNT_WARN(cond, str) (void)(cond)
+#define __refcount_check
+#else
+#define REFCOUNT_WARN(cond, str) BUG_ON(cond)
+#define __refcount_check        __must_check
+#endif
+
+typedef struct refcount_struct {
+        atomic_t refs;
+} refcount_t;
+
+#define REFCOUNT_INIT(n)        { .refs = ATOMIC_INIT(n), }
+
+static inline void refcount_set(refcount_t *r, unsigned int n)
+{
+        atomic_set(&r->refs, n);
+}
+
+static inline unsigned int refcount_read(const refcount_t *r)
+{
+        return atomic_read(&r->refs);
+}
+
+/*
+ * Similar to atomic_inc_not_zero(), will saturate at UINT_MAX and WARN.
+ *
+ * Provides no memory ordering, it is assumed the caller has guaranteed the
+ * object memory to be stable (RCU, etc.). It does provide a control dependency
+ * and thereby orders future stores. See the comment on top.
+ */
+static inline __refcount_check
+bool refcount_inc_not_zero(refcount_t *r)
+{
+        unsigned int old, new, val = atomic_read(&r->refs);
+
+        for (;;) {
+                new = val + 1;
+
+                if (!val)
+                        return false;
+
+                if (unlikely(!new))
+                        return true;
+
+                old = atomic_cmpxchg_relaxed(&r->refs, val, new);
+                if (old == val)
+                        break;
+
+                val = old;
+        }
+
+        REFCOUNT_WARN(new == UINT_MAX, "refcount_t: saturated; leaking memory.\n");
+
+        return true;
+}
+
+/*
+ * Similar to atomic_inc(), will saturate at UINT_MAX and WARN.
+ *
+ * Provides no memory ordering, it is assumed the caller already has a
+ * reference on the object, will WARN when this is not so.
+ */
+static inline void refcount_inc(refcount_t *r)
+{
+        REFCOUNT_WARN(!refcount_inc_not_zero(r), "refcount_t: increment on 0; use-after-free.\n");
+}
+
+/*
+ * Similar to atomic_dec_and_test(), it will WARN on underflow and fail to
+ * decrement when saturated at UINT_MAX.
+ *
+ * Provides release memory ordering, such that prior loads and stores are done
+ * before, and provides a control dependency such that free() must come after.
+ * See the comment on top.
+ */
+static inline __refcount_check
+bool refcount_sub_and_test(unsigned int i, refcount_t *r)
+{
+        unsigned int old, new, val = atomic_read(&r->refs);
+
+        for (;;) {
+                if (unlikely(val == UINT_MAX))
+                        return false;
+
+                new = val - i;
+                if (new > val) {
+                        REFCOUNT_WARN(new > val, "refcount_t: underflow; use-after-free.\n");
+                        return false;
+                }
+
+                old = atomic_cmpxchg_release(&r->refs, val, new);
+                if (old == val)
+                        break;
+
+                val = old;
+        }
+
+        return !new;
+}
+
+static inline __refcount_check
+bool refcount_dec_and_test(refcount_t *r)
+{
+        return refcount_sub_and_test(1, r);
+}
+
+
+#endif /* _ATOMIC_LINUX_REFCOUNT_H */
diff --git a/tools/include/linux/types.h b/tools/include/linux/types.h
index c24b3e3ae296..77a28a26a670 100644
--- a/tools/include/linux/types.h
+++ b/tools/include/linux/types.h
@@ -7,6 +7,7 @@
 
 #define __SANE_USERSPACE_TYPES__        /* For PPC64, to get LL64 types */
 #include <asm/types.h>
+#include <asm/posix_types.h>
 
 struct page;
 struct kmem_cache;
diff --git a/tools/include/uapi/linux/fcntl.h b/tools/include/uapi/linux/fcntl.h
new file mode 100644
index 000000000000..813afd6eee71
--- /dev/null
+++ b/tools/include/uapi/linux/fcntl.h
@@ -0,0 +1,72 @@
+#ifndef _UAPI_LINUX_FCNTL_H
+#define _UAPI_LINUX_FCNTL_H
+
+#include <asm/fcntl.h>
+
+#define F_SETLEASE      (F_LINUX_SPECIFIC_BASE + 0)
+#define F_GETLEASE      (F_LINUX_SPECIFIC_BASE + 1)
+
+/*
+ * Cancel a blocking posix lock; internal use only until we expose an
+ * asynchronous lock api to userspace:
+ */
+#define F_CANCELLK      (F_LINUX_SPECIFIC_BASE + 5)
+
+/* Create a file descriptor with FD_CLOEXEC set. */
+#define F_DUPFD_CLOEXEC (F_LINUX_SPECIFIC_BASE + 6)
+
+/*
+ * Request nofications on a directory.
+ * See below for events that may be notified.
+ */
+#define F_NOTIFY        (F_LINUX_SPECIFIC_BASE+2)
+
+/*
+ * Set and get of pipe page size array
+ */
+#define F_SETPIPE_SZ    (F_LINUX_SPECIFIC_BASE + 7)
+#define F_GETPIPE_SZ    (F_LINUX_SPECIFIC_BASE + 8)
+
+/*
+ * Set/Get seals
+ */
+#define F_ADD_SEALS     (F_LINUX_SPECIFIC_BASE + 9)
+#define F_GET_SEALS     (F_LINUX_SPECIFIC_BASE + 10)
+
+/*
+ * Types of seals
+ */
+#define F_SEAL_SEAL     0x0001  /* prevent further seals from being set */
+#define F_SEAL_SHRINK   0x0002  /* prevent file from shrinking */
+#define F_SEAL_GROW     0x0004  /* prevent file from growing */
+#define F_SEAL_WRITE    0x0008  /* prevent writes */
+/* (1U << 31) is reserved for signed error codes */
+
+/*
+ * Types of directory notifications that may be requested.
+ */
+#define DN_ACCESS       0x00000001      /* File accessed */
+#define DN_MODIFY       0x00000002      /* File modified */
+#define DN_CREATE       0x00000004      /* File created */
+#define DN_DELETE       0x00000008      /* File removed */
+#define DN_RENAME       0x00000010      /* File renamed */
+#define DN_ATTRIB       0x00000020      /* File changed attibutes */
+#define DN_MULTISHOT    0x80000000      /* Don't remove notifier */
+
+#define AT_FDCWD                -100    /* Special value used to indicate
+                                           openat should use the current
+                                           working directory. */
+#define AT_SYMLINK_NOFOLLOW     0x100   /* Do not follow symbolic links.  */
+#define AT_REMOVEDIR            0x200   /* Remove directory instead of
+                                           unlinking file.  */
+#define AT_SYMLINK_FOLLOW       0x400   /* Follow symbolic links.  */
+#define AT_NO_AUTOMOUNT         0x800   /* Suppress terminal automount traversal */
+#define AT_EMPTY_PATH           0x1000  /* Allow empty relative pathname */
+
+#define AT_STATX_SYNC_TYPE      0x6000  /* Type of synchronisation required from statx() */
+#define AT_STATX_SYNC_AS_STAT   0x0000  /* - Do whatever stat() does */
+#define AT_STATX_FORCE_SYNC     0x2000  /* - Force the attributes to be sync'd with the server */
+#define AT_STATX_DONT_SYNC      0x4000  /* - Don't sync attributes with the server */
+
+
+#endif /* _UAPI_LINUX_FCNTL_H */
diff --git a/tools/include/uapi/linux/perf_event.h b/tools/include/uapi/linux/perf_event.h
index c66a485a24ac..d09a9cd021b1 100644
--- a/tools/include/uapi/linux/perf_event.h
+++ b/tools/include/uapi/linux/perf_event.h
@@ -344,7 +344,8 @@ struct perf_event_attr {
                                 use_clockid    :  1, /* use @clockid for time fields */
                                 context_switch :  1, /* context switch data */
                                 write_backward :  1, /* Write ring buffer from end to beginning */
-                                __reserved_1   : 36;
+                                namespaces     :  1, /* include namespaces data */
+                                __reserved_1   : 35;
 
         union {
                 __u32           wakeup_events;    /* wakeup every n events */
@@ -610,6 +611,23 @@ struct perf_event_header {
         __u16   size;
 };
 
+struct perf_ns_link_info {
+        __u64   dev;
+        __u64   ino;
+};
+
+enum {
+        NET_NS_INDEX            = 0,
+        UTS_NS_INDEX            = 1,
+        IPC_NS_INDEX            = 2,
+        PID_NS_INDEX            = 3,
+        USER_NS_INDEX           = 4,
+        MNT_NS_INDEX            = 5,
+        CGROUP_NS_INDEX         = 6,
+
+        NR_NAMESPACES,          /* number of available namespaces */
+};
+
 enum perf_event_type {
 
         /*
@@ -862,6 +880,18 @@ enum perf_event_type {
          */
         PERF_RECORD_SWITCH_CPU_WIDE             = 15,
 
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid;
+         *      u32                             tid;
+         *      u64                             nr_namespaces;
+         *      { u64                           dev, inode; } [nr_namespaces];
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_NAMESPACES                  = 16,
+
         PERF_RECORD_MAX,                        /* non-ABI */
 };
 
@@ -885,6 +915,7 @@ enum perf_callchain_context {
  */
 #define PERF_AUX_FLAG_TRUNCATED         0x01    /* record was truncated to fit */
 #define PERF_AUX_FLAG_OVERWRITE         0x02    /* snapshot from overwrite mode */
+#define PERF_AUX_FLAG_PARTIAL           0x04    /* record contains gaps */
 
 #define PERF_FLAG_FD_NO_GROUP           (1UL << 0)
 #define PERF_FLAG_FD_OUTPUT             (1UL << 1)
diff --git a/tools/include/uapi/linux/stat.h b/tools/include/uapi/linux/stat.h
new file mode 100644
index 000000000000..d538897b8e08
--- /dev/null
+++ b/tools/include/uapi/linux/stat.h
@@ -0,0 +1,177 @@
+#ifndef _UAPI_LINUX_STAT_H
+#define _UAPI_LINUX_STAT_H
+
+#include <linux/types.h>
+
+#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
+
+#define S_IFMT  00170000
+#define S_IFSOCK 0140000
+#define S_IFLNK  0120000
+#define S_IFREG  0100000
+#define S_IFBLK  0060000
+#define S_IFDIR  0040000
+#define S_IFCHR  0020000
+#define S_IFIFO  0010000
+#define S_ISUID  0004000
+#define S_ISGID  0002000
+#define S_ISVTX  0001000
+
+#define S_ISLNK(m)      (((m) & S_IFMT) == S_IFLNK)
+#define S_ISREG(m)      (((m) & S_IFMT) == S_IFREG)
+#define S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)
+#define S_ISCHR(m)      (((m) & S_IFMT) == S_IFCHR)
+#define S_ISBLK(m)      (((m) & S_IFMT) == S_IFBLK)
+#define S_ISFIFO(m)     (((m) & S_IFMT) == S_IFIFO)
+#define S_ISSOCK(m)     (((m) & S_IFMT) == S_IFSOCK)
+
+#define S_IRWXU 00700
+#define S_IRUSR 00400
+#define S_IWUSR 00200
+#define S_IXUSR 00100
+
+#define S_IRWXG 00070
+#define S_IRGRP 00040
+#define S_IWGRP 00020
+#define S_IXGRP 00010
+
+#define S_IRWXO 00007
+#define S_IROTH 00004
+#define S_IWOTH 00002
+#define S_IXOTH 00001
+
+#endif
+
+/*
+ * Timestamp structure for the timestamps in struct statx.
+ *
+ * tv_sec holds the number of seconds before (negative) or after (positive)
+ * 00:00:00 1st January 1970 UTC.
+ *
+ * tv_nsec holds a number of nanoseconds before (0..-999,999,999 if tv_sec is
+ * negative) or after (0..999,999,999 if tv_sec is positive) the tv_sec time.
+ *
+ * Note that if both tv_sec and tv_nsec are non-zero, then the two values must
+ * either be both positive or both negative.
+ *
+ * __reserved is held in case we need a yet finer resolution.
+ */
+struct statx_timestamp {
+        __s64   tv_sec;
+        __s32   tv_nsec;
+        __s32   __reserved;
+};
+
+/*
+ * Structures for the extended file attribute retrieval system call
+ * (statx()).
+ *
+ * The caller passes a mask of what they're specifically interested in as a
+ * parameter to statx().  What statx() actually got will be indicated in
+ * st_mask upon return.
+ *
+ * For each bit in the mask argument:
+ *
+ * - if the datum is not supported:
+ *
+ *   - the bit will be cleared, and
+ *
+ *   - the datum will be set to an appropriate fabricated value if one is
+ *     available (eg. CIFS can take a default uid and gid), otherwise
+ *
+ *   - the field will be cleared;
+ *
+ * - otherwise, if explicitly requested:
+ *
+ *   - the datum will be synchronised to the server if AT_STATX_FORCE_SYNC is
+ *     set or if the datum is considered out of date, and
+ *
+ *   - the field will be filled in and the bit will be set;
+ *
+ * - otherwise, if not requested, but available in approximate form without any
+ *   effort, it will be filled in anyway, and the bit will be set upon return
+ *   (it might not be up to date, however, and no attempt will be made to
+ *   synchronise the internal state first);
+ *
+ * - otherwise the field and the bit will be cleared before returning.
+ *
+ * Items in STATX_BASIC_STATS may be marked unavailable on return, but they
+ * will have values installed for compatibility purposes so that stat() and
+ * co. can be emulated in userspace.
+ */
+struct statx {
+        /* 0x00 */
+        __u32   stx_mask;       /* What results were written [uncond] */
+        __u32   stx_blksize;    /* Preferred general I/O size [uncond] */
+        __u64   stx_attributes; /* Flags conveying information about the file [uncond] */
+        /* 0x10 */
+        __u32   stx_nlink;      /* Number of hard links */
+        __u32   stx_uid;        /* User ID of owner */
+        __u32   stx_gid;        /* Group ID of owner */
+        __u16   stx_mode;       /* File mode */
+        __u16   __spare0[1];
+        /* 0x20 */
+        __u64   stx_ino;        /* Inode number */
+        __u64   stx_size;       /* File size */
+        __u64   stx_blocks;     /* Number of 512-byte blocks allocated */
+        __u64   stx_attributes_mask; /* Mask to show what's supported in stx_attributes */
+        /* 0x40 */
+        struct statx_timestamp  stx_atime;      /* Last access time */
+        struct statx_timestamp  stx_btime;      /* File creation time */
+        struct statx_timestamp  stx_ctime;      /* Last attribute change time */
+        struct statx_timestamp  stx_mtime;      /* Last data modification time */
+        /* 0x80 */
+        __u32   stx_rdev_major; /* Device ID of special file [if bdev/cdev] */
+        __u32   stx_rdev_minor;
+        __u32   stx_dev_major;  /* ID of device containing file [uncond] */
+        __u32   stx_dev_minor;
+        /* 0x90 */
+        __u64   __spare2[14];   /* Spare space for future expansion */
+        /* 0x100 */
+};
+
+/*
+ * Flags to be stx_mask
+ *
+ * Query request/result mask for statx() and struct statx::stx_mask.
+ *
+ * These bits should be set in the mask argument of statx() to request
+ * particular items when calling statx().
+ */
+#define STATX_TYPE              0x00000001U     /* Want/got stx_mode & S_IFMT */
+#define STATX_MODE              0x00000002U     /* Want/got stx_mode & ~S_IFMT */
+#define STATX_NLINK             0x00000004U     /* Want/got stx_nlink */
+#define STATX_UID               0x00000008U     /* Want/got stx_uid */
+#define STATX_GID               0x00000010U     /* Want/got stx_gid */
+#define STATX_ATIME             0x00000020U     /* Want/got stx_atime */
+#define STATX_MTIME             0x00000040U     /* Want/got stx_mtime */
+#define STATX_CTIME             0x00000080U     /* Want/got stx_ctime */
+#define STATX_INO               0x00000100U     /* Want/got stx_ino */
+#define STATX_SIZE              0x00000200U     /* Want/got stx_size */
+#define STATX_BLOCKS            0x00000400U     /* Want/got stx_blocks */
+#define STATX_BASIC_STATS       0x000007ffU     /* The stuff in the normal stat struct */
+#define STATX_BTIME             0x00000800U     /* Want/got stx_btime */
+#define STATX_ALL               0x00000fffU     /* All currently supported flags */
+#define STATX__RESERVED         0x80000000U     /* Reserved for future struct statx expansion */
+
+/*
+ * Attributes to be found in stx_attributes and masked in stx_attributes_mask.
+ *
+ * These give information about the features or the state of a file that might
+ * be of use to ordinary userspace programs such as GUIs or ls rather than
+ * specialised tools.
+ *
+ * Note that the flags marked [I] correspond to generic FS_IOC_FLAGS
+ * semantically.  Where possible, the numerical value is picked to correspond
+ * also.
+ */
+#define STATX_ATTR_COMPRESSED           0x00000004 /* [I] File is compressed by the fs */
+#define STATX_ATTR_IMMUTABLE            0x00000010 /* [I] File is marked immutable */
+#define STATX_ATTR_APPEND               0x00000020 /* [I] File is append-only */
+#define STATX_ATTR_NODUMP               0x00000040 /* [I] File is not to be dumped */
+#define STATX_ATTR_ENCRYPTED            0x00000800 /* [I] File requires key to decrypt in fs */
+
+#define STATX_ATTR_AUTOMOUNT            0x00001000 /* Dir: Automount trigger */
+
+
+#endif /* _UAPI_LINUX_STAT_H */
diff --git a/tools/lib/api/fs/fs.c b/tools/lib/api/fs/fs.c
index 4b6bfc43cccf..809c7721cd24 100644
--- a/tools/lib/api/fs/fs.c
+++ b/tools/lib/api/fs/fs.c
@@ -439,6 +439,35 @@ int sysfs__read_str(const char *entry, char **buf, size_t *sizep)
         return filename__read_str(path, buf, sizep);
 }
 
+int sysfs__read_bool(const char *entry, bool *value)
+{
+        char *buf;
+        size_t size;
+        int ret;
+
+        ret = sysfs__read_str(entry, &buf, &size);
+        if (ret < 0)
+                return ret;
+
+        switch (buf[0]) {
+        case '1':
+        case 'y':
+        case 'Y':
+                *value = true;
+                break;
+        case '0':
+        case 'n':
+        case 'N':
+                *value = false;
+                break;
+        default:
+                ret = -1;
+        }
+
+        free(buf);
+
+        return ret;
+}
 int sysctl__read_int(const char *sysctl, int *value)
 {
         char path[PATH_MAX];
diff --git a/tools/lib/api/fs/fs.h b/tools/lib/api/fs/fs.h
index 6b332dc74498..956c21127d1e 100644
--- a/tools/lib/api/fs/fs.h
+++ b/tools/lib/api/fs/fs.h
@@ -37,4 +37,5 @@ int sysctl__read_int(const char *sysctl, int *value);
 int sysfs__read_int(const char *entry, int *value);
 int sysfs__read_ull(const char *entry, unsigned long long *value);
 int sysfs__read_str(const char *entry, char **buf, size_t *sizep);
+int sysfs__read_bool(const char *entry, bool *value);
 #endif /* __API_FS__ */
diff --git a/tools/lib/subcmd/help.h b/tools/lib/subcmd/help.h
index e145a020780c..9bd4223dc722 100644
--- a/tools/lib/subcmd/help.h
+++ b/tools/lib/subcmd/help.h
@@ -2,6 +2,7 @@
 #define __SUBCMD_HELP_H
 
 #include <sys/types.h>
+#include <stdio.h>
 
 struct cmdnames {
         size_t alloc;
diff --git a/tools/lib/symbol/kallsyms.c b/tools/lib/symbol/kallsyms.c
index 5e431077fcd6..d270ac00613d 100644
--- a/tools/lib/symbol/kallsyms.c
+++ b/tools/lib/symbol/kallsyms.c
@@ -1,3 +1,4 @@
+#include <ctype.h>
 #include "symbol/kallsyms.h"
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/tools/objtool/builtin-check.c b/tools/objtool/builtin-check.c
index 066086dd59a8..282a60368b14 100644
--- a/tools/objtool/builtin-check.c
+++ b/tools/objtool/builtin-check.c
@@ -36,8 +36,7 @@
 #include "warn.h"
 
 #include <linux/hashtable.h>
-
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#include <linux/kernel.h>
 
 #define STATE_FP_SAVED          0x1
 #define STATE_FP_SETUP          0x2
diff --git a/tools/objtool/objtool.c b/tools/objtool/objtool.c
index 46c326db4f46..ecc5b1b5d15d 100644
--- a/tools/objtool/objtool.c
+++ b/tools/objtool/objtool.c
@@ -31,11 +31,10 @@
 #include <stdlib.h>
 #include <subcmd/exec-cmd.h>
 #include <subcmd/pager.h>
+#include <linux/kernel.h>
 
 #include "builtin.h"
 
-#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
-
 struct cmd_struct {
         const char *name;
         int (*fn)(int, const char **);
diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 3db3db9278be..643cc4ba6872 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -31,3 +31,5 @@ config.mak.autogen
 .config-detected
 util/intel-pt-decoder/inat-tables.c
 arch/*/include/generated/
+pmu-events/pmu-events.c
+pmu-events/jevents
diff --git a/tools/perf/Build b/tools/perf/Build
index 9b79f8d7db50..bd8eeb60533c 100644
--- a/tools/perf/Build
+++ b/tools/perf/Build
@@ -50,5 +50,6 @@ libperf-y += util/
 libperf-y += arch/
 libperf-y += ui/
 libperf-y += scripts/
+libperf-y += trace/beauty/
 
 gtk-y += ui/gtk/
diff --git a/tools/perf/Documentation/perf-ftrace.txt b/tools/perf/Documentation/perf-ftrace.txt
index 2d96de6132a9..6e6a8b22c859 100644
--- a/tools/perf/Documentation/perf-ftrace.txt
+++ b/tools/perf/Documentation/perf-ftrace.txt
@@ -30,6 +30,24 @@ OPTIONS
 --verbose=::
         Verbosity level.
 
+-p::
+--pid=::
+        Trace on existing process id (comma separated list).
+
+-a::
+--all-cpus::
+        Force system-wide collection.  Scripts run without a <command>
+        normally use -a by default, while scripts run with a <command>
+        normally don't - this option allows the latter to be run in
+        system-wide mode.
+
+-C::
+--cpu=::
+        Only trace for the list of CPUs provided.  Multiple CPUs can
+        be provided as a comma separated list with no space like: 0,1.
+        Ranges of CPUs are specified with -: 0-2.
+        Default is to trace on all online CPUs.
+
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index 41857cce5e86..f709de54707b 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -8,7 +8,7 @@ perf-list - List all symbolic event types
 SYNOPSIS
 --------
 [verse]
-'perf list' [--no-desc] [--long-desc] [hw|sw|cache|tracepoint|pmu|event_glob]
+'perf list' [--no-desc] [--long-desc] [hw|sw|cache|tracepoint|pmu|sdt|event_glob]
 
 DESCRIPTION
 -----------
@@ -24,6 +24,10 @@ Don't print descriptions.
 --long-desc::
 Print longer event descriptions.
 
+--details::
+Print how named events are resolved internally into perf events, and also
+any extra expressions computed by perf stat.
+
 
 [[EVENT_MODIFIERS]]
 EVENT MODIFIERS
@@ -240,6 +244,8 @@ To limit the list use:
 
 . 'pmu' to print the kernel supplied PMU events.
 
+. 'sdt' to list all Statically Defined Tracepoint events.
+
 . If none of the above is matched, it will apply the supplied glob to all
   events, printing the ones that match.
 
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index b16003ec14a7..ea3789d05e5e 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -347,6 +347,9 @@ Enable weightened sampling. An additional weight is recorded per sample and can
 displayed with the weight and local_weight sort keys.  This currently works for TSX
 abort events and some memory events in precise mode on modern Intel CPUs.
 
+--namespaces::
+Record events of type PERF_RECORD_NAMESPACES.
+
 --transaction::
 Record transaction flags for transaction related events.
 
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index c04cc0647c16..37a175914157 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -72,7 +72,8 @@ OPTIONS
 --sort=::
         Sort histogram entries by given key(s) - multiple keys can be specified
         in CSV format.  Following sort keys are available:
-        pid, comm, dso, symbol, parent, cpu, socket, srcline, weight, local_weight.
+        pid, comm, dso, symbol, parent, cpu, socket, srcline, weight,
+        local_weight, cgroup_id.
 
         Each key has following meaning:
 
@@ -80,6 +81,7 @@ OPTIONS
         - pid: command and tid of the task
         - dso: name of library or module executed at the time of sample
         - symbol: name of function executed at the time of sample
+        - symbol_size: size of function executed at the time of sample
         - parent: name of function matched to the parent regex filter. Unmatched
         entries are displayed as "[other]".
         - cpu: cpu number the task ran at the time of sample
@@ -91,6 +93,7 @@ OPTIONS
         - weight: Event specific weight, e.g. memory latency or transaction
         abort cost. This is the global weight.
         - local_weight: Local weight version of the weight above.
+        - cgroup_id: ID derived from cgroup namespace device and inode numbers.
         - transaction: Transaction abort flags.
         - overhead: Overhead percentage of sample
         - overhead_sys: Overhead percentage of sample running in system mode
@@ -172,6 +175,9 @@ OPTIONS
         By default, every sort keys not specified in -F will be appended
         automatically.
 
+        If the keys starts with a prefix '+', then it will append the specified
+        field(s) to the default field order. For example: perf report -F +period,sample.
+
 -p::
 --parent=<regex>::
         A regex filter to identify parent. The parent is a caller of this
@@ -229,6 +235,7 @@ OPTIONS
         sort_key can be:
         - function: compare on functions (default)
         - address: compare on individual code addresses
+        - srcline: compare on source filename and line number
 
         branch can be:
         - branch: include last branch information in callgraph when available.
@@ -424,6 +431,10 @@ include::itrace.txt[]
 --hierarchy::
         Enable hierarchical output.
 
+--inline::
+        If a callgraph address belongs to an inlined function, the inline stack
+        will be printed. Each entry is function name or file/line.
+
 include::callchain-overhead-calculation.txt[]
 
 SEE ALSO
diff --git a/tools/perf/Documentation/perf-sched.txt b/tools/perf/Documentation/perf-sched.txt
index d33deddb0146..a092a2499e8f 100644
--- a/tools/perf/Documentation/perf-sched.txt
+++ b/tools/perf/Documentation/perf-sched.txt
@@ -132,6 +132,10 @@ OPTIONS for 'perf sched timehist'
 --migrations::
         Show migration events.
 
+-n::
+--next::
+        Show next task.
+
 -I::
 --idle-hist::
         Show idle-related events only.
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index 4ed5f239ba7d..cb0eda3925e6 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -116,7 +116,7 @@ OPTIONS
 --fields::
         Comma separated list of fields to print. Options are:
         comm, tid, pid, time, cpu, event, trace, ip, sym, dso, addr, symoff,
-        srcline, period, iregs, brstack, brstacksym, flags, bpf-output,
+        srcline, period, iregs, brstack, brstacksym, flags, bpf-output, brstackinsn,
         callindent, insn, insnlen. Field list can be prepended with the type, trace, sw or hw,
         to indicate to which event type the field list applies.
         e.g., -F sw:comm,tid,time,ip,sym  and -F trace:time,cpu,trace
@@ -189,15 +189,20 @@ OPTIONS
         i.e., -F "" is not allowed.
 
         The brstack output includes branch related information with raw addresses using the
-        /v/v/v/v/ syntax in the following order:
+        /v/v/v/v/cycles syntax in the following order:
         FROM: branch source instruction
         TO  : branch target instruction
         M/P/-: M=branch target mispredicted or branch direction was mispredicted, P=target predicted or direction predicted, -=not supported
         X/- : X=branch inside a transactional region, -=not in transaction region or not supported
         A/- : A=TSX abort entry, -=not aborted region or not supported
+        cycles
 
         The brstacksym is identical to brstack, except that the FROM and TO addresses are printed in a symbolic form if possible.
 
+        When brstackinsn is specified the full assembler sequences of branch sequences for each sample
+        is printed. This is the full execution path leading to the sample. This is only supported when the
+        sample was recorded with perf record -b or -j any.
+
 -k::
 --vmlinux=<file>::
         vmlinux pathname
@@ -248,6 +253,9 @@ OPTIONS
 --show-mmap-events
         Display mmap related events (e.g. MMAP, MMAP2).
 
+--show-namespace-events
+        Display namespace events i.e. events of type PERF_RECORD_NAMESPACES.
+
 --show-switch-events
         Display context switch events i.e. events of type PERF_RECORD_SWITCH or
         PERF_RECORD_SWITCH_CPU_WIDE.
@@ -299,6 +307,10 @@ include::itrace.txt[]
         stop time is not given (i.e, time string is 'x.y,') then analysis goes
         to end of file.
 
+--max-blocks::
+        Set the maximum number of program blocks to print with brstackasm for
+        each sample.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script-perl[1],
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index aecf2a87e7d6..bd0e4417f2be 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -94,8 +94,7 @@ to activate system-wide monitoring. Default is to count on all CPUs.
 
 -A::
 --no-aggr::
-Do not aggregate counts across all monitored CPUs in system-wide mode (-a).
-This option is only valid in system-wide mode.
+Do not aggregate counts across all monitored CPUs.
 
 -n::
 --null::
@@ -237,6 +236,9 @@ To interpret the results it is usually needed to know on which
 CPUs the workload runs on. If needed the CPUs can be forced using
 taskset.
 
+--no-merge::
+Do not merge results from same PMUs.
+
 EXAMPLES
 --------
 
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index afd728672b6f..c1e3288a2dfb 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -123,7 +123,8 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
         major or all pagefaults. Default value is maj.
 
 --syscalls::
-        Trace system calls. This options is enabled by default.
+        Trace system calls. This options is enabled by default, disable with
+        --no-syscalls.
 
 --call-graph [mode,type,min[,limit],order[,key][,branch]]::
         Setup and enable call-graph (stack chain/backtrace) recording.
diff --git a/tools/perf/Documentation/perf.data-file-format.txt b/tools/perf/Documentation/perf.data-file-format.txt
index b664b18d3991..fa2a9132f0a9 100644
--- a/tools/perf/Documentation/perf.data-file-format.txt
+++ b/tools/perf/Documentation/perf.data-file-format.txt
@@ -11,8 +11,8 @@ All fields are in native-endian of the machine that generated the perf.data.
 
 When perf is writing to a pipe it uses a special version of the file
 format that does not rely on seeking to adjust data offsets.  This
-format is not described here. The pipe version can be converted to
-normal perf.data with perf inject.
+format is described in "Pipe-mode data" section. The pipe data version can be
+augmented with additional events using perf inject.
 
 The file starts with a perf_header:
 
@@ -411,6 +411,21 @@ An array bound by the perf_file_section size.
 
 ids points to a array of uint64_t defining the ids for event attr attr.
 
+Pipe-mode data
+
+Pipe-mode avoid seeks in the file by removing the perf_file_section and flags
+from the struct perf_header. The trimmed header is:
+
+struct perf_pipe_file_header {
+        u64                             magic;
+        u64                             size;
+};
+
+The information about attrs, data, and event_types is instead in the
+synthesized events PERF_RECORD_ATTR, PERF_RECORD_HEADER_TRACING_DATA and
+PERF_RECORD_HEADER_EVENT_TYPE that are generated by perf record in pipe-mode.
+
+
 References:
 
 include/uapi/linux/perf_event.h
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index 8672f835ae4e..a29da46d180f 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -12,6 +12,7 @@ tools/arch/sparc/include/asm/barrier_32.h
 tools/arch/sparc/include/asm/barrier_64.h
 tools/arch/tile/include/asm/barrier.h
 tools/arch/x86/include/asm/barrier.h
+tools/arch/x86/include/asm/cmpxchg.h
 tools/arch/x86/include/asm/cpufeatures.h
 tools/arch/x86/include/asm/disabled-features.h
 tools/arch/x86/include/asm/required-features.h
@@ -63,6 +64,7 @@ tools/include/linux/bitops.h
 tools/include/linux/compiler.h
 tools/include/linux/compiler-gcc.h
 tools/include/linux/coresight-pmu.h
+tools/include/linux/bug.h
 tools/include/linux/filter.h
 tools/include/linux/hash.h
 tools/include/linux/kernel.h
@@ -72,12 +74,15 @@ tools/include/uapi/asm-generic/mman-common.h
 tools/include/uapi/asm-generic/mman.h
 tools/include/uapi/linux/bpf.h
 tools/include/uapi/linux/bpf_common.h
+tools/include/uapi/linux/fcntl.h
 tools/include/uapi/linux/hw_breakpoint.h
 tools/include/uapi/linux/mman.h
 tools/include/uapi/linux/perf_event.h
+tools/include/uapi/linux/stat.h
 tools/include/linux/poison.h
 tools/include/linux/rbtree.h
 tools/include/linux/rbtree_augmented.h
+tools/include/linux/refcount.h
 tools/include/linux/string.h
 tools/include/linux/stringify.h
 tools/include/linux/types.h
diff --git a/tools/perf/Makefile.config b/tools/perf/Makefile.config
index 27c9fbca7bd9..8354d04b392f 100644
--- a/tools/perf/Makefile.config
+++ b/tools/perf/Makefile.config
@@ -170,13 +170,20 @@ PYTHON2_CONFIG := \
 override PYTHON_CONFIG := \
   $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON2_CONFIG))
 
-PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
+grep-libs  = $(filter -l%,$(1))
+strip-libs  = $(filter-out -l%,$(1))
 
-PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
-PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
+PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
 
-ifeq ($(CC), clang)
-  PYTHON_EMBED_CCOPTS := $(filter-out -specs=%,$(PYTHON_EMBED_CCOPTS))
+ifdef PYTHON_CONFIG
+  PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
+  PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
+  PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS)) -lutil
+  PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
+  ifeq ($(CC), clang)
+    PYTHON_EMBED_CCOPTS := $(filter-out -specs=%,$(PYTHON_EMBED_CCOPTS))
+  endif
+  FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
 endif
 
 FEATURE_CHECK_CFLAGS-libpython := $(PYTHON_EMBED_CCOPTS)
@@ -267,6 +274,7 @@ ifdef NO_LIBELF
   NO_LIBUNWIND := 1
   NO_LIBDW_DWARF_UNWIND := 1
   NO_LIBBPF := 1
+  NO_JVMTI := 1
 else
   ifeq ($(feature-libelf), 0)
     ifeq ($(feature-glibc), 1)
@@ -276,7 +284,7 @@ else
       LIBC_SUPPORT := 1
     endif
     ifeq ($(LIBC_SUPPORT),1)
-      msg := $(warning No libelf found, disables 'probe' tool and BPF support in 'perf record', please install libelf-dev, libelf-devel or elfutils-libelf-devel);
+      msg := $(warning No libelf found. Disables 'probe' tool, jvmti and BPF support in 'perf record'. Please install libelf-dev, libelf-devel or elfutils-libelf-devel);
 
       NO_LIBELF := 1
       NO_DWARF := 1
@@ -284,6 +292,7 @@ else
       NO_LIBUNWIND := 1
       NO_LIBDW_DWARF_UNWIND := 1
       NO_LIBBPF := 1
+      NO_JVMTI := 1
     else
       ifneq ($(filter s% -static%,$(LDFLAGS),),)
         msg := $(error No static glibc found, please install glibc-static);
@@ -317,6 +326,10 @@ ifdef NO_DWARF
   NO_LIBDW_DWARF_UNWIND := 1
 endif
 
+ifeq ($(feature-sched_getcpu), 1)
+  CFLAGS += -DHAVE_SCHED_GETCPU_SUPPORT
+endif
+
 ifndef NO_LIBELF
   CFLAGS += -DHAVE_LIBELF_SUPPORT
   EXTLIBS += -lelf
@@ -550,8 +563,6 @@ ifndef NO_GTK2
   endif
 endif
 
-grep-libs  = $(filter -l%,$(1))
-strip-libs = $(filter-out -l%,$(1))
 
 ifdef NO_LIBPERL
   CFLAGS += -DNO_LIBPERL
@@ -599,21 +610,9 @@ else
       $(call disable-python,No 'python-config' tool was found: disables Python support - please install python-devel/python-dev)
     else
 
-      PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
-
-      PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
-      PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
-      PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS)) -lutil
-      PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
-      ifeq ($(CC), clang)
-        PYTHON_EMBED_CCOPTS := $(filter-out -specs=%,$(PYTHON_EMBED_CCOPTS))
-      endif
-      FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
-
       ifneq ($(feature-libpython), 1)
         $(call disable-python,No 'Python.h' (for Python 2.x support) was found: disables Python support - please install python-devel/python-dev)
       else
-
         ifneq ($(feature-libpython-version), 1)
           $(warning Python 3 is not yet supported; please set)
           $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
diff --git a/tools/perf/arch/arm/util/cs-etm.c b/tools/perf/arch/arm/util/cs-etm.c
index dfea6b635525..29361d9b635a 100644
--- a/tools/perf/arch/arm/util/cs-etm.c
+++ b/tools/perf/arch/arm/util/cs-etm.c
@@ -33,6 +33,7 @@
 #include "../../util/cs-etm.h"
 
 #include <stdlib.h>
+#include <sys/stat.h>
 
 #define ENABLE_SINK_MAX 128
 #define CS_BUS_DEVICE_PATH "/bus/coresight/devices/"
diff --git a/tools/perf/arch/arm/util/dwarf-regs.c b/tools/perf/arch/arm/util/dwarf-regs.c
index 33ec5b339da8..8bb176a37990 100644
--- a/tools/perf/arch/arm/util/dwarf-regs.c
+++ b/tools/perf/arch/arm/util/dwarf-regs.c
@@ -9,6 +9,7 @@
  */
 
 #include <stddef.h>
+#include <linux/stringify.h>
 #include <dwarf-regs.h>
 
 struct pt_regs_dwarfnum {
@@ -16,10 +17,9 @@ struct pt_regs_dwarfnum {
         unsigned int dwarfnum;
 };
 
-#define STR(s) #s
 #define REG_DWARFNUM_NAME(r, num) {.name = r, .dwarfnum = num}
 #define GPR_DWARFNUM_NAME(num) \
-        {.name = STR(%r##num), .dwarfnum = num}
+        {.name = __stringify(%r##num), .dwarfnum = num}
 #define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0}
 
 /*
diff --git a/tools/perf/arch/arm/util/unwind-libdw.c b/tools/perf/arch/arm/util/unwind-libdw.c
index b4176c60117a..bacfa00fca39 100644
--- a/tools/perf/arch/arm/util/unwind-libdw.c
+++ b/tools/perf/arch/arm/util/unwind-libdw.c
@@ -1,6 +1,7 @@
 #include <elfutils/libdwfl.h>
 #include "../../util/unwind-libdw.h"
 #include "../../util/perf_regs.h"
+#include "../../util/event.h"
 
 bool libdw__arch_set_initial_registers(Dwfl_Thread *thread, void *arg)
 {
diff --git a/tools/perf/arch/arm64/util/dwarf-regs.c b/tools/perf/arch/arm64/util/dwarf-regs.c
index 068b6189157b..cd764a9fd098 100644
--- a/tools/perf/arch/arm64/util/dwarf-regs.c
+++ b/tools/perf/arch/arm64/util/dwarf-regs.c
@@ -8,9 +8,12 @@
  * published by the Free Software Foundation.
  */
 
+#include <errno.h>
 #include <stddef.h>
+#include <string.h>
 #include <dwarf-regs.h>
 #include <linux/ptrace.h> /* for struct user_pt_regs */
+#include <linux/stringify.h>
 #include "util.h"
 
 struct pt_regs_dwarfnum {
@@ -20,7 +23,7 @@ struct pt_regs_dwarfnum {
 
 #define REG_DWARFNUM_NAME(r, num) {.name = r, .dwarfnum = num}
 #define GPR_DWARFNUM_NAME(num) \
-        {.name = STR(%x##num), .dwarfnum = num}
+        {.name = __stringify(%x##num), .dwarfnum = num}
 #define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0}
 #define DWARFNUM2OFFSET(index) \
         (index * sizeof((struct user_pt_regs *)0)->regs[0])
diff --git a/tools/perf/arch/arm64/util/unwind-libunwind.c b/tools/perf/arch/arm64/util/unwind-libunwind.c
index c116b713f7f7..b415dfdbccca 100644
--- a/tools/perf/arch/arm64/util/unwind-libunwind.c
+++ b/tools/perf/arch/arm64/util/unwind-libunwind.c
@@ -1,6 +1,6 @@
+#include <errno.h>
 
 #ifndef REMOTE_UNWIND_LIBUNWIND
-#include <errno.h>
 #include <libunwind.h>
 #include "perf_regs.h"
 #include "../../util/unwind.h"
diff --git a/tools/perf/arch/common.c b/tools/perf/arch/common.c
index 886dd2aaff0d..837067f48a4c 100644
--- a/tools/perf/arch/common.c
+++ b/tools/perf/arch/common.c
@@ -4,6 +4,8 @@
 #include "../util/util.h"
 #include "../util/debug.h"
 
+#include "sane_ctype.h"
+
 const char *const arm_triplets[] = {
         "arm-eabi-",
         "arm-linux-androideabi-",
diff --git a/tools/perf/arch/powerpc/util/dwarf-regs.c b/tools/perf/arch/powerpc/util/dwarf-regs.c
index 41bdf9530d82..98ac87052a74 100644
--- a/tools/perf/arch/powerpc/util/dwarf-regs.c
+++ b/tools/perf/arch/powerpc/util/dwarf-regs.c
@@ -15,6 +15,7 @@
 #include <dwarf-regs.h>
 #include <linux/ptrace.h>
 #include <linux/kernel.h>
+#include <linux/stringify.h>
 #include "util.h"
 
 struct pt_regs_dwarfnum {
@@ -24,10 +25,10 @@ struct pt_regs_dwarfnum {
 };
 
 #define REG_DWARFNUM_NAME(r, num)                                       \
-                {.name = STR(%)STR(r), .dwarfnum = num,                 \
+                {.name = __stringify(%)__stringify(r), .dwarfnum = num,                 \
                 .ptregs_offset = offsetof(struct pt_regs, r)}
 #define GPR_DWARFNUM_NAME(num)                                          \
-                {.name = STR(%gpr##num), .dwarfnum = num,               \
+                {.name = __stringify(%gpr##num), .dwarfnum = num,               \
                 .ptregs_offset = offsetof(struct pt_regs, gpr[num])}
 #define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0, .ptregs_offset = 0}
 
diff --git a/tools/perf/arch/powerpc/util/kvm-stat.c b/tools/perf/arch/powerpc/util/kvm-stat.c
index 74eee30398f8..249723f0e6a9 100644
--- a/tools/perf/arch/powerpc/util/kvm-stat.c
+++ b/tools/perf/arch/powerpc/util/kvm-stat.c
@@ -1,3 +1,4 @@
+#include <errno.h>
 #include "util/kvm-stat.h"
 #include "util/parse-events.h"
 #include "util/debug.h"
diff --git a/tools/perf/arch/powerpc/util/perf_regs.c b/tools/perf/arch/powerpc/util/perf_regs.c
index a3c3e1ce6807..f860dc411f69 100644
--- a/tools/perf/arch/powerpc/util/perf_regs.c
+++ b/tools/perf/arch/powerpc/util/perf_regs.c
@@ -1,5 +1,11 @@
+#include <errno.h>
+#include <string.h>
+#include <regex.h>
+
 #include "../../perf.h"
+#include "../../util/util.h"
 #include "../../util/perf_regs.h"
+#include "../../util/debug.h"
 
 const struct sample_reg sample_reg_masks[] = {
         SMPL_REG(r0, PERF_REG_POWERPC_R0),
@@ -47,3 +53,109 @@ const struct sample_reg sample_reg_masks[] = {
         SMPL_REG(dsisr, PERF_REG_POWERPC_DSISR),
         SMPL_REG_END
 };
+
+/* REG or %rREG */
+#define SDT_OP_REGEX1  "^(%r)?([1-2]?[0-9]|3[0-1])$"
+
+/* -NUM(REG) or NUM(REG) or -NUM(%rREG) or NUM(%rREG) */
+#define SDT_OP_REGEX2  "^(\\-)?([0-9]+)\\((%r)?([1-2]?[0-9]|3[0-1])\\)$"
+
+static regex_t sdt_op_regex1, sdt_op_regex2;
+
+static int sdt_init_op_regex(void)
+{
+        static int initialized;
+        int ret = 0;
+
+        if (initialized)
+                return 0;
+
+        ret = regcomp(&sdt_op_regex1, SDT_OP_REGEX1, REG_EXTENDED);
+        if (ret)
+                goto error;
+
+        ret = regcomp(&sdt_op_regex2, SDT_OP_REGEX2, REG_EXTENDED);
+        if (ret)
+                goto free_regex1;
+
+        initialized = 1;
+        return 0;
+
+free_regex1:
+        regfree(&sdt_op_regex1);
+error:
+        pr_debug4("Regex compilation error.\n");
+        return ret;
+}
+
+/*
+ * Parse OP and convert it into uprobe format, which is, +/-NUM(%gprREG).
+ * Possible variants of OP are:
+ *      Format          Example
+ *      -------------------------
+ *      NUM(REG)        48(18)
+ *      -NUM(REG)       -48(18)
+ *      NUM(%rREG)      48(%r18)
+ *      -NUM(%rREG)     -48(%r18)
+ *      REG             18
+ *      %rREG           %r18
+ *      iNUM            i0
+ *      i-NUM           i-1
+ *
+ * SDT marker arguments on Powerpc uses %rREG form with -mregnames flag
+ * and REG form with -mno-regnames. Here REG is general purpose register,
+ * which is in 0 to 31 range.
+ */
+int arch_sdt_arg_parse_op(char *old_op, char **new_op)
+{
+        int ret, new_len;
+        regmatch_t rm[5];
+        char prefix;
+
+        /* Constant argument. Uprobe does not support it */
+        if (old_op[0] == 'i') {
+                pr_debug4("Skipping unsupported SDT argument: %s\n", old_op);
+                return SDT_ARG_SKIP;
+        }
+
+        ret = sdt_init_op_regex();
+        if (ret < 0)
+                return ret;
+
+        if (!regexec(&sdt_op_regex1, old_op, 3, rm, 0)) {
+                /* REG or %rREG --> %gprREG */
+
+                new_len = 5;    /* % g p r NULL */
+                new_len += (int)(rm[2].rm_eo - rm[2].rm_so);
+
+                *new_op = zalloc(new_len);
+                if (!*new_op)
+                        return -ENOMEM;
+
+                scnprintf(*new_op, new_len, "%%gpr%.*s",
+                        (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so);
+        } else if (!regexec(&sdt_op_regex2, old_op, 5, rm, 0)) {
+                /*
+                 * -NUM(REG) or NUM(REG) or -NUM(%rREG) or NUM(%rREG) -->
+                 *      +/-NUM(%gprREG)
+                 */
+                prefix = (rm[1].rm_so == -1) ? '+' : '-';
+
+                new_len = 8;    /* +/- ( % g p r ) NULL */
+                new_len += (int)(rm[2].rm_eo - rm[2].rm_so);
+                new_len += (int)(rm[4].rm_eo - rm[4].rm_so);
+
+                *new_op = zalloc(new_len);
+                if (!*new_op)
+                        return -ENOMEM;
+
+                scnprintf(*new_op, new_len, "%c%.*s(%%gpr%.*s)", prefix,
+                        (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so,
+                        (int)(rm[4].rm_eo - rm[4].rm_so), old_op + rm[4].rm_so);
+        } else {
+                pr_debug4("Skipping unsupported SDT argument: %s\n", old_op);
+                return SDT_ARG_SKIP;
+        }
+
+        return SDT_ARG_VALID;
+}
diff --git a/tools/perf/arch/powerpc/util/sym-handling.c b/tools/perf/arch/powerpc/util/sym-handling.c
index 1030a6e504bb..39dbe512b9fc 100644
--- a/tools/perf/arch/powerpc/util/sym-handling.c
+++ b/tools/perf/arch/powerpc/util/sym-handling.c
@@ -10,6 +10,7 @@
 #include "symbol.h"
 #include "map.h"
 #include "probe-event.h"
+#include "probe-file.h"
 
 #ifdef HAVE_LIBELF_SUPPORT
 bool elf__needs_adjust_symbols(GElf_Ehdr ehdr)
@@ -79,13 +80,18 @@ void arch__fix_tev_from_maps(struct perf_probe_event *pev,
          * However, if the user specifies an offset, we fall back to using the
          * GEP since all userspace applications (objdump/readelf) show function
          * disassembly with offsets from the GEP.
-         *
-         * In addition, we shouldn't specify an offset for kretprobes.
          */
-        if (pev->point.offset || (!pev->uprobes && pev->point.retprobe) ||
-            !map || !sym)
+        if (pev->point.offset || !map || !sym)
                 return;
 
+        /* For kretprobes, add an offset only if the kernel supports it */
+        if (!pev->uprobes && pev->point.retprobe) {
+#ifdef HAVE_LIBELF_SUPPORT
+                if (!kretprobe_offset_is_supported())
+#endif
+                        return;
+        }
+
         lep_offset = PPC64_LOCAL_ENTRY_OFFSET(sym->arch_sym);
 
         if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS)
diff --git a/tools/perf/arch/s390/annotate/instructions.c b/tools/perf/arch/s390/annotate/instructions.c
new file mode 100644
index 000000000000..745b4b1b8b21
--- /dev/null
+++ b/tools/perf/arch/s390/annotate/instructions.c
@@ -0,0 +1,30 @@
+static struct ins_ops *s390__associate_ins_ops(struct arch *arch, const char *name)
+{
+        struct ins_ops *ops = NULL;
+
+        /* catch all kind of jumps */
+        if (strchr(name, 'j') ||
+            !strncmp(name, "bct", 3) ||
+            !strncmp(name, "br", 2))
+                ops = &jump_ops;
+        /* override call/returns */
+        if (!strcmp(name, "bras") ||
+            !strcmp(name, "brasl") ||
+            !strcmp(name, "basr"))
+                ops = &call_ops;
+        if (!strcmp(name, "br"))
+                ops = &ret_ops;
+
+        arch__associate_ins_ops(arch, name, ops);
+        return ops;
+}
+
+static int s390__annotate_init(struct arch *arch)
+{
+        if (!arch->initialized) {
+                arch->initialized = true;
+                arch->associate_instruction_ops = s390__associate_ins_ops;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/arch/s390/util/kvm-stat.c b/tools/perf/arch/s390/util/kvm-stat.c
index ed57df2e6d68..d233e2eb9592 100644
--- a/tools/perf/arch/s390/util/kvm-stat.c
+++ b/tools/perf/arch/s390/util/kvm-stat.c
@@ -9,6 +9,7 @@
  * as published by the Free Software Foundation.
  */
 
+#include <errno.h>
 #include "../../util/kvm-stat.h"
 #include <asm/sie.h>
 
diff --git a/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl b/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
index e93ef0b38db8..5aef183e2f85 100644
--- a/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
@@ -338,6 +338,7 @@
 329     common  pkey_mprotect           sys_pkey_mprotect
 330     common  pkey_alloc              sys_pkey_alloc
 331     common  pkey_free               sys_pkey_free
+332     common  statx                   sys_statx
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/tools/perf/arch/x86/tests/intel-cqm.c b/tools/perf/arch/x86/tests/intel-cqm.c
index 7f064eb37158..f9713a71d77e 100644
--- a/tools/perf/arch/x86/tests/intel-cqm.c
+++ b/tools/perf/arch/x86/tests/intel-cqm.c
@@ -6,7 +6,10 @@
 #include "evsel.h"
 #include "arch-tests.h"
 
+#include <signal.h>
 #include <sys/mman.h>
+#include <sys/wait.h>
+#include <errno.h>
 #include <string.h>
 
 static pid_t spawn(void)
diff --git a/tools/perf/arch/x86/tests/perf-time-to-tsc.c b/tools/perf/arch/x86/tests/perf-time-to-tsc.c
index 5c76cc83186a..e3ae9cff2b67 100644
--- a/tools/perf/arch/x86/tests/perf-time-to-tsc.c
+++ b/tools/perf/arch/x86/tests/perf-time-to-tsc.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <linux/types.h>
diff --git a/tools/perf/arch/x86/util/auxtrace.c b/tools/perf/arch/x86/util/auxtrace.c
index cc1d865e31f1..6aa3f2a38321 100644
--- a/tools/perf/arch/x86/util/auxtrace.c
+++ b/tools/perf/arch/x86/util/auxtrace.c
@@ -13,6 +13,7 @@
  *
  */
 
+#include <errno.h>
 #include <stdbool.h>
 
 #include "../../util/header.h"
diff --git a/tools/perf/arch/x86/util/intel-bts.c b/tools/perf/arch/x86/util/intel-bts.c
index 5132775a044f..af2bce7a2cd6 100644
--- a/tools/perf/arch/x86/util/intel-bts.c
+++ b/tools/perf/arch/x86/util/intel-bts.c
@@ -13,6 +13,7 @@
  *
  */
 
+#include <errno.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/bitops.h>
diff --git a/tools/perf/arch/x86/util/intel-pt.c b/tools/perf/arch/x86/util/intel-pt.c
index 90fa2286edcf..f630de0206a1 100644
--- a/tools/perf/arch/x86/util/intel-pt.c
+++ b/tools/perf/arch/x86/util/intel-pt.c
@@ -13,6 +13,7 @@
  *
  */
 
+#include <errno.h>
 #include <stdbool.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
diff --git a/tools/perf/arch/x86/util/kvm-stat.c b/tools/perf/arch/x86/util/kvm-stat.c
index b63d4be655a2..bf817beca0a8 100644
--- a/tools/perf/arch/x86/util/kvm-stat.c
+++ b/tools/perf/arch/x86/util/kvm-stat.c
@@ -1,3 +1,4 @@
+#include <errno.h>
 #include "../../util/kvm-stat.h"
 #include <asm/svm.h>
 #include <asm/vmx.h>
diff --git a/tools/perf/arch/x86/util/perf_regs.c b/tools/perf/arch/x86/util/perf_regs.c
index c5db14f36cc7..f95edebfb716 100644
--- a/tools/perf/arch/x86/util/perf_regs.c
+++ b/tools/perf/arch/x86/util/perf_regs.c
@@ -1,5 +1,11 @@
+#include <errno.h>
+#include <string.h>
+#include <regex.h>
+
 #include "../../perf.h"
+#include "../../util/util.h"
 #include "../../util/perf_regs.h"
+#include "../../util/debug.h"
 
 const struct sample_reg sample_reg_masks[] = {
         SMPL_REG(AX, PERF_REG_X86_AX),
@@ -26,3 +32,224 @@ const struct sample_reg sample_reg_masks[] = {
 #endif
         SMPL_REG_END
 };
+
+struct sdt_name_reg {
+        const char *sdt_name;
+        const char *uprobe_name;
+};
+#define SDT_NAME_REG(n, m) {.sdt_name = "%" #n, .uprobe_name = "%" #m}
+#define SDT_NAME_REG_END {.sdt_name = NULL, .uprobe_name = NULL}
+
+static const struct sdt_name_reg sdt_reg_tbl[] = {
+        SDT_NAME_REG(eax, ax),
+        SDT_NAME_REG(rax, ax),
+        SDT_NAME_REG(al,  ax),
+        SDT_NAME_REG(ah,  ax),
+        SDT_NAME_REG(ebx, bx),
+        SDT_NAME_REG(rbx, bx),
+        SDT_NAME_REG(bl,  bx),
+        SDT_NAME_REG(bh,  bx),
+        SDT_NAME_REG(ecx, cx),
+        SDT_NAME_REG(rcx, cx),
+        SDT_NAME_REG(cl,  cx),
+        SDT_NAME_REG(ch,  cx),
+        SDT_NAME_REG(edx, dx),
+        SDT_NAME_REG(rdx, dx),
+        SDT_NAME_REG(dl,  dx),
+        SDT_NAME_REG(dh,  dx),
+        SDT_NAME_REG(esi, si),
+        SDT_NAME_REG(rsi, si),
+        SDT_NAME_REG(sil, si),
+        SDT_NAME_REG(edi, di),
+        SDT_NAME_REG(rdi, di),
+        SDT_NAME_REG(dil, di),
+        SDT_NAME_REG(ebp, bp),
+        SDT_NAME_REG(rbp, bp),
+        SDT_NAME_REG(bpl, bp),
+        SDT_NAME_REG(rsp, sp),
+        SDT_NAME_REG(esp, sp),
+        SDT_NAME_REG(spl, sp),
+
+        /* rNN registers */
+        SDT_NAME_REG(r8b,  r8),
+        SDT_NAME_REG(r8w,  r8),
+        SDT_NAME_REG(r8d,  r8),
+        SDT_NAME_REG(r9b,  r9),
+        SDT_NAME_REG(r9w,  r9),
+        SDT_NAME_REG(r9d,  r9),
+        SDT_NAME_REG(r10b, r10),
+        SDT_NAME_REG(r10w, r10),
+        SDT_NAME_REG(r10d, r10),
+        SDT_NAME_REG(r11b, r11),
+        SDT_NAME_REG(r11w, r11),
+        SDT_NAME_REG(r11d, r11),
+        SDT_NAME_REG(r12b, r12),
+        SDT_NAME_REG(r12w, r12),
+        SDT_NAME_REG(r12d, r12),
+        SDT_NAME_REG(r13b, r13),
+        SDT_NAME_REG(r13w, r13),
+        SDT_NAME_REG(r13d, r13),
+        SDT_NAME_REG(r14b, r14),
+        SDT_NAME_REG(r14w, r14),
+        SDT_NAME_REG(r14d, r14),
+        SDT_NAME_REG(r15b, r15),
+        SDT_NAME_REG(r15w, r15),
+        SDT_NAME_REG(r15d, r15),
+        SDT_NAME_REG_END,
+};
+
+/*
+ * Perf only supports OP which is in  +/-NUM(REG)  form.
+ * Here plus-minus sign, NUM and parenthesis are optional,
+ * only REG is mandatory.
+ *
+ * SDT events also supports indirect addressing mode with a
+ * symbol as offset, scaled mode and constants in OP. But
+ * perf does not support them yet. Below are few examples.
+ *
+ * OP with scaled mode:
+ *     (%rax,%rsi,8)
+ *     10(%ras,%rsi,8)
+ *
+ * OP with indirect addressing mode:
+ *     check_action(%rip)
+ *     mp_+52(%rip)
+ *     44+mp_(%rip)
+ *
+ * OP with constant values:
+ *     $0
+ *     $123
+ *     $-1
+ */
+#define SDT_OP_REGEX  "^([+\\-]?)([0-9]*)(\\(?)(%[a-z][a-z0-9]+)(\\)?)$"
+
+static regex_t sdt_op_regex;
+
+static int sdt_init_op_regex(void)
+{
+        static int initialized;
+        int ret = 0;
+
+        if (initialized)
+                return 0;
+
+        ret = regcomp(&sdt_op_regex, SDT_OP_REGEX, REG_EXTENDED);
+        if (ret < 0) {
+                pr_debug4("Regex compilation error.\n");
+                return ret;
+        }
+
+        initialized = 1;
+        return 0;
+}
+
+/*
+ * Max x86 register name length is 5(ex: %r15d). So, 6th char
+ * should always contain NULL. This helps to find register name
+ * length using strlen, insted of maintaing one more variable.
+ */
+#define SDT_REG_NAME_SIZE  6
+
+/*
+ * The uprobe parser does not support all gas register names;
+ * so, we have to replace them (ex. for x86_64: %rax -> %ax).
+ * Note: If register does not require renaming, just copy
+ * paste as it is, but don't leave it empty.
+ */
+static void sdt_rename_register(char *sdt_reg, int sdt_len, char *uprobe_reg)
+{
+        int i = 0;
+
+        for (i = 0; sdt_reg_tbl[i].sdt_name != NULL; i++) {
+                if (!strncmp(sdt_reg_tbl[i].sdt_name, sdt_reg, sdt_len)) {
+                        strcpy(uprobe_reg, sdt_reg_tbl[i].uprobe_name);
+                        return;
+                }
+        }
+
+        strncpy(uprobe_reg, sdt_reg, sdt_len);
+}
+
+int arch_sdt_arg_parse_op(char *old_op, char **new_op)
+{
+        char new_reg[SDT_REG_NAME_SIZE] = {0};
+        int new_len = 0, ret;
+        /*
+         * rm[0]:  +/-NUM(REG)
+         * rm[1]:  +/-
+         * rm[2]:  NUM
+         * rm[3]:  (
+         * rm[4]:  REG
+         * rm[5]:  )
+         */
+        regmatch_t rm[6];
+        /*
+         * Max prefix length is 2 as it may contains sign(+/-)
+         * and displacement 0 (Both sign and displacement 0 are
+         * optional so it may be empty). Use one more character
+         * to hold last NULL so that strlen can be used to find
+         * prefix length, instead of maintaing one more variable.
+         */
+        char prefix[3] = {0};
+
+        ret = sdt_init_op_regex();
+        if (ret < 0)
+                return ret;
+
+        /*
+         * If unsupported OR does not match with regex OR
+         * register name too long, skip it.
+         */
+        if (strchr(old_op, ',') || strchr(old_op, '$') ||
+            regexec(&sdt_op_regex, old_op, 6, rm, 0)   ||
+            rm[4].rm_eo - rm[4].rm_so > SDT_REG_NAME_SIZE) {
+                pr_debug4("Skipping unsupported SDT argument: %s\n", old_op);
+                return SDT_ARG_SKIP;
+        }
+
+        /*
+         * Prepare prefix.
+         * If SDT OP has parenthesis but does not provide
+         * displacement, add 0 for displacement.
+         *     SDT         Uprobe     Prefix
+         *     -----------------------------
+         *     +24(%rdi)   +24(%di)   +
+         *     24(%rdi)    +24(%di)   +
+         *     %rdi        %di
+         *     (%rdi)      +0(%di)    +0
+         *     -80(%rbx)   -80(%bx)   -
+         */
+        if (rm[3].rm_so != rm[3].rm_eo) {
+                if (rm[1].rm_so != rm[1].rm_eo)
+                        prefix[0] = *(old_op + rm[1].rm_so);
+                else if (rm[2].rm_so != rm[2].rm_eo)
+                        prefix[0] = '+';
+                else
+                        strncpy(prefix, "+0", 2);
+        }
+
+        /* Rename register */
+        sdt_rename_register(old_op + rm[4].rm_so, rm[4].rm_eo - rm[4].rm_so,
+                            new_reg);
+
+        /* Prepare final OP which should be valid for uprobe_events */
+        new_len = strlen(prefix)              +
+                  (rm[2].rm_eo - rm[2].rm_so) +
+                  (rm[3].rm_eo - rm[3].rm_so) +
+                  strlen(new_reg)             +
+                  (rm[5].rm_eo - rm[5].rm_so) +
+                  1;                                    /* NULL */
+
+        *new_op = zalloc(new_len);
+        if (!*new_op)
+                return -ENOMEM;
+
+        scnprintf(*new_op, new_len, "%.*s%.*s%.*s%.*s%.*s",
+                  strlen(prefix), prefix,
+                  (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so,
+                  (int)(rm[3].rm_eo - rm[3].rm_so), old_op + rm[3].rm_so,
+                  strlen(new_reg), new_reg,
+                  (int)(rm[5].rm_eo - rm[5].rm_so), old_op + rm[5].rm_so);
+
+        return SDT_ARG_VALID;
+}
diff --git a/tools/perf/arch/x86/util/unwind-libdw.c b/tools/perf/arch/x86/util/unwind-libdw.c
index c4b72176ca83..38dc9bb2a7c9 100644
--- a/tools/perf/arch/x86/util/unwind-libdw.c
+++ b/tools/perf/arch/x86/util/unwind-libdw.c
@@ -1,6 +1,7 @@
 #include <elfutils/libdwfl.h>
 #include "../../util/unwind-libdw.h"
 #include "../../util/perf_regs.h"
+#include "../../util/event.h"
 
 bool libdw__arch_set_initial_registers(Dwfl_Thread *thread, void *arg)
 {
diff --git a/tools/perf/bench/bench.h b/tools/perf/bench/bench.h
index 579a592990dd..842ab2781cdc 100644
--- a/tools/perf/bench/bench.h
+++ b/tools/perf/bench/bench.h
@@ -25,17 +25,17 @@
 # endif
 #endif
 
-int bench_numa(int argc, const char **argv, const char *prefix);
-int bench_sched_messaging(int argc, const char **argv, const char *prefix);
-int bench_sched_pipe(int argc, const char **argv, const char *prefix);
-int bench_mem_memcpy(int argc, const char **argv, const char *prefix);
-int bench_mem_memset(int argc, const char **argv, const char *prefix);
-int bench_futex_hash(int argc, const char **argv, const char *prefix);
-int bench_futex_wake(int argc, const char **argv, const char *prefix);
-int bench_futex_wake_parallel(int argc, const char **argv, const char *prefix);
-int bench_futex_requeue(int argc, const char **argv, const char *prefix);
+int bench_numa(int argc, const char **argv);
+int bench_sched_messaging(int argc, const char **argv);
+int bench_sched_pipe(int argc, const char **argv);
+int bench_mem_memcpy(int argc, const char **argv);
+int bench_mem_memset(int argc, const char **argv);
+int bench_futex_hash(int argc, const char **argv);
+int bench_futex_wake(int argc, const char **argv);
+int bench_futex_wake_parallel(int argc, const char **argv);
+int bench_futex_requeue(int argc, const char **argv);
 /* pi futexes */
-int bench_futex_lock_pi(int argc, const char **argv, const char *prefix);
+int bench_futex_lock_pi(int argc, const char **argv);
 
 #define BENCH_FORMAT_DEFAULT_STR        "default"
 #define BENCH_FORMAT_DEFAULT            0
diff --git a/tools/perf/bench/futex-hash.c b/tools/perf/bench/futex-hash.c
index da04b8c5568a..fe16b310097f 100644
--- a/tools/perf/bench/futex-hash.c
+++ b/tools/perf/bench/futex-hash.c
@@ -9,6 +9,7 @@
  */
 
 /* For the CLR_() macros */
+#include <string.h>
 #include <pthread.h>
 
 #include <errno.h>
@@ -113,8 +114,7 @@ static void print_summary(void)
                (int) runtime.tv_sec);
 }
 
-int bench_futex_hash(int argc, const char **argv,
-                     const char *prefix __maybe_unused)
+int bench_futex_hash(int argc, const char **argv)
 {
         int ret = 0;
         cpu_set_t cpu;
diff --git a/tools/perf/bench/futex-lock-pi.c b/tools/perf/bench/futex-lock-pi.c
index 91877777ec6e..73a1c44ea63c 100644
--- a/tools/perf/bench/futex-lock-pi.c
+++ b/tools/perf/bench/futex-lock-pi.c
@@ -3,6 +3,7 @@
  */
 
 /* For the CLR_() macros */
+#include <string.h>
 #include <pthread.h>
 
 #include <signal.h>
@@ -139,8 +140,7 @@ static void create_threads(struct worker *w, pthread_attr_t thread_attr)
         }
 }
 
-int bench_futex_lock_pi(int argc, const char **argv,
-                        const char *prefix __maybe_unused)
+int bench_futex_lock_pi(int argc, const char **argv)
 {
         int ret = 0;
         unsigned int i;
diff --git a/tools/perf/bench/futex-requeue.c b/tools/perf/bench/futex-requeue.c
index 2b9705a8734c..41786cbea24c 100644
--- a/tools/perf/bench/futex-requeue.c
+++ b/tools/perf/bench/futex-requeue.c
@@ -9,6 +9,7 @@
  */
 
 /* For the CLR_() macros */
+#include <string.h>
 #include <pthread.h>
 
 #include <signal.h>
@@ -108,8 +109,7 @@ static void toggle_done(int sig __maybe_unused,
         done = true;
 }
 
-int bench_futex_requeue(int argc, const char **argv,
-                        const char *prefix __maybe_unused)
+int bench_futex_requeue(int argc, const char **argv)
 {
         int ret = 0;
         unsigned int i, j;
diff --git a/tools/perf/bench/futex-wake-parallel.c b/tools/perf/bench/futex-wake-parallel.c
index 2c8fa67ad537..4ab12c8e016a 100644
--- a/tools/perf/bench/futex-wake-parallel.c
+++ b/tools/perf/bench/futex-wake-parallel.c
@@ -8,6 +8,7 @@
  */
 
 /* For the CLR_() macros */
+#include <string.h>
 #include <pthread.h>
 
 #include <signal.h>
@@ -196,8 +197,7 @@ static void toggle_done(int sig __maybe_unused,
         done = true;
 }
 
-int bench_futex_wake_parallel(int argc, const char **argv,
-                              const char *prefix __maybe_unused)
+int bench_futex_wake_parallel(int argc, const char **argv)
 {
         int ret = 0;
         unsigned int i, j;
diff --git a/tools/perf/bench/futex-wake.c b/tools/perf/bench/futex-wake.c
index e246b1b8388a..2fa49222ef8d 100644
--- a/tools/perf/bench/futex-wake.c
+++ b/tools/perf/bench/futex-wake.c
@@ -9,6 +9,7 @@
  */
 
 /* For the CLR_() macros */
+#include <string.h>
 #include <pthread.h>
 
 #include <signal.h>
@@ -114,8 +115,7 @@ static void toggle_done(int sig __maybe_unused,
         done = true;
 }
 
-int bench_futex_wake(int argc, const char **argv,
-                     const char *prefix __maybe_unused)
+int bench_futex_wake(int argc, const char **argv)
 {
         int ret = 0;
         unsigned int i, j;
diff --git a/tools/perf/bench/futex.h b/tools/perf/bench/futex.h
index b2e06d1190d0..e44fd3239530 100644
--- a/tools/perf/bench/futex.h
+++ b/tools/perf/bench/futex.h
@@ -88,13 +88,11 @@ futex_cmp_requeue(u_int32_t *uaddr, u_int32_t val, u_int32_t *uaddr2, int nr_wak
 
 #ifndef HAVE_PTHREAD_ATTR_SETAFFINITY_NP
 #include <pthread.h>
-static inline int pthread_attr_setaffinity_np(pthread_attr_t *attr,
-                                              size_t cpusetsize,
-                                              cpu_set_t *cpuset)
+#include <linux/compiler.h>
+static inline int pthread_attr_setaffinity_np(pthread_attr_t *attr __maybe_unused,
+                                              size_t cpusetsize __maybe_unused,
+                                              cpu_set_t *cpuset __maybe_unused)
 {
-        attr = attr;
-        cpusetsize = cpusetsize;
-        cpuset = cpuset;
         return 0;
 }
 #endif
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 52504a83b5a1..fbd732b54047 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -12,6 +12,7 @@
 #include <subcmd/parse-options.h>
 #include "../util/header.h"
 #include "../util/cloexec.h"
+#include "../util/string2.h"
 #include "bench.h"
 #include "mem-memcpy-arch.h"
 #include "mem-memset-arch.h"
@@ -284,7 +285,7 @@ static const char * const bench_mem_memcpy_usage[] = {
         NULL
 };
 
-int bench_mem_memcpy(int argc, const char **argv, const char *prefix __maybe_unused)
+int bench_mem_memcpy(int argc, const char **argv)
 {
         struct bench_mem_info info = {
                 .functions              = memcpy_functions,
@@ -358,7 +359,7 @@ static const struct function memset_functions[] = {
         { .name = NULL, }
 };
 
-int bench_mem_memset(int argc, const char **argv, const char *prefix __maybe_unused)
+int bench_mem_memset(int argc, const char **argv)
 {
         struct bench_mem_info info = {
                 .functions              = memset_functions,
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 3083fc36282b..27de0c8c5c19 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -4,6 +4,7 @@
  * numa: Simulate NUMA-sensitive workload and measure their NUMA performance
  */
 
+#include <inttypes.h>
 /* For the CLR_() macros */
 #include <pthread.h>
 
@@ -30,6 +31,7 @@
 #include <sys/wait.h>
 #include <sys/prctl.h>
 #include <sys/types.h>
+#include <linux/kernel.h>
 #include <linux/time64.h>
 
 #include <numa.h>
@@ -187,7 +189,8 @@ static const struct option options[] = {
         OPT_INCR   ('d', "show_details" , &p0.show_details,     "Show details"),
         OPT_INCR   ('a', "all"          , &p0.run_all,          "Run all tests in the suite"),
         OPT_INTEGER('H', "thp"          , &p0.thp,              "MADV_NOHUGEPAGE < 0 < MADV_HUGEPAGE"),
-        OPT_BOOLEAN('c', "show_convergence", &p0.show_convergence, "show convergence details"),
+        OPT_BOOLEAN('c', "show_convergence", &p0.show_convergence, "show convergence details, "
+                    "convergence is reached when each process (all its threads) is running on a single NUMA node."),
         OPT_BOOLEAN('m', "measure_convergence", &p0.measure_convergence, "measure convergence latency"),
         OPT_BOOLEAN('q', "quiet"        , &p0.show_quiet,       "quiet mode"),
         OPT_BOOLEAN('S', "serialize-startup", &p0.serialize_startup,"serialize thread startup"),
@@ -1766,7 +1769,7 @@ static int bench_all(void)
         return 0;
 }
 
-int bench_numa(int argc, const char **argv, const char *prefix __maybe_unused)
+int bench_numa(int argc, const char **argv)
 {
         init_params(&p0, "main,", argc, argv);
         argc = parse_options(argc, argv, options, bench_numa_usage, 0);
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index 6a111e775210..4f961e74535b 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -260,8 +260,7 @@ static const char * const bench_sched_message_usage[] = {
         NULL
 };
 
-int bench_sched_messaging(int argc, const char **argv,
-                    const char *prefix __maybe_unused)
+int bench_sched_messaging(int argc, const char **argv)
 {
         unsigned int i, total_children;
         struct timeval start, stop, diff;
diff --git a/tools/perf/bench/sched-pipe.c b/tools/perf/bench/sched-pipe.c
index 2243f0150d76..a152737370c5 100644
--- a/tools/perf/bench/sched-pipe.c
+++ b/tools/perf/bench/sched-pipe.c
@@ -76,7 +76,7 @@ static void *worker_thread(void *__tdata)
         return NULL;
 }
 
-int bench_sched_pipe(int argc, const char **argv, const char *prefix __maybe_unused)
+int bench_sched_pipe(int argc, const char **argv)
 {
         struct thread_data threads[2], *td;
         int pipe_1[2], pipe_2[2];
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 4f52d85f5ebc..7a5dc7e5c577 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -33,6 +33,7 @@
 #include "util/block-range.h"
 
 #include <dlfcn.h>
+#include <errno.h>
 #include <linux/bitmap.h>
 
 struct perf_annotate {
@@ -383,7 +384,7 @@ static const char * const annotate_usage[] = {
         NULL
 };
 
-int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_annotate(int argc, const char **argv)
 {
         struct perf_annotate annotate = {
                 .tool = {
@@ -393,6 +394,9 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                         .comm   = perf_event__process_comm,
                         .exit   = perf_event__process_exit,
                         .fork   = perf_event__process_fork,
+                        .namespaces = perf_event__process_namespaces,
+                        .attr   = perf_event__process_attr,
+                        .build_id = perf_event__process_build_id,
                         .ordered_events = true,
                         .ordering_requires_timestamps = true,
                 },
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index a1cddc6bbf0f..445e62881254 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -25,7 +25,7 @@
 #include <string.h>
 #include <sys/prctl.h>
 
-typedef int (*bench_fn_t)(int argc, const char **argv, const char *prefix);
+typedef int (*bench_fn_t)(int argc, const char **argv);
 
 struct bench {
         const char      *name;
@@ -155,7 +155,7 @@ static int bench_str2int(const char *str)
  * to something meaningful:
  */
 static int run_bench(const char *coll_name, const char *bench_name, bench_fn_t fn,
-                     int argc, const char **argv, const char *prefix)
+                     int argc, const char **argv)
 {
         int size;
         char *name;
@@ -171,7 +171,7 @@ static int run_bench(const char *coll_name, const char *bench_name, bench_fn_t f
         prctl(PR_SET_NAME, name);
         argv[0] = name;
 
-        ret = fn(argc, argv, prefix);
+        ret = fn(argc, argv);
 
         free(name);
 
@@ -198,7 +198,7 @@ static void run_collection(struct collection *coll)
                 fflush(stdout);
 
                 argv[1] = bench->name;
-                run_bench(coll->name, bench->name, bench->fn, 1, argv, NULL);
+                run_bench(coll->name, bench->name, bench->fn, 1, argv);
                 printf("\n");
         }
 }
@@ -211,7 +211,7 @@ static void run_all_collections(void)
                 run_collection(coll);
 }
 
-int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_bench(int argc, const char **argv)
 {
         struct collection *coll;
         int ret = 0;
@@ -270,7 +270,7 @@ int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused)
                         if (bench_format == BENCH_FORMAT_DEFAULT)
                                 printf("# Running '%s/%s' benchmark:\n", coll->name, bench->name);
                         fflush(stdout);
-                        ret = run_bench(coll->name, bench->name, bench->fn, argc-1, argv+1, prefix);
+                        ret = run_bench(coll->name, bench->name, bench->fn, argc-1, argv+1);
                         goto end;
                 }
 
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index 30e2b2cb2421..64b44e81c771 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -10,6 +10,7 @@
 #include <sys/time.h>
 #include <time.h>
 #include <dirent.h>
+#include <errno.h>
 #include <unistd.h>
 #include "builtin.h"
 #include "perf.h"
@@ -21,6 +22,7 @@
 #include "util/build-id.h"
 #include "util/session.h"
 #include "util/symbol.h"
+#include "util/time-utils.h"
 
 static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid)
 {
@@ -276,8 +278,7 @@ static int build_id_cache__update_file(const char *filename)
         return err;
 }
 
-int cmd_buildid_cache(int argc, const char **argv,
-                      const char *prefix __maybe_unused)
+int cmd_buildid_cache(int argc, const char **argv)
 {
         struct strlist *list;
         struct str_node *pos;
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index 5e914ee79eb3..fdaca16e0c74 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -16,6 +16,7 @@
 #include "util/session.h"
 #include "util/symbol.h"
 #include "util/data.h"
+#include <errno.h>
 
 static int sysfs__fprintf_build_id(FILE *fp)
 {
@@ -87,8 +88,7 @@ out:
         return 0;
 }
 
-int cmd_buildid_list(int argc, const char **argv,
-                     const char *prefix __maybe_unused)
+int cmd_buildid_list(int argc, const char **argv)
 {
         bool show_kernel = false;
         bool with_hits = false;
diff --git a/tools/perf/builtin-c2c.c b/tools/perf/builtin-c2c.c
index e2b21723bbf8..e33b4acece90 100644
--- a/tools/perf/builtin-c2c.c
+++ b/tools/perf/builtin-c2c.c
@@ -9,10 +9,13 @@
  *   Dick Fowles <fowles@inreach.com>
  *   Joe Mario <jmario@redhat.com>
  */
+#include <errno.h>
+#include <inttypes.h>
 #include <linux/compiler.h>
 #include <linux/kernel.h>
 #include <linux/stringify.h>
 #include <asm/bug.h>
+#include <sys/param.h>
 #include "util.h"
 #include "debug.h"
 #include "builtin.h"
@@ -29,6 +32,7 @@
 #include <asm/bug.h>
 #include "ui/browsers/hists.h"
 #include "evlist.h"
+#include "thread.h"
 
 struct c2c_hists {
         struct hists            hists;
@@ -2334,7 +2338,7 @@ out:
 
 static void perf_c2c_display(struct perf_session *session)
 {
-        if (c2c.use_stdio)
+        if (use_browser == 0)
                 perf_c2c__hists_fprintf(stdout, session);
         else
                 perf_c2c__hists_browse(&c2c.hists.hists);
@@ -2536,7 +2540,7 @@ static int perf_c2c__report(int argc, const char **argv)
         OPT_BOOLEAN(0, "stdio", &c2c.use_stdio, "Use the stdio interface"),
 #endif
         OPT_BOOLEAN(0, "stats", &c2c.stats_only,
-                    "Use the stdio interface"),
+                    "Display only statistic tables (implies --stdio)"),
         OPT_BOOLEAN(0, "full-symbols", &c2c.symbol_full,
                     "Display full length of symbols"),
         OPT_BOOLEAN(0, "no-source", &no_source,
@@ -2755,12 +2759,12 @@ static int perf_c2c__record(int argc, const char **argv)
                 pr_debug("\n");
         }
 
-        ret = cmd_record(i, rec_argv, NULL);
+        ret = cmd_record(i, rec_argv);
         free(rec_argv);
         return ret;
 }
 
-int cmd_c2c(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_c2c(int argc, const char **argv)
 {
         argc = parse_options(argc, argv, c2c_options, c2c_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
diff --git a/tools/perf/builtin-config.c b/tools/perf/builtin-config.c
index 8c0d93b7c2f0..55f04f85b049 100644
--- a/tools/perf/builtin-config.c
+++ b/tools/perf/builtin-config.c
@@ -154,7 +154,7 @@ static int parse_config_arg(char *arg, char **var, char **value)
         return 0;
 }
 
-int cmd_config(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_config(int argc, const char **argv)
 {
         int i, ret = 0;
         struct perf_config_set *set;
diff --git a/tools/perf/builtin-data.c b/tools/perf/builtin-data.c
index 7ad6e17ac6b3..0adb5f82335a 100644
--- a/tools/perf/builtin-data.c
+++ b/tools/perf/builtin-data.c
@@ -6,7 +6,7 @@
 #include "data-convert.h"
 #include "data-convert-bt.h"
 
-typedef int (*data_cmd_fn_t)(int argc, const char **argv, const char *prefix);
+typedef int (*data_cmd_fn_t)(int argc, const char **argv);
 
 struct data_cmd {
         const char      *name;
@@ -50,8 +50,7 @@ static const char * const data_convert_usage[] = {
         NULL
 };
 
-static int cmd_data_convert(int argc, const char **argv,
-                            const char *prefix __maybe_unused)
+static int cmd_data_convert(int argc, const char **argv)
 {
         const char *to_ctf     = NULL;
         struct perf_data_convert_opts opts = {
@@ -98,7 +97,7 @@ static struct data_cmd data_cmds[] = {
         { .name = NULL, },
 };
 
-int cmd_data(int argc, const char **argv, const char *prefix)
+int cmd_data(int argc, const char **argv)
 {
         struct data_cmd *cmd;
         const char *cmdstr;
@@ -118,7 +117,7 @@ int cmd_data(int argc, const char **argv, const char *prefix)
                 if (strcmp(cmd->name, cmdstr))
                         continue;
 
-                return cmd->fn(argc, argv, prefix);
+                return cmd->fn(argc, argv);
         }
 
         pr_err("Unknown command: %s\n", cmdstr);
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 1b96a3122228..eec5df80f5a3 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -19,6 +19,8 @@
 #include "util/data.h"
 #include "util/config.h"
 
+#include <errno.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <math.h>
 
@@ -364,6 +366,7 @@ static struct perf_tool tool = {
         .exit   = perf_event__process_exit,
         .fork   = perf_event__process_fork,
         .lost   = perf_event__process_lost,
+        .namespaces = perf_event__process_namespaces,
         .ordered_events = true,
         .ordering_requires_timestamps = true,
 };
@@ -1320,7 +1323,7 @@ static int diff__config(const char *var, const char *value,
         return 0;
 }
 
-int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_diff(int argc, const char **argv)
 {
         int ret = hists__init();
 
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index e09c4287fe87..6d210e40d611 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -46,7 +46,7 @@ static int __cmd_evlist(const char *file_name, struct perf_attr_details *details
         return 0;
 }
 
-int cmd_evlist(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_evlist(int argc, const char **argv)
 {
         struct perf_attr_details details = { .verbose = false, };
         const struct option options[] = {
diff --git a/tools/perf/builtin-ftrace.c b/tools/perf/builtin-ftrace.c
index c3e643666c72..9e0b35cd0eea 100644
--- a/tools/perf/builtin-ftrace.c
+++ b/tools/perf/builtin-ftrace.c
@@ -9,13 +9,18 @@
 #include "builtin.h"
 #include "perf.h"
 
+#include <errno.h>
 #include <unistd.h>
 #include <signal.h>
+#include <fcntl.h>
+#include <poll.h>
 
 #include "debug.h"
 #include <subcmd/parse-options.h>
+#include <api/fs/tracing_path.h>
 #include "evlist.h"
 #include "target.h"
+#include "cpumap.h"
 #include "thread_map.h"
 #include "util/config.h"
 
@@ -50,11 +55,12 @@ static void ftrace__workload_exec_failed_signal(int signo __maybe_unused,
         done = true;
 }
 
-static int write_tracing_file(const char *name, const char *val)
+static int __write_tracing_file(const char *name, const char *val, bool append)
 {
         char *file;
         int fd, ret = -1;
         ssize_t size = strlen(val);
+        int flags = O_WRONLY;
 
         file = get_tracing_file(name);
         if (!file) {
@@ -62,7 +68,12 @@ static int write_tracing_file(const char *name, const char *val)
                 return -1;
         }
 
-        fd = open(file, O_WRONLY);
+        if (append)
+                flags |= O_APPEND;
+        else
+                flags |= O_TRUNC;
+
+        fd = open(file, flags);
         if (fd < 0) {
                 pr_debug("cannot open tracing file: %s\n", name);
                 goto out;
@@ -79,6 +90,18 @@ out:
         return ret;
 }
 
+static int write_tracing_file(const char *name, const char *val)
+{
+        return __write_tracing_file(name, val, false);
+}
+
+static int append_tracing_file(const char *name, const char *val)
+{
+        return __write_tracing_file(name, val, true);
+}
+
+static int reset_tracing_cpu(void);
+
 static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
 {
         if (write_tracing_file("tracing_on", "0") < 0)
@@ -90,14 +113,78 @@ static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
         if (write_tracing_file("set_ftrace_pid", " ") < 0)
                 return -1;
 
+        if (reset_tracing_cpu() < 0)
+                return -1;
+
+        return 0;
+}
+
+static int set_tracing_pid(struct perf_ftrace *ftrace)
+{
+        int i;
+        char buf[16];
+
+        if (target__has_cpu(&ftrace->target))
+                return 0;
+
+        for (i = 0; i < thread_map__nr(ftrace->evlist->threads); i++) {
+                scnprintf(buf, sizeof(buf), "%d",
+                          ftrace->evlist->threads->map[i]);
+                if (append_tracing_file("set_ftrace_pid", buf) < 0)
+                        return -1;
+        }
         return 0;
 }
 
+static int set_tracing_cpumask(struct cpu_map *cpumap)
+{
+        char *cpumask;
+        size_t mask_size;
+        int ret;
+        int last_cpu;
+
+        last_cpu = cpu_map__cpu(cpumap, cpumap->nr - 1);
+        mask_size = (last_cpu + 3) / 4 + 1;
+        mask_size += last_cpu / 32; /* ',' is needed for every 32th cpus */
+
+        cpumask = malloc(mask_size);
+        if (cpumask == NULL) {
+                pr_debug("failed to allocate cpu mask\n");
+                return -1;
+        }
+
+        cpu_map__snprint_mask(cpumap, cpumask, mask_size);
+
+        ret = write_tracing_file("tracing_cpumask", cpumask);
+
+        free(cpumask);
+        return ret;
+}
+
+static int set_tracing_cpu(struct perf_ftrace *ftrace)
+{
+        struct cpu_map *cpumap = ftrace->evlist->cpus;
+
+        if (!target__has_cpu(&ftrace->target))
+                return 0;
+
+        return set_tracing_cpumask(cpumap);
+}
+
+static int reset_tracing_cpu(void)
+{
+        struct cpu_map *cpumap = cpu_map__new(NULL);
+        int ret;
+
+        ret = set_tracing_cpumask(cpumap);
+        cpu_map__put(cpumap);
+        return ret;
+}
+
 static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
 {
         char *trace_file;
         int trace_fd;
-        char *trace_pid;
         char buf[4096];
         struct pollfd pollfd = {
                 .events = POLLIN,
@@ -108,42 +195,43 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
                 return -1;
         }
 
-        if (argc < 1)
-                return -1;
-
         signal(SIGINT, sig_handler);
         signal(SIGUSR1, sig_handler);
         signal(SIGCHLD, sig_handler);
+        signal(SIGPIPE, sig_handler);
 
-        reset_tracing_files(ftrace);
+        if (reset_tracing_files(ftrace) < 0)
+                goto out;
 
         /* reset ftrace buffer */
         if (write_tracing_file("trace", "0") < 0)
                 goto out;
 
-        if (perf_evlist__prepare_workload(ftrace->evlist, &ftrace->target,
-                                          argv, false, ftrace__workload_exec_failed_signal) < 0)
+        if (argc && perf_evlist__prepare_workload(ftrace->evlist,
+                                &ftrace->target, argv, false,
+                                ftrace__workload_exec_failed_signal) < 0) {
                 goto out;
+        }
 
-        if (write_tracing_file("current_tracer", ftrace->tracer) < 0) {
-                pr_err("failed to set current_tracer to %s\n", ftrace->tracer);
-                goto out;
+        if (set_tracing_pid(ftrace) < 0) {
+                pr_err("failed to set ftrace pid\n");
+                goto out_reset;
         }
 
-        if (asprintf(&trace_pid, "%d", thread_map__pid(ftrace->evlist->threads, 0)) < 0) {
-                pr_err("failed to allocate pid string\n");
-                goto out;
+        if (set_tracing_cpu(ftrace) < 0) {
+                pr_err("failed to set tracing cpumask\n");
+                goto out_reset;
         }
 
-        if (write_tracing_file("set_ftrace_pid", trace_pid) < 0) {
-                pr_err("failed to set pid: %s\n", trace_pid);
-                goto out_free_pid;
+        if (write_tracing_file("current_tracer", ftrace->tracer) < 0) {
+                pr_err("failed to set current_tracer to %s\n", ftrace->tracer);
+                goto out_reset;
         }
 
         trace_file = get_tracing_file("trace_pipe");
         if (!trace_file) {
                 pr_err("failed to open trace_pipe\n");
-                goto out_free_pid;
+                goto out_reset;
         }
 
         trace_fd = open(trace_file, O_RDONLY);
@@ -152,7 +240,7 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
 
         if (trace_fd < 0) {
                 pr_err("failed to open trace_pipe\n");
-                goto out_free_pid;
+                goto out_reset;
         }
 
         fcntl(trace_fd, F_SETFL, O_NONBLOCK);
@@ -163,6 +251,8 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
                 goto out_close_fd;
         }
 
+        setup_pager();
+
         perf_evlist__start_workload(ftrace->evlist);
 
         while (!done) {
@@ -191,11 +281,9 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
 
 out_close_fd:
         close(trace_fd);
-out_free_pid:
-        free(trace_pid);
-out:
+out_reset:
         reset_tracing_files(ftrace);
-
+out:
         return done ? 0 : -1;
 }
 
@@ -219,7 +307,7 @@ static int perf_ftrace_config(const char *var, const char *value, void *cb)
         return -1;
 }
 
-int cmd_ftrace(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_ftrace(int argc, const char **argv)
 {
         int ret;
         struct perf_ftrace ftrace = {
@@ -227,15 +315,21 @@ int cmd_ftrace(int argc, const char **argv, const char *prefix __maybe_unused)
                 .target = { .uid = UINT_MAX, },
         };
         const char * const ftrace_usage[] = {
-                "perf ftrace [<options>] <command>",
+                "perf ftrace [<options>] [<command>]",
                 "perf ftrace [<options>] -- <command> [<options>]",
                 NULL
         };
         const struct option ftrace_options[] = {
         OPT_STRING('t', "tracer", &ftrace.tracer, "tracer",
                    "tracer to use: function_graph(default) or function"),
+        OPT_STRING('p', "pid", &ftrace.target.pid, "pid",
+                   "trace on existing process id"),
         OPT_INCR('v', "verbose", &verbose,
                  "be more verbose"),
+        OPT_BOOLEAN('a', "all-cpus", &ftrace.target.system_wide,
+                    "system-wide collection from all CPUs"),
+        OPT_STRING('C', "cpu", &ftrace.target.cpu_list, "cpu",
+                    "list of cpus to monitor"),
         OPT_END()
         };
 
@@ -245,9 +339,18 @@ int cmd_ftrace(int argc, const char **argv, const char *prefix __maybe_unused)
 
         argc = parse_options(argc, argv, ftrace_options, ftrace_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc)
+        if (!argc && target__none(&ftrace.target))
                 usage_with_options(ftrace_usage, ftrace_options);
 
+        ret = target__validate(&ftrace.target);
+        if (ret) {
+                char errbuf[512];
+
+                target__strerror(&ftrace.target, ret, errbuf, 512);
+                pr_err("%s\n", errbuf);
+                return -EINVAL;
+        }
+
         ftrace.evlist = perf_evlist__new();
         if (ftrace.evlist == NULL)
                 return -ENOMEM;
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index aed0d844e8c2..492f8e14ab09 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -12,16 +12,22 @@
 #include <subcmd/run-command.h>
 #include <subcmd/help.h>
 #include "util/debug.h"
+#include <linux/kernel.h>
+#include <errno.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 static struct man_viewer_list {
         struct man_viewer_list *next;
-        char name[FLEX_ARRAY];
+        char name[0];
 } *man_viewer_list;
 
 static struct man_viewer_info_list {
         struct man_viewer_info_list *next;
         const char *info;
-        char name[FLEX_ARRAY];
+        char name[0];
 } *man_viewer_info_list;
 
 enum help_format {
@@ -301,12 +307,6 @@ void list_common_cmds_help(void)
         }
 }
 
-static int is_perf_command(const char *s)
-{
-        return is_in_cmdlist(&main_cmds, s) ||
-                is_in_cmdlist(&other_cmds, s);
-}
-
 static const char *cmd_to_page(const char *perf_cmd)
 {
         char *s;
@@ -418,7 +418,7 @@ static int show_html_page(const char *perf_cmd)
         return 0;
 }
 
-int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_help(int argc, const char **argv)
 {
         bool show_all = false;
         enum help_format help_format = HELP_FORMAT_MAN;
@@ -446,7 +446,6 @@ int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
                 "perf help [--all] [--man|--web|--info] [command]",
                 NULL
         };
-        const char *alias;
         int rc;
 
         load_command_list("perf-", &main_cmds, &other_cmds);
@@ -472,12 +471,6 @@ int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
                 return 0;
         }
 
-        alias = alias_lookup(argv[0]);
-        if (alias && !is_perf_command(argv[0])) {
-                printf("`perf %s' is aliased to `%s'\n", argv[0], alias);
-                return 0;
-        }
-
         switch (help_format) {
         case HELP_FORMAT_MAN:
                 rc = show_man_page(argv[0]);
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index b9bc7e39833a..ea8db38eedd1 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -18,10 +18,13 @@
 #include "util/data.h"
 #include "util/auxtrace.h"
 #include "util/jit.h"
+#include "util/thread.h"
 
 #include <subcmd/parse-options.h>
 
 #include <linux/list.h>
+#include <errno.h>
+#include <signal.h>
 
 struct perf_inject {
         struct perf_tool        tool;
@@ -333,6 +336,18 @@ static int perf_event__repipe_comm(struct perf_tool *tool,
         return err;
 }
 
+static int perf_event__repipe_namespaces(struct perf_tool *tool,
+                                         union perf_event *event,
+                                         struct perf_sample *sample,
+                                         struct machine *machine)
+{
+        int err = perf_event__process_namespaces(tool, event, sample, machine);
+
+        perf_event__repipe(tool, event, sample, machine);
+
+        return err;
+}
+
 static int perf_event__repipe_exit(struct perf_tool *tool,
                                    union perf_event *event,
                                    struct perf_sample *sample,
@@ -660,6 +675,7 @@ static int __cmd_inject(struct perf_inject *inject)
                 session->itrace_synth_opts = &inject->itrace_synth_opts;
                 inject->itrace_synth_opts.inject = true;
                 inject->tool.comm           = perf_event__repipe_comm;
+                inject->tool.namespaces     = perf_event__repipe_namespaces;
                 inject->tool.exit           = perf_event__repipe_exit;
                 inject->tool.id_index       = perf_event__repipe_id_index;
                 inject->tool.auxtrace_info  = perf_event__process_auxtrace_info;
@@ -681,6 +697,8 @@ static int __cmd_inject(struct perf_inject *inject)
                 lseek(fd, output_data_offset, SEEK_SET);
 
         ret = perf_session__process_events(session);
+        if (ret)
+                return ret;
 
         if (!file_out->is_pipe) {
                 if (inject->build_ids)
@@ -725,7 +743,7 @@ static int __cmd_inject(struct perf_inject *inject)
         return ret;
 }
 
-int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_inject(int argc, const char **argv)
 {
         struct perf_inject inject = {
                 .tool = {
diff --git a/tools/perf/builtin-kallsyms.c b/tools/perf/builtin-kallsyms.c
index 224bfc454b4a..bcfb363112d3 100644
--- a/tools/perf/builtin-kallsyms.c
+++ b/tools/perf/builtin-kallsyms.c
@@ -7,6 +7,7 @@
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
+#include <inttypes.h>
 #include "builtin.h"
 #include <linux/compiler.h>
 #include <subcmd/parse-options.h>
@@ -43,7 +44,7 @@ static int __cmd_kallsyms(int argc, const char **argv)
         return 0;
 }
 
-int cmd_kallsyms(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_kallsyms(int argc, const char **argv)
 {
         const struct option options[] = {
         OPT_INCR('v', "verbose", &verbose, "be more verbose (show counter open errors, etc)"),
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 6da8d083e4e5..9409c9464667 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -20,11 +20,16 @@
 
 #include "util/debug.h"
 
+#include <linux/kernel.h>
 #include <linux/rbtree.h>
 #include <linux/string.h>
+#include <errno.h>
+#include <inttypes.h>
 #include <locale.h>
 #include <regex.h>
 
+#include "sane_ctype.h"
+
 static int      kmem_slab;
 static int      kmem_page;
 
@@ -964,6 +969,7 @@ static struct perf_tool perf_kmem = {
         .comm            = perf_event__process_comm,
         .mmap            = perf_event__process_mmap,
         .mmap2           = perf_event__process_mmap2,
+        .namespaces      = perf_event__process_namespaces,
         .ordered_events  = true,
 };
 
@@ -1865,7 +1871,7 @@ static int __cmd_record(int argc, const char **argv)
         for (j = 1; j < (unsigned int)argc; j++, i++)
                 rec_argv[i] = argv[j];
 
-        return cmd_record(i, rec_argv, NULL);
+        return cmd_record(i, rec_argv);
 }
 
 static int kmem_config(const char *var, const char *value, void *cb __maybe_unused)
@@ -1884,7 +1890,7 @@ static int kmem_config(const char *var, const char *value, void *cb __maybe_unus
         return 0;
 }
 
-int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_kmem(int argc, const char **argv)
 {
         const char * const default_slab_sort = "frag,hit,bytes";
         const char * const default_page_sort = "bytes,hit";
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 08fa88f62a24..f309c3773522 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -3,6 +3,7 @@
 
 #include "util/evsel.h"
 #include "util/evlist.h"
+#include "util/term.h"
 #include "util/util.h"
 #include "util/cache.h"
 #include "util/symbol.h"
@@ -23,13 +24,33 @@
 #ifdef HAVE_TIMERFD_SUPPORT
 #include <sys/timerfd.h>
 #endif
+#include <sys/time.h>
 
+#include <linux/kernel.h>
 #include <linux/time64.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <poll.h>
 #include <termios.h>
 #include <semaphore.h>
+#include <signal.h>
 #include <pthread.h>
 #include <math.h>
 
+static const char *get_filename_for_perf_kvm(void)
+{
+        const char *filename;
+
+        if (perf_host && !perf_guest)
+                filename = strdup("perf.data.host");
+        else if (!perf_host && perf_guest)
+                filename = strdup("perf.data.guest");
+        else
+                filename = strdup("perf.data.kvm");
+
+        return filename;
+}
+
 #ifdef HAVE_KVM_STAT_SUPPORT
 #include "util/kvm-stat.h"
 
@@ -1044,6 +1065,7 @@ static int read_events(struct perf_kvm_stat *kvm)
         struct perf_tool eops = {
                 .sample                 = process_sample_event,
                 .comm                   = perf_event__process_comm,
+                .namespaces             = perf_event__process_namespaces,
                 .ordered_events         = true,
         };
         struct perf_data_file file = {
@@ -1208,7 +1230,7 @@ kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
         set_option_flag(record_options, 0, "transaction", PARSE_OPT_DISABLED);
 
         record_usage = kvm_stat_record_usage;
-        return cmd_record(i, rec_argv, NULL);
+        return cmd_record(i, rec_argv);
 }
 
 static int
@@ -1348,6 +1370,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
         kvm->tool.exit   = perf_event__process_exit;
         kvm->tool.fork   = perf_event__process_fork;
         kvm->tool.lost   = process_lost_event;
+        kvm->tool.namespaces  = perf_event__process_namespaces;
         kvm->tool.ordered_events = true;
         perf_tool__fill_defaults(&kvm->tool);
 
@@ -1475,7 +1498,7 @@ static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
 #endif
 
 perf_stat:
-        return cmd_stat(argc, argv, NULL);
+        return cmd_stat(argc, argv);
 }
 #endif /* HAVE_KVM_STAT_SUPPORT */
 
@@ -1494,7 +1517,7 @@ static int __cmd_record(const char *file_name, int argc, const char **argv)
 
         BUG_ON(i != rec_argc);
 
-        return cmd_record(i, rec_argv, NULL);
+        return cmd_record(i, rec_argv);
 }
 
 static int __cmd_report(const char *file_name, int argc, const char **argv)
@@ -1512,7 +1535,7 @@ static int __cmd_report(const char *file_name, int argc, const char **argv)
 
         BUG_ON(i != rec_argc);
 
-        return cmd_report(i, rec_argv, NULL);
+        return cmd_report(i, rec_argv);
 }
 
 static int
@@ -1531,10 +1554,10 @@ __cmd_buildid_list(const char *file_name, int argc, const char **argv)
 
         BUG_ON(i != rec_argc);
 
-        return cmd_buildid_list(i, rec_argv, NULL);
+        return cmd_buildid_list(i, rec_argv);
 }
 
-int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_kvm(int argc, const char **argv)
 {
         const char *file_name = NULL;
         const struct option kvm_options[] = {
@@ -1589,9 +1612,9 @@ int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
         else if (!strncmp(argv[0], "rep", 3))
                 return __cmd_report(file_name, argc, argv);
         else if (!strncmp(argv[0], "diff", 4))
-                return cmd_diff(argc, argv, NULL);
+                return cmd_diff(argc, argv);
         else if (!strncmp(argv[0], "top", 3))
-                return cmd_top(argc, argv, NULL);
+                return cmd_top(argc, argv);
         else if (!strncmp(argv[0], "buildid-list", 12))
                 return __cmd_buildid_list(file_name, argc, argv);
 #ifdef HAVE_KVM_STAT_SUPPORT
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
index 3b9d98b5feef..4bf2cb4d25aa 100644
--- a/tools/perf/builtin-list.c
+++ b/tools/perf/builtin-list.c
@@ -18,8 +18,9 @@
 #include <subcmd/parse-options.h>
 
 static bool desc_flag = true;
+static bool details_flag;
 
-int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_list(int argc, const char **argv)
 {
         int i;
         bool raw_dump = false;
@@ -30,6 +31,8 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                             "Print extra event descriptions. --no-desc to not print."),
                 OPT_BOOLEAN('v', "long-desc", &long_desc_flag,
                             "Print longer event descriptions."),
+                OPT_BOOLEAN(0, "details", &details_flag,
+                            "Print information on the perf event names and expressions used internally by events."),
                 OPT_INCR(0, "debug", &verbose,
                              "Enable debugging output"),
                 OPT_END()
@@ -50,7 +53,8 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                 printf("\nList of pre-defined events (to be used in -e):\n\n");
 
         if (argc == 0) {
-                print_events(NULL, raw_dump, !desc_flag, long_desc_flag);
+                print_events(NULL, raw_dump, !desc_flag, long_desc_flag,
+                                details_flag);
                 return 0;
         }
 
@@ -72,7 +76,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                         print_hwcache_events(NULL, raw_dump);
                 else if (strcmp(argv[i], "pmu") == 0)
                         print_pmu_events(NULL, raw_dump, !desc_flag,
-                                                long_desc_flag);
+                                                long_desc_flag, details_flag);
                 else if (strcmp(argv[i], "sdt") == 0)
                         print_sdt_events(NULL, NULL, raw_dump);
                 else if ((sep = strchr(argv[i], ':')) != NULL) {
@@ -80,7 +84,8 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 
                         if (sep == NULL) {
                                 print_events(argv[i], raw_dump, !desc_flag,
-                                                        long_desc_flag);
+                                                        long_desc_flag,
+                                                        details_flag);
                                 continue;
                         }
                         sep_idx = sep - argv[i];
@@ -103,7 +108,8 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                                             event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
                         print_hwcache_events(s, raw_dump);
                         print_pmu_events(s, raw_dump, !desc_flag,
-                                                long_desc_flag);
+                                                long_desc_flag,
+                                                details_flag);
                         print_tracepoint_events(NULL, s, raw_dump);
                         print_sdt_events(NULL, s, raw_dump);
                         free(s);
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index ce3bfb48b26f..ff98652484a7 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 #include "builtin.h"
 #include "perf.h"
 
@@ -26,6 +28,7 @@
 
 #include <linux/list.h>
 #include <linux/hash.h>
+#include <linux/kernel.h>
 
 static struct perf_session *session;
 
@@ -858,6 +861,7 @@ static int __cmd_report(bool display_info)
         struct perf_tool eops = {
                 .sample          = process_sample_event,
                 .comm            = perf_event__process_comm,
+                .namespaces      = perf_event__process_namespaces,
                 .ordered_events  = true,
         };
         struct perf_data_file file = {
@@ -940,34 +944,36 @@ static int __cmd_record(int argc, const char **argv)
 
         BUG_ON(i != rec_argc);
 
-        ret = cmd_record(i, rec_argv, NULL);
+        ret = cmd_record(i, rec_argv);
         free(rec_argv);
         return ret;
 }
 
-int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_lock(int argc, const char **argv)
 {
-        const struct option info_options[] = {
-        OPT_BOOLEAN('t', "threads", &info_threads,
-                    "dump thread list in perf.data"),
-        OPT_BOOLEAN('m', "map", &info_map,
-                    "map of lock instances (address:name table)"),
-        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
-        OPT_END()
-        };
         const struct option lock_options[] = {
         OPT_STRING('i', "input", &input_name, "file", "input file name"),
         OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
         OPT_END()
         };
+
+        const struct option info_options[] = {
+        OPT_BOOLEAN('t', "threads", &info_threads,
+                    "dump thread list in perf.data"),
+        OPT_BOOLEAN('m', "map", &info_map,
+                    "map of lock instances (address:name table)"),
+        OPT_PARENT(lock_options)
+        };
+
         const struct option report_options[] = {
         OPT_STRING('k', "key", &sort_key, "acquired",
                     "key for sorting (acquired / contended / avg_wait / wait_total / wait_max / wait_min)"),
-        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
         /* TODO: type */
-        OPT_END()
+        OPT_PARENT(lock_options)
         };
+
         const char * const info_usage[] = {
                 "perf lock info [<options>]",
                 NULL
@@ -1006,7 +1012,7 @@ int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
                 rc = __cmd_report(false);
         } else if (!strcmp(argv[0], "script")) {
                 /* Aliased to 'perf script' */
-                return cmd_script(argc, argv, prefix);
+                return cmd_script(argc, argv);
         } else if (!strcmp(argv[0], "info")) {
                 if (argc) {
                         argc = parse_options(argc, argv,
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 6114e07ca613..e001c0290793 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -1,3 +1,7 @@
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include "builtin.h"
 #include "perf.h"
 
@@ -8,6 +12,7 @@
 #include "util/data.h"
 #include "util/mem-events.h"
 #include "util/debug.h"
+#include "util/symbol.h"
 
 #define MEM_OPERATION_LOAD      0x1
 #define MEM_OPERATION_STORE     0x2
@@ -129,7 +134,7 @@ static int __cmd_record(int argc, const char **argv, struct perf_mem *mem)
                 pr_debug("\n");
         }
 
-        ret = cmd_record(i, rec_argv, NULL);
+        ret = cmd_record(i, rec_argv);
         free(rec_argv);
         return ret;
 }
@@ -256,7 +261,7 @@ static int report_events(int argc, const char **argv, struct perf_mem *mem)
         for (j = 1; j < argc; j++, i++)
                 rep_argv[i] = argv[j];
 
-        ret = cmd_report(i, rep_argv, NULL);
+        ret = cmd_report(i, rep_argv);
         free(rep_argv);
         return ret;
 }
@@ -330,7 +335,7 @@ error:
         return ret;
 }
 
-int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_mem(int argc, const char **argv)
 {
         struct stat st;
         struct perf_mem mem = {
@@ -342,6 +347,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
                         .lost           = perf_event__process_lost,
                         .fork           = perf_event__process_fork,
                         .build_id       = perf_event__process_build_id,
+                        .namespaces     = perf_event__process_namespaces,
                         .ordered_events = true,
                 },
                 .input_name              = "perf.data",
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 1fcebc31a508..d7360c2bda13 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -442,9 +442,9 @@ static int perf_del_probe_events(struct strfilter *filter)
         }
 
         if (ret == -ENOENT && ret2 == -ENOENT)
-                pr_debug("\"%s\" does not hit any event.\n", str);
-                /* Note that this is silently ignored */
-        ret = 0;
+                pr_warning("\"%s\" does not hit any event.\n", str);
+        else
+                ret = 0;
 
 error:
         if (kfd >= 0)
@@ -468,7 +468,7 @@ out:
 
 
 static int
-__cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
+__cmd_probe(int argc, const char **argv)
 {
         const char * const probe_usage[] = {
                 "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
@@ -687,13 +687,13 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
         return 0;
 }
 
-int cmd_probe(int argc, const char **argv, const char *prefix)
+int cmd_probe(int argc, const char **argv)
 {
         int ret;
 
         ret = init_params();
         if (!ret) {
-                ret = __cmd_probe(argc, argv, prefix);
+                ret = __cmd_probe(argc, argv);
                 cleanup_params();
         }
 
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index bc84a375295d..ee7d0a82ccd0 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -38,11 +38,18 @@
 #include "util/bpf-loader.h"
 #include "util/trigger.h"
 #include "util/perf-hooks.h"
+#include "util/time-utils.h"
+#include "util/units.h"
 #include "asm/bug.h"
 
+#include <errno.h>
+#include <inttypes.h>
+#include <poll.h>
 #include <unistd.h>
 #include <sched.h>
+#include <signal.h>
 #include <sys/mman.h>
+#include <sys/wait.h>
 #include <asm/bug.h>
 #include <linux/time64.h>
 
@@ -876,6 +883,9 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         signal(SIGTERM, sig_handler);
         signal(SIGSEGV, sigsegv_handler);
 
+        if (rec->opts.record_namespaces)
+                tool->namespace_events = true;
+
         if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) {
                 signal(SIGUSR2, snapshot_sig_handler);
                 if (rec->opts.auxtrace_snapshot_mode)
@@ -983,6 +993,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
          */
         if (forks) {
                 union perf_event *event;
+                pid_t tgid;
 
                 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
                 if (event == NULL) {
@@ -996,10 +1007,30 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                  * cannot see a correct process name for those events.
                  * Synthesize COMM event to prevent it.
                  */
-                perf_event__synthesize_comm(tool, event,
-                                            rec->evlist->workload.pid,
-                                            process_synthesized_event,
-                                            machine);
+                tgid = perf_event__synthesize_comm(tool, event,
+                                                   rec->evlist->workload.pid,
+                                                   process_synthesized_event,
+                                                   machine);
+                free(event);
+
+                if (tgid == -1)
+                        goto out_child;
+
+                event = malloc(sizeof(event->namespaces) +
+                               (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
+                               machine->id_hdr_size);
+                if (event == NULL) {
+                        err = -ENOMEM;
+                        goto out_child;
+                }
+
+                /*
+                 * Synthesize NAMESPACES event for the command specified.
+                 */
+                perf_event__synthesize_namespaces(tool, event,
+                                                  rec->evlist->workload.pid,
+                                                  tgid, process_synthesized_event,
+                                                  machine);
                 free(event);
 
                 perf_evlist__start_workload(rec->evlist);
@@ -1497,6 +1528,7 @@ static struct record record = {
                 .fork           = perf_event__process_fork,
                 .exit           = perf_event__process_exit,
                 .comm           = perf_event__process_comm,
+                .namespaces     = perf_event__process_namespaces,
                 .mmap           = perf_event__process_mmap,
                 .mmap2          = perf_event__process_mmap2,
                 .ordered_events = true,
@@ -1611,6 +1643,8 @@ static struct option __record_options[] = {
                           "opts", "AUX area tracing Snapshot Mode", ""),
         OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
                         "per thread proc mmap processing timeout in ms"),
+        OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
+                    "Record namespaces events"),
         OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
                     "Record context switch events"),
         OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
@@ -1640,7 +1674,7 @@ static struct option __record_options[] = {
 
 struct option *record_options = __record_options;
 
-int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_record(int argc, const char **argv)
 {
         int err;
         struct record *rec = &record;
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 0a88670e56f3..22478ff2b706 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -16,7 +16,6 @@
 #include <linux/rbtree.h>
 #include "util/symbol.h"
 #include "util/callchain.h"
-#include "util/strlist.h"
 #include "util/values.h"
 
 #include "perf.h"
@@ -38,10 +37,18 @@
 #include "arch/common.h"
 #include "util/time-utils.h"
 #include "util/auxtrace.h"
+#include "util/units.h"
 
 #include <dlfcn.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <regex.h>
+#include <signal.h>
 #include <linux/bitmap.h>
 #include <linux/stringify.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 struct report {
         struct perf_tool        tool;
@@ -394,8 +401,7 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
                 fprintf(stdout, "\n\n");
         }
 
-        if (sort_order == NULL &&
-            parent_pattern == default_parent_pattern)
+        if (!quiet)
                 fprintf(stdout, "#\n# (%s)\n#\n", help);
 
         if (rep->show_threads) {
@@ -682,7 +688,7 @@ const char report_callchain_help[] = "Display call graph (stack chain/backtrace)
                                      CALLCHAIN_REPORT_HELP
                                      "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT;
 
-int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_report(int argc, const char **argv)
 {
         struct perf_session *session;
         struct itrace_synth_opts itrace_synth_opts = { .set = 0, };
@@ -701,6 +707,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                         .mmap            = perf_event__process_mmap,
                         .mmap2           = perf_event__process_mmap2,
                         .comm            = perf_event__process_comm,
+                        .namespaces      = perf_event__process_namespaces,
                         .exit            = perf_event__process_exit,
                         .fork            = perf_event__process_fork,
                         .lost            = perf_event__process_lost,
@@ -845,6 +852,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                              stdio__config_color, "always"),
         OPT_STRING(0, "time", &report.time_str, "str",
                    "Time span of interest (start,stop)"),
+        OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
+                    "Show inline function"),
         OPT_END()
         };
         struct perf_data_file file = {
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index b94cf0de715a..39996c53995a 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -22,16 +22,21 @@
 
 #include "util/debug.h"
 
+#include <linux/kernel.h>
 #include <linux/log2.h>
 #include <sys/prctl.h>
 #include <sys/resource.h>
+#include <inttypes.h>
 
+#include <errno.h>
 #include <semaphore.h>
 #include <pthread.h>
 #include <math.h>
 #include <api/fs/fs.h>
 #include <linux/time64.h>
 
+#include "sane_ctype.h"
+
 #define PR_SET_NAME             15               /* Set process name */
 #define MAX_CPUS                4096
 #define COMM_LEN                20
@@ -221,6 +226,7 @@ struct perf_sched {
         unsigned int    max_stack;
         bool            show_cpu_visual;
         bool            show_wakeups;
+        bool            show_next;
         bool            show_migrations;
         bool            show_state;
         u64             skipped_samples;
@@ -1897,14 +1903,18 @@ static char task_state_char(struct thread *thread, int state)
 }
 
 static void timehist_print_sample(struct perf_sched *sched,
+                                  struct perf_evsel *evsel,
                                   struct perf_sample *sample,
                                   struct addr_location *al,
                                   struct thread *thread,
                                   u64 t, int state)
 {
         struct thread_runtime *tr = thread__priv(thread);
+        const char *next_comm = perf_evsel__strval(evsel, sample, "next_comm");
+        const u32 next_pid = perf_evsel__intval(evsel, sample, "next_pid");
         u32 max_cpus = sched->max_cpu + 1;
         char tstr[64];
+        char nstr[30];
         u64 wait_time;
 
         timestamp__scnprintf_usec(t, tstr, sizeof(tstr));
@@ -1937,7 +1947,12 @@ static void timehist_print_sample(struct perf_sched *sched,
         if (sched->show_state)
                 printf(" %5c ", task_state_char(thread, state));
 
-        if (sched->show_wakeups)
+        if (sched->show_next) {
+                snprintf(nstr, sizeof(nstr), "next: %s[%d]", next_comm, next_pid);
+                printf(" %-*s", comm_width, nstr);
+        }
+
+        if (sched->show_wakeups && !sched->show_next)
                 printf("  %-*s", comm_width, "");
 
         if (thread->tid == 0)
@@ -2531,7 +2546,7 @@ static int timehist_sched_change_event(struct perf_tool *tool,
         }
 
         if (!sched->summary_only)
-                timehist_print_sample(sched, sample, &al, thread, t, state);
+                timehist_print_sample(sched, evsel, sample, &al, thread, t, state);
 
 out:
         if (sched->hist_time.start == 0 && t >= ptime->start)
@@ -3262,16 +3277,17 @@ static int __cmd_record(int argc, const char **argv)
 
         BUG_ON(i != rec_argc);
 
-        return cmd_record(i, rec_argv, NULL);
+        return cmd_record(i, rec_argv);
 }
 
-int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_sched(int argc, const char **argv)
 {
         const char default_sort_order[] = "avg, max, switch, runtime";
         struct perf_sched sched = {
                 .tool = {
                         .sample          = perf_sched__process_tracepoint_sample,
                         .comm            = perf_event__process_comm,
+                        .namespaces      = perf_event__process_namespaces,
                         .lost            = perf_event__process_lost,
                         .fork            = perf_sched__process_fork_event,
                         .ordered_events = true,
@@ -3340,6 +3356,7 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_BOOLEAN('S', "with-summary", &sched.summary,
                     "Show all syscalls and summary with statistics"),
         OPT_BOOLEAN('w', "wakeups", &sched.show_wakeups, "Show wakeup events"),
+        OPT_BOOLEAN('n', "next", &sched.show_next, "Show next task"),
         OPT_BOOLEAN('M', "migrations", &sched.show_migrations, "Show migration events"),
         OPT_BOOLEAN('V', "cpu-visual", &sched.show_cpu_visual, "Add CPU visual"),
         OPT_BOOLEAN('I', "idle-hist", &sched.idle_hist, "Show idle events only"),
@@ -3400,7 +3417,7 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
          * Aliased to 'perf script' for now:
          */
         if (!strcmp(argv[0], "script"))
-                return cmd_script(argc, argv, prefix);
+                return cmd_script(argc, argv);
 
         if (!strncmp(argv[0], "rec", 3)) {
                 return __cmd_record(argc, argv);
@@ -3437,10 +3454,14 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
                         if (argc)
                                 usage_with_options(timehist_usage, timehist_options);
                 }
-                if (sched.show_wakeups && sched.summary_only) {
-                        pr_err(" Error: -s and -w are mutually exclusive.\n");
+                if ((sched.show_wakeups || sched.show_next) &&
+                    sched.summary_only) {
+                        pr_err(" Error: -s and -[n|w] are mutually exclusive.\n");
                         parse_options_usage(timehist_usage, timehist_options, "s", true);
-                        parse_options_usage(NULL, timehist_options, "w", true);
+                        if (sched.show_wakeups)
+                                parse_options_usage(NULL, timehist_options, "w", true);
+                        if (sched.show_next)
+                                parse_options_usage(NULL, timehist_options, "n", true);
                         return -EINVAL;
                 }
 
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index c0783b4f7b6c..d05aec491cff 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -21,13 +21,27 @@
 #include "util/cpumap.h"
 #include "util/thread_map.h"
 #include "util/stat.h"
+#include "util/string2.h"
 #include "util/thread-stack.h"
 #include "util/time-utils.h"
+#include "print_binary.h"
 #include <linux/bitmap.h>
+#include <linux/kernel.h>
 #include <linux/stringify.h>
 #include <linux/time64.h>
 #include "asm/bug.h"
 #include "util/mem-events.h"
+#include "util/dump-insn.h"
+#include <dirent.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "sane_ctype.h"
 
 static char const               *script_name;
 static char const               *generate_script_lang;
@@ -42,6 +56,7 @@ static bool			nanosecs;
 static const char               *cpu_list;
 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 static struct perf_stat_config  stat_config;
+static int                      max_blocks;
 
 unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH;
 
@@ -69,6 +84,7 @@ enum perf_output_field {
         PERF_OUTPUT_CALLINDENT      = 1U << 20,
         PERF_OUTPUT_INSN            = 1U << 21,
         PERF_OUTPUT_INSNLEN         = 1U << 22,
+        PERF_OUTPUT_BRSTACKINSN     = 1U << 23,
 };
 
 struct output_option {
@@ -98,6 +114,7 @@ struct output_option {
         {.str = "callindent", .field = PERF_OUTPUT_CALLINDENT},
         {.str = "insn", .field = PERF_OUTPUT_INSN},
         {.str = "insnlen", .field = PERF_OUTPUT_INSNLEN},
+        {.str = "brstackinsn", .field = PERF_OUTPUT_BRSTACKINSN},
 };
 
 /* default set to maintain compatibility with current format */
@@ -292,7 +309,13 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                        "selected. Hence, no address to lookup the source line number.\n");
                 return -EINVAL;
         }
-
+        if (PRINT_FIELD(BRSTACKINSN) &&
+            !(perf_evlist__combined_branch_type(session->evlist) &
+              PERF_SAMPLE_BRANCH_ANY)) {
+                pr_err("Display of branch stack assembler requested, but non all-branch filter set\n"
+                       "Hint: run 'perf record -b ...'\n");
+                return -EINVAL;
+        }
         if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
                 perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID",
                                         PERF_OUTPUT_TID|PERF_OUTPUT_PID))
@@ -546,6 +569,233 @@ static void print_sample_brstacksym(struct perf_sample *sample,
         }
 }
 
+#define MAXBB 16384UL
+
+static int grab_bb(u8 *buffer, u64 start, u64 end,
+                    struct machine *machine, struct thread *thread,
+                    bool *is64bit, u8 *cpumode, bool last)
+{
+        long offset, len;
+        struct addr_location al;
+        bool kernel;
+
+        if (!start || !end)
+                return 0;
+
+        kernel = machine__kernel_ip(machine, start);
+        if (kernel)
+                *cpumode = PERF_RECORD_MISC_KERNEL;
+        else
+                *cpumode = PERF_RECORD_MISC_USER;
+
+        /*
+         * Block overlaps between kernel and user.
+         * This can happen due to ring filtering
+         * On Intel CPUs the entry into the kernel is filtered,
+         * but the exit is not. Let the caller patch it up.
+         */
+        if (kernel != machine__kernel_ip(machine, end)) {
+                printf("\tblock %" PRIx64 "-%" PRIx64 " transfers between kernel and user\n",
+                                start, end);
+                return -ENXIO;
+        }
+
+        memset(&al, 0, sizeof(al));
+        if (end - start > MAXBB - MAXINSN) {
+                if (last)
+                        printf("\tbrstack does not reach to final jump (%" PRIx64 "-%" PRIx64 ")\n", start, end);
+                else
+                        printf("\tblock %" PRIx64 "-%" PRIx64 " (%" PRIu64 ") too long to dump\n", start, end, end - start);
+                return 0;
+        }
+
+        thread__find_addr_map(thread, *cpumode, MAP__FUNCTION, start, &al);
+        if (!al.map || !al.map->dso) {
+                printf("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
+                return 0;
+        }
+        if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR) {
+                printf("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
+                return 0;
+        }
+
+        /* Load maps to ensure dso->is_64_bit has been updated */
+        map__load(al.map);
+
+        offset = al.map->map_ip(al.map, start);
+        len = dso__data_read_offset(al.map->dso, machine, offset, (u8 *)buffer,
+                                    end - start + MAXINSN);
+
+        *is64bit = al.map->dso->is_64_bit;
+        if (len <= 0)
+                printf("\tcannot fetch code for block at %" PRIx64 "-%" PRIx64 "\n",
+                        start, end);
+        return len;
+}
+
+static void print_jump(uint64_t ip, struct branch_entry *en,
+                       struct perf_insn *x, u8 *inbuf, int len,
+                       int insn)
+{
+        printf("\t%016" PRIx64 "\t%-30s\t#%s%s%s%s",
+               ip,
+               dump_insn(x, ip, inbuf, len, NULL),
+               en->flags.predicted ? " PRED" : "",
+               en->flags.mispred ? " MISPRED" : "",
+               en->flags.in_tx ? " INTX" : "",
+               en->flags.abort ? " ABORT" : "");
+        if (en->flags.cycles) {
+                printf(" %d cycles", en->flags.cycles);
+                if (insn)
+                        printf(" %.2f IPC", (float)insn / en->flags.cycles);
+        }
+        putchar('\n');
+}
+
+static void print_ip_sym(struct thread *thread, u8 cpumode, int cpu,
+                         uint64_t addr, struct symbol **lastsym,
+                         struct perf_event_attr *attr)
+{
+        struct addr_location al;
+        int off;
+
+        memset(&al, 0, sizeof(al));
+
+        thread__find_addr_map(thread, cpumode, MAP__FUNCTION, addr, &al);
+        if (!al.map)
+                thread__find_addr_map(thread, cpumode, MAP__VARIABLE,
+                                      addr, &al);
+        if ((*lastsym) && al.addr >= (*lastsym)->start && al.addr < (*lastsym)->end)
+                return;
+
+        al.cpu = cpu;
+        al.sym = NULL;
+        if (al.map)
+                al.sym = map__find_symbol(al.map, al.addr);
+
+        if (!al.sym)
+                return;
+
+        if (al.addr < al.sym->end)
+                off = al.addr - al.sym->start;
+        else
+                off = al.addr - al.map->start - al.sym->start;
+        printf("\t%s", al.sym->name);
+        if (off)
+                printf("%+d", off);
+        putchar(':');
+        if (PRINT_FIELD(SRCLINE))
+                map__fprintf_srcline(al.map, al.addr, "\t", stdout);
+        putchar('\n');
+        *lastsym = al.sym;
+}
+
+static void print_sample_brstackinsn(struct perf_sample *sample,
+                                     struct thread *thread,
+                                     struct perf_event_attr *attr,
+                                     struct machine *machine)
+{
+        struct branch_stack *br = sample->branch_stack;
+        u64 start, end;
+        int i, insn, len, nr, ilen;
+        struct perf_insn x;
+        u8 buffer[MAXBB];
+        unsigned off;
+        struct symbol *lastsym = NULL;
+
+        if (!(br && br->nr))
+                return;
+        nr = br->nr;
+        if (max_blocks && nr > max_blocks + 1)
+                nr = max_blocks + 1;
+
+        x.thread = thread;
+        x.cpu = sample->cpu;
+
+        putchar('\n');
+
+        /* Handle first from jump, of which we don't know the entry. */
+        len = grab_bb(buffer, br->entries[nr-1].from,
+                        br->entries[nr-1].from,
+                        machine, thread, &x.is64bit, &x.cpumode, false);
+        if (len > 0) {
+                print_ip_sym(thread, x.cpumode, x.cpu,
+                             br->entries[nr - 1].from, &lastsym, attr);
+                print_jump(br->entries[nr - 1].from, &br->entries[nr - 1],
+                            &x, buffer, len, 0);
+        }
+
+        /* Print all blocks */
+        for (i = nr - 2; i >= 0; i--) {
+                if (br->entries[i].from || br->entries[i].to)
+                        pr_debug("%d: %" PRIx64 "-%" PRIx64 "\n", i,
+                                 br->entries[i].from,
+                                 br->entries[i].to);
+                start = br->entries[i + 1].to;
+                end   = br->entries[i].from;
+
+                len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
+                /* Patch up missing kernel transfers due to ring filters */
+                if (len == -ENXIO && i > 0) {
+                        end = br->entries[--i].from;
+                        pr_debug("\tpatching up to %" PRIx64 "-%" PRIx64 "\n", start, end);
+                        len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
+                }
+                if (len <= 0)
+                        continue;
+
+                insn = 0;
+                for (off = 0;; off += ilen) {
+                        uint64_t ip = start + off;
+
+                        print_ip_sym(thread, x.cpumode, x.cpu, ip, &lastsym, attr);
+                        if (ip == end) {
+                                print_jump(ip, &br->entries[i], &x, buffer + off, len - off, insn);
+                                break;
+                        } else {
+                                printf("\t%016" PRIx64 "\t%s\n", ip,
+                                        dump_insn(&x, ip, buffer + off, len - off, &ilen));
+                                if (ilen == 0)
+                                        break;
+                                insn++;
+                        }
+                }
+        }
+
+        /*
+         * Hit the branch? In this case we are already done, and the target
+         * has not been executed yet.
+         */
+        if (br->entries[0].from == sample->ip)
+                return;
+        if (br->entries[0].flags.abort)
+                return;
+
+        /*
+         * Print final block upto sample
+         */
+        start = br->entries[0].to;
+        end = sample->ip;
+        len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, true);
+        print_ip_sym(thread, x.cpumode, x.cpu, start, &lastsym, attr);
+        if (len <= 0) {
+                /* Print at least last IP if basic block did not work */
+                len = grab_bb(buffer, sample->ip, sample->ip,
+                              machine, thread, &x.is64bit, &x.cpumode, false);
+                if (len <= 0)
+                        return;
+
+                printf("\t%016" PRIx64 "\t%s\n", sample->ip,
+                        dump_insn(&x, sample->ip, buffer, len, NULL));
+                return;
+        }
+        for (off = 0; off <= end - start; off += ilen) {
+                printf("\t%016" PRIx64 "\t%s\n", start + off,
+                        dump_insn(&x, start + off, buffer + off, len - off, &ilen));
+                if (ilen == 0)
+                        break;
+        }
+}
 
 static void print_sample_addr(struct perf_sample *sample,
                           struct thread *thread,
@@ -632,7 +882,9 @@ static void print_sample_callindent(struct perf_sample *sample,
 }
 
 static void print_insn(struct perf_sample *sample,
-                       struct perf_event_attr *attr)
+                       struct perf_event_attr *attr,
+                       struct thread *thread,
+                       struct machine *machine)
 {
         if (PRINT_FIELD(INSNLEN))
                 printf(" ilen: %d", sample->insn_len);
@@ -643,12 +895,15 @@ static void print_insn(struct perf_sample *sample,
                 for (i = 0; i < sample->insn_len; i++)
                         printf(" %02x", (unsigned char)sample->insn[i]);
         }
+        if (PRINT_FIELD(BRSTACKINSN))
+                print_sample_brstackinsn(sample, thread, attr, machine);
 }
 
 static void print_sample_bts(struct perf_sample *sample,
                              struct perf_evsel *evsel,
                              struct thread *thread,
-                             struct addr_location *al)
+                             struct addr_location *al,
+                             struct machine *machine)
 {
         struct perf_event_attr *attr = &evsel->attr;
         bool print_srcline_last = false;
@@ -689,7 +944,7 @@ static void print_sample_bts(struct perf_sample *sample,
         if (print_srcline_last)
                 map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);
 
-        print_insn(sample, attr);
+        print_insn(sample, attr, thread, machine);
 
         printf("\n");
 }
@@ -830,6 +1085,7 @@ struct perf_script {
         bool                    show_task_events;
         bool                    show_mmap_events;
         bool                    show_switch_events;
+        bool                    show_namespace_events;
         bool                    allocated;
         struct cpu_map          *cpus;
         struct thread_map       *threads;
@@ -871,7 +1127,8 @@ static size_t data_src__printf(u64 data_src)
 
 static void process_event(struct perf_script *script,
                           struct perf_sample *sample, struct perf_evsel *evsel,
-                          struct addr_location *al)
+                          struct addr_location *al,
+                          struct machine *machine)
 {
         struct thread *thread = al->thread;
         struct perf_event_attr *attr = &evsel->attr;
@@ -898,7 +1155,7 @@ static void process_event(struct perf_script *script,
                 print_sample_flags(sample->flags);
 
         if (is_bts_event(attr)) {
-                print_sample_bts(sample, evsel, thread, al);
+                print_sample_bts(sample, evsel, thread, al, machine);
                 return;
         }
 
@@ -936,7 +1193,7 @@ static void process_event(struct perf_script *script,
 
         if (perf_evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
                 print_sample_bpf_output(sample);
-        print_insn(sample, attr);
+        print_insn(sample, attr, thread, machine);
         printf("\n");
 }
 
@@ -1046,7 +1303,7 @@ static int process_sample_event(struct perf_tool *tool,
         if (scripting_ops)
                 scripting_ops->process_event(event, sample, evsel, &al);
         else
-                process_event(scr, sample, evsel, &al);
+                process_event(scr, sample, evsel, &al, machine);
 
 out_put:
         addr_location__put(&al);
@@ -1118,6 +1375,41 @@ out:
         return ret;
 }
 
+static int process_namespaces_event(struct perf_tool *tool,
+                                    union perf_event *event,
+                                    struct perf_sample *sample,
+                                    struct machine *machine)
+{
+        struct thread *thread;
+        struct perf_script *script = container_of(tool, struct perf_script, tool);
+        struct perf_session *session = script->session;
+        struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
+        int ret = -1;
+
+        thread = machine__findnew_thread(machine, event->namespaces.pid,
+                                         event->namespaces.tid);
+        if (thread == NULL) {
+                pr_debug("problem processing NAMESPACES event, skipping it.\n");
+                return -1;
+        }
+
+        if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
+                goto out;
+
+        if (!evsel->attr.sample_id_all) {
+                sample->cpu = 0;
+                sample->time = 0;
+                sample->tid = event->namespaces.tid;
+                sample->pid = event->namespaces.pid;
+        }
+        print_sample_start(sample, thread, evsel);
+        perf_event__fprintf(event, stdout);
+        ret = 0;
+out:
+        thread__put(thread);
+        return ret;
+}
+
 static int process_fork_event(struct perf_tool *tool,
                               union perf_event *event,
                               struct perf_sample *sample,
@@ -1293,6 +1585,8 @@ static int __cmd_script(struct perf_script *script)
         }
         if (script->show_switch_events)
                 script->tool.context_switch = process_switch_event;
+        if (script->show_namespace_events)
+                script->tool.namespaces = process_namespaces_event;
 
         ret = perf_session__process_events(script->session);
 
@@ -1427,7 +1721,7 @@ static int parse_scriptname(const struct option *opt __maybe_unused,
 static int parse_output_fields(const struct option *opt __maybe_unused,
                             const char *arg, int unset __maybe_unused)
 {
-        char *tok;
+        char *tok, *strtok_saveptr = NULL;
         int i, imax = ARRAY_SIZE(all_output_options);
         int j;
         int rc = 0;
@@ -1488,7 +1782,7 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
                 }
         }
 
-        for (tok = strtok(tok, ","); tok; tok = strtok(NULL, ",")) {
+        for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
                 for (i = 0; i < imax; ++i) {
                         if (strcmp(tok, all_output_options[i].str) == 0)
                                 break;
@@ -2078,7 +2372,7 @@ int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
         return set_maps(script);
 }
 
-int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_script(int argc, const char **argv)
 {
         bool show_full_info = false;
         bool header = false;
@@ -2097,6 +2391,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                         .mmap            = perf_event__process_mmap,
                         .mmap2           = perf_event__process_mmap2,
                         .comm            = perf_event__process_comm,
+                        .namespaces      = perf_event__process_namespaces,
                         .exit            = perf_event__process_exit,
                         .fork            = perf_event__process_fork,
                         .attr            = process_attr,
@@ -2152,7 +2447,8 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                      "Valid types: hw,sw,trace,raw. "
                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
                      "addr,symoff,period,iregs,brstack,brstacksym,flags,"
-                     "bpf-output,callindent,insn,insnlen", parse_output_fields),
+                     "bpf-output,callindent,insn,insnlen,brstackinsn",
+                     parse_output_fields),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
@@ -2180,7 +2476,11 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show the mmap events"),
         OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
                     "Show context switch events (if recorded)"),
+        OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
+                    "Show namespace events (if recorded)"),
         OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
+        OPT_INTEGER(0, "max-blocks", &max_blocks,
+                    "Maximum number of code blocks to dump with brstackinsn"),
         OPT_BOOLEAN(0, "ns", &nanosecs,
                     "Use 9 decimal places when displaying time"),
         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
@@ -2217,7 +2517,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
         if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
                 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
                 if (!rec_script_path)
-                        return cmd_record(argc, argv, NULL);
+                        return cmd_record(argc, argv);
         }
 
         if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 13b54999ad79..a935b5023732 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -64,14 +64,24 @@
 #include "util/session.h"
 #include "util/tool.h"
 #include "util/group.h"
+#include "util/string2.h"
 #include "asm/bug.h"
 
 #include <linux/time64.h>
 #include <api/fs/fs.h>
+#include <errno.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <sys/prctl.h>
+#include <inttypes.h>
 #include <locale.h>
 #include <math.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "sane_ctype.h"
 
 #define DEFAULT_SEPARATOR       " "
 #define CNTR_NOT_SUPPORTED      "<not supported>"
@@ -140,12 +150,14 @@ 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 struct timespec          ref_time;
 static struct cpu_map           *aggr_map;
 static aggr_get_id_t            aggr_get_id;
 static bool                     append_file;
 static const char               *output_name;
 static int                      output_fd;
+static int                      print_free_counters_hint;
 
 struct perf_stat {
         bool                     record;
@@ -310,8 +322,12 @@ static int read_counter(struct perf_evsel *counter)
                         struct perf_counts_values *count;
 
                         count = perf_counts(counter->counts, cpu, thread);
-                        if (perf_evsel__read(counter, cpu, thread, count))
+                        if (perf_evsel__read(counter, cpu, thread, count)) {
+                                counter->counts->scaled = -1;
+                                perf_counts(counter->counts, cpu, thread)->ena = 0;
+                                perf_counts(counter->counts, cpu, thread)->run = 0;
                                 return -1;
+                        }
 
                         if (STAT_RECORD) {
                                 if (perf_evsel__write_stat_event(counter, cpu, thread, count)) {
@@ -336,12 +352,14 @@ static int read_counter(struct perf_evsel *counter)
 static void read_counters(void)
 {
         struct perf_evsel *counter;
+        int ret;
 
         evlist__for_each_entry(evsel_list, counter) {
-                if (read_counter(counter))
+                ret = read_counter(counter);
+                if (ret)
                         pr_debug("failed to read counter %s\n", counter->name);
 
-                if (perf_stat_process_counter(&stat_config, counter))
+                if (ret == 0 && perf_stat_process_counter(&stat_config, counter))
                         pr_warning("failed to process counter %s\n", counter->name);
         }
 }
@@ -873,10 +891,7 @@ static void print_metric_csv(void *ctx,
                 return;
         }
         snprintf(buf, sizeof(buf), fmt, val);
-        vals = buf;
-        while (isspace(*vals))
-                vals++;
-        ends = vals;
+        ends = vals = ltrim(buf);
         while (isdigit(*ends) || *ends == '.')
                 ends++;
         *ends = 0;
@@ -948,10 +963,7 @@ static void print_metric_only_csv(void *ctx, const char *color __maybe_unused,
                 return;
         unit = fixunit(tbuf, os->evsel, unit);
         snprintf(buf, sizeof buf, fmt, val);
-        vals = buf;
-        while (isspace(*vals))
-                vals++;
-        ends = vals;
+        ends = vals = ltrim(buf);
         while (isdigit(*ends) || *ends == '.')
                 ends++;
         *ends = 0;
@@ -1109,6 +1121,9 @@ static void printout(int id, int nr, struct perf_evsel *counter, double uval,
                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
                         csv_sep);
 
+                if (counter->supported)
+                        print_free_counters_hint = 1;
+
                 fprintf(stat_config.output, "%-*s%s",
                         csv_output ? 0 : unit_width,
                         counter->unit, csv_sep);
@@ -1140,6 +1155,7 @@ static void printout(int id, int nr, struct perf_evsel *counter, double 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);
@@ -1178,11 +1194,81 @@ static void aggr_update_shadow(void)
         }
 }
 
+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) ||
+                    nsec_counter(alias) != nsec_counter(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)
+                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 cpu, s, s2, id, nr;
+        int s, id, nr;
         double uval;
         u64 ena, run, val;
         bool first;
@@ -1197,23 +1283,21 @@ static void print_aggr(char *prefix)
          * 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);
 
-                id = aggr_map->map[s];
+                ad.id = id = aggr_map->map[s];
                 first = true;
                 evlist__for_each_entry(evsel_list, counter) {
-                        val = ena = run = 0;
-                        nr = 0;
-                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                                s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
-                                if (s2 != id)
-                                        continue;
-                                val += perf_counts(counter->counts, cpu, 0)->val;
-                                ena += perf_counts(counter->counts, cpu, 0)->ena;
-                                run += perf_counts(counter->counts, cpu, 0)->run;
-                                nr++;
-                        }
+                        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);
@@ -1257,6 +1341,21 @@ static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
         }
 }
 
+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->priv;
+
+        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
@@ -1264,23 +1363,31 @@ static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
 static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
 {
         FILE *output = stat_config.output;
-        struct perf_stat_evsel *ps = counter->priv;
-        double avg = avg_stats(&ps->res_stats[0]);
         double uval;
-        double avg_enabled, avg_running;
+        struct caggr_data cd = { .avg = 0.0 };
 
-        avg_enabled = avg_stats(&ps->res_stats[1]);
-        avg_running = avg_stats(&ps->res_stats[2]);
+        if (!collect_data(counter, counter_aggr_cb, &cd))
+                return;
 
         if (prefix && !metric_only)
                 fprintf(output, "%s", prefix);
 
-        uval = avg * counter->scale;
-        printout(-1, 0, counter, uval, prefix, avg_running, avg_enabled, avg);
+        uval = cd.avg * counter->scale;
+        printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled, cd.avg);
         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
@@ -1293,9 +1400,13 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
         int cpu;
 
         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                val = perf_counts(counter->counts, cpu, 0)->val;
-                ena = perf_counts(counter->counts, cpu, 0)->ena;
-                run = perf_counts(counter->counts, cpu, 0)->run;
+                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);
@@ -1380,6 +1491,7 @@ static void print_metric_headers(const char *prefix, bool no_indent)
                 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,
@@ -1477,6 +1589,13 @@ static void print_footer(void)
                                 avg_stats(&walltime_nsecs_stats));
         }
         fprintf(output, "\n\n");
+
+        if (print_free_counters_hint)
+                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");
 }
 
 static void print_counters(struct timespec *ts, int argc, const char **argv)
@@ -1633,6 +1752,7 @@ 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",
                    "print counts with custom separator"),
         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
@@ -2339,7 +2459,36 @@ static int __cmd_report(int argc, const char **argv)
         return 0;
 }
 
-int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
+static void setup_system_wide(int forks)
+{
+        /*
+         * Make system wide (-a) the default target if
+         * no target was specified and one of following
+         * conditions is met:
+         *
+         *   - there's no workload specified
+         *   - there is workload specified but all requested
+         *     events are system wide events
+         */
+        if (!target__none(&target))
+                return;
+
+        if (!forks)
+                target.system_wide = true;
+        else {
+                struct perf_evsel *counter;
+
+                evlist__for_each_entry(evsel_list, counter) {
+                        if (!counter->system_wide)
+                                return;
+                }
+
+                if (evsel_list->nr_entries)
+                        target.system_wide = true;
+        }
+}
+
+int cmd_stat(int argc, const char **argv)
 {
         const char * const stat_usage[] = {
                 "perf stat [<options>] [<command>]",
@@ -2361,6 +2510,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
         argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
                                         (const char **) stat_usage,
                                         PARSE_OPT_STOP_AT_NON_OPTION);
+        perf_stat__collect_metric_expr(evsel_list);
         perf_stat__init_shadow_stats();
 
         if (csv_sep) {
@@ -2445,9 +2595,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
         } else if (big_num_opt == 0) /* User passed --no-big-num */
                 big_num = false;
 
-        /* Make system wide (-a) the default target. */
-        if (!argc && target__none(&target))
-                target.system_wide = true;
+        setup_system_wide(argc);
 
         if (run_count < 0) {
                 pr_err("Run count must be a positive number\n");
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index e7eaa298d34a..4e2e61695986 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -12,6 +12,8 @@
  * of the License.
  */
 
+#include <errno.h>
+#include <inttypes.h>
 #include <traceevent/event-parse.h>
 
 #include "builtin.h"
@@ -23,11 +25,12 @@
 #include "util/cache.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
+#include <linux/kernel.h>
 #include <linux/rbtree.h>
 #include <linux/time64.h>
 #include "util/symbol.h"
+#include "util/thread.h"
 #include "util/callchain.h"
-#include "util/strlist.h"
 
 #include "perf.h"
 #include "util/header.h"
@@ -1773,7 +1776,7 @@ static int timechart__io_record(int argc, const char **argv)
         for (i = 0; i < (unsigned int)argc; i++)
                 *p++ = argv[i];
 
-        return cmd_record(rec_argc, rec_argv, NULL);
+        return cmd_record(rec_argc, rec_argv);
 }
 
 
@@ -1864,7 +1867,7 @@ static int timechart__record(struct timechart *tchart, int argc, const char **ar
         for (j = 0; j < (unsigned int)argc; j++)
                 *p++ = argv[j];
 
-        return cmd_record(rec_argc, rec_argv, NULL);
+        return cmd_record(rec_argc, rec_argv);
 }
 
 static int
@@ -1917,8 +1920,7 @@ parse_time(const struct option *opt, const char *arg, int __maybe_unused unset)
         return 0;
 }
 
-int cmd_timechart(int argc, const char **argv,
-                  const char *prefix __maybe_unused)
+int cmd_timechart(int argc, const char **argv)
 {
         struct timechart tchart = {
                 .tool = {
@@ -1933,6 +1935,11 @@ int cmd_timechart(int argc, const char **argv,
                 .merge_dist = 1000,
         };
         const char *output_name = "output.svg";
+        const struct option timechart_common_options[] = {
+        OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
+        OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only, "output processes data only"),
+        OPT_END()
+        };
         const struct option timechart_options[] = {
         OPT_STRING('i', "input", &input_name, "file", "input file name"),
         OPT_STRING('o', "output", &output_name, "file", "output file name"),
@@ -1940,9 +1947,6 @@ int cmd_timechart(int argc, const char **argv,
         OPT_CALLBACK(0, "highlight", NULL, "duration or task name",
                       "highlight tasks. Pass duration in ns or process name.",
                        parse_highlight),
-        OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
-        OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
-                    "output processes data only"),
         OPT_CALLBACK('p', "process", NULL, "process",
                       "process selector. Pass a pid or process name.",
                        parse_process),
@@ -1962,22 +1966,18 @@ int cmd_timechart(int argc, const char **argv,
                      "merge events that are merge-dist us apart",
                      parse_time),
         OPT_BOOLEAN('f', "force", &tchart.force, "don't complain, do it"),
-        OPT_END()
+        OPT_PARENT(timechart_common_options),
         };
         const char * const timechart_subcommands[] = { "record", NULL };
         const char *timechart_usage[] = {
                 "perf timechart [<options>] {record}",
                 NULL
         };
-
         const struct option timechart_record_options[] = {
-        OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
-        OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
-                    "output processes data only"),
         OPT_BOOLEAN('I', "io-only", &tchart.io_only,
                     "record only IO data"),
         OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
-        OPT_END()
+        OPT_PARENT(timechart_common_options),
         };
         const char * const timechart_record_usage[] = {
                 "perf timechart record [<options>]",
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index ab9077915763..7ab42b8311a1 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -40,6 +40,7 @@
 #include "util/cpumap.h"
 #include "util/xyarray.h"
 #include "util/sort.h"
+#include "util/term.h"
 #include "util/intlist.h"
 #include "util/parse-branch-options.h"
 #include "arch/common.h"
@@ -58,6 +59,7 @@
 #include <errno.h>
 #include <time.h>
 #include <sched.h>
+#include <signal.h>
 
 #include <sys/syscall.h>
 #include <sys/ioctl.h>
@@ -72,6 +74,8 @@
 #include <linux/time64.h>
 #include <linux/types.h>
 
+#include "sane_ctype.h"
+
 static volatile int done;
 
 #define HEADER_LINE_NR  5
@@ -1075,7 +1079,7 @@ parse_percent_limit(const struct option *opt, const char *arg,
 const char top_callchain_help[] = CALLCHAIN_RECORD_HELP CALLCHAIN_REPORT_HELP
         "\n\t\t\t\tDefault: fp,graph,0.5,caller,function";
 
-int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_top(int argc, const char **argv)
 {
         char errbuf[BUFSIZ];
         struct perf_top top = {
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 256f1fac6f7e..eaa66fb57347 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -24,6 +24,7 @@
 #include "util/evlist.h"
 #include <subcmd/exec-cmd.h>
 #include "util/machine.h"
+#include "util/path.h"
 #include "util/session.h"
 #include "util/thread.h"
 #include <subcmd/parse-options.h>
@@ -31,23 +32,33 @@
 #include "util/intlist.h"
 #include "util/thread_map.h"
 #include "util/stat.h"
+#include "trace/beauty/beauty.h"
 #include "trace-event.h"
 #include "util/parse-events.h"
 #include "util/bpf-loader.h"
 #include "callchain.h"
+#include "print_binary.h"
+#include "string2.h"
 #include "syscalltbl.h"
 #include "rb_resort.h"
 
+#include <errno.h>
+#include <inttypes.h>
 #include <libaudit.h> /* FIXME: Still needed for audit_errno_to_name */
+#include <poll.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <linux/err.h>
 #include <linux/filter.h>
 #include <linux/audit.h>
+#include <linux/kernel.h>
 #include <linux/random.h>
 #include <linux/stringify.h>
 #include <linux/time64.h>
 
+#include "sane_ctype.h"
+
 #ifndef O_CLOEXEC
 # define O_CLOEXEC              02000000
 #endif
@@ -267,15 +278,6 @@ out_delete:
         ({ struct syscall_tp *fields = evsel->priv; \
            fields->name.pointer(&fields->name, sample); })
 
-struct syscall_arg {
-        unsigned long val;
-        struct thread *thread;
-        struct trace  *trace;
-        void          *parm;
-        u8            idx;
-        u8            mask;
-};
-
 struct strarray {
         int         offset;
         int         nr_entries;
@@ -771,6 +773,10 @@ static struct syscall_fmt {
           .arg_parm      = { [0] = &strarray__socket_families, /* family */ }, },
         { .name     = "stat",       .errmsg = true, .alias = "newstat", },
         { .name     = "statfs",     .errmsg = true, },
+        { .name     = "statx",      .errmsg = true,
+          .arg_scnprintf = { [0] = SCA_FDAT, /* flags */
+                             [2] = SCA_STATX_FLAGS, /* flags */
+                             [3] = SCA_STATX_MASK, /* mask */ }, },
         { .name     = "swapoff",    .errmsg = true,
           .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
         { .name     = "swapon",     .errmsg = true,
@@ -821,12 +827,21 @@ struct syscall {
         void                **arg_parm;
 };
 
-static size_t fprintf_duration(unsigned long t, FILE *fp)
+/*
+ * We need to have this 'calculated' boolean because in some cases we really
+ * don't know what is the duration of a syscall, for instance, when we start
+ * a session and some threads are waiting for a syscall to finish, say 'poll',
+ * in which case all we can do is to print "( ? ) for duration and for the
+ * start timestamp.
+ */
+static size_t fprintf_duration(unsigned long t, bool calculated, FILE *fp)
 {
         double duration = (double)t / NSEC_PER_MSEC;
         size_t printed = fprintf(fp, "(");
 
-        if (duration >= 1.0)
+        if (!calculated)
+                printed += fprintf(fp, "     ?   ");
+        else if (duration >= 1.0)
                 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
         else if (duration >= 0.01)
                 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
@@ -1028,13 +1043,27 @@ static bool trace__filter_duration(struct trace *trace, double t)
         return t < (trace->duration_filter * NSEC_PER_MSEC);
 }
 
-static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
+static size_t __trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
 {
         double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
 
         return fprintf(fp, "%10.3f ", ts);
 }
 
+/*
+ * We're handling tstamp=0 as an undefined tstamp, i.e. like when we are
+ * using ttrace->entry_time for a thread that receives a sys_exit without
+ * first having received a sys_enter ("poll" issued before tracing session
+ * starts, lost sys_enter exit due to ring buffer overflow).
+ */
+static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
+{
+        if (tstamp > 0)
+                return __trace__fprintf_tstamp(trace, tstamp, fp);
+
+        return fprintf(fp, "         ? ");
+}
+
 static bool done = false;
 static bool interrupted = false;
 
@@ -1045,10 +1074,10 @@ static void sig_handler(int sig)
 }
 
 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
-                                        u64 duration, u64 tstamp, FILE *fp)
+                                        u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
 {
         size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
-        printed += fprintf_duration(duration, fp);
+        printed += fprintf_duration(duration, duration_calculated, fp);
 
         if (trace->multiple_threads) {
                 if (trace->show_comm)
@@ -1450,7 +1479,7 @@ static int trace__printf_interrupted_entry(struct trace *trace, struct perf_samp
 
         duration = sample->time - ttrace->entry_time;
 
-        printed  = trace__fprintf_entry_head(trace, trace->current, duration, ttrace->entry_time, trace->output);
+        printed  = trace__fprintf_entry_head(trace, trace->current, duration, true, ttrace->entry_time, trace->output);
         printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
         ttrace->entry_pending = false;
 
@@ -1497,7 +1526,7 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
 
         if (sc->is_exit) {
                 if (!(trace->duration_filter || trace->summary_only || trace->min_stack)) {
-                        trace__fprintf_entry_head(trace, thread, 1, ttrace->entry_time, trace->output);
+                        trace__fprintf_entry_head(trace, thread, 0, false, ttrace->entry_time, trace->output);
                         fprintf(trace->output, "%-70s)\n", ttrace->entry_str);
                 }
         } else {
@@ -1545,6 +1574,7 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
 {
         long ret;
         u64 duration = 0;
+        bool duration_calculated = false;
         struct thread *thread;
         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0;
         struct syscall *sc = trace__syscall_info(trace, evsel, id);
@@ -1573,6 +1603,7 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
                 duration = sample->time - ttrace->entry_time;
                 if (trace__filter_duration(trace, duration))
                         goto out;
+                duration_calculated = true;
         } else if (trace->duration_filter)
                 goto out;
 
@@ -1588,7 +1619,7 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
         if (trace->summary_only)
                 goto out;
 
-        trace__fprintf_entry_head(trace, thread, duration, ttrace->entry_time, trace->output);
+        trace__fprintf_entry_head(trace, thread, duration, duration_calculated, ttrace->entry_time, trace->output);
 
         if (ttrace->entry_pending) {
                 fprintf(trace->output, "%-70s", ttrace->entry_str);
@@ -1653,15 +1684,17 @@ static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
 
         ttrace = thread__priv(thread);
         if (!ttrace)
-                goto out;
+                goto out_put;
 
         filename_len = strlen(filename);
+        if (filename_len == 0)
+                goto out_put;
 
         if (ttrace->filename.namelen < filename_len) {
                 char *f = realloc(ttrace->filename.name, filename_len + 1);
 
                 if (f == NULL)
-                                goto out;
+                        goto out_put;
 
                 ttrace->filename.namelen = filename_len;
                 ttrace->filename.name = f;
@@ -1671,12 +1704,12 @@ static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
         ttrace->filename.pending_open = true;
 
         if (!ttrace->filename.ptr)
-                goto out;
+                goto out_put;
 
         entry_str_len = strlen(ttrace->entry_str);
         remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
         if (remaining_space <= 0)
-                goto out;
+                goto out_put;
 
         if (filename_len > (size_t)remaining_space) {
                 filename += filename_len - remaining_space;
@@ -1690,6 +1723,8 @@ static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
 
         ttrace->filename.ptr = 0;
         ttrace->filename.entry_str_pos = 0;
+out_put:
+        thread__put(thread);
 out:
         return 0;
 }
@@ -1710,6 +1745,7 @@ static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evs
 
         ttrace->runtime_ms += runtime_ms;
         trace->runtime_ms += runtime_ms;
+out_put:
         thread__put(thread);
         return 0;
 
@@ -1720,8 +1756,7 @@ out_dump:
                (pid_t)perf_evsel__intval(evsel, sample, "pid"),
                runtime,
                perf_evsel__intval(evsel, sample, "vruntime"));
-        thread__put(thread);
-        return 0;
+        goto out_put;
 }
 
 static void bpf_output__printer(enum binary_printer_ops op,
@@ -1851,7 +1886,7 @@ static int trace__pgfault(struct trace *trace,
         thread__find_addr_location(thread, sample->cpumode, MAP__FUNCTION,
                               sample->ip, &al);
 
-        trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
+        trace__fprintf_entry_head(trace, thread, 0, true, sample->time, trace->output);
 
         fprintf(trace->output, "%sfault [",
                 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
@@ -1920,7 +1955,7 @@ static int trace__process_sample(struct perf_tool *tool,
 
         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
         if (thread && thread__is_filtered(thread))
-                return 0;
+                goto out;
 
         trace__set_base_time(trace, evsel, sample);
 
@@ -1928,7 +1963,8 @@ static int trace__process_sample(struct perf_tool *tool,
                 ++trace->nr_events;
                 handler(trace, evsel, event, sample);
         }
-
+out:
+        thread__put(thread);
         return err;
 }
 
@@ -1988,7 +2024,7 @@ static int trace__record(struct trace *trace, int argc, const char **argv)
         for (i = 0; i < (unsigned int)argc; i++)
                 rec_argv[j++] = argv[i];
 
-        return cmd_record(j, rec_argv, NULL);
+        return cmd_record(j, rec_argv);
 }
 
 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
@@ -2415,8 +2451,9 @@ static int trace__replay(struct trace *trace)
         trace->tool.exit          = perf_event__process_exit;
         trace->tool.fork          = perf_event__process_fork;
         trace->tool.attr          = perf_event__process_attr;
-        trace->tool.tracing_data = perf_event__process_tracing_data;
+        trace->tool.tracing_data  = perf_event__process_tracing_data;
         trace->tool.build_id      = perf_event__process_build_id;
+        trace->tool.namespaces    = perf_event__process_namespaces;
 
         trace->tool.ordered_events = true;
         trace->tool.ordering_requires_timestamps = true;
@@ -2785,7 +2822,7 @@ out:
         return err;
 }
 
-int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_trace(int argc, const char **argv)
 {
         const char *trace_usage[] = {
                 "perf trace [<options>] [<command>]",
diff --git a/tools/perf/builtin-version.c b/tools/perf/builtin-version.c
index 9b10cda6b6dc..d25149456a2f 100644
--- a/tools/perf/builtin-version.c
+++ b/tools/perf/builtin-version.c
@@ -1,9 +1,9 @@
-#include "util/util.h"
 #include "builtin.h"
 #include "perf.h"
+#include <linux/compiler.h>
+#include <stdio.h>
 
-int cmd_version(int argc __maybe_unused, const char **argv __maybe_unused,
-                const char *prefix __maybe_unused)
+int cmd_version(int argc __maybe_unused, const char **argv __maybe_unused)
 {
         printf("perf version %s\n", perf_version_string);
         return 0;
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index 036e1e35b1a8..d4d19fe3d050 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -2,46 +2,42 @@
 #define BUILTIN_H
 
 #include "util/util.h"
-#include "util/strbuf.h"
 
 extern const char perf_usage_string[];
 extern const char perf_more_info_string[];
 
 void list_common_cmds_help(void);
 const char *help_unknown_cmd(const char *cmd);
-void prune_packed_objects(int);
-int read_line_with_nul(char *buf, int size, FILE *file);
-int check_pager_config(const char *cmd);
 
-int cmd_annotate(int argc, const char **argv, const char *prefix);
-int cmd_bench(int argc, const char **argv, const char *prefix);
-int cmd_buildid_cache(int argc, const char **argv, const char *prefix);
-int cmd_buildid_list(int argc, const char **argv, const char *prefix);
-int cmd_config(int argc, const char **argv, const char *prefix);
-int cmd_c2c(int argc, const char **argv, const char *prefix);
-int cmd_diff(int argc, const char **argv, const char *prefix);
-int cmd_evlist(int argc, const char **argv, const char *prefix);
-int cmd_help(int argc, const char **argv, const char *prefix);
-int cmd_sched(int argc, const char **argv, const char *prefix);
-int cmd_kallsyms(int argc, const char **argv, const char *prefix);
-int cmd_list(int argc, const char **argv, const char *prefix);
-int cmd_record(int argc, const char **argv, const char *prefix);
-int cmd_report(int argc, const char **argv, const char *prefix);
-int cmd_stat(int argc, const char **argv, const char *prefix);
-int cmd_timechart(int argc, const char **argv, const char *prefix);
-int cmd_top(int argc, const char **argv, const char *prefix);
-int cmd_script(int argc, const char **argv, const char *prefix);
-int cmd_version(int argc, const char **argv, const char *prefix);
-int cmd_probe(int argc, const char **argv, const char *prefix);
-int cmd_kmem(int argc, const char **argv, const char *prefix);
-int cmd_lock(int argc, const char **argv, const char *prefix);
-int cmd_kvm(int argc, const char **argv, const char *prefix);
-int cmd_test(int argc, const char **argv, const char *prefix);
-int cmd_trace(int argc, const char **argv, const char *prefix);
-int cmd_inject(int argc, const char **argv, const char *prefix);
-int cmd_mem(int argc, const char **argv, const char *prefix);
-int cmd_data(int argc, const char **argv, const char *prefix);
-int cmd_ftrace(int argc, const char **argv, const char *prefix);
+int cmd_annotate(int argc, const char **argv);
+int cmd_bench(int argc, const char **argv);
+int cmd_buildid_cache(int argc, const char **argv);
+int cmd_buildid_list(int argc, const char **argv);
+int cmd_config(int argc, const char **argv);
+int cmd_c2c(int argc, const char **argv);
+int cmd_diff(int argc, const char **argv);
+int cmd_evlist(int argc, const char **argv);
+int cmd_help(int argc, const char **argv);
+int cmd_sched(int argc, const char **argv);
+int cmd_kallsyms(int argc, const char **argv);
+int cmd_list(int argc, const char **argv);
+int cmd_record(int argc, const char **argv);
+int cmd_report(int argc, const char **argv);
+int cmd_stat(int argc, const char **argv);
+int cmd_timechart(int argc, const char **argv);
+int cmd_top(int argc, const char **argv);
+int cmd_script(int argc, const char **argv);
+int cmd_version(int argc, const char **argv);
+int cmd_probe(int argc, const char **argv);
+int cmd_kmem(int argc, const char **argv);
+int cmd_lock(int argc, const char **argv);
+int cmd_kvm(int argc, const char **argv);
+int cmd_test(int argc, const char **argv);
+int cmd_trace(int argc, const char **argv);
+int cmd_inject(int argc, const char **argv);
+int cmd_mem(int argc, const char **argv);
+int cmd_data(int argc, const char **argv);
+int cmd_ftrace(int argc, const char **argv);
 
 int find_scripts(char **scripts_array, char **scripts_path_array);
 #endif
diff --git a/tools/perf/check-headers.sh b/tools/perf/check-headers.sh
index c747bfd7f14d..83fe2202382e 100755
--- a/tools/perf/check-headers.sh
+++ b/tools/perf/check-headers.sh
@@ -1,7 +1,9 @@
 #!/bin/sh
 
 HEADERS='
+include/uapi/linux/fcntl.h
 include/uapi/linux/perf_event.h
+include/uapi/linux/stat.h
 include/linux/hash.h
 include/uapi/linux/hw_breakpoint.h
 arch/x86/include/asm/disabled-features.h
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index ac3efd396a72..2d0caf20ff3a 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -9,6 +9,7 @@ perf-buildid-cache		mainporcelain common
 perf-buildid-list               mainporcelain common
 perf-data                       mainporcelain common
 perf-diff                       mainporcelain common
+perf-c2c                        mainporcelain common
 perf-config                     mainporcelain common
 perf-evlist                     mainporcelain common
 perf-ftrace                     mainporcelain common
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 6d5479e03e0d..4cc6960f6226 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -19,9 +19,15 @@
 #include "util/debug.h"
 #include <api/fs/fs.h>
 #include <api/fs/tracing_path.h>
+#include <errno.h>
 #include <pthread.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <linux/kernel.h>
 
 const char perf_usage_string[] =
         "perf [--version] [--help] [OPTIONS] COMMAND [ARGS]";
@@ -34,7 +40,7 @@ const char *input_name;
 
 struct cmd_struct {
         const char *cmd;
-        int (*fn)(int, const char **, const char *);
+        int (*fn)(int, const char **);
         int option;
 };
 
@@ -88,7 +94,7 @@ static int pager_command_config(const char *var, const char *value, void *data)
 }
 
 /* returns 0 for "no pager", 1 for "use pager", and -1 for "not specified" */
-int check_pager_config(const char *cmd)
+static int check_pager_config(const char *cmd)
 {
         int err;
         struct pager_config c;
@@ -267,71 +273,6 @@ static int handle_options(const char ***argv, int *argc, int *envchanged)
         return handled;
 }
 
-static int handle_alias(int *argcp, const char ***argv)
-{
-        int envchanged = 0, ret = 0, saved_errno = errno;
-        int count, option_count;
-        const char **new_argv;
-        const char *alias_command;
-        char *alias_string;
-
-        alias_command = (*argv)[0];
-        alias_string = alias_lookup(alias_command);
-        if (alias_string) {
-                if (alias_string[0] == '!') {
-                        if (*argcp > 1) {
-                                struct strbuf buf;
-
-                                if (strbuf_init(&buf, PATH_MAX) < 0 ||
-                                    strbuf_addstr(&buf, alias_string) < 0 ||
-                                    sq_quote_argv(&buf, (*argv) + 1,
-                                                  PATH_MAX) < 0)
-                                        die("Failed to allocate memory.");
-                                free(alias_string);
-                                alias_string = buf.buf;
-                        }
-                        ret = system(alias_string + 1);
-                        if (ret >= 0 && WIFEXITED(ret) &&
-                            WEXITSTATUS(ret) != 127)
-                                exit(WEXITSTATUS(ret));
-                        die("Failed to run '%s' when expanding alias '%s'",
-                            alias_string + 1, alias_command);
-                }
-                count = split_cmdline(alias_string, &new_argv);
-                if (count < 0)
-                        die("Bad alias.%s string", alias_command);
-                option_count = handle_options(&new_argv, &count, &envchanged);
-                if (envchanged)
-                        die("alias '%s' changes environment variables\n"
-                                 "You can use '!perf' in the alias to do this.",
-                                 alias_command);
-                memmove(new_argv - option_count, new_argv,
-                                count * sizeof(char *));
-                new_argv -= option_count;
-
-                if (count < 1)
-                        die("empty alias for %s", alias_command);
-
-                if (!strcmp(alias_command, new_argv[0]))
-                        die("recursive alias: %s", alias_command);
-
-                new_argv = realloc(new_argv, sizeof(char *) *
-                                    (count + *argcp + 1));
-                /* insert after command name */
-                memcpy(new_argv + count, *argv + 1, sizeof(char *) * *argcp);
-                new_argv[count + *argcp] = NULL;
-
-                *argv = new_argv;
-                *argcp += count - 1;
-
-                ret = 1;
-        }
-
-        errno = saved_errno;
-
-        return ret;
-}
-
 #define RUN_SETUP       (1<<0)
 #define USE_PAGER       (1<<1)
 
@@ -339,13 +280,8 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
 {
         int status;
         struct stat st;
-        const char *prefix;
         char sbuf[STRERR_BUFSIZE];
 
-        prefix = NULL;
-        if (p->option & RUN_SETUP)
-                prefix = NULL; /* setup_perf_directory(); */
-
         if (use_browser == -1)
                 use_browser = check_browser_config(p->cmd);
 
@@ -356,7 +292,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         commit_pager_choice();
 
         perf_env__set_cmdline(&perf_env, argc, argv);
-        status = p->fn(argc, argv, prefix);
+        status = p->fn(argc, argv);
         perf_config__exit();
         exit_browser(status);
         perf_env__exit(&perf_env);
@@ -397,16 +333,6 @@ static void handle_internal_command(int argc, const char **argv)
 {
         const char *cmd = argv[0];
         unsigned int i;
-        static const char ext[] = STRIP_EXTENSION;
-
-        if (sizeof(ext) > 1) {
-                i = strlen(argv[0]) - strlen(ext);
-                if (i > 0 && !strcmp(argv[0] + i, ext)) {
-                        char *argv0 = strdup(argv[0]);
-                        argv[0] = cmd = argv0;
-                        argv0[i] = '\0';
-                }
-        }
 
         /* Turn "perf cmd --help" into "perf help cmd" */
         if (argc > 1 && !strcmp(argv[1], "--help")) {
@@ -448,7 +374,8 @@ static void execv_dashed_external(const char **argv)
         if (status != -ERR_RUN_COMMAND_EXEC) {
                 if (IS_RUN_COMMAND_ERR(status)) {
 do_die:
-                        die("unable to run '%s'", argv[0]);
+                        pr_err("FATAL: unable to run '%s'", argv[0]);
+                        status = -128;
                 }
                 exit(-status);
         }
@@ -460,25 +387,12 @@ do_die:
 
 static int run_argv(int *argcp, const char ***argv)
 {
-        int done_alias = 0;
+        /* See if it's an internal command */
+        handle_internal_command(*argcp, *argv);
 
-        while (1) {
-                /* See if it's an internal command */
-                handle_internal_command(*argcp, *argv);
-
-                /* .. then try the external ones */
-                execv_dashed_external(*argv);
-
-                /* It could be an alias -- this works around the insanity
-                 * of overriding "perf log" with "perf show" by having
-                 * alias.log = show
-                 */
-                if (done_alias || !handle_alias(argcp, argv))
-                        break;
-                done_alias = 1;
-        }
-
-        return done_alias;
+        /* .. then try the external ones */
+        execv_dashed_external(*argv);
+        return 0;
 }
 
 static void pthread__block_sigwinch(void)
@@ -566,7 +480,7 @@ int main(int argc, const char **argv)
 #ifdef HAVE_LIBAUDIT_SUPPORT
                 setup_path();
                 argv[0] = "trace";
-                return cmd_trace(argc, argv, NULL);
+                return cmd_trace(argc, argv);
 #else
                 fprintf(stderr,
                         "trace command not available: missing audit-libs devel package at build time.\n");
@@ -611,17 +525,12 @@ int main(int argc, const char **argv)
 
         while (1) {
                 static int done_help;
-                int was_alias = run_argv(&argc, &argv);
+
+                run_argv(&argc, &argv);
 
                 if (errno != ENOENT)
                         break;
 
-                if (was_alias) {
-                        fprintf(stderr, "Expansion of alias '%s' failed; "
-                                "'%s' is not a perf-command\n",
-                                cmd, argv[0]);
-                        goto out;
-                }
                 if (!done_help) {
                         cmd = argv[0] = help_unknown_cmd(cmd);
                         done_help = 1;
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 1c27d947c2fe..806c216a1078 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -50,6 +50,7 @@ struct record_opts {
         bool         running_time;
         bool         full_auxtrace;
         bool         auxtrace_snapshot_mode;
+        bool         record_namespaces;
         bool         record_switch_events;
         bool         all_kernel;
         bool         all_user;
diff --git a/tools/perf/pmu-events/arch/x86/broadwell/uncore.json b/tools/perf/pmu-events/arch/x86/broadwell/uncore.json
new file mode 100644
index 000000000000..28e1e159a3cb
--- /dev/null
+++ b/tools/perf/pmu-events/arch/x86/broadwell/uncore.json
@@ -0,0 +1,278 @@
+[
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x41",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which misses in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x81",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_EVICTION",
+    "BriefDescription": "A cross-core snoop resulted from L3 Eviction which misses in some processor core.",
+    "PublicDescription": "A cross-core snoop resulted from L3 Eviction which misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x44",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a non-modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x48",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x11",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_M",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in M-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x21",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_M",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in M-state",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x81",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_M",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in M-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x18",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_I",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in I-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x88",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_I",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in I-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x1f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_MESI",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in any MESI-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in any MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x2f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_MESI",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in MESI-state",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x8f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_MESI",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in MESI-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x86",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_ES",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in E or S-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x16",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_ES",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in E or S-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x26",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_ES",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in E or S-state",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Each cycle count number of all Core outgoing valid entries. Such entry is defined as valid from it's allocation till first of IDI0 or DRS0 messages is sent out. Accounts for Coherent and non-coherent traffic.",
+    "PublicDescription": "Each cycle count number of all Core outgoing valid entries. Such entry is defined as valid from it's allocation till first of IDI0 or DRS0 messages is sent out. Accounts for Coherent and non-coherent traffic.",
+    "Counter": "0,",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x80",
+    "UMask": "0x02",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.DRD_DIRECT",
+    "BriefDescription": "Each cycle count number of 'valid' coherent Data Read entries that are in DirectData mode. Such entry is defined as valid when it is allocated till data sent to Core (first chunk, IDI0). Applicable for IA Cores' requests in normal case.",
+    "PublicDescription": "Each cycle count number of 'valid' coherent Data Read entries that are in DirectData mode. Such entry is defined as valid when it is allocated till data sent to Core (first chunk, IDI0). Applicable for IA Cores' requests in normal case.",
+    "Counter": "0,",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_REQUESTS.ALL",
+    "BriefDescription": "Total number of Core outgoing entries allocated. Accounts for Coherent and non-coherent traffic.",
+    "PublicDescription": "Total number of Core outgoing entries allocated. Accounts for Coherent and non-coherent traffic.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x02",
+    "EventName": "UNC_ARB_TRK_REQUESTS.DRD_DIRECT",
+    "BriefDescription": "Number of Core coherent Data Read entries allocated in DirectData mode",
+    "PublicDescription": "Number of Core coherent Data Read entries allocated in DirectData mode.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x20",
+    "EventName": "UNC_ARB_TRK_REQUESTS.WRITES",
+    "BriefDescription": "Number of Writes allocated - any write transactions: full/partials writes and evictions.",
+    "PublicDescription": "Number of Writes allocated - any write transactions: full/partials writes and evictions.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x84",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_REQUESTS.ALL",
+    "BriefDescription": "Number of entries allocated. Account for Any type: e.g. Snoop, Core aperture, etc.",
+    "PublicDescription": "Number of entries allocated. Account for Any type: e.g. Snoop, Core aperture, etc.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.CYCLES_WITH_ANY_REQUEST",
+    "BriefDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.;",
+    "PublicDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "Counter": "0,",
+    "CounterMask": "1",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "NCU",
+    "EventCode": "0x0",
+    "UMask": "0x01",
+    "EventName": "UNC_CLOCK.SOCKET",
+    "BriefDescription": "This 48-bit fixed counter counts the UCLK cycles",
+    "PublicDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "Counter": "FIXED",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  }
+]
\ No newline at end of file
diff --git a/tools/perf/pmu-events/arch/x86/broadwellde/uncore-cache.json b/tools/perf/pmu-events/arch/x86/broadwellde/uncore-cache.json
index 076459c51d4e..58ed6d33d1f4 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellde/uncore-cache.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellde/uncore-cache.json
@@ -1,13 +1,13 @@
 [
     {
-        "BriefDescription": "Uncore cache clock ticks. Derived from unc_c_clockticks",
+        "BriefDescription": "Uncore cache clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_C_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch). Derived from unc_c_llc_lookup.any",
+        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch)",
         "Counter": "0,1,2,3",
         "EventCode": "0x34",
         "EventName": "UNC_C_LLC_LOOKUP.ANY",
@@ -18,7 +18,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "M line evictions from LLC (writebacks to memory). Derived from unc_c_llc_victims.m_state",
+        "BriefDescription": "M line evictions from LLC (writebacks to memory)",
         "Counter": "0,1,2,3",
         "EventCode": "0x37",
         "EventName": "UNC_C_LLC_VICTIMS.M_STATE",
@@ -212,7 +212,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "read requests to home agent. Derived from unc_h_requests.reads",
+        "BriefDescription": "read requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS",
@@ -221,7 +221,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "read requests to local home agent. Derived from unc_h_requests.reads_local",
+        "BriefDescription": "read requests to local home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS_LOCAL",
@@ -230,7 +230,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "read requests to remote home agent. Derived from unc_h_requests.reads_remote",
+        "BriefDescription": "read requests to remote home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS_REMOTE",
@@ -239,7 +239,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to home agent. Derived from unc_h_requests.writes",
+        "BriefDescription": "write requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES",
@@ -248,7 +248,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to local home agent. Derived from unc_h_requests.writes_local",
+        "BriefDescription": "write requests to local home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES_LOCAL",
@@ -257,7 +257,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to remote home agent. Derived from unc_h_requests.writes_remote",
+        "BriefDescription": "write requests to remote home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES_REMOTE",
@@ -266,7 +266,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Conflict requests (requests for same address from multiple agents simultaneously). Derived from unc_h_snoop_resp.rspcnflct",
+        "BriefDescription": "Conflict requests (requests for same address from multiple agents simultaneously)",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPCNFLCT",
@@ -275,7 +275,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache along with writeback to memory. Derived from unc_h_snoop_resp.rsp_fwd_wb",
+        "BriefDescription": "M line forwarded from remote cache along with writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSP_FWD_WB",
@@ -285,7 +285,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache with no writeback to memory. Derived from unc_h_snoop_resp.rspifwd",
+        "BriefDescription": "M line forwarded from remote cache with no writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPIFWD",
@@ -295,7 +295,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line response from remote cache. Derived from unc_h_snoop_resp.rsps",
+        "BriefDescription": "Shared line response from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPS",
@@ -305,7 +305,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line forwarded from remote cache. Derived from unc_h_snoop_resp.rspsfwd",
+        "BriefDescription": "Shared line forwarded from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPSFWD",
diff --git a/tools/perf/pmu-events/arch/x86/broadwellde/uncore-memory.json b/tools/perf/pmu-events/arch/x86/broadwellde/uncore-memory.json
index d17dc235f734..f4b0745cdbbf 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellde/uncore-memory.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellde/uncore-memory.json
@@ -3,7 +3,7 @@
         "BriefDescription": "read requests to memory controller. Derived from unc_m_cas_count.rd",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.RD",
+        "EventName": "LLC_MISSES.MEM_READ",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0x3",
@@ -13,48 +13,51 @@
         "BriefDescription": "write requests to memory controller. Derived from unc_m_cas_count.wr",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.WR",
+        "EventName": "LLC_MISSES.MEM_WRITE",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0xC",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory controller clock ticks. Derived from unc_m_clockticks",
+        "BriefDescription": "Memory controller clock ticks",
         "Counter": "0,1,2,3",
-        "EventName": "UNC_M_CLOCKTICKS",
+        "EventName": "UNC_M_DCLOCKTICKS",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode. Derived from unc_m_power_channel_ppd",
+        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x85",
         "EventName": "UNC_M_POWER_CHANNEL_PPD",
-        "MetricExpr": "(UNC_M_POWER_CHANNEL_PPD / UNC_M_CLOCKTICKS) * 100.",
+        "MetricExpr": "(UNC_M_POWER_CHANNEL_PPD / UNC_M_DCLOCKTICKS) * 100.",
+        "MetricName": "power_channel_ppd %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles all ranks are in critical thermal throttle. Derived from unc_m_power_critical_throttle_cycles",
+        "BriefDescription": "Cycles all ranks are in critical thermal throttle",
         "Counter": "0,1,2,3",
         "EventCode": "0x86",
         "EventName": "UNC_M_POWER_CRITICAL_THROTTLE_CYCLES",
-        "MetricExpr": "(UNC_M_POWER_CRITICAL_THROTTLE_CYCLES / UNC_M_CLOCKTICKS) * 100.",
+        "MetricExpr": "(UNC_M_POWER_CRITICAL_THROTTLE_CYCLES / UNC_M_DCLOCKTICKS) * 100.",
+        "MetricName": "power_critical_throttle_cycles %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles Memory is in self refresh power mode. Derived from unc_m_power_self_refresh",
+        "BriefDescription": "Cycles Memory is in self refresh power mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x43",
         "EventName": "UNC_M_POWER_SELF_REFRESH",
-        "MetricExpr": "(UNC_M_POWER_SELF_REFRESH / UNC_M_CLOCKTICKS) * 100.",
+        "MetricExpr": "(UNC_M_POWER_SELF_REFRESH / UNC_M_DCLOCKTICKS) * 100.",
+        "MetricName": "power_self_refresh %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charges due to page misses. Derived from unc_m_pre_count.page_miss",
+        "BriefDescription": "Pre-charges due to page misses",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.PAGE_MISS",
@@ -63,7 +66,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charge for reads. Derived from unc_m_pre_count.rd",
+        "BriefDescription": "Pre-charge for reads",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.RD",
@@ -72,7 +75,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charge for writes. Derived from unc_m_pre_count.wr",
+        "BriefDescription": "Pre-charge for writes",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.WR",
diff --git a/tools/perf/pmu-events/arch/x86/broadwellde/uncore-power.json b/tools/perf/pmu-events/arch/x86/broadwellde/uncore-power.json
index b44d43088bbb..dd1b95655d1d 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellde/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellde/uncore-power.json
@@ -1,83 +1,91 @@
 [
     {
-        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events. Derived from unc_p_clockticks",
+        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_P_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C0 and C1. Derived from unc_p_power_state_occupancy.cores_c0",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C0.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C0",
         "Filter": "occ_sel=1",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C0 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c0 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C3. Derived from unc_p_power_state_occupancy.cores_c3",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C3.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C3",
         "Filter": "occ_sel=2",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C3 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c3 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C6 and C7. Derived from unc_p_power_state_occupancy.cores_c6",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C6.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events ",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C6",
         "Filter": "occ_sel=3",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C6 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c6 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "External Prochot. Derived from unc_p_prochot_external_cycles",
+        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip",
         "Counter": "0,1,2,3",
         "EventCode": "0xA",
         "EventName": "UNC_P_PROCHOT_EXTERNAL_CYCLES",
         "MetricExpr": "(UNC_P_PROCHOT_EXTERNAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "prochot_external_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Thermal Strongest Upper Limit Cycles. Derived from unc_p_freq_max_limit_thermal_cycles",
+        "BriefDescription": "Counts the number of cycles when temperature is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
         "EventName": "UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_limit_thermal_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "OS Strongest Upper Limit Cycles. Derived from unc_p_freq_max_os_cycles",
+        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x6",
         "EventName": "UNC_P_FREQ_MAX_OS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_OS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_os_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Power Strongest Upper Limit Cycles. Derived from unc_p_freq_max_power_cycles",
+        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x5",
         "EventName": "UNC_P_FREQ_MAX_POWER_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_POWER_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_power_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Cycles spent changing Frequency. Derived from unc_p_freq_trans_cycles",
+        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x74",
         "EventName": "UNC_P_FREQ_TRANS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_TRANS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_trans_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     }
diff --git a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-cache.json b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-cache.json
index 076459c51d4e..58ed6d33d1f4 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-cache.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-cache.json
@@ -1,13 +1,13 @@
 [
     {
-        "BriefDescription": "Uncore cache clock ticks. Derived from unc_c_clockticks",
+        "BriefDescription": "Uncore cache clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_C_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch). Derived from unc_c_llc_lookup.any",
+        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch)",
         "Counter": "0,1,2,3",
         "EventCode": "0x34",
         "EventName": "UNC_C_LLC_LOOKUP.ANY",
@@ -18,7 +18,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "M line evictions from LLC (writebacks to memory). Derived from unc_c_llc_victims.m_state",
+        "BriefDescription": "M line evictions from LLC (writebacks to memory)",
         "Counter": "0,1,2,3",
         "EventCode": "0x37",
         "EventName": "UNC_C_LLC_VICTIMS.M_STATE",
@@ -212,7 +212,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "read requests to home agent. Derived from unc_h_requests.reads",
+        "BriefDescription": "read requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS",
@@ -221,7 +221,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "read requests to local home agent. Derived from unc_h_requests.reads_local",
+        "BriefDescription": "read requests to local home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS_LOCAL",
@@ -230,7 +230,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "read requests to remote home agent. Derived from unc_h_requests.reads_remote",
+        "BriefDescription": "read requests to remote home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS_REMOTE",
@@ -239,7 +239,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to home agent. Derived from unc_h_requests.writes",
+        "BriefDescription": "write requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES",
@@ -248,7 +248,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to local home agent. Derived from unc_h_requests.writes_local",
+        "BriefDescription": "write requests to local home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES_LOCAL",
@@ -257,7 +257,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to remote home agent. Derived from unc_h_requests.writes_remote",
+        "BriefDescription": "write requests to remote home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES_REMOTE",
@@ -266,7 +266,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Conflict requests (requests for same address from multiple agents simultaneously). Derived from unc_h_snoop_resp.rspcnflct",
+        "BriefDescription": "Conflict requests (requests for same address from multiple agents simultaneously)",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPCNFLCT",
@@ -275,7 +275,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache along with writeback to memory. Derived from unc_h_snoop_resp.rsp_fwd_wb",
+        "BriefDescription": "M line forwarded from remote cache along with writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSP_FWD_WB",
@@ -285,7 +285,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache with no writeback to memory. Derived from unc_h_snoop_resp.rspifwd",
+        "BriefDescription": "M line forwarded from remote cache with no writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPIFWD",
@@ -295,7 +295,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line response from remote cache. Derived from unc_h_snoop_resp.rsps",
+        "BriefDescription": "Shared line response from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPS",
@@ -305,7 +305,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line forwarded from remote cache. Derived from unc_h_snoop_resp.rspsfwd",
+        "BriefDescription": "Shared line forwarded from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPSFWD",
diff --git a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-interconnect.json b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-interconnect.json
index 39387f7909b2..824961318c1e 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-interconnect.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-interconnect.json
@@ -1,6 +1,6 @@
 [
     {
-        "BriefDescription": "QPI clock ticks. Derived from unc_q_clockticks",
+        "BriefDescription": "QPI clock ticks",
         "Counter": "0,1,2,3",
         "EventCode": "0x14",
         "EventName": "UNC_Q_CLOCKTICKS",
@@ -10,7 +10,7 @@
     {
         "BriefDescription": "Number of data flits transmitted . Derived from unc_q_txl_flits_g0.data",
         "Counter": "0,1,2,3",
-        "EventName": "UNC_Q_TxL_FLITS_G0.DATA",
+        "EventName": "QPI_DATA_BANDWIDTH_TX",
         "PerPkg": "1",
         "ScaleUnit": "8Bytes",
         "UMask": "0x2",
@@ -19,7 +19,7 @@
     {
         "BriefDescription": "Number of non data (control) flits transmitted . Derived from unc_q_txl_flits_g0.non_data",
         "Counter": "0,1,2,3",
-        "EventName": "UNC_Q_TxL_FLITS_G0.NON_DATA",
+        "EventName": "QPI_CTL_BANDWIDTH_TX",
         "PerPkg": "1",
         "ScaleUnit": "8Bytes",
         "UMask": "0x4",
diff --git a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-memory.json b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-memory.json
index d17dc235f734..66eed399724c 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-memory.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-memory.json
@@ -3,7 +3,7 @@
         "BriefDescription": "read requests to memory controller. Derived from unc_m_cas_count.rd",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.RD",
+        "EventName": "LLC_MISSES.MEM_READ",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0x3",
@@ -13,48 +13,51 @@
         "BriefDescription": "write requests to memory controller. Derived from unc_m_cas_count.wr",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.WR",
+        "EventName": "LLC_MISSES.MEM_WRITE",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0xC",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory controller clock ticks. Derived from unc_m_clockticks",
+        "BriefDescription": "Memory controller clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_M_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode. Derived from unc_m_power_channel_ppd",
+        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x85",
         "EventName": "UNC_M_POWER_CHANNEL_PPD",
         "MetricExpr": "(UNC_M_POWER_CHANNEL_PPD / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_channel_ppd %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles all ranks are in critical thermal throttle. Derived from unc_m_power_critical_throttle_cycles",
+        "BriefDescription": "Cycles all ranks are in critical thermal throttle",
         "Counter": "0,1,2,3",
         "EventCode": "0x86",
         "EventName": "UNC_M_POWER_CRITICAL_THROTTLE_CYCLES",
         "MetricExpr": "(UNC_M_POWER_CRITICAL_THROTTLE_CYCLES / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_critical_throttle_cycles %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles Memory is in self refresh power mode. Derived from unc_m_power_self_refresh",
+        "BriefDescription": "Cycles Memory is in self refresh power mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x43",
         "EventName": "UNC_M_POWER_SELF_REFRESH",
         "MetricExpr": "(UNC_M_POWER_SELF_REFRESH / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_self_refresh %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charges due to page misses. Derived from unc_m_pre_count.page_miss",
+        "BriefDescription": "Pre-charges due to page misses",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.PAGE_MISS",
@@ -63,7 +66,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charge for reads. Derived from unc_m_pre_count.rd",
+        "BriefDescription": "Pre-charge for reads",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.RD",
@@ -72,7 +75,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charge for writes. Derived from unc_m_pre_count.wr",
+        "BriefDescription": "Pre-charge for writes",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.WR",
diff --git a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-power.json b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-power.json
index b44d43088bbb..dd1b95655d1d 100644
--- a/tools/perf/pmu-events/arch/x86/broadwellx/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/broadwellx/uncore-power.json
@@ -1,83 +1,91 @@
 [
     {
-        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events. Derived from unc_p_clockticks",
+        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_P_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C0 and C1. Derived from unc_p_power_state_occupancy.cores_c0",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C0.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C0",
         "Filter": "occ_sel=1",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C0 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c0 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C3. Derived from unc_p_power_state_occupancy.cores_c3",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C3.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C3",
         "Filter": "occ_sel=2",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C3 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c3 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C6 and C7. Derived from unc_p_power_state_occupancy.cores_c6",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C6.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events ",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C6",
         "Filter": "occ_sel=3",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C6 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c6 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "External Prochot. Derived from unc_p_prochot_external_cycles",
+        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip",
         "Counter": "0,1,2,3",
         "EventCode": "0xA",
         "EventName": "UNC_P_PROCHOT_EXTERNAL_CYCLES",
         "MetricExpr": "(UNC_P_PROCHOT_EXTERNAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "prochot_external_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Thermal Strongest Upper Limit Cycles. Derived from unc_p_freq_max_limit_thermal_cycles",
+        "BriefDescription": "Counts the number of cycles when temperature is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
         "EventName": "UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_limit_thermal_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "OS Strongest Upper Limit Cycles. Derived from unc_p_freq_max_os_cycles",
+        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x6",
         "EventName": "UNC_P_FREQ_MAX_OS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_OS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_os_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Power Strongest Upper Limit Cycles. Derived from unc_p_freq_max_power_cycles",
+        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x5",
         "EventName": "UNC_P_FREQ_MAX_POWER_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_POWER_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_power_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Cycles spent changing Frequency. Derived from unc_p_freq_trans_cycles",
+        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x74",
         "EventName": "UNC_P_FREQ_TRANS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_TRANS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_trans_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     }
diff --git a/tools/perf/pmu-events/arch/x86/haswell/uncore.json b/tools/perf/pmu-events/arch/x86/haswell/uncore.json
new file mode 100644
index 000000000000..3ef5c21fef56
--- /dev/null
+++ b/tools/perf/pmu-events/arch/x86/haswell/uncore.json
@@ -0,0 +1,374 @@
+[
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x21",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_EXTERNAL",
+    "BriefDescription": "An external snoop misses in some processor core.",
+    "PublicDescription": "An external snoop misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x41",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which misses in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x81",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_EVICTION",
+    "BriefDescription": "A cross-core snoop resulted from L3 Eviction which misses in some processor core.",
+    "PublicDescription": "A cross-core snoop resulted from L3 Eviction which misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x24",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT_EXTERNAL",
+    "BriefDescription": "An external snoop hits a non-modified line in some processor core.",
+    "PublicDescription": "An external snoop hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x44",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a non-modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x84",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT_EVICTION",
+    "BriefDescription": "A cross-core snoop resulted from L3 Eviction which hits a non-modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop resulted from L3 Eviction which hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x28",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM_EXTERNAL",
+    "BriefDescription": "An external snoop hits a modified line in some processor core.",
+    "PublicDescription": "An external snoop hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x48",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x88",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM_EVICTION",
+    "BriefDescription": "A cross-core snoop resulted from L3 Eviction which hits a modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop resulted from L3 Eviction which hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x11",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_M",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in M-state.",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x21",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_M",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in M-state.",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x41",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.EXTSNP_M",
+    "BriefDescription": "L3 Lookup external snoop request that access cache and found line in M-state.",
+    "PublicDescription": "L3 Lookup external snoop request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x81",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_M",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in M-state.",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x18",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_I",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in I-state.",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x28",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_I",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in I-state.",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x48",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.EXTSNP_I",
+    "BriefDescription": "L3 Lookup external snoop request that access cache and found line in I-state.",
+    "PublicDescription": "L3 Lookup external snoop request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x88",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_I",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in I-state.",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x1f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_MESI",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in any MESI-state.",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in any MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x2f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_MESI",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in MESI-state.",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x4f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.EXTSNP_MESI",
+    "BriefDescription": "L3 Lookup external snoop request that access cache and found line in MESI-state.",
+    "PublicDescription": "L3 Lookup external snoop request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x8f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_MESI",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in MESI-state.",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x86",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_ES",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in E or S-state.",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x46",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.EXTSNP_ES",
+    "BriefDescription": "L3 Lookup external snoop request that access cache and found line in E or S-state.",
+    "PublicDescription": "L3 Lookup external snoop request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x16",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_ES",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in E or S-state.",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x26",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_ES",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in E or S-state.",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Each cycle count number of all Core outgoing valid entries. Such entry is defined as valid from it's allocation till first of IDI0 or DRS0 messages is sent out. Accounts for Coherent and non-coherent traffic.",
+    "PublicDescription": "Each cycle count number of all Core outgoing valid entries. Such entry is defined as valid from it's allocation till first of IDI0 or DRS0 messages is sent out. Accounts for Coherent and non-coherent traffic.",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_REQUESTS.ALL",
+    "BriefDescription": "Total number of Core outgoing entries allocated. Accounts for Coherent and non-coherent traffic.",
+    "PublicDescription": "Total number of Core outgoing entries allocated. Accounts for Coherent and non-coherent traffic.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x20",
+    "EventName": "UNC_ARB_TRK_REQUESTS.WRITES",
+    "BriefDescription": "Number of Writes allocated - any write transactions: full/partials writes and evictions.",
+    "PublicDescription": "Number of Writes allocated - any write transactions: full/partials writes and evictions.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x83",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_OCCUPANCY.All",
+    "BriefDescription": "Each cycle count number of valid entries in Coherency Tracker queue from allocation till deallocation. Aperture requests (snoops) appear as NC decoded internally and become coherent (snoop L3, access memory)",
+    "PublicDescription": "Each cycle count number of valid entries in Coherency Tracker queue from allocation till deallocation. Aperture requests (snoops) appear as NC decoded internally and become coherent (snoop L3, access memory).",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x84",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_REQUESTS.ALL",
+    "BriefDescription": "Number of entries allocated. Account for Any type: e.g. Snoop, Core aperture, etc.",
+    "PublicDescription": "Number of entries allocated. Account for Any type: e.g. Snoop, Core aperture, etc.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "NCU",
+    "EventCode": "0x0",
+    "UMask": "0x01",
+    "EventName": "UNC_CLOCK.SOCKET",
+    "BriefDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "PublicDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "Counter": "FIXED",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  }
+]
\ No newline at end of file
diff --git a/tools/perf/pmu-events/arch/x86/haswellx/uncore-cache.json b/tools/perf/pmu-events/arch/x86/haswellx/uncore-cache.json
index 076459c51d4e..58ed6d33d1f4 100644
--- a/tools/perf/pmu-events/arch/x86/haswellx/uncore-cache.json
+++ b/tools/perf/pmu-events/arch/x86/haswellx/uncore-cache.json
@@ -1,13 +1,13 @@
 [
     {
-        "BriefDescription": "Uncore cache clock ticks. Derived from unc_c_clockticks",
+        "BriefDescription": "Uncore cache clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_C_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch). Derived from unc_c_llc_lookup.any",
+        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch)",
         "Counter": "0,1,2,3",
         "EventCode": "0x34",
         "EventName": "UNC_C_LLC_LOOKUP.ANY",
@@ -18,7 +18,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "M line evictions from LLC (writebacks to memory). Derived from unc_c_llc_victims.m_state",
+        "BriefDescription": "M line evictions from LLC (writebacks to memory)",
         "Counter": "0,1,2,3",
         "EventCode": "0x37",
         "EventName": "UNC_C_LLC_VICTIMS.M_STATE",
@@ -212,7 +212,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "read requests to home agent. Derived from unc_h_requests.reads",
+        "BriefDescription": "read requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS",
@@ -221,7 +221,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "read requests to local home agent. Derived from unc_h_requests.reads_local",
+        "BriefDescription": "read requests to local home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS_LOCAL",
@@ -230,7 +230,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "read requests to remote home agent. Derived from unc_h_requests.reads_remote",
+        "BriefDescription": "read requests to remote home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS_REMOTE",
@@ -239,7 +239,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to home agent. Derived from unc_h_requests.writes",
+        "BriefDescription": "write requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES",
@@ -248,7 +248,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to local home agent. Derived from unc_h_requests.writes_local",
+        "BriefDescription": "write requests to local home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES_LOCAL",
@@ -257,7 +257,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to remote home agent. Derived from unc_h_requests.writes_remote",
+        "BriefDescription": "write requests to remote home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES_REMOTE",
@@ -266,7 +266,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Conflict requests (requests for same address from multiple agents simultaneously). Derived from unc_h_snoop_resp.rspcnflct",
+        "BriefDescription": "Conflict requests (requests for same address from multiple agents simultaneously)",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPCNFLCT",
@@ -275,7 +275,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache along with writeback to memory. Derived from unc_h_snoop_resp.rsp_fwd_wb",
+        "BriefDescription": "M line forwarded from remote cache along with writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSP_FWD_WB",
@@ -285,7 +285,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache with no writeback to memory. Derived from unc_h_snoop_resp.rspifwd",
+        "BriefDescription": "M line forwarded from remote cache with no writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPIFWD",
@@ -295,7 +295,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line response from remote cache. Derived from unc_h_snoop_resp.rsps",
+        "BriefDescription": "Shared line response from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPS",
@@ -305,7 +305,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line forwarded from remote cache. Derived from unc_h_snoop_resp.rspsfwd",
+        "BriefDescription": "Shared line forwarded from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPSFWD",
diff --git a/tools/perf/pmu-events/arch/x86/haswellx/uncore-interconnect.json b/tools/perf/pmu-events/arch/x86/haswellx/uncore-interconnect.json
index 39387f7909b2..824961318c1e 100644
--- a/tools/perf/pmu-events/arch/x86/haswellx/uncore-interconnect.json
+++ b/tools/perf/pmu-events/arch/x86/haswellx/uncore-interconnect.json
@@ -1,6 +1,6 @@
 [
     {
-        "BriefDescription": "QPI clock ticks. Derived from unc_q_clockticks",
+        "BriefDescription": "QPI clock ticks",
         "Counter": "0,1,2,3",
         "EventCode": "0x14",
         "EventName": "UNC_Q_CLOCKTICKS",
@@ -10,7 +10,7 @@
     {
         "BriefDescription": "Number of data flits transmitted . Derived from unc_q_txl_flits_g0.data",
         "Counter": "0,1,2,3",
-        "EventName": "UNC_Q_TxL_FLITS_G0.DATA",
+        "EventName": "QPI_DATA_BANDWIDTH_TX",
         "PerPkg": "1",
         "ScaleUnit": "8Bytes",
         "UMask": "0x2",
@@ -19,7 +19,7 @@
     {
         "BriefDescription": "Number of non data (control) flits transmitted . Derived from unc_q_txl_flits_g0.non_data",
         "Counter": "0,1,2,3",
-        "EventName": "UNC_Q_TxL_FLITS_G0.NON_DATA",
+        "EventName": "QPI_CTL_BANDWIDTH_TX",
         "PerPkg": "1",
         "ScaleUnit": "8Bytes",
         "UMask": "0x4",
diff --git a/tools/perf/pmu-events/arch/x86/haswellx/uncore-memory.json b/tools/perf/pmu-events/arch/x86/haswellx/uncore-memory.json
index d17dc235f734..66eed399724c 100644
--- a/tools/perf/pmu-events/arch/x86/haswellx/uncore-memory.json
+++ b/tools/perf/pmu-events/arch/x86/haswellx/uncore-memory.json
@@ -3,7 +3,7 @@
         "BriefDescription": "read requests to memory controller. Derived from unc_m_cas_count.rd",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.RD",
+        "EventName": "LLC_MISSES.MEM_READ",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0x3",
@@ -13,48 +13,51 @@
         "BriefDescription": "write requests to memory controller. Derived from unc_m_cas_count.wr",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.WR",
+        "EventName": "LLC_MISSES.MEM_WRITE",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0xC",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory controller clock ticks. Derived from unc_m_clockticks",
+        "BriefDescription": "Memory controller clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_M_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode. Derived from unc_m_power_channel_ppd",
+        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x85",
         "EventName": "UNC_M_POWER_CHANNEL_PPD",
         "MetricExpr": "(UNC_M_POWER_CHANNEL_PPD / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_channel_ppd %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles all ranks are in critical thermal throttle. Derived from unc_m_power_critical_throttle_cycles",
+        "BriefDescription": "Cycles all ranks are in critical thermal throttle",
         "Counter": "0,1,2,3",
         "EventCode": "0x86",
         "EventName": "UNC_M_POWER_CRITICAL_THROTTLE_CYCLES",
         "MetricExpr": "(UNC_M_POWER_CRITICAL_THROTTLE_CYCLES / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_critical_throttle_cycles %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles Memory is in self refresh power mode. Derived from unc_m_power_self_refresh",
+        "BriefDescription": "Cycles Memory is in self refresh power mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x43",
         "EventName": "UNC_M_POWER_SELF_REFRESH",
         "MetricExpr": "(UNC_M_POWER_SELF_REFRESH / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_self_refresh %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charges due to page misses. Derived from unc_m_pre_count.page_miss",
+        "BriefDescription": "Pre-charges due to page misses",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.PAGE_MISS",
@@ -63,7 +66,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charge for reads. Derived from unc_m_pre_count.rd",
+        "BriefDescription": "Pre-charge for reads",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.RD",
@@ -72,7 +75,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Pre-charge for writes. Derived from unc_m_pre_count.wr",
+        "BriefDescription": "Pre-charge for writes",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.WR",
diff --git a/tools/perf/pmu-events/arch/x86/haswellx/uncore-power.json b/tools/perf/pmu-events/arch/x86/haswellx/uncore-power.json
index b44d43088bbb..dd1b95655d1d 100644
--- a/tools/perf/pmu-events/arch/x86/haswellx/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/haswellx/uncore-power.json
@@ -1,83 +1,91 @@
 [
     {
-        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events. Derived from unc_p_clockticks",
+        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_P_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C0 and C1. Derived from unc_p_power_state_occupancy.cores_c0",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C0.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C0",
         "Filter": "occ_sel=1",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C0 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c0 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C3. Derived from unc_p_power_state_occupancy.cores_c3",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C3.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C3",
         "Filter": "occ_sel=2",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C3 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c3 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "C6 and C7. Derived from unc_p_power_state_occupancy.cores_c6",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C6.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events ",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C6",
         "Filter": "occ_sel=3",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C6 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c6 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "External Prochot. Derived from unc_p_prochot_external_cycles",
+        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip",
         "Counter": "0,1,2,3",
         "EventCode": "0xA",
         "EventName": "UNC_P_PROCHOT_EXTERNAL_CYCLES",
         "MetricExpr": "(UNC_P_PROCHOT_EXTERNAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "prochot_external_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Thermal Strongest Upper Limit Cycles. Derived from unc_p_freq_max_limit_thermal_cycles",
+        "BriefDescription": "Counts the number of cycles when temperature is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
         "EventName": "UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_limit_thermal_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "OS Strongest Upper Limit Cycles. Derived from unc_p_freq_max_os_cycles",
+        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x6",
         "EventName": "UNC_P_FREQ_MAX_OS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_OS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_os_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Power Strongest Upper Limit Cycles. Derived from unc_p_freq_max_power_cycles",
+        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x5",
         "EventName": "UNC_P_FREQ_MAX_POWER_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_POWER_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_power_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Cycles spent changing Frequency. Derived from unc_p_freq_trans_cycles",
+        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x74",
         "EventName": "UNC_P_FREQ_TRANS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_TRANS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_trans_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     }
diff --git a/tools/perf/pmu-events/arch/x86/ivybridge/uncore.json b/tools/perf/pmu-events/arch/x86/ivybridge/uncore.json
new file mode 100644
index 000000000000..42c70eed05a2
--- /dev/null
+++ b/tools/perf/pmu-events/arch/x86/ivybridge/uncore.json
@@ -0,0 +1,314 @@
+[
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x01",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS",
+    "BriefDescription": "A snoop misses in some processor core.",
+    "PublicDescription": "A snoop misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x02",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.INVAL",
+    "BriefDescription": "A snoop invalidates a non-modified line in some processor core.",
+    "PublicDescription": "A snoop invalidates a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x04",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT",
+    "BriefDescription": "A snoop hits a non-modified line in some processor core.",
+    "PublicDescription": "A snoop hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x08",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM",
+    "BriefDescription": "A snoop hits a modified line in some processor core.",
+    "PublicDescription": "A snoop hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x10",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.INVAL_M",
+    "BriefDescription": "A snoop invalidates a modified line in some processor core.",
+    "PublicDescription": "A snoop invalidates a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x20",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.EXTERNAL_FILTER",
+    "BriefDescription": "Filter on cross-core snoops initiated by this Cbox due to external snoop request.",
+    "PublicDescription": "Filter on cross-core snoops initiated by this Cbox due to external snoop request.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x40",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.XCORE_FILTER",
+    "BriefDescription": "Filter on cross-core snoops initiated by this Cbox due to processor core memory request.",
+    "PublicDescription": "Filter on cross-core snoops initiated by this Cbox due to processor core memory request.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x80",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.EVICTION_FILTER",
+    "BriefDescription": "Filter on cross-core snoops initiated by this Cbox due to LLC eviction.",
+    "PublicDescription": "Filter on cross-core snoops initiated by this Cbox due to LLC eviction.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x01",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.M",
+    "BriefDescription": "LLC lookup request that access cache and found line in M-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x02",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.E",
+    "BriefDescription": "LLC lookup request that access cache and found line in E-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in E-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x04",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.S",
+    "BriefDescription": "LLC lookup request that access cache and found line in S-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x08",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.I",
+    "BriefDescription": "LLC lookup request that access cache and found line in I-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x10",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_FILTER",
+    "BriefDescription": "Filter on processor core initiated cacheable read requests.",
+    "PublicDescription": "Filter on processor core initiated cacheable read requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x20",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_FILTER",
+    "BriefDescription": "Filter on processor core initiated cacheable write requests.",
+    "PublicDescription": "Filter on processor core initiated cacheable write requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x40",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.EXTSNP_FILTER",
+    "BriefDescription": "Filter on external snoop requests.",
+    "PublicDescription": "Filter on external snoop requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x80",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_REQUEST_FILTER",
+    "BriefDescription": "Filter on any IRQ or IPQ initiated requests including uncacheable, non-coherent requests.",
+    "PublicDescription": "Filter on any IRQ or IPQ initiated requests including uncacheable, non-coherent requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Counts cycles weighted by the number of requests waiting for data returning from the memory controller. Accounts for coherent and non-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "PublicDescription": "Counts cycles weighted by the number of requests waiting for data returning from the memory controller. Accounts for coherent and non-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x81",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_REQUESTS.ALL",
+    "BriefDescription": "Counts the number of coherent and in-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "PublicDescription": "Counts the number of coherent and in-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x81",
+    "UMask": "0x20",
+    "EventName": "UNC_ARB_TRK_REQUESTS.WRITES",
+    "BriefDescription": "Counts the number of allocated write entries, include full, partial, and LLC evictions.",
+    "PublicDescription": "Counts the number of allocated write entries, include full, partial, and LLC evictions.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x81",
+    "UMask": "0x80",
+    "EventName": "UNC_ARB_TRK_REQUESTS.EVICTIONS",
+    "BriefDescription": "Counts the number of LLC evictions allocated.",
+    "PublicDescription": "Counts the number of LLC evictions allocated.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x83",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Cycles weighted by number of requests pending in Coherency Tracker.",
+    "PublicDescription": "Cycles weighted by number of requests pending in Coherency Tracker.",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x84",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_REQUESTS.ALL",
+    "BriefDescription": "Number of requests allocated in Coherency Tracker.",
+    "PublicDescription": "Number of requests allocated in Coherency Tracker.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.CYCLES_WITH_ANY_REQUEST",
+    "BriefDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "PublicDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "Counter": "0,1",
+    "CounterMask": "1",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.CYCLES_OVER_HALF_FULL",
+    "BriefDescription": "Cycles with at least half of the requests outstanding are waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "PublicDescription": "Cycles with at least half of the requests outstanding are waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "Counter": "0,1",
+    "CounterMask": "10",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x0",
+    "UMask": "0x01",
+    "EventName": "UNC_CLOCK.SOCKET",
+    "BriefDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "PublicDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "Counter": "Fixed",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x06",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ES",
+    "BriefDescription": "LLC lookup request that access cache and found line in E-state or S-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in E-state or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  }
+]
\ No newline at end of file
diff --git a/tools/perf/pmu-events/arch/x86/ivytown/uncore-cache.json b/tools/perf/pmu-events/arch/x86/ivytown/uncore-cache.json
index 2efdc6772e0b..267410594833 100644
--- a/tools/perf/pmu-events/arch/x86/ivytown/uncore-cache.json
+++ b/tools/perf/pmu-events/arch/x86/ivytown/uncore-cache.json
@@ -1,13 +1,13 @@
 [
     {
-        "BriefDescription": "Uncore cache clock ticks. Derived from unc_c_clockticks",
+        "BriefDescription": "Uncore cache clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_C_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch). Derived from unc_c_llc_lookup.any",
+        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch)",
         "Counter": "0,1",
         "EventCode": "0x34",
         "EventName": "UNC_C_LLC_LOOKUP.ANY",
@@ -18,7 +18,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "M line evictions from LLC (writebacks to memory). Derived from unc_c_llc_victims.m_state",
+        "BriefDescription": "M line evictions from LLC (writebacks to memory)",
         "Counter": "0,1",
         "EventCode": "0x37",
         "EventName": "UNC_C_LLC_VICTIMS.M_STATE",
@@ -237,7 +237,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "Occupancy for all LLC misses that are addressed to local memory. Derived from unc_c_tor_occupancy.miss_local",
+        "BriefDescription": "Occupancy for all LLC misses that are addressed to local memory",
         "EventCode": "0x36",
         "EventName": "UNC_C_TOR_OCCUPANCY.MISS_LOCAL",
         "PerPkg": "1",
@@ -254,7 +254,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "Occupancy for all LLC misses that are addressed to remote memory. Derived from unc_c_tor_occupancy.miss_remote",
+        "BriefDescription": "Occupancy for all LLC misses that are addressed to remote memory",
         "EventCode": "0x36",
         "EventName": "UNC_C_TOR_OCCUPANCY.MISS_REMOTE",
         "PerPkg": "1",
@@ -262,7 +262,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "Read requests to home agent. Derived from unc_h_requests.reads",
+        "BriefDescription": "Read requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS",
@@ -271,7 +271,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Write requests to home agent. Derived from unc_h_requests.writes",
+        "BriefDescription": "Write requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES",
@@ -280,7 +280,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache along with writeback to memory. Derived from unc_h_snoop_resp.rsp_fwd_wb",
+        "BriefDescription": "M line forwarded from remote cache along with writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSP_FWD_WB",
@@ -290,7 +290,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "M line forwarded from remote cache with no writeback to memory. Derived from unc_h_snoop_resp.rspifwd",
+        "BriefDescription": "M line forwarded from remote cache with no writeback to memory",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPIFWD",
@@ -300,7 +300,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line response from remote cache. Derived from unc_h_snoop_resp.rsps",
+        "BriefDescription": "Shared line response from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPS",
@@ -310,7 +310,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "Shared line forwarded from remote cache. Derived from unc_h_snoop_resp.rspsfwd",
+        "BriefDescription": "Shared line forwarded from remote cache",
         "Counter": "0,1,2,3",
         "EventCode": "0x21",
         "EventName": "UNC_H_SNOOP_RESP.RSPSFWD",
diff --git a/tools/perf/pmu-events/arch/x86/ivytown/uncore-interconnect.json b/tools/perf/pmu-events/arch/x86/ivytown/uncore-interconnect.json
index d7e2fda1d695..b798a860bc81 100644
--- a/tools/perf/pmu-events/arch/x86/ivytown/uncore-interconnect.json
+++ b/tools/perf/pmu-events/arch/x86/ivytown/uncore-interconnect.json
@@ -1,6 +1,6 @@
 [
     {
-        "BriefDescription": "QPI clock ticks. Use to get percentages for QPI cycles events. Derived from unc_q_clockticks",
+        "BriefDescription": "QPI clock ticks. Use to get percentages for QPI cycles events",
         "Counter": "0,1,2,3",
         "EventCode": "0x14",
         "EventName": "UNC_Q_CLOCKTICKS",
@@ -8,25 +8,27 @@
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Cycles where receiving QPI link is in half-width mode. Derived from unc_q_rxl0p_power_cycles",
+        "BriefDescription": "Cycles where receiving QPI link is in half-width mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x10",
         "EventName": "UNC_Q_RxL0P_POWER_CYCLES",
         "MetricExpr": "(UNC_Q_RxL0P_POWER_CYCLES / UNC_Q_CLOCKTICKS) * 100.",
+        "MetricName": "rxl0p_power_cycles %",
         "PerPkg": "1",
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Cycles where transmitting QPI link is in half-width mode. Derived from unc_q_txl0p_power_cycles",
+        "BriefDescription": "Cycles where transmitting QPI link is in half-width mode",
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_Q_TxL0P_POWER_CYCLES",
         "MetricExpr": "(UNC_Q_TxL0P_POWER_CYCLES / UNC_Q_CLOCKTICKS) * 100.",
+        "MetricName": "txl0p_power_cycles %",
         "PerPkg": "1",
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Number of data flits transmitted . Derived from unc_q_txl_flits_g0.data",
+        "BriefDescription": "Number of data flits transmitted ",
         "Counter": "0,1,2,3",
         "EventName": "UNC_Q_TxL_FLITS_G0.DATA",
         "PerPkg": "1",
@@ -35,7 +37,7 @@
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Number of non data (control) flits transmitted . Derived from unc_q_txl_flits_g0.non_data",
+        "BriefDescription": "Number of non data (control) flits transmitted ",
         "Counter": "0,1,2,3",
         "EventName": "UNC_Q_TxL_FLITS_G0.NON_DATA",
         "PerPkg": "1",
diff --git a/tools/perf/pmu-events/arch/x86/ivytown/uncore-memory.json b/tools/perf/pmu-events/arch/x86/ivytown/uncore-memory.json
index ac4ad4d6357b..df4b43294fa0 100644
--- a/tools/perf/pmu-events/arch/x86/ivytown/uncore-memory.json
+++ b/tools/perf/pmu-events/arch/x86/ivytown/uncore-memory.json
@@ -1,6 +1,6 @@
 [
     {
-        "BriefDescription": "Memory page activates for reads and writes. Derived from unc_m_act_count.rd",
+        "BriefDescription": "Memory page activates for reads and writes",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_M_ACT_COUNT.RD",
@@ -13,7 +13,7 @@
         "BriefDescription": "Read requests to memory controller. Derived from unc_m_cas_count.rd",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.RD",
+        "EventName": "LLC_MISSES.MEM_READ",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0x3",
@@ -23,48 +23,51 @@
         "BriefDescription": "Write requests to memory controller. Derived from unc_m_cas_count.wr",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.WR",
+        "EventName": "LLC_MISSES.MEM_WRITE",
         "PerPkg": "1",
         "ScaleUnit": "64Bytes",
         "UMask": "0xC",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory controller clock ticks. Use to generate percentages for memory controller CYCLES events. Derived from unc_m_clockticks",
+        "BriefDescription": "Memory controller clock ticks. Use to generate percentages for memory controller CYCLES events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_M_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode. Derived from unc_m_power_channel_ppd",
+        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x85",
         "EventName": "UNC_M_POWER_CHANNEL_PPD",
         "MetricExpr": "(UNC_M_POWER_CHANNEL_PPD / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_channel_ppd %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles all ranks are in critical thermal throttle. Derived from unc_m_power_critical_throttle_cycles",
+        "BriefDescription": "Cycles all ranks are in critical thermal throttle",
         "Counter": "0,1,2,3",
         "EventCode": "0x86",
         "EventName": "UNC_M_POWER_CRITICAL_THROTTLE_CYCLES",
         "MetricExpr": "(UNC_M_POWER_CRITICAL_THROTTLE_CYCLES / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_critical_throttle_cycles %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles Memory is in self refresh power mode. Derived from unc_m_power_self_refresh",
+        "BriefDescription": "Cycles Memory is in self refresh power mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x43",
         "EventName": "UNC_M_POWER_SELF_REFRESH",
         "MetricExpr": "(UNC_M_POWER_SELF_REFRESH / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_self_refresh %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory page conflicts. Derived from unc_m_pre_count.page_miss",
+        "BriefDescription": "Memory page conflicts",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.PAGE_MISS",
diff --git a/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json b/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json
index dc2586db0dfc..d40498f2cb1e 100644
--- a/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json
@@ -1,44 +1,48 @@
 [
     {
-        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events. Derived from unc_p_clockticks",
+        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_P_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band0=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band0_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band0=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xb",
         "EventName": "UNC_P_FREQ_BAND0_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND0_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band0_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band1=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band1_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band1=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xc",
         "EventName": "UNC_P_FREQ_BAND1_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND1_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band1_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band2=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band2_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band2=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_P_FREQ_BAND2_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND2_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band2_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band3=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band3_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band3=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xe",
         "EventName": "UNC_P_FREQ_BAND3_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND3_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band3_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -49,6 +53,7 @@
         "EventName": "UNC_P_FREQ_BAND0_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND0_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band0_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -59,6 +64,7 @@
         "EventName": "UNC_P_FREQ_BAND1_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND1_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band1_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -69,6 +75,7 @@
         "EventName": "UNC_P_FREQ_BAND2_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND2_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band2_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -79,90 +86,100 @@
         "EventName": "UNC_P_FREQ_BAND3_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND3_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band3_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in the chosen C-State.  It can be used by itself to get the average number of cores in that C-state with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details. Derived from unc_p_power_state_occupancy.cores_c0",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C0.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C0",
         "Filter": "occ_sel=1",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C0 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c0 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in the chosen C-State.  It can be used by itself to get the average number of cores in that C-state with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details. Derived from unc_p_power_state_occupancy.cores_c3",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C3.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C3",
         "Filter": "occ_sel=2",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C3 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c3 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in the chosen C-State.  It can be used by itself to get the average number of cores in that C-state with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details. Derived from unc_p_power_state_occupancy.cores_c6",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C6.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events ",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C6",
         "Filter": "occ_sel=3",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C6 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c6 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip. Derived from unc_p_prochot_external_cycles",
+        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip",
         "Counter": "0,1,2,3",
         "EventCode": "0xa",
         "EventName": "UNC_P_PROCHOT_EXTERNAL_CYCLES",
         "MetricExpr": "(UNC_P_PROCHOT_EXTERNAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "prochot_external_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when thermal conditions are the upper limit on frequency.  This is related to the THERMAL_THROTTLE CYCLES_ABOVE_TEMP event, which always counts cycles when we are above the thermal temperature.  This event (STRONGEST_UPPER_LIMIT) is sampled at the output of the algorithm that determines the actual frequency, while THERMAL_THROTTLE looks at the input. Derived from unc_p_freq_max_limit_thermal_cycles",
+        "BriefDescription": "Counts the number of cycles when temperature is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
         "EventName": "UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_limit_thermal_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency. Derived from unc_p_freq_max_os_cycles",
+        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x6",
         "EventName": "UNC_P_FREQ_MAX_OS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_OS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_os_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency. Derived from unc_p_freq_max_power_cycles",
+        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x5",
         "EventName": "UNC_P_FREQ_MAX_POWER_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_POWER_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_power_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency. Derived from unc_p_freq_max_current_cycles",
+        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x7",
         "EventName": "UNC_P_FREQ_MAX_CURRENT_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_CURRENT_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_current_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when the system is changing frequency.  This can not be filtered by thread ID.  One can also use it with the occupancy counter that monitors number of threads in C0 to estimate the performance impact that frequency transitions had on the system. Derived from unc_p_freq_trans_cycles",
+        "BriefDescription": "Cycles spent changing Frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x60",
         "EventName": "UNC_P_FREQ_TRANS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_TRANS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_trans_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -173,6 +190,7 @@
         "EventName": "UNC_P_FREQ_GE_1200MHZ_CYCLES",
         "Filter": "filter_band0=1200",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -183,6 +201,7 @@
         "EventName": "UNC_P_FREQ_GE_2000MHZ_CYCLES",
         "Filter": "filter_band1=2000",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -193,6 +212,7 @@
         "EventName": "UNC_P_FREQ_GE_3000MHZ_CYCLES",
         "Filter": "filter_band2=3000",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -203,6 +223,7 @@
         "EventName": "UNC_P_FREQ_GE_4000MHZ_CYCLES",
         "Filter": "filter_band3=4000",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -213,6 +234,7 @@
         "EventName": "UNC_P_FREQ_GE_1200MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band0=1200",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -223,6 +245,7 @@
         "EventName": "UNC_P_FREQ_GE_2000MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band1=2000",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -233,6 +256,7 @@
         "EventName": "UNC_P_FREQ_GE_3000MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band2=4000",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -243,6 +267,7 @@
         "EventName": "UNC_P_FREQ_GE_4000MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band3=4000",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     }
diff --git a/tools/perf/pmu-events/arch/x86/jaketown/uncore-cache.json b/tools/perf/pmu-events/arch/x86/jaketown/uncore-cache.json
index 2f23cf0129e7..3fa61d962607 100644
--- a/tools/perf/pmu-events/arch/x86/jaketown/uncore-cache.json
+++ b/tools/perf/pmu-events/arch/x86/jaketown/uncore-cache.json
@@ -1,13 +1,13 @@
 [
     {
-        "BriefDescription": "Uncore cache clock ticks. Derived from unc_c_clockticks",
+        "BriefDescription": "Uncore cache clock ticks",
         "Counter": "0,1,2,3",
         "EventName": "UNC_C_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch). Derived from unc_c_llc_lookup.any",
+        "BriefDescription": "All LLC Misses (code+ data rd + data wr - including demand and prefetch)",
         "Counter": "0,1",
         "EventCode": "0x34",
         "EventName": "UNC_C_LLC_LOOKUP.ANY",
@@ -18,7 +18,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "M line evictions from LLC (writebacks to memory). Derived from unc_c_llc_victims.m_state",
+        "BriefDescription": "M line evictions from LLC (writebacks to memory)",
         "Counter": "0,1",
         "EventCode": "0x37",
         "EventName": "UNC_C_LLC_VICTIMS.M_STATE",
@@ -171,11 +171,12 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "Occupancy counter for all LLC misses; we divide this by UNC_C_CLOCKTICKS to get average Q depth. Derived from unc_c_tor_occupancy.miss_all",
+        "BriefDescription": "Occupancy counter for all LLC misses; we divide this by UNC_C_CLOCKTICKS to get average Q depth",
         "EventCode": "0x36",
         "EventName": "UNC_C_TOR_OCCUPANCY.MISS_ALL",
         "Filter": "filter_opc=0x182",
         "MetricExpr": "(UNC_C_TOR_OCCUPANCY.MISS_ALL / UNC_C_CLOCKTICKS) * 100.",
+        "MetricName": "tor_occupancy.miss_all %",
         "PerPkg": "1",
         "UMask": "0xa",
         "Unit": "CBO"
@@ -189,7 +190,7 @@
         "Unit": "CBO"
     },
     {
-        "BriefDescription": "read requests to home agent. Derived from unc_h_requests.reads",
+        "BriefDescription": "read requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.READS",
@@ -198,7 +199,7 @@
         "Unit": "HA"
     },
     {
-        "BriefDescription": "write requests to home agent. Derived from unc_h_requests.writes",
+        "BriefDescription": "write requests to home agent",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_H_REQUESTS.WRITES",
diff --git a/tools/perf/pmu-events/arch/x86/jaketown/uncore-interconnect.json b/tools/perf/pmu-events/arch/x86/jaketown/uncore-interconnect.json
index 63351876eb57..1b53c0e609e3 100644
--- a/tools/perf/pmu-events/arch/x86/jaketown/uncore-interconnect.json
+++ b/tools/perf/pmu-events/arch/x86/jaketown/uncore-interconnect.json
@@ -1,6 +1,6 @@
 [
     {
-        "BriefDescription": "QPI clock ticks. Used to get percentages of QPI cycles events. Derived from unc_q_clockticks",
+        "BriefDescription": "QPI clock ticks. Used to get percentages of QPI cycles events",
         "Counter": "0,1,2,3",
         "EventCode": "0x14",
         "EventName": "UNC_Q_CLOCKTICKS",
@@ -8,25 +8,27 @@
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Cycles where receiving QPI link is in half-width mode. Derived from unc_q_rxl0p_power_cycles",
+        "BriefDescription": "Cycles where receiving QPI link is in half-width mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x10",
         "EventName": "UNC_Q_RxL0P_POWER_CYCLES",
         "MetricExpr": "(UNC_Q_RxL0P_POWER_CYCLES / UNC_Q_CLOCKTICKS) * 100.",
+        "MetricName": "rxl0p_power_cycles %",
         "PerPkg": "1",
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Cycles where transmitting QPI link is in half-width mode. Derived from unc_q_txl0p_power_cycles",
+        "BriefDescription": "Cycles where transmitting QPI link is in half-width mode",
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_Q_TxL0P_POWER_CYCLES",
         "MetricExpr": "(UNC_Q_TxL0P_POWER_CYCLES / UNC_Q_CLOCKTICKS) * 100.",
+        "MetricName": "txl0p_power_cycles %",
         "PerPkg": "1",
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Number of data flits transmitted . Derived from unc_q_txl_flits_g0.data",
+        "BriefDescription": "Number of data flits transmitted ",
         "Counter": "0,1,2,3",
         "EventName": "UNC_Q_TxL_FLITS_G0.DATA",
         "PerPkg": "1",
@@ -35,7 +37,7 @@
         "Unit": "QPI LL"
     },
     {
-        "BriefDescription": "Number of non data (control) flits transmitted . Derived from unc_q_txl_flits_g0.non_data",
+        "BriefDescription": "Number of non data (control) flits transmitted ",
         "Counter": "0,1,2,3",
         "EventName": "UNC_Q_TxL_FLITS_G0.NON_DATA",
         "PerPkg": "1",
diff --git a/tools/perf/pmu-events/arch/x86/jaketown/uncore-memory.json b/tools/perf/pmu-events/arch/x86/jaketown/uncore-memory.json
index e2cf6daa7b37..8551cebeba23 100644
--- a/tools/perf/pmu-events/arch/x86/jaketown/uncore-memory.json
+++ b/tools/perf/pmu-events/arch/x86/jaketown/uncore-memory.json
@@ -1,6 +1,6 @@
 [
     {
-        "BriefDescription": "Memory page activates. Derived from unc_m_act_count",
+        "BriefDescription": "Memory page activates",
         "Counter": "0,1,2,3",
         "EventCode": "0x1",
         "EventName": "UNC_M_ACT_COUNT",
@@ -11,7 +11,7 @@
         "BriefDescription": "read requests to memory controller. Derived from unc_m_cas_count.rd",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.RD",
+        "EventName": "LLC_MISSES.MEM_READ",
         "PerPkg": "1",
         "UMask": "0x3",
         "Unit": "iMC"
@@ -20,47 +20,50 @@
         "BriefDescription": "write requests to memory controller. Derived from unc_m_cas_count.wr",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
-        "EventName": "UNC_M_CAS_COUNT.WR",
+        "EventName": "LLC_MISSES.MEM_WRITE",
         "PerPkg": "1",
         "UMask": "0xc",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory controller clock ticks. Used to get percentages of memory controller cycles events. Derived from unc_m_clockticks",
+        "BriefDescription": "Memory controller clock ticks. Used to get percentages of memory controller cycles events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_M_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode. Derived from unc_m_power_channel_ppd",
+        "BriefDescription": "Cycles where DRAM ranks are in power down (CKE) mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x85",
         "EventName": "UNC_M_POWER_CHANNEL_PPD",
         "MetricExpr": "(UNC_M_POWER_CHANNEL_PPD / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_channel_ppd %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles all ranks are in critical thermal throttle. Derived from unc_m_power_critical_throttle_cycles",
+        "BriefDescription": "Cycles all ranks are in critical thermal throttle",
         "Counter": "0,1,2,3",
         "EventCode": "0x86",
         "EventName": "UNC_M_POWER_CRITICAL_THROTTLE_CYCLES",
         "MetricExpr": "(UNC_M_POWER_CRITICAL_THROTTLE_CYCLES / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_critical_throttle_cycles %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Cycles Memory is in self refresh power mode. Derived from unc_m_power_self_refresh",
+        "BriefDescription": "Cycles Memory is in self refresh power mode",
         "Counter": "0,1,2,3",
         "EventCode": "0x43",
         "EventName": "UNC_M_POWER_SELF_REFRESH",
         "MetricExpr": "(UNC_M_POWER_SELF_REFRESH / UNC_M_CLOCKTICKS) * 100.",
+        "MetricName": "power_self_refresh %",
         "PerPkg": "1",
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Memory page conflicts. Derived from unc_m_pre_count.page_miss",
+        "BriefDescription": "Memory page conflicts",
         "Counter": "0,1,2,3",
         "EventCode": "0x2",
         "EventName": "UNC_M_PRE_COUNT.PAGE_MISS",
@@ -69,7 +72,7 @@
         "Unit": "iMC"
     },
     {
-        "BriefDescription": "Occupancy counter for memory read queue. Derived from unc_m_rpq_occupancy",
+        "BriefDescription": "Occupancy counter for memory read queue",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_M_RPQ_OCCUPANCY",
diff --git a/tools/perf/pmu-events/arch/x86/jaketown/uncore-power.json b/tools/perf/pmu-events/arch/x86/jaketown/uncore-power.json
index bbe36d547386..16034bfd06dd 100644
--- a/tools/perf/pmu-events/arch/x86/jaketown/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/jaketown/uncore-power.json
@@ -1,44 +1,48 @@
 [
     {
-        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events. Derived from unc_p_clockticks",
+        "BriefDescription": "PCU clock ticks. Use to get percentages of PCU cycles events",
         "Counter": "0,1,2,3",
         "EventName": "UNC_P_CLOCKTICKS",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band0=XXX with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band0_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band0=XXX with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xb",
         "EventName": "UNC_P_FREQ_BAND0_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND0_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band0_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band1=XXX with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band1_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band1=XXX with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xc",
         "EventName": "UNC_P_FREQ_BAND1_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND1_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band1_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band2=XXX with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band2_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band2=XXX with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_P_FREQ_BAND2_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND2_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band2_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band3=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency. Derived from unc_p_freq_band3_cycles",
+        "BriefDescription": "Counts the number of cycles that the uncore was running at a frequency greater than or equal to the frequency that is configured in the filter.  (filter_band3=XXX, with XXX in 100Mhz units). One can also use inversion (filter_inv=1) to track cycles when we were less than the configured frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0xe",
         "EventName": "UNC_P_FREQ_BAND3_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_BAND3_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band3_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -49,6 +53,7 @@
         "EventName": "UNC_P_FREQ_BAND0_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND0_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band0_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -59,6 +64,7 @@
         "EventName": "UNC_P_FREQ_BAND1_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND1_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band1_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -69,6 +75,7 @@
         "EventName": "UNC_P_FREQ_BAND2_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND2_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band2_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -79,89 +86,99 @@
         "EventName": "UNC_P_FREQ_BAND3_TRANSITIONS",
         "Filter": "edge=1",
         "MetricExpr": "(UNC_P_FREQ_BAND3_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_band3_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C0.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details. Derived from unc_p_power_state_occupancy.cores_c0",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C0.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C0",
         "Filter": "occ_sel=1",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C0 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c0 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C3.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details. Derived from unc_p_power_state_occupancy.cores_c3",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C3.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events and occupancy triggering to capture other details",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C3",
         "Filter": "occ_sel=2",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C3 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c3 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C6.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events . Derived from unc_p_power_state_occupancy.cores_c6",
+        "BriefDescription": "This is an occupancy event that tracks the number of cores that are in C6.  It can be used by itself to get the average number of cores in C0, with threshholding to generate histograms, or with other PCU events ",
         "Counter": "0,1,2,3",
         "EventCode": "0x80",
         "EventName": "UNC_P_POWER_STATE_OCCUPANCY.CORES_C6",
         "Filter": "occ_sel=3",
         "MetricExpr": "(UNC_P_POWER_STATE_OCCUPANCY.CORES_C6 / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "power_state_occupancy.cores_c6 %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip. Derived from unc_p_prochot_external_cycles",
+        "BriefDescription": "Counts the number of cycles that we are in external PROCHOT mode.  This mode is triggered when a sensor off the die determines that something off-die (like DRAM) is too hot and must throttle to avoid damaging the chip",
         "Counter": "0,1,2,3",
         "EventCode": "0xa",
         "EventName": "UNC_P_PROCHOT_EXTERNAL_CYCLES",
         "MetricExpr": "(UNC_P_PROCHOT_EXTERNAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "prochot_external_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when temperature is the upper limit on frequency. Derived from unc_p_freq_max_limit_thermal_cycles",
+        "BriefDescription": "Counts the number of cycles when temperature is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x4",
         "EventName": "UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_LIMIT_THERMAL_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_limit_thermal_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency. Derived from unc_p_freq_max_os_cycles",
+        "BriefDescription": "Counts the number of cycles when the OS is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x6",
         "EventName": "UNC_P_FREQ_MAX_OS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_OS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_os_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency. Derived from unc_p_freq_max_power_cycles",
+        "BriefDescription": "Counts the number of cycles when power is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x5",
         "EventName": "UNC_P_FREQ_MAX_POWER_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_POWER_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_power_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency. Derived from unc_p_freq_max_current_cycles",
+        "BriefDescription": "Counts the number of cycles when current is the upper limit on frequency",
         "Counter": "0,1,2,3",
         "EventCode": "0x7",
         "EventName": "UNC_P_FREQ_MAX_CURRENT_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_MAX_CURRENT_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_max_current_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
     {
-        "BriefDescription": "Cycles spent changing Frequency. Derived from unc_p_freq_trans_cycles",
+        "BriefDescription": "Cycles spent changing Frequency",
         "Counter": "0,1,2,3",
         "EventName": "UNC_P_FREQ_TRANS_CYCLES",
         "MetricExpr": "(UNC_P_FREQ_TRANS_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_trans_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -172,6 +189,7 @@
         "EventName": "UNC_P_FREQ_GE_1200MHZ_CYCLES",
         "Filter": "filter_band0=1200",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -182,6 +200,7 @@
         "EventName": "UNC_P_FREQ_GE_2000MHZ_CYCLES",
         "Filter": "filter_band1=2000",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -192,6 +211,7 @@
         "EventName": "UNC_P_FREQ_GE_3000MHZ_CYCLES",
         "Filter": "filter_band2=3000",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -202,6 +222,7 @@
         "EventName": "UNC_P_FREQ_GE_4000MHZ_CYCLES",
         "Filter": "filter_band3=4000",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -212,6 +233,7 @@
         "EventName": "UNC_P_FREQ_GE_1200MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band0=1200",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -222,6 +244,7 @@
         "EventName": "UNC_P_FREQ_GE_2000MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band1=2000",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -232,6 +255,7 @@
         "EventName": "UNC_P_FREQ_GE_3000MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band2=4000",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     },
@@ -242,6 +266,7 @@
         "EventName": "UNC_P_FREQ_GE_4000MHZ_TRANSITIONS",
         "Filter": "edge=1,filter_band3=4000",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
+        "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
         "Unit": "PCU"
     }
diff --git a/tools/perf/pmu-events/arch/x86/mapfile.csv b/tools/perf/pmu-events/arch/x86/mapfile.csv
index 12181bb1da2a..d1a12e584c1b 100644
--- a/tools/perf/pmu-events/arch/x86/mapfile.csv
+++ b/tools/perf/pmu-events/arch/x86/mapfile.csv
@@ -17,6 +17,7 @@ GenuineIntel-6-3A,v18,ivybridge,core
 GenuineIntel-6-3E,v19,ivytown,core
 GenuineIntel-6-2D,v20,jaketown,core
 GenuineIntel-6-57,v9,knightslanding,core
+GenuineIntel-6-85,v9,knightslanding,core
 GenuineIntel-6-1E,v2,nehalemep,core
 GenuineIntel-6-1F,v2,nehalemep,core
 GenuineIntel-6-1A,v2,nehalemep,core
diff --git a/tools/perf/pmu-events/arch/x86/sandybridge/uncore.json b/tools/perf/pmu-events/arch/x86/sandybridge/uncore.json
new file mode 100644
index 000000000000..42c70eed05a2
--- /dev/null
+++ b/tools/perf/pmu-events/arch/x86/sandybridge/uncore.json
@@ -0,0 +1,314 @@
+[
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x01",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS",
+    "BriefDescription": "A snoop misses in some processor core.",
+    "PublicDescription": "A snoop misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x02",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.INVAL",
+    "BriefDescription": "A snoop invalidates a non-modified line in some processor core.",
+    "PublicDescription": "A snoop invalidates a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x04",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT",
+    "BriefDescription": "A snoop hits a non-modified line in some processor core.",
+    "PublicDescription": "A snoop hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x08",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM",
+    "BriefDescription": "A snoop hits a modified line in some processor core.",
+    "PublicDescription": "A snoop hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x10",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.INVAL_M",
+    "BriefDescription": "A snoop invalidates a modified line in some processor core.",
+    "PublicDescription": "A snoop invalidates a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x20",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.EXTERNAL_FILTER",
+    "BriefDescription": "Filter on cross-core snoops initiated by this Cbox due to external snoop request.",
+    "PublicDescription": "Filter on cross-core snoops initiated by this Cbox due to external snoop request.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x40",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.XCORE_FILTER",
+    "BriefDescription": "Filter on cross-core snoops initiated by this Cbox due to processor core memory request.",
+    "PublicDescription": "Filter on cross-core snoops initiated by this Cbox due to processor core memory request.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x80",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.EVICTION_FILTER",
+    "BriefDescription": "Filter on cross-core snoops initiated by this Cbox due to LLC eviction.",
+    "PublicDescription": "Filter on cross-core snoops initiated by this Cbox due to LLC eviction.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x01",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.M",
+    "BriefDescription": "LLC lookup request that access cache and found line in M-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x02",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.E",
+    "BriefDescription": "LLC lookup request that access cache and found line in E-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in E-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x04",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.S",
+    "BriefDescription": "LLC lookup request that access cache and found line in S-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x08",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.I",
+    "BriefDescription": "LLC lookup request that access cache and found line in I-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x10",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_FILTER",
+    "BriefDescription": "Filter on processor core initiated cacheable read requests.",
+    "PublicDescription": "Filter on processor core initiated cacheable read requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x20",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_FILTER",
+    "BriefDescription": "Filter on processor core initiated cacheable write requests.",
+    "PublicDescription": "Filter on processor core initiated cacheable write requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x40",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.EXTSNP_FILTER",
+    "BriefDescription": "Filter on external snoop requests.",
+    "PublicDescription": "Filter on external snoop requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x80",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_REQUEST_FILTER",
+    "BriefDescription": "Filter on any IRQ or IPQ initiated requests including uncacheable, non-coherent requests.",
+    "PublicDescription": "Filter on any IRQ or IPQ initiated requests including uncacheable, non-coherent requests.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Counts cycles weighted by the number of requests waiting for data returning from the memory controller. Accounts for coherent and non-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "PublicDescription": "Counts cycles weighted by the number of requests waiting for data returning from the memory controller. Accounts for coherent and non-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x81",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_REQUESTS.ALL",
+    "BriefDescription": "Counts the number of coherent and in-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "PublicDescription": "Counts the number of coherent and in-coherent requests initiated by IA cores, processor graphic units, or LLC.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x81",
+    "UMask": "0x20",
+    "EventName": "UNC_ARB_TRK_REQUESTS.WRITES",
+    "BriefDescription": "Counts the number of allocated write entries, include full, partial, and LLC evictions.",
+    "PublicDescription": "Counts the number of allocated write entries, include full, partial, and LLC evictions.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x81",
+    "UMask": "0x80",
+    "EventName": "UNC_ARB_TRK_REQUESTS.EVICTIONS",
+    "BriefDescription": "Counts the number of LLC evictions allocated.",
+    "PublicDescription": "Counts the number of LLC evictions allocated.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x83",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Cycles weighted by number of requests pending in Coherency Tracker.",
+    "PublicDescription": "Cycles weighted by number of requests pending in Coherency Tracker.",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x84",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_REQUESTS.ALL",
+    "BriefDescription": "Number of requests allocated in Coherency Tracker.",
+    "PublicDescription": "Number of requests allocated in Coherency Tracker.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.CYCLES_WITH_ANY_REQUEST",
+    "BriefDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "PublicDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "Counter": "0,1",
+    "CounterMask": "1",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.CYCLES_OVER_HALF_FULL",
+    "BriefDescription": "Cycles with at least half of the requests outstanding are waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "PublicDescription": "Cycles with at least half of the requests outstanding are waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "Counter": "0,1",
+    "CounterMask": "10",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "ARB",
+    "EventCode": "0x0",
+    "UMask": "0x01",
+    "EventName": "UNC_CLOCK.SOCKET",
+    "BriefDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "PublicDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "Counter": "Fixed",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x06",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ES",
+    "BriefDescription": "LLC lookup request that access cache and found line in E-state or S-state.",
+    "PublicDescription": "LLC lookup request that access cache and found line in E-state or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  }
+]
\ No newline at end of file
diff --git a/tools/perf/pmu-events/arch/x86/skylake/uncore.json b/tools/perf/pmu-events/arch/x86/skylake/uncore.json
new file mode 100644
index 000000000000..dbc193252fb3
--- /dev/null
+++ b/tools/perf/pmu-events/arch/x86/skylake/uncore.json
@@ -0,0 +1,254 @@
+[
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x41",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which misses in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x81",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_EVICTION",
+    "BriefDescription": "A cross-core snoop resulted from L3 Eviction which misses in some processor core.",
+    "PublicDescription": "A cross-core snoop resulted from L3 Eviction which misses in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x44",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HIT_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a non-modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a non-modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x22",
+    "UMask": "0x48",
+    "EventName": "UNC_CBO_XSNP_RESPONSE.HITM_XCORE",
+    "BriefDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a modified line in some processor core.",
+    "PublicDescription": "A cross-core snoop initiated by this Cbox due to processor core memory request which hits a modified line in some processor core.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x21",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_M",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in M-state",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x81",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_M",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in M-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in M-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x18",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_I",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in I-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x88",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_I",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in I-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in I-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x1f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_MESI",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in any MESI-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in any MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x2f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_MESI",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in MESI-state",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x8f",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_MESI",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in MESI-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in MESI-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x86",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.ANY_ES",
+    "BriefDescription": "L3 Lookup any request that access cache and found line in E or S-state",
+    "PublicDescription": "L3 Lookup any request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x16",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.READ_ES",
+    "BriefDescription": "L3 Lookup read request that access cache and found line in E or S-state",
+    "PublicDescription": "L3 Lookup read request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "CBO",
+    "EventCode": "0x34",
+    "UMask": "0x26",
+    "EventName": "UNC_CBO_CACHE_LOOKUP.WRITE_ES",
+    "BriefDescription": "L3 Lookup write request that access cache and found line in E or S-state",
+    "PublicDescription": "L3 Lookup write request that access cache and found line in E or S-state.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.ALL",
+    "BriefDescription": "Each cycle count number of all Core outgoing valid entries. Such entry is defined as valid from its allocation till first of IDI0 or DRS0 messages is sent out. Accounts for Coherent and non-coherent traffic.",
+    "PublicDescription": "Each cycle count number of all Core outgoing valid entries. Such entry is defined as valid from its allocation till first of IDI0 or DRS0 messages is sent out. Accounts for Coherent and non-coherent traffic.",
+    "Counter": "0",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_REQUESTS.ALL",
+    "BriefDescription": "Total number of Core outgoing entries allocated. Accounts for Coherent and non-coherent traffic.",
+    "PublicDescription": "Total number of Core outgoing entries allocated. Accounts for Coherent and non-coherent traffic.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x02",
+    "EventName": "UNC_ARB_TRK_REQUESTS.DRD_DIRECT",
+    "BriefDescription": "Number of Core coherent Data Read entries allocated in DirectData mode",
+    "PublicDescription": "Number of Core coherent Data Read entries allocated in DirectData mode.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x81",
+    "UMask": "0x20",
+    "EventName": "UNC_ARB_TRK_REQUESTS.WRITES",
+    "BriefDescription": "Number of Writes allocated - any write transactions: full/partials writes and evictions.",
+    "PublicDescription": "Number of Writes allocated - any write transactions: full/partials writes and evictions.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x84",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_COH_TRK_REQUESTS.ALL",
+    "BriefDescription": "Number of entries allocated. Account for Any type: e.g. Snoop, Core aperture, etc.",
+    "PublicDescription": "Number of entries allocated. Account for Any type: e.g. Snoop, Core aperture, etc.",
+    "Counter": "0,1",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "iMPH-U",
+    "EventCode": "0x80",
+    "UMask": "0x01",
+    "EventName": "UNC_ARB_TRK_OCCUPANCY.CYCLES_WITH_ANY_REQUEST",
+    "BriefDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.;",
+    "PublicDescription": "Cycles with at least one request outstanding is waiting for data return from memory controller. Account for coherent and non-coherent requests initiated by IA Cores, Processor Graphics Unit, or LLC.",
+    "Counter": "0",
+    "CounterMask": "1",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  },
+  {
+    "Unit": "NCU",
+    "EventCode": "0x0",
+    "UMask": "0x01",
+    "EventName": "UNC_CLOCK.SOCKET",
+    "BriefDescription": "This 48-bit fixed counter counts the UCLK cycles",
+    "PublicDescription": "This 48-bit fixed counter counts the UCLK cycles.",
+    "Counter": "FIXED",
+    "CounterMask": "0",
+    "Invert": "0",
+    "EdgeDetect": "0"
+  }
+]
\ No newline at end of file
diff --git a/tools/perf/pmu-events/jevents.c b/tools/perf/pmu-events/jevents.c
index eed09346a72a..baa073f38334 100644
--- a/tools/perf/pmu-events/jevents.c
+++ b/tools/perf/pmu-events/jevents.c
@@ -195,6 +195,7 @@ static struct map {
         { "CBO", "uncore_cbox" },
         { "QPI LL", "uncore_qpi" },
         { "SBO", "uncore_sbox" },
+        { "iMPH-U", "uncore_arb" },
         {}
 };
 
@@ -291,7 +292,9 @@ static void print_events_table_prefix(FILE *fp, const char *tblname)
 
 static int print_events_table_entry(void *data, char *name, char *event,
                                     char *desc, char *long_desc,
-                                    char *pmu, char *unit, char *perpkg)
+                                    char *pmu, char *unit, char *perpkg,
+                                    char *metric_expr,
+                                    char *metric_name)
 {
         struct perf_entry_data *pd = data;
         FILE *outfp = pd->outfp;
@@ -315,6 +318,10 @@ static int print_events_table_entry(void *data, char *name, char *event,
                 fprintf(outfp, "\t.unit = \"%s\",\n", unit);
         if (perpkg)
                 fprintf(outfp, "\t.perpkg = \"%s\",\n", perpkg);
+        if (metric_expr)
+                fprintf(outfp, "\t.metric_expr = \"%s\",\n", metric_expr);
+        if (metric_name)
+                fprintf(outfp, "\t.metric_name = \"%s\",\n", metric_name);
         fprintf(outfp, "},\n");
 
         return 0;
@@ -362,7 +369,9 @@ static char *real_event(const char *name, char *event)
 int json_events(const char *fn,
           int (*func)(void *data, char *name, char *event, char *desc,
                       char *long_desc,
-                      char *pmu, char *unit, char *perpkg),
+                      char *pmu, char *unit, char *perpkg,
+                      char *metric_expr,
+                      char *metric_name),
           void *data)
 {
         int err = -EIO;
@@ -388,6 +397,8 @@ int json_events(const char *fn,
                 char *filter = NULL;
                 char *perpkg = NULL;
                 char *unit = NULL;
+                char *metric_expr = NULL;
+                char *metric_name = NULL;
                 unsigned long long eventcode = 0;
                 struct msrmap *msr = NULL;
                 jsmntok_t *msrval = NULL;
@@ -398,6 +409,7 @@ int json_events(const char *fn,
                 for (j = 0; j < obj->size; j += 2) {
                         jsmntok_t *field, *val;
                         int nz;
+                        char *s;
 
                         field = tok + j;
                         EXPECT(field->type == JSMN_STRING, tok + j,
@@ -444,7 +456,6 @@ int json_events(const char *fn,
                                         NULL);
                         } else if (json_streq(map, field, "Unit")) {
                                 const char *ppmu;
-                                char *s;
 
                                 ppmu = field_to_perf(unit_to_pmu, map, val);
                                 if (ppmu) {
@@ -458,12 +469,19 @@ int json_events(const char *fn,
                                 }
                                 addfield(map, &desc, ". ", "Unit: ", NULL);
                                 addfield(map, &desc, "", pmu, NULL);
+                                addfield(map, &desc, "", " ", NULL);
                         } else if (json_streq(map, field, "Filter")) {
                                 addfield(map, &filter, "", "", val);
                         } else if (json_streq(map, field, "ScaleUnit")) {
                                 addfield(map, &unit, "", "", val);
                         } else if (json_streq(map, field, "PerPkg")) {
                                 addfield(map, &perpkg, "", "", val);
+                        } else if (json_streq(map, field, "MetricName")) {
+                                addfield(map, &metric_name, "", "", val);
+                        } else if (json_streq(map, field, "MetricExpr")) {
+                                addfield(map, &metric_expr, "", "", val);
+                                for (s = metric_expr; *s; s++)
+                                        *s = tolower(*s);
                         }
                         /* ignore unknown fields */
                 }
@@ -488,7 +506,7 @@ int json_events(const char *fn,
                 fixname(name);
 
                 err = func(data, name, real_event(name, event), desc, long_desc,
-                                pmu, unit, perpkg);
+                                pmu, unit, perpkg, metric_expr, metric_name);
                 free(event);
                 free(desc);
                 free(name);
@@ -498,6 +516,8 @@ int json_events(const char *fn,
                 free(filter);
                 free(perpkg);
                 free(unit);
+                free(metric_expr);
+                free(metric_name);
                 if (err)
                         break;
                 tok += j;
diff --git a/tools/perf/pmu-events/jevents.h b/tools/perf/pmu-events/jevents.h
index 71e13de31092..611fac01913d 100644
--- a/tools/perf/pmu-events/jevents.h
+++ b/tools/perf/pmu-events/jevents.h
@@ -5,7 +5,8 @@ int json_events(const char *fn,
                 int (*func)(void *data, char *name, char *event, char *desc,
                                 char *long_desc,
                                 char *pmu,
-                                char *unit, char *perpkg),
+                                char *unit, char *perpkg, char *metric_expr,
+                                char *metric_name),
                 void *data);
 char *get_cpu_str(void);
 
diff --git a/tools/perf/pmu-events/pmu-events.h b/tools/perf/pmu-events/pmu-events.h
index c669a3cdb9f0..569eab3688dd 100644
--- a/tools/perf/pmu-events/pmu-events.h
+++ b/tools/perf/pmu-events/pmu-events.h
@@ -13,6 +13,8 @@ struct pmu_event {
         const char *pmu;
         const char *unit;
         const char *perpkg;
+        const char *metric_expr;
+        const char *metric_name;
 };
 
 /*
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 1cb3d9b540e9..af58ebc243ef 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -38,6 +38,7 @@ perf-y += cpumap.o
 perf-y += stat.o
 perf-y += event_update.o
 perf-y += event-times.o
+perf-y += expr.o
 perf-y += backward-ring-buffer.o
 perf-y += sdt.o
 perf-y += is_printable_array.o
diff --git a/tools/perf/tests/attr.c b/tools/perf/tests/attr.c
index 88dc51f4c27b..0dd77494bb58 100644
--- a/tools/perf/tests/attr.c
+++ b/tools/perf/tests/attr.c
@@ -18,10 +18,16 @@
  * permissions. All the event text files are stored there.
  */
 
+#include <errno.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include "../perf.h"
 #include "util.h"
 #include <subcmd/exec-cmd.h>
diff --git a/tools/perf/tests/backward-ring-buffer.c b/tools/perf/tests/backward-ring-buffer.c
index 42e892b1e979..50f6d7afee58 100644
--- a/tools/perf/tests/backward-ring-buffer.c
+++ b/tools/perf/tests/backward-ring-buffer.c
@@ -8,6 +8,7 @@
 #include <sys/prctl.h>
 #include "tests.h"
 #include "debug.h"
+#include <errno.h>
 
 #define NR_ITERS 111
 
diff --git a/tools/perf/tests/bpf.c b/tools/perf/tests/bpf.c
index 1a04fe77487d..5876da126b58 100644
--- a/tools/perf/tests/bpf.c
+++ b/tools/perf/tests/bpf.c
@@ -1,10 +1,14 @@
+#include <errno.h>
 #include <stdio.h>
 #include <sys/epoll.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 #include <util/util.h>
 #include <util/bpf-loader.h>
 #include <util/evlist.h>
 #include <linux/bpf.h>
 #include <linux/filter.h>
+#include <linux/kernel.h>
 #include <api/fs/fs.h>
 #include <bpf/bpf.h>
 #include "tests.h"
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 83c4669cbc5b..9e08d297f1a9 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -3,8 +3,10 @@
  *
  * Builtin regression testing command: ever growing number of sanity tests
  */
+#include <errno.h>
 #include <unistd.h>
 #include <string.h>
+#include <sys/wait.h>
 #include "builtin.h"
 #include "hist.h"
 #include "intlist.h"
@@ -13,6 +15,7 @@
 #include "color.h"
 #include <subcmd/parse-options.h>
 #include "symbol.h"
+#include <linux/kernel.h>
 
 static bool dont_fork;
 
@@ -44,6 +47,10 @@ static struct test generic_tests[] = {
                 .func = test__parse_events,
         },
         {
+                .desc = "Simple expression parser",
+                .func = test__expr,
+        },
+        {
                 .desc = "PERF_RECORD_* events & perf_sample fields",
                 .func = test__PERF_RECORD,
         },
@@ -460,7 +467,7 @@ static int perf_test__list(int argc, const char **argv)
         return 0;
 }
 
-int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
+int cmd_test(int argc, const char **argv)
 {
         const char *test_usage[] = {
         "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
diff --git a/tools/perf/tests/clang.c b/tools/perf/tests/clang.c
index f853e242a86c..c5bb2203f5a9 100644
--- a/tools/perf/tests/clang.c
+++ b/tools/perf/tests/clang.c
@@ -2,6 +2,7 @@
 #include "debug.h"
 #include "util.h"
 #include "c++/clang-c.h"
+#include <linux/kernel.h>
 
 static struct {
         int (*func)(void);
diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c
index d1f693041324..1f14e7612cbb 100644
--- a/tools/perf/tests/code-reading.c
+++ b/tools/perf/tests/code-reading.c
@@ -1,9 +1,12 @@
+#include <errno.h>
+#include <linux/kernel.h>
 #include <linux/types.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdio.h>
-#include <ctype.h>
 #include <string.h>
+#include <sys/param.h>
 
 #include "parse-events.h"
 #include "evlist.h"
@@ -16,6 +19,8 @@
 
 #include "tests.h"
 
+#include "sane_ctype.h"
+
 #define BUFSZ   1024
 #define READLEN 128
 
diff --git a/tools/perf/tests/cpumap.c b/tools/perf/tests/cpumap.c
index f168a85992d0..4478773cdb97 100644
--- a/tools/perf/tests/cpumap.c
+++ b/tools/perf/tests/cpumap.c
@@ -66,7 +66,7 @@ static int process_event_cpus(struct perf_tool *tool __maybe_unused,
         TEST_ASSERT_VAL("wrong nr",  map->nr == 2);
         TEST_ASSERT_VAL("wrong cpu", map->map[0] == 1);
         TEST_ASSERT_VAL("wrong cpu", map->map[1] == 256);
-        TEST_ASSERT_VAL("wrong refcnt", atomic_read(&map->refcnt) == 1);
+        TEST_ASSERT_VAL("wrong refcnt", refcount_read(&map->refcnt) == 1);
         cpu_map__put(map);
         return 0;
 }
diff --git a/tools/perf/tests/dso-data.c b/tools/perf/tests/dso-data.c
index 13725e09ba22..8f08df5861cb 100644
--- a/tools/perf/tests/dso-data.c
+++ b/tools/perf/tests/dso-data.c
@@ -1,4 +1,6 @@
+#include <dirent.h>
 #include <stdlib.h>
+#include <linux/kernel.h>
 #include <linux/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
diff --git a/tools/perf/tests/dwarf-unwind.c b/tools/perf/tests/dwarf-unwind.c
index 1046491de4b2..dfe5c89e2049 100644
--- a/tools/perf/tests/dwarf-unwind.c
+++ b/tools/perf/tests/dwarf-unwind.c
@@ -1,5 +1,6 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
+#include <inttypes.h>
 #include <unistd.h>
 #include "tests.h"
 #include "debug.h"
diff --git a/tools/perf/tests/event-times.c b/tools/perf/tests/event-times.c
index 19ef77bd6eb4..634f20c631d8 100644
--- a/tools/perf/tests/event-times.c
+++ b/tools/perf/tests/event-times.c
@@ -1,5 +1,8 @@
 #include <linux/compiler.h>
+#include <errno.h>
+#include <inttypes.h>
 #include <string.h>
+#include <sys/wait.h>
 #include "tests.h"
 #include "evlist.h"
 #include "evsel.h"
diff --git a/tools/perf/tests/evsel-roundtrip-name.c b/tools/perf/tests/evsel-roundtrip-name.c
index 60926a1f6fd7..d2bea6f780f8 100644
--- a/tools/perf/tests/evsel-roundtrip-name.c
+++ b/tools/perf/tests/evsel-roundtrip-name.c
@@ -3,6 +3,8 @@
 #include "parse-events.h"
 #include "tests.h"
 #include "debug.h"
+#include <errno.h>
+#include <linux/kernel.h>
 
 static int perf_evsel__roundtrip_cache_name_test(void)
 {
diff --git a/tools/perf/tests/expr.c b/tools/perf/tests/expr.c
new file mode 100644
index 000000000000..6c6a3749aaf6
--- /dev/null
+++ b/tools/perf/tests/expr.c
@@ -0,0 +1,56 @@
+#include "util/debug.h"
+#include "util/expr.h"
+#include "tests.h"
+#include <stdlib.h>
+
+static int test(struct parse_ctx *ctx, const char *e, double val2)
+{
+        double val;
+
+        if (expr__parse(&val, ctx, &e))
+                TEST_ASSERT_VAL("parse test failed", 0);
+        TEST_ASSERT_VAL("unexpected value", val == val2);
+        return 0;
+}
+
+int test__expr(int subtest __maybe_unused)
+{
+        const char *p;
+        const char **other;
+        double val;
+        int ret;
+        struct parse_ctx ctx;
+        int num_other;
+
+        expr__ctx_init(&ctx);
+        expr__add_id(&ctx, "FOO", 1);
+        expr__add_id(&ctx, "BAR", 2);
+
+        ret = test(&ctx, "1+1", 2);
+        ret |= test(&ctx, "FOO+BAR", 3);
+        ret |= test(&ctx, "(BAR/2)%2", 1);
+        ret |= test(&ctx, "1 - -4",  5);
+        ret |= test(&ctx, "(FOO-1)*2 + (BAR/2)%2 - -4",  5);
+
+        if (ret)
+                return ret;
+
+        p = "FOO/0";
+        ret = expr__parse(&val, &ctx, &p);
+        TEST_ASSERT_VAL("division by zero", ret == 1);
+
+        p = "BAR/";
+        ret = expr__parse(&val, &ctx, &p);
+        TEST_ASSERT_VAL("missing operand", ret == 1);
+
+        TEST_ASSERT_VAL("find other",
+                        expr__find_other("FOO + BAR + BAZ + BOZO", "FOO", &other, &num_other) == 0);
+        TEST_ASSERT_VAL("find other", num_other == 3);
+        TEST_ASSERT_VAL("find other", !strcmp(other[0], "BAR"));
+        TEST_ASSERT_VAL("find other", !strcmp(other[1], "BAZ"));
+        TEST_ASSERT_VAL("find other", !strcmp(other[2], "BOZO"));
+        TEST_ASSERT_VAL("find other", other[3] == NULL);
+        free((void *)other);
+
+        return 0;
+}
diff --git a/tools/perf/tests/hists_common.c b/tools/perf/tests/hists_common.c
index 6b21746d6eec..00b8dc50f3db 100644
--- a/tools/perf/tests/hists_common.c
+++ b/tools/perf/tests/hists_common.c
@@ -1,3 +1,4 @@
+#include <inttypes.h>
 #include "perf.h"
 #include "util/debug.h"
 #include "util/symbol.h"
@@ -7,6 +8,7 @@
 #include "util/machine.h"
 #include "util/thread.h"
 #include "tests/hists_common.h"
+#include <linux/kernel.h>
 
 static struct {
         u32 pid;
diff --git a/tools/perf/tests/hists_cumulate.c b/tools/perf/tests/hists_cumulate.c
index 9fd54b79a788..70918b986568 100644
--- a/tools/perf/tests/hists_cumulate.c
+++ b/tools/perf/tests/hists_cumulate.c
@@ -9,6 +9,7 @@
 #include "util/parse-events.h"
 #include "tests/tests.h"
 #include "tests/hists_common.h"
+#include <linux/kernel.h>
 
 struct sample {
         u32 pid;
diff --git a/tools/perf/tests/hists_filter.c b/tools/perf/tests/hists_filter.c
index 62efb14f3a5a..f171b2da4899 100644
--- a/tools/perf/tests/hists_filter.c
+++ b/tools/perf/tests/hists_filter.c
@@ -9,6 +9,7 @@
 #include "util/parse-events.h"
 #include "tests/tests.h"
 #include "tests/hists_common.h"
+#include <linux/kernel.h>
 
 struct sample {
         u32 pid;
diff --git a/tools/perf/tests/hists_link.c b/tools/perf/tests/hists_link.c
index eddc7407ff8a..a26cbb79e988 100644
--- a/tools/perf/tests/hists_link.c
+++ b/tools/perf/tests/hists_link.c
@@ -9,6 +9,8 @@
 #include "thread.h"
 #include "parse-events.h"
 #include "hists_common.h"
+#include <errno.h>
+#include <linux/kernel.h>
 
 struct sample {
         u32 pid;
diff --git a/tools/perf/tests/hists_output.c b/tools/perf/tests/hists_output.c
index 63c5efaba1b5..cdf0dde5fe97 100644
--- a/tools/perf/tests/hists_output.c
+++ b/tools/perf/tests/hists_output.c
@@ -9,6 +9,7 @@
 #include "util/parse-events.h"
 #include "tests/tests.h"
 #include "tests/hists_common.h"
+#include <linux/kernel.h>
 
 struct sample {
         u32 cpu;
diff --git a/tools/perf/tests/is_printable_array.c b/tools/perf/tests/is_printable_array.c
index 42e13393e502..a5192f6a20d7 100644
--- a/tools/perf/tests/is_printable_array.c
+++ b/tools/perf/tests/is_printable_array.c
@@ -1,7 +1,8 @@
 #include <linux/compiler.h>
+#include <linux/kernel.h>
 #include "tests.h"
 #include "debug.h"
-#include "util.h"
+#include "print_binary.h"
 
 int test__is_printable_array(int subtest __maybe_unused)
 {
diff --git a/tools/perf/tests/mmap-basic.c b/tools/perf/tests/mmap-basic.c
index 634bce9caebd..15c770856aac 100644
--- a/tools/perf/tests/mmap-basic.c
+++ b/tools/perf/tests/mmap-basic.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 /* For the CLR_() macros */
 #include <pthread.h>
 
@@ -7,6 +9,7 @@
 #include "cpumap.h"
 #include "tests.h"
 #include <linux/err.h>
+#include <linux/kernel.h>
 
 /*
  * This test will generate random numbers of calls to some getpid syscalls,
diff --git a/tools/perf/tests/mmap-thread-lookup.c b/tools/perf/tests/mmap-thread-lookup.c
index 0c5ce44f723f..6ea4d8a5d26b 100644
--- a/tools/perf/tests/mmap-thread-lookup.c
+++ b/tools/perf/tests/mmap-thread-lookup.c
@@ -1,3 +1,4 @@
+#include <inttypes.h>
 #include <unistd.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
@@ -11,6 +12,7 @@
 #include "thread_map.h"
 #include "symbol.h"
 #include "thread.h"
+#include "util.h"
 
 #define THREADS 4
 
diff --git a/tools/perf/tests/openat-syscall-all-cpus.c b/tools/perf/tests/openat-syscall-all-cpus.c
index c8d9592eb142..1a74dd9fd067 100644
--- a/tools/perf/tests/openat-syscall-all-cpus.c
+++ b/tools/perf/tests/openat-syscall-all-cpus.c
@@ -1,8 +1,14 @@
+#include <errno.h>
+#include <inttypes.h>
 /* For the CPU_* macros */
 #include <pthread.h>
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #include <api/fs/fs.h>
 #include <linux/err.h>
+#include <api/fs/tracing_path.h>
 #include "evsel.h"
 #include "tests.h"
 #include "thread_map.h"
diff --git a/tools/perf/tests/openat-syscall-tp-fields.c b/tools/perf/tests/openat-syscall-tp-fields.c
index f52239fed361..9788fac91095 100644
--- a/tools/perf/tests/openat-syscall-tp-fields.c
+++ b/tools/perf/tests/openat-syscall-tp-fields.c
@@ -5,6 +5,7 @@
 #include "thread_map.h"
 #include "tests.h"
 #include "debug.h"
+#include <errno.h>
 
 #ifndef O_DIRECTORY
 #define O_DIRECTORY    00200000
diff --git a/tools/perf/tests/openat-syscall.c b/tools/perf/tests/openat-syscall.c
index d7414128d7fe..e44506e21ee7 100644
--- a/tools/perf/tests/openat-syscall.c
+++ b/tools/perf/tests/openat-syscall.c
@@ -1,5 +1,10 @@
+#include <errno.h>
+#include <inttypes.h>
 #include <api/fs/tracing_path.h>
 #include <linux/err.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #include "thread_map.h"
 #include "evsel.h"
 #include "debug.h"
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 1dc838014422..7fad885491c5 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -1,4 +1,3 @@
-
 #include "parse-events.h"
 #include "evsel.h"
 #include "evlist.h"
@@ -6,8 +5,15 @@
 #include "tests.h"
 #include "debug.h"
 #include "util.h"
+#include <dirent.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <linux/kernel.h>
 #include <linux/hw_breakpoint.h>
 #include <api/fs/fs.h>
+#include <api/fs/tracing_path.h>
 
 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
                              PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
diff --git a/tools/perf/tests/parse-no-sample-id-all.c b/tools/perf/tests/parse-no-sample-id-all.c
index 65dcf48a92fb..c6207db09f12 100644
--- a/tools/perf/tests/parse-no-sample-id-all.c
+++ b/tools/perf/tests/parse-no-sample-id-all.c
@@ -1,3 +1,4 @@
+#include <linux/kernel.h>
 #include <linux/types.h>
 #include <stddef.h>
 
diff --git a/tools/perf/tests/perf-record.c b/tools/perf/tests/perf-record.c
index 87893f3ba5f1..d37cd9588cc0 100644
--- a/tools/perf/tests/perf-record.c
+++ b/tools/perf/tests/perf-record.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 /* For the CLR_() macros */
 #include <pthread.h>
 
diff --git a/tools/perf/tests/pmu.c b/tools/perf/tests/pmu.c
index 1e2ba2602930..a6d7aef30030 100644
--- a/tools/perf/tests/pmu.c
+++ b/tools/perf/tests/pmu.c
@@ -2,6 +2,8 @@
 #include "pmu.h"
 #include "util.h"
 #include "tests.h"
+#include <errno.h>
+#include <linux/kernel.h>
 
 /* Simulated format definitions. */
 static struct test_format {
diff --git a/tools/perf/tests/sample-parsing.c b/tools/perf/tests/sample-parsing.c
index 5f23710b9fee..bac5c3885b3b 100644
--- a/tools/perf/tests/sample-parsing.c
+++ b/tools/perf/tests/sample-parsing.c
@@ -1,4 +1,6 @@
 #include <stdbool.h>
+#include <inttypes.h>
+#include <linux/kernel.h>
 #include <linux/types.h>
 
 #include "util.h"
diff --git a/tools/perf/tests/sdt.c b/tools/perf/tests/sdt.c
index f59d210e1baf..f73b3c5e125d 100644
--- a/tools/perf/tests/sdt.c
+++ b/tools/perf/tests/sdt.c
@@ -1,3 +1,4 @@
+#include <errno.h>
 #include <stdio.h>
 #include <sys/epoll.h>
 #include <util/util.h>
@@ -43,7 +44,7 @@ static char *get_self_path(void)
 {
         char *buf = calloc(PATH_MAX, sizeof(char));
 
-        if (buf && readlink("/proc/self/exe", buf, PATH_MAX) < 0) {
+        if (buf && readlink("/proc/self/exe", buf, PATH_MAX - 1) < 0) {
                 pr_debug("Failed to get correct path of perf\n");
                 free(buf);
                 return NULL;
diff --git a/tools/perf/tests/sw-clock.c b/tools/perf/tests/sw-clock.c
index 4c9fd046d57b..828494db4a19 100644
--- a/tools/perf/tests/sw-clock.c
+++ b/tools/perf/tests/sw-clock.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <signal.h>
diff --git a/tools/perf/tests/switch-tracking.c b/tools/perf/tests/switch-tracking.c
index 7ddbe267d0ac..65474fd80da7 100644
--- a/tools/perf/tests/switch-tracking.c
+++ b/tools/perf/tests/switch-tracking.c
@@ -1,5 +1,6 @@
 #include <sys/time.h>
 #include <sys/prctl.h>
+#include <errno.h>
 #include <time.h>
 #include <stdlib.h>
 
diff --git a/tools/perf/tests/task-exit.c b/tools/perf/tests/task-exit.c
index 01a5ba2788c6..32873ec91a4e 100644
--- a/tools/perf/tests/task-exit.c
+++ b/tools/perf/tests/task-exit.c
@@ -4,6 +4,7 @@
 #include "cpumap.h"
 #include "tests.h"
 
+#include <errno.h>
 #include <signal.h>
 
 static int exited;
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 1fa9b9d83aa5..631859629403 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -62,6 +62,7 @@ int test__sample_parsing(int subtest);
 int test__keep_tracking(int subtest);
 int test__parse_no_sample_id_all(int subtest);
 int test__dwarf_unwind(int subtest);
+int test__expr(int subtest);
 int test__hists_filter(int subtest);
 int test__mmap_thread_lookup(int subtest);
 int test__thread_mg_share(int subtest);
diff --git a/tools/perf/tests/thread-map.c b/tools/perf/tests/thread-map.c
index f2d2e542d0ee..a63d6945807b 100644
--- a/tools/perf/tests/thread-map.c
+++ b/tools/perf/tests/thread-map.c
@@ -29,7 +29,7 @@ int test__thread_map(int subtest __maybe_unused)
                         thread_map__comm(map, 0) &&
                         !strcmp(thread_map__comm(map, 0), NAME));
         TEST_ASSERT_VAL("wrong refcnt",
-                        atomic_read(&map->refcnt) == 1);
+                        refcount_read(&map->refcnt) == 1);
         thread_map__put(map);
 
         /* test dummy pid */
@@ -44,7 +44,7 @@ int test__thread_map(int subtest __maybe_unused)
                         thread_map__comm(map, 0) &&
                         !strcmp(thread_map__comm(map, 0), "dummy"));
         TEST_ASSERT_VAL("wrong refcnt",
-                        atomic_read(&map->refcnt) == 1);
+                        refcount_read(&map->refcnt) == 1);
         thread_map__put(map);
         return 0;
 }
@@ -71,7 +71,7 @@ static int process_event(struct perf_tool *tool __maybe_unused,
                         thread_map__comm(threads, 0) &&
                         !strcmp(thread_map__comm(threads, 0), NAME));
         TEST_ASSERT_VAL("wrong refcnt",
-                        atomic_read(&threads->refcnt) == 1);
+                        refcount_read(&threads->refcnt) == 1);
         thread_map__put(threads);
         return 0;
 }
diff --git a/tools/perf/tests/thread-mg-share.c b/tools/perf/tests/thread-mg-share.c
index 188b63140fc8..76686dd6f5ec 100644
--- a/tools/perf/tests/thread-mg-share.c
+++ b/tools/perf/tests/thread-mg-share.c
@@ -43,7 +43,7 @@ int test__thread_mg_share(int subtest __maybe_unused)
                         leader && t1 && t2 && t3 && other);
 
         mg = leader->mg;
-        TEST_ASSERT_EQUAL("wrong refcnt", atomic_read(&mg->refcnt), 4);
+        TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&mg->refcnt), 4);
 
         /* test the map groups pointer is shared */
         TEST_ASSERT_VAL("map groups don't match", mg == t1->mg);
@@ -71,25 +71,25 @@ int test__thread_mg_share(int subtest __maybe_unused)
         machine__remove_thread(machine, other_leader);
 
         other_mg = other->mg;
-        TEST_ASSERT_EQUAL("wrong refcnt", atomic_read(&other_mg->refcnt), 2);
+        TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&other_mg->refcnt), 2);
 
         TEST_ASSERT_VAL("map groups don't match", other_mg == other_leader->mg);
 
         /* release thread group */
         thread__put(leader);
-        TEST_ASSERT_EQUAL("wrong refcnt", atomic_read(&mg->refcnt), 3);
+        TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&mg->refcnt), 3);
 
         thread__put(t1);
-        TEST_ASSERT_EQUAL("wrong refcnt", atomic_read(&mg->refcnt), 2);
+        TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&mg->refcnt), 2);
 
         thread__put(t2);
-        TEST_ASSERT_EQUAL("wrong refcnt", atomic_read(&mg->refcnt), 1);
+        TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&mg->refcnt), 1);
 
         thread__put(t3);
 
         /* release other group  */
         thread__put(other_leader);
-        TEST_ASSERT_EQUAL("wrong refcnt", atomic_read(&other_mg->refcnt), 1);
+        TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&other_mg->refcnt), 1);
 
         thread__put(other);
 
diff --git a/tools/perf/tests/unit_number__scnprintf.c b/tools/perf/tests/unit_number__scnprintf.c
index 623c2aa53c4a..44589de084b8 100644
--- a/tools/perf/tests/unit_number__scnprintf.c
+++ b/tools/perf/tests/unit_number__scnprintf.c
@@ -1,7 +1,8 @@
+#include <inttypes.h>
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include "tests.h"
-#include "util.h"
+#include "units.h"
 #include "debug.h"
 
 int test__unit_number__scnprint(int subtest __maybe_unused)
diff --git a/tools/perf/tests/vmlinux-kallsyms.c b/tools/perf/tests/vmlinux-kallsyms.c
index 862b043e5924..8456175fc234 100644
--- a/tools/perf/tests/vmlinux-kallsyms.c
+++ b/tools/perf/tests/vmlinux-kallsyms.c
@@ -1,5 +1,6 @@
 #include <linux/compiler.h>
 #include <linux/rbtree.h>
+#include <inttypes.h>
 #include <string.h>
 #include "map.h"
 #include "symbol.h"
diff --git a/tools/perf/trace/beauty/Build b/tools/perf/trace/beauty/Build
new file mode 100644
index 000000000000..be95ac6ce845
--- /dev/null
+++ b/tools/perf/trace/beauty/Build
@@ -0,0 +1 @@
+libperf-y += statx.o
diff --git a/tools/perf/trace/beauty/beauty.h b/tools/perf/trace/beauty/beauty.h
new file mode 100644
index 000000000000..cf50be3f17a4
--- /dev/null
+++ b/tools/perf/trace/beauty/beauty.h
@@ -0,0 +1,24 @@
+#ifndef _PERF_TRACE_BEAUTY_H
+#define _PERF_TRACE_BEAUTY_H
+
+#include <linux/types.h>
+
+struct trace;
+struct thread;
+
+struct syscall_arg {
+        unsigned long val;
+        struct thread *thread;
+        struct trace  *trace;
+        void          *parm;
+        u8            idx;
+        u8            mask;
+};
+
+size_t syscall_arg__scnprintf_statx_flags(char *bf, size_t size, struct syscall_arg *arg);
+#define SCA_STATX_FLAGS syscall_arg__scnprintf_statx_flags
+
+size_t syscall_arg__scnprintf_statx_mask(char *bf, size_t size, struct syscall_arg *arg);
+#define SCA_STATX_MASK syscall_arg__scnprintf_statx_mask
+
+#endif /* _PERF_TRACE_BEAUTY_H */
diff --git a/tools/perf/trace/beauty/signum.c b/tools/perf/trace/beauty/signum.c
index d3b0b1fab077..fde8f2fc6558 100644
--- a/tools/perf/trace/beauty/signum.c
+++ b/tools/perf/trace/beauty/signum.c
@@ -1,3 +1,4 @@
+#include <signal.h>
 
 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
 {
diff --git a/tools/perf/trace/beauty/statx.c b/tools/perf/trace/beauty/statx.c
new file mode 100644
index 000000000000..5643b692af4c
--- /dev/null
+++ b/tools/perf/trace/beauty/statx.c
@@ -0,0 +1,72 @@
+/*
+ * trace/beauty/statx.c
+ *
+ *  Copyright (C) 2017, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
+ */
+
+#include "trace/beauty/beauty.h"
+#include <linux/kernel.h>
+#include <sys/types.h>
+#include <uapi/linux/fcntl.h>
+#include <uapi/linux/stat.h>
+
+size_t syscall_arg__scnprintf_statx_flags(char *bf, size_t size, struct syscall_arg *arg)
+{
+        int printed = 0, flags = arg->val;
+
+        if (flags == 0)
+                return scnprintf(bf, size, "SYNC_AS_STAT");
+#define P_FLAG(n) \
+        if (flags & AT_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                flags &= ~AT_##n; \
+        }
+
+        P_FLAG(SYMLINK_NOFOLLOW);
+        P_FLAG(REMOVEDIR);
+        P_FLAG(SYMLINK_FOLLOW);
+        P_FLAG(NO_AUTOMOUNT);
+        P_FLAG(EMPTY_PATH);
+        P_FLAG(STATX_FORCE_SYNC);
+        P_FLAG(STATX_DONT_SYNC);
+
+#undef P_FLAG
+
+        if (flags)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
+
+        return printed;
+}
+
+size_t syscall_arg__scnprintf_statx_mask(char *bf, size_t size, struct syscall_arg *arg)
+{
+        int printed = 0, flags = arg->val;
+
+#define P_FLAG(n) \
+        if (flags & STATX_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                flags &= ~STATX_##n; \
+        }
+
+        P_FLAG(TYPE);
+        P_FLAG(MODE);
+        P_FLAG(NLINK);
+        P_FLAG(UID);
+        P_FLAG(GID);
+        P_FLAG(ATIME);
+        P_FLAG(MTIME);
+        P_FLAG(CTIME);
+        P_FLAG(INO);
+        P_FLAG(SIZE);
+        P_FLAG(BLOCKS);
+        P_FLAG(BTIME);
+
+#undef P_FLAG
+
+        if (flags)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
+
+        return printed;
+}
diff --git a/tools/perf/ui/browser.c b/tools/perf/ui/browser.c
index 3eb3edb307a4..a4d3762cd825 100644
--- a/tools/perf/ui/browser.c
+++ b/tools/perf/ui/browser.c
@@ -1,4 +1,5 @@
 #include "../util.h"
+#include "../string2.h"
 #include "../config.h"
 #include "../../perf.h"
 #include "libslang.h"
@@ -13,6 +14,7 @@
 #include "helpline.h"
 #include "keysyms.h"
 #include "../color.h"
+#include "sane_ctype.h"
 
 static int ui_browser__percent_color(struct ui_browser *browser,
                                      double percent, bool current)
@@ -579,7 +581,7 @@ static int ui_browser__color_config(const char *var, const char *value,
                         break;
 
                 *bg = '\0';
-                while (isspace(*++bg));
+                bg = ltrim(++bg);
                 ui_browser__colorsets[i].bg = bg;
                 ui_browser__colorsets[i].fg = fg;
                 return 0;
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index ba36aac340bc..d990ad08a3c6 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -9,7 +9,10 @@
 #include "../../util/symbol.h"
 #include "../../util/evsel.h"
 #include "../../util/config.h"
+#include <inttypes.h>
 #include <pthread.h>
+#include <linux/kernel.h>
+#include <sys/ttydefaults.h>
 
 struct disasm_line_samples {
         double          percent;
diff --git a/tools/perf/ui/browsers/header.c b/tools/perf/ui/browsers/header.c
index edbeaaf31ace..e2c9390ff4c5 100644
--- a/tools/perf/ui/browsers/header.c
+++ b/tools/perf/ui/browsers/header.c
@@ -8,6 +8,8 @@
 #include "util/header.h"
 #include "util/session.h"
 
+#include <sys/ttydefaults.h>
+
 static void ui_browser__argv_write(struct ui_browser *browser,
                                    void *entry, int row)
 {
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index fc4fb669ceee..69f4570bd4f9 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -1,7 +1,11 @@
+#include <dirent.h>
+#include <errno.h>
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <linux/rbtree.h>
+#include <sys/ttydefaults.h>
 
 #include "../../util/evsel.h"
 #include "../../util/evlist.h"
@@ -10,6 +14,7 @@
 #include "../../util/sort.h"
 #include "../../util/util.h"
 #include "../../util/top.h"
+#include "../../util/thread.h"
 #include "../../arch/common.h"
 
 #include "../browsers/hists.h"
@@ -18,6 +23,11 @@
 #include "../ui.h"
 #include "map.h"
 #include "annotate.h"
+#include "srcline.h"
+#include "string2.h"
+#include "units.h"
+
+#include "sane_ctype.h"
 
 extern void hist_browser__init_hpp(void);
 
@@ -144,9 +154,60 @@ static void callchain_list__set_folding(struct callchain_list *cl, bool unfold)
         cl->unfolded = unfold ? cl->has_children : false;
 }
 
+static struct inline_node *inline_node__create(struct map *map, u64 ip)
+{
+        struct dso *dso;
+        struct inline_node *node;
+
+        if (map == NULL)
+                return NULL;
+
+        dso = map->dso;
+        if (dso == NULL)
+                return NULL;
+
+        if (dso->kernel != DSO_TYPE_USER)
+                return NULL;
+
+        node = dso__parse_addr_inlines(dso,
+                                       map__rip_2objdump(map, ip));
+
+        return node;
+}
+
+static int inline__count_rows(struct inline_node *node)
+{
+        struct inline_list *ilist;
+        int i = 0;
+
+        if (node == NULL)
+                return 0;
+
+        list_for_each_entry(ilist, &node->val, list) {
+                if ((ilist->filename != NULL) || (ilist->funcname != NULL))
+                        i++;
+        }
+
+        return i;
+}
+
+static int callchain_list__inline_rows(struct callchain_list *chain)
+{
+        struct inline_node *node;
+        int rows;
+
+        node = inline_node__create(chain->ms.map, chain->ip);
+        if (node == NULL)
+                return 0;
+
+        rows = inline__count_rows(node);
+        inline_node__delete(node);
+        return rows;
+}
+
 static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
 {
-        int n = 0;
+        int n = 0, inline_rows;
         struct rb_node *nd;
 
         for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
@@ -156,6 +217,13 @@ static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
 
                 list_for_each_entry(chain, &child->val, list) {
                         ++n;
+
+                        if (symbol_conf.inline_name) {
+                                inline_rows =
+                                        callchain_list__inline_rows(chain);
+                                n += inline_rows;
+                        }
+
                         /* We need this because we may not have children */
                         folded_sign = callchain_list__folded(chain);
                         if (folded_sign == '+')
@@ -207,7 +275,7 @@ static int callchain_node__count_rows(struct callchain_node *node)
 {
         struct callchain_list *chain;
         bool unfolded = false;
-        int n = 0;
+        int n = 0, inline_rows;
 
         if (callchain_param.mode == CHAIN_FLAT)
                 return callchain_node__count_flat_rows(node);
@@ -216,6 +284,11 @@ static int callchain_node__count_rows(struct callchain_node *node)
 
         list_for_each_entry(chain, &node->val, list) {
                 ++n;
+                if (symbol_conf.inline_name) {
+                        inline_rows = callchain_list__inline_rows(chain);
+                        n += inline_rows;
+                }
+
                 unfolded = chain->unfolded;
         }
 
@@ -362,6 +435,19 @@ static void hist_entry__init_have_children(struct hist_entry *he)
         he->init_have_children = true;
 }
 
+static void hist_entry_init_inline_node(struct hist_entry *he)
+{
+        if (he->inline_node)
+                return;
+
+        he->inline_node = inline_node__create(he->ms.map, he->ip);
+
+        if (he->inline_node == NULL)
+                return;
+
+        he->has_children = true;
+}
+
 static bool hist_browser__toggle_fold(struct hist_browser *browser)
 {
         struct hist_entry *he = browser->he_selection;
@@ -393,7 +479,12 @@ static bool hist_browser__toggle_fold(struct hist_browser *browser)
 
                 if (he->unfolded) {
                         if (he->leaf)
-                                he->nr_rows = callchain__count_rows(&he->sorted_chain);
+                                if (he->inline_node)
+                                        he->nr_rows = inline__count_rows(
+                                                        he->inline_node);
+                                else
+                                        he->nr_rows = callchain__count_rows(
+                                                        &he->sorted_chain);
                         else
                                 he->nr_rows = hierarchy_count_rows(browser, he, false);
 
@@ -753,6 +844,71 @@ static bool hist_browser__check_dump_full(struct hist_browser *browser __maybe_u
 
 #define LEVEL_OFFSET_STEP 3
 
+static int hist_browser__show_inline(struct hist_browser *browser,
+                                     struct inline_node *node,
+                                     unsigned short row,
+                                     int offset)
+{
+        struct inline_list *ilist;
+        char buf[1024];
+        int color, width, first_row;
+
+        first_row = row;
+        width = browser->b.width - (LEVEL_OFFSET_STEP + 2);
+        list_for_each_entry(ilist, &node->val, list) {
+                if ((ilist->filename != NULL) || (ilist->funcname != NULL)) {
+                        color = HE_COLORSET_NORMAL;
+                        if (ui_browser__is_current_entry(&browser->b, row))
+                                color = HE_COLORSET_SELECTED;
+
+                        if (callchain_param.key == CCKEY_ADDRESS ||
+                            callchain_param.key == CCKEY_SRCLINE) {
+                                if (ilist->filename != NULL)
+                                        scnprintf(buf, sizeof(buf),
+                                                  "%s:%d (inline)",
+                                                  ilist->filename,
+                                                  ilist->line_nr);
+                                else
+                                        scnprintf(buf, sizeof(buf), "??");
+                        } else if (ilist->funcname != NULL)
+                                scnprintf(buf, sizeof(buf), "%s (inline)",
+                                          ilist->funcname);
+                        else if (ilist->filename != NULL)
+                                scnprintf(buf, sizeof(buf),
+                                          "%s:%d (inline)",
+                                          ilist->filename,
+                                          ilist->line_nr);
+                        else
+                                scnprintf(buf, sizeof(buf), "??");
+
+                        ui_browser__set_color(&browser->b, color);
+                        hist_browser__gotorc(browser, row, 0);
+                        ui_browser__write_nstring(&browser->b, " ",
+                                LEVEL_OFFSET_STEP + offset);
+                        ui_browser__write_nstring(&browser->b, buf, width);
+                        row++;
+                }
+        }
+
+        return row - first_row;
+}
+
+static size_t show_inline_list(struct hist_browser *browser, struct map *map,
+                               u64 ip, int row, int offset)
+{
+        struct inline_node *node;
+        int ret;
+
+        node = inline_node__create(map, ip);
+        if (node == NULL)
+                return 0;
+
+        ret = hist_browser__show_inline(browser, node, row, offset);
+
+        inline_node__delete(node);
+        return ret;
+}
+
 static int hist_browser__show_callchain_list(struct hist_browser *browser,
                                              struct callchain_node *node,
                                              struct callchain_list *chain,
@@ -764,6 +920,7 @@ static int hist_browser__show_callchain_list(struct hist_browser *browser,
         char bf[1024], *alloc_str;
         char buf[64], *alloc_str2;
         const char *str;
+        int inline_rows = 0, ret = 1;
 
         if (arg->row_offset != 0) {
                 arg->row_offset--;
@@ -801,10 +958,15 @@ static int hist_browser__show_callchain_list(struct hist_browser *browser,
         }
 
         print(browser, chain, str, offset, row, arg);
-
         free(alloc_str);
         free(alloc_str2);
-        return 1;
+
+        if (symbol_conf.inline_name) {
+                inline_rows = show_inline_list(browser, chain->ms.map,
+                                               chain->ip, row + 1, offset);
+        }
+
+        return ret + inline_rows;
 }
 
 static bool check_percent_display(struct rb_node *node, u64 parent_total)
@@ -1228,6 +1390,12 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                 folded_sign = hist_entry__folded(entry);
         }
 
+        if (symbol_conf.inline_name &&
+            (!entry->has_children)) {
+                hist_entry_init_inline_node(entry);
+                folded_sign = hist_entry__folded(entry);
+        }
+
         if (row_offset == 0) {
                 struct hpp_arg arg = {
                         .b              = &browser->b,
@@ -1259,7 +1427,8 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                         }
 
                         if (first) {
-                                if (symbol_conf.use_callchain) {
+                                if (symbol_conf.use_callchain ||
+                                        symbol_conf.inline_name) {
                                         ui_browser__printf(&browser->b, "%c ", folded_sign);
                                         width -= 2;
                                 }
@@ -1301,8 +1470,14 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                         .is_current_entry = current_entry,
                 };
 
-                printed += hist_browser__show_callchain(browser, entry, 1, row,
-                                        hist_browser__show_callchain_entry, &arg,
+                if (entry->inline_node)
+                        printed += hist_browser__show_inline(browser,
+                                        entry->inline_node, row, 0);
+                else
+                        printed += hist_browser__show_callchain(browser,
+                                        entry, 1, row,
+                                        hist_browser__show_callchain_entry,
+                                        &arg,
                                         hist_browser__check_output_full);
         }
 
@@ -2308,7 +2483,7 @@ static int switch_data_file(void)
                 return ret;
 
         memset(options, 0, sizeof(options));
-        memset(options, 0, sizeof(abs_path));
+        memset(abs_path, 0, sizeof(abs_path));
 
         while ((dent = readdir(pwd_dir))) {
                 char path[PATH_MAX];
diff --git a/tools/perf/ui/browsers/map.c b/tools/perf/ui/browsers/map.c
index 9ce142de536d..ffa5addf631d 100644
--- a/tools/perf/ui/browsers/map.c
+++ b/tools/perf/ui/browsers/map.c
@@ -11,6 +11,8 @@
 #include "../keysyms.h"
 #include "map.h"
 
+#include "sane_ctype.h"
+
 struct map_browser {
         struct ui_browser b;
         struct map        *map;
diff --git a/tools/perf/ui/gtk/annotate.c b/tools/perf/ui/gtk/annotate.c
index 8c9308ac30b7..e99ba86158d2 100644
--- a/tools/perf/ui/gtk/annotate.c
+++ b/tools/perf/ui/gtk/annotate.c
@@ -3,7 +3,8 @@
 #include "util/annotate.h"
 #include "util/evsel.h"
 #include "ui/helpline.h"
-
+#include <inttypes.h>
+#include <signal.h>
 
 enum {
         ANN_COL__PERCENT,
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
index a4f02de7c1b5..e24f83957705 100644
--- a/tools/perf/ui/gtk/hists.c
+++ b/tools/perf/ui/gtk/hists.c
@@ -4,7 +4,9 @@
 #include "../sort.h"
 #include "../hist.h"
 #include "../helpline.h"
+#include "../string2.h"
 #include "gtk.h"
+#include <signal.h>
 
 #define MAX_COLUMNS                     32
 
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index 5d632dca672a..59addd52d9cd 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -1,3 +1,4 @@
+#include <inttypes.h>
 #include <math.h>
 #include <linux/compiler.h>
 
diff --git a/tools/perf/ui/setup.c b/tools/perf/ui/setup.c
index 50d13e58210f..5ea0b40c4fc2 100644
--- a/tools/perf/ui/setup.c
+++ b/tools/perf/ui/setup.c
@@ -4,6 +4,7 @@
 #include "../util/cache.h"
 #include "../util/debug.h"
 #include "../util/hist.h"
+#include "../util/util.h"
 
 pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 void *perf_gtk_handle;
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index 668f4aecf2e6..42e432bd2eb4 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -4,7 +4,10 @@
 #include "../../util/hist.h"
 #include "../../util/sort.h"
 #include "../../util/evsel.h"
-
+#include "../../util/srcline.h"
+#include "../../util/string2.h"
+#include "../../util/thread.h"
+#include "../../util/sane_ctype.h"
 
 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
 {
@@ -17,6 +20,67 @@ static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
         return ret;
 }
 
+static size_t inline__fprintf(struct map *map, u64 ip, int left_margin,
+                              int depth, int depth_mask, FILE *fp)
+{
+        struct dso *dso;
+        struct inline_node *node;
+        struct inline_list *ilist;
+        int ret = 0, i;
+
+        if (map == NULL)
+                return 0;
+
+        dso = map->dso;
+        if (dso == NULL)
+                return 0;
+
+        if (dso->kernel != DSO_TYPE_USER)
+                return 0;
+
+        node = dso__parse_addr_inlines(dso,
+                                       map__rip_2objdump(map, ip));
+        if (node == NULL)
+                return 0;
+
+        list_for_each_entry(ilist, &node->val, list) {
+                if ((ilist->filename != NULL) || (ilist->funcname != NULL)) {
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+
+                        for (i = 0; i < depth; i++) {
+                                if (depth_mask & (1 << i))
+                                        ret += fprintf(fp, "|");
+                                else
+                                        ret += fprintf(fp, " ");
+                                ret += fprintf(fp, "          ");
+                        }
+
+                        if (callchain_param.key == CCKEY_ADDRESS ||
+                            callchain_param.key == CCKEY_SRCLINE) {
+                                if (ilist->filename != NULL)
+                                        ret += fprintf(fp, "%s:%d (inline)",
+                                                       ilist->filename,
+                                                       ilist->line_nr);
+                                else
+                                        ret += fprintf(fp, "??");
+                        } else if (ilist->funcname != NULL)
+                                ret += fprintf(fp, "%s (inline)",
+                                               ilist->funcname);
+                        else if (ilist->filename != NULL)
+                                ret += fprintf(fp, "%s:%d (inline)",
+                                               ilist->filename,
+                                               ilist->line_nr);
+                        else
+                                ret += fprintf(fp, "??");
+
+                        ret += fprintf(fp, "\n");
+                }
+        }
+
+        inline_node__delete(node);
+        return ret;
+}
+
 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
                                           int left_margin)
 {
@@ -78,6 +142,10 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_node *node,
         fputs(str, fp);
         fputc('\n', fp);
         free(alloc_str);
+
+        if (symbol_conf.inline_name)
+                ret += inline__fprintf(chain->ms.map, chain->ip,
+                                       left_margin, depth, depth_mask, fp);
         return ret;
 }
 
@@ -229,6 +297,7 @@ static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
                         if (!i++ && field_order == NULL &&
                             sort_order && !prefixcmp(sort_order, "sym"))
                                 continue;
+
                         if (!printed) {
                                 ret += callchain__fprintf_left_margin(fp, left_margin);
                                 ret += fprintf(fp, "|\n");
@@ -251,6 +320,13 @@ static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
 
                         if (++entries_printed == callchain_param.print_limit)
                                 break;
+
+                        if (symbol_conf.inline_name)
+                                ret += inline__fprintf(chain->ms.map,
+                                                       chain->ip,
+                                                       left_margin,
+                                                       0, 0,
+                                                       fp);
                 }
                 root = &cnode->rb_root;
         }
@@ -529,6 +605,8 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
                                bool use_callchain)
 {
         int ret;
+        int callchain_ret = 0;
+        int inline_ret = 0;
         struct perf_hpp hpp = {
                 .buf            = bf,
                 .size           = size,
@@ -547,7 +625,16 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
         ret = fprintf(fp, "%s\n", bf);
 
         if (use_callchain)
-                ret += hist_entry_callchain__fprintf(he, total_period, 0, fp);
+                callchain_ret = hist_entry_callchain__fprintf(he, total_period,
+                                                              0, fp);
+
+        if (callchain_ret == 0 && symbol_conf.inline_name) {
+                inline_ret = inline__fprintf(he->ms.map, he->ip, 0, 0, 0, fp);
+                ret += inline_ret;
+                if (inline_ret > 0)
+                        ret += fprintf(fp, "\n");
+        } else
+                ret += callchain_ret;
 
         return ret;
 }
diff --git a/tools/perf/ui/tui/setup.c b/tools/perf/ui/tui/setup.c
index 4ea2ba861fc2..d9350a1da48b 100644
--- a/tools/perf/ui/tui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -1,6 +1,7 @@
 #include <errno.h>
 #include <signal.h>
 #include <stdbool.h>
+#include <linux/kernel.h>
 #ifdef HAVE_BACKTRACE_SUPPORT
 #include <execinfo.h>
 #endif
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
index 5da376bc1afc..069583bdc670 100644
--- a/tools/perf/util/Build
+++ b/tools/perf/util/Build
@@ -1,4 +1,3 @@
-libperf-y += alias.o
 libperf-y += annotate.o
 libperf-y += block-range.o
 libperf-y += build-id.o
@@ -17,6 +16,7 @@ libperf-y += llvm-utils.o
 libperf-y += parse-events.o
 libperf-y += perf_regs.o
 libperf-y += path.o
+libperf-y += print_binary.o
 libperf-y += rbtree.o
 libperf-y += libstring.o
 libperf-y += bitmap.o
@@ -42,6 +42,7 @@ libperf-y += pstack.o
 libperf-y += session.o
 libperf-$(CONFIG_AUDIT) += syscalltbl.o
 libperf-y += ordered-events.o
+libperf-y += namespaces.o
 libperf-y += comm.o
 libperf-y += thread.o
 libperf-y += thread_map.o
@@ -81,13 +82,16 @@ libperf-$(CONFIG_AUXTRACE) += intel-pt-decoder/
 libperf-$(CONFIG_AUXTRACE) += intel-pt.o
 libperf-$(CONFIG_AUXTRACE) += intel-bts.o
 libperf-y += parse-branch-options.o
+libperf-y += dump-insn.o
 libperf-y += parse-regs-options.o
 libperf-y += term.o
 libperf-y += help-unknown-cmd.o
 libperf-y += mem-events.o
 libperf-y += vsprintf.o
 libperf-y += drv_configs.o
+libperf-y += units.o
 libperf-y += time-utils.o
+libperf-y += expr-bison.o
 
 libperf-$(CONFIG_LIBBPF) += bpf-loader.o
 libperf-$(CONFIG_BPF_PROLOGUE) += bpf-prologue.o
@@ -140,6 +144,10 @@ $(OUTPUT)util/parse-events-bison.c: util/parse-events.y
         $(call rule_mkdir)
         $(Q)$(call echo-cmd,bison)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $@ -p parse_events_
 
+$(OUTPUT)util/expr-bison.c: util/expr.y
+        $(call rule_mkdir)
+        $(Q)$(call echo-cmd,bison)$(BISON) -v util/expr.y -d $(PARSER_DEBUG_BISON) -o $@ -p expr__
+
 $(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
         $(call rule_mkdir)
         $(Q)$(call echo-cmd,flex)$(FLEX) -o $@ --header-file=$(OUTPUT)util/pmu-flex.h util/pmu.l
@@ -152,6 +160,7 @@ CFLAGS_parse-events-flex.o  += -w
 CFLAGS_pmu-flex.o           += -w
 CFLAGS_parse-events-bison.o += -DYYENABLE_NLS=0 -w
 CFLAGS_pmu-bison.o          += -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w
+CFLAGS_expr-bison.o         += -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w
 
 $(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
 $(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
diff --git a/tools/perf/util/alias.c b/tools/perf/util/alias.c
deleted file mode 100644
index 6455471d9cd1..000000000000
--- a/tools/perf/util/alias.c
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "cache.h"
-#include "util.h"
-#include "config.h"
-
-static const char *alias_key;
-static char *alias_val;
-
-static int alias_lookup_cb(const char *k, const char *v,
-                           void *cb __maybe_unused)
-{
-        if (!prefixcmp(k, "alias.") && !strcmp(k+6, alias_key)) {
-                if (!v)
-                        return config_error_nonbool(k);
-                alias_val = strdup(v);
-                return 0;
-        }
-        return 0;
-}
-
-char *alias_lookup(const char *alias)
-{
-        alias_key = alias;
-        alias_val = NULL;
-        perf_config(alias_lookup_cb, NULL);
-        return alias_val;
-}
-
-int split_cmdline(char *cmdline, const char ***argv)
-{
-        int src, dst, count = 0, size = 16;
-        char quoted = 0;
-
-        *argv = malloc(sizeof(char*) * size);
-
-        /* split alias_string */
-        (*argv)[count++] = cmdline;
-        for (src = dst = 0; cmdline[src];) {
-                char c = cmdline[src];
-                if (!quoted && isspace(c)) {
-                        cmdline[dst++] = 0;
-                        while (cmdline[++src]
-                                        && isspace(cmdline[src]))
-                                ; /* skip */
-                        if (count >= size) {
-                                size += 16;
-                                *argv = realloc(*argv, sizeof(char*) * size);
-                        }
-                        (*argv)[count++] = cmdline + dst;
-                } else if (!quoted && (c == '\'' || c == '"')) {
-                        quoted = c;
-                        src++;
-                } else if (c == quoted) {
-                        quoted = 0;
-                        src++;
-                } else {
-                        if (c == '\\' && quoted != '\'') {
-                                src++;
-                                c = cmdline[src];
-                                if (!c) {
-                                        zfree(argv);
-                                        return error("cmdline ends with \\");
-                                }
-                        }
-                        cmdline[dst++] = c;
-                        src++;
-                }
-        }
-
-        cmdline[dst] = 0;
-
-        if (quoted) {
-                zfree(argv);
-                return error("unclosed quote");
-        }
-
-        return count;
-}
-
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 7aa57225cbf7..683f8340460c 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -7,6 +7,8 @@
  * Released under the GPL v2. (and only v2, not any later version)
  */
 
+#include <errno.h>
+#include <inttypes.h>
 #include "util.h"
 #include "ui/ui.h"
 #include "sort.h"
@@ -18,12 +20,16 @@
 #include "annotate.h"
 #include "evsel.h"
 #include "block-range.h"
+#include "string2.h"
 #include "arch/common.h"
 #include <regex.h>
 #include <pthread.h>
 #include <linux/bitops.h>
+#include <linux/kernel.h>
 #include <sys/utsname.h>
 
+#include "sane_ctype.h"
+
 const char      *disassembler_style;
 const char      *objdump_path;
 static regex_t   file_lineno;
@@ -108,6 +114,7 @@ static int arch__associate_ins_ops(struct arch* arch, const char *name, struct i
 #include "arch/arm64/annotate/instructions.c"
 #include "arch/x86/annotate/instructions.c"
 #include "arch/powerpc/annotate/instructions.c"
+#include "arch/s390/annotate/instructions.c"
 
 static struct arch architectures[] = {
         {
@@ -132,6 +139,7 @@ static struct arch architectures[] = {
         },
         {
                 .name = "s390",
+                .init = s390__annotate_init,
                 .objdump =  {
                         .comment_char = '#',
                 },
@@ -385,9 +393,7 @@ static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map *m
         if (comment == NULL)
                 return 0;
 
-        while (comment[0] != '\0' && isspace(comment[0]))
-                ++comment;
-
+        comment = ltrim(comment);
         comment__symbol(ops->source.raw, comment, &ops->source.addr, &ops->source.name);
         comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
 
@@ -432,9 +438,7 @@ static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops
         if (comment == NULL)
                 return 0;
 
-        while (comment[0] != '\0' && isspace(comment[0]))
-                ++comment;
-
+        comment = ltrim(comment);
         comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
 
         return 0;
@@ -783,10 +787,7 @@ static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, str
 
 static int disasm_line__parse(char *line, const char **namep, char **rawp)
 {
-        char *name = line, tmp;
-
-        while (isspace(name[0]))
-                ++name;
+        char tmp, *name = ltrim(line);
 
         if (name[0] == '\0')
                 return -1;
@@ -804,12 +805,7 @@ static int disasm_line__parse(char *line, const char **namep, char **rawp)
                 goto out_free_name;
 
         (*rawp)[0] = tmp;
-
-        if ((*rawp)[0] != '\0') {
-                (*rawp)++;
-                while (isspace((*rawp)[0]))
-                        ++(*rawp);
-        }
+        *rawp = ltrim(*rawp);
 
         return 0;
 
@@ -1154,7 +1150,7 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
 {
         struct annotation *notes = symbol__annotation(sym);
         struct disasm_line *dl;
-        char *line = NULL, *parsed_line, *tmp, *tmp2, *c;
+        char *line = NULL, *parsed_line, *tmp, *tmp2;
         size_t line_len;
         s64 line_ip, offset = -1;
         regmatch_t match[2];
@@ -1165,32 +1161,16 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
         if (!line)
                 return -1;
 
-        while (line_len != 0 && isspace(line[line_len - 1]))
-                line[--line_len] = '\0';
-
-        c = strchr(line, '\n');
-        if (c)
-                *c = 0;
-
         line_ip = -1;
-        parsed_line = line;
+        parsed_line = rtrim(line);
 
         /* /filename:linenr ? Save line number and ignore. */
-        if (regexec(&file_lineno, line, 2, match, 0) == 0) {
-                *line_nr = atoi(line + match[1].rm_so);
+        if (regexec(&file_lineno, parsed_line, 2, match, 0) == 0) {
+                *line_nr = atoi(parsed_line + match[1].rm_so);
                 return 0;
         }
 
-        /*
-         * Strip leading spaces:
-         */
-        tmp = line;
-        while (*tmp) {
-                if (*tmp != ' ')
-                        break;
-                tmp++;
-        }
-
+        tmp = ltrim(parsed_line);
         if (*tmp) {
                 /*
                  * Parse hexa addresses followed by ':'
@@ -1313,6 +1293,7 @@ static int dso__disassemble_filename(struct dso *dso, char *filename, size_t fil
 {
         char linkname[PATH_MAX];
         char *build_id_filename;
+        char *build_id_path = NULL;
 
         if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
             !dso__is_kcore(dso))
@@ -1328,8 +1309,14 @@ static int dso__disassemble_filename(struct dso *dso, char *filename, size_t fil
                 goto fallback;
         }
 
+        build_id_path = strdup(filename);
+        if (!build_id_path)
+                return -1;
+
+        dirname(build_id_path);
+
         if (dso__is_kcore(dso) ||
-            readlink(filename, linkname, sizeof(linkname)) < 0 ||
+            readlink(build_id_path, linkname, sizeof(linkname)) < 0 ||
             strstr(linkname, DSO__NAME_KALLSYMS) ||
             access(filename, R_OK)) {
 fallback:
@@ -1341,6 +1328,7 @@ fallback:
                 __symbol__join_symfs(filename, filename_size, dso->long_name);
         }
 
+        free(build_id_path);
         return 0;
 }
 
@@ -1441,7 +1429,7 @@ int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_na
         snprintf(command, sizeof(command),
                  "%s %s%s --start-address=0x%016" PRIx64
                  " --stop-address=0x%016" PRIx64
-                 " -l -d %s %s -C %s 2>/dev/null|grep -v %s|expand",
+                 " -l -d %s %s -C %s 2>/dev/null|grep -v %s:|expand",
                  objdump_path ? objdump_path : "objdump",
                  disassembler_style ? "-M " : "",
                  disassembler_style ? disassembler_style : "",
@@ -1488,6 +1476,12 @@ int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_na
 
         nline = 0;
         while (!feof(file)) {
+                /*
+                 * The source code line number (lineno) needs to be kept in
+                 * accross calls to symbol__parse_objdump_line(), so that it
+                 * can associate it with the instructions till the next one.
+                 * See disasm_line__new() and struct disasm_line::line_nr.
+                 */
                 if (symbol__parse_objdump_line(sym, map, arch, file, privsize,
                             &lineno) < 0)
                         break;
@@ -1657,24 +1651,31 @@ static int symbol__get_source_line(struct symbol *sym, struct map *map,
         start = map__rip_2objdump(map, sym->start);
 
         for (i = 0; i < len; i++) {
-                u64 offset;
+                u64 offset, nr_samples;
                 double percent_max = 0.0;
 
                 src_line->nr_pcnt = nr_pcnt;
 
                 for (k = 0; k < nr_pcnt; k++) {
+                        double percent = 0.0;
+
                         h = annotation__histogram(notes, evidx + k);
-                        src_line->samples[k].percent = 100.0 * h->addr[i] / h->sum;
+                        nr_samples = h->addr[i];
+                        if (h->sum)
+                                percent = 100.0 * nr_samples / h->sum;
 
-                        if (src_line->samples[k].percent > percent_max)
-                                percent_max = src_line->samples[k].percent;
+                        if (percent > percent_max)
+                                percent_max = percent;
+                        src_line->samples[k].percent = percent;
+                        src_line->samples[k].nr = nr_samples;
                 }
 
                 if (percent_max <= 0.5)
                         goto next;
 
                 offset = start + i;
-                src_line->path = get_srcline(map->dso, offset, NULL, false);
+                src_line->path = get_srcline(map->dso, offset, NULL,
+                                             false, true);
                 insert_source_line(&tmp_root, src_line);
 
         next:
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index 09776b5af991..948aa8e6fd39 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -98,7 +98,7 @@ struct cyc_hist {
 struct source_line_samples {
         double          percent;
         double          percent_sum;
-        double          nr;
+        u64             nr;
 };
 
 struct source_line {
diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
index c5a6e0b12452..0daf63b9ee3e 100644
--- a/tools/perf/util/auxtrace.c
+++ b/tools/perf/util/auxtrace.c
@@ -13,10 +13,10 @@
  *
  */
 
+#include <inttypes.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <stdbool.h>
-#include <ctype.h>
 #include <string.h>
 #include <limits.h>
 #include <errno.h>
@@ -46,7 +46,6 @@
 #include "cpumap.h"
 #include "thread_map.h"
 #include "asm/bug.h"
-#include "symbol/kallsyms.h"
 #include "auxtrace.h"
 
 #include <linux/hash.h>
@@ -59,6 +58,9 @@
 #include "intel-pt.h"
 #include "intel-bts.h"
 
+#include "sane_ctype.h"
+#include "symbol/kallsyms.h"
+
 int auxtrace_mmap__mmap(struct auxtrace_mmap *mm,
                         struct auxtrace_mmap_params *mp,
                         void *userpg, int fd)
@@ -1826,7 +1828,7 @@ static int addr_filter__resolve_kernel_syms(struct addr_filter *filt)
                 filt->addr = start;
                 if (filt->range && !filt->size && !filt->sym_to) {
                         filt->size = size;
-                        no_size = !!size;
+                        no_size = !size;
                 }
         }
 
@@ -1840,7 +1842,7 @@ static int addr_filter__resolve_kernel_syms(struct addr_filter *filt)
                 if (err)
                         return err;
                 filt->size = start + size - filt->addr;
-                no_size = !!size;
+                no_size = !size;
         }
 
         /* The very last symbol in kallsyms does not imply a particular size */
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 26fb1ee5746a..9f0de72d58e2 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -17,6 +17,7 @@
 #define __PERF_AUXTRACE_H
 
 #include <sys/types.h>
+#include <errno.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <linux/list.h>
diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c
index bc6bc7062eb4..4bd2d1d882af 100644
--- a/tools/perf/util/bpf-loader.c
+++ b/tools/perf/util/bpf-loader.c
@@ -9,7 +9,9 @@
 #include <bpf/libbpf.h>
 #include <bpf/bpf.h>
 #include <linux/err.h>
+#include <linux/kernel.h>
 #include <linux/string.h>
+#include <errno.h>
 #include "perf.h"
 #include "debug.h"
 #include "bpf-loader.h"
@@ -17,6 +19,7 @@
 #include "probe-event.h"
 #include "probe-finder.h" // for MAX_PROBES
 #include "parse-events.h"
+#include "strfilter.h"
 #include "llvm-utils.h"
 #include "c++/clang-c.h"
 
diff --git a/tools/perf/util/bpf-loader.h b/tools/perf/util/bpf-loader.h
index f2b737b225f2..48863867878b 100644
--- a/tools/perf/util/bpf-loader.h
+++ b/tools/perf/util/bpf-loader.h
@@ -85,6 +85,8 @@ int bpf__strerror_setup_stdout(struct perf_evlist *evlist, int err,
                                char *buf, size_t size);
 
 #else
+#include <errno.h>
+
 static inline struct bpf_object *
 bpf__prepare_load(const char *filename __maybe_unused,
                   bool source __maybe_unused)
diff --git a/tools/perf/util/bpf-prologue.c b/tools/perf/util/bpf-prologue.c
index 6cdbee119ceb..1356220a9f1b 100644
--- a/tools/perf/util/bpf-prologue.c
+++ b/tools/perf/util/bpf-prologue.c
@@ -12,6 +12,7 @@
 #include "bpf-loader.h"
 #include "bpf-prologue.h"
 #include "probe-finder.h"
+#include <errno.h>
 #include <dwarf-regs.h>
 #include <linux/filter.h>
 
diff --git a/tools/perf/util/bpf-prologue.h b/tools/perf/util/bpf-prologue.h
index d94cbea12899..ba564838375f 100644
--- a/tools/perf/util/bpf-prologue.h
+++ b/tools/perf/util/bpf-prologue.h
@@ -18,6 +18,8 @@ int bpf__gen_prologue(struct probe_trace_arg *args, int nargs,
                       struct bpf_insn *new_prog, size_t *new_cnt,
                       size_t cnt_space);
 #else
+#include <errno.h>
+
 static inline int
 bpf__gen_prologue(struct probe_trace_arg *args __maybe_unused,
                   int nargs __maybe_unused,
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index e528c40739cc..168cc49654e7 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -7,18 +7,26 @@
  * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
  */
 #include "util.h"
+#include <dirent.h>
+#include <errno.h>
 #include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include "build-id.h"
 #include "event.h"
 #include "symbol.h"
+#include "thread.h"
 #include <linux/kernel.h>
 #include "debug.h"
 #include "session.h"
 #include "tool.h"
 #include "header.h"
 #include "vdso.h"
+#include "path.h"
 #include "probe-file.h"
+#include "strlist.h"
 
+#include "sane_ctype.h"
 
 static bool no_buildid_cache;
 
@@ -182,13 +190,17 @@ char *build_id_cache__origname(const char *sbuild_id)
         char buf[PATH_MAX];
         char *ret = NULL, *p;
         size_t offs = 5;        /* == strlen("../..") */
+        ssize_t len;
 
         linkname = build_id_cache__linkname(sbuild_id, NULL, 0);
         if (!linkname)
                 return NULL;
 
-        if (readlink(linkname, buf, PATH_MAX) < 0)
+        len = readlink(linkname, buf, sizeof(buf) - 1);
+        if (len <= 0)
                 goto out;
+        buf[len] = '\0';
+
         /* The link should be "../..<origpath>/<sbuild_id>" */
         p = strrchr(buf, '/');  /* Cut off the "/<sbuild_id>" */
         if (p && (p > buf + offs)) {
@@ -443,14 +455,14 @@ void disable_buildid_cache(void)
 }
 
 static bool lsdir_bid_head_filter(const char *name __maybe_unused,
-                                  struct dirent *d __maybe_unused)
+                                  struct dirent *d)
 {
         return (strlen(d->d_name) == 2) &&
                 isxdigit(d->d_name[0]) && isxdigit(d->d_name[1]);
 }
 
 static bool lsdir_bid_tail_filter(const char *name __maybe_unused,
-                                  struct dirent *d __maybe_unused)
+                                  struct dirent *d)
 {
         int i = 0;
         while (isxdigit(d->d_name[i]) && i < SBUILD_ID_SIZE - 3)
@@ -690,7 +702,7 @@ int build_id_cache__add_s(const char *sbuild_id, const char *name,
                 err = 0;
 
         /* Update SDT cache : error is just warned */
-        if (build_id_cache__add_sdt_cache(sbuild_id, realname) < 0)
+        if (realname && build_id_cache__add_sdt_cache(sbuild_id, realname) < 0)
                 pr_debug4("Failed to update/scan SDT cache for %s\n", realname);
 
 out_free:
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index d27990610f9f..a96081121179 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -5,7 +5,6 @@
 #define SBUILD_ID_SIZE  (BUILD_ID_SIZE * 2 + 1)
 
 #include "tool.h"
-#include "strlist.h"
 #include <linux/types.h>
 
 extern struct perf_tool build_id__mark_dso_hit_ops;
@@ -34,6 +33,9 @@ char *build_id_cache__origname(const char *sbuild_id);
 char *build_id_cache__linkname(const char *sbuild_id, char *bf, size_t size);
 char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
                                bool is_kallsyms, bool is_vdso);
+
+struct strlist;
+
 struct strlist *build_id_cache__list_all(bool validonly);
 char *build_id_cache__complement(const char *incomplete_sbuild_id);
 int build_id_cache__list_build_ids(const char *pathname,
diff --git a/tools/perf/util/c++/clang-c.h b/tools/perf/util/c++/clang-c.h
index 0eadd792ab1f..ccafcf72b37a 100644
--- a/tools/perf/util/c++/clang-c.h
+++ b/tools/perf/util/c++/clang-c.h
@@ -20,6 +20,7 @@ extern int perf_clang__compile_bpf(const char *filename,
                                    size_t *p_obj_buf_sz);
 #else
 
+#include <errno.h>
 
 static inline void perf_clang__init(void) { }
 static inline void perf_clang__cleanup(void) { }
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 512c0c83fbc6..0328f297a748 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -15,7 +15,6 @@
 #define PERF_TRACEFS_ENVIRONMENT "PERF_TRACEFS_DIR"
 #define PERF_PAGER_ENVIRONMENT "PERF_PAGER"
 
-char *alias_lookup(const char *alias);
 int split_cmdline(char *cmdline, const char ***argv);
 
 #define alloc_nr(x) (((x)+16)*3/2)
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index aba953421a03..81fc29ac798f 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -9,6 +9,7 @@
  *
  */
 
+#include <inttypes.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdbool.h>
@@ -23,6 +24,21 @@
 #include "machine.h"
 #include "callchain.h"
 
+#define CALLCHAIN_PARAM_DEFAULT                 \
+        .mode           = CHAIN_GRAPH_ABS,      \
+        .min_percent    = 0.5,                  \
+        .order          = ORDER_CALLEE,         \
+        .key            = CCKEY_FUNCTION,       \
+        .value          = CCVAL_PERCENT,        \
+
+struct callchain_param callchain_param = {
+        CALLCHAIN_PARAM_DEFAULT
+};
+
+struct callchain_param callchain_param_default = {
+        CALLCHAIN_PARAM_DEFAULT
+};
+
 __thread struct callchain_cursor callchain_cursor;
 
 int parse_callchain_record_opt(const char *arg, struct callchain_param *param)
@@ -80,6 +96,10 @@ static int parse_callchain_sort_key(const char *value)
                 callchain_param.key = CCKEY_ADDRESS;
                 return 0;
         }
+        if (!strncmp(value, "srcline", strlen(value))) {
+                callchain_param.key = CCKEY_SRCLINE;
+                return 0;
+        }
         if (!strncmp(value, "branch", strlen(value))) {
                 callchain_param.branch_callstack = 1;
                 return 0;
@@ -108,11 +128,37 @@ static int parse_callchain_value(const char *value)
         return -1;
 }
 
+static int get_stack_size(const char *str, unsigned long *_size)
+{
+        char *endptr;
+        unsigned long size;
+        unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
+
+        size = strtoul(str, &endptr, 0);
+
+        do {
+                if (*endptr)
+                        break;
+
+                size = round_up(size, sizeof(u64));
+                if (!size || size > max_size)
+                        break;
+
+                *_size = size;
+                return 0;
+
+        } while (0);
+
+        pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
+               max_size, str);
+        return -1;
+}
+
 static int
 __parse_callchain_report_opt(const char *arg, bool allow_record_opt)
 {
         char *tok;
-        char *endptr;
+        char *endptr, *saveptr = NULL;
         bool minpcnt_set = false;
         bool record_opt_set = false;
         bool try_stack_size = false;
@@ -123,7 +169,7 @@ __parse_callchain_report_opt(const char *arg, bool allow_record_opt)
         if (!arg)
                 return 0;
 
-        while ((tok = strtok((char *)arg, ",")) != NULL) {
+        while ((tok = strtok_r((char *)arg, ",", &saveptr)) != NULL) {
                 if (!strncmp(tok, "none", strlen(tok))) {
                         callchain_param.mode = CHAIN_NONE;
                         callchain_param.enabled = false;
@@ -191,6 +237,68 @@ int parse_callchain_top_opt(const char *arg)
         return __parse_callchain_report_opt(arg, true);
 }
 
+int parse_callchain_record(const char *arg, struct callchain_param *param)
+{
+        char *tok, *name, *saveptr = NULL;
+        char *buf;
+        int ret = -1;
+
+        /* We need buffer that we know we can write to. */
+        buf = malloc(strlen(arg) + 1);
+        if (!buf)
+                return -ENOMEM;
+
+        strcpy(buf, arg);
+
+        tok = strtok_r((char *)buf, ",", &saveptr);
+        name = tok ? : (char *)buf;
+
+        do {
+                /* Framepointer style */
+                if (!strncmp(name, "fp", sizeof("fp"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                param->record_mode = CALLCHAIN_FP;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                       "needed for --call-graph fp\n");
+                        break;
+
+                /* Dwarf style */
+                } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
+                        const unsigned long default_stack_dump_size = 8192;
+
+                        ret = 0;
+                        param->record_mode = CALLCHAIN_DWARF;
+                        param->dump_size = default_stack_dump_size;
+
+                        tok = strtok_r(NULL, ",", &saveptr);
+                        if (tok) {
+                                unsigned long size = 0;
+
+                                ret = get_stack_size(tok, &size);
+                                param->dump_size = size;
+                        }
+                } else if (!strncmp(name, "lbr", sizeof("lbr"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                param->record_mode = CALLCHAIN_LBR;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                        "needed for --call-graph lbr\n");
+                        break;
+                } else {
+                        pr_err("callchain: Unknown --call-graph option "
+                               "value: %s\n", arg);
+                        break;
+                }
+
+        } while (0);
+
+        free(buf);
+        return ret;
+}
+
 int perf_callchain_config(const char *var, const char *value)
 {
         char *endptr;
@@ -510,14 +618,51 @@ enum match_result {
         MATCH_GT,
 };
 
+static enum match_result match_chain_srcline(struct callchain_cursor_node *node,
+                                             struct callchain_list *cnode)
+{
+        char *left = get_srcline(cnode->ms.map->dso,
+                                 map__rip_2objdump(cnode->ms.map, cnode->ip),
+                                 cnode->ms.sym, true, false);
+        char *right = get_srcline(node->map->dso,
+                                  map__rip_2objdump(node->map, node->ip),
+                                  node->sym, true, false);
+        enum match_result ret = MATCH_EQ;
+        int cmp;
+
+        if (left && right)
+                cmp = strcmp(left, right);
+        else if (!left && right)
+                cmp = 1;
+        else if (left && !right)
+                cmp = -1;
+        else if (cnode->ip == node->ip)
+                cmp = 0;
+        else
+                cmp = (cnode->ip < node->ip) ? -1 : 1;
+
+        if (cmp != 0)
+                ret = cmp < 0 ? MATCH_LT : MATCH_GT;
+
+        free_srcline(left);
+        free_srcline(right);
+        return ret;
+}
+
 static enum match_result match_chain(struct callchain_cursor_node *node,
                                      struct callchain_list *cnode)
 {
         struct symbol *sym = node->sym;
         u64 left, right;
 
-        if (cnode->ms.sym && sym &&
-            callchain_param.key == CCKEY_FUNCTION) {
+        if (callchain_param.key == CCKEY_SRCLINE) {
+                enum match_result match = match_chain_srcline(node, cnode);
+
+                if (match != MATCH_ERROR)
+                        return match;
+        }
+
+        if (cnode->ms.sym && sym && callchain_param.key == CCKEY_FUNCTION) {
                 left = cnode->ms.sym->start;
                 right = sym->start;
         } else {
@@ -911,15 +1056,16 @@ out:
 char *callchain_list__sym_name(struct callchain_list *cl,
                                char *bf, size_t bfsize, bool show_dso)
 {
+        bool show_addr = callchain_param.key == CCKEY_ADDRESS;
+        bool show_srcline = show_addr || callchain_param.key == CCKEY_SRCLINE;
         int printed;
 
         if (cl->ms.sym) {
-                if (callchain_param.key == CCKEY_ADDRESS &&
-                    cl->ms.map && !cl->srcline)
+                if (show_srcline && cl->ms.map && !cl->srcline)
                         cl->srcline = get_srcline(cl->ms.map->dso,
                                                   map__rip_2objdump(cl->ms.map,
                                                                     cl->ip),
-                                                  cl->ms.sym, false);
+                                                  cl->ms.sym, false, show_addr);
                 if (cl->srcline)
                         printed = scnprintf(bf, bfsize, "%s %s",
                                         cl->ms.sym->name, cl->srcline);
@@ -1063,63 +1209,100 @@ int callchain_branch_counts(struct callchain_root *root,
                                                   cycles_count);
 }
 
-static int callchain_counts_printf(FILE *fp, char *bf, int bfsize,
-                                   u64 branch_count, u64 predicted_count,
-                                   u64 abort_count, u64 cycles_count,
-                                   u64 iter_count, u64 samples_count)
+static int counts_str_build(char *bf, int bfsize,
+                             u64 branch_count, u64 predicted_count,
+                             u64 abort_count, u64 cycles_count,
+                             u64 iter_count, u64 samples_count)
 {
         double predicted_percent = 0.0;
         const char *null_str = "";
         char iter_str[32];
-        char *str;
-        u64 cycles = 0;
-
-        if (branch_count == 0) {
-                if (fp)
-                        return fprintf(fp, " (calltrace)");
+        char cycle_str[32];
+        char *istr, *cstr;
+        u64 cycles;
 
+        if (branch_count == 0)
                 return scnprintf(bf, bfsize, " (calltrace)");
-        }
+
+        cycles = cycles_count / branch_count;
 
         if (iter_count && samples_count) {
-                scnprintf(iter_str, sizeof(iter_str),
-                         ", iterations:%" PRId64 "",
-                         iter_count / samples_count);
-                str = iter_str;
+                if (cycles > 0)
+                        scnprintf(iter_str, sizeof(iter_str),
+                                 " iterations:%" PRId64 "",
+                                 iter_count / samples_count);
+                else
+                        scnprintf(iter_str, sizeof(iter_str),
+                                 "iterations:%" PRId64 "",
+                                 iter_count / samples_count);
+                istr = iter_str;
+        } else
+                istr = (char *)null_str;
+
+        if (cycles > 0) {
+                scnprintf(cycle_str, sizeof(cycle_str),
+                          "cycles:%" PRId64 "", cycles);
+                cstr = cycle_str;
         } else
-                str = (char *)null_str;
+                cstr = (char *)null_str;
 
         predicted_percent = predicted_count * 100.0 / branch_count;
-        cycles = cycles_count / branch_count;
 
-        if ((predicted_percent >= 100.0) && (abort_count == 0)) {
-                if (fp)
-                        return fprintf(fp, " (cycles:%" PRId64 "%s)",
-                                       cycles, str);
+        if ((predicted_count == branch_count) && (abort_count == 0)) {
+                if ((cycles > 0) || (istr != (char *)null_str))
+                        return scnprintf(bf, bfsize, " (%s%s)", cstr, istr);
+                else
+                        return scnprintf(bf, bfsize, "%s", (char *)null_str);
+        }
 
-                return scnprintf(bf, bfsize, " (cycles:%" PRId64 "%s)",
-                                 cycles, str);
+        if ((predicted_count < branch_count) && (abort_count == 0)) {
+                if ((cycles > 0) || (istr != (char *)null_str))
+                        return scnprintf(bf, bfsize,
+                                " (predicted:%.1f%% %s%s)",
+                                predicted_percent, cstr, istr);
+                else {
+                        return scnprintf(bf, bfsize,
+                                " (predicted:%.1f%%)",
+                                predicted_percent);
+                }
         }
 
-        if ((predicted_percent < 100.0) && (abort_count == 0)) {
-                if (fp)
-                        return fprintf(fp,
-                                " (predicted:%.1f%%, cycles:%" PRId64 "%s)",
-                                predicted_percent, cycles, str);
+        if ((predicted_count == branch_count) && (abort_count > 0)) {
+                if ((cycles > 0) || (istr != (char *)null_str))
+                        return scnprintf(bf, bfsize,
+                                " (abort:%" PRId64 " %s%s)",
+                                abort_count, cstr, istr);
+                else
+                        return scnprintf(bf, bfsize,
+                                " (abort:%" PRId64 ")",
+                                abort_count);
+        }
 
+        if ((cycles > 0) || (istr != (char *)null_str))
                 return scnprintf(bf, bfsize,
-                        " (predicted:%.1f%%, cycles:%" PRId64 "%s)",
-                        predicted_percent, cycles, str);
-        }
+                        " (predicted:%.1f%% abort:%" PRId64 " %s%s)",
+                        predicted_percent, abort_count, cstr, istr);
+
+        return scnprintf(bf, bfsize,
+                        " (predicted:%.1f%% abort:%" PRId64 ")",
+                        predicted_percent, abort_count);
+}
+
+static int callchain_counts_printf(FILE *fp, char *bf, int bfsize,
+                                   u64 branch_count, u64 predicted_count,
+                                   u64 abort_count, u64 cycles_count,
+                                   u64 iter_count, u64 samples_count)
+{
+        char str[128];
+
+        counts_str_build(str, sizeof(str), branch_count,
+                         predicted_count, abort_count, cycles_count,
+                         iter_count, samples_count);
 
         if (fp)
-                return fprintf(fp,
-                " (predicted:%.1f%%, abort:%" PRId64 ", cycles:%" PRId64 "%s)",
-                        predicted_percent, abort_count, cycles, str);
+                return fprintf(fp, "%s", str);
 
-        return scnprintf(bf, bfsize,
-                " (predicted:%.1f%%, abort:%" PRId64 ", cycles:%" PRId64 "%s)",
-                predicted_percent, abort_count, cycles, str);
+        return scnprintf(bf, bfsize, "%s", str);
 }
 
 int callchain_list_counts__printf_value(struct callchain_node *node,
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 4f4b60f1558a..c56c23dbbf72 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -77,7 +77,8 @@ typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_root *,
 
 enum chain_key {
         CCKEY_FUNCTION,
-        CCKEY_ADDRESS
+        CCKEY_ADDRESS,
+        CCKEY_SRCLINE
 };
 
 enum chain_value {
diff --git a/tools/perf/util/cgroup.c b/tools/perf/util/cgroup.c
index eafbf11442b2..03347748f3fa 100644
--- a/tools/perf/util/cgroup.c
+++ b/tools/perf/util/cgroup.c
@@ -4,6 +4,7 @@
 #include "evsel.h"
 #include "cgroup.h"
 #include "evlist.h"
+#include <linux/stringify.h>
 
 int nr_cgroups;
 
@@ -27,8 +28,8 @@ cgroupfs_find_mountpoint(char *buf, size_t maxlen)
         path_v1[0] = '\0';
         path_v2[0] = '\0';
 
-        while (fscanf(fp, "%*s %"STR(PATH_MAX)"s %"STR(PATH_MAX)"s %"
-                                STR(PATH_MAX)"s %*d %*d\n",
+        while (fscanf(fp, "%*s %"__stringify(PATH_MAX)"s %"__stringify(PATH_MAX)"s %"
+                                __stringify(PATH_MAX)"s %*d %*d\n",
                                 mountpoint, type, tokens) == 3) {
 
                 if (!path_v1[0] && !strcmp(type, "cgroup")) {
@@ -127,19 +128,19 @@ static int add_cgroup(struct perf_evlist *evlist, char *str)
                         goto found;
                 n++;
         }
-        if (atomic_read(&cgrp->refcnt) == 0)
+        if (refcount_read(&cgrp->refcnt) == 0)
                 free(cgrp);
 
         return -1;
 found:
-        atomic_inc(&cgrp->refcnt);
+        refcount_inc(&cgrp->refcnt);
         counter->cgrp = cgrp;
         return 0;
 }
 
 void close_cgroup(struct cgroup_sel *cgrp)
 {
-        if (cgrp && atomic_dec_and_test(&cgrp->refcnt)) {
+        if (cgrp && refcount_dec_and_test(&cgrp->refcnt)) {
                 close(cgrp->fd);
                 zfree(&cgrp->name);
                 free(cgrp);
diff --git a/tools/perf/util/cgroup.h b/tools/perf/util/cgroup.h
index 31f8dcdbd7ef..d91966b97cbd 100644
--- a/tools/perf/util/cgroup.h
+++ b/tools/perf/util/cgroup.h
@@ -1,14 +1,14 @@
 #ifndef __CGROUP_H__
 #define __CGROUP_H__
 
-#include <linux/atomic.h>
+#include <linux/refcount.h>
 
 struct option;
 
 struct cgroup_sel {
         char *name;
         int fd;
-        atomic_t refcnt;
+        refcount_t refcnt;
 };
 
 
diff --git a/tools/perf/util/cloexec.c b/tools/perf/util/cloexec.c
index f0dcd0ee0afa..4b4f00df58a8 100644
--- a/tools/perf/util/cloexec.c
+++ b/tools/perf/util/cloexec.c
@@ -1,3 +1,4 @@
+#include <errno.h>
 #include <sched.h>
 #include "util.h"
 #include "../perf.h"
diff --git a/tools/perf/util/cloexec.h b/tools/perf/util/cloexec.h
index d0d465953d36..94a5a7d829d5 100644
--- a/tools/perf/util/cloexec.h
+++ b/tools/perf/util/cloexec.h
@@ -3,10 +3,4 @@
 
 unsigned long perf_event_open_cloexec_flag(void);
 
-#ifdef __GLIBC_PREREQ
-#if !__GLIBC_PREREQ(2, 6) && !defined(__UCLIBC__)
-int sched_getcpu(void) __THROW;
-#endif
-#endif
-
 #endif /* __PERF_CLOEXEC_H */
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index a93997f16dec..52122bcc3170 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -1,6 +1,8 @@
 #ifndef __PERF_COLOR_H
 #define __PERF_COLOR_H
 
+#include <stdio.h>
+
 /* "\033[1;38;5;2xx;48;5;2xxm\0" is 23 bytes */
 #define COLOR_MAXLEN 24
 
diff --git a/tools/perf/util/comm.c b/tools/perf/util/comm.c
index 21b7ff382c3f..7bc981b6bf29 100644
--- a/tools/perf/util/comm.c
+++ b/tools/perf/util/comm.c
@@ -1,13 +1,15 @@
 #include "comm.h"
 #include "util.h"
+#include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <linux/atomic.h>
+#include <string.h>
+#include <linux/refcount.h>
 
 struct comm_str {
         char *str;
         struct rb_node rb_node;
-        atomic_t refcnt;
+        refcount_t refcnt;
 };
 
 /* Should perhaps be moved to struct machine */
@@ -16,13 +18,13 @@ static struct rb_root comm_str_root;
 static struct comm_str *comm_str__get(struct comm_str *cs)
 {
         if (cs)
-                atomic_inc(&cs->refcnt);
+                refcount_inc(&cs->refcnt);
         return cs;
 }
 
 static void comm_str__put(struct comm_str *cs)
 {
-        if (cs && atomic_dec_and_test(&cs->refcnt)) {
+        if (cs && refcount_dec_and_test(&cs->refcnt)) {
                 rb_erase(&cs->rb_node, &comm_str_root);
                 zfree(&cs->str);
                 free(cs);
@@ -43,7 +45,7 @@ static struct comm_str *comm_str__alloc(const char *str)
                 return NULL;
         }
 
-        atomic_set(&cs->refcnt, 0);
+        refcount_set(&cs->refcnt, 1);
 
         return cs;
 }
@@ -61,7 +63,7 @@ static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
 
                 cmp = strcmp(str, iter->str);
                 if (!cmp)
-                        return iter;
+                        return comm_str__get(iter);
 
                 if (cmp < 0)
                         p = &(*p)->rb_left;
@@ -95,8 +97,6 @@ struct comm *comm__new(const char *str, u64 timestamp, bool exec)
                 return NULL;
         }
 
-        comm_str__get(comm->comm_str);
-
         return comm;
 }
 
@@ -108,7 +108,6 @@ int comm__override(struct comm *comm, const char *str, u64 timestamp, bool exec)
         if (!new)
                 return -ENOMEM;
 
-        comm_str__get(new);
         comm_str__put(old);
         comm->comm_str = new;
         comm->start = timestamp;
diff --git a/tools/perf/util/compress.h b/tools/perf/util/compress.h
new file mode 100644
index 000000000000..67fd1bb7c2b7
--- /dev/null
+++ b/tools/perf/util/compress.h
@@ -0,0 +1,12 @@
+#ifndef PERF_COMPRESS_H
+#define PERF_COMPRESS_H
+
+#ifdef HAVE_ZLIB_SUPPORT
+int gzip_decompress_to_file(const char *input, int output_fd);
+#endif
+
+#ifdef HAVE_LZMA_SUPPORT
+int lzma_decompress_to_file(const char *input, int output_fd);
+#endif
+
+#endif /* PERF_COMPRESS_H */
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 0c7d5a4975cd..8d724f0fa5a8 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -8,12 +8,19 @@
  * Copyright (C) Johannes Schindelin, 2005
  *
  */
+#include <errno.h>
+#include <sys/param.h>
 #include "util.h"
 #include "cache.h"
 #include <subcmd/exec-cmd.h>
 #include "util/hist.h"  /* perf_hist_config */
 #include "util/llvm-utils.h"   /* perf_llvm_config */
 #include "config.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "sane_ctype.h"
 
 #define MAXNAME (256)
 
@@ -627,6 +634,8 @@ static int perf_config_set__init(struct perf_config_set *set)
 {
         int ret = -1;
         const char *home = NULL;
+        char *user_config;
+        struct stat st;
 
         /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
         if (config_exclusive_filename)
@@ -637,35 +646,41 @@ static int perf_config_set__init(struct perf_config_set *set)
         }
 
         home = getenv("HOME");
-        if (perf_config_global() && home) {
-                char *user_config = strdup(mkpath("%s/.perfconfig", home));
-                struct stat st;
 
-                if (user_config == NULL) {
-                        warning("Not enough memory to process %s/.perfconfig, "
-                                "ignoring it.", home);
-                        goto out;
-                }
+        /*
+         * Skip reading user config if:
+         *   - there is no place to read it from (HOME)
+         *   - we are asked not to (PERF_CONFIG_NOGLOBAL=1)
+         */
+        if (!home || !*home || !perf_config_global())
+                return 0;
 
-                if (stat(user_config, &st) < 0) {
-                        if (errno == ENOENT)
-                                ret = 0;
-                        goto out_free;
-                }
+        user_config = strdup(mkpath("%s/.perfconfig", home));
+        if (user_config == NULL) {
+                warning("Not enough memory to process %s/.perfconfig, "
+                        "ignoring it.", home);
+                goto out;
+        }
 
-                ret = 0;
+        if (stat(user_config, &st) < 0) {
+                if (errno == ENOENT)
+                        ret = 0;
+                goto out_free;
+        }
 
-                if (st.st_uid && (st.st_uid != geteuid())) {
-                        warning("File %s not owned by current user or root, "
-                                "ignoring it.", user_config);
-                        goto out_free;
-                }
+        ret = 0;
 
-                if (st.st_size)
-                        ret = perf_config_from_file(collect_config, user_config, set);
-out_free:
-                free(user_config);
+        if (st.st_uid && (st.st_uid != geteuid())) {
+                warning("File %s not owned by current user or root, "
+                        "ignoring it.", user_config);
+                goto out_free;
         }
+
+        if (st.st_size)
+                ret = perf_config_from_file(collect_config, user_config, set);
+
+out_free:
+        free(user_config);
 out:
         return ret;
 }
diff --git a/tools/perf/util/counts.c b/tools/perf/util/counts.c
index e3fde313deb2..c4af82ab7808 100644
--- a/tools/perf/util/counts.c
+++ b/tools/perf/util/counts.c
@@ -1,6 +1,8 @@
+#include <errno.h>
 #include <stdlib.h>
 #include "evsel.h"
 #include "counts.h"
+#include "util.h"
 
 struct perf_counts *perf_counts__new(int ncpus, int nthreads)
 {
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index 8c7504939113..37b3bb79ee08 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -3,11 +3,14 @@
 #include "../perf.h"
 #include "cpumap.h"
 #include <assert.h>
+#include <dirent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <linux/bitmap.h>
 #include "asm/bug.h"
 
+#include "sane_ctype.h"
+
 static int max_cpu_num;
 static int max_present_cpu_num;
 static int max_node_num;
@@ -29,7 +32,7 @@ static struct cpu_map *cpu_map__default_new(void)
                         cpus->map[i] = i;
 
                 cpus->nr = nr_cpus;
-                atomic_set(&cpus->refcnt, 1);
+                refcount_set(&cpus->refcnt, 1);
         }
 
         return cpus;
@@ -43,7 +46,7 @@ static struct cpu_map *cpu_map__trim_new(int nr_cpus, int *tmp_cpus)
         if (cpus != NULL) {
                 cpus->nr = nr_cpus;
                 memcpy(cpus->map, tmp_cpus, payload_size);
-                atomic_set(&cpus->refcnt, 1);
+                refcount_set(&cpus->refcnt, 1);
         }
 
         return cpus;
@@ -252,7 +255,7 @@ struct cpu_map *cpu_map__dummy_new(void)
         if (cpus != NULL) {
                 cpus->nr = 1;
                 cpus->map[0] = -1;
-                atomic_set(&cpus->refcnt, 1);
+                refcount_set(&cpus->refcnt, 1);
         }
 
         return cpus;
@@ -269,7 +272,7 @@ struct cpu_map *cpu_map__empty_new(int nr)
                 for (i = 0; i < nr; i++)
                         cpus->map[i] = -1;
 
-                atomic_set(&cpus->refcnt, 1);
+                refcount_set(&cpus->refcnt, 1);
         }
 
         return cpus;
@@ -278,7 +281,7 @@ struct cpu_map *cpu_map__empty_new(int nr)
 static void cpu_map__delete(struct cpu_map *map)
 {
         if (map) {
-                WARN_ONCE(atomic_read(&map->refcnt) != 0,
+                WARN_ONCE(refcount_read(&map->refcnt) != 0,
                           "cpu_map refcnt unbalanced\n");
                 free(map);
         }
@@ -287,13 +290,13 @@ static void cpu_map__delete(struct cpu_map *map)
 struct cpu_map *cpu_map__get(struct cpu_map *map)
 {
         if (map)
-                atomic_inc(&map->refcnt);
+                refcount_inc(&map->refcnt);
         return map;
 }
 
 void cpu_map__put(struct cpu_map *map)
 {
-        if (map && atomic_dec_and_test(&map->refcnt))
+        if (map && refcount_dec_and_test(&map->refcnt))
                 cpu_map__delete(map);
 }
 
@@ -357,7 +360,7 @@ int cpu_map__build_map(struct cpu_map *cpus, struct cpu_map **res,
         /* ensure we process id in increasing order */
         qsort(c->map, c->nr, sizeof(int), cmp_ids);
 
-        atomic_set(&c->refcnt, 1);
+        refcount_set(&c->refcnt, 1);
         *res = c;
         return 0;
 }
@@ -673,3 +676,49 @@ size_t cpu_map__snprint(struct cpu_map *map, char *buf, size_t size)
         pr_debug("cpumask list: %s\n", buf);
         return ret;
 }
+
+static char hex_char(unsigned char val)
+{
+        if (val < 10)
+                return val + '0';
+        if (val < 16)
+                return val - 10 + 'a';
+        return '?';
+}
+
+size_t cpu_map__snprint_mask(struct cpu_map *map, char *buf, size_t size)
+{
+        int i, cpu;
+        char *ptr = buf;
+        unsigned char *bitmap;
+        int last_cpu = cpu_map__cpu(map, map->nr - 1);
+
+        bitmap = zalloc((last_cpu + 7) / 8);
+        if (bitmap == NULL) {
+                buf[0] = '\0';
+                return 0;
+        }
+
+        for (i = 0; i < map->nr; i++) {
+                cpu = cpu_map__cpu(map, i);
+                bitmap[cpu / 8] |= 1 << (cpu % 8);
+        }
+
+        for (cpu = last_cpu / 4 * 4; cpu >= 0; cpu -= 4) {
+                unsigned char bits = bitmap[cpu / 8];
+
+                if (cpu % 8)
+                        bits >>= 4;
+                else
+                        bits &= 0xf;
+
+                *ptr++ = hex_char(bits);
+                if ((cpu % 32) == 0 && cpu > 0)
+                        *ptr++ = ',';
+        }
+        *ptr = '\0';
+        free(bitmap);
+
+        buf[size - 1] = '\0';
+        return ptr - buf;
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 1a0549af8f5c..6b8bff87481d 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -3,13 +3,13 @@
 
 #include <stdio.h>
 #include <stdbool.h>
-#include <linux/atomic.h>
+#include <linux/refcount.h>
 
 #include "perf.h"
 #include "util/debug.h"
 
 struct cpu_map {
-        atomic_t refcnt;
+        refcount_t refcnt;
         int nr;
         int map[];
 };
@@ -20,6 +20,7 @@ struct cpu_map *cpu_map__dummy_new(void);
 struct cpu_map *cpu_map__new_data(struct cpu_map_data *data);
 struct cpu_map *cpu_map__read(FILE *file);
 size_t cpu_map__snprint(struct cpu_map *map, char *buf, size_t size);
+size_t cpu_map__snprint_mask(struct cpu_map *map, char *buf, size_t size);
 size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp);
 int cpu_map__get_socket_id(int cpu);
 int cpu_map__get_socket(struct cpu_map *map, int idx, void *data);
diff --git a/tools/perf/util/ctype.c b/tools/perf/util/ctype.c
index d4a5a21c2a7e..4b261c2ec0f1 100644
--- a/tools/perf/util/ctype.c
+++ b/tools/perf/util/ctype.c
@@ -3,7 +3,7 @@
  *
  * No surprises, and works with signed and unsigned chars.
  */
-#include "util.h"
+#include "sane_ctype.h"
 
 enum {
         S = GIT_SPACE,
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
index 4e6cbc99f08e..89d50318833d 100644
--- a/tools/perf/util/data-convert-bt.c
+++ b/tools/perf/util/data-convert-bt.c
@@ -7,7 +7,10 @@
  * Released under the GPL v2. (and only v2, not any later version)
  */
 
+#include <errno.h>
+#include <inttypes.h>
 #include <linux/compiler.h>
+#include <linux/kernel.h>
 #include <babeltrace/ctf-writer/writer.h>
 #include <babeltrace/ctf-writer/clock.h>
 #include <babeltrace/ctf-writer/stream.h>
@@ -27,6 +30,7 @@
 #include "evsel.h"
 #include "machine.h"
 #include "config.h"
+#include "sane_ctype.h"
 
 #define pr_N(n, fmt, ...) \
         eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
@@ -1468,6 +1472,7 @@ int bt_convert__perf2ctf(const char *input, const char *path,
                         .lost            = perf_event__process_lost,
                         .tracing_data    = perf_event__process_tracing_data,
                         .build_id        = perf_event__process_build_id,
+                        .namespaces      = perf_event__process_namespaces,
                         .ordered_events  = true,
                         .ordering_requires_timestamps = true,
                 },
diff --git a/tools/perf/util/data.c b/tools/perf/util/data.c
index 60bfc9ca1e22..e84bbc8ec058 100644
--- a/tools/perf/util/data.c
+++ b/tools/perf/util/data.c
@@ -2,6 +2,7 @@
 #include <linux/kernel.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <errno.h>
 #include <unistd.h>
 #include <string.h>
 
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 03eb81f30d0d..a5b3777ffee6 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -2,19 +2,26 @@
 
 #include "../perf.h"
 
+#include <inttypes.h>
 #include <string.h>
 #include <stdarg.h>
 #include <stdio.h>
+#include <sys/wait.h>
 #include <api/debug.h>
 #include <linux/time64.h>
-
+#ifdef HAVE_BACKTRACE_SUPPORT
+#include <execinfo.h>
+#endif
 #include "cache.h"
 #include "color.h"
 #include "event.h"
 #include "debug.h"
+#include "print_binary.h"
 #include "util.h"
 #include "target.h"
 
+#include "sane_ctype.h"
+
 int verbose;
 bool dump_trace = false, quiet = false;
 int debug_ordered_events;
@@ -244,3 +251,31 @@ void perf_debug_setup(void)
 {
         libapi_set_print(pr_warning_wrapper, pr_warning_wrapper, pr_debug_wrapper);
 }
+
+/* Obtain a backtrace and print it to stdout. */
+#ifdef HAVE_BACKTRACE_SUPPORT
+void dump_stack(void)
+{
+        void *array[16];
+        size_t size = backtrace(array, ARRAY_SIZE(array));
+        char **strings = backtrace_symbols(array, size);
+        size_t i;
+
+        printf("Obtained %zd stack frames.\n", size);
+
+        for (i = 0; i < size; i++)
+                printf("%s\n", strings[i]);
+
+        free(strings);
+}
+#else
+void dump_stack(void) {}
+#endif
+
+void sighandler_dump_stack(int sig)
+{
+        psignal(sig, "perf");
+        dump_stack();
+        signal(sig, SIG_DFL);
+        raise(sig);
+}
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 98832f5531d3..8a23ea1a71c7 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -56,4 +56,7 @@ int perf_debug_option(const char *str);
 void perf_debug_setup(void);
 int perf_quiet_option(void);
 
+void dump_stack(void);
+void sighandler_dump_stack(int sig);
+
 #endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/demangle-java.c b/tools/perf/util/demangle-java.c
index 3e6062ab2cdd..cb66d334f532 100644
--- a/tools/perf/util/demangle-java.c
+++ b/tools/perf/util/demangle-java.c
@@ -7,6 +7,8 @@
 
 #include "demangle-java.h"
 
+#include "sane_ctype.h"
+
 enum {
         MODE_PREFIX = 0,
         MODE_CLASS  = 1,
diff --git a/tools/perf/util/drv_configs.c b/tools/perf/util/drv_configs.c
index 1647f285c629..eec754243f4d 100644
--- a/tools/perf/util/drv_configs.c
+++ b/tools/perf/util/drv_configs.c
@@ -17,6 +17,7 @@
 #include "evlist.h"
 #include "evsel.h"
 #include "pmu.h"
+#include <errno.h>
 
 static int
 perf_evsel__apply_drv_configs(struct perf_evsel *evsel,
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index d38b62a700ca..a96a99d2369f 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -1,12 +1,20 @@
 #include <asm/bug.h>
+#include <linux/kernel.h>
 #include <sys/time.h>
 #include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+#include "compress.h"
+#include "path.h"
 #include "symbol.h"
 #include "dso.h"
 #include "machine.h"
 #include "auxtrace.h"
 #include "util.h"
 #include "debug.h"
+#include "string2.h"
 #include "vdso.h"
 
 static const char * const debuglink_paths[] = {
@@ -1109,7 +1117,7 @@ struct dso *dso__new(const char *name)
                 INIT_LIST_HEAD(&dso->node);
                 INIT_LIST_HEAD(&dso->data.open_entry);
                 pthread_mutex_init(&dso->lock, NULL);
-                atomic_set(&dso->refcnt, 1);
+                refcount_set(&dso->refcnt, 1);
         }
 
         return dso;
@@ -1147,13 +1155,13 @@ void dso__delete(struct dso *dso)
 struct dso *dso__get(struct dso *dso)
 {
         if (dso)
-                atomic_inc(&dso->refcnt);
+                refcount_inc(&dso->refcnt);
         return dso;
 }
 
 void dso__put(struct dso *dso)
 {
-        if (dso && atomic_dec_and_test(&dso->refcnt))
+        if (dso && refcount_dec_and_test(&dso->refcnt))
                 dso__delete(dso);
 }
 
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index ecc4bbd3f82e..12350b171727 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -1,7 +1,7 @@
 #ifndef __PERF_DSO
 #define __PERF_DSO
 
-#include <linux/atomic.h>
+#include <linux/refcount.h>
 #include <linux/types.h>
 #include <linux/rbtree.h>
 #include <sys/types.h>
@@ -187,7 +187,7 @@ struct dso {
                 void     *priv;
                 u64      db_id;
         };
-        atomic_t         refcnt;
+        refcount_t       refcnt;
         char             name[0];
 };
 
diff --git a/tools/perf/util/dump-insn.c b/tools/perf/util/dump-insn.c
new file mode 100644
index 000000000000..ffbdb19f05d0
--- /dev/null
+++ b/tools/perf/util/dump-insn.c
@@ -0,0 +1,14 @@
+#include <linux/compiler.h>
+#include "dump-insn.h"
+
+/* Fallback code */
+
+__weak
+const char *dump_insn(struct perf_insn *x __maybe_unused,
+                      u64 ip __maybe_unused, u8 *inbuf __maybe_unused,
+                      int inlen __maybe_unused, int *lenp)
+{
+        if (lenp)
+                *lenp = 0;
+        return "?";
+}
diff --git a/tools/perf/util/dump-insn.h b/tools/perf/util/dump-insn.h
new file mode 100644
index 000000000000..90fb115981cf
--- /dev/null
+++ b/tools/perf/util/dump-insn.h
@@ -0,0 +1,22 @@
+#ifndef __PERF_DUMP_INSN_H
+#define __PERF_DUMP_INSN_H 1
+
+#define MAXINSN 15
+
+#include <linux/types.h>
+
+struct thread;
+
+struct perf_insn {
+        /* Initialized by callers: */
+        struct thread *thread;
+        u8            cpumode;
+        bool          is64bit;
+        int           cpu;
+        /* Temporary */
+        char          out[256];
+};
+
+const char *dump_insn(struct perf_insn *x, u64 ip,
+                      u8 *inbuf, int inlen, int *lenp);
+#endif
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index 41e068e94349..f5acda13dcfa 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -17,10 +17,13 @@
  *
  */
 
+#include <errno.h>
+#include <inttypes.h>
 #include <stdbool.h>
 #include "util.h"
 #include "debug.h"
 #include "dwarf-aux.h"
+#include "string2.h"
 
 /**
  * cu_find_realpath - Find the realpath of the target file
diff --git a/tools/perf/util/dwarf-regs.c b/tools/perf/util/dwarf-regs.c
index 62bc4a86a970..c708395b3cb6 100644
--- a/tools/perf/util/dwarf-regs.c
+++ b/tools/perf/util/dwarf-regs.c
@@ -8,6 +8,7 @@
 #include <debug.h>
 #include <dwarf-regs.h>
 #include <elf.h>
+#include <linux/kernel.h>
 
 #ifndef EM_AARCH64
 #define EM_AARCH64      183  /* ARM 64 bit */
diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c
index 075fc77286bf..9e21538c42ae 100644
--- a/tools/perf/util/env.c
+++ b/tools/perf/util/env.c
@@ -1,6 +1,7 @@
 #include "cpumap.h"
 #include "env.h"
 #include "util.h"
+#include <errno.h>
 
 struct perf_env perf_env;
 
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 4ea7ce72ed9c..142835c0ca0a 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -1,15 +1,23 @@
+#include <dirent.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <linux/kernel.h>
 #include <linux/types.h>
-#include <linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */
 #include <api/fs/fs.h>
 #include "event.h"
 #include "debug.h"
 #include "hist.h"
 #include "machine.h"
 #include "sort.h"
-#include "string.h"
+#include "string2.h"
 #include "strlist.h"
 #include "thread.h"
 #include "thread_map.h"
+#include "sane_ctype.h"
 #include "symbol/kallsyms.h"
 #include "asm/bug.h"
 #include "stat.h"
@@ -31,6 +39,7 @@ static const char *perf_event__names[] = {
         [PERF_RECORD_LOST_SAMPLES]              = "LOST_SAMPLES",
         [PERF_RECORD_SWITCH]                    = "SWITCH",
         [PERF_RECORD_SWITCH_CPU_WIDE]           = "SWITCH_CPU_WIDE",
+        [PERF_RECORD_NAMESPACES]                = "NAMESPACES",
         [PERF_RECORD_HEADER_ATTR]               = "ATTR",
         [PERF_RECORD_HEADER_EVENT_TYPE]         = "EVENT_TYPE",
         [PERF_RECORD_HEADER_TRACING_DATA]       = "TRACING_DATA",
@@ -49,6 +58,16 @@ static const char *perf_event__names[] = {
         [PERF_RECORD_TIME_CONV]                 = "TIME_CONV",
 };
 
+static const char *perf_ns__names[] = {
+        [NET_NS_INDEX]          = "net",
+        [UTS_NS_INDEX]          = "uts",
+        [IPC_NS_INDEX]          = "ipc",
+        [PID_NS_INDEX]          = "pid",
+        [USER_NS_INDEX]         = "user",
+        [MNT_NS_INDEX]          = "mnt",
+        [CGROUP_NS_INDEX]       = "cgroup",
+};
+
 const char *perf_event__name(unsigned int id)
 {
         if (id >= ARRAY_SIZE(perf_event__names))
@@ -58,6 +77,13 @@ const char *perf_event__name(unsigned int id)
         return perf_event__names[id];
 }
 
+static const char *perf_ns__name(unsigned int id)
+{
+        if (id >= ARRAY_SIZE(perf_ns__names))
+                return "UNKNOWN";
+        return perf_ns__names[id];
+}
+
 static int perf_tool__process_synth_event(struct perf_tool *tool,
                                           union perf_event *event,
                                           struct machine *machine,
@@ -88,7 +114,7 @@ static int perf_event__get_comm_ids(pid_t pid, char *comm, size_t len,
         int fd;
         size_t size = 0;
         ssize_t n;
-        char *nl, *name, *tgids, *ppids;
+        char *name, *tgids, *ppids;
 
         *tgid = -1;
         *ppid = -1;
@@ -115,10 +141,10 @@ static int perf_event__get_comm_ids(pid_t pid, char *comm, size_t len,
         ppids = strstr(bf, "PPid:");
 
         if (name) {
-                name += 5;  /* strlen("Name:") */
+                char *nl;
 
-                while (*name && isspace(*name))
-                        ++name;
+                name += 5;  /* strlen("Name:") */
+                name = ltrim(name);
 
                 nl = strchr(name, '\n');
                 if (nl)
@@ -203,6 +229,58 @@ pid_t perf_event__synthesize_comm(struct perf_tool *tool,
         return tgid;
 }
 
+static void perf_event__get_ns_link_info(pid_t pid, const char *ns,
+                                         struct perf_ns_link_info *ns_link_info)
+{
+        struct stat64 st;
+        char proc_ns[128];
+
+        sprintf(proc_ns, "/proc/%u/ns/%s", pid, ns);
+        if (stat64(proc_ns, &st) == 0) {
+                ns_link_info->dev = st.st_dev;
+                ns_link_info->ino = st.st_ino;
+        }
+}
+
+int perf_event__synthesize_namespaces(struct perf_tool *tool,
+                                      union perf_event *event,
+                                      pid_t pid, pid_t tgid,
+                                      perf_event__handler_t process,
+                                      struct machine *machine)
+{
+        u32 idx;
+        struct perf_ns_link_info *ns_link_info;
+
+        if (!tool || !tool->namespace_events)
+                return 0;
+
+        memset(&event->namespaces, 0, (sizeof(event->namespaces) +
+               (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
+               machine->id_hdr_size));
+
+        event->namespaces.pid = tgid;
+        event->namespaces.tid = pid;
+
+        event->namespaces.nr_namespaces = NR_NAMESPACES;
+
+        ns_link_info = event->namespaces.link_info;
+
+        for (idx = 0; idx < event->namespaces.nr_namespaces; idx++)
+                perf_event__get_ns_link_info(pid, perf_ns__name(idx),
+                                             &ns_link_info[idx]);
+
+        event->namespaces.header.type = PERF_RECORD_NAMESPACES;
+
+        event->namespaces.header.size = (sizeof(event->namespaces) +
+                        (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
+                        machine->id_hdr_size);
+
+        if (perf_tool__process_synth_event(tool, event, machine, process) != 0)
+                return -1;
+
+        return 0;
+}
+
 static int perf_event__synthesize_fork(struct perf_tool *tool,
                                        union perf_event *event,
                                        pid_t pid, pid_t tgid, pid_t ppid,
@@ -255,8 +333,8 @@ int perf_event__synthesize_mmap_events(struct perf_tool *tool,
         if (machine__is_default_guest(machine))
                 return 0;
 
-        snprintf(filename, sizeof(filename), "%s/proc/%d/maps",
-                 machine->root_dir, pid);
+        snprintf(filename, sizeof(filename), "%s/proc/%d/task/%d/maps",
+                 machine->root_dir, pid, pid);
 
         fp = fopen(filename, "r");
         if (fp == NULL) {
@@ -434,8 +512,9 @@ int perf_event__synthesize_modules(struct perf_tool *tool,
 static int __event__synthesize_thread(union perf_event *comm_event,
                                       union perf_event *mmap_event,
                                       union perf_event *fork_event,
+                                      union perf_event *namespaces_event,
                                       pid_t pid, int full,
-                                          perf_event__handler_t process,
+                                      perf_event__handler_t process,
                                       struct perf_tool *tool,
                                       struct machine *machine,
                                       bool mmap_data,
@@ -455,6 +534,11 @@ static int __event__synthesize_thread(union perf_event *comm_event,
                 if (tgid == -1)
                         return -1;
 
+                if (perf_event__synthesize_namespaces(tool, namespaces_event, pid,
+                                                      tgid, process, machine) < 0)
+                        return -1;
+
+
                 return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
                                                           process, machine, mmap_data,
                                                           proc_map_timeout);
@@ -488,6 +572,11 @@ static int __event__synthesize_thread(union perf_event *comm_event,
                 if (perf_event__synthesize_fork(tool, fork_event, _pid, tgid,
                                                 ppid, process, machine) < 0)
                         break;
+
+                if (perf_event__synthesize_namespaces(tool, namespaces_event, _pid,
+                                                      tgid, process, machine) < 0)
+                        break;
+
                 /*
                  * Send the prepared comm event
                  */
@@ -516,6 +605,7 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
                                       unsigned int proc_map_timeout)
 {
         union perf_event *comm_event, *mmap_event, *fork_event;
+        union perf_event *namespaces_event;
         int err = -1, thread, j;
 
         comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size);
@@ -530,10 +620,16 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
         if (fork_event == NULL)
                 goto out_free_mmap;
 
+        namespaces_event = malloc(sizeof(namespaces_event->namespaces) +
+                                  (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
+                                  machine->id_hdr_size);
+        if (namespaces_event == NULL)
+                goto out_free_fork;
+
         err = 0;
         for (thread = 0; thread < threads->nr; ++thread) {
                 if (__event__synthesize_thread(comm_event, mmap_event,
-                                               fork_event,
+                                               fork_event, namespaces_event,
                                                thread_map__pid(threads, thread), 0,
                                                process, tool, machine,
                                                mmap_data, proc_map_timeout)) {
@@ -559,7 +655,7 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
                         /* if not, generate events for it */
                         if (need_leader &&
                             __event__synthesize_thread(comm_event, mmap_event,
-                                                       fork_event,
+                                                       fork_event, namespaces_event,
                                                        comm_event->comm.pid, 0,
                                                        process, tool, machine,
                                                        mmap_data, proc_map_timeout)) {
@@ -568,6 +664,8 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
                         }
                 }
         }
+        free(namespaces_event);
+out_free_fork:
         free(fork_event);
 out_free_mmap:
         free(mmap_event);
@@ -587,6 +685,7 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
         char proc_path[PATH_MAX];
         struct dirent *dirent;
         union perf_event *comm_event, *mmap_event, *fork_event;
+        union perf_event *namespaces_event;
         int err = -1;
 
         if (machine__is_default_guest(machine))
@@ -604,11 +703,17 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
         if (fork_event == NULL)
                 goto out_free_mmap;
 
+        namespaces_event = malloc(sizeof(namespaces_event->namespaces) +
+                                  (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
+                                  machine->id_hdr_size);
+        if (namespaces_event == NULL)
+                goto out_free_fork;
+
         snprintf(proc_path, sizeof(proc_path), "%s/proc", machine->root_dir);
         proc = opendir(proc_path);
 
         if (proc == NULL)
-                goto out_free_fork;
+                goto out_free_namespaces;
 
         while ((dirent = readdir(proc)) != NULL) {
                 char *end;
@@ -620,13 +725,16 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
                  * We may race with exiting thread, so don't stop just because
                  * one thread couldn't be synthesized.
                  */
-                __event__synthesize_thread(comm_event, mmap_event, fork_event, pid,
-                                           1, process, tool, machine, mmap_data,
+                __event__synthesize_thread(comm_event, mmap_event, fork_event,
+                                           namespaces_event, pid, 1, process,
+                                           tool, machine, mmap_data,
                                            proc_map_timeout);
         }
 
         err = 0;
         closedir(proc);
+out_free_namespaces:
+        free(namespaces_event);
 out_free_fork:
         free(fork_event);
 out_free_mmap:
@@ -1008,6 +1116,33 @@ size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
         return fprintf(fp, "%s: %s:%d/%d\n", s, event->comm.comm, event->comm.pid, event->comm.tid);
 }
 
+size_t perf_event__fprintf_namespaces(union perf_event *event, FILE *fp)
+{
+        size_t ret = 0;
+        struct perf_ns_link_info *ns_link_info;
+        u32 nr_namespaces, idx;
+
+        ns_link_info = event->namespaces.link_info;
+        nr_namespaces = event->namespaces.nr_namespaces;
+
+        ret += fprintf(fp, " %d/%d - nr_namespaces: %u\n\t\t[",
+                       event->namespaces.pid,
+                       event->namespaces.tid,
+                       nr_namespaces);
+
+        for (idx = 0; idx < nr_namespaces; idx++) {
+                if (idx && (idx % 4 == 0))
+                        ret += fprintf(fp, "\n\t\t ");
+
+                ret  += fprintf(fp, "%u/%s: %" PRIu64 "/%#" PRIx64 "%s", idx,
+                                perf_ns__name(idx), (u64)ns_link_info[idx].dev,
+                                (u64)ns_link_info[idx].ino,
+                                ((idx + 1) != nr_namespaces) ? ", " : "]\n");
+        }
+
+        return ret;
+}
+
 int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
                              struct perf_sample *sample,
@@ -1016,6 +1151,14 @@ int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
         return machine__process_comm_event(machine, event, sample);
 }
 
+int perf_event__process_namespaces(struct perf_tool *tool __maybe_unused,
+                                   union perf_event *event,
+                                   struct perf_sample *sample,
+                                   struct machine *machine)
+{
+        return machine__process_namespaces_event(machine, event, sample);
+}
+
 int perf_event__process_lost(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
                              struct perf_sample *sample,
@@ -1153,11 +1296,12 @@ int perf_event__process_exit(struct perf_tool *tool __maybe_unused,
 
 size_t perf_event__fprintf_aux(union perf_event *event, FILE *fp)
 {
-        return fprintf(fp, " offset: %#"PRIx64" size: %#"PRIx64" flags: %#"PRIx64" [%s%s]\n",
+        return fprintf(fp, " offset: %#"PRIx64" size: %#"PRIx64" flags: %#"PRIx64" [%s%s%s]\n",
                        event->aux.aux_offset, event->aux.aux_size,
                        event->aux.flags,
                        event->aux.flags & PERF_AUX_FLAG_TRUNCATED ? "T" : "",
-                       event->aux.flags & PERF_AUX_FLAG_OVERWRITE ? "O" : "");
+                       event->aux.flags & PERF_AUX_FLAG_OVERWRITE ? "O" : "",
+                       event->aux.flags & PERF_AUX_FLAG_PARTIAL   ? "P" : "");
 }
 
 size_t perf_event__fprintf_itrace_start(union perf_event *event, FILE *fp)
@@ -1196,6 +1340,9 @@ size_t perf_event__fprintf(union perf_event *event, FILE *fp)
         case PERF_RECORD_MMAP:
                 ret += perf_event__fprintf_mmap(event, fp);
                 break;
+        case PERF_RECORD_NAMESPACES:
+                ret += perf_event__fprintf_namespaces(event, fp);
+                break;
         case PERF_RECORD_MMAP2:
                 ret += perf_event__fprintf_mmap2(event, fp);
                 break;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index c735c53a26f8..db2de6413518 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -3,9 +3,9 @@
 
 #include <limits.h>
 #include <stdio.h>
+#include <linux/kernel.h>
 
 #include "../perf.h"
-#include "map.h"
 #include "build-id.h"
 #include "perf_regs.h"
 
@@ -39,6 +39,13 @@ struct comm_event {
         char comm[16];
 };
 
+struct namespaces_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        u64 nr_namespaces;
+        struct perf_ns_link_info link_info[];
+};
+
 struct fork_event {
         struct perf_event_header header;
         u32 pid, ppid;
@@ -269,6 +276,7 @@ struct events_stats {
         u64 total_lost;
         u64 total_lost_samples;
         u64 total_aux_lost;
+        u64 total_aux_partial;
         u64 total_invalid_chains;
         u32 nr_events[PERF_RECORD_HEADER_MAX];
         u32 nr_non_filtered_samples;
@@ -485,6 +493,7 @@ union perf_event {
         struct mmap_event               mmap;
         struct mmap2_event              mmap2;
         struct comm_event               comm;
+        struct namespaces_event         namespaces;
         struct fork_event               fork;
         struct lost_event               lost;
         struct lost_samples_event       lost_samples;
@@ -587,6 +596,10 @@ int perf_event__process_switch(struct perf_tool *tool,
                                union perf_event *event,
                                struct perf_sample *sample,
                                struct machine *machine);
+int perf_event__process_namespaces(struct perf_tool *tool,
+                                   union perf_event *event,
+                                   struct perf_sample *sample,
+                                   struct machine *machine);
 int perf_event__process_mmap(struct perf_tool *tool,
                              union perf_event *event,
                              struct perf_sample *sample,
@@ -636,6 +649,12 @@ pid_t perf_event__synthesize_comm(struct perf_tool *tool,
                                   perf_event__handler_t process,
                                   struct machine *machine);
 
+int perf_event__synthesize_namespaces(struct perf_tool *tool,
+                                      union perf_event *event,
+                                      pid_t pid, pid_t tgid,
+                                      perf_event__handler_t process,
+                                      struct machine *machine);
+
 int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                                        union perf_event *event,
                                        pid_t pid, pid_t tgid,
@@ -653,6 +672,7 @@ size_t perf_event__fprintf_itrace_start(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_switch(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_thread_map(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_cpu_map(union perf_event *event, FILE *fp);
+size_t perf_event__fprintf_namespaces(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf(union perf_event *event, FILE *fp);
 
 u64 kallsyms__get_function_start(const char *kallsyms_filename,
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index b601f2814a30..46c0faf6c502 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -8,6 +8,8 @@
  */
 #include "util.h"
 #include <api/fs/fs.h>
+#include <errno.h>
+#include <inttypes.h>
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
@@ -15,12 +17,15 @@
 #include "evlist.h"
 #include "evsel.h"
 #include "debug.h"
+#include "units.h"
 #include "asm/bug.h"
+#include <signal.h>
 #include <unistd.h>
 
 #include "parse-events.h"
 #include <subcmd/parse-options.h>
 
+#include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include <linux/bitops.h>
@@ -777,7 +782,7 @@ union perf_event *perf_mmap__read_forward(struct perf_mmap *md, bool check_messu
         /*
          * Check if event was unmapped due to a POLLHUP/POLLERR.
          */
-        if (!atomic_read(&md->refcnt))
+        if (!refcount_read(&md->refcnt))
                 return NULL;
 
         head = perf_mmap__read_head(md);
@@ -794,7 +799,7 @@ perf_mmap__read_backward(struct perf_mmap *md)
         /*
          * Check if event was unmapped due to a POLLHUP/POLLERR.
          */
-        if (!atomic_read(&md->refcnt))
+        if (!refcount_read(&md->refcnt))
                 return NULL;
 
         head = perf_mmap__read_head(md);
@@ -856,7 +861,7 @@ void perf_mmap__read_catchup(struct perf_mmap *md)
 {
         u64 head;
 
-        if (!atomic_read(&md->refcnt))
+        if (!refcount_read(&md->refcnt))
                 return;
 
         head = perf_mmap__read_head(md);
@@ -875,14 +880,14 @@ static bool perf_mmap__empty(struct perf_mmap *md)
 
 static void perf_mmap__get(struct perf_mmap *map)
 {
-        atomic_inc(&map->refcnt);
+        refcount_inc(&map->refcnt);
 }
 
 static void perf_mmap__put(struct perf_mmap *md)
 {
-        BUG_ON(md->base && atomic_read(&md->refcnt) == 0);
+        BUG_ON(md->base && refcount_read(&md->refcnt) == 0);
 
-        if (atomic_dec_and_test(&md->refcnt))
+        if (refcount_dec_and_test(&md->refcnt))
                 perf_mmap__munmap(md);
 }
 
@@ -894,7 +899,7 @@ void perf_mmap__consume(struct perf_mmap *md, bool overwrite)
                 perf_mmap__write_tail(md, old);
         }
 
-        if (atomic_read(&md->refcnt) == 1 && perf_mmap__empty(md))
+        if (refcount_read(&md->refcnt) == 1 && perf_mmap__empty(md))
                 perf_mmap__put(md);
 }
 
@@ -937,7 +942,7 @@ static void perf_mmap__munmap(struct perf_mmap *map)
                 munmap(map->base, perf_mmap__mmap_len(map));
                 map->base = NULL;
                 map->fd = -1;
-                atomic_set(&map->refcnt, 0);
+                refcount_set(&map->refcnt, 0);
         }
         auxtrace_mmap__munmap(&map->auxtrace_mmap);
 }
@@ -974,8 +979,19 @@ static struct perf_mmap *perf_evlist__alloc_mmap(struct perf_evlist *evlist)
         if (!map)
                 return NULL;
 
-        for (i = 0; i < evlist->nr_mmaps; i++)
+        for (i = 0; i < evlist->nr_mmaps; i++) {
                 map[i].fd = -1;
+                /*
+                 * When the perf_mmap() call is made we grab one refcount, plus
+                 * one extra to let perf_evlist__mmap_consume() get the last
+                 * events after all real references (perf_mmap__get()) are
+                 * dropped.
+                 *
+                 * Each PERF_EVENT_IOC_SET_OUTPUT points to this mmap and
+                 * thus does perf_mmap__get() on it.
+                 */
+                refcount_set(&map[i].refcnt, 0);
+        }
         return map;
 }
 
@@ -1001,7 +1017,7 @@ static int perf_mmap__mmap(struct perf_mmap *map,
          * evlist layer can't just drop it when filtering events in
          * perf_evlist__filter_pollfd().
          */
-        atomic_set(&map->refcnt, 2);
+        refcount_set(&map->refcnt, 2);
         map->prev = 0;
         map->mask = mp->mask;
         map->base = mmap(NULL, perf_mmap__mmap_len(map), mp->prot,
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 389b9ccdf8c7..94cea4398a13 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -1,7 +1,8 @@
 #ifndef __PERF_EVLIST_H
 #define __PERF_EVLIST_H 1
 
-#include <linux/atomic.h>
+#include <linux/kernel.h>
+#include <linux/refcount.h>
 #include <linux/list.h>
 #include <api/fd/array.h>
 #include <stdio.h>
@@ -10,6 +11,7 @@
 #include "evsel.h"
 #include "util.h"
 #include "auxtrace.h"
+#include <signal.h>
 #include <unistd.h>
 
 struct pollfd;
@@ -29,7 +31,7 @@ struct perf_mmap {
         void             *base;
         int              mask;
         int              fd;
-        atomic_t         refcnt;
+        refcount_t       refcnt;
         u64              prev;
         struct auxtrace_mmap auxtrace_mmap;
         char             event_copy[PERF_SAMPLE_MAX_SIZE] __attribute__((aligned(8)));
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index ac59710b79e0..0e879097adfb 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -8,12 +8,15 @@
  */
 
 #include <byteswap.h>
+#include <errno.h>
+#include <inttypes.h>
 #include <linux/bitops.h>
 #include <api/fs/tracing_path.h>
 #include <traceevent/event-parse.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/perf_event.h>
 #include <linux/err.h>
+#include <sys/ioctl.h>
 #include <sys/resource.h>
 #include "asm/bug.h"
 #include "callchain.h"
@@ -30,6 +33,8 @@
 #include "stat.h"
 #include "util/parse-branch-options.h"
 
+#include "sane_ctype.h"
+
 static struct {
         bool sample_id_all;
         bool exclude_guest;
@@ -236,6 +241,10 @@ void perf_evsel__init(struct perf_evsel *evsel,
         evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
         perf_evsel__calc_id_pos(evsel);
         evsel->cmdline_group_boundary = false;
+        evsel->metric_expr   = NULL;
+        evsel->metric_name   = NULL;
+        evsel->metric_events = NULL;
+        evsel->collect_stat  = false;
 }
 
 struct perf_evsel *perf_evsel__new_idx(struct perf_event_attr *attr, int idx)
@@ -932,6 +941,9 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
         attr->mmap2 = track && !perf_missing_features.mmap2;
         attr->comm  = track;
 
+        if (opts->record_namespaces)
+                attr->namespaces  = track;
+
         if (opts->record_switch_events)
                 attr->context_switch = track;
 
@@ -1232,7 +1244,7 @@ int perf_evsel__read(struct perf_evsel *evsel, int cpu, int thread,
         if (FD(evsel, cpu, thread) < 0)
                 return -EINVAL;
 
-        if (readn(FD(evsel, cpu, thread), count, sizeof(*count)) < 0)
+        if (readn(FD(evsel, cpu, thread), count, sizeof(*count)) <= 0)
                 return -errno;
 
         return 0;
@@ -1250,7 +1262,7 @@ int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
         if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0)
                 return -ENOMEM;
 
-        if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
+        if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) <= 0)
                 return -errno;
 
         perf_evsel__compute_deltas(evsel, cpu, thread, &count);
@@ -2450,11 +2462,17 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
                               int err, char *msg, size_t size)
 {
         char sbuf[STRERR_BUFSIZE];
+        int printed = 0;
 
         switch (err) {
         case EPERM:
         case EACCES:
-                return scnprintf(msg, size,
+                if (err == EPERM)
+                        printed = scnprintf(msg, size,
+                                "No permission to enable %s event.\n\n",
+                                perf_evsel__name(evsel));
+
+                return scnprintf(msg + printed, size - printed,
                  "You may not have permission to collect %sstats.\n\n"
                  "Consider tweaking /proc/sys/kernel/perf_event_paranoid,\n"
                  "which controls use of the performance events system by\n"
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 06ef6f29efa1..d101695c482c 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -131,6 +131,11 @@ struct perf_evsel {
         bool                    cmdline_group_boundary;
         struct list_head        config_terms;
         int                     bpf_fd;
+        bool                    merged_stat;
+        const char *            metric_expr;
+        const char *            metric_name;
+        struct perf_evsel       **metric_events;
+        bool                    collect_stat;
 };
 
 union u64_swap {
diff --git a/tools/perf/util/evsel_fprintf.c b/tools/perf/util/evsel_fprintf.c
index 4ef5184819a0..e415aee6a245 100644
--- a/tools/perf/util/evsel_fprintf.c
+++ b/tools/perf/util/evsel_fprintf.c
@@ -1,9 +1,11 @@
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <traceevent/event-parse.h>
 #include "evsel.h"
 #include "callchain.h"
 #include "map.h"
+#include "strlist.h"
 #include "symbol.h"
 
 static int comma_fprintf(FILE *fp, bool *first, const char *fmt, ...)
diff --git a/tools/perf/util/expr.h b/tools/perf/util/expr.h
new file mode 100644
index 000000000000..9c2760a1a96e
--- /dev/null
+++ b/tools/perf/util/expr.h
@@ -0,0 +1,25 @@
+#ifndef PARSE_CTX_H
+#define PARSE_CTX_H 1
+
+#define EXPR_MAX_OTHER 8
+#define MAX_PARSE_ID EXPR_MAX_OTHER
+
+struct parse_id {
+        const char *name;
+        double val;
+};
+
+struct parse_ctx {
+        int num_ids;
+        struct parse_id ids[MAX_PARSE_ID];
+};
+
+void expr__ctx_init(struct parse_ctx *ctx);
+void expr__add_id(struct parse_ctx *ctx, const char *id, double val);
+#ifndef IN_EXPR_Y
+int expr__parse(double *final_val, struct parse_ctx *ctx, const char **pp);
+#endif
+int expr__find_other(const char *p, const char *one, const char ***other,
+                int *num_other);
+
+#endif
diff --git a/tools/perf/util/expr.y b/tools/perf/util/expr.y
new file mode 100644
index 000000000000..954556bea36e
--- /dev/null
+++ b/tools/perf/util/expr.y
@@ -0,0 +1,173 @@
+/* Simple expression parser */
+%{
+#include "util.h"
+#include "util/debug.h"
+#define IN_EXPR_Y 1
+#include "expr.h"
+#include <string.h>
+
+#define MAXIDLEN 256
+%}
+
+%pure-parser
+%parse-param { double *final_val }
+%parse-param { struct parse_ctx *ctx }
+%parse-param { const char **pp }
+%lex-param { const char **pp }
+
+%union {
+        double num;
+        char id[MAXIDLEN+1];
+}
+
+%token <num> NUMBER
+%token <id> ID
+%left '|'
+%left '^'
+%left '&'
+%left '-' '+'
+%left '*' '/' '%'
+%left NEG NOT
+%type <num> expr
+
+%{
+static int expr__lex(YYSTYPE *res, const char **pp);
+
+static void expr__error(double *final_val __maybe_unused,
+                       struct parse_ctx *ctx __maybe_unused,
+                       const char **pp __maybe_unused,
+                       const char *s)
+{
+        pr_debug("%s\n", s);
+}
+
+static int lookup_id(struct parse_ctx *ctx, char *id, double *val)
+{
+        int i;
+
+        for (i = 0; i < ctx->num_ids; i++) {
+                if (!strcasecmp(ctx->ids[i].name, id)) {
+                        *val = ctx->ids[i].val;
+                        return 0;
+                }
+        }
+        return -1;
+}
+
+%}
+%%
+
+all_expr: expr                  { *final_val = $1; }
+        ;
+
+expr:     NUMBER
+        | ID                    { if (lookup_id(ctx, $1, &$$) < 0) {
+                                        pr_debug("%s not found", $1);
+                                        YYABORT;
+                                  }
+                                }
+        | expr '+' expr         { $$ = $1 + $3; }
+        | expr '-' expr         { $$ = $1 - $3; }
+        | expr '*' expr         { $$ = $1 * $3; }
+        | expr '/' expr         { if ($3 == 0) YYABORT; $$ = $1 / $3; }
+        | expr '%' expr         { if ((long)$3 == 0) YYABORT; $$ = (long)$1 % (long)$3; }
+        | '-' expr %prec NEG    { $$ = -$2; }
+        | '(' expr ')'          { $$ = $2; }
+        ;
+
+%%
+
+static int expr__symbol(YYSTYPE *res, const char *p, const char **pp)
+{
+        char *dst = res->id;
+        const char *s = p;
+
+        while (isalnum(*p) || *p == '_' || *p == '.') {
+                if (p - s >= MAXIDLEN)
+                        return -1;
+                *dst++ = *p++;
+        }
+        *dst = 0;
+        *pp = p;
+        return ID;
+}
+
+static int expr__lex(YYSTYPE *res, const char **pp)
+{
+        int tok;
+        const char *s;
+        const char *p = *pp;
+
+        while (isspace(*p))
+                p++;
+        s = p;
+        switch (*p++) {
+        case 'a' ... 'z':
+        case 'A' ... 'Z':
+                return expr__symbol(res, p - 1, pp);
+        case '0' ... '9': case '.':
+                res->num = strtod(s, (char **)&p);
+                tok = NUMBER;
+                break;
+        default:
+                tok = *s;
+                break;
+        }
+        *pp = p;
+        return tok;
+}
+
+/* Caller must make sure id is allocated */
+void expr__add_id(struct parse_ctx *ctx, const char *name, double val)
+{
+        int idx;
+        assert(ctx->num_ids < MAX_PARSE_ID);
+        idx = ctx->num_ids++;
+        ctx->ids[idx].name = name;
+        ctx->ids[idx].val = val;
+}
+
+void expr__ctx_init(struct parse_ctx *ctx)
+{
+        ctx->num_ids = 0;
+}
+
+int expr__find_other(const char *p, const char *one, const char ***other,
+                     int *num_otherp)
+{
+        const char *orig = p;
+        int err = -1;
+        int num_other;
+
+        *other = malloc((EXPR_MAX_OTHER + 1) * sizeof(char *));
+        if (!*other)
+                return -1;
+
+        num_other = 0;
+        for (;;) {
+                YYSTYPE val;
+                int tok = expr__lex(&val, &p);
+                if (tok == 0) {
+                        err = 0;
+                        break;
+                }
+                if (tok == ID && strcasecmp(one, val.id)) {
+                        if (num_other >= EXPR_MAX_OTHER - 1) {
+                                pr_debug("Too many extra events in %s\n", orig);
+                                break;
+                        }
+                        (*other)[num_other] = strdup(val.id);
+                        if (!(*other)[num_other])
+                                return -1;
+                        num_other++;
+                }
+        }
+        (*other)[num_other] = NULL;
+        *num_otherp = num_other;
+        if (err) {
+                *num_otherp = 0;
+                free(*other);
+                *other = NULL;
+        }
+        return err;
+}
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 05714d548584..948b2c5efb65 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,4 +1,8 @@
+#include <errno.h>
+#include <inttypes.h>
 #include "util.h"
+#include "string2.h"
+#include <sys/param.h>
 #include <sys/types.h>
 #include <byteswap.h>
 #include <unistd.h>
@@ -7,7 +11,10 @@
 #include <linux/list.h>
 #include <linux/kernel.h>
 #include <linux/bitops.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <sys/utsname.h>
+#include <unistd.h>
 
 #include "evlist.h"
 #include "evsel.h"
@@ -26,6 +33,8 @@
 #include <api/fs/fs.h>
 #include "asm/bug.h"
 
+#include "sane_ctype.h"
+
 /*
  * magic2 = "PERFILE2"
  * must be a numerical value to let the endianness
@@ -370,15 +379,11 @@ static int write_cmdline(int fd, struct perf_header *h __maybe_unused,
                          struct perf_evlist *evlist __maybe_unused)
 {
         char buf[MAXPATHLEN];
-        char proc[32];
         u32 n;
         int i, ret;
 
-        /*
-         * actual atual path to perf binary
-         */
-        sprintf(proc, "/proc/%d/exe", getpid());
-        ret = readlink(proc, buf, sizeof(buf));
+        /* actual path to perf binary */
+        ret = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
         if (ret <= 0)
                 return -1;
 
@@ -2274,6 +2279,9 @@ int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
         perf_header__process_sections(header, fd, &hd,
                                       perf_file_section__fprintf_info);
 
+        if (session->file->is_pipe)
+                return 0;
+
         fprintf(fp, "# missing features: ");
         for_each_clear_bit(bit, header->adds_features, HEADER_LAST_FEATURE) {
                 if (bit)
diff --git a/tools/perf/util/help-unknown-cmd.c b/tools/perf/util/help-unknown-cmd.c
index 2821f8d77e52..1c88ad6425b8 100644
--- a/tools/perf/util/help-unknown-cmd.c
+++ b/tools/perf/util/help-unknown-cmd.c
@@ -1,21 +1,18 @@
 #include "cache.h"
 #include "config.h"
+#include <poll.h>
 #include <stdio.h>
 #include <subcmd/help.h>
 #include "../builtin.h"
 #include "levenshtein.h"
 
 static int autocorrect;
-static struct cmdnames aliases;
 
 static int perf_unknown_cmd_config(const char *var, const char *value,
                                    void *cb __maybe_unused)
 {
         if (!strcmp(var, "help.autocorrect"))
                 autocorrect = perf_config_int(var,value);
-        /* Also use aliases for command lookup */
-        if (!prefixcmp(var, "alias."))
-                add_cmdname(&aliases, var + 6, strlen(var + 6));
 
         return 0;
 }
@@ -59,14 +56,12 @@ const char *help_unknown_cmd(const char *cmd)
 
         memset(&main_cmds, 0, sizeof(main_cmds));
         memset(&other_cmds, 0, sizeof(main_cmds));
-        memset(&aliases, 0, sizeof(aliases));
 
         perf_config(perf_unknown_cmd_config, NULL);
 
         load_command_list("perf-", &main_cmds, &other_cmds);
 
-        if (add_cmd_list(&main_cmds, &aliases) < 0 ||
-            add_cmd_list(&main_cmds, &other_cmds) < 0) {
+        if (add_cmd_list(&main_cmds, &other_cmds) < 0) {
                 fprintf(stderr, "ERROR: Failed to allocate command list for unknown command.\n");
                 goto end;
         }
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index eaf72a938fb4..cf0186a088c1 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -3,12 +3,17 @@
 #include "hist.h"
 #include "map.h"
 #include "session.h"
+#include "namespaces.h"
 #include "sort.h"
 #include "evlist.h"
 #include "evsel.h"
 #include "annotate.h"
+#include "srcline.h"
+#include "thread.h"
 #include "ui/progress.h"
+#include <errno.h>
 #include <math.h>
+#include <sys/param.h>
 
 static bool hists__filter_entry_by_dso(struct hists *hists,
                                        struct hist_entry *he);
@@ -169,6 +174,7 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                 hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
         }
 
+        hists__new_col_len(hists, HISTC_CGROUP_ID, 20);
         hists__new_col_len(hists, HISTC_CPU, 3);
         hists__new_col_len(hists, HISTC_SOCKET, 6);
         hists__new_col_len(hists, HISTC_MEM_LOCKED, 6);
@@ -574,9 +580,14 @@ __hists__add_entry(struct hists *hists,
                    bool sample_self,
                    struct hist_entry_ops *ops)
 {
+        struct namespaces *ns = thread__namespaces(al->thread);
         struct hist_entry entry = {
                 .thread = al->thread,
                 .comm = thread__comm(al->thread),
+                .cgroup_id = {
+                        .dev = ns ? ns->link_info[CGROUP_NS_INDEX].dev : 0,
+                        .ino = ns ? ns->link_info[CGROUP_NS_INDEX].ino : 0,
+                },
                 .ms = {
                         .map    = al->map,
                         .sym    = al->sym,
@@ -1129,6 +1140,11 @@ void hist_entry__delete(struct hist_entry *he)
                 zfree(&he->mem_info);
         }
 
+        if (he->inline_node) {
+                inline_node__delete(he->inline_node);
+                he->inline_node = NULL;
+        }
+
         zfree(&he->stat_acc);
         free_srcline(he->srcline);
         if (he->srcfile && he->srcfile[0])
@@ -2447,7 +2463,7 @@ int parse_filter_percentage(const struct option *opt __maybe_unused,
         else if (!strcmp(arg, "absolute"))
                 symbol_conf.filter_relative = false;
         else {
-                pr_debug("Invalud percentage: %s\n", arg);
+                pr_debug("Invalid percentage: %s\n", arg);
                 return -1;
         }
 
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 28c216e3d5b7..ee3670a388df 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -30,6 +30,7 @@ enum hist_column {
         HISTC_DSO,
         HISTC_THREAD,
         HISTC_COMM,
+        HISTC_CGROUP_ID,
         HISTC_PARENT,
         HISTC_CPU,
         HISTC_SOCKET,
@@ -57,6 +58,7 @@ enum hist_column {
         HISTC_SRCLINE_FROM,
         HISTC_SRCLINE_TO,
         HISTC_TRACE,
+        HISTC_SYM_SIZE,
         HISTC_NR_COLS, /* Last entry */
 };
 
diff --git a/tools/perf/util/intel-bts.c b/tools/perf/util/intel-bts.c
index 6c2eb5da4afc..b2834ac7b1f5 100644
--- a/tools/perf/util/intel-bts.c
+++ b/tools/perf/util/intel-bts.c
@@ -14,7 +14,9 @@
  */
 
 #include <endian.h>
+#include <errno.h>
 #include <byteswap.h>
+#include <inttypes.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/bitops.h>
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-insn-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-insn-decoder.c
index 4f3c758d875d..54818828023b 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-insn-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-insn-decoder.c
@@ -26,6 +26,7 @@
 #include "insn.c"
 
 #include "intel-pt-insn-decoder.h"
+#include "dump-insn.h"
 
 #if INTEL_PT_INSN_BUF_SZ < MAX_INSN_SIZE || INTEL_PT_INSN_BUF_SZ > MAX_INSN
 #error Instruction buffer size too small
@@ -39,6 +40,8 @@ static void intel_pt_insn_decoder(struct insn *insn,
         enum intel_pt_insn_branch branch = INTEL_PT_BR_NO_BRANCH;
         int ext;
 
+        intel_pt_insn->rel = 0;
+
         if (insn_is_avx(insn)) {
                 intel_pt_insn->op = INTEL_PT_OP_OTHER;
                 intel_pt_insn->branch = INTEL_PT_BR_NO_BRANCH;
@@ -177,6 +180,29 @@ int intel_pt_get_insn(const unsigned char *buf, size_t len, int x86_64,
         return 0;
 }
 
+const char *dump_insn(struct perf_insn *x, uint64_t ip __maybe_unused,
+                      u8 *inbuf, int inlen, int *lenp)
+{
+        struct insn insn;
+        int n, i;
+        int left;
+
+        insn_init(&insn, inbuf, inlen, x->is64bit);
+        insn_get_length(&insn);
+        if (!insn_complete(&insn) || insn.length > inlen)
+                return "<bad>";
+        if (lenp)
+                *lenp = insn.length;
+        left = sizeof(x->out);
+        n = snprintf(x->out, left, "insn: ");
+        left -= n;
+        for (i = 0; i < insn.length; i++) {
+                n += snprintf(x->out + n, left, "%02x ", inbuf[i]);
+                left -= n;
+        }
+        return x->out;
+}
+
 const char *branch_name[] = {
         [INTEL_PT_OP_OTHER]     = "Other",
         [INTEL_PT_OP_CALL]      = "Call",
diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
index da20cd5612e9..bdd4a28c6cee 100644
--- a/tools/perf/util/intel-pt.c
+++ b/tools/perf/util/intel-pt.c
@@ -13,6 +13,7 @@
  *
  */
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdbool.h>
 #include <errno.h>
diff --git a/tools/perf/util/jitdump.c b/tools/perf/util/jitdump.c
index c9a941ef0f6d..9084930e1757 100644
--- a/tools/perf/util/jitdump.c
+++ b/tools/perf/util/jitdump.c
@@ -1,5 +1,6 @@
 #include <sys/sysmacros.h>
 #include <sys/types.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -9,13 +10,13 @@
 #include <byteswap.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
+#include <linux/stringify.h>
 
 #include "util.h"
 #include "event.h"
 #include "debug.h"
 #include "evlist.h"
 #include "symbol.h"
-#include "strlist.h"
 #include <elf.h>
 
 #include "tsc.h"
@@ -25,6 +26,8 @@
 #include "genelf.h"
 #include "../builtin.h"
 
+#include "sane_ctype.h"
+
 struct jit_buf_desc {
         struct perf_data_file *output;
         struct perf_session *session;
@@ -181,7 +184,7 @@ jit_open(struct jit_buf_desc *jd, const char *name)
                         jd->use_arch_timestamp);
 
         if (header.version > JITHEADER_VERSION) {
-                pr_err("wrong jitdump version %u, expected " STR(JITHEADER_VERSION),
+                pr_err("wrong jitdump version %u, expected " __stringify(JITHEADER_VERSION),
                         header.version);
                 goto error;
         }
diff --git a/tools/perf/util/llvm-utils.c b/tools/perf/util/llvm-utils.c
index 824356488ce6..c6a15f204c03 100644
--- a/tools/perf/util/llvm-utils.c
+++ b/tools/perf/util/llvm-utils.c
@@ -12,6 +12,7 @@
 #include "llvm-utils.h"
 #include "config.h"
 #include "util.h"
+#include <sys/wait.h>
 
 #define CLANG_BPF_CMD_DEFAULT_TEMPLATE                          \
                 "$CLANG_EXEC -D__KERNEL__ -D__NR_CPUS__=$NR_CPUS "\
diff --git a/tools/perf/util/lzma.c b/tools/perf/util/lzma.c
index 9ddea5cecd94..4ca7c5c6cdcd 100644
--- a/tools/perf/util/lzma.c
+++ b/tools/perf/util/lzma.c
@@ -1,6 +1,8 @@
+#include <errno.h>
 #include <lzma.h>
 #include <stdio.h>
 #include <linux/compiler.h>
+#include "compress.h"
 #include "util.h"
 #include "debug.h"
 
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 71c9720d4973..7a47f52ccfcc 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -1,3 +1,7 @@
+#include <dirent.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <regex.h>
 #include "callchain.h"
 #include "debug.h"
 #include "event.h"
@@ -10,9 +14,15 @@
 #include "thread.h"
 #include "vdso.h"
 #include <stdbool.h>
-#include <symbol/kallsyms.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include "unwind.h"
 #include "linux/hash.h"
+#include "asm/bug.h"
+
+#include "sane_ctype.h"
+#include <symbol/kallsyms.h>
 
 static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock);
 
@@ -501,6 +511,37 @@ int machine__process_comm_event(struct machine *machine, union perf_event *event
         return err;
 }
 
+int machine__process_namespaces_event(struct machine *machine __maybe_unused,
+                                      union perf_event *event,
+                                      struct perf_sample *sample __maybe_unused)
+{
+        struct thread *thread = machine__findnew_thread(machine,
+                                                        event->namespaces.pid,
+                                                        event->namespaces.tid);
+        int err = 0;
+
+        WARN_ONCE(event->namespaces.nr_namespaces > NR_NAMESPACES,
+                  "\nWARNING: kernel seems to support more namespaces than perf"
+                  " tool.\nTry updating the perf tool..\n\n");
+
+        WARN_ONCE(event->namespaces.nr_namespaces < NR_NAMESPACES,
+                  "\nWARNING: perf tool seems to support more namespaces than"
+                  " the kernel.\nTry updating the kernel..\n\n");
+
+        if (dump_trace)
+                perf_event__fprintf_namespaces(event, stdout);
+
+        if (thread == NULL ||
+            thread__set_namespaces(thread, sample->time, &event->namespaces)) {
+                dump_printf("problem processing PERF_RECORD_NAMESPACES, skipping event.\n");
+                err = -1;
+        }
+
+        thread__put(thread);
+
+        return err;
+}
+
 int machine__process_lost_event(struct machine *machine __maybe_unused,
                                 union perf_event *event, struct perf_sample *sample __maybe_unused)
 {
@@ -1439,7 +1480,7 @@ static void __machine__remove_thread(struct machine *machine, struct thread *th,
         if (machine->last_match == th)
                 machine->last_match = NULL;
 
-        BUG_ON(atomic_read(&th->refcnt) == 0);
+        BUG_ON(refcount_read(&th->refcnt) == 0);
         if (lock)
                 pthread_rwlock_wrlock(&machine->threads_lock);
         rb_erase_init(&th->rb_node, &machine->threads);
@@ -1538,6 +1579,8 @@ int machine__process_event(struct machine *machine, union perf_event *event,
                 ret = machine__process_comm_event(machine, event, sample); break;
         case PERF_RECORD_MMAP:
                 ret = machine__process_mmap_event(machine, event, sample); break;
+        case PERF_RECORD_NAMESPACES:
+                ret = machine__process_namespaces_event(machine, event, sample); break;
         case PERF_RECORD_MMAP2:
                 ret = machine__process_mmap2_event(machine, event, sample); break;
         case PERF_RECORD_FORK:
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index a28305029711..3cdb1340f917 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -97,6 +97,9 @@ int machine__process_itrace_start_event(struct machine *machine,
                                         union perf_event *event);
 int machine__process_switch_event(struct machine *machine,
                                   union perf_event *event);
+int machine__process_namespaces_event(struct machine *machine,
+                                      union perf_event *event,
+                                      struct perf_sample *sample);
 int machine__process_mmap_event(struct machine *machine, union perf_event *event,
                                 struct perf_sample *sample);
 int machine__process_mmap2_event(struct machine *machine, union perf_event *event,
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 0a943e7b1ea7..ebfa5d92358a 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -9,13 +9,13 @@
 #include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */
 #include "map.h"
 #include "thread.h"
-#include "strlist.h"
 #include "vdso.h"
 #include "build-id.h"
 #include "util.h"
 #include "debug.h"
 #include "machine.h"
 #include <linux/string.h>
+#include "srcline.h"
 #include "unwind.h"
 
 static void __maps__insert(struct maps *maps, struct map *map);
@@ -141,7 +141,7 @@ void map__init(struct map *map, enum map_type type,
         RB_CLEAR_NODE(&map->rb_node);
         map->groups   = NULL;
         map->erange_warned = false;
-        atomic_set(&map->refcnt, 1);
+        refcount_set(&map->refcnt, 1);
 }
 
 struct map *map__new(struct machine *machine, u64 start, u64 len,
@@ -255,7 +255,7 @@ void map__delete(struct map *map)
 
 void map__put(struct map *map)
 {
-        if (map && atomic_dec_and_test(&map->refcnt))
+        if (map && refcount_dec_and_test(&map->refcnt))
                 map__delete(map);
 }
 
@@ -354,7 +354,7 @@ struct map *map__clone(struct map *from)
         struct map *map = memdup(from, sizeof(*map));
 
         if (map != NULL) {
-                atomic_set(&map->refcnt, 1);
+                refcount_set(&map->refcnt, 1);
                 RB_CLEAR_NODE(&map->rb_node);
                 dso__get(map->dso);
                 map->groups = NULL;
@@ -405,7 +405,8 @@ int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
 
         if (map && map->dso) {
                 srcline = get_srcline(map->dso,
-                                      map__rip_2objdump(map, addr), NULL, true);
+                                      map__rip_2objdump(map, addr), NULL,
+                                      true, true);
                 if (srcline != SRCLINE_UNKNOWN)
                         ret = fprintf(fp, "%s%s", prefix, srcline);
                 free_srcline(srcline);
@@ -485,7 +486,7 @@ void map_groups__init(struct map_groups *mg, struct machine *machine)
                 maps__init(&mg->maps[i]);
         }
         mg->machine = machine;
-        atomic_set(&mg->refcnt, 1);
+        refcount_set(&mg->refcnt, 1);
 }
 
 static void __maps__purge(struct maps *maps)
@@ -547,7 +548,7 @@ void map_groups__delete(struct map_groups *mg)
 
 void map_groups__put(struct map_groups *mg)
 {
-        if (mg && atomic_dec_and_test(&mg->refcnt))
+        if (mg && refcount_dec_and_test(&mg->refcnt))
                 map_groups__delete(mg);
 }
 
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index abdacf800c98..c8a5a644c0a9 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -1,7 +1,7 @@
 #ifndef __PERF_MAP_H
 #define __PERF_MAP_H
 
-#include <linux/atomic.h>
+#include <linux/refcount.h>
 #include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/rbtree.h>
@@ -51,7 +51,7 @@ struct map {
 
         struct dso              *dso;
         struct map_groups       *groups;
-        atomic_t                refcnt;
+        refcount_t              refcnt;
 };
 
 struct kmap {
@@ -67,7 +67,7 @@ struct maps {
 struct map_groups {
         struct maps      maps[MAP__NR_TYPES];
         struct machine   *machine;
-        atomic_t         refcnt;
+        refcount_t       refcnt;
 };
 
 struct map_groups *map_groups__new(struct machine *machine);
@@ -77,7 +77,7 @@ bool map_groups__empty(struct map_groups *mg);
 static inline struct map_groups *map_groups__get(struct map_groups *mg)
 {
         if (mg)
-                atomic_inc(&mg->refcnt);
+                refcount_inc(&mg->refcnt);
         return mg;
 }
 
@@ -150,7 +150,7 @@ struct map *map__clone(struct map *map);
 static inline struct map *map__get(struct map *map)
 {
         if (map)
-                atomic_inc(&map->refcnt);
+                refcount_inc(&map->refcnt);
         return map;
 }
 
diff --git a/tools/perf/util/mem-events.c b/tools/perf/util/mem-events.c
index 1d4ab53c60ca..06f5a3a4295c 100644
--- a/tools/perf/util/mem-events.c
+++ b/tools/perf/util/mem-events.c
@@ -6,6 +6,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <api/fs/fs.h>
+#include <linux/kernel.h>
 #include "mem-events.h"
 #include "debug.h"
 #include "symbol.h"
@@ -205,8 +206,8 @@ int perf_mem__lvl_scnprintf(char *out, size_t sz, struct mem_info *mem_info)
 static const char * const snoop_access[] = {
         "N/A",
         "None",
-        "Miss",
         "Hit",
+        "Miss",
         "HitM",
 };
 
diff --git a/tools/perf/util/namespaces.c b/tools/perf/util/namespaces.c
new file mode 100644
index 000000000000..67dcbcc73c7d
--- /dev/null
+++ b/tools/perf/util/namespaces.c
@@ -0,0 +1,37 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * Copyright (C) 2017 Hari Bathini, IBM Corporation
+ */
+
+#include "namespaces.h"
+#include "util.h"
+#include "event.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+struct namespaces *namespaces__new(struct namespaces_event *event)
+{
+        struct namespaces *namespaces;
+        u64 link_info_size = ((event ? event->nr_namespaces : NR_NAMESPACES) *
+                              sizeof(struct perf_ns_link_info));
+
+        namespaces = zalloc(sizeof(struct namespaces) + link_info_size);
+        if (!namespaces)
+                return NULL;
+
+        namespaces->end_time = -1;
+
+        if (event)
+                memcpy(namespaces->link_info, event->link_info, link_info_size);
+
+        return namespaces;
+}
+
+void namespaces__free(struct namespaces *namespaces)
+{
+        free(namespaces);
+}
diff --git a/tools/perf/util/namespaces.h b/tools/perf/util/namespaces.h
new file mode 100644
index 000000000000..468f1e9a1484
--- /dev/null
+++ b/tools/perf/util/namespaces.h
@@ -0,0 +1,26 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * Copyright (C) 2017 Hari Bathini, IBM Corporation
+ */
+
+#ifndef __PERF_NAMESPACES_H
+#define __PERF_NAMESPACES_H
+
+#include "../perf.h"
+#include <linux/list.h>
+
+struct namespaces_event;
+
+struct namespaces {
+        struct list_head list;
+        u64 end_time;
+        struct perf_ns_link_info link_info[];
+};
+
+struct namespaces *namespaces__new(struct namespaces_event *event);
+void namespaces__free(struct namespaces *namespaces);
+
+#endif  /* __PERF_NAMESPACES_H */
diff --git a/tools/perf/util/ordered-events.c b/tools/perf/util/ordered-events.c
index fe84df1875aa..4de398cfb577 100644
--- a/tools/perf/util/ordered-events.c
+++ b/tools/perf/util/ordered-events.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 #include <linux/list.h>
 #include <linux/compiler.h>
 #include <linux/string.h>
@@ -79,7 +81,7 @@ static union perf_event *dup_event(struct ordered_events *oe,
 
 static void free_dup_event(struct ordered_events *oe, union perf_event *event)
 {
-        if (oe->copy_on_queue) {
+        if (event && oe->copy_on_queue) {
                 oe->cur_alloc_size -= event->header.size;
                 free(event);
         }
@@ -150,6 +152,7 @@ void ordered_events__delete(struct ordered_events *oe, struct ordered_event *eve
         list_move(&event->list, &oe->cache);
         oe->nr_events--;
         free_dup_event(oe, event->event);
+        event->event = NULL;
 }
 
 int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 67a8aebc67ab..01e779b91c8e 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1,13 +1,18 @@
 #include <linux/hw_breakpoint.h>
 #include <linux/err.h>
-#include "util.h"
+#include <dirent.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include "term.h"
 #include "../perf.h"
 #include "evlist.h"
 #include "evsel.h"
 #include <subcmd/parse-options.h>
 #include "parse-events.h"
 #include <subcmd/exec-cmd.h>
-#include "string.h"
+#include "string2.h"
+#include "strlist.h"
 #include "symbol.h"
 #include "cache.h"
 #include "header.h"
@@ -316,8 +321,9 @@ __add_event(struct list_head *list, int *idx,
                 return NULL;
 
         (*idx)++;
-        evsel->cpus     = cpu_map__get(cpus);
-        evsel->own_cpus = cpu_map__get(cpus);
+        evsel->cpus        = cpu_map__get(cpus);
+        evsel->own_cpus    = cpu_map__get(cpus);
+        evsel->system_wide = !!cpus;
 
         if (name)
                 evsel->name = strdup(name);
@@ -1254,11 +1260,59 @@ int parse_events_add_pmu(struct parse_events_evlist *data,
                 evsel->scale = info.scale;
                 evsel->per_pkg = info.per_pkg;
                 evsel->snapshot = info.snapshot;
+                evsel->metric_expr = info.metric_expr;
+                evsel->metric_name = info.metric_name;
         }
 
         return evsel ? 0 : -ENOMEM;
 }
 
+int parse_events_multi_pmu_add(struct parse_events_evlist *data,
+                               char *str, struct list_head **listp)
+{
+        struct list_head *head;
+        struct parse_events_term *term;
+        struct list_head *list;
+        struct perf_pmu *pmu = NULL;
+        int ok = 0;
+
+        *listp = NULL;
+        /* Add it for all PMUs that support the alias */
+        list = malloc(sizeof(struct list_head));
+        if (!list)
+                return -1;
+        INIT_LIST_HEAD(list);
+        while ((pmu = perf_pmu__scan(pmu)) != NULL) {
+                struct perf_pmu_alias *alias;
+
+                list_for_each_entry(alias, &pmu->aliases, list) {
+                        if (!strcasecmp(alias->name, str)) {
+                                head = malloc(sizeof(struct list_head));
+                                if (!head)
+                                        return -1;
+                                INIT_LIST_HEAD(head);
+                                if (parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                                           str, 1, false, &str, NULL) < 0)
+                                        return -1;
+                                list_add_tail(&term->list, head);
+
+                                if (!parse_events_add_pmu(data, list,
+                                                  pmu->name, head)) {
+                                        pr_debug("%s -> %s/%s/\n", str,
+                                                 pmu->name, alias->str);
+                                        ok++;
+                                }
+
+                                parse_events_terms__delete(head);
+                        }
+                }
+        }
+        if (!ok)
+                return -1;
+        *listp = list;
+        return 0;
+}
+
 int parse_events__modifier_group(struct list_head *list,
                                  char *event_mod)
 {
@@ -2276,7 +2330,7 @@ out_enomem:
  * Print the help text for the event symbols:
  */
 void print_events(const char *event_glob, bool name_only, bool quiet_flag,
-                        bool long_desc)
+                        bool long_desc, bool details_flag)
 {
         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
                             event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
@@ -2286,7 +2340,8 @@ void print_events(const char *event_glob, bool name_only, bool quiet_flag,
 
         print_hwcache_events(event_glob, name_only);
 
-        print_pmu_events(event_glob, name_only, quiet_flag, long_desc);
+        print_pmu_events(event_glob, name_only, quiet_flag, long_desc,
+                        details_flag);
 
         if (event_glob != NULL)
                 return;
@@ -2415,6 +2470,31 @@ int parse_events_term__clone(struct parse_events_term **new,
         return new_term(new, &temp, term->val.str, term->val.num);
 }
 
+int parse_events_copy_term_list(struct list_head *old,
+                                 struct list_head **new)
+{
+        struct parse_events_term *term, *n;
+        int ret;
+
+        if (!old) {
+                *new = NULL;
+                return 0;
+        }
+
+        *new = malloc(sizeof(struct list_head));
+        if (!*new)
+                return -ENOMEM;
+        INIT_LIST_HEAD(*new);
+
+        list_for_each_entry (term, old, list) {
+                ret = parse_events_term__clone(&n, term);
+                if (ret)
+                        return ret;
+                list_add_tail(&n->list, *new);
+        }
+        return 0;
+}
+
 void parse_events_terms__purge(struct list_head *terms)
 {
         struct parse_events_term *term, *h;
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 1af6a267c21b..a235f4d6d5e5 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -8,6 +8,7 @@
 #include <stdbool.h>
 #include <linux/types.h>
 #include <linux/perf_event.h>
+#include <string.h>
 
 struct list_head;
 struct perf_evsel;
@@ -166,6 +167,14 @@ int parse_events_add_breakpoint(struct list_head *list, int *idx,
 int parse_events_add_pmu(struct parse_events_evlist *data,
                          struct list_head *list, char *name,
                          struct list_head *head_config);
+
+int parse_events_multi_pmu_add(struct parse_events_evlist *data,
+                               char *str,
+                               struct list_head **listp);
+
+int parse_events_copy_term_list(struct list_head *old,
+                                 struct list_head **new);
+
 enum perf_pmu_event_symbol_type
 perf_pmu__parse_check(const char *name);
 void parse_events__set_leader(char *name, struct list_head *list);
@@ -175,7 +184,7 @@ void parse_events_evlist_error(struct parse_events_evlist *data,
                                int idx, const char *str);
 
 void print_events(const char *event_glob, bool name_only, bool quiet,
-                  bool long_desc);
+                  bool long_desc, bool details_flag);
 
 struct event_symbol {
         const char      *symbol;
@@ -196,4 +205,23 @@ int is_valid_tracepoint(const char *event_string);
 int valid_event_mount(const char *eventfs);
 char *parse_events_formats_error_string(char *additional_terms);
 
+#ifdef HAVE_LIBELF_SUPPORT
+/*
+ * If the probe point starts with '%',
+ * or starts with "sdt_" and has a ':' but no '=',
+ * then it should be a SDT/cached probe point.
+ */
+static inline bool is_sdt_event(char *str)
+{
+        return (str[0] == '%' ||
+                (!strncmp(str, "sdt_", 4) &&
+                 !!strchr(str, ':') && !strchr(str, '=')));
+}
+#else
+static inline bool is_sdt_event(char *str __maybe_unused)
+{
+        return false;
+}
+#endif /* HAVE_LIBELF_SUPPORT */
+
 #endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 30f018ea1370..04fd8c9af9f9 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -226,68 +226,55 @@ event_pmu:
 PE_NAME opt_event_config
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list;
+        struct list_head *list, *orig_terms, *terms;
+
+        if (parse_events_copy_term_list($2, &orig_terms))
+                YYABORT;
 
         ALLOC_LIST(list);
-        ABORT_ON(parse_events_add_pmu(data, list, $1, $2));
+        if (parse_events_add_pmu(data, list, $1, $2)) {
+                struct perf_pmu *pmu = NULL;
+                int ok = 0;
+
+                while ((pmu = perf_pmu__scan(pmu)) != NULL) {
+                        char *name = pmu->name;
+
+                        if (!strncmp(name, "uncore_", 7) &&
+                            strncmp($1, "uncore_", 7))
+                                name += 7;
+                        if (!strncmp($1, name, strlen($1))) {
+                                if (parse_events_copy_term_list(orig_terms, &terms))
+                                        YYABORT;
+                                if (!parse_events_add_pmu(data, list, pmu->name, terms))
+                                        ok++;
+                                parse_events_terms__delete(terms);
+                        }
+                }
+                if (!ok)
+                        YYABORT;
+        }
         parse_events_terms__delete($2);
+        parse_events_terms__delete(orig_terms);
         $$ = list;
 }
 |
 PE_KERNEL_PMU_EVENT sep_dc
 {
-        struct parse_events_evlist *data = _data;
-        struct list_head *head;
-        struct parse_events_term *term;
         struct list_head *list;
-        struct perf_pmu *pmu = NULL;
-        int ok = 0;
-
-        /* Add it for all PMUs that support the alias */
-        ALLOC_LIST(list);
-        while ((pmu = perf_pmu__scan(pmu)) != NULL) {
-                struct perf_pmu_alias *alias;
-
-                list_for_each_entry(alias, &pmu->aliases, list) {
-                        if (!strcasecmp(alias->name, $1)) {
-                                ALLOC_LIST(head);
-                                ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
-                                        $1, 1, false, &@1, NULL));
-                                list_add_tail(&term->list, head);
-
-                                if (!parse_events_add_pmu(data, list,
-                                                  pmu->name, head)) {
-                                        pr_debug("%s -> %s/%s/\n", $1,
-                                                 pmu->name, alias->str);
-                                        ok++;
-                                }
 
-                                parse_events_terms__delete(head);
-                        }
-                }
-        }
-        if (!ok)
+        if (parse_events_multi_pmu_add(_data, $1, &list) < 0)
                 YYABORT;
         $$ = list;
 }
 |
 PE_PMU_EVENT_PRE '-' PE_PMU_EVENT_SUF sep_dc
 {
-        struct parse_events_evlist *data = _data;
-        struct list_head *head;
-        struct parse_events_term *term;
         struct list_head *list;
         char pmu_name[128];
-        snprintf(&pmu_name, 128, "%s-%s", $1, $3);
 
-        ALLOC_LIST(head);
-        ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
-                                        &pmu_name, 1, false, &@1, NULL));
-        list_add_tail(&term->list, head);
-
-        ALLOC_LIST(list);
-        ABORT_ON(parse_events_add_pmu(data, list, "cpu", head));
-        parse_events_terms__delete(head);
+        snprintf(&pmu_name, 128, "%s-%s", $1, $3);
+        if (parse_events_multi_pmu_add(_data, pmu_name, &list) < 0)
+                YYABORT;
         $$ = list;
 }
 
diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
index 7c7630be5a89..50ec3bc87a60 100644
--- a/tools/perf/util/path.c
+++ b/tools/perf/util/path.c
@@ -11,8 +11,13 @@
  * which is what it's designed for.
  */
 #include "cache.h"
-#include "util.h"
+#include "path.h"
+#include <linux/kernel.h>
 #include <limits.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 static char bad_path[] = "/bad-path/";
 /*
@@ -50,3 +55,24 @@ char *mkpath(const char *fmt, ...)
                 return bad_path;
         return cleanup_path(pathname);
 }
+
+int path__join(char *bf, size_t size, const char *path1, const char *path2)
+{
+        return scnprintf(bf, size, "%s%s%s", path1, path1[0] ? "/" : "", path2);
+}
+
+int path__join3(char *bf, size_t size, const char *path1, const char *path2, const char *path3)
+{
+        return scnprintf(bf, size, "%s%s%s%s%s", path1, path1[0] ? "/" : "",
+                         path2, path2[0] ? "/" : "", path3);
+}
+
+bool is_regular_file(const char *file)
+{
+        struct stat st;
+
+        if (stat(file, &st))
+                return false;
+
+        return S_ISREG(st.st_mode);
+}
diff --git a/tools/perf/util/path.h b/tools/perf/util/path.h
new file mode 100644
index 000000000000..9a276a58e3c2
--- /dev/null
+++ b/tools/perf/util/path.h
@@ -0,0 +1,9 @@
+#ifndef _PERF_PATH_H
+#define _PERF_PATH_H
+
+int path__join(char *bf, size_t size, const char *path1, const char *path2);
+int path__join3(char *bf, size_t size, const char *path1, const char *path2, const char *path3);
+
+bool is_regular_file(const char *file);
+
+#endif /* _PERF_PATH_H */
diff --git a/tools/perf/util/perf-hooks.c b/tools/perf/util/perf-hooks.c
index cb368306b12b..d55092964da2 100644
--- a/tools/perf/util/perf-hooks.c
+++ b/tools/perf/util/perf-hooks.c
@@ -9,6 +9,7 @@
 #include <stdlib.h>
 #include <setjmp.h>
 #include <linux/err.h>
+#include <linux/kernel.h>
 #include "util/util.h"
 #include "util/debug.h"
 #include "util/perf-hooks.h"
diff --git a/tools/perf/util/perf_regs.c b/tools/perf/util/perf_regs.c
index c4023f22f287..b2ae039eff85 100644
--- a/tools/perf/util/perf_regs.c
+++ b/tools/perf/util/perf_regs.c
@@ -6,6 +6,12 @@ const struct sample_reg __weak sample_reg_masks[] = {
         SMPL_REG_END
 };
 
+int __weak arch_sdt_arg_parse_op(char *old_op __maybe_unused,
+                                 char **new_op __maybe_unused)
+{
+        return SDT_ARG_SKIP;
+}
+
 #ifdef HAVE_PERF_REGS_SUPPORT
 int perf_reg_value(u64 *valp, struct regs_dump *regs, int id)
 {
diff --git a/tools/perf/util/perf_regs.h b/tools/perf/util/perf_regs.h
index 679d6e493962..32b37d19dcc3 100644
--- a/tools/perf/util/perf_regs.h
+++ b/tools/perf/util/perf_regs.h
@@ -15,6 +15,13 @@ struct sample_reg {
 
 extern const struct sample_reg sample_reg_masks[];
 
+enum {
+        SDT_ARG_VALID = 0,
+        SDT_ARG_SKIP,
+};
+
+int arch_sdt_arg_parse_op(char *old_op, char **new_op);
+
 #ifdef HAVE_PERF_REGS_SUPPORT
 #include <perf_regs.h>
 
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 12f84dd2ac5d..ac16a9db1fb5 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -1,6 +1,8 @@
 #include <linux/list.h>
 #include <linux/compiler.h>
 #include <sys/types.h>
+#include <errno.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdbool.h>
@@ -15,6 +17,7 @@
 #include "header.h"
 #include "pmu-events/pmu-events.h"
 #include "cache.h"
+#include "string2.h"
 
 struct perf_pmu_format {
         char *name;
@@ -231,7 +234,9 @@ static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                                  char *desc, char *val,
                                  char *long_desc, char *topic,
-                                 char *unit, char *perpkg)
+                                 char *unit, char *perpkg,
+                                 char *metric_expr,
+                                 char *metric_name)
 {
         struct perf_pmu_alias *alias;
         int ret;
@@ -265,6 +270,8 @@ static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                 perf_pmu__parse_snapshot(alias, dir, name);
         }
 
+        alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL;
+        alias->metric_name = metric_name ? strdup(metric_name): NULL;
         alias->desc = desc ? strdup(desc) : NULL;
         alias->long_desc = long_desc ? strdup(long_desc) :
                                 desc ? strdup(desc) : NULL;
@@ -294,7 +301,7 @@ static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FI
         buf[ret] = 0;
 
         return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
-                                     NULL);
+                                     NULL, NULL, NULL);
 }
 
 static inline bool pmu_alias_info_file(char *name)
@@ -564,7 +571,9 @@ static void pmu_add_cpu_aliases(struct list_head *head, const char *name)
                 __perf_pmu__new_alias(head, NULL, (char *)pe->name,
                                 (char *)pe->desc, (char *)pe->event,
                                 (char *)pe->long_desc, (char *)pe->topic,
-                                (char *)pe->unit, (char *)pe->perpkg);
+                                (char *)pe->unit, (char *)pe->perpkg,
+                                (char *)pe->metric_expr,
+                                (char *)pe->metric_name);
         }
 
 out:
@@ -991,6 +1000,8 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
         info->unit     = NULL;
         info->scale    = 0.0;
         info->snapshot = false;
+        info->metric_expr = NULL;
+        info->metric_name = NULL;
 
         list_for_each_entry_safe(term, h, head_terms, list) {
                 alias = pmu_find_alias(pmu, term);
@@ -1006,6 +1017,8 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
 
                 if (alias->per_pkg)
                         info->per_pkg = true;
+                info->metric_expr = alias->metric_expr;
+                info->metric_name = alias->metric_name;
 
                 list_del(&term->list);
                 free(term);
@@ -1100,6 +1113,8 @@ struct sevent {
         char *topic;
         char *str;
         char *pmu;
+        char *metric_expr;
+        char *metric_name;
 };
 
 static int cmp_sevent(const void *a, const void *b)
@@ -1136,13 +1151,12 @@ static void wordwrap(char *s, int start, int max, int corr)
                         break;
                 s += wlen;
                 column += n;
-                while (isspace(*s))
-                        s++;
+                s = ltrim(s);
         }
 }
 
 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
-                        bool long_desc)
+                        bool long_desc, bool details_flag)
 {
         struct perf_pmu *pmu;
         struct perf_pmu_alias *alias;
@@ -1198,6 +1212,8 @@ void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
                         aliases[j].topic = alias->topic;
                         aliases[j].str = alias->str;
                         aliases[j].pmu = pmu->name;
+                        aliases[j].metric_expr = alias->metric_expr;
+                        aliases[j].metric_name = alias->metric_name;
                         j++;
                 }
                 if (pmu->selectable &&
@@ -1232,8 +1248,14 @@ void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
                         printf("%*s", 8, "[");
                         wordwrap(aliases[j].desc, 8, columns, 0);
                         printf("]\n");
-                        if (verbose > 0)
-                                printf("%*s%s/%s/\n", 8, "", aliases[j].pmu, aliases[j].str);
+                        if (details_flag) {
+                                printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
+                                if (aliases[j].metric_name)
+                                        printf(" MetricName: %s", aliases[j].metric_name);
+                                if (aliases[j].metric_expr)
+                                        printf(" MetricExpr: %s", aliases[j].metric_expr);
+                                putchar('\n');
+                        }
                 } else
                         printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
                 printed++;
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index 00852ddc7741..ea7f450dc609 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -31,6 +31,8 @@ struct perf_pmu {
 
 struct perf_pmu_info {
         const char *unit;
+        const char *metric_expr;
+        const char *metric_name;
         double scale;
         bool per_pkg;
         bool snapshot;
@@ -50,6 +52,8 @@ struct perf_pmu_alias {
         double scale;
         bool per_pkg;
         bool snapshot;
+        char *metric_expr;
+        char *metric_name;
 };
 
 struct perf_pmu *perf_pmu__find(const char *name);
@@ -76,7 +80,7 @@ int perf_pmu__format_parse(char *dir, struct list_head *head);
 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu);
 
 void print_pmu_events(const char *event_glob, bool name_only, bool quiet,
-                      bool long_desc);
+                      bool long_desc, bool details_flag);
 bool pmu_have_event(const char *pname, const char *name);
 
 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
diff --git a/tools/perf/util/print_binary.c b/tools/perf/util/print_binary.c
new file mode 100644
index 000000000000..e908177b9976
--- /dev/null
+++ b/tools/perf/util/print_binary.c
@@ -0,0 +1,55 @@
+#include "print_binary.h"
+#include <linux/log2.h>
+#include "sane_ctype.h"
+
+void print_binary(unsigned char *data, size_t len,
+                  size_t bytes_per_line, print_binary_t printer,
+                  void *extra)
+{
+        size_t i, j, mask;
+
+        if (!printer)
+                return;
+
+        bytes_per_line = roundup_pow_of_two(bytes_per_line);
+        mask = bytes_per_line - 1;
+
+        printer(BINARY_PRINT_DATA_BEGIN, 0, extra);
+        for (i = 0; i < len; i++) {
+                if ((i & mask) == 0) {
+                        printer(BINARY_PRINT_LINE_BEGIN, -1, extra);
+                        printer(BINARY_PRINT_ADDR, i, extra);
+                }
+
+                printer(BINARY_PRINT_NUM_DATA, data[i], extra);
+
+                if (((i & mask) == mask) || i == len - 1) {
+                        for (j = 0; j < mask-(i & mask); j++)
+                                printer(BINARY_PRINT_NUM_PAD, -1, extra);
+
+                        printer(BINARY_PRINT_SEP, i, extra);
+                        for (j = i & ~mask; j <= i; j++)
+                                printer(BINARY_PRINT_CHAR_DATA, data[j], extra);
+                        for (j = 0; j < mask-(i & mask); j++)
+                                printer(BINARY_PRINT_CHAR_PAD, i, extra);
+                        printer(BINARY_PRINT_LINE_END, -1, extra);
+                }
+        }
+        printer(BINARY_PRINT_DATA_END, -1, extra);
+}
+
+int is_printable_array(char *p, unsigned int len)
+{
+        unsigned int i;
+
+        if (!p || !len || p[len - 1] != 0)
+                return 0;
+
+        len--;
+
+        for (i = 0; i < len; i++) {
+                if (!isprint(p[i]) && !isspace(p[i]))
+                        return 0;
+        }
+        return 1;
+}
diff --git a/tools/perf/util/print_binary.h b/tools/perf/util/print_binary.h
new file mode 100644
index 000000000000..da0427263d2d
--- /dev/null
+++ b/tools/perf/util/print_binary.h
@@ -0,0 +1,28 @@
+#ifndef PERF_PRINT_BINARY_H
+#define PERF_PRINT_BINARY_H
+
+#include <stddef.h>
+
+enum binary_printer_ops {
+        BINARY_PRINT_DATA_BEGIN,
+        BINARY_PRINT_LINE_BEGIN,
+        BINARY_PRINT_ADDR,
+        BINARY_PRINT_NUM_DATA,
+        BINARY_PRINT_NUM_PAD,
+        BINARY_PRINT_SEP,
+        BINARY_PRINT_CHAR_DATA,
+        BINARY_PRINT_CHAR_PAD,
+        BINARY_PRINT_LINE_END,
+        BINARY_PRINT_DATA_END,
+};
+
+typedef void (*print_binary_t)(enum binary_printer_ops op,
+                               unsigned int val, void *extra);
+
+void print_binary(unsigned char *data, size_t len,
+                  size_t bytes_per_line, print_binary_t printer,
+                  void *extra);
+
+int is_printable_array(char *p, unsigned int len);
+
+#endif /* PERF_PRINT_BINARY_H */
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 28fb62c32678..84e7e698411e 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -19,6 +19,7 @@
  *
  */
 
+#include <inttypes.h>
 #include <sys/utsname.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -35,6 +36,7 @@
 #include "util.h"
 #include "event.h"
 #include "strlist.h"
+#include "strfilter.h"
 #include "debug.h"
 #include "cache.h"
 #include "color.h"
@@ -46,8 +48,10 @@
 #include "probe-finder.h"
 #include "probe-file.h"
 #include "session.h"
+#include "string2.h"
+
+#include "sane_ctype.h"
 
-#define MAX_CMDLEN 256
 #define PERFPROBE_GROUP "probe"
 
 bool probe_event_dry_run;       /* Dry run flag */
@@ -757,7 +761,9 @@ post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
         }
 
         for (i = 0; i < ntevs; i++) {
-                if (!tevs[i].point.address || tevs[i].point.retprobe)
+                if (!tevs[i].point.address)
+                        continue;
+                if (tevs[i].point.retprobe && !kretprobe_offset_is_supported())
                         continue;
                 /* If we found a wrong one, mark it by NULL symbol */
                 if (kprobe_warn_out_range(tevs[i].point.symbol,
@@ -1339,14 +1345,7 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
         if (!arg)
                 return -EINVAL;
 
-        /*
-         * If the probe point starts with '%',
-         * or starts with "sdt_" and has a ':' but no '=',
-         * then it should be a SDT/cached probe point.
-         */
-        if (arg[0] == '%' ||
-            (!strncmp(arg, "sdt_", 4) &&
-             !!strchr(arg, ':') && !strchr(arg, '='))) {
+        if (is_sdt_event(arg)) {
                 pev->sdt = true;
                 if (arg[0] == '%')
                         arg++;
@@ -1528,11 +1527,6 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
                 return -EINVAL;
         }
 
-        if (pp->retprobe && !pp->function) {
-                semantic_error("Return probe requires an entry function.\n");
-                return -EINVAL;
-        }
-
         if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
                 semantic_error("Offset/Line/Lazy pattern can't be used with "
                                "return probe.\n");
@@ -2841,7 +2835,8 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
         }
 
         /* Note that the symbols in the kmodule are not relocated */
-        if (!pev->uprobes && !pp->retprobe && !pev->target) {
+        if (!pev->uprobes && !pev->target &&
+                        (!pp->retprobe || kretprobe_offset_is_supported())) {
                 reloc_sym = kernel_get_ref_reloc_sym();
                 if (!reloc_sym) {
                         pr_warning("Relocated base symbol is not found!\n");
@@ -3057,7 +3052,7 @@ concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
         struct probe_trace_event *new_tevs;
         int ret = 0;
 
-        if (ntevs == 0) {
+        if (*ntevs == 0) {
                 *tevs = *tevs2;
                 *ntevs = ntevs2;
                 *tevs2 = NULL;
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 5d4e94061402..373842656fb6 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -3,8 +3,6 @@
 
 #include <stdbool.h>
 #include "intlist.h"
-#include "strlist.h"
-#include "strfilter.h"
 
 /* Probe related configurations */
 struct probe_conf {
@@ -107,6 +105,8 @@ struct line_range {
         struct intlist          *line_list;     /* Visible lines */
 };
 
+struct strlist;
+
 /* List of variables */
 struct variable_list {
         struct probe_trace_point        point;  /* Actual probepoint */
@@ -153,6 +153,9 @@ int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 int show_probe_trace_events(struct perf_probe_event *pevs, int npevs);
 void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs);
+
+struct strfilter;
+
 int del_perf_probe_events(struct strfilter *filter);
 
 int show_perf_probe_event(const char *group, const char *event,
diff --git a/tools/perf/util/probe-file.c b/tools/perf/util/probe-file.c
index 436b64731f65..d679389e627c 100644
--- a/tools/perf/util/probe-file.c
+++ b/tools/perf/util/probe-file.c
@@ -14,10 +14,15 @@
  * GNU General Public License for more details.
  *
  */
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <sys/uio.h>
+#include <unistd.h>
 #include "util.h"
 #include "event.h"
 #include "strlist.h"
+#include "strfilter.h"
 #include "debug.h"
 #include "cache.h"
 #include "color.h"
@@ -27,8 +32,11 @@
 #include "probe-event.h"
 #include "probe-file.h"
 #include "session.h"
+#include "perf_regs.h"
+#include "string2.h"
 
-#define MAX_CMDLEN 256
+/* 4096 - 2 ('\n' + '\0') */
+#define MAX_CMDLEN 4094
 
 static void print_open_warning(int err, bool uprobe)
 {
@@ -70,7 +78,7 @@ static void print_both_open_warning(int kerr, int uerr)
         }
 }
 
-static int open_probe_events(const char *trace_file, bool readwrite)
+int open_trace_file(const char *trace_file, bool readwrite)
 {
         char buf[PATH_MAX];
         int ret;
@@ -92,12 +100,12 @@ static int open_probe_events(const char *trace_file, bool readwrite)
 
 static int open_kprobe_events(bool readwrite)
 {
-        return open_probe_events("kprobe_events", readwrite);
+        return open_trace_file("kprobe_events", readwrite);
 }
 
 static int open_uprobe_events(bool readwrite)
 {
-        return open_probe_events("uprobe_events", readwrite);
+        return open_trace_file("uprobe_events", readwrite);
 }
 
 int probe_file__open(int flag)
@@ -687,6 +695,110 @@ static unsigned long long sdt_note__get_addr(struct sdt_note *note)
                  : (unsigned long long)note->addr.a64[0];
 }
 
+static const char * const type_to_suffix[] = {
+        ":s64", "", "", "", ":s32", "", ":s16", ":s8",
+        "", ":u8", ":u16", "", ":u32", "", "", "", ":u64"
+};
+
+/*
+ * Isolate the string number and convert it into a decimal value;
+ * this will be an index to get suffix of the uprobe name (defining
+ * the type)
+ */
+static int sdt_arg_parse_size(char *n_ptr, const char **suffix)
+{
+        long type_idx;
+
+        type_idx = strtol(n_ptr, NULL, 10);
+        if (type_idx < -8 || type_idx > 8) {
+                pr_debug4("Failed to get a valid sdt type\n");
+                return -1;
+        }
+
+        *suffix = type_to_suffix[type_idx + 8];
+        return 0;
+}
+
+static int synthesize_sdt_probe_arg(struct strbuf *buf, int i, const char *arg)
+{
+        char *op, *desc = strdup(arg), *new_op = NULL;
+        const char *suffix = "";
+        int ret = -1;
+
+        if (desc == NULL) {
+                pr_debug4("Allocation error\n");
+                return ret;
+        }
+
+        /*
+         * Argument is in N@OP format. N is size of the argument and OP is
+         * the actual assembly operand. N can be omitted; in that case
+         * argument is just OP(without @).
+         */
+        op = strchr(desc, '@');
+        if (op) {
+                op[0] = '\0';
+                op++;
+
+                if (sdt_arg_parse_size(desc, &suffix))
+                        goto error;
+        } else {
+                op = desc;
+        }
+
+        ret = arch_sdt_arg_parse_op(op, &new_op);
+
+        if (ret < 0)
+                goto error;
+
+        if (ret == SDT_ARG_VALID) {
+                ret = strbuf_addf(buf, " arg%d=%s%s", i + 1, new_op, suffix);
+                if (ret < 0)
+                        goto error;
+        }
+
+        ret = 0;
+error:
+        free(desc);
+        free(new_op);
+        return ret;
+}
+
+static char *synthesize_sdt_probe_command(struct sdt_note *note,
+                                        const char *pathname,
+                                        const char *sdtgrp)
+{
+        struct strbuf buf;
+        char *ret = NULL, **args;
+        int i, args_count;
+
+        if (strbuf_init(&buf, 32) < 0)
+                return NULL;
+
+        if (strbuf_addf(&buf, "p:%s/%s %s:0x%llx",
+                                sdtgrp, note->name, pathname,
+                                sdt_note__get_addr(note)) < 0)
+                goto error;
+
+        if (!note->args)
+                goto out;
+
+        if (note->args) {
+                args = argv_split(note->args, &args_count);
+
+                for (i = 0; i < args_count; ++i) {
+                        if (synthesize_sdt_probe_arg(&buf, i, args[i]) < 0)
+                                goto error;
+                }
+        }
+
+out:
+        ret = strbuf_detach(&buf, NULL);
+error:
+        strbuf_release(&buf);
+        return ret;
+}
+
 int probe_cache__scan_sdt(struct probe_cache *pcache, const char *pathname)
 {
         struct probe_cache_entry *entry = NULL;
@@ -723,11 +835,12 @@ int probe_cache__scan_sdt(struct probe_cache *pcache, const char *pathname)
                         entry->pev.group = strdup(sdtgrp);
                         list_add_tail(&entry->node, &pcache->entries);
                 }
-                ret = asprintf(&buf, "p:%s/%s %s:0x%llx",
-                                sdtgrp, note->name, pathname,
-                                sdt_note__get_addr(note));
-                if (ret < 0)
+                buf = synthesize_sdt_probe_command(note, pathname, sdtgrp);
+                if (!buf) {
+                        ret = -ENOMEM;
                         break;
+                }
+
                 strlist__add(entry->tevlist, buf);
                 free(buf);
                 entry = NULL;
@@ -877,59 +990,72 @@ int probe_cache__show_all_caches(struct strfilter *filter)
         return 0;
 }
 
+enum ftrace_readme {
+        FTRACE_README_PROBE_TYPE_X = 0,
+        FTRACE_README_KRETPROBE_OFFSET,
+        FTRACE_README_END,
+};
+
 static struct {
         const char *pattern;
-        bool    avail;
-        bool    checked;
-} probe_type_table[] = {
-#define DEFINE_TYPE(idx, pat, def_avail)        \
-        [idx] = {.pattern = pat, .avail = (def_avail)}
-        DEFINE_TYPE(PROBE_TYPE_U, "* u8/16/32/64,*", true),
-        DEFINE_TYPE(PROBE_TYPE_S, "* s8/16/32/64,*", true),
-        DEFINE_TYPE(PROBE_TYPE_X, "* x8/16/32/64,*", false),
-        DEFINE_TYPE(PROBE_TYPE_STRING, "* string,*", true),
-        DEFINE_TYPE(PROBE_TYPE_BITFIELD,
-                    "* b<bit-width>@<bit-offset>/<container-size>", true),
+        bool avail;
+} ftrace_readme_table[] = {
+#define DEFINE_TYPE(idx, pat)                   \
+        [idx] = {.pattern = pat, .avail = false}
+        DEFINE_TYPE(FTRACE_README_PROBE_TYPE_X, "*type: * x8/16/32/64,*"),
+        DEFINE_TYPE(FTRACE_README_KRETPROBE_OFFSET, "*place (kretprobe): *"),
 };
 
-bool probe_type_is_available(enum probe_type type)
+static bool scan_ftrace_readme(enum ftrace_readme type)
 {
+        int fd;
         FILE *fp;
         char *buf = NULL;
         size_t len = 0;
-        bool target_line = false;
-        bool ret = probe_type_table[type].avail;
+        bool ret = false;
+        static bool scanned = false;
 
-        if (type >= PROBE_TYPE_END)
-                return false;
-        /* We don't have to check the type which supported by default */
-        if (ret || probe_type_table[type].checked)
-                return ret;
+        if (scanned)
+                goto result;
 
-        if (asprintf(&buf, "%s/README", tracing_path) < 0)
+        fd = open_trace_file("README", false);
+        if (fd < 0)
                 return ret;
 
-        fp = fopen(buf, "r");
-        if (!fp)
-                goto end;
-
-        zfree(&buf);
-        while (getline(&buf, &len, fp) > 0 && !ret) {
-                if (!target_line) {
-                        target_line = !!strstr(buf, " type: ");
-                        if (!target_line)
-                                continue;
-                } else if (strstr(buf, "\t          ") != buf)
-                        break;
-                ret = strglobmatch(buf, probe_type_table[type].pattern);
+        fp = fdopen(fd, "r");
+        if (!fp) {
+                close(fd);
+                return ret;
         }
-        /* Cache the result */
-        probe_type_table[type].checked = true;
-        probe_type_table[type].avail = ret;
+
+        while (getline(&buf, &len, fp) > 0)
+                for (enum ftrace_readme i = 0; i < FTRACE_README_END; i++)
+                        if (!ftrace_readme_table[i].avail)
+                                ftrace_readme_table[i].avail =
+                                        strglobmatch(buf, ftrace_readme_table[i].pattern);
+        scanned = true;
 
         fclose(fp);
-end:
         free(buf);
 
-        return ret;
+result:
+        if (type >= FTRACE_README_END)
+                return false;
+
+        return ftrace_readme_table[type].avail;
+}
+
+bool probe_type_is_available(enum probe_type type)
+{
+        if (type >= PROBE_TYPE_END)
+                return false;
+        else if (type == PROBE_TYPE_X)
+                return scan_ftrace_readme(FTRACE_README_PROBE_TYPE_X);
+
+        return true;
+}
+
+bool kretprobe_offset_is_supported(void)
+{
+        return scan_ftrace_readme(FTRACE_README_KRETPROBE_OFFSET);
 }
diff --git a/tools/perf/util/probe-file.h b/tools/perf/util/probe-file.h
index eba44c3e9dca..5ecc9d3925db 100644
--- a/tools/perf/util/probe-file.h
+++ b/tools/perf/util/probe-file.h
@@ -1,10 +1,11 @@
 #ifndef __PROBE_FILE_H
 #define __PROBE_FILE_H
 
-#include "strlist.h"
-#include "strfilter.h"
 #include "probe-event.h"
 
+struct strlist;
+struct strfilter;
+
 /* Cache of probe definitions */
 struct probe_cache_entry {
         struct list_head        node;
@@ -35,11 +36,13 @@ enum probe_type {
 
 /* probe-file.c depends on libelf */
 #ifdef HAVE_LIBELF_SUPPORT
+int open_trace_file(const char *trace_file, bool readwrite);
 int probe_file__open(int flag);
 int probe_file__open_both(int *kfd, int *ufd, int flag);
 struct strlist *probe_file__get_namelist(int fd);
 struct strlist *probe_file__get_rawlist(int fd);
 int probe_file__add_event(int fd, struct probe_trace_event *tev);
+
 int probe_file__del_events(int fd, struct strfilter *filter);
 int probe_file__get_events(int fd, struct strfilter *filter,
                                   struct strlist *plist);
@@ -64,6 +67,7 @@ struct probe_cache_entry *probe_cache__find_by_name(struct probe_cache *pcache,
                                         const char *group, const char *event);
 int probe_cache__show_all_caches(struct strfilter *filter);
 bool probe_type_is_available(enum probe_type type);
+bool kretprobe_offset_is_supported(void);
 #else   /* ! HAVE_LIBELF_SUPPORT */
 static inline struct probe_cache *probe_cache__new(const char *tgt __maybe_unused)
 {
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 57cd268d4275..a5731de0e5eb 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -19,6 +19,7 @@
  *
  */
 
+#include <inttypes.h>
 #include <sys/utsname.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -37,9 +38,11 @@
 #include "debug.h"
 #include "intlist.h"
 #include "util.h"
+#include "strlist.h"
 #include "symbol.h"
 #include "probe-finder.h"
 #include "probe-file.h"
+#include "string2.h"
 
 /* Kprobe tracer basic type is up to u64 */
 #define MAX_BASIC_TYPE_BITS     64
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 2956c5198652..27f061551012 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -2,9 +2,9 @@
 #define _PROBE_FINDER_H
 
 #include <stdbool.h>
-#include "util.h"
 #include "intlist.h"
 #include "probe-event.h"
+#include "sane_ctype.h"
 
 #define MAX_PROBE_BUFFER        1024
 #define MAX_PROBES               128
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index 0546a4304347..9f3b0d9754a8 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -21,8 +21,10 @@ util/cgroup.c
 util/parse-branch-options.c
 util/rblist.c
 util/counts.c
+util/print_binary.c
 util/strlist.c
 util/trace-event.c
 ../lib/rbtree.c
 util/string.c
 util/symbol_fprintf.c
+util/units.c
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index a5fbc012e3df..c129e99114ae 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -4,12 +4,26 @@
 #include <poll.h>
 #include <linux/err.h>
 #include "evlist.h"
+#include "callchain.h"
 #include "evsel.h"
 #include "event.h"
 #include "cpumap.h"
+#include "print_binary.h"
 #include "thread_map.h"
 
 /*
+ * Provide these two so that we don't have to link against callchain.c and
+ * start dragging hist.c, etc.
+ */
+struct callchain_param callchain_param;
+
+int parse_callchain_record(const char *arg __maybe_unused,
+                           struct callchain_param *param __maybe_unused)
+{
+        return 0;
+}
+
+/*
  * Support debug printing even though util/debug.c is not linked.  That means
  * implementing 'verbose' and 'eprintf'.
  */
diff --git a/tools/perf/util/quote.c b/tools/perf/util/quote.c
index 293534c1a474..1ba8920151d8 100644
--- a/tools/perf/util/quote.c
+++ b/tools/perf/util/quote.c
@@ -1,3 +1,4 @@
+#include <errno.h>
 #include <stdlib.h>
 #include "strbuf.h"
 #include "quote.h"
diff --git a/tools/perf/util/record.c b/tools/perf/util/record.c
index 98bf584853ea..d91bdf5a1aa4 100644
--- a/tools/perf/util/record.c
+++ b/tools/perf/util/record.c
@@ -2,6 +2,7 @@
 #include "evsel.h"
 #include "cpumap.h"
 #include "parse-events.h"
+#include <errno.h>
 #include <api/fs/fs.h>
 #include "util.h"
 #include "cloexec.h"
diff --git a/tools/perf/util/sane_ctype.h b/tools/perf/util/sane_ctype.h
new file mode 100644
index 000000000000..4308c22c22ad
--- /dev/null
+++ b/tools/perf/util/sane_ctype.h
@@ -0,0 +1,51 @@
+#ifndef _PERF_SANE_CTYPE_H
+#define _PERF_SANE_CTYPE_H
+
+extern const char *graph_line;
+extern const char *graph_dotted_line;
+extern const char *spaces;
+extern const char *dots;
+
+/* Sane ctype - no locale, and works with signed chars */
+#undef isascii
+#undef isspace
+#undef isdigit
+#undef isxdigit
+#undef isalpha
+#undef isprint
+#undef isalnum
+#undef islower
+#undef isupper
+#undef tolower
+#undef toupper
+
+extern unsigned char sane_ctype[256];
+#define GIT_SPACE               0x01
+#define GIT_DIGIT               0x02
+#define GIT_ALPHA               0x04
+#define GIT_GLOB_SPECIAL        0x08
+#define GIT_REGEX_SPECIAL       0x10
+#define GIT_PRINT_EXTRA         0x20
+#define GIT_PRINT               0x3E
+#define sane_istest(x,mask) ((sane_ctype[(unsigned char)(x)] & (mask)) != 0)
+#define isascii(x) (((x) & ~0x7f) == 0)
+#define isspace(x) sane_istest(x,GIT_SPACE)
+#define isdigit(x) sane_istest(x,GIT_DIGIT)
+#define isxdigit(x)     \
+        (sane_istest(toupper(x), GIT_ALPHA | GIT_DIGIT) && toupper(x) < 'G')
+#define isalpha(x) sane_istest(x,GIT_ALPHA)
+#define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
+#define isprint(x) sane_istest(x,GIT_PRINT)
+#define islower(x) (sane_istest(x,GIT_ALPHA) && (x & 0x20))
+#define isupper(x) (sane_istest(x,GIT_ALPHA) && !(x & 0x20))
+#define tolower(x) sane_case((unsigned char)(x), 0x20)
+#define toupper(x) sane_case((unsigned char)(x), 0)
+
+static inline int sane_case(int x, int high)
+{
+        if (sane_istest(x, GIT_ALPHA))
+                x = (x & ~0x20) | high;
+        return x;
+}
+
+#endif /* _PERF_SANE_CTYPE_H */
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index dff043a29589..2b12bdb3ce33 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -19,6 +19,7 @@
  *
  */
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 783326cfbaa6..9d92af7d0718 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -21,6 +21,7 @@
 
 #include <Python.h>
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -45,6 +46,7 @@
 #include "../call-path.h"
 #include "thread_map.h"
 #include "cpumap.h"
+#include "print_binary.h"
 #include "stat.h"
 
 PyMODINIT_FUNC initperf_trace_context(void);
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 1dd617d116b5..3041c6b98191 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1,5 +1,8 @@
+#include <errno.h>
+#include <inttypes.h>
 #include <linux/kernel.h>
 #include <traceevent/event-parse.h>
+#include <api/fs/fs.h>
 
 #include <byteswap.h>
 #include <unistd.h>
@@ -16,6 +19,7 @@
 #include "perf_regs.h"
 #include "asm/bug.h"
 #include "auxtrace.h"
+#include "thread.h"
 #include "thread-stack.h"
 #include "stat.h"
 
@@ -139,8 +143,14 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                         if (perf_session__open(session) < 0)
                                 goto out_close;
 
-                        perf_session__set_id_hdr_size(session);
-                        perf_session__set_comm_exec(session);
+                        /*
+                         * set session attributes that are present in perf.data
+                         * but not in pipe-mode.
+                         */
+                        if (!file->is_pipe) {
+                                perf_session__set_id_hdr_size(session);
+                                perf_session__set_comm_exec(session);
+                        }
                 }
         } else  {
                 session->machines.host.env = &perf_env;
@@ -155,7 +165,11 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                         pr_warning("Cannot read kernel map\n");
         }
 
-        if (tool && tool->ordering_requires_timestamps &&
+        /*
+         * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is
+         * processed, so perf_evlist__sample_id_all is not meaningful here.
+         */
+        if ((!file || !file->is_pipe) && tool && tool->ordering_requires_timestamps &&
             tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
                 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
                 tool->ordered_events = false;
@@ -1239,6 +1253,8 @@ static int machines__deliver_event(struct machines *machines,
                 return tool->mmap2(tool, event, sample, machine);
         case PERF_RECORD_COMM:
                 return tool->comm(tool, event, sample, machine);
+        case PERF_RECORD_NAMESPACES:
+                return tool->namespaces(tool, event, sample, machine);
         case PERF_RECORD_FORK:
                 return tool->fork(tool, event, sample, machine);
         case PERF_RECORD_EXIT:
@@ -1258,9 +1274,12 @@ static int machines__deliver_event(struct machines *machines,
         case PERF_RECORD_UNTHROTTLE:
                 return tool->unthrottle(tool, event, sample, machine);
         case PERF_RECORD_AUX:
-                if (tool->aux == perf_event__process_aux &&
-                    (event->aux.flags & PERF_AUX_FLAG_TRUNCATED))
-                        evlist->stats.total_aux_lost += 1;
+                if (tool->aux == perf_event__process_aux) {
+                        if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED)
+                                evlist->stats.total_aux_lost += 1;
+                        if (event->aux.flags & PERF_AUX_FLAG_PARTIAL)
+                                evlist->stats.total_aux_partial += 1;
+                }
                 return tool->aux(tool, event, sample, machine);
         case PERF_RECORD_ITRACE_START:
                 return tool->itrace_start(tool, event, sample, machine);
@@ -1494,6 +1513,11 @@ int perf_session__register_idle_thread(struct perf_session *session)
                 err = -1;
         }
 
+        if (thread == NULL || thread__set_namespaces(thread, 0, NULL)) {
+                pr_err("problem inserting idle task.\n");
+                err = -1;
+        }
+
         /* machine__findnew_thread() got the thread, so put it */
         thread__put(thread);
         return err;
@@ -1548,6 +1572,23 @@ static void perf_session__warn_about_errors(const struct perf_session *session)
                             stats->nr_events[PERF_RECORD_AUX]);
         }
 
+        if (session->tool->aux == perf_event__process_aux &&
+            stats->total_aux_partial != 0) {
+                bool vmm_exclusive = false;
+
+                (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive",
+                                       &vmm_exclusive);
+
+                ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n"
+                            "Are you running a KVM guest in the background?%s\n\n",
+                            stats->total_aux_partial,
+                            stats->nr_events[PERF_RECORD_AUX],
+                            vmm_exclusive ?
+                            "\nReloading kvm_intel module with vmm_exclusive=0\n"
+                            "will reduce the gaps to only guest's timeslices." :
+                            "");
+        }
+
         if (stats->nr_unknown_events != 0) {
                 ui__warning("Found %u unknown events!\n\n"
                             "Is this an older tool processing a perf.data "
@@ -1628,6 +1669,7 @@ static int __perf_session__process_pipe_events(struct perf_session *session)
         buf = malloc(cur_size);
         if (!buf)
                 return -errno;
+        ordered_events__set_copy_on_queue(oe, true);
 more:
         event = buf;
         err = readn(fd, event, sizeof(struct perf_event_header));
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 4bd758553450..47b5e7dbcb18 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -5,14 +5,14 @@
 #include "event.h"
 #include "header.h"
 #include "machine.h"
-#include "symbol.h"
-#include "thread.h"
 #include "data.h"
 #include "ordered-events.h"
+#include <linux/kernel.h>
 #include <linux/rbtree.h>
 #include <linux/perf_event.h>
 
 struct ip_callchain;
+struct symbol;
 struct thread;
 
 struct auxtrace;
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 0ff622288d24..5762ae4e9e91 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,12 +1,18 @@
+#include <errno.h>
+#include <inttypes.h>
+#include <regex.h>
 #include <sys/mman.h>
 #include "sort.h"
 #include "hist.h"
 #include "comm.h"
 #include "symbol.h"
+#include "thread.h"
 #include "evsel.h"
 #include "evlist.h"
+#include "strlist.h"
 #include <traceevent/event-parse.h>
 #include "mem-events.h"
+#include <linux/kernel.h>
 
 regex_t         parent_regex;
 const char      default_parent_pattern[] = "^sys_|^do_page_fault";
@@ -323,7 +329,7 @@ char *hist_entry__get_srcline(struct hist_entry *he)
                 return SRCLINE_UNKNOWN;
 
         return get_srcline(map->dso, map__rip_2objdump(map, he->ip),
-                           he->ms.sym, true);
+                           he->ms.sym, true, true);
 }
 
 static int64_t
@@ -366,7 +372,8 @@ sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right)
                         left->branch_info->srcline_from = get_srcline(map->dso,
                                            map__rip_2objdump(map,
                                                              left->branch_info->from.al_addr),
-                                                         left->branch_info->from.sym, true);
+                                                         left->branch_info->from.sym,
+                                                         true, true);
         }
         if (!right->branch_info->srcline_from) {
                 struct map *map = right->branch_info->from.map;
@@ -376,7 +383,8 @@ sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right)
                         right->branch_info->srcline_from = get_srcline(map->dso,
                                              map__rip_2objdump(map,
                                                                right->branch_info->from.al_addr),
-                                                     right->branch_info->from.sym, true);
+                                                     right->branch_info->from.sym,
+                                                     true, true);
         }
         return strcmp(right->branch_info->srcline_from, left->branch_info->srcline_from);
 }
@@ -407,7 +415,8 @@ sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right)
                         left->branch_info->srcline_to = get_srcline(map->dso,
                                            map__rip_2objdump(map,
                                                              left->branch_info->to.al_addr),
-                                                         left->branch_info->from.sym, true);
+                                                         left->branch_info->from.sym,
+                                                         true, true);
         }
         if (!right->branch_info->srcline_to) {
                 struct map *map = right->branch_info->to.map;
@@ -417,7 +426,8 @@ sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right)
                         right->branch_info->srcline_to = get_srcline(map->dso,
                                              map__rip_2objdump(map,
                                                                right->branch_info->to.al_addr),
-                                                     right->branch_info->to.sym, true);
+                                                     right->branch_info->to.sym,
+                                                     true, true);
         }
         return strcmp(right->branch_info->srcline_to, left->branch_info->srcline_to);
 }
@@ -448,7 +458,7 @@ static char *hist_entry__get_srcfile(struct hist_entry *e)
                 return no_srcfile;
 
         sf = __get_srcline(map->dso, map__rip_2objdump(map, e->ip),
-                         e->ms.sym, false, true);
+                         e->ms.sym, false, true, true);
         if (!strcmp(sf, SRCLINE_UNKNOWN))
                 return no_srcfile;
         p = strchr(sf, ':');
@@ -536,6 +546,46 @@ struct sort_entry sort_cpu = {
         .se_width_idx   = HISTC_CPU,
 };
 
+/* --sort cgroup_id */
+
+static int64_t _sort__cgroup_dev_cmp(u64 left_dev, u64 right_dev)
+{
+        return (int64_t)(right_dev - left_dev);
+}
+
+static int64_t _sort__cgroup_inode_cmp(u64 left_ino, u64 right_ino)
+{
+        return (int64_t)(right_ino - left_ino);
+}
+
+static int64_t
+sort__cgroup_id_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        int64_t ret;
+
+        ret = _sort__cgroup_dev_cmp(right->cgroup_id.dev, left->cgroup_id.dev);
+        if (ret != 0)
+                return ret;
+
+        return _sort__cgroup_inode_cmp(right->cgroup_id.ino,
+                                       left->cgroup_id.ino);
+}
+
+static int hist_entry__cgroup_id_snprintf(struct hist_entry *he,
+                                          char *bf, size_t size,
+                                          unsigned int width __maybe_unused)
+{
+        return repsep_snprintf(bf, size, "%lu/0x%lx", he->cgroup_id.dev,
+                               he->cgroup_id.ino);
+}
+
+struct sort_entry sort_cgroup_id = {
+        .se_header      = "cgroup id (dev/inode)",
+        .se_cmp         = sort__cgroup_id_cmp,
+        .se_snprintf    = hist_entry__cgroup_id_snprintf,
+        .se_width_idx   = HISTC_CGROUP_ID,
+};
+
 /* --sort socket */
 
 static int64_t
@@ -846,6 +896,9 @@ static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
 static int64_t
 sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
 {
+        if (!left->branch_info || !right->branch_info)
+                return cmp_null(left->branch_info, right->branch_info);
+
         return left->branch_info->flags.cycles -
                 right->branch_info->flags.cycles;
 }
@@ -853,6 +906,8 @@ sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
 static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
                                     size_t size, unsigned int width)
 {
+        if (!he->branch_info)
+                return scnprintf(bf, size, "%-.*s", width, "N/A");
         if (he->branch_info->flags.cycles == 0)
                 return repsep_snprintf(bf, size, "%-*s", width, "-");
         return repsep_snprintf(bf, size, "%-*hd", width,
@@ -1396,6 +1451,46 @@ struct sort_entry sort_transaction = {
         .se_width_idx   = HISTC_TRANSACTION,
 };
 
+/* --sort symbol_size */
+
+static int64_t _sort__sym_size_cmp(struct symbol *sym_l, struct symbol *sym_r)
+{
+        int64_t size_l = sym_l != NULL ? symbol__size(sym_l) : 0;
+        int64_t size_r = sym_r != NULL ? symbol__size(sym_r) : 0;
+
+        return size_l < size_r ? -1 :
+                size_l == size_r ? 0 : 1;
+}
+
+static int64_t
+sort__sym_size_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return _sort__sym_size_cmp(right->ms.sym, left->ms.sym);
+}
+
+static int _hist_entry__sym_size_snprintf(struct symbol *sym, char *bf,
+                                          size_t bf_size, unsigned int width)
+{
+        if (sym)
+                return repsep_snprintf(bf, bf_size, "%*d", width, symbol__size(sym));
+
+        return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
+}
+
+static int hist_entry__sym_size_snprintf(struct hist_entry *he, char *bf,
+                                         size_t size, unsigned int width)
+{
+        return _hist_entry__sym_size_snprintf(he->ms.sym, bf, size, width);
+}
+
+struct sort_entry sort_sym_size = {
+        .se_header      = "Symbol size",
+        .se_cmp         = sort__sym_size_cmp,
+        .se_snprintf    = hist_entry__sym_size_snprintf,
+        .se_width_idx   = HISTC_SYM_SIZE,
+};
+
+
 struct sort_dimension {
         const char              *name;
         struct sort_entry       *entry;
@@ -1418,6 +1513,8 @@ static struct sort_dimension common_sort_dimensions[] = {
         DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
         DIM(SORT_TRANSACTION, "transaction", sort_transaction),
         DIM(SORT_TRACE, "trace", sort_trace),
+        DIM(SORT_SYM_SIZE, "symbol_size", sort_sym_size),
+        DIM(SORT_CGROUP_ID, "cgroup_id", sort_cgroup_id),
 };
 
 #undef DIM
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 796c847e2f00..b7c75597e18f 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -2,7 +2,7 @@
 #define __PERF_SORT_H
 #include "../builtin.h"
 
-#include "util.h"
+#include <regex.h>
 
 #include "color.h"
 #include <linux/list.h>
@@ -11,7 +11,6 @@
 #include "symbol.h"
 #include "string.h"
 #include "callchain.h"
-#include "strlist.h"
 #include "values.h"
 
 #include "../perf.h"
@@ -21,7 +20,9 @@
 #include <subcmd/parse-options.h>
 #include "parse-events.h"
 #include "hist.h"
-#include "thread.h"
+#include "srcline.h"
+
+struct thread;
 
 extern regex_t parent_regex;
 extern const char *sort_order;
@@ -54,6 +55,11 @@ struct he_stat {
         u32                     nr_events;
 };
 
+struct namespace_id {
+        u64                     dev;
+        u64                     ino;
+};
+
 struct hist_entry_diff {
         bool    computed;
         union {
@@ -91,6 +97,7 @@ struct hist_entry {
         struct map_symbol       ms;
         struct thread           *thread;
         struct comm             *comm;
+        struct namespace_id     cgroup_id;
         u64                     ip;
         u64                     transaction;
         s32                     socket;
@@ -122,6 +129,7 @@ struct hist_entry {
         };
         char                    *srcline;
         char                    *srcfile;
+        struct inline_node      *inline_node;
         struct symbol           *parent;
         struct branch_info      *branch_info;
         struct hists            *hists;
@@ -211,6 +219,8 @@ enum sort_type {
         SORT_GLOBAL_WEIGHT,
         SORT_TRANSACTION,
         SORT_TRACE,
+        SORT_SYM_SIZE,
+        SORT_CGROUP_ID,
 
         /* branch stack specific sort keys */
         __SORT_BRANCH_STACK,
diff --git a/tools/perf/util/srcline.c b/tools/perf/util/srcline.c
index b4db3f48e3b0..df051a52393c 100644
--- a/tools/perf/util/srcline.c
+++ b/tools/perf/util/srcline.c
@@ -1,3 +1,4 @@
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -7,11 +8,59 @@
 #include "util/dso.h"
 #include "util/util.h"
 #include "util/debug.h"
+#include "util/callchain.h"
+#include "srcline.h"
 
 #include "symbol.h"
 
 bool srcline_full_filename;
 
+static const char *dso__name(struct dso *dso)
+{
+        const char *dso_name;
+
+        if (dso->symsrc_filename)
+                dso_name = dso->symsrc_filename;
+        else
+                dso_name = dso->long_name;
+
+        if (dso_name[0] == '[')
+                return NULL;
+
+        if (!strncmp(dso_name, "/tmp/perf-", 10))
+                return NULL;
+
+        return dso_name;
+}
+
+static int inline_list__append(char *filename, char *funcname, int line_nr,
+                               struct inline_node *node, struct dso *dso)
+{
+        struct inline_list *ilist;
+        char *demangled;
+
+        ilist = zalloc(sizeof(*ilist));
+        if (ilist == NULL)
+                return -1;
+
+        ilist->filename = filename;
+        ilist->line_nr = line_nr;
+
+        if (dso != NULL) {
+                demangled = dso__demangle_sym(dso, 0, funcname);
+                if (demangled == NULL) {
+                        ilist->funcname = funcname;
+                } else {
+                        ilist->funcname = demangled;
+                        free(funcname);
+                }
+        }
+
+        list_add_tail(&ilist->list, &node->val);
+
+        return 0;
+}
+
 #ifdef HAVE_LIBBFD_SUPPORT
 
 /*
@@ -151,9 +200,17 @@ static void addr2line_cleanup(struct a2l_data *a2l)
 
 #define MAX_INLINE_NEST 1024
 
+static void inline_list__reverse(struct inline_node *node)
+{
+        struct inline_list *ilist, *n;
+
+        list_for_each_entry_safe_reverse(ilist, n, &node->val, list)
+                list_move_tail(&ilist->list, &node->val);
+}
+
 static int addr2line(const char *dso_name, u64 addr,
                      char **file, unsigned int *line, struct dso *dso,
-                     bool unwind_inlines)
+                     bool unwind_inlines, struct inline_node *node)
 {
         int ret = 0;
         struct a2l_data *a2l = dso->a2l;
@@ -178,8 +235,21 @@ static int addr2line(const char *dso_name, u64 addr,
 
                 while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
                                              &a2l->funcname, &a2l->line) &&
-                       cnt++ < MAX_INLINE_NEST)
-                        ;
+                       cnt++ < MAX_INLINE_NEST) {
+
+                        if (node != NULL) {
+                                if (inline_list__append(strdup(a2l->filename),
+                                                        strdup(a2l->funcname),
+                                                        a2l->line, node,
+                                                        dso) != 0)
+                                        return 0;
+                        }
+                }
+
+                if ((node != NULL) &&
+                    (callchain_param.order != ORDER_CALLEE)) {
+                        inline_list__reverse(node);
+                }
         }
 
         if (a2l->found && a2l->filename) {
@@ -205,18 +275,68 @@ void dso__free_a2l(struct dso *dso)
         dso->a2l = NULL;
 }
 
+static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
+        struct dso *dso)
+{
+        char *file = NULL;
+        unsigned int line = 0;
+        struct inline_node *node;
+
+        node = zalloc(sizeof(*node));
+        if (node == NULL) {
+                perror("not enough memory for the inline node");
+                return NULL;
+        }
+
+        INIT_LIST_HEAD(&node->val);
+        node->addr = addr;
+
+        if (!addr2line(dso_name, addr, &file, &line, dso, TRUE, node))
+                goto out_free_inline_node;
+
+        if (list_empty(&node->val))
+                goto out_free_inline_node;
+
+        return node;
+
+out_free_inline_node:
+        inline_node__delete(node);
+        return NULL;
+}
+
 #else /* HAVE_LIBBFD_SUPPORT */
 
+static int filename_split(char *filename, unsigned int *line_nr)
+{
+        char *sep;
+
+        sep = strchr(filename, '\n');
+        if (sep)
+                *sep = '\0';
+
+        if (!strcmp(filename, "??:0"))
+                return 0;
+
+        sep = strchr(filename, ':');
+        if (sep) {
+                *sep++ = '\0';
+                *line_nr = strtoul(sep, NULL, 0);
+                return 1;
+        }
+
+        return 0;
+}
+
 static int addr2line(const char *dso_name, u64 addr,
                      char **file, unsigned int *line_nr,
                      struct dso *dso __maybe_unused,
-                     bool unwind_inlines __maybe_unused)
+                     bool unwind_inlines __maybe_unused,
+                     struct inline_node *node __maybe_unused)
 {
         FILE *fp;
         char cmd[PATH_MAX];
         char *filename = NULL;
         size_t len;
-        char *sep;
         int ret = 0;
 
         scnprintf(cmd, sizeof(cmd), "addr2line -e %s %016"PRIx64,
@@ -233,23 +353,14 @@ static int addr2line(const char *dso_name, u64 addr,
                 goto out;
         }
 
-        sep = strchr(filename, '\n');
-        if (sep)
-                *sep = '\0';
-
-        if (!strcmp(filename, "??:0")) {
-                pr_debug("no debugging info in %s\n", dso_name);
+        ret = filename_split(filename, line_nr);
+        if (ret != 1) {
                 free(filename);
                 goto out;
         }
 
-        sep = strchr(filename, ':');
-        if (sep) {
-                *sep++ = '\0';
-                *file = filename;
-                *line_nr = strtoul(sep, NULL, 0);
-                ret = 1;
-        }
+        *file = filename;
+
 out:
         pclose(fp);
         return ret;
@@ -259,6 +370,58 @@ void dso__free_a2l(struct dso *dso __maybe_unused)
 {
 }
 
+static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
+        struct dso *dso __maybe_unused)
+{
+        FILE *fp;
+        char cmd[PATH_MAX];
+        struct inline_node *node;
+        char *filename = NULL;
+        size_t len;
+        unsigned int line_nr = 0;
+
+        scnprintf(cmd, sizeof(cmd), "addr2line -e %s -i %016"PRIx64,
+                  dso_name, addr);
+
+        fp = popen(cmd, "r");
+        if (fp == NULL) {
+                pr_err("popen failed for %s\n", dso_name);
+                return NULL;
+        }
+
+        node = zalloc(sizeof(*node));
+        if (node == NULL) {
+                perror("not enough memory for the inline node");
+                goto out;
+        }
+
+        INIT_LIST_HEAD(&node->val);
+        node->addr = addr;
+
+        while (getline(&filename, &len, fp) != -1) {
+                if (filename_split(filename, &line_nr) != 1) {
+                        free(filename);
+                        goto out;
+                }
+
+                if (inline_list__append(filename, NULL, line_nr, node,
+                                        NULL) != 0)
+                        goto out;
+
+                filename = NULL;
+        }
+
+out:
+        pclose(fp);
+
+        if (list_empty(&node->val)) {
+                inline_node__delete(node);
+                return NULL;
+        }
+
+        return node;
+}
+
 #endif /* HAVE_LIBBFD_SUPPORT */
 
 /*
@@ -268,7 +431,7 @@ void dso__free_a2l(struct dso *dso __maybe_unused)
 #define A2L_FAIL_LIMIT 123
 
 char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
-                  bool show_sym, bool unwind_inlines)
+                  bool show_sym, bool show_addr, bool unwind_inlines)
 {
         char *file = NULL;
         unsigned line = 0;
@@ -278,18 +441,11 @@ char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
         if (!dso->has_srcline)
                 goto out;
 
-        if (dso->symsrc_filename)
-                dso_name = dso->symsrc_filename;
-        else
-                dso_name = dso->long_name;
-
-        if (dso_name[0] == '[')
-                goto out;
-
-        if (!strncmp(dso_name, "/tmp/perf-", 10))
+        dso_name = dso__name(dso);
+        if (dso_name == NULL)
                 goto out;
 
-        if (!addr2line(dso_name, addr, &file, &line, dso, unwind_inlines))
+        if (!addr2line(dso_name, addr, &file, &line, dso, unwind_inlines, NULL))
                 goto out;
 
         if (asprintf(&srcline, "%s:%u",
@@ -309,6 +465,11 @@ out:
                 dso->has_srcline = 0;
                 dso__free_a2l(dso);
         }
+
+        if (!show_addr)
+                return (show_sym && sym) ?
+                            strndup(sym->name, sym->namelen) : NULL;
+
         if (sym) {
                 if (asprintf(&srcline, "%s+%" PRIu64, show_sym ? sym->name : "",
                                         addr - sym->start) < 0)
@@ -325,7 +486,32 @@ void free_srcline(char *srcline)
 }
 
 char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
-                  bool show_sym)
+                  bool show_sym, bool show_addr)
+{
+        return __get_srcline(dso, addr, sym, show_sym, show_addr, false);
+}
+
+struct inline_node *dso__parse_addr_inlines(struct dso *dso, u64 addr)
 {
-        return __get_srcline(dso, addr, sym, show_sym, false);
+        const char *dso_name;
+
+        dso_name = dso__name(dso);
+        if (dso_name == NULL)
+                return NULL;
+
+        return addr2inlines(dso_name, addr, dso);
+}
+
+void inline_node__delete(struct inline_node *node)
+{
+        struct inline_list *ilist, *tmp;
+
+        list_for_each_entry_safe(ilist, tmp, &node->val, list) {
+                list_del_init(&ilist->list);
+                zfree(&ilist->filename);
+                zfree(&ilist->funcname);
+                free(ilist);
+        }
+
+        free(node);
 }
diff --git a/tools/perf/util/srcline.h b/tools/perf/util/srcline.h
new file mode 100644
index 000000000000..7b52ba88676e
--- /dev/null
+++ b/tools/perf/util/srcline.h
@@ -0,0 +1,34 @@
+#ifndef PERF_SRCLINE_H
+#define PERF_SRCLINE_H
+
+#include <linux/list.h>
+#include <linux/types.h>
+
+struct dso;
+struct symbol;
+
+extern bool srcline_full_filename;
+char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
+                  bool show_sym, bool show_addr);
+char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
+                  bool show_sym, bool show_addr, bool unwind_inlines);
+void free_srcline(char *srcline);
+
+#define SRCLINE_UNKNOWN  ((char *) "??:0")
+
+struct inline_list {
+        char                    *filename;
+        char                    *funcname;
+        unsigned int            line_nr;
+        struct list_head        list;
+};
+
+struct inline_node {
+        u64                     addr;
+        struct list_head        val;
+};
+
+struct inline_node *dso__parse_addr_inlines(struct dso *dso, u64 addr);
+void inline_node__delete(struct inline_node *node);
+
+#endif /* PERF_SRCLINE_H */
diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index 8a2bbd2a4d82..ac10cc675d39 100644
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -3,6 +3,9 @@
 #include "stat.h"
 #include "color.h"
 #include "pmu.h"
+#include "rblist.h"
+#include "evlist.h"
+#include "expr.h"
 
 enum {
         CTX_BIT_USER    = 1 << 0,
@@ -41,13 +44,73 @@ static struct stats runtime_topdown_slots_issued[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_topdown_slots_retired[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_topdown_fetch_bubbles[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_topdown_recovery_bubbles[NUM_CTX][MAX_NR_CPUS];
+static struct rblist runtime_saved_values;
 static bool have_frontend_stalled;
 
 struct stats walltime_nsecs_stats;
 
+struct saved_value {
+        struct rb_node rb_node;
+        struct perf_evsel *evsel;
+        int cpu;
+        int ctx;
+        struct stats stats;
+};
+
+static int saved_value_cmp(struct rb_node *rb_node, const void *entry)
+{
+        struct saved_value *a = container_of(rb_node,
+                                             struct saved_value,
+                                             rb_node);
+        const struct saved_value *b = entry;
+
+        if (a->ctx != b->ctx)
+                return a->ctx - b->ctx;
+        if (a->cpu != b->cpu)
+                return a->cpu - b->cpu;
+        return a->evsel - b->evsel;
+}
+
+static struct rb_node *saved_value_new(struct rblist *rblist __maybe_unused,
+                                     const void *entry)
+{
+        struct saved_value *nd = malloc(sizeof(struct saved_value));
+
+        if (!nd)
+                return NULL;
+        memcpy(nd, entry, sizeof(struct saved_value));
+        return &nd->rb_node;
+}
+
+static struct saved_value *saved_value_lookup(struct perf_evsel *evsel,
+                                              int cpu, int ctx,
+                                              bool create)
+{
+        struct rb_node *nd;
+        struct saved_value dm = {
+                .cpu = cpu,
+                .ctx = ctx,
+                .evsel = evsel,
+        };
+        nd = rblist__find(&runtime_saved_values, &dm);
+        if (nd)
+                return container_of(nd, struct saved_value, rb_node);
+        if (create) {
+                rblist__add_node(&runtime_saved_values, &dm);
+                nd = rblist__find(&runtime_saved_values, &dm);
+                if (nd)
+                        return container_of(nd, struct saved_value, rb_node);
+        }
+        return NULL;
+}
+
 void perf_stat__init_shadow_stats(void)
 {
         have_frontend_stalled = pmu_have_event("cpu", "stalled-cycles-frontend");
+        rblist__init(&runtime_saved_values);
+        runtime_saved_values.node_cmp = saved_value_cmp;
+        runtime_saved_values.node_new = saved_value_new;
+        /* No delete for now */
 }
 
 static int evsel_context(struct perf_evsel *evsel)
@@ -70,6 +133,8 @@ static int evsel_context(struct perf_evsel *evsel)
 
 void perf_stat__reset_shadow_stats(void)
 {
+        struct rb_node *pos, *next;
+
         memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats));
         memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats));
         memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats));
@@ -92,6 +157,15 @@ void perf_stat__reset_shadow_stats(void)
         memset(runtime_topdown_slots_issued, 0, sizeof(runtime_topdown_slots_issued));
         memset(runtime_topdown_fetch_bubbles, 0, sizeof(runtime_topdown_fetch_bubbles));
         memset(runtime_topdown_recovery_bubbles, 0, sizeof(runtime_topdown_recovery_bubbles));
+
+        next = rb_first(&runtime_saved_values.entries);
+        while (next) {
+                pos = next;
+                next = rb_next(pos);
+                memset(&container_of(pos, struct saved_value, rb_node)->stats,
+                       0,
+                       sizeof(struct stats));
+        }
 }
 
 /*
@@ -143,6 +217,12 @@ void perf_stat__update_shadow_stats(struct perf_evsel *counter, u64 *count,
                 update_stats(&runtime_dtlb_cache_stats[ctx][cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
                 update_stats(&runtime_itlb_cache_stats[ctx][cpu], count[0]);
+
+        if (counter->collect_stat) {
+                struct saved_value *v = saved_value_lookup(counter, cpu, ctx,
+                                                           true);
+                update_stats(&v->stats, count[0]);
+        }
 }
 
 /* used for get_ratio_color() */
@@ -172,6 +252,95 @@ static const char *get_ratio_color(enum grc_type type, double ratio)
         return color;
 }
 
+static struct perf_evsel *perf_stat__find_event(struct perf_evlist *evsel_list,
+                                                const char *name)
+{
+        struct perf_evsel *c2;
+
+        evlist__for_each_entry (evsel_list, c2) {
+                if (!strcasecmp(c2->name, name))
+                        return c2;
+        }
+        return NULL;
+}
+
+/* Mark MetricExpr target events and link events using them to them. */
+void perf_stat__collect_metric_expr(struct perf_evlist *evsel_list)
+{
+        struct perf_evsel *counter, *leader, **metric_events, *oc;
+        bool found;
+        const char **metric_names;
+        int i;
+        int num_metric_names;
+
+        evlist__for_each_entry(evsel_list, counter) {
+                bool invalid = false;
+
+                leader = counter->leader;
+                if (!counter->metric_expr)
+                        continue;
+                metric_events = counter->metric_events;
+                if (!metric_events) {
+                        if (expr__find_other(counter->metric_expr, counter->name,
+                                                &metric_names, &num_metric_names) < 0)
+                                continue;
+
+                        metric_events = calloc(sizeof(struct perf_evsel *),
+                                               num_metric_names + 1);
+                        if (!metric_events)
+                                return;
+                        counter->metric_events = metric_events;
+                }
+
+                for (i = 0; i < num_metric_names; i++) {
+                        found = false;
+                        if (leader) {
+                                /* Search in group */
+                                for_each_group_member (oc, leader) {
+                                        if (!strcasecmp(oc->name, metric_names[i])) {
+                                                found = true;
+                                                break;
+                                        }
+                                }
+                        }
+                        if (!found) {
+                                /* Search ignoring groups */
+                                oc = perf_stat__find_event(evsel_list, metric_names[i]);
+                        }
+                        if (!oc) {
+                                /* Deduping one is good enough to handle duplicated PMUs. */
+                                static char *printed;
+
+                                /*
+                                 * Adding events automatically would be difficult, because
+                                 * it would risk creating groups that are not schedulable.
+                                 * perf stat doesn't understand all the scheduling constraints
+                                 * of events. So we ask the user instead to add the missing
+                                 * events.
+                                 */
+                                if (!printed || strcasecmp(printed, metric_names[i])) {
+                                        fprintf(stderr,
+                                                "Add %s event to groups to get metric expression for %s\n",
+                                                metric_names[i],
+                                                counter->name);
+                                        printed = strdup(metric_names[i]);
+                                }
+                                invalid = true;
+                                continue;
+                        }
+                        metric_events[i] = oc;
+                        oc->collect_stat = true;
+                }
+                metric_events[i] = NULL;
+                free(metric_names);
+                if (invalid) {
+                        free(metric_events);
+                        counter->metric_events = NULL;
+                        counter->metric_expr = NULL;
+                }
+        }
+}
+
 static void print_stalled_cycles_frontend(int cpu,
                                           struct perf_evsel *evsel, double avg,
                                           struct perf_stat_output_ctx *out)
@@ -614,6 +783,34 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                         be_bound * 100.);
                 else
                         print_metric(ctxp, NULL, NULL, name, 0);
+        } else if (evsel->metric_expr) {
+                struct parse_ctx pctx;
+                int i;
+
+                expr__ctx_init(&pctx);
+                expr__add_id(&pctx, evsel->name, avg);
+                for (i = 0; evsel->metric_events[i]; i++) {
+                        struct saved_value *v;
+
+                        v = saved_value_lookup(evsel->metric_events[i], cpu, ctx, false);
+                        if (!v)
+                                break;
+                        expr__add_id(&pctx, evsel->metric_events[i]->name,
+                                             avg_stats(&v->stats));
+                }
+                if (!evsel->metric_events[i]) {
+                        const char *p = evsel->metric_expr;
+
+                        if (expr__parse(&ratio, &pctx, &p) == 0)
+                                print_metric(ctxp, NULL, "%8.1f",
+                                        evsel->metric_name ?
+                                        evsel->metric_name :
+                                        out->force_header ?  evsel->name : "",
+                                        ratio);
+                        else
+                                print_metric(ctxp, NULL, NULL, "", 0);
+                } else
+                        print_metric(ctxp, NULL, NULL, "", 0);
         } else if (runtime_nsecs_stats[cpu].n != 0) {
                 char unit = 'M';
                 char unit_buf[10];
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index 0d51334a9b46..c58174443dc1 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -1,3 +1,5 @@
+#include <errno.h>
+#include <inttypes.h>
 #include <math.h>
 #include "stat.h"
 #include "evlist.h"
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
index c29bb94c48a4..0a65ae23f495 100644
--- a/tools/perf/util/stat.h
+++ b/tools/perf/util/stat.h
@@ -85,11 +85,13 @@ struct perf_stat_output_ctx {
         void *ctx;
         print_metric_t print_metric;
         new_line_t new_line;
+        bool force_header;
 };
 
 void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out);
+void perf_stat__collect_metric_expr(struct perf_evlist *);
 
 int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw);
 void perf_evlist__free_stats(struct perf_evlist *evlist);
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 817593908d47..e91b5e86f027 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -1,6 +1,7 @@
 #include "debug.h"
 #include "util.h"
 #include <linux/kernel.h>
+#include <errno.h>
 
 int prefixcmp(const char *str, const char *prefix)
 {
diff --git a/tools/perf/util/strfilter.c b/tools/perf/util/strfilter.c
index efb53772e0ec..4dc0af669a30 100644
--- a/tools/perf/util/strfilter.c
+++ b/tools/perf/util/strfilter.c
@@ -1,7 +1,10 @@
 #include "util.h"
-#include "string.h"
+#include "string2.h"
 #include "strfilter.h"
 
+#include <errno.h>
+#include "sane_ctype.h"
+
 /* Operators */
 static const char *OP_and       = "&";  /* Logical AND */
 static const char *OP_or        = "|";  /* Logical OR */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index bddca519dd58..cca53b693a48 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,5 +1,9 @@
-#include "util.h"
-#include "linux/string.h"
+#include "string2.h"
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <stdlib.h>
+
+#include "sane_ctype.h"
 
 #define K 1024LL
 /*
@@ -99,8 +103,10 @@ static int count_argc(const char *str)
 void argv_free(char **argv)
 {
         char **p;
-        for (p = argv; *p; p++)
-                zfree(p);
+        for (p = argv; *p; p++) {
+                free(*p);
+                *p = NULL;
+        }
 
         free(argv);
 }
@@ -120,7 +126,7 @@ void argv_free(char **argv)
 char **argv_split(const char *str, int *argcp)
 {
         int argc = count_argc(str);
-        char **argv = zalloc(sizeof(*argv) * (argc+1));
+        char **argv = calloc(argc + 1, sizeof(*argv));
         char **argvp;
 
         if (argv == NULL)
@@ -322,12 +328,8 @@ char *strxfrchar(char *s, char from, char to)
  */
 char *ltrim(char *s)
 {
-        int len = strlen(s);
-
-        while (len && isspace(*s)) {
-                len--;
+        while (isspace(*s))
                 s++;
-        }
 
         return s;
 }
@@ -381,7 +383,7 @@ char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints
                                 goto out_err_overflow;
 
                         if (i > 0)
-                                printed += snprintf(e + printed, size - printed, " %s ", or_and);
+                                printed += scnprintf(e + printed, size - printed, " %s ", or_and);
                         printed += scnprintf(e + printed, size - printed,
                                              "%s %s %d", var, eq_neq, ints[i]);
                 }
diff --git a/tools/perf/util/string2.h b/tools/perf/util/string2.h
new file mode 100644
index 000000000000..2f619681bd6a
--- /dev/null
+++ b/tools/perf/util/string2.h
@@ -0,0 +1,42 @@
+#ifndef PERF_STRING_H
+#define PERF_STRING_H
+
+#include <linux/types.h>
+#include <stddef.h>
+#include <string.h>
+
+s64 perf_atoll(const char *str);
+char **argv_split(const char *str, int *argcp);
+void argv_free(char **argv);
+bool strglobmatch(const char *str, const char *pat);
+bool strglobmatch_nocase(const char *str, const char *pat);
+bool strlazymatch(const char *str, const char *pat);
+static inline bool strisglob(const char *str)
+{
+        return strpbrk(str, "*?[") != NULL;
+}
+int strtailcmp(const char *s1, const char *s2);
+char *strxfrchar(char *s, char from, char to);
+
+char *ltrim(char *s);
+char *rtrim(char *s);
+
+static inline char *trim(char *s)
+{
+        return ltrim(rtrim(s));
+}
+
+char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints);
+
+static inline char *asprintf_expr_in_ints(const char *var, size_t nints, int *ints)
+{
+        return asprintf_expr_inout_ints(var, true, nints, ints);
+}
+
+static inline char *asprintf_expr_not_in_ints(const char *var, size_t nints, int *ints)
+{
+        return asprintf_expr_inout_ints(var, false, nints, ints);
+}
+
+
+#endif /* PERF_STRING_H */
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
index 0d3dfcb919b4..9de5434bb49e 100644
--- a/tools/perf/util/strlist.c
+++ b/tools/perf/util/strlist.c
@@ -10,6 +10,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 static
 struct rb_node *strlist__node_new(struct rblist *rblist, const void *entry)
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 4e59ddeb4eda..e7ee47f7377a 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -10,8 +10,9 @@
 #include "demangle-rust.h"
 #include "machine.h"
 #include "vdso.h"
-#include <symbol/kallsyms.h>
 #include "debug.h"
+#include "sane_ctype.h"
+#include <symbol/kallsyms.h>
 
 #ifndef EM_AARCH64
 #define EM_AARCH64      183  /* ARM 64 bit */
@@ -390,6 +391,11 @@ out_elf_end:
         return 0;
 }
 
+char *dso__demangle_sym(struct dso *dso, int kmodule, char *elf_name)
+{
+        return demangle_sym(dso, kmodule, elf_name);
+}
+
 /*
  * Align offset to 4 bytes as needed for note name and descriptor data.
  */
@@ -1828,7 +1834,7 @@ void kcore_extract__delete(struct kcore_extract *kce)
 static int populate_sdt_note(Elf **elf, const char *data, size_t len,
                              struct list_head *sdt_notes)
 {
-        const char *provider, *name;
+        const char *provider, *name, *args;
         struct sdt_note *tmp = NULL;
         GElf_Ehdr ehdr;
         GElf_Addr base_off = 0;
@@ -1887,6 +1893,25 @@ static int populate_sdt_note(Elf **elf, const char *data, size_t len,
                 goto out_free_prov;
         }
 
+        args = memchr(name, '\0', data + len - name);
+
+        /*
+         * There is no argument if:
+         * - We reached the end of the note;
+         * - There is not enough room to hold a potential string;
+         * - The argument string is empty or just contains ':'.
+         */
+        if (args == NULL || data + len - args < 2 ||
+                args[1] == ':' || args[1] == '\0')
+                tmp->args = NULL;
+        else {
+                tmp->args = strdup(++args);
+                if (!tmp->args) {
+                        ret = -ENOMEM;
+                        goto out_free_name;
+                }
+        }
+
         if (gelf_getclass(*elf) == ELFCLASS32) {
                 memcpy(&tmp->addr, &buf, 3 * sizeof(Elf32_Addr));
                 tmp->bit32 = true;
@@ -1898,7 +1923,7 @@ static int populate_sdt_note(Elf **elf, const char *data, size_t len,
         if (!gelf_getehdr(*elf, &ehdr)) {
                 pr_debug("%s : cannot get elf header.\n", __func__);
                 ret = -EBADF;
-                goto out_free_name;
+                goto out_free_args;
         }
 
         /* Adjust the prelink effect :
@@ -1923,6 +1948,8 @@ static int populate_sdt_note(Elf **elf, const char *data, size_t len,
         list_add_tail(&tmp->note_list, sdt_notes);
         return 0;
 
+out_free_args:
+        free(tmp->args);
 out_free_name:
         free(tmp->name);
 out_free_prov:
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index 11cdde980545..40bf5d4c0bfd 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -1,6 +1,7 @@
 #include "symbol.h"
 #include "util.h"
 
+#include <errno.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <string.h>
@@ -373,3 +374,10 @@ int kcore_copy(const char *from_dir __maybe_unused,
 void symbol__elf_init(void)
 {
 }
+
+char *dso__demangle_sym(struct dso *dso __maybe_unused,
+                        int kmodule __maybe_unused,
+                        char *elf_name __maybe_unused)
+{
+        return NULL;
+}
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 9b4d8ba22fed..2cb7665e9973 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <linux/kernel.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/param.h>
@@ -18,6 +19,8 @@
 #include "strlist.h"
 #include "intlist.h"
 #include "header.h"
+#include "path.h"
+#include "sane_ctype.h"
 
 #include <elf.h>
 #include <limits.h>
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 6c358b7ed336..7acd70fce68e 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -13,7 +13,7 @@
 #include <libgen.h>
 #include "build-id.h"
 #include "event.h"
-#include "util.h"
+#include "path.h"
 
 #ifdef HAVE_LIBELF_SUPPORT
 #include <libelf.h>
@@ -118,7 +118,8 @@ struct symbol_conf {
                         show_ref_callgraph,
                         hide_unresolved,
                         raw_trace,
-                        report_hierarchy;
+                        report_hierarchy,
+                        inline_name;
         const char      *vmlinux_name,
                         *kallsyms_name,
                         *source_prefix,
@@ -305,6 +306,8 @@ int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
 int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss,
                                 struct map *map);
 
+char *dso__demangle_sym(struct dso *dso, int kmodule, char *elf_name);
+
 void __symbols__insert(struct rb_root *symbols, struct symbol *sym, bool kernel);
 void symbols__insert(struct rb_root *symbols, struct symbol *sym);
 void symbols__fixup_duplicate(struct rb_root *symbols);
@@ -351,6 +354,7 @@ int arch__choose_best_symbol(struct symbol *syma, struct symbol *symb);
 struct sdt_note {
         char *name;                     /* name of the note*/
         char *provider;                 /* provider name */
+        char *args;
         bool bit32;                     /* whether the location is 32 bits? */
         union {                         /* location, base and semaphore addrs */
                 Elf64_Addr a64[3];
diff --git a/tools/perf/util/term.c b/tools/perf/util/term.c
index 90b47d8aa19c..8f254a74d97d 100644
--- a/tools/perf/util/term.c
+++ b/tools/perf/util/term.c
@@ -1,4 +1,8 @@
-#include "util.h"
+#include "term.h"
+#include <stdlib.h>
+#include <termios.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
 
 void get_term_dimensions(struct winsize *ws)
 {
diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c
index d3301529f6a7..dd17d6a38d3a 100644
--- a/tools/perf/util/thread-stack.c
+++ b/tools/perf/util/thread-stack.c
@@ -15,6 +15,7 @@
 
 #include <linux/rbtree.h>
 #include <linux/list.h>
+#include <errno.h>
 #include "thread.h"
 #include "event.h"
 #include "machine.h"
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index f5af87f66663..378c418ca0c1 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -1,12 +1,15 @@
 #include "../perf.h"
+#include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <linux/kernel.h>
 #include "session.h"
 #include "thread.h"
 #include "thread-stack.h"
 #include "util.h"
 #include "debug.h"
+#include "namespaces.h"
 #include "comm.h"
 #include "unwind.h"
 
@@ -40,6 +43,7 @@ struct thread *thread__new(pid_t pid, pid_t tid)
                 thread->tid = tid;
                 thread->ppid = -1;
                 thread->cpu = -1;
+                INIT_LIST_HEAD(&thread->namespaces_list);
                 INIT_LIST_HEAD(&thread->comm_list);
 
                 comm_str = malloc(32);
@@ -53,7 +57,7 @@ struct thread *thread__new(pid_t pid, pid_t tid)
                         goto err_thread;
 
                 list_add(&comm->list, &thread->comm_list);
-                atomic_set(&thread->refcnt, 1);
+                refcount_set(&thread->refcnt, 1);
                 RB_CLEAR_NODE(&thread->rb_node);
         }
 
@@ -66,7 +70,8 @@ err_thread:
 
 void thread__delete(struct thread *thread)
 {
-        struct comm *comm, *tmp;
+        struct namespaces *namespaces, *tmp_namespaces;
+        struct comm *comm, *tmp_comm;
 
         BUG_ON(!RB_EMPTY_NODE(&thread->rb_node));
 
@@ -76,7 +81,12 @@ void thread__delete(struct thread *thread)
                 map_groups__put(thread->mg);
                 thread->mg = NULL;
         }
-        list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) {
+        list_for_each_entry_safe(namespaces, tmp_namespaces,
+                                 &thread->namespaces_list, list) {
+                list_del(&namespaces->list);
+                namespaces__free(namespaces);
+        }
+        list_for_each_entry_safe(comm, tmp_comm, &thread->comm_list, list) {
                 list_del(&comm->list);
                 comm__free(comm);
         }
@@ -88,13 +98,13 @@ void thread__delete(struct thread *thread)
 struct thread *thread__get(struct thread *thread)
 {
         if (thread)
-                atomic_inc(&thread->refcnt);
+                refcount_inc(&thread->refcnt);
         return thread;
 }
 
 void thread__put(struct thread *thread)
 {
-        if (thread && atomic_dec_and_test(&thread->refcnt)) {
+        if (thread && refcount_dec_and_test(&thread->refcnt)) {
                 /*
                  * Remove it from the dead_threads list, as last reference
                  * is gone.
@@ -104,6 +114,38 @@ void thread__put(struct thread *thread)
         }
 }
 
+struct namespaces *thread__namespaces(const struct thread *thread)
+{
+        if (list_empty(&thread->namespaces_list))
+                return NULL;
+
+        return list_first_entry(&thread->namespaces_list, struct namespaces, list);
+}
+
+int thread__set_namespaces(struct thread *thread, u64 timestamp,
+                           struct namespaces_event *event)
+{
+        struct namespaces *new, *curr = thread__namespaces(thread);
+
+        new = namespaces__new(event);
+        if (!new)
+                return -ENOMEM;
+
+        list_add(&new->list, &thread->namespaces_list);
+
+        if (timestamp && curr) {
+                /*
+                 * setns syscall must have changed few or all the namespaces
+                 * of this thread. Update end time for the namespaces
+                 * previously used.
+                 */
+                curr = list_next_entry(new, list);
+                curr->end_time = timestamp;
+        }
+
+        return 0;
+}
+
 struct comm *thread__comm(const struct thread *thread)
 {
         if (list_empty(&thread->comm_list))
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 99263cb6e6b6..4eb849e9098f 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -1,7 +1,7 @@
 #ifndef __PERF_THREAD_H
 #define __PERF_THREAD_H
 
-#include <linux/atomic.h>
+#include <linux/refcount.h>
 #include <linux/rbtree.h>
 #include <linux/list.h>
 #include <unistd.h>
@@ -23,11 +23,12 @@ struct thread {
         pid_t                   tid;
         pid_t                   ppid;
         int                     cpu;
-        atomic_t                refcnt;
+        refcount_t              refcnt;
         char                    shortname[3];
         bool                    comm_set;
         int                     comm_len;
         bool                    dead; /* if set thread has exited */
+        struct list_head        namespaces_list;
         struct list_head        comm_list;
         u64                     db_id;
 
@@ -40,6 +41,7 @@ struct thread {
 };
 
 struct machine;
+struct namespaces;
 struct comm;
 
 struct thread *thread__new(pid_t pid, pid_t tid);
@@ -62,6 +64,10 @@ static inline void thread__exited(struct thread *thread)
         thread->dead = true;
 }
 
+struct namespaces *thread__namespaces(const struct thread *thread);
+int thread__set_namespaces(struct thread *thread, u64 timestamp,
+                           struct namespaces_event *event);
+
 int __thread__set_comm(struct thread *thread, const char *comm, u64 timestamp,
                        bool exec);
 static inline int thread__set_comm(struct thread *thread, const char *comm,
diff --git a/tools/perf/util/thread_map.c b/tools/perf/util/thread_map.c
index 7c3fcc538a70..63ead7b06324 100644
--- a/tools/perf/util/thread_map.c
+++ b/tools/perf/util/thread_map.c
@@ -1,4 +1,5 @@
 #include <dirent.h>
+#include <errno.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -6,6 +7,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include "string2.h"
 #include "strlist.h"
 #include <string.h>
 #include <api/fs/fs.h>
@@ -66,7 +68,7 @@ struct thread_map *thread_map__new_by_pid(pid_t pid)
                 for (i = 0; i < items; i++)
                         thread_map__set_pid(threads, i, atoi(namelist[i]->d_name));
                 threads->nr = items;
-                atomic_set(&threads->refcnt, 1);
+                refcount_set(&threads->refcnt, 1);
         }
 
         for (i=0; i<items; i++)
@@ -83,7 +85,7 @@ struct thread_map *thread_map__new_by_tid(pid_t tid)
         if (threads != NULL) {
                 thread_map__set_pid(threads, 0, tid);
                 threads->nr = 1;
-                atomic_set(&threads->refcnt, 1);
+                refcount_set(&threads->refcnt, 1);
         }
 
         return threads;
@@ -105,7 +107,7 @@ struct thread_map *thread_map__new_by_uid(uid_t uid)
                 goto out_free_threads;
 
         threads->nr = 0;
-        atomic_set(&threads->refcnt, 1);
+        refcount_set(&threads->refcnt, 1);
 
         while ((dirent = readdir(proc)) != NULL) {
                 char *end;
@@ -235,7 +237,7 @@ static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
 out:
         strlist__delete(slist);
         if (threads)
-                atomic_set(&threads->refcnt, 1);
+                refcount_set(&threads->refcnt, 1);
         return threads;
 
 out_free_namelist:
@@ -255,7 +257,7 @@ struct thread_map *thread_map__new_dummy(void)
         if (threads != NULL) {
                 thread_map__set_pid(threads, 0, -1);
                 threads->nr = 1;
-                atomic_set(&threads->refcnt, 1);
+                refcount_set(&threads->refcnt, 1);
         }
         return threads;
 }
@@ -300,7 +302,7 @@ struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
         }
 out:
         if (threads)
-                atomic_set(&threads->refcnt, 1);
+                refcount_set(&threads->refcnt, 1);
         return threads;
 
 out_free_threads:
@@ -326,7 +328,7 @@ static void thread_map__delete(struct thread_map *threads)
         if (threads) {
                 int i;
 
-                WARN_ONCE(atomic_read(&threads->refcnt) != 0,
+                WARN_ONCE(refcount_read(&threads->refcnt) != 0,
                           "thread map refcnt unbalanced\n");
                 for (i = 0; i < threads->nr; i++)
                         free(thread_map__comm(threads, i));
@@ -337,13 +339,13 @@ static void thread_map__delete(struct thread_map *threads)
 struct thread_map *thread_map__get(struct thread_map *map)
 {
         if (map)
-                atomic_inc(&map->refcnt);
+                refcount_inc(&map->refcnt);
         return map;
 }
 
 void thread_map__put(struct thread_map *map)
 {
-        if (map && atomic_dec_and_test(&map->refcnt))
+        if (map && refcount_dec_and_test(&map->refcnt))
                 thread_map__delete(map);
 }
 
@@ -423,7 +425,7 @@ static void thread_map__copy_event(struct thread_map *threads,
                 threads->map[i].comm = strndup(event->entries[i].comm, 16);
         }
 
-        atomic_set(&threads->refcnt, 1);
+        refcount_set(&threads->refcnt, 1);
 }
 
 struct thread_map *thread_map__new_event(struct thread_map_event *event)
diff --git a/tools/perf/util/thread_map.h b/tools/perf/util/thread_map.h
index ea0ef08c6303..bd34d7a0b9fa 100644
--- a/tools/perf/util/thread_map.h
+++ b/tools/perf/util/thread_map.h
@@ -3,7 +3,7 @@
 
 #include <sys/types.h>
 #include <stdio.h>
-#include <linux/atomic.h>
+#include <linux/refcount.h>
 
 struct thread_map_data {
         pid_t    pid;
@@ -11,7 +11,7 @@ struct thread_map_data {
 };
 
 struct thread_map {
-        atomic_t refcnt;
+        refcount_t refcnt;
         int nr;
         struct thread_map_data map[];
 };
diff --git a/tools/perf/util/time-utils.c b/tools/perf/util/time-utils.c
index d1b21c72206d..5b5d0214debd 100644
--- a/tools/perf/util/time-utils.c
+++ b/tools/perf/util/time-utils.c
@@ -117,3 +117,28 @@ bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
 
         return false;
 }
+
+int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
+{
+        u64  sec = timestamp / NSEC_PER_SEC;
+        u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;
+
+        return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
+}
+
+int fetch_current_timestamp(char *buf, size_t sz)
+{
+        struct timeval tv;
+        struct tm tm;
+        char dt[32];
+
+        if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
+                return -1;
+
+        if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
+                return -1;
+
+        scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
+
+        return 0;
+}
diff --git a/tools/perf/util/time-utils.h b/tools/perf/util/time-utils.h
index c1f197c4af6c..8656be08513b 100644
--- a/tools/perf/util/time-utils.h
+++ b/tools/perf/util/time-utils.h
@@ -1,6 +1,9 @@
 #ifndef _TIME_UTILS_H_
 #define _TIME_UTILS_H_
 
+#include <stddef.h>
+#include <linux/types.h>
+
 struct perf_time_interval {
         u64 start, end;
 };
@@ -11,4 +14,8 @@ int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr);
 
 bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp);
 
+int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz);
+
+int fetch_current_timestamp(char *buf, size_t sz);
+
 #endif
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index ac2590a3de2d..829471a1c6d7 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -40,6 +40,7 @@ struct perf_tool {
         event_op        mmap,
                         mmap2,
                         comm,
+                        namespaces,
                         fork,
                         exit,
                         lost,
@@ -66,6 +67,7 @@ struct perf_tool {
         event_op3       auxtrace;
         bool            ordered_events;
         bool            ordering_requires_timestamps;
+        bool            namespace_events;
 };
 
 #endif /* __PERF_TOOL_H */
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index b2940c88734a..9bdfb78a9a35 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -5,7 +5,7 @@
 #include <linux/types.h>
 #include <stddef.h>
 #include <stdbool.h>
-#include <termios.h>
+#include <sys/ioctl.h>
 
 struct perf_evlist;
 struct perf_evsel;
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index de0078e21408..746bbee645d9 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -21,13 +21,14 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <errno.h>
 
 #include "../perf.h"
 #include "util.h"
 #include "trace-event.h"
 
+#include "sane_ctype.h"
+
 static int get_common_field(struct scripting_context *context,
                             int *offset, int *size, const char *type)
 {
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 27420159bf69..8a9a677f7576 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -192,7 +192,7 @@ static int read_ftrace_printk(struct pevent *pevent)
         if (!size)
                 return 0;
 
-        buf = malloc(size);
+        buf = malloc(size + 1);
         if (buf == NULL)
                 return -1;
 
@@ -201,6 +201,8 @@ static int read_ftrace_printk(struct pevent *pevent)
                 return -1;
         }
 
+        buf[size] = '\0';
+
         parse_ftrace_printk(pevent, buf, size);
 
         free(buf);
diff --git a/tools/perf/util/units.c b/tools/perf/util/units.c
new file mode 100644
index 000000000000..f6a2a3d117d5
--- /dev/null
+++ b/tools/perf/util/units.c
@@ -0,0 +1,39 @@
+#include "units.h"
+#include <inttypes.h>
+#include <linux/kernel.h>
+#include <linux/time64.h>
+
+unsigned long convert_unit(unsigned long value, char *unit)
+{
+        *unit = ' ';
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'K';
+        }
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'M';
+        }
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'G';
+        }
+
+        return value;
+}
+
+int unit_number__scnprintf(char *buf, size_t size, u64 n)
+{
+        char unit[4] = "BKMG";
+        int i = 0;
+
+        while (((n / 1024) > 1) && (i < 3)) {
+                n /= 1024;
+                i++;
+        }
+
+        return scnprintf(buf, size, "%" PRIu64 "%c", n, unit[i]);
+}
diff --git a/tools/perf/util/units.h b/tools/perf/util/units.h
new file mode 100644
index 000000000000..3ed7774afaa9
--- /dev/null
+++ b/tools/perf/util/units.h
@@ -0,0 +1,10 @@
+#ifndef PERF_UNIT_H
+#define PERF_UNIT_H
+
+#include <stddef.h>
+#include <linux/types.h>
+
+unsigned long convert_unit(unsigned long value, char *unit);
+int unit_number__scnprintf(char *buf, size_t size, u64 n);
+
+#endif /* PERF_UNIT_H */
diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c
index 783a53fb7a4e..f90e11a555b2 100644
--- a/tools/perf/util/unwind-libdw.c
+++ b/tools/perf/util/unwind-libdw.c
@@ -12,6 +12,7 @@
 #include "event.h"
 #include "perf_regs.h"
 #include "callchain.h"
+#include "util.h"
 
 static char *debuginfo_path;
 
diff --git a/tools/perf/util/unwind-libdw.h b/tools/perf/util/unwind-libdw.h
index 58328669ed16..4a2b269a7b3b 100644
--- a/tools/perf/util/unwind-libdw.h
+++ b/tools/perf/util/unwind-libdw.h
@@ -2,10 +2,12 @@
 #define __PERF_UNWIND_LIBDW_H
 
 #include <elfutils/libdwfl.h>
-#include "event.h"
-#include "thread.h"
 #include "unwind.h"
 
+struct machine;
+struct perf_sample;
+struct thread;
+
 bool libdw__arch_set_initial_registers(Dwfl_Thread *thread, void *arg);
 
 struct unwind_info {
diff --git a/tools/perf/util/unwind-libunwind-local.c b/tools/perf/util/unwind-libunwind-local.c
index bfb9b7987692..f8455bed6e65 100644
--- a/tools/perf/util/unwind-libunwind-local.c
+++ b/tools/perf/util/unwind-libunwind-local.c
@@ -16,8 +16,10 @@
  */
 
 #include <elf.h>
+#include <errno.h>
 #include <gelf.h>
 #include <fcntl.h>
+#include <inttypes.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/mman.h>
diff --git a/tools/perf/util/unwind.h b/tools/perf/util/unwind.h
index 61fb1e90ff51..bfbdcc6198c9 100644
--- a/tools/perf/util/unwind.h
+++ b/tools/perf/util/unwind.h
@@ -1,10 +1,13 @@
 #ifndef __UNWIND_H
 #define __UNWIND_H
 
+#include <linux/compiler.h>
 #include <linux/types.h>
-#include "event.h"
-#include "symbol.h"
-#include "thread.h"
+
+struct map;
+struct perf_sample;
+struct symbol;
+struct thread;
 
 struct unwind_entry {
         struct map      *map;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index d8b45cea54d0..6450c75a6f5b 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -3,10 +3,11 @@
 #include "debug.h"
 #include <api/fs/fs.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
 #include <sys/utsname.h>
-#ifdef HAVE_BACKTRACE_SUPPORT
-#include <execinfo.h>
-#endif
+#include <dirent.h>
+#include <inttypes.h>
+#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -17,24 +18,8 @@
 #include <linux/log2.h>
 #include <linux/time64.h>
 #include <unistd.h>
-#include "callchain.h"
 #include "strlist.h"
 
-#define CALLCHAIN_PARAM_DEFAULT                 \
-        .mode           = CHAIN_GRAPH_ABS,      \
-        .min_percent    = 0.5,                  \
-        .order          = ORDER_CALLEE,         \
-        .key            = CCKEY_FUNCTION,       \
-        .value          = CCVAL_PERCENT,        \
-
-struct callchain_param callchain_param = {
-        CALLCHAIN_PARAM_DEFAULT
-};
-
-struct callchain_param callchain_param_default = {
-        CALLCHAIN_PARAM_DEFAULT
-};
-
 /*
  * XXX We need to find a better place for these things...
  */
@@ -269,28 +254,6 @@ int copyfile(const char *from, const char *to)
         return copyfile_mode(from, to, 0755);
 }
 
-unsigned long convert_unit(unsigned long value, char *unit)
-{
-        *unit = ' ';
-
-        if (value > 1000) {
-                value /= 1000;
-                *unit = 'K';
-        }
-
-        if (value > 1000) {
-                value /= 1000;
-                *unit = 'M';
-        }
-
-        if (value > 1000) {
-                value /= 1000;
-                *unit = 'G';
-        }
-
-        return value;
-}
-
 static ssize_t ion(bool is_read, int fd, void *buf, size_t n)
 {
         void *buf_start = buf;
@@ -372,42 +335,6 @@ int hex2u64(const char *ptr, u64 *long_val)
         return p - ptr;
 }
 
-/* Obtain a backtrace and print it to stdout. */
-#ifdef HAVE_BACKTRACE_SUPPORT
-void dump_stack(void)
-{
-        void *array[16];
-        size_t size = backtrace(array, ARRAY_SIZE(array));
-        char **strings = backtrace_symbols(array, size);
-        size_t i;
-
-        printf("Obtained %zd stack frames.\n", size);
-
-        for (i = 0; i < size; i++)
-                printf("%s\n", strings[i]);
-
-        free(strings);
-}
-#else
-void dump_stack(void) {}
-#endif
-
-void sighandler_dump_stack(int sig)
-{
-        psignal(sig, "perf");
-        dump_stack();
-        signal(sig, SIG_DFL);
-        raise(sig);
-}
-
-int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
-{
-        u64  sec = timestamp / NSEC_PER_SEC;
-        u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;
-
-        return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
-}
-
 unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
 {
         struct parse_tag *i = tags;
@@ -435,108 +362,6 @@ unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
         return (unsigned long) -1;
 }
 
-int get_stack_size(const char *str, unsigned long *_size)
-{
-        char *endptr;
-        unsigned long size;
-        unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
-
-        size = strtoul(str, &endptr, 0);
-
-        do {
-                if (*endptr)
-                        break;
-
-                size = round_up(size, sizeof(u64));
-                if (!size || size > max_size)
-                        break;
-
-                *_size = size;
-                return 0;
-
-        } while (0);
-
-        pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
-               max_size, str);
-        return -1;
-}
-
-int parse_callchain_record(const char *arg, struct callchain_param *param)
-{
-        char *tok, *name, *saveptr = NULL;
-        char *buf;
-        int ret = -1;
-
-        /* We need buffer that we know we can write to. */
-        buf = malloc(strlen(arg) + 1);
-        if (!buf)
-                return -ENOMEM;
-
-        strcpy(buf, arg);
-
-        tok = strtok_r((char *)buf, ",", &saveptr);
-        name = tok ? : (char *)buf;
-
-        do {
-                /* Framepointer style */
-                if (!strncmp(name, "fp", sizeof("fp"))) {
-                        if (!strtok_r(NULL, ",", &saveptr)) {
-                                param->record_mode = CALLCHAIN_FP;
-                                ret = 0;
-                        } else
-                                pr_err("callchain: No more arguments "
-                                       "needed for --call-graph fp\n");
-                        break;
-
-                /* Dwarf style */
-                } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
-                        const unsigned long default_stack_dump_size = 8192;
-
-                        ret = 0;
-                        param->record_mode = CALLCHAIN_DWARF;
-                        param->dump_size = default_stack_dump_size;
-
-                        tok = strtok_r(NULL, ",", &saveptr);
-                        if (tok) {
-                                unsigned long size = 0;
-
-                                ret = get_stack_size(tok, &size);
-                                param->dump_size = size;
-                        }
-                } else if (!strncmp(name, "lbr", sizeof("lbr"))) {
-                        if (!strtok_r(NULL, ",", &saveptr)) {
-                                param->record_mode = CALLCHAIN_LBR;
-                                ret = 0;
-                        } else
-                                pr_err("callchain: No more arguments "
-                                        "needed for --call-graph lbr\n");
-                        break;
-                } else {
-                        pr_err("callchain: Unknown --call-graph option "
-                               "value: %s\n", arg);
-                        break;
-                }
-
-        } while (0);
-
-        free(buf);
-        return ret;
-}
-
-const char *get_filename_for_perf_kvm(void)
-{
-        const char *filename;
-
-        if (perf_host && !perf_guest)
-                filename = strdup("perf.data.host");
-        else if (!perf_host && perf_guest)
-                filename = strdup("perf.data.guest");
-        else
-                filename = strdup("perf.data.kvm");
-
-        return filename;
-}
-
 int perf_event_paranoid(void)
 {
         int value;
@@ -696,7 +521,8 @@ const char *perf_tip(const char *dirpath)
 
         tips = strlist__new("tips.txt", &conf);
         if (tips == NULL)
-                return errno == ENOENT ? NULL : "Tip: get more memory! ;-p";
+                return errno == ENOENT ? NULL :
+                        "Tip: check path of tips.txt or get more memory! ;-p";
 
         if (strlist__nr_entries(tips) == 0)
                 goto out;
@@ -710,95 +536,3 @@ out:
 
         return tip;
 }
-
-bool is_regular_file(const char *file)
-{
-        struct stat st;
-
-        if (stat(file, &st))
-                return false;
-
-        return S_ISREG(st.st_mode);
-}
-
-int fetch_current_timestamp(char *buf, size_t sz)
-{
-        struct timeval tv;
-        struct tm tm;
-        char dt[32];
-
-        if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
-                return -1;
-
-        if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
-                return -1;
-
-        scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
-
-        return 0;
-}
-
-void print_binary(unsigned char *data, size_t len,
-                  size_t bytes_per_line, print_binary_t printer,
-                  void *extra)
-{
-        size_t i, j, mask;
-
-        if (!printer)
-                return;
-
-        bytes_per_line = roundup_pow_of_two(bytes_per_line);
-        mask = bytes_per_line - 1;
-
-        printer(BINARY_PRINT_DATA_BEGIN, 0, extra);
-        for (i = 0; i < len; i++) {
-                if ((i & mask) == 0) {
-                        printer(BINARY_PRINT_LINE_BEGIN, -1, extra);
-                        printer(BINARY_PRINT_ADDR, i, extra);
-                }
-
-                printer(BINARY_PRINT_NUM_DATA, data[i], extra);
-
-                if (((i & mask) == mask) || i == len - 1) {
-                        for (j = 0; j < mask-(i & mask); j++)
-                                printer(BINARY_PRINT_NUM_PAD, -1, extra);
-
-                        printer(BINARY_PRINT_SEP, i, extra);
-                        for (j = i & ~mask; j <= i; j++)
-                                printer(BINARY_PRINT_CHAR_DATA, data[j], extra);
-                        for (j = 0; j < mask-(i & mask); j++)
-                                printer(BINARY_PRINT_CHAR_PAD, i, extra);
-                        printer(BINARY_PRINT_LINE_END, -1, extra);
-                }
-        }
-        printer(BINARY_PRINT_DATA_END, -1, extra);
-}
-
-int is_printable_array(char *p, unsigned int len)
-{
-        unsigned int i;
-
-        if (!p || !len || p[len - 1] != 0)
-                return 0;
-
-        len--;
-
-        for (i = 0; i < len; i++) {
-                if (!isprint(p[i]) && !isspace(p[i]))
-                        return 0;
-        }
-        return 1;
-}
-
-int unit_number__scnprintf(char *buf, size_t size, u64 n)
-{
-        char unit[4] = "BKMG";
-        int i = 0;
-
-        while (((n / 1024) > 1) && (i < 3)) {
-                n /= 1024;
-                i++;
-        }
-
-        return scnprintf(buf, size, "%" PRIu64 "%c", n, unit[i]);
-}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index c74708da8571..3852b6d3270a 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -1,126 +1,21 @@
 #ifndef GIT_COMPAT_UTIL_H
 #define GIT_COMPAT_UTIL_H
 
-#ifndef FLEX_ARRAY
-/*
- * See if our compiler is known to support flexible array members.
- */
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-# define FLEX_ARRAY /* empty */
-#elif defined(__GNUC__)
-# if (__GNUC__ >= 3)
-#  define FLEX_ARRAY /* empty */
-# else
-#  define FLEX_ARRAY 0 /* older GNU extension */
-# endif
-#endif
-
-/*
- * Otherwise, default to safer but a bit wasteful traditional style
- */
-#ifndef FLEX_ARRAY
-# define FLEX_ARRAY 1
-#endif
-#endif
-
-#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
-
-#ifdef __GNUC__
-#define TYPEOF(x) (__typeof__(x))
-#else
-#define TYPEOF(x)
-#endif
-
-#define MSB(x, bits) ((x) & TYPEOF(x)(~0ULL << (sizeof(x) * 8 - (bits))))
-#define HAS_MULTI_BITS(i)  ((i) & ((i) - 1))  /* checks if an integer has more than 1 bit set */
-
-/* Approximation of the length of the decimal representation of this type. */
-#define decimal_length(x)       ((int)(sizeof(x) * 2.56 + 0.5) + 1)
-
 #define _ALL_SOURCE 1
 #define _BSD_SOURCE 1
 /* glibc 2.20 deprecates _BSD_SOURCE in favour of _DEFAULT_SOURCE */
 #define _DEFAULT_SOURCE 1
 #define HAS_BOOL
 
-#include <unistd.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <sys/statfs.h>
 #include <fcntl.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdarg.h>
-#include <string.h>
-#include <term.h>
-#include <errno.h>
-#include <limits.h>
-#include <sys/param.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <sys/time.h>
-#include <time.h>
-#include <signal.h>
-#include <fnmatch.h>
-#include <assert.h>
-#include <regex.h>
-#include <utime.h>
-#include <sys/wait.h>
-#include <poll.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <inttypes.h>
-#include <linux/kernel.h>
 #include <linux/types.h>
-#include <sys/ttydefaults.h>
-#include <api/fs/tracing_path.h>
-#include <termios.h>
-#include <linux/bitops.h>
-#include <termios.h>
-#include "strlist.h"
 
-extern const char *graph_line;
-extern const char *graph_dotted_line;
-extern const char *spaces;
-extern const char *dots;
 extern char buildid_dir[];
 
-/* On most systems <limits.h> would have given us this, but
- * not on some systems (e.g. GNU/Hurd).
- */
-#ifndef PATH_MAX
-#define PATH_MAX 4096
-#endif
-
-#ifndef PRIuMAX
-#define PRIuMAX "llu"
-#endif
-
-#ifndef PRIu32
-#define PRIu32 "u"
-#endif
-
-#ifndef PRIx32
-#define PRIx32 "x"
-#endif
-
-#ifndef PATH_SEP
-#define PATH_SEP ':'
-#endif
-
-#ifndef STRIP_EXTENSION
-#define STRIP_EXTENSION ""
-#endif
-
-#ifndef has_dos_drive_prefix
-#define has_dos_drive_prefix(path) 0
-#endif
-
-#ifndef is_dir_sep
-#define is_dir_sep(c) ((c) == '/')
-#endif
-
 #ifdef __GNUC__
 #define NORETURN __attribute__((__noreturn__))
 #else
@@ -143,22 +38,6 @@ void set_warning_routine(void (*routine)(const char *err, va_list params));
 int prefixcmp(const char *str, const char *prefix);
 void set_buildid_dir(const char *dir);
 
-#ifdef __GLIBC_PREREQ
-#if __GLIBC_PREREQ(2, 1)
-#define HAVE_STRCHRNUL
-#endif
-#endif
-
-#ifndef HAVE_STRCHRNUL
-#define strchrnul gitstrchrnul
-static inline char *gitstrchrnul(const char *s, int c)
-{
-        while (*s && *s != c)
-                s++;
-        return (char *)s;
-}
-#endif
-
 static inline void *zalloc(size_t size)
 {
         return calloc(1, size);
@@ -166,47 +45,8 @@ static inline void *zalloc(size_t size)
 
 #define zfree(ptr) ({ free(*ptr); *ptr = NULL; })
 
-/* Sane ctype - no locale, and works with signed chars */
-#undef isascii
-#undef isspace
-#undef isdigit
-#undef isxdigit
-#undef isalpha
-#undef isprint
-#undef isalnum
-#undef islower
-#undef isupper
-#undef tolower
-#undef toupper
-
-extern unsigned char sane_ctype[256];
-#define GIT_SPACE               0x01
-#define GIT_DIGIT               0x02
-#define GIT_ALPHA               0x04
-#define GIT_GLOB_SPECIAL        0x08
-#define GIT_REGEX_SPECIAL       0x10
-#define GIT_PRINT_EXTRA         0x20
-#define GIT_PRINT               0x3E
-#define sane_istest(x,mask) ((sane_ctype[(unsigned char)(x)] & (mask)) != 0)
-#define isascii(x) (((x) & ~0x7f) == 0)
-#define isspace(x) sane_istest(x,GIT_SPACE)
-#define isdigit(x) sane_istest(x,GIT_DIGIT)
-#define isxdigit(x)     \
-        (sane_istest(toupper(x), GIT_ALPHA | GIT_DIGIT) && toupper(x) < 'G')
-#define isalpha(x) sane_istest(x,GIT_ALPHA)
-#define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
-#define isprint(x) sane_istest(x,GIT_PRINT)
-#define islower(x) (sane_istest(x,GIT_ALPHA) && (x & 0x20))
-#define isupper(x) (sane_istest(x,GIT_ALPHA) && !(x & 0x20))
-#define tolower(x) sane_case((unsigned char)(x), 0x20)
-#define toupper(x) sane_case((unsigned char)(x), 0)
-
-static inline int sane_case(int x, int high)
-{
-        if (sane_istest(x, GIT_ALPHA))
-                x = (x & ~0x20) | high;
-        return x;
-}
+struct dirent;
+struct strlist;
 
 int mkdir_p(char *path, mode_t mode);
 int rm_rf(const char *path);
@@ -216,19 +56,6 @@ int copyfile(const char *from, const char *to);
 int copyfile_mode(const char *from, const char *to, mode_t mode);
 int copyfile_offset(int fromfd, loff_t from_ofs, int tofd, loff_t to_ofs, u64 size);
 
-s64 perf_atoll(const char *str);
-char **argv_split(const char *str, int *argcp);
-void argv_free(char **argv);
-bool strglobmatch(const char *str, const char *pat);
-bool strglobmatch_nocase(const char *str, const char *pat);
-bool strlazymatch(const char *str, const char *pat);
-static inline bool strisglob(const char *str)
-{
-        return strpbrk(str, "*?[") != NULL;
-}
-int strtailcmp(const char *s1, const char *s2);
-char *strxfrchar(char *s, char from, char to);
-unsigned long convert_unit(unsigned long value, char *unit);
 ssize_t readn(int fd, void *buf, size_t n);
 ssize_t writen(int fd, void *buf, size_t n);
 
@@ -236,23 +63,9 @@ struct perf_event_attr;
 
 void event_attr_init(struct perf_event_attr *attr);
 
-#define _STR(x) #x
-#define STR(x) _STR(x)
-
 size_t hex_width(u64 v);
 int hex2u64(const char *ptr, u64 *val);
 
-char *ltrim(char *s);
-char *rtrim(char *s);
-
-static inline char *trim(char *s)
-{
-        return ltrim(rtrim(s));
-}
-
-void dump_stack(void);
-void sighandler_dump_stack(int sig);
-
 extern unsigned int page_size;
 extern int cacheline_size;
 extern int sysctl_perf_event_max_stack;
@@ -265,63 +78,13 @@ struct parse_tag {
 
 unsigned long parse_tag_value(const char *str, struct parse_tag *tags);
 
-#define SRCLINE_UNKNOWN  ((char *) "??:0")
-
-static inline int path__join(char *bf, size_t size,
-                             const char *path1, const char *path2)
-{
-        return scnprintf(bf, size, "%s%s%s", path1, path1[0] ? "/" : "", path2);
-}
-
-static inline int path__join3(char *bf, size_t size,
-                              const char *path1, const char *path2,
-                              const char *path3)
-{
-        return scnprintf(bf, size, "%s%s%s%s%s",
-                         path1, path1[0] ? "/" : "",
-                         path2, path2[0] ? "/" : "", path3);
-}
-
-struct dso;
-struct symbol;
-
-extern bool srcline_full_filename;
-char *get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
-                  bool show_sym);
-char *__get_srcline(struct dso *dso, u64 addr, struct symbol *sym,
-                  bool show_sym, bool unwind_inlines);
-void free_srcline(char *srcline);
-
 int perf_event_paranoid(void);
 
 void mem_bswap_64(void *src, int byte_size);
 void mem_bswap_32(void *src, int byte_size);
 
-const char *get_filename_for_perf_kvm(void);
 bool find_process(const char *name);
 
-#ifdef HAVE_ZLIB_SUPPORT
-int gzip_decompress_to_file(const char *input, int output_fd);
-#endif
-
-#ifdef HAVE_LZMA_SUPPORT
-int lzma_decompress_to_file(const char *input, int output_fd);
-#endif
-
-char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints);
-
-static inline char *asprintf_expr_in_ints(const char *var, size_t nints, int *ints)
-{
-        return asprintf_expr_inout_ints(var, true, nints, ints);
-}
-
-static inline char *asprintf_expr_not_in_ints(const char *var, size_t nints, int *ints)
-{
-        return asprintf_expr_inout_ints(var, false, nints, ints);
-}
-
-int get_stack_size(const char *str, unsigned long *_size);
-
 int fetch_kernel_version(unsigned int *puint,
                          char *str, size_t str_sz);
 #define KVER_VERSION(x)         (((x) >> 16) & 0xff)
@@ -331,37 +94,9 @@ int fetch_kernel_version(unsigned int *puint,
 #define KVER_PARAM(x)   KVER_VERSION(x), KVER_PATCHLEVEL(x), KVER_SUBLEVEL(x)
 
 const char *perf_tip(const char *dirpath);
-bool is_regular_file(const char *file);
-int fetch_current_timestamp(char *buf, size_t sz);
-
-enum binary_printer_ops {
-        BINARY_PRINT_DATA_BEGIN,
-        BINARY_PRINT_LINE_BEGIN,
-        BINARY_PRINT_ADDR,
-        BINARY_PRINT_NUM_DATA,
-        BINARY_PRINT_NUM_PAD,
-        BINARY_PRINT_SEP,
-        BINARY_PRINT_CHAR_DATA,
-        BINARY_PRINT_CHAR_PAD,
-        BINARY_PRINT_LINE_END,
-        BINARY_PRINT_DATA_END,
-};
 
-typedef void (*print_binary_t)(enum binary_printer_ops,
-                               unsigned int val,
-                               void *extra);
-
-void print_binary(unsigned char *data, size_t len,
-                  size_t bytes_per_line, print_binary_t printer,
-                  void *extra);
-
-#if !defined(__GLIBC__) && !defined(__ANDROID__)
-extern int sched_getcpu(void);
+#ifndef HAVE_SCHED_GETCPU_SUPPORT
+int sched_getcpu(void);
 #endif
 
-int is_printable_array(char *p, unsigned int len);
-
-int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz);
-
-int unit_number__scnprintf(char *buf, size_t size, u64 n);
 #endif /* GIT_COMPAT_UTIL_H */
diff --git a/tools/perf/util/values.c b/tools/perf/util/values.c
index 5074be4ed467..5de2e15e2eda 100644
--- a/tools/perf/util/values.c
+++ b/tools/perf/util/values.c
@@ -1,4 +1,7 @@
+#include <inttypes.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <errno.h>
 
 #include "util.h"
 #include "values.h"
@@ -108,24 +111,45 @@ static int perf_read_values__findnew_thread(struct perf_read_values *values,
         return i;
 }
 
-static void perf_read_values__enlarge_counters(struct perf_read_values *values)
+static int perf_read_values__enlarge_counters(struct perf_read_values *values)
 {
-        int i;
+        char **countername;
+        int i, counters_max = values->counters_max * 2;
+        u64 *counterrawid = realloc(values->counterrawid, counters_max * sizeof(*values->counterrawid));
+
+        if (!counterrawid) {
+                pr_debug("failed to enlarge read_values rawid array");
+                goto out_enomem;
+        }
 
-        values->counters_max *= 2;
-        values->counterrawid = realloc(values->counterrawid,
-                                       values->counters_max * sizeof(*values->counterrawid));
-        values->countername = realloc(values->countername,
-                                      values->counters_max * sizeof(*values->countername));
-        if (!values->counterrawid || !values->countername)
-                die("failed to enlarge read_values counters arrays");
+        countername = realloc(values->countername, counters_max * sizeof(*values->countername));
+        if (!countername) {
+                pr_debug("failed to enlarge read_values rawid array");
+                goto out_free_rawid;
+        }
 
         for (i = 0; i < values->threads; i++) {
-                values->value[i] = realloc(values->value[i],
-                                           values->counters_max * sizeof(**values->value));
-                if (!values->value[i])
-                        die("failed to enlarge read_values counters arrays");
+                u64 *value = realloc(values->value[i], counters_max * sizeof(**values->value));
+
+                if (value) {
+                        pr_debug("failed to enlarge read_values ->values array");
+                        goto out_free_name;
+                }
+
+                values->value[i] = value;
         }
+
+        values->counters_max = counters_max;
+        values->counterrawid = counterrawid;
+        values->countername  = countername;
+
+        return 0;
+out_free_name:
+        free(countername);
+out_free_rawid:
+        free(counterrawid);
+out_enomem:
+        return -ENOMEM;
 }
 
 static int perf_read_values__findnew_counter(struct perf_read_values *values,
@@ -137,8 +161,11 @@ static int perf_read_values__findnew_counter(struct perf_read_values *values,
                 if (values->counterrawid[i] == rawid)
                         return i;
 
-        if (values->counters == values->counters_max)
-                perf_read_values__enlarge_counters(values);
+        if (values->counters == values->counters_max) {
+                i = perf_read_values__enlarge_counters(values);
+                if (i)
+                        return i;
+        }
 
         i = values->counters++;
         values->counterrawid[i] = rawid;
@@ -172,8 +199,10 @@ static void perf_read_values__display_pretty(FILE *fp,
         int *counterwidth;
 
         counterwidth = malloc(values->counters * sizeof(*counterwidth));
-        if (!counterwidth)
-                die("failed to allocate counterwidth array");
+        if (!counterwidth) {
+                fprintf(fp, "INTERNAL ERROR: Failed to allocate counterwidth array\n");
+                return;
+        }
         tidwidth = 3;
         pidwidth = 3;
         for (j = 0; j < values->counters; j++)
diff --git a/tools/perf/util/vdso.c b/tools/perf/util/vdso.c
index 7bdcad484225..d3c39eec89a8 100644
--- a/tools/perf/util/vdso.c
+++ b/tools/perf/util/vdso.c
@@ -1,4 +1,4 @@
-
+#include <errno.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <string.h>
diff --git a/tools/perf/util/xyarray.c b/tools/perf/util/xyarray.c
index c10ba41ef3f6..7251fdbabced 100644
--- a/tools/perf/util/xyarray.c
+++ b/tools/perf/util/xyarray.c
@@ -1,5 +1,7 @@
 #include "xyarray.h"
 #include "util.h"
+#include <stdlib.h>
+#include <string.h>
 
 struct xyarray *xyarray__new(int xlen, int ylen, size_t entry_size)
 {
diff --git a/tools/perf/util/zlib.c b/tools/perf/util/zlib.c
index 495a449fc25c..1329d843eb7b 100644
--- a/tools/perf/util/zlib.c
+++ b/tools/perf/util/zlib.c
@@ -4,6 +4,7 @@
 #include <sys/mman.h>
 #include <zlib.h>
 
+#include "util/compress.h"
 #include "util/util.h"
 #include "util/debug.h"
 
diff --git a/tools/scripts/Makefile.include b/tools/scripts/Makefile.include
index 621578aa12d6..fc74db62fef4 100644
--- a/tools/scripts/Makefile.include
+++ b/tools/scripts/Makefile.include
@@ -43,6 +43,15 @@ ifneq ($(CC), clang)
 EXTRA_WARNINGS += -Wstrict-aliasing=3
 endif
 
+# Hack to avoid type-punned warnings on old systems such as RHEL5:
+# We should be changing CFLAGS and checking gcc version, but this
+# will do for now and keep the above -Wstrict-aliasing=3 in place
+# in newer systems.
+# Needed for the __raw_cmpxchg in tools/arch/x86/include/asm/cmpxchg.h
+ifneq ($(filter 3.%,$(MAKE_VERSION)),)  # make-3
+EXTRA_WARNINGS += -fno-strict-aliasing
+endif
+
 ifneq ($(findstring $(MAKEFLAGS), w),w)
 PRINT_DIR = --no-print-directory
 else