Sync to mainline for security submaintainers to work against

455 files changed, 19491 insertions, 2376 deletions

diff --git a/tools/Makefile b/tools/Makefile
index 00caacd3ed92..c8a90d01dd8e 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -86,10 +86,13 @@ tmon: FORCE
 freefall: FORCE
         $(call descend,laptop/$@)
 
+kvm_stat: FORCE
+        $(call descend,kvm/$@)
+
 all: acpi cgroup cpupower gpio hv firewire lguest \
                 perf selftests turbostat usb \
                 virtio vm net x86_energy_perf_policy \
-                tmon freefall objtool
+                tmon freefall objtool kvm_stat
 
 acpi_install:
         $(call descend,power/$(@:_install=),install)
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/s390/include/uapi/asm/kvm.h b/tools/arch/s390/include/uapi/asm/kvm.h
index a2ffec4139ad..7f4fd65e9208 100644
--- a/tools/arch/s390/include/uapi/asm/kvm.h
+++ b/tools/arch/s390/include/uapi/asm/kvm.h
@@ -131,7 +131,8 @@ struct kvm_s390_vm_cpu_subfunc {
         __u8 kmo[16];           /* with MSA4 */
         __u8 pcc[16];           /* with MSA4 */
         __u8 ppno[16];          /* with MSA5 */
-        __u8 reserved[1824];
+        __u8 kma[16];           /* with MSA8 */
+        __u8 reserved[1808];
 };
 
 /* kvm attributes for crypto */
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-bpf.c b/tools/build/feature/test-bpf.c
index e04ab89a1013..7598361ef1f1 100644
--- a/tools/build/feature/test-bpf.c
+++ b/tools/build/feature/test-bpf.c
@@ -9,6 +9,9 @@
 #  define __NR_bpf 321
 # elif defined(__aarch64__)
 #  define __NR_bpf 280
+# elif defined(__sparc__)
+#  define __NR_bpf 349
+# else
 #  error __NR_bpf not defined. libbpf does not support your arch.
 # endif
 #endif
@@ -26,6 +29,7 @@ int main(void)
         attr.log_size = 0;
         attr.log_level = 0;
         attr.kern_version = 0;
+        attr.prog_flags = 0;
 
         /*
          * Test existence of __NR_bpf and BPF_PROG_LOAD.
diff --git a/tools/build/feature/test-sched_getcpu.c b/tools/build/feature/test-sched_getcpu.c
new file mode 100644
index 000000000000..9c6b4cbffb1c
--- /dev/null
+++ b/tools/build/feature/test-sched_getcpu.c
@@ -0,0 +1,9 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <sched.h>
+
+int main(void)
+{
+        return sched_getcpu();
+}
diff --git a/tools/hv/bondvf.sh b/tools/hv/bondvf.sh
index 4aa5369ffa4e..d85968cb1bf2 100755
--- a/tools/hv/bondvf.sh
+++ b/tools/hv/bondvf.sh
@@ -101,9 +101,25 @@ function create_bond_cfg_redhat {
         echo BONDING_OPTS=\"mode=active-backup miimon=100 primary=$2\" >>$fn
 }
 
+function del_eth_cfg_ubuntu {
+        local fn=$cfgdir/interfaces
+        local tmpfl=$(mktemp)
+
+        local nic_start='^[ \t]*(auto|iface|mapping|allow-.*)[ \t]+'$1
+        local nic_end='^[ \t]*(auto|iface|mapping|allow-.*|source)'
+
+        awk "/$nic_end/{x=0} x{next} /$nic_start/{x=1;next} 1"  $fn >$tmpfl
+
+        cp $tmpfl $fn
+
+        rm $tmpfl
+}
+
 function create_eth_cfg_ubuntu {
         local fn=$cfgdir/interfaces
 
+        del_eth_cfg_ubuntu $1
+
         echo $'\n'auto $1 >>$fn
         echo iface $1 inet manual >>$fn
         echo bond-master $2 >>$fn
@@ -119,6 +135,8 @@ function create_eth_cfg_pri_ubuntu {
 function create_bond_cfg_ubuntu {
         local fn=$cfgdir/interfaces
 
+        del_eth_cfg_ubuntu $1
+
         echo $'\n'auto $1 >>$fn
         echo iface $1 inet dhcp >>$fn
         echo bond-mode active-backup >>$fn
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/filter.h b/tools/include/linux/filter.h
index 122153b16ea4..390d7c9685fd 100644
--- a/tools/include/linux/filter.h
+++ b/tools/include/linux/filter.h
@@ -168,6 +168,16 @@
                 .off   = OFF,                                   \
                 .imm   = 0 })
 
+/* Atomic memory add, *(uint *)(dst_reg + off16) += src_reg */
+
+#define BPF_STX_XADD(SIZE, DST, SRC, OFF)                       \
+        ((struct bpf_insn) {                                    \
+                .code  = BPF_STX | BPF_SIZE(SIZE) | BPF_XADD,   \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = 0 })
+
 /* Memory store, *(uint *) (dst_reg + off16) = imm32 */
 
 #define BPF_ST_MEM(SIZE, DST, OFF, IMM)                         \
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/string.h b/tools/include/linux/string.h
index f436d2420a18..d62b56cf8c12 100644
--- a/tools/include/linux/string.h
+++ b/tools/include/linux/string.h
@@ -18,4 +18,6 @@ extern size_t strlcpy(char *dest, const char *src, size_t size);
 
 char *str_error_r(int errnum, char *buf, size_t buflen);
 
+int prefixcmp(const char *str, const char *prefix);
+
 #endif /* _LINUX_STRING_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/bpf.h b/tools/include/uapi/linux/bpf.h
index 0539a0ceef38..94dfa9def355 100644
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -81,6 +81,7 @@ enum bpf_cmd {
         BPF_OBJ_GET,
         BPF_PROG_ATTACH,
         BPF_PROG_DETACH,
+        BPF_PROG_TEST_RUN,
 };
 
 enum bpf_map_type {
@@ -96,6 +97,8 @@ enum bpf_map_type {
         BPF_MAP_TYPE_LRU_HASH,
         BPF_MAP_TYPE_LRU_PERCPU_HASH,
         BPF_MAP_TYPE_LPM_TRIE,
+        BPF_MAP_TYPE_ARRAY_OF_MAPS,
+        BPF_MAP_TYPE_HASH_OF_MAPS,
 };
 
 enum bpf_prog_type {
@@ -129,6 +132,13 @@ enum bpf_attach_type {
  */
 #define BPF_F_ALLOW_OVERRIDE    (1U << 0)
 
+/* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the
+ * verifier will perform strict alignment checking as if the kernel
+ * has been built with CONFIG_EFFICIENT_UNALIGNED_ACCESS not set,
+ * and NET_IP_ALIGN defined to 2.
+ */
+#define BPF_F_STRICT_ALIGNMENT  (1U << 0)
+
 #define BPF_PSEUDO_MAP_FD       1
 
 /* flags for BPF_MAP_UPDATE_ELEM command */
@@ -152,6 +162,7 @@ union bpf_attr {
                 __u32   value_size;     /* size of value in bytes */
                 __u32   max_entries;    /* max number of entries in a map */
                 __u32   map_flags;      /* prealloc or not */
+                __u32   inner_map_fd;   /* fd pointing to the inner map */
         };
 
         struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
@@ -173,6 +184,7 @@ union bpf_attr {
                 __u32           log_size;       /* size of user buffer */
                 __aligned_u64   log_buf;        /* user supplied buffer */
                 __u32           kern_version;   /* checked when prog_type=kprobe */
+                __u32           prog_flags;
         };
 
         struct { /* anonymous struct used by BPF_OBJ_* commands */
@@ -186,6 +198,17 @@ union bpf_attr {
                 __u32           attach_type;
                 __u32           attach_flags;
         };
+
+        struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */
+                __u32           prog_fd;
+                __u32           retval;
+                __u32           data_size_in;
+                __u32           data_size_out;
+                __aligned_u64   data_in;
+                __aligned_u64   data_out;
+                __u32           repeat;
+                __u32           duration;
+        } test;
 } __attribute__((aligned(8)));
 
 /* BPF helper function descriptions:
@@ -456,6 +479,17 @@ union bpf_attr {
  *     Return:
  *       > 0 length of the string including the trailing NUL on success
  *       < 0 error
+ *
+ * u64 bpf_get_socket_cookie(skb)
+ *     Get the cookie for the socket stored inside sk_buff.
+ *     @skb: pointer to skb
+ *     Return: 8 Bytes non-decreasing number on success or 0 if the socket
+ *     field is missing inside sk_buff
+ *
+ * u32 bpf_get_socket_uid(skb)
+ *     Get the owner uid of the socket stored inside sk_buff.
+ *     @skb: pointer to skb
+ *     Return: uid of the socket owner on success or overflowuid if failed.
  */
 #define __BPF_FUNC_MAPPER(FN)           \
         FN(unspec),                     \
@@ -503,7 +537,9 @@ union bpf_attr {
         FN(get_numa_node_id),           \
         FN(skb_change_head),            \
         FN(xdp_adjust_head),            \
-        FN(probe_read_str),
+        FN(probe_read_str),             \
+        FN(get_socket_cookie),          \
+        FN(get_socket_uid),
 
 /* integer value in 'imm' field of BPF_CALL instruction selects which helper
  * function eBPF program intends to call
@@ -574,6 +610,7 @@ struct __sk_buff {
         __u32 tc_classid;
         __u32 data;
         __u32 data_end;
+        __u32 napi_id;
 };
 
 struct bpf_tunnel_key {
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..b1c0b187acfe 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,12 +915,14 @@ 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)
 #define PERF_FLAG_PID_CGROUP            (1UL << 2) /* pid=cgroup id, per-cpu mode only */
 #define PERF_FLAG_FD_CLOEXEC            (1UL << 3) /* O_CLOEXEC */
 
+#if defined(__LITTLE_ENDIAN_BITFIELD)
 union perf_mem_data_src {
         __u64 val;
         struct {
@@ -902,6 +934,21 @@ union perf_mem_data_src {
                         mem_rsvd:31;
         };
 };
+#elif defined(__BIG_ENDIAN_BITFIELD)
+union perf_mem_data_src {
+        __u64 val;
+        struct {
+                __u64   mem_rsvd:31,
+                        mem_dtlb:7,     /* tlb access */
+                        mem_lock:2,     /* lock instr */
+                        mem_snoop:5,    /* snoop mode */
+                        mem_lvl:14,     /* memory hierarchy level */
+                        mem_op:5;       /* type of opcode */
+        };
+};
+#else
+#error "Unknown endianness"
+#endif
 
 /* type of opcode (load/store/prefetch,code) */
 #define PERF_MEM_OP_NA          0x01 /* not available */
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/kvm/kvm_stat/kvm_stat b/tools/kvm/kvm_stat/kvm_stat
index 581278c58488..8f74ed8e7237 100755
--- a/tools/kvm/kvm_stat/kvm_stat
+++ b/tools/kvm/kvm_stat/kvm_stat
@@ -30,8 +30,8 @@ import fcntl
 import resource
 import struct
 import re
+import subprocess
 from collections import defaultdict
-from time import sleep
 
 VMX_EXIT_REASONS = {
     'EXCEPTION_NMI':        0,
@@ -225,6 +225,7 @@ IOCTL_NUMBERS = {
     'RESET':       0x00002403,
 }
 
+
 class Arch(object):
     """Encapsulates global architecture specific data.
 
@@ -255,12 +256,14 @@ class Arch(object):
                     return ArchX86(SVM_EXIT_REASONS)
                 return
 
+
 class ArchX86(Arch):
     def __init__(self, exit_reasons):
         self.sc_perf_evt_open = 298
         self.ioctl_numbers = IOCTL_NUMBERS
         self.exit_reasons = exit_reasons
 
+
 class ArchPPC(Arch):
     def __init__(self):
         self.sc_perf_evt_open = 319
@@ -275,12 +278,14 @@ class ArchPPC(Arch):
         self.ioctl_numbers['SET_FILTER'] = 0x80002406 | char_ptr_size << 16
         self.exit_reasons = {}
 
+
 class ArchA64(Arch):
     def __init__(self):
         self.sc_perf_evt_open = 241
         self.ioctl_numbers = IOCTL_NUMBERS
         self.exit_reasons = AARCH64_EXIT_REASONS
 
+
 class ArchS390(Arch):
     def __init__(self):
         self.sc_perf_evt_open = 331
@@ -316,6 +321,61 @@ def parse_int_list(list_string):
     return integers
 
 
+def get_pid_from_gname(gname):
+    """Fuzzy function to convert guest name to QEMU process pid.
+
+    Returns a list of potential pids, can be empty if no match found.
+    Throws an exception on processing errors.
+
+    """
+    pids = []
+    try:
+        child = subprocess.Popen(['ps', '-A', '--format', 'pid,args'],
+                                 stdout=subprocess.PIPE)
+    except:
+        raise Exception
+    for line in child.stdout:
+        line = line.lstrip().split(' ', 1)
+        # perform a sanity check before calling the more expensive
+        # function to possibly extract the guest name
+        if ' -name ' in line[1] and gname == get_gname_from_pid(line[0]):
+            pids.append(int(line[0]))
+    child.stdout.close()
+
+    return pids
+
+
+def get_gname_from_pid(pid):
+    """Returns the guest name for a QEMU process pid.
+
+    Extracts the guest name from the QEMU comma line by processing the '-name'
+    option. Will also handle names specified out of sequence.
+
+    """
+    name = ''
+    try:
+        line = open('/proc/{}/cmdline'.format(pid), 'rb').read().split('\0')
+        parms = line[line.index('-name') + 1].split(',')
+        while '' in parms:
+            # commas are escaped (i.e. ',,'), hence e.g. 'foo,bar' results in
+            # ['foo', '', 'bar'], which we revert here
+            idx = parms.index('')
+            parms[idx - 1] += ',' + parms[idx + 1]
+            del parms[idx:idx+2]
+        # the '-name' switch allows for two ways to specify the guest name,
+        # where the plain name overrides the name specified via 'guest='
+        for arg in parms:
+            if '=' not in arg:
+                name = arg
+                break
+            if arg[:6] == 'guest=':
+                name = arg[6:]
+    except (ValueError, IOError, IndexError):
+        pass
+
+    return name
+
+
 def get_online_cpus():
     """Returns a list of cpu id integers."""
     with open('/sys/devices/system/cpu/online') as cpu_list:
@@ -342,6 +402,7 @@ def get_filters():
 libc = ctypes.CDLL('libc.so.6', use_errno=True)
 syscall = libc.syscall
 
+
 class perf_event_attr(ctypes.Structure):
     """Struct that holds the necessary data to set up a trace event.
 
@@ -370,6 +431,7 @@ class perf_event_attr(ctypes.Structure):
         self.size = ctypes.sizeof(self)
         self.read_format = PERF_FORMAT_GROUP
 
+
 def perf_event_open(attr, pid, cpu, group_fd, flags):
     """Wrapper for the sys_perf_evt_open() syscall.
 
@@ -395,6 +457,7 @@ PERF_FORMAT_GROUP = 1 << 3
 PATH_DEBUGFS_TRACING = '/sys/kernel/debug/tracing'
 PATH_DEBUGFS_KVM = '/sys/kernel/debug/kvm'
 
+
 class Group(object):
     """Represents a perf event group."""
 
@@ -427,6 +490,7 @@ class Group(object):
                         struct.unpack(read_format,
                                       os.read(self.events[0].fd, length))))
 
+
 class Event(object):
     """Represents a performance event and manages its life cycle."""
     def __init__(self, name, group, trace_cpu, trace_pid, trace_point,
@@ -510,6 +574,7 @@ class Event(object):
         """Resets the count of the trace event in the kernel."""
         fcntl.ioctl(self.fd, ARCH.ioctl_numbers['RESET'], 0)
 
+
 class TracepointProvider(object):
     """Data provider for the stats class.
 
@@ -551,6 +616,7 @@ class TracepointProvider(object):
     def setup_traces(self):
         """Creates all event and group objects needed to be able to retrieve
         data."""
+        fields = self.get_available_fields()
         if self._pid > 0:
             # Fetch list of all threads of the monitored pid, as qemu
             # starts a thread for each vcpu.
@@ -561,7 +627,7 @@ class TracepointProvider(object):
 
         # The constant is needed as a buffer for python libs, std
         # streams and other files that the script opens.
-        newlim = len(groupids) * len(self._fields) + 50
+        newlim = len(groupids) * len(fields) + 50
         try:
             softlim_, hardlim = resource.getrlimit(resource.RLIMIT_NOFILE)
 
@@ -577,7 +643,7 @@ class TracepointProvider(object):
 
         for groupid in groupids:
             group = Group()
-            for name in self._fields:
+            for name in fields:
                 tracepoint = name
                 tracefilter = None
                 match = re.match(r'(.*)\((.*)\)', name)
@@ -650,13 +716,23 @@ class TracepointProvider(object):
                     ret[name] += val
         return ret
 
+    def reset(self):
+        """Reset all field counters"""
+        for group in self.group_leaders:
+            for event in group.events:
+                event.reset()
+
+
 class DebugfsProvider(object):
     """Provides data from the files that KVM creates in the kvm debugfs
     folder."""
     def __init__(self):
         self._fields = self.get_available_fields()
+        self._baseline = {}
         self._pid = 0
         self.do_read = True
+        self.paths = []
+        self.reset()
 
     def get_available_fields(self):
         """"Returns a list of available fields.
@@ -673,6 +749,7 @@ class DebugfsProvider(object):
     @fields.setter
     def fields(self, fields):
         self._fields = fields
+        self.reset()
 
     @property
     def pid(self):
@@ -690,10 +767,11 @@ class DebugfsProvider(object):
             self.paths = filter(lambda x: "{}-".format(pid) in x, vms)
 
         else:
-            self.paths = ['']
+            self.paths = []
             self.do_read = True
+        self.reset()
 
-    def read(self):
+    def read(self, reset=0):
         """Returns a dict with format:'file name / field -> current value'."""
         results = {}
 
@@ -701,10 +779,22 @@ class DebugfsProvider(object):
         if not self.do_read:
             return results
 
-        for path in self.paths:
+        paths = self.paths
+        if self._pid == 0:
+            paths = []
+            for entry in os.walk(PATH_DEBUGFS_KVM):
+                for dir in entry[1]:
+                    paths.append(dir)
+        for path in paths:
             for field in self._fields:
-                results[field] = results.get(field, 0) \
-                                 + self.read_field(field, path)
+                value = self.read_field(field, path)
+                key = path + field
+                if reset:
+                    self._baseline[key] = value
+                if self._baseline.get(key, -1) == -1:
+                    self._baseline[key] = value
+                results[field] = (results.get(field, 0) + value -
+                                  self._baseline.get(key, 0))
 
         return results
 
@@ -718,6 +808,12 @@ class DebugfsProvider(object):
         except IOError:
             return 0
 
+    def reset(self):
+        """Reset field counters"""
+        self._baseline = {}
+        self.read(1)
+
+
 class Stats(object):
     """Manages the data providers and the data they provide.
 
@@ -753,14 +849,20 @@ class Stats(object):
         for provider in self.providers:
             provider.pid = self._pid_filter
 
+    def reset(self):
+        self.values = {}
+        for provider in self.providers:
+            provider.reset()
+
     @property
     def fields_filter(self):
         return self._fields_filter
 
     @fields_filter.setter
     def fields_filter(self, fields_filter):
-        self._fields_filter = fields_filter
-        self.update_provider_filters()
+        if fields_filter != self._fields_filter:
+            self._fields_filter = fields_filter
+            self.update_provider_filters()
 
     @property
     def pid_filter(self):
@@ -768,9 +870,10 @@ class Stats(object):
 
     @pid_filter.setter
     def pid_filter(self, pid):
-        self._pid_filter = pid
-        self.values = {}
-        self.update_provider_pid()
+        if pid != self._pid_filter:
+            self._pid_filter = pid
+            self.values = {}
+            self.update_provider_pid()
 
     def get(self):
         """Returns a dict with field -> (value, delta to last value) of all
@@ -778,23 +881,26 @@ class Stats(object):
         for provider in self.providers:
             new = provider.read()
             for key in provider.fields:
-                oldval = self.values.get(key, (0, 0))
+                oldval = self.values.get(key, (0, 0))[0]
                 newval = new.get(key, 0)
-                newdelta = None
-                if oldval is not None:
-                    newdelta = newval - oldval[0]
+                newdelta = newval - oldval
                 self.values[key] = (newval, newdelta)
         return self.values
 
 LABEL_WIDTH = 40
 NUMBER_WIDTH = 10
+DELAY_INITIAL = 0.25
+DELAY_REGULAR = 3.0
+MAX_GUEST_NAME_LEN = 48
+MAX_REGEX_LEN = 44
+DEFAULT_REGEX = r'^[^\(]*$'
+
 
 class Tui(object):
     """Instruments curses to draw a nice text ui."""
     def __init__(self, stats):
         self.stats = stats
         self.screen = None
-        self.drilldown = False
         self.update_drilldown()
 
     def __enter__(self):
@@ -809,7 +915,14 @@ class Tui(object):
         # return from C start_color() is ignorable.
         try:
             curses.start_color()
-        except:
+        except curses.error:
+            pass
+
+        # Hide cursor in extra statement as some monochrome terminals
+        # might support hiding but not colors.
+        try:
+            curses.curs_set(0)
+        except curses.error:
             pass
 
         curses.use_default_colors()
@@ -827,36 +940,60 @@ class Tui(object):
     def update_drilldown(self):
         """Sets or removes a filter that only allows fields without braces."""
         if not self.stats.fields_filter:
-            self.stats.fields_filter = r'^[^\(]*$'
+            self.stats.fields_filter = DEFAULT_REGEX
 
-        elif self.stats.fields_filter == r'^[^\(]*$':
+        elif self.stats.fields_filter == DEFAULT_REGEX:
             self.stats.fields_filter = None
 
     def update_pid(self, pid):
         """Propagates pid selection to stats object."""
         self.stats.pid_filter = pid
 
-    def refresh(self, sleeptime):
-        """Refreshes on-screen data."""
+    def refresh_header(self, pid=None):
+        """Refreshes the header."""
+        if pid is None:
+            pid = self.stats.pid_filter
         self.screen.erase()
-        if self.stats.pid_filter > 0:
-            self.screen.addstr(0, 0, 'kvm statistics - pid {0}'
-                               .format(self.stats.pid_filter),
-                               curses.A_BOLD)
+        gname = get_gname_from_pid(pid)
+        if gname:
+            gname = ('({})'.format(gname[:MAX_GUEST_NAME_LEN] + '...'
+                                   if len(gname) > MAX_GUEST_NAME_LEN
+                                   else gname))
+        if pid > 0:
+            self.screen.addstr(0, 0, 'kvm statistics - pid {0} {1}'
+                               .format(pid, gname), curses.A_BOLD)
         else:
             self.screen.addstr(0, 0, 'kvm statistics - summary', curses.A_BOLD)
+        if self.stats.fields_filter and self.stats.fields_filter \
+           != DEFAULT_REGEX:
+            regex = self.stats.fields_filter
+            if len(regex) > MAX_REGEX_LEN:
+                regex = regex[:MAX_REGEX_LEN] + '...'
+            self.screen.addstr(1, 17, 'regex filter: {0}'.format(regex))
         self.screen.addstr(2, 1, 'Event')
         self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH -
                            len('Total'), 'Total')
-        self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH + 8 -
+        self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH + 7 -
+                           len('%Total'), '%Total')
+        self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH + 7 + 8 -
                            len('Current'), 'Current')
+        self.screen.addstr(4, 1, 'Collecting data...')
+        self.screen.refresh()
+
+    def refresh_body(self, sleeptime):
         row = 3
+        self.screen.move(row, 0)
+        self.screen.clrtobot()
         stats = self.stats.get()
+
         def sortkey(x):
             if stats[x][1]:
                 return (-stats[x][1], -stats[x][0])
             else:
                 return (0, -stats[x][0])
+        total = 0.
+        for val in stats.values():
+            total += val[0]
         for key in sorted(stats.keys(), key=sortkey):
 
             if row >= self.screen.getmaxyx()[0]:
@@ -869,6 +1006,8 @@ class Tui(object):
             col += LABEL_WIDTH
             self.screen.addstr(row, col, '%10d' % (values[0],))
             col += NUMBER_WIDTH
+            self.screen.addstr(row, col, '%7.1f' % (values[0] * 100 / total,))
+            col += 7
             if values[1] is not None:
                 self.screen.addstr(row, col, '%8d' % (values[1] / sleeptime,))
             row += 1
@@ -893,20 +1032,24 @@ class Tui(object):
             regex = self.screen.getstr()
             curses.noecho()
             if len(regex) == 0:
+                self.stats.fields_filter = DEFAULT_REGEX
+                self.refresh_header()
                 return
             try:
                 re.compile(regex)
                 self.stats.fields_filter = regex
+                self.refresh_header()
                 return
             except re.error:
                 continue
 
-    def show_vm_selection(self):
+    def show_vm_selection_by_pid(self):
         """Draws PID selection mask.
 
         Asks for a pid until a valid pid or 0 has been entered.
 
         """
+        msg = ''
         while True:
             self.screen.erase()
             self.screen.addstr(0, 0,
@@ -915,6 +1058,7 @@ class Tui(object):
             self.screen.addstr(1, 0,
                                'This might limit the shown data to the trace '
                                'statistics.')
+            self.screen.addstr(5, 0, msg)
 
             curses.echo()
             self.screen.addstr(3, 0, "Pid [0 or pid]: ")
@@ -922,60 +1066,128 @@ class Tui(object):
             curses.noecho()
 
             try:
-                pid = int(pid)
-
-                if pid == 0:
-                    self.update_pid(pid)
-                    break
-                else:
-                    if not os.path.isdir(os.path.join('/proc/', str(pid))):
+                if len(pid) > 0:
+                    pid = int(pid)
+                    if pid != 0 and not os.path.isdir(os.path.join('/proc/',
+                                                                   str(pid))):
+                        msg = '"' + str(pid) + '": Not a running process'
                         continue
-                    else:
-                        self.update_pid(pid)
-                        break
+                else:
+                    pid = 0
+                self.refresh_header(pid)
+                self.update_pid(pid)
+                break
 
             except ValueError:
+                msg = '"' + str(pid) + '": Not a valid pid'
                 continue
 
+    def show_vm_selection_by_guest_name(self):
+        """Draws guest selection mask.
+
+        Asks for a guest name until a valid guest name or '' is entered.
+
+        """
+        msg = ''
+        while True:
+            self.screen.erase()
+            self.screen.addstr(0, 0,
+                               'Show statistics for specific guest.',
+                               curses.A_BOLD)
+            self.screen.addstr(1, 0,
+                               'This might limit the shown data to the trace '
+                               'statistics.')
+            self.screen.addstr(5, 0, msg)
+            curses.echo()
+            self.screen.addstr(3, 0, "Guest [ENTER or guest]: ")
+            gname = self.screen.getstr()
+            curses.noecho()
+
+            if not gname:
+                self.refresh_header(0)
+                self.update_pid(0)
+                break
+            else:
+                pids = []
+                try:
+                    pids = get_pid_from_gname(gname)
+                except:
+                    msg = '"' + gname + '": Internal error while searching, ' \
+                          'use pid filter instead'
+                    continue
+                if len(pids) == 0:
+                    msg = '"' + gname + '": Not an active guest'
+                    continue
+                if len(pids) > 1:
+                    msg = '"' + gname + '": Multiple matches found, use pid ' \
+                          'filter instead'
+                    continue
+                self.refresh_header(pids[0])
+                self.update_pid(pids[0])
+                break
+
     def show_stats(self):
         """Refreshes the screen and processes user input."""
-        sleeptime = 0.25
+        sleeptime = DELAY_INITIAL
+        self.refresh_header()
         while True:
-            self.refresh(sleeptime)
+            self.refresh_body(sleeptime)
             curses.halfdelay(int(sleeptime * 10))
-            sleeptime = 3
+            sleeptime = DELAY_REGULAR
             try:
                 char = self.screen.getkey()
                 if char == 'x':
-                    self.drilldown = not self.drilldown
+                    self.refresh_header()
                     self.update_drilldown()
+                    sleeptime = DELAY_INITIAL
                 if char == 'q':
                     break
+                if char == 'c':
+                    self.stats.fields_filter = DEFAULT_REGEX
+                    self.refresh_header(0)
+                    self.update_pid(0)
+                    sleeptime = DELAY_INITIAL
                 if char == 'f':
                     self.show_filter_selection()
+                    sleeptime = DELAY_INITIAL
+                if char == 'g':
+                    self.show_vm_selection_by_guest_name()
+                    sleeptime = DELAY_INITIAL
                 if char == 'p':
-                    self.show_vm_selection()
+                    self.show_vm_selection_by_pid()
+                    sleeptime = DELAY_INITIAL
+                if char == 'r':
+                    self.refresh_header()
+                    self.stats.reset()
+                    sleeptime = DELAY_INITIAL
             except KeyboardInterrupt:
                 break
             except curses.error:
                 continue
 
+
 def batch(stats):
     """Prints statistics in a key, value format."""
-    s = stats.get()
-    time.sleep(1)
-    s = stats.get()
-    for key in sorted(s.keys()):
-        values = s[key]
-        print '%-42s%10d%10d' % (key, values[0], values[1])
+    try:
+        s = stats.get()
+        time.sleep(1)
+        s = stats.get()
+        for key in sorted(s.keys()):
+            values = s[key]
+            print '%-42s%10d%10d' % (key, values[0], values[1])
+    except KeyboardInterrupt:
+        pass
+
 
 def log(stats):
     """Prints statistics as reiterating key block, multiple value blocks."""
     keys = sorted(stats.get().iterkeys())
+
     def banner():
         for k in keys:
             print '%s' % k,
         print
+
     def statline():
         s = stats.get()
         for k in keys:
@@ -984,11 +1196,15 @@ def log(stats):
     line = 0
     banner_repeat = 20
     while True:
-        time.sleep(1)
-        if line % banner_repeat == 0:
-            banner()
-        statline()
-        line += 1
+        try:
+            time.sleep(1)
+            if line % banner_repeat == 0:
+                banner()
+            statline()
+            line += 1
+        except KeyboardInterrupt:
+            break
+
 
 def get_options():
     """Returns processed program arguments."""
@@ -1009,6 +1225,16 @@ Requirements:
   CAP_SYS_ADMIN and perf events are used.
 - CAP_SYS_RESOURCE if the hard limit is not high enough to allow
   the large number of files that are possibly opened.
+
+Interactive Commands:
+   c     clear filter
+   f     filter by regular expression
+   g     filter by guest name
+   p     filter by PID
+   q     quit
+   x     toggle reporting of stats for individual child trace events
+   r     reset stats
+Press any other key to refresh statistics immediately.
 """
 
     class PlainHelpFormatter(optparse.IndentedHelpFormatter):
@@ -1018,6 +1244,22 @@ Requirements:
             else:
                 return ""
 
+    def cb_guest_to_pid(option, opt, val, parser):
+        try:
+            pids = get_pid_from_gname(val)
+        except:
+            raise optparse.OptionValueError('Error while searching for guest '
+                                            '"{}", use "-p" to specify a pid '
+                                            'instead'.format(val))
+        if len(pids) == 0:
+            raise optparse.OptionValueError('No guest by the name "{}" '
+                                            'found'.format(val))
+        if len(pids) > 1:
+            raise optparse.OptionValueError('Multiple processes found (pids: '
+                                            '{}) - use "-p" to specify a pid '
+                                            'instead'.format(" ".join(pids)))
+        parser.values.pid = pids[0]
+
     optparser = optparse.OptionParser(description=description_text,
                                       formatter=PlainHelpFormatter())
     optparser.add_option('-1', '--once', '--batch',
@@ -1051,15 +1293,24 @@ Requirements:
                          help='fields to display (regex)',
                          )
     optparser.add_option('-p', '--pid',
-                        action='store',
-                        default=0,
-                        type=int,
-                        dest='pid',
-                        help='restrict statistics to pid',
-                        )
+                         action='store',
+                         default=0,
+                         type='int',
+                         dest='pid',
+                         help='restrict statistics to pid',
+                         )
+    optparser.add_option('-g', '--guest',
+                         action='callback',
+                         type='string',
+                         dest='pid',
+                         metavar='GUEST',
+                         help='restrict statistics to guest by name',
+                         callback=cb_guest_to_pid,
+                         )
     (options, _) = optparser.parse_args(sys.argv)
     return options
 
+
 def get_providers(options):
     """Returns a list of data providers depending on the passed options."""
     providers = []
@@ -1073,6 +1324,7 @@ def get_providers(options):
 
     return providers
 
+
 def check_access(options):
     """Exits if the current user can't access all needed directories."""
     if not os.path.exists('/sys/kernel/debug'):
@@ -1086,8 +1338,8 @@ def check_access(options):
                          "Also ensure, that the kvm modules are loaded.\n")
         sys.exit(1)
 
-    if not os.path.exists(PATH_DEBUGFS_TRACING) and (options.tracepoints
-                                                     or not options.debugfs):
+    if not os.path.exists(PATH_DEBUGFS_TRACING) and (options.tracepoints or
+                                                     not options.debugfs):
         sys.stderr.write("Please enable CONFIG_TRACING in your kernel "
                          "when using the option -t (default).\n"
                          "If it is enabled, make {0} readable by the "
@@ -1098,10 +1350,11 @@ def check_access(options):
 
         sys.stderr.write("Falling back to debugfs statistics!\n")
         options.debugfs = True
-        sleep(5)
+        time.sleep(5)
 
     return options
 
+
 def main():
     options = get_options()
     options = check_access(options)
diff --git a/tools/kvm/kvm_stat/kvm_stat.txt b/tools/kvm/kvm_stat/kvm_stat.txt
index b92a153d7115..109431bdc63c 100644
--- a/tools/kvm/kvm_stat/kvm_stat.txt
+++ b/tools/kvm/kvm_stat/kvm_stat.txt
@@ -18,11 +18,33 @@ state transitions such as guest mode entry and exit.
 This tool is useful for observing guest behavior from the host perspective.
 Often conclusions about performance or buggy behavior can be drawn from the
 output.
+While running in regular mode, use any of the keys listed in section
+'Interactive Commands' below.
+Use batch and logging modes for scripting purposes.
 
 The set of KVM kernel module trace events may be specific to the kernel version
 or architecture.  It is best to check the KVM kernel module source code for the
 meaning of events.
 
+INTERACTIVE COMMANDS
+--------------------
+[horizontal]
+*c*::   clear filter
+
+*f*::   filter by regular expression
+
+*g*::   filter by guest name
+
+*p*::   filter by PID
+
+*q*::   quit
+
+*r*::   reset stats
+
+*x*::   toggle reporting of stats for child trace events
+
+Press any other key to refresh statistics immediately.
+
 OPTIONS
 -------
 -1::
@@ -46,6 +68,10 @@ OPTIONS
 --pid=<pid>::
         limit statistics to one virtual machine (pid)
 
+-g<guest>::
+--guest=<guest_name>::
+        limit statistics to one virtual machine (guest name)
+
 -f<fields>::
 --fields=<fields>::
         fields to display (regex)
diff --git a/tools/lguest/lguest.c b/tools/lguest/lguest.c
index 5d19fdf80292..897cd6f3f687 100644
--- a/tools/lguest/lguest.c
+++ b/tools/lguest/lguest.c
@@ -3339,7 +3339,7 @@ int main(int argc, char *argv[])
          * simple, single region.
          */
         boot->e820_entries = 1;
-        boot->e820_map[0] = ((struct e820entry) { 0, mem, E820_RAM });
+        boot->e820_table[0] = ((struct e820_entry) { 0, mem, E820_TYPE_RAM });
         /*
          * The boot header contains a command line pointer: we put the command
          * line after the boot header.
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/bpf/bpf.c b/tools/lib/bpf/bpf.c
index 207c2eeddab0..6e178987af8e 100644
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -37,6 +37,8 @@
 #  define __NR_bpf 321
 # elif defined(__aarch64__)
 #  define __NR_bpf 280
+# elif defined(__sparc__)
+#  define __NR_bpf 349
 # else
 #  error __NR_bpf not defined. libbpf does not support your arch.
 # endif
@@ -69,6 +71,23 @@ int bpf_create_map(enum bpf_map_type map_type, int key_size,
         return sys_bpf(BPF_MAP_CREATE, &attr, sizeof(attr));
 }
 
+int bpf_create_map_in_map(enum bpf_map_type map_type, int key_size,
+                          int inner_map_fd, int max_entries, __u32 map_flags)
+{
+        union bpf_attr attr;
+
+        memset(&attr, '\0', sizeof(attr));
+
+        attr.map_type = map_type;
+        attr.key_size = key_size;
+        attr.value_size = 4;
+        attr.inner_map_fd = inner_map_fd;
+        attr.max_entries = max_entries;
+        attr.map_flags = map_flags;
+
+        return sys_bpf(BPF_MAP_CREATE, &attr, sizeof(attr));
+}
+
 int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
                      size_t insns_cnt, const char *license,
                      __u32 kern_version, char *log_buf, size_t log_buf_sz)
@@ -98,6 +117,28 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
         return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
 }
 
+int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
+                       size_t insns_cnt, int strict_alignment,
+                       const char *license, __u32 kern_version,
+                       char *log_buf, size_t log_buf_sz)
+{
+        union bpf_attr attr;
+
+        bzero(&attr, sizeof(attr));
+        attr.prog_type = type;
+        attr.insn_cnt = (__u32)insns_cnt;
+        attr.insns = ptr_to_u64(insns);
+        attr.license = ptr_to_u64(license);
+        attr.log_buf = ptr_to_u64(log_buf);
+        attr.log_size = log_buf_sz;
+        attr.log_level = 2;
+        log_buf[0] = 0;
+        attr.kern_version = kern_version;
+        attr.prog_flags = strict_alignment ? BPF_F_STRICT_ALIGNMENT : 0;
+
+        return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
+}
+
 int bpf_map_update_elem(int fd, const void *key, const void *value,
                         __u64 flags)
 {
@@ -192,3 +233,27 @@ int bpf_prog_detach(int target_fd, enum bpf_attach_type type)
 
         return sys_bpf(BPF_PROG_DETACH, &attr, sizeof(attr));
 }
+
+int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size,
+                      void *data_out, __u32 *size_out, __u32 *retval,
+                      __u32 *duration)
+{
+        union bpf_attr attr;
+        int ret;
+
+        bzero(&attr, sizeof(attr));
+        attr.test.prog_fd = prog_fd;
+        attr.test.data_in = ptr_to_u64(data);
+        attr.test.data_out = ptr_to_u64(data_out);
+        attr.test.data_size_in = size;
+        attr.test.repeat = repeat;
+
+        ret = sys_bpf(BPF_PROG_TEST_RUN, &attr, sizeof(attr));
+        if (size_out)
+                *size_out = attr.test.data_size_out;
+        if (retval)
+                *retval = attr.test.retval;
+        if (duration)
+                *duration = attr.test.duration;
+        return ret;
+}
diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index 09c3dcac0496..972bd8333eb7 100644
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h
@@ -26,6 +26,8 @@
 
 int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,
                    int max_entries, __u32 map_flags);
+int bpf_create_map_in_map(enum bpf_map_type map_type, int key_size,
+                          int inner_map_fd, int max_entries, __u32 map_flags);
 
 /* Recommend log buffer size */
 #define BPF_LOG_BUF_SIZE 65536
@@ -33,6 +35,10 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
                      size_t insns_cnt, const char *license,
                      __u32 kern_version, char *log_buf,
                      size_t log_buf_sz);
+int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
+                       size_t insns_cnt, int strict_alignment,
+                       const char *license, __u32 kern_version,
+                       char *log_buf, size_t log_buf_sz);
 
 int bpf_map_update_elem(int fd, const void *key, const void *value,
                         __u64 flags);
@@ -45,6 +51,8 @@ int bpf_obj_get(const char *pathname);
 int bpf_prog_attach(int prog_fd, int attachable_fd, enum bpf_attach_type type,
                     unsigned int flags);
 int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
-
+int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size,
+                      void *data_out, __u32 *size_out, __u32 *retval,
+                      __u32 *duration);
 
 #endif
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index ac6eb863b2a4..1a2c07eb7795 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -1618,8 +1618,7 @@ int bpf_program__nth_fd(struct bpf_program *prog, int n)
         return fd;
 }
 
-static void bpf_program__set_type(struct bpf_program *prog,
-                                  enum bpf_prog_type type)
+void bpf_program__set_type(struct bpf_program *prog, enum bpf_prog_type type)
 {
         prog->type = type;
 }
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index b30394f9947a..32c7252f734e 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -25,6 +25,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <sys/types.h>  // for size_t
+#include <linux/bpf.h>
 
 enum libbpf_errno {
         __LIBBPF_ERRNO__START = 4000,
@@ -185,6 +186,7 @@ int bpf_program__set_sched_cls(struct bpf_program *prog);
 int bpf_program__set_sched_act(struct bpf_program *prog);
 int bpf_program__set_xdp(struct bpf_program *prog);
 int bpf_program__set_perf_event(struct bpf_program *prog);
+void bpf_program__set_type(struct bpf_program *prog, enum bpf_prog_type type);
 
 bool bpf_program__is_socket_filter(struct bpf_program *prog);
 bool bpf_program__is_tracepoint(struct bpf_program *prog);
diff --git a/tools/lib/string.c b/tools/lib/string.c
index bd239bc1d557..8e678af1c6ee 100644
--- a/tools/lib/string.c
+++ b/tools/lib/string.c
@@ -87,3 +87,12 @@ size_t __weak strlcpy(char *dest, const char *src, size_t size)
         }
         return ret;
 }
+
+int prefixcmp(const char *str, const char *prefix)
+{
+        for (; ; str++, prefix++)
+                if (!*prefix)
+                        return 0;
+                else if (*str != *prefix)
+                        return (unsigned char)*prefix - (unsigned char)*str;
+}
diff --git a/tools/lib/subcmd/help.c b/tools/lib/subcmd/help.c
index e228c3cb3716..ba970a73d053 100644
--- a/tools/lib/subcmd/help.c
+++ b/tools/lib/subcmd/help.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <linux/string.h>
 #include <termios.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
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/subcmd/parse-options.c b/tools/lib/subcmd/parse-options.c
index 6bc24025d054..359bfa77f39c 100644
--- a/tools/lib/subcmd/parse-options.c
+++ b/tools/lib/subcmd/parse-options.c
@@ -1,4 +1,5 @@
 #include <linux/compiler.h>
+#include <linux/string.h>
 #include <linux/types.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/tools/lib/subcmd/subcmd-util.h b/tools/lib/subcmd/subcmd-util.h
index fc2e45d8aaf1..8fa5f036eff0 100644
--- a/tools/lib/subcmd/subcmd-util.h
+++ b/tools/lib/subcmd/subcmd-util.h
@@ -79,13 +79,4 @@ static inline void astrcat(char **out, const char *add)
         free(tmp);
 }
 
-static inline int prefixcmp(const char *str, const char *prefix)
-{
-        for (; ; str++, prefix++)
-                if (!*prefix)
-                        return 0;
-                else if (*str != *prefix)
-                        return (unsigned char)*prefix - (unsigned char)*str;
-}
-
 #endif /* __SUBCMD_UTIL_H */
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/net/bpf_jit_disasm.c b/tools/net/bpf_jit_disasm.c
index 544b05a53b70..ad572e6cdbd0 100644
--- a/tools/net/bpf_jit_disasm.c
+++ b/tools/net/bpf_jit_disasm.c
@@ -229,6 +229,7 @@ static void usage(void)
 {
         printf("Usage: bpf_jit_disasm [...]\n");
         printf("       -o          Also display related opcodes (default: off).\n");
+        printf("       -O <file>   Write binary image of code to file, don't disassemble to stdout.\n");
         printf("       -f <file>   Read last image dump from file or stdin (default: klog).\n");
         printf("       -h          Display this help.\n");
 }
@@ -238,12 +239,19 @@ int main(int argc, char **argv)
         unsigned int len, klen, opt, opcodes = 0;
         static uint8_t image[32768];
         char *kbuff, *file = NULL;
+        char *ofile = NULL;
+        int ofd;
+        ssize_t nr;
+        uint8_t *pos;
 
-        while ((opt = getopt(argc, argv, "of:")) != -1) {
+        while ((opt = getopt(argc, argv, "of:O:")) != -1) {
                 switch (opt) {
                 case 'o':
                         opcodes = 1;
                         break;
+                case 'O':
+                        ofile = optarg;
+                        break;
                 case 'f':
                         file = optarg;
                         break;
@@ -263,11 +271,35 @@ int main(int argc, char **argv)
         }
 
         len = get_last_jit_image(kbuff, klen, image, sizeof(image));
-        if (len > 0)
-                get_asm_insns(image, len, opcodes);
-        else
+        if (len <= 0) {
                 fprintf(stderr, "No JIT image found!\n");
+                goto done;
+        }
+        if (!ofile) {
+                get_asm_insns(image, len, opcodes);
+                goto done;
+        }
+
+        ofd = open(ofile, O_WRONLY | O_CREAT | O_TRUNC, DEFFILEMODE);
+        if (ofd < 0) {
+                fprintf(stderr, "Could not open file %s for writing: ", ofile);
+                perror(NULL);
+                goto done;
+        }
+        pos = image;
+        do {
+                nr = write(ofd, pos, len);
+                if (nr < 0) {
+                        fprintf(stderr, "Could not write data to %s: ", ofile);
+                        perror(NULL);
+                        goto done;
+                }
+                len -= nr;
+                pos += nr;
+        } while (len);
+        close(ofd);
 
+done:
         put_log_buff(kbuff);
         return 0;
 }
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/pci/pcitest.c b/tools/pci/pcitest.c
new file mode 100644
index 000000000000..ad54a58d7dda
--- /dev/null
+++ b/tools/pci/pcitest.c
@@ -0,0 +1,186 @@
+/**
+ * Userspace PCI Endpoint Test Module
+ *
+ * Copyright (C) 2017 Texas Instruments
+ * Author: Kishon Vijay Abraham I <kishon@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 of
+ * the License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <linux/pcitest.h>
+
+#define BILLION 1E9
+
+static char *result[] = { "NOT OKAY", "OKAY" };
+
+struct pci_test {
+        char            *device;
+        char            barnum;
+        bool            legacyirq;
+        unsigned int    msinum;
+        bool            read;
+        bool            write;
+        bool            copy;
+        unsigned long   size;
+};
+
+static int run_test(struct pci_test *test)
+{
+        long ret;
+        int fd;
+        struct timespec start, end;
+        double time;
+
+        fd = open(test->device, O_RDWR);
+        if (fd < 0) {
+                perror("can't open PCI Endpoint Test device");
+                return fd;
+        }
+
+        if (test->barnum >= 0 && test->barnum <= 5) {
+                ret = ioctl(fd, PCITEST_BAR, test->barnum);
+                fprintf(stdout, "BAR%d:\t\t", test->barnum);
+                if (ret < 0)
+                        fprintf(stdout, "TEST FAILED\n");
+                else
+                        fprintf(stdout, "%s\n", result[ret]);
+        }
+
+        if (test->legacyirq) {
+                ret = ioctl(fd, PCITEST_LEGACY_IRQ, 0);
+                fprintf(stdout, "LEGACY IRQ:\t");
+                if (ret < 0)
+                        fprintf(stdout, "TEST FAILED\n");
+                else
+                        fprintf(stdout, "%s\n", result[ret]);
+        }
+
+        if (test->msinum > 0 && test->msinum <= 32) {
+                ret = ioctl(fd, PCITEST_MSI, test->msinum);
+                fprintf(stdout, "MSI%d:\t\t", test->msinum);
+                if (ret < 0)
+                        fprintf(stdout, "TEST FAILED\n");
+                else
+                        fprintf(stdout, "%s\n", result[ret]);
+        }
+
+        if (test->write) {
+                ret = ioctl(fd, PCITEST_WRITE, test->size);
+                fprintf(stdout, "WRITE (%7ld bytes):\t\t", test->size);
+                if (ret < 0)
+                        fprintf(stdout, "TEST FAILED\n");
+                else
+                        fprintf(stdout, "%s\n", result[ret]);
+        }
+
+        if (test->read) {
+                ret = ioctl(fd, PCITEST_READ, test->size);
+                fprintf(stdout, "READ (%7ld bytes):\t\t", test->size);
+                if (ret < 0)
+                        fprintf(stdout, "TEST FAILED\n");
+                else
+                        fprintf(stdout, "%s\n", result[ret]);
+        }
+
+        if (test->copy) {
+                ret = ioctl(fd, PCITEST_COPY, test->size);
+                fprintf(stdout, "COPY (%7ld bytes):\t\t", test->size);
+                if (ret < 0)
+                        fprintf(stdout, "TEST FAILED\n");
+                else
+                        fprintf(stdout, "%s\n", result[ret]);
+        }
+
+        fflush(stdout);
+}
+
+int main(int argc, char **argv)
+{
+        int c;
+        struct pci_test *test;
+
+        test = calloc(1, sizeof(*test));
+        if (!test) {
+                perror("Fail to allocate memory for pci_test\n");
+                return -ENOMEM;
+        }
+
+        /* since '0' is a valid BAR number, initialize it to -1 */
+        test->barnum = -1;
+
+        /* set default size as 100KB */
+        test->size = 0x19000;
+
+        /* set default endpoint device */
+        test->device = "/dev/pci-endpoint-test.0";
+
+        while ((c = getopt(argc, argv, "D:b:m:lrwcs:")) != EOF)
+        switch (c) {
+        case 'D':
+                test->device = optarg;
+                continue;
+        case 'b':
+                test->barnum = atoi(optarg);
+                if (test->barnum < 0 || test->barnum > 5)
+                        goto usage;
+                continue;
+        case 'l':
+                test->legacyirq = true;
+                continue;
+        case 'm':
+                test->msinum = atoi(optarg);
+                if (test->msinum < 1 || test->msinum > 32)
+                        goto usage;
+                continue;
+        case 'r':
+                test->read = true;
+                continue;
+        case 'w':
+                test->write = true;
+                continue;
+        case 'c':
+                test->copy = true;
+                continue;
+        case 's':
+                test->size = strtoul(optarg, NULL, 0);
+                continue;
+        case '?':
+        case 'h':
+        default:
+usage:
+                fprintf(stderr,
+                        "usage: %s [options]\n"
+                        "Options:\n"
+                        "\t-D <dev>             PCI endpoint test device {default: /dev/pci-endpoint-test.0}\n"
+                        "\t-b <bar num>         BAR test (bar number between 0..5)\n"
+                        "\t-m <msi num>         MSI test (msi number between 1..32)\n"
+                        "\t-r                   Read buffer test\n"
+                        "\t-w                   Write buffer test\n"
+                        "\t-c                   Copy buffer test\n"
+                        "\t-s <size>            Size of buffer {default: 100KB}\n",
+                        argv[0]);
+                return -EINVAL;
+        }
+
+        run_test(test);
+        return 0;
+}
diff --git a/tools/pci/pcitest.sh b/tools/pci/pcitest.sh
new file mode 100644
index 000000000000..5442bbea4c22
--- /dev/null
+++ b/tools/pci/pcitest.sh
@@ -0,0 +1,56 @@
+#!/bin/sh
+
+echo "BAR tests"
+echo
+
+bar=0
+
+while [ $bar -lt 6 ]
+do
+        pcitest -b $bar
+        bar=`expr $bar + 1`
+done
+echo
+
+echo "Interrupt tests"
+echo
+
+pcitest -l
+msi=1
+
+while [ $msi -lt 33 ]
+do
+        pcitest -m $msi
+        msi=`expr $msi + 1`
+done
+echo
+
+echo "Read Tests"
+echo
+
+pcitest -r -s 1
+pcitest -r -s 1024
+pcitest -r -s 1025
+pcitest -r -s 1024000
+pcitest -r -s 1024001
+echo
+
+echo "Write Tests"
+echo
+
+pcitest -w -s 1
+pcitest -w -s 1024
+pcitest -w -s 1025
+pcitest -w -s 1024000
+pcitest -w -s 1024001
+echo
+
+echo "Copy Tests"
+echo
+
+pcitest -c -s 1
+pcitest -c -s 1024
+pcitest -c -s 1025
+pcitest -c -s 1024000
+pcitest -c -s 1024001
+echo
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-c2c.txt b/tools/perf/Documentation/perf-c2c.txt
index 2da07e51e119..822414235170 100644
--- a/tools/perf/Documentation/perf-c2c.txt
+++ b/tools/perf/Documentation/perf-c2c.txt
@@ -76,7 +76,7 @@ REPORT OPTIONS
 
 -c::
 --coalesce::
-        Specify sorintg fields for single cacheline display.
+        Specify sorting fields for single cacheline display.
         Following fields are available: tid,pid,iaddr,dso
         (see COALESCE)
 
@@ -106,7 +106,7 @@ REPORT OPTIONS
 
 -d::
 --display::
-        Siwtch to HITM type (rmt, lcl) to display and sort on. Total HITMs as default.
+        Switch to HITM type (rmt, lcl) to display and sort on. Total HITMs as default.
 
 C2C RECORD
 ----------
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..b0e9e921d534 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -225,7 +225,7 @@ OPTIONS
         the libunwind or libdw library) should be used instead.
         Using the "lbr" method doesn't require any compiler options. It
         will produce call graphs from the hardware LBR registers. The
-        main limition is that it is only available on new Intel
+        main limitation is that it is only available on new Intel
         platforms, such as Haswell. It can only get user call chain. It
         doesn't work with branch stack sampling at the same time.
 
@@ -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..9fa84617181e 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,11 +175,14 @@ 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
         function and searched through the callchain, thus it requires callchain
-        information recorded. The pattern is in the exteneded regex format and
+        information recorded. The pattern is in the extended regex format and
         defaults to "\^sys_|^do_page_fault", see '--sort parent'.
 
 -x::
@@ -201,8 +207,8 @@ OPTIONS
 -g::
 --call-graph=<print_type,threshold[,print_limit],order,sort_key[,branch],value>::
         Display call chains using type, min percent threshold, print limit,
-        call order, sort key, optional branch and value.  Note that ordering of
-        parameters is not fixed so any parement can be given in an arbitraty order.
+        call order, sort key, optional branch and value.  Note that ordering
+        is not fixed so any parameter can be given in an arbitrary order.
         One exception is the print_limit which should be preceded by threshold.
 
         print_type can be either:
@@ -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..de8b39dda7b8 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:
 
@@ -270,7 +270,7 @@ When the event stream contains multiple events each event is identified
 by an ID. This can be either through the PERF_SAMPLE_ID or the
 PERF_SAMPLE_IDENTIFIER header. The PERF_SAMPLE_IDENTIFIER header is
 at a fixed offset from the event header, which allows reliable
-parsing of the header. Relying on ID may be ambigious.
+parsing of the header. Relying on ID may be ambiguous.
 IDENTIFIER is only supported by newer Linux kernels.
 
 Perf record specific events:
@@ -288,7 +288,7 @@ struct attr_event {
         uint64_t id[];
 };
 
-        PERF_RECORD_HEADER_EVENT_TYPE           = 65, /* depreceated */
+        PERF_RECORD_HEADER_EVENT_TYPE           = 65, /* deprecated */
 
 #define MAX_EVENT_NAME 64
 
@@ -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/Documentation/tips.txt b/tools/perf/Documentation/tips.txt
index 170b0289a7bc..db0ca3063eae 100644
--- a/tools/perf/Documentation/tips.txt
+++ b/tools/perf/Documentation/tips.txt
@@ -23,7 +23,7 @@ For memory address profiling, try: perf mem record / perf mem report
 For tracepoint events, try: perf report -s trace_fields
 To record callchains for each sample: perf record -g
 To record every process run by a user: perf record -u <user>
-Skip collecing build-id when recording: perf record -B
+Skip collecting build-id when recording: perf record -B
 To change sampling frequency to 100 Hz: perf record -F 100
 See assembly instructions with percentage: perf annotate <symbol>
 If you prefer Intel style assembly, try: perf annotate -M intel
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/annotate/instructions.c b/tools/perf/arch/arm64/annotate/instructions.c
index 44eafd6f2d50..8f1908756cb6 100644
--- a/tools/perf/arch/arm64/annotate/instructions.c
+++ b/tools/perf/arch/arm64/annotate/instructions.c
@@ -50,7 +50,7 @@ static int arm64__annotate_init(struct arch *arch)
         arch->initialized = true;
         arch->priv        = arm;
         arch->associate_instruction_ops   = arm64__associate_instruction_ops;
-        arch->objdump.comment_char        = ';';
+        arch->objdump.comment_char        = '/';
         arch->objdump.skip_functions_char = '+';
         return 0;
 
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..bf9a2594572c 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)
@@ -51,6 +52,18 @@ int arch__compare_symbol_names(const char *namea, const char *nameb)
 
         return strcmp(namea, nameb);
 }
+
+int arch__compare_symbol_names_n(const char *namea, const char *nameb,
+                                 unsigned int n)
+{
+        /* Skip over initial dot */
+        if (*namea == '.')
+                namea++;
+        if (*nameb == '.')
+                nameb++;
+
+        return strncmp(namea, nameb, n);
+}
 #endif
 
 #if defined(_CALL_ELF) && _CALL_ELF == 2
@@ -79,13 +92,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..9eba7f1add1f 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)
 {
@@ -47,19 +49,22 @@ static bool same_kallsyms_reloc(const char *from_dir, char *to_dir)
         char to[PATH_MAX];
         const char *name;
         u64 addr1 = 0, addr2 = 0;
-        int i;
+        int i, err = -1;
 
         scnprintf(from, sizeof(from), "%s/kallsyms", from_dir);
         scnprintf(to, sizeof(to), "%s/kallsyms", to_dir);
 
         for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) {
-                addr1 = kallsyms__get_function_start(from, name);
-                if (addr1)
+                err = kallsyms__get_function_start(from, name, &addr1);
+                if (!err)
                         break;
         }
 
-        if (name)
-                addr2 = kallsyms__get_function_start(to, name);
+        if (err)
+                return false;
+
+        if (kallsyms__get_function_start(to, name, &addr2))
+                return false;
 
         return addr1 == addr2;
 }
@@ -276,8 +281,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..620a467ee304 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"
@@ -24,11 +27,13 @@
 #include "tool.h"
 #include "data.h"
 #include "sort.h"
+#include "event.h"
 #include "evlist.h"
 #include "evsel.h"
 #include <asm/bug.h>
 #include "ui/browsers/hists.h"
 #include "evlist.h"
+#include "thread.h"
 
 struct c2c_hists {
         struct hists            hists;
@@ -2334,7 +2339,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 +2541,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 +2760,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..80668fa7556e 100644
--- a/tools/perf/builtin-config.c
+++ b/tools/perf/builtin-config.c
@@ -154,11 +154,12 @@ 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;
         char *user_config = mkpath("%s/.perfconfig", getenv("HOME"));
+        const char *config_filename;
 
         argc = parse_options(argc, argv, config_options, config_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
@@ -175,6 +176,11 @@ int cmd_config(int argc, const char **argv, const char *prefix __maybe_unused)
         else if (use_user_config)
                 config_exclusive_filename = user_config;
 
+        if (!config_exclusive_filename)
+                config_filename = user_config;
+        else
+                config_filename = config_exclusive_filename;
+
         /*
          * At only 'config' sub-command, individually use the config set
          * because of reinitializing with options config file location.
@@ -192,13 +198,9 @@ int cmd_config(int argc, const char **argv, const char *prefix __maybe_unused)
                         parse_options_usage(config_usage, config_options, "l", 1);
                 } else {
                         ret = show_config(set);
-                        if (ret < 0) {
-                                const char * config_filename = config_exclusive_filename;
-                                if (!config_exclusive_filename)
-                                        config_filename = user_config;
+                        if (ret < 0)
                                 pr_err("Nothing configured, "
                                        "please check your %s \n", config_filename);
-                        }
                 }
                 break;
         default:
@@ -221,13 +223,8 @@ int cmd_config(int argc, const char **argv, const char *prefix __maybe_unused)
 
                                 if (value == NULL)
                                         ret = show_spec_config(set, var);
-                                else {
-                                        const char *config_filename = config_exclusive_filename;
-
-                                        if (!config_exclusive_filename)
-                                                config_filename = user_config;
+                                else
                                         ret = set_config(set, config_filename, var, value);
-                                }
                                 free(arg);
                         }
                 } else
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..cf9f9e9c2fc0 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' ...]",
@@ -486,7 +486,7 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show parsed arguments, etc)"),
         OPT_BOOLEAN('q', "quiet", &params.quiet,
-                    "be quiet (do not show any mesages)"),
+                    "be quiet (do not show any messages)"),
         OPT_CALLBACK_DEFAULT('l', "list", NULL, "[GROUP:]EVENT",
                              "list up probe events",
                              opt_set_filter_with_command, DEFAULT_LIST_FILTER),
@@ -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..10b6362ca0bf 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -27,19 +27,20 @@
 #include "util/drv_configs.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
+#include "util/event.h"
 #include "util/machine.h"
 #include "util/session.h"
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/thread_map.h"
 #include "util/top.h"
-#include "util/util.h"
 #include <linux/rbtree.h>
 #include <subcmd/parse-options.h>
 #include "util/parse-events.h"
 #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..d014350adc52 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -21,9 +21,11 @@
 #include "builtin.h"
 #include "util/color.h"
 #include "util/debug.h"
+#include "util/event.h"
 #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 +33,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 +279,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 +774,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 +828,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 +1044,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 +1075,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 +1480,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 +1527,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 +1575,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 +1604,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 +1620,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 +1685,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 +1705,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 +1724,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 +1746,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 +1757,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 +1887,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 +1956,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 +1964,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 +2025,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 +2452,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 +2823,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..628a5e412cb1 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -17,11 +17,18 @@
 #include <subcmd/parse-options.h>
 #include "util/bpf-loader.h"
 #include "util/debug.h"
+#include "util/event.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 +41,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 +95,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 +274,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 +281,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 +293,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 +334,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 +375,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 +388,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 +481,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 +526,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..d549a9f2c41b 100644
--- a/tools/perf/tests/hists_cumulate.c
+++ b/tools/perf/tests/hists_cumulate.c
@@ -1,5 +1,6 @@
 #include "perf.h"
 #include "util/debug.h"
+#include "util/event.h"
 #include "util/symbol.h"
 #include "util/sort.h"
 #include "util/evsel.h"
@@ -9,6 +10,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..df9c91f49af1 100644
--- a/tools/perf/tests/hists_filter.c
+++ b/tools/perf/tests/hists_filter.c
@@ -3,12 +3,14 @@
 #include "util/symbol.h"
 #include "util/sort.h"
 #include "util/evsel.h"
+#include "util/event.h"
 #include "util/evlist.h"
 #include "util/machine.h"
 #include "util/thread.h"
 #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..06e5080182d3 100644
--- a/tools/perf/tests/hists_output.c
+++ b/tools/perf/tests/hists_output.c
@@ -1,5 +1,6 @@
 #include "perf.h"
 #include "util/debug.h"
+#include "util/event.h"
 #include "util/symbol.h"
 #include "util/sort.h"
 #include "util/evsel.h"
@@ -9,6 +10,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/kmod-path.c b/tools/perf/tests/kmod-path.c
index 76f41f249944..6cd9e5107f77 100644
--- a/tools/perf/tests/kmod-path.c
+++ b/tools/perf/tests/kmod-path.c
@@ -61,6 +61,7 @@ int test__kmod_path__parse(int subtest __maybe_unused)
         M("/xxxx/xxxx/x-x.ko", PERF_RECORD_MISC_KERNEL, true);
         M("/xxxx/xxxx/x-x.ko", PERF_RECORD_MISC_USER, false);
 
+#ifdef HAVE_ZLIB_SUPPORT
         /* path                alloc_name  alloc_ext   kmod  comp  name   ext */
         T("/xxxx/xxxx/x.ko.gz", true     , true      , true, true, "[x]", "gz");
         T("/xxxx/xxxx/x.ko.gz", false    , true      , true, true, NULL , "gz");
@@ -96,6 +97,7 @@ int test__kmod_path__parse(int subtest __maybe_unused)
         M("x.ko.gz", PERF_RECORD_MISC_CPUMODE_UNKNOWN, true);
         M("x.ko.gz", PERF_RECORD_MISC_KERNEL, true);
         M("x.ko.gz", PERF_RECORD_MISC_USER, false);
+#endif
 
         /* path            alloc_name  alloc_ext  kmod  comp   name             ext */
         T("[test_module]", true      , true     , true, false, "[test_module]", NULL);
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..06eda675ae2c 100644
--- a/tools/perf/tests/sdt.c
+++ b/tools/perf/tests/sdt.c
@@ -1,6 +1,6 @@
+#include <errno.h>
 #include <stdio.h>
 #include <sys/epoll.h>
-#include <util/util.h>
 #include <util/evlist.h>
 #include <linux/filter.h>
 #include "tests.h"
@@ -43,7 +43,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..caf1ce6f5152 100644
--- a/tools/perf/ui/setup.c
+++ b/tools/perf/ui/setup.c
@@ -4,12 +4,16 @@
 #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;
 int use_browser = -1;
 
+#define PERF_GTK_DSO "libperf-gtk.so"
+
 #ifdef HAVE_GTK2_SUPPORT
+
 static int setup_gtk_browser(void)
 {
         int (*perf_ui_init)(void);
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..79dea95a7f68 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
@@ -14,9 +13,11 @@ libperf-y += find_bit.o
 libperf-y += kallsyms.o
 libperf-y += levenshtein.o
 libperf-y += llvm-utils.o
+libperf-y += memswap.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 +43,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 +83,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 +145,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 +161,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 273f21fa32b5..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[] = {
         {
@@ -130,6 +137,13 @@ static struct arch architectures[] = {
                 .name = "powerpc",
                 .init = powerpc__annotate_init,
         },
+        {
+                .name = "s390",
+                .init = s390__annotate_init,
+                .objdump =  {
+                        .comment_char = '#',
+                },
+        },
 };
 
 static void ins__delete(struct ins_operands *ops)
@@ -379,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);
 
@@ -426,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;
@@ -777,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;
@@ -798,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;
 
@@ -1148,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];
@@ -1159,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 ':'
@@ -1307,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))
@@ -1322,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:
@@ -1335,6 +1328,7 @@ fallback:
                 __symbol__join_symfs(filename, filename_size, dso->long_name);
         }
 
+        free(build_id_path);
         return 0;
 }
 
@@ -1435,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 : "",
@@ -1482,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;
@@ -1651,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..8a89b195c1fc 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,
@@ -42,6 +44,10 @@ bool build_id_cache__cached(const char *sbuild_id);
 int build_id_cache__add_s(const char *sbuild_id,
                           const char *name, bool is_kallsyms, bool is_vdso);
 int build_id_cache__remove_s(const char *sbuild_id);
+
+extern char buildid_dir[];
+
+void set_buildid_dir(const char *dir);
 void disable_buildid_cache(void);
 
 #endif
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..dc5c3bb69d73 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -1,15 +1,24 @@
+#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 <linux/perf_event.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 +40,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 +59,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 +78,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 +115,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 +142,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 +230,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 +334,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 +513,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 +535,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 +573,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 +606,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 +621,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 +656,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 +665,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 +686,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 +704,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 +726,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:
@@ -659,15 +768,16 @@ static int find_symbol_cb(void *arg, const char *name, char type,
         return 1;
 }
 
-u64 kallsyms__get_function_start(const char *kallsyms_filename,
-                                 const char *symbol_name)
+int kallsyms__get_function_start(const char *kallsyms_filename,
+                                 const char *symbol_name, u64 *addr)
 {
         struct process_symbol_args args = { .name = symbol_name, };
 
         if (kallsyms__parse(kallsyms_filename, &args, find_symbol_cb) <= 0)
-                return 0;
+                return -1;
 
-        return args.start;
+        *addr = args.start;
+        return 0;
 }
 
 int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
@@ -1008,6 +1118,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 +1153,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 +1298,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 +1342,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..7c3fa1c8cbcd 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;
@@ -222,7 +229,7 @@ struct build_id_event {
 enum perf_user_event_type { /* above any possible kernel type */
         PERF_RECORD_USER_TYPE_START             = 64,
         PERF_RECORD_HEADER_ATTR                 = 64,
-        PERF_RECORD_HEADER_EVENT_TYPE           = 65, /* depreceated */
+        PERF_RECORD_HEADER_EVENT_TYPE           = 65, /* deprecated */
         PERF_RECORD_HEADER_TRACING_DATA         = 66,
         PERF_RECORD_HEADER_BUILD_ID             = 67,
         PERF_RECORD_FINISHED_ROUND              = 68,
@@ -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,12 +672,21 @@ 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,
-                                 const char *symbol_name);
+int kallsyms__get_function_start(const char *kallsyms_filename,
+                                 const char *symbol_name, u64 *addr);
 
 void *cpu_map_data__alloc(struct cpu_map *map, size_t *size, u16 *type, int *max);
 void  cpu_map_data__synthesize(struct cpu_map_data *data, struct cpu_map *map,
                                u16 type, int max);
+
+void event_attr_init(struct perf_event_attr *attr);
+
+int perf_event_paranoid(void);
+
+extern int sysctl_perf_event_max_stack;
+extern int sysctl_perf_event_max_contexts_per_stack;
+
 #endif /* __PERF_RECORD_H */
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..e4f7902d5afa 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -8,16 +8,20 @@
  */
 
 #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"
 #include "cgroup.h"
+#include "event.h"
 #include "evsel.h"
 #include "evlist.h"
 #include "util.h"
@@ -30,6 +34,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 +242,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 +942,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 +1245,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 +1263,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 +2463,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..314a07151fb7 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,11 +11,15 @@
 #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"
 #include "header.h"
+#include "memswap.h"
 #include "../perf.h"
 #include "trace-event.h"
 #include "session.h"
@@ -26,6 +34,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 +380,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 +2280,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..4c7718f87a08 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>
@@ -22,6 +23,7 @@
 #include "../perf.h"
 #include "session.h"
 #include "machine.h"
+#include "memswap.h"
 #include "sort.h"
 #include "tool.h"
 #include "event.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..d97e014c3df3 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)
 {
@@ -755,11 +796,11 @@ const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL};
  * Returns the name of the start symbol in *symbol_name. Pass in NULL as
  * symbol_name if it's not that important.
  */
-static u64 machine__get_running_kernel_start(struct machine *machine,
-                                             const char **symbol_name)
+static int machine__get_running_kernel_start(struct machine *machine,
+                                             const char **symbol_name, u64 *start)
 {
         char filename[PATH_MAX];
-        int i;
+        int i, err = -1;
         const char *name;
         u64 addr = 0;
 
@@ -769,21 +810,28 @@ static u64 machine__get_running_kernel_start(struct machine *machine,
                 return 0;
 
         for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) {
-                addr = kallsyms__get_function_start(filename, name);
-                if (addr)
+                err = kallsyms__get_function_start(filename, name, &addr);
+                if (!err)
                         break;
         }
 
+        if (err)
+                return -1;
+
         if (symbol_name)
                 *symbol_name = name;
 
-        return addr;
+        *start = addr;
+        return 0;
 }
 
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 {
         int type;
-        u64 start = machine__get_running_kernel_start(machine, NULL);
+        u64 start = 0;
+
+        if (machine__get_running_kernel_start(machine, NULL, &start))
+                return -1;
 
         /* In case of renewal the kernel map, destroy previous one */
         machine__destroy_kernel_maps(machine);
@@ -1144,8 +1192,8 @@ static int machine__create_modules(struct machine *machine)
 int machine__create_kernel_maps(struct machine *machine)
 {
         struct dso *kernel = machine__get_kernel(machine);
-        const char *name;
-        u64 addr;
+        const char *name = NULL;
+        u64 addr = 0;
         int ret;
 
         if (kernel == NULL)
@@ -1170,8 +1218,7 @@ int machine__create_kernel_maps(struct machine *machine)
          */
         map_groups__fixup_end(&machine->kmaps);
 
-        addr = machine__get_running_kernel_start(machine, &name);
-        if (!addr) {
+        if (machine__get_running_kernel_start(machine, &name, &addr)) {
         } else if (maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name, addr)) {
                 machine__destroy_kernel_maps(machine);
                 return -1;
@@ -1439,7 +1486,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 +1585,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..2179b2deb730 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);
 }
 
@@ -325,11 +325,6 @@ int map__load(struct map *map)
         return 0;
 }
 
-int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
-{
-        return strcmp(namea, nameb);
-}
-
 struct symbol *map__find_symbol(struct map *map, u64 addr)
 {
         if (map__load(map) < 0)
@@ -354,7 +349,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 +400,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 +481,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 +543,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..f9e8ac8a52cd 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;
 }
 
@@ -130,13 +130,14 @@ struct thread;
  */
 #define __map__for_each_symbol_by_name(map, sym_name, pos)      \
         for (pos = map__find_symbol_by_name(map, sym_name);     \
-             pos && arch__compare_symbol_names(pos->name, sym_name) == 0;       \
+             pos &&                                             \
+             !symbol__match_symbol_name(pos->name, sym_name,    \
+                                        SYMBOL_TAG_INCLUDE__DEFAULT_ONLY); \
              pos = symbol__next_by_name(pos))
 
 #define map__for_each_symbol_by_name(map, sym_name, pos)                \
         __map__for_each_symbol_by_name(map, sym_name, (pos))
 
-int arch__compare_symbol_names(const char *namea, const char *nameb);
 void map__init(struct map *map, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso);
 struct map *map__new(struct machine *machine, u64 start, u64 len,
@@ -150,7 +151,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/memswap.c b/tools/perf/util/memswap.c
new file mode 100644
index 000000000000..55f7faa8d9ec
--- /dev/null
+++ b/tools/perf/util/memswap.c
@@ -0,0 +1,24 @@
+#include <byteswap.h>
+#include "memswap.h"
+#include <linux/types.h>
+
+void mem_bswap_32(void *src, int byte_size)
+{
+        u32 *m = src;
+        while (byte_size > 0) {
+                *m = bswap_32(*m);
+                byte_size -= sizeof(u32);
+                ++m;
+        }
+}
+
+void mem_bswap_64(void *src, int byte_size)
+{
+        u64 *m = src;
+
+        while (byte_size > 0) {
+                *m = bswap_64(*m);
+                byte_size -= sizeof(u64);
+                ++m;
+        }
+}
diff --git a/tools/perf/util/memswap.h b/tools/perf/util/memswap.h
new file mode 100644
index 000000000000..7d1b1c34bb57
--- /dev/null
+++ b/tools/perf/util/memswap.h
@@ -0,0 +1,7 @@
+#ifndef PERF_MEMSWAP_H_
+#define PERF_MEMSWAP_H_
+
+void mem_bswap_64(void *src, int byte_size);
+void mem_bswap_32(void *src, int byte_size);
+
+#endif /* PERF_MEMSWAP_H_ */
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..7b79c413486b 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>
@@ -27,7 +28,9 @@
 #include <linux/bitmap.h>
 #include <linux/time64.h>
 
-#include "../util.h"
+#include <stdbool.h>
+/* perl needs the following define, right after including stdbool.h */
+#define HAS_BOOL
 #include <EXTERN.h>
 #include <perl.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..7dc1096264c5 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>
@@ -8,6 +11,7 @@
 
 #include "evlist.h"
 #include "evsel.h"
+#include "memswap.h"
 #include "session.h"
 #include "tool.h"
 #include "sort.h"
@@ -16,6 +20,7 @@
 #include "perf_regs.h"
 #include "asm/bug.h"
 #include "auxtrace.h"
+#include "thread.h"
 #include "thread-stack.h"
 #include "stat.h"
 
@@ -139,8 +144,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 +166,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 +1254,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 +1275,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 +1514,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 +1573,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 +1670,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..aafe908b82b5 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -1,15 +1,7 @@
 #include "debug.h"
 #include "util.h"
 #include <linux/kernel.h>
-
-int prefixcmp(const char *str, const char *prefix)
-{
-        for (; ; str++, prefix++)
-                if (!*prefix)
-                        return 0;
-                else if (*str != *prefix)
-                        return (unsigned char)*prefix - (unsigned char)*str;
-}
+#include <errno.h>
 
 /*
  * Used as the default ->buf value, so that people can always assume
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..8f2b068ff756 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>
@@ -87,6 +90,17 @@ static int prefix_underscores_count(const char *str)
         return tail - str;
 }
 
+int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
+{
+        return strcmp(namea, nameb);
+}
+
+int __weak arch__compare_symbol_names_n(const char *namea, const char *nameb,
+                                        unsigned int n)
+{
+        return strncmp(namea, nameb, n);
+}
+
 int __weak arch__choose_best_symbol(struct symbol *syma,
                                     struct symbol *symb __maybe_unused)
 {
@@ -396,8 +410,26 @@ static void symbols__sort_by_name(struct rb_root *symbols,
         }
 }
 
+int symbol__match_symbol_name(const char *name, const char *str,
+                              enum symbol_tag_include includes)
+{
+        const char *versioning;
+
+        if (includes == SYMBOL_TAG_INCLUDE__DEFAULT_ONLY &&
+            (versioning = strstr(name, "@@"))) {
+                int len = strlen(str);
+
+                if (len < versioning - name)
+                        len = versioning - name;
+
+                return arch__compare_symbol_names_n(name, str, len);
+        } else
+                return arch__compare_symbol_names(name, str);
+}
+
 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
-                                            const char *name)
+                                            const char *name,
+                                            enum symbol_tag_include includes)
 {
         struct rb_node *n;
         struct symbol_name_rb_node *s = NULL;
@@ -411,11 +443,11 @@ static struct symbol *symbols__find_by_name(struct rb_root *symbols,
                 int cmp;
 
                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
-                cmp = arch__compare_symbol_names(name, s->sym.name);
+                cmp = symbol__match_symbol_name(s->sym.name, name, includes);
 
-                if (cmp < 0)
+                if (cmp > 0)
                         n = n->rb_left;
-                else if (cmp > 0)
+                else if (cmp < 0)
                         n = n->rb_right;
                 else
                         break;
@@ -424,16 +456,17 @@ static struct symbol *symbols__find_by_name(struct rb_root *symbols,
         if (n == NULL)
                 return NULL;
 
-        /* return first symbol that has same name (if any) */
-        for (n = rb_prev(n); n; n = rb_prev(n)) {
-                struct symbol_name_rb_node *tmp;
+        if (includes != SYMBOL_TAG_INCLUDE__DEFAULT_ONLY)
+                /* return first symbol that has same name (if any) */
+                for (n = rb_prev(n); n; n = rb_prev(n)) {
+                        struct symbol_name_rb_node *tmp;
 
-                tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
-                if (arch__compare_symbol_names(tmp->sym.name, s->sym.name))
-                        break;
+                        tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
+                        if (arch__compare_symbol_names(tmp->sym.name, s->sym.name))
+                                break;
 
-                s = tmp;
-        }
+                        s = tmp;
+                }
 
         return &s->sym;
 }
@@ -463,7 +496,7 @@ void dso__insert_symbol(struct dso *dso, enum map_type type, struct symbol *sym)
 struct symbol *dso__find_symbol(struct dso *dso,
                                 enum map_type type, u64 addr)
 {
-        if (dso->last_find_result[type].addr != addr) {
+        if (dso->last_find_result[type].addr != addr || dso->last_find_result[type].symbol == NULL) {
                 dso->last_find_result[type].addr   = addr;
                 dso->last_find_result[type].symbol = symbols__find(&dso->symbols[type], addr);
         }
@@ -500,7 +533,12 @@ struct symbol *symbol__next_by_name(struct symbol *sym)
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
                                         const char *name)
 {
-        return symbols__find_by_name(&dso->symbol_names[type], name);
+        struct symbol *s = symbols__find_by_name(&dso->symbol_names[type], name,
+                                                 SYMBOL_TAG_INCLUDE__NONE);
+        if (!s)
+                s = symbols__find_by_name(&dso->symbol_names[type], name,
+                                          SYMBOL_TAG_INCLUDE__DEFAULT_ONLY);
+        return s;
 }
 
 void dso__sort_by_name(struct dso *dso, enum map_type type)
@@ -1072,8 +1110,9 @@ static int validate_kcore_addresses(const char *kallsyms_filename,
         if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
                 u64 start;
 
-                start = kallsyms__get_function_start(kallsyms_filename,
-                                                     kmap->ref_reloc_sym->name);
+                if (kallsyms__get_function_start(kallsyms_filename,
+                                                 kmap->ref_reloc_sym->name, &start))
+                        return -ENOENT;
                 if (start != kmap->ref_reloc_sym->addr)
                         return -EINVAL;
         }
@@ -1245,9 +1284,7 @@ static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
         if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
                 return 0;
 
-        addr = kallsyms__get_function_start(filename,
-                                            kmap->ref_reloc_sym->name);
-        if (!addr)
+        if (kallsyms__get_function_start(filename, kmap->ref_reloc_sym->name, &addr))
                 return -1;
 
         *delta = addr - kmap->ref_reloc_sym->addr;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 6c358b7ed336..41ebba9a2eb2 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);
@@ -345,12 +348,24 @@ void arch__sym_update(struct symbol *s, GElf_Sym *sym);
 #define SYMBOL_A 0
 #define SYMBOL_B 1
 
+int arch__compare_symbol_names(const char *namea, const char *nameb);
+int arch__compare_symbol_names_n(const char *namea, const char *nameb,
+                                 unsigned int n);
 int arch__choose_best_symbol(struct symbol *syma, struct symbol *symb);
 
+enum symbol_tag_include {
+        SYMBOL_TAG_INCLUDE__NONE = 0,
+        SYMBOL_TAG_INCLUDE__DEFAULT_ONLY
+};
+
+int symbol__match_symbol_name(const char *namea, const char *nameb,
+                              enum symbol_tag_include includes);
+
 /* structure containing an SDT note's info */
 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..4767ec2c5ef6
--- /dev/null
+++ b/tools/perf/util/units.c
@@ -0,0 +1,68 @@
+#include "units.h"
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <linux/kernel.h>
+#include <linux/time64.h>
+
+unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
+{
+        struct parse_tag *i = tags;
+
+        while (i->tag) {
+                char *s = strchr(str, i->tag);
+
+                if (s) {
+                        unsigned long int value;
+                        char *endptr;
+
+                        value = strtoul(str, &endptr, 10);
+                        if (s != endptr)
+                                break;
+
+                        if (value > ULONG_MAX / i->mult)
+                                break;
+                        value *= i->mult;
+                        return value;
+                }
+                i++;
+        }
+
+        return (unsigned long) -1;
+}
+
+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..f02c87317150
--- /dev/null
+++ b/tools/perf/util/units.h
@@ -0,0 +1,17 @@
+#ifndef PERF_UNIT_H
+#define PERF_UNIT_H
+
+#include <stddef.h>
+#include <linux/types.h>
+
+struct parse_tag {
+        char tag;
+        int  mult;
+};
+
+unsigned long parse_tag_value(const char *str, struct parse_tag *tags);
+
+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..28c9f335006c 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -3,38 +3,22 @@
 #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>
 #include <errno.h>
 #include <limits.h>
-#include <byteswap.h>
 #include <linux/kernel.h>
 #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 +253,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,171 +334,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;
-
-        while (i->tag) {
-                char *s;
-
-                s = strchr(str, i->tag);
-                if (s) {
-                        unsigned long int value;
-                        char *endptr;
-
-                        value = strtoul(str, &endptr, 10);
-                        if (s != endptr)
-                                break;
-
-                        if (value > ULONG_MAX / i->mult)
-                                break;
-                        value *= i->mult;
-                        return value;
-                }
-                i++;
-        }
-
-        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;
@@ -547,27 +344,6 @@ int perf_event_paranoid(void)
         return value;
 }
 
-void mem_bswap_32(void *src, int byte_size)
-{
-        u32 *m = src;
-        while (byte_size > 0) {
-                *m = bswap_32(*m);
-                byte_size -= sizeof(u32);
-                ++m;
-        }
-}
-
-void mem_bswap_64(void *src, int byte_size)
-{
-        u64 *m = src;
-
-        while (byte_size > 0) {
-                *m = bswap_64(*m);
-                byte_size -= sizeof(u64);
-                ++m;
-        }
-}
-
 bool find_process(const char *name)
 {
         size_t len = strlen(name);
@@ -696,7 +472,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 +487,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..5dfb9bb6482d 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -1,125 +1,17 @@
 #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__))
@@ -130,8 +22,6 @@ extern char buildid_dir[];
 #endif
 #endif
 
-#define PERF_GTK_DSO  "libperf-gtk.so"
-
 /* General helper functions */
 void usage(const char *err) NORETURN;
 void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
@@ -140,25 +30,6 @@ void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 
 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 +37,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,112 +48,17 @@ 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);
 
-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;
-extern int sysctl_perf_event_max_contexts_per_stack;
-
-struct parse_tag {
-        char tag;
-        int mult;
-};
-
-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 +68,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/power/cpupower/utils/helpers/cpuid.c b/tools/power/cpupower/utils/helpers/cpuid.c
index 93b0aa74ca03..39c2c7d067bb 100644
--- a/tools/power/cpupower/utils/helpers/cpuid.c
+++ b/tools/power/cpupower/utils/helpers/cpuid.c
@@ -156,6 +156,7 @@ out:
                                          */
                         case 0x2C:      /* Westmere EP - Gulftown */
                                 cpu_info->caps |= CPUPOWER_CAP_HAS_TURBO_RATIO;
+                                break;
                         case 0x2A:      /* SNB */
                         case 0x2D:      /* SNB Xeon */
                         case 0x3A:      /* IVB */
diff --git a/tools/power/pm-graph/Makefile b/tools/power/pm-graph/Makefile
new file mode 100644
index 000000000000..4d0ccc89e6c6
--- /dev/null
+++ b/tools/power/pm-graph/Makefile
@@ -0,0 +1,28 @@
+PREFIX          ?= /usr
+DESTDIR         ?=
+
+all:
+        @echo "Nothing to build"
+
+install :
+        install -d  $(DESTDIR)$(PREFIX)/lib/pm-graph
+        install analyze_suspend.py $(DESTDIR)$(PREFIX)/lib/pm-graph
+        install analyze_boot.py $(DESTDIR)$(PREFIX)/lib/pm-graph
+
+        ln -s $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_boot.py $(DESTDIR)$(PREFIX)/bin/bootgraph
+        ln -s $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_suspend.py $(DESTDIR)$(PREFIX)/bin/sleepgraph
+
+        install -d  $(DESTDIR)$(PREFIX)/share/man/man8
+        install bootgraph.8 $(DESTDIR)$(PREFIX)/share/man/man8
+        install sleepgraph.8 $(DESTDIR)$(PREFIX)/share/man/man8
+
+uninstall :
+        rm $(DESTDIR)$(PREFIX)/share/man/man8/bootgraph.8
+        rm $(DESTDIR)$(PREFIX)/share/man/man8/sleepgraph.8
+
+        rm $(DESTDIR)$(PREFIX)/bin/bootgraph
+        rm $(DESTDIR)$(PREFIX)/bin/sleepgraph
+
+        rm $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_boot.py
+        rm $(DESTDIR)$(PREFIX)/lib/pm-graph/analyze_suspend.py
+        rmdir $(DESTDIR)$(PREFIX)/lib/pm-graph
diff --git a/tools/power/pm-graph/analyze_boot.py b/tools/power/pm-graph/analyze_boot.py
new file mode 100755
index 000000000000..3e1dcbbf1adc
--- /dev/null
+++ b/tools/power/pm-graph/analyze_boot.py
@@ -0,0 +1,824 @@
+#!/usr/bin/python
+#
+# Tool for analyzing boot timing
+# Copyright (c) 2013, Intel Corporation.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# Authors:
+#        Todd Brandt <todd.e.brandt@linux.intel.com>
+#
+# Description:
+#        This tool is designed to assist kernel and OS developers in optimizing
+#        their linux stack's boot time. It creates an html representation of
+#        the kernel boot timeline up to the start of the init process.
+#
+
+# ----------------- LIBRARIES --------------------
+
+import sys
+import time
+import os
+import string
+import re
+import platform
+import shutil
+from datetime import datetime, timedelta
+from subprocess import call, Popen, PIPE
+import analyze_suspend as aslib
+
+# ----------------- CLASSES --------------------
+
+# Class: SystemValues
+# Description:
+#        A global, single-instance container used to
+#        store system values and test parameters
+class SystemValues(aslib.SystemValues):
+        title = 'BootGraph'
+        version = 2.0
+        hostname = 'localhost'
+        testtime = ''
+        kernel = ''
+        dmesgfile = ''
+        ftracefile = ''
+        htmlfile = 'bootgraph.html'
+        outfile = ''
+        phoronix = False
+        addlogs = False
+        useftrace = False
+        usedevsrc = True
+        suspendmode = 'boot'
+        max_graph_depth = 2
+        graph_filter = 'do_one_initcall'
+        reboot = False
+        manual = False
+        iscronjob = False
+        timeformat = '%.6f'
+        def __init__(self):
+                if('LOG_FILE' in os.environ and 'TEST_RESULTS_IDENTIFIER' in os.environ):
+                        self.phoronix = True
+                        self.addlogs = True
+                        self.outfile = os.environ['LOG_FILE']
+                        self.htmlfile = os.environ['LOG_FILE']
+                self.hostname = platform.node()
+                self.testtime = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
+                if os.path.exists('/proc/version'):
+                        fp = open('/proc/version', 'r')
+                        val = fp.read().strip()
+                        fp.close()
+                        self.kernel = self.kernelVersion(val)
+                else:
+                        self.kernel = 'unknown'
+        def kernelVersion(self, msg):
+                return msg.split()[2]
+        def kernelParams(self):
+                cmdline = 'initcall_debug log_buf_len=32M'
+                if self.useftrace:
+                        cmdline += ' trace_buf_size=128M trace_clock=global '\
+                        'trace_options=nooverwrite,funcgraph-abstime,funcgraph-cpu,'\
+                        'funcgraph-duration,funcgraph-proc,funcgraph-tail,'\
+                        'nofuncgraph-overhead,context-info,graph-time '\
+                        'ftrace=function_graph '\
+                        'ftrace_graph_max_depth=%d '\
+                        'ftrace_graph_filter=%s' % \
+                                (self.max_graph_depth, self.graph_filter)
+                return cmdline
+        def setGraphFilter(self, val):
+                fp = open(self.tpath+'available_filter_functions')
+                master = fp.read().split('\n')
+                fp.close()
+                for i in val.split(','):
+                        func = i.strip()
+                        if func not in master:
+                                doError('function "%s" not available for ftrace' % func)
+                self.graph_filter = val
+        def cronjobCmdString(self):
+                cmdline = '%s -cronjob' % os.path.abspath(sys.argv[0])
+                args = iter(sys.argv[1:])
+                for arg in args:
+                        if arg in ['-h', '-v', '-cronjob', '-reboot']:
+                                continue
+                        elif arg in ['-o', '-dmesg', '-ftrace', '-filter']:
+                                args.next()
+                                continue
+                        cmdline += ' '+arg
+                if self.graph_filter != 'do_one_initcall':
+                        cmdline += ' -filter "%s"' % self.graph_filter
+                cmdline += ' -o "%s"' % os.path.abspath(self.htmlfile)
+                return cmdline
+        def manualRebootRequired(self):
+                cmdline = self.kernelParams()
+                print 'To generate a new timeline manually, follow these steps:\n'
+                print '1. Add the CMDLINE string to your kernel command line.'
+                print '2. Reboot the system.'
+                print '3. After reboot, re-run this tool with the same arguments but no command (w/o -reboot or -manual).\n'
+                print 'CMDLINE="%s"' % cmdline
+                sys.exit()
+
+sysvals = SystemValues()
+
+# Class: Data
+# Description:
+#        The primary container for test data.
+class Data(aslib.Data):
+        dmesg = {}  # root data structure
+        start = 0.0 # test start
+        end = 0.0   # test end
+        dmesgtext = []   # dmesg text file in memory
+        testnumber = 0
+        idstr = ''
+        html_device_id = 0
+        valid = False
+        initstart = 0.0
+        boottime = ''
+        phases = ['boot']
+        do_one_initcall = False
+        def __init__(self, num):
+                self.testnumber = num
+                self.idstr = 'a'
+                self.dmesgtext = []
+                self.dmesg = {
+                        'boot': {'list': dict(), 'start': -1.0, 'end': -1.0, 'row': 0, 'color': '#dddddd'}
+                }
+        def deviceTopology(self):
+                return ''
+        def newAction(self, phase, name, start, end, ret, ulen):
+                # new device callback for a specific phase
+                self.html_device_id += 1
+                devid = '%s%d' % (self.idstr, self.html_device_id)
+                list = self.dmesg[phase]['list']
+                length = -1.0
+                if(start >= 0 and end >= 0):
+                        length = end - start
+                i = 2
+                origname = name
+                while(name in list):
+                        name = '%s[%d]' % (origname, i)
+                        i += 1
+                list[name] = {'name': name, 'start': start, 'end': end,
+                        'pid': 0, 'length': length, 'row': 0, 'id': devid,
+                        'ret': ret, 'ulen': ulen }
+                return name
+        def deviceMatch(self, cg):
+                if cg.end - cg.start == 0:
+                        return True
+                list = self.dmesg['boot']['list']
+                for devname in list:
+                        dev = list[devname]
+                        if cg.name == 'do_one_initcall':
+                                if(cg.start <= dev['start'] and cg.end >= dev['end'] and dev['length'] > 0):
+                                        dev['ftrace'] = cg
+                                        self.do_one_initcall = True
+                                        return True
+                        else:
+                                if(cg.start > dev['start'] and cg.end < dev['end']):
+                                        if 'ftraces' not in dev:
+                                                dev['ftraces'] = []
+                                        dev['ftraces'].append(cg)
+                                        return True
+                return False
+
+# ----------------- FUNCTIONS --------------------
+
+# Function: loadKernelLog
+# Description:
+#        Load a raw kernel log from dmesg
+def loadKernelLog():
+        data = Data(0)
+        data.dmesg['boot']['start'] = data.start = ktime = 0.0
+        sysvals.stamp = {
+                'time': datetime.now().strftime('%B %d %Y, %I:%M:%S %p'),
+                'host': sysvals.hostname,
+                'mode': 'boot', 'kernel': ''}
+
+        devtemp = dict()
+        if(sysvals.dmesgfile):
+                lf = open(sysvals.dmesgfile, 'r')
+        else:
+                lf = Popen('dmesg', stdout=PIPE).stdout
+        for line in lf:
+                line = line.replace('\r\n', '')
+                idx = line.find('[')
+                if idx > 1:
+                        line = line[idx:]
+                m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line)
+                if(not m):
+                        continue
+                ktime = float(m.group('ktime'))
+                if(ktime > 120):
+                        break
+                msg = m.group('msg')
+                data.end = data.initstart = ktime
+                data.dmesgtext.append(line)
+                if(ktime == 0.0 and re.match('^Linux version .*', msg)):
+                        if(not sysvals.stamp['kernel']):
+                                sysvals.stamp['kernel'] = sysvals.kernelVersion(msg)
+                        continue
+                m = re.match('.* setting system clock to (?P<t>.*) UTC.*', msg)
+                if(m):
+                        bt = datetime.strptime(m.group('t'), '%Y-%m-%d %H:%M:%S')
+                        bt = bt - timedelta(seconds=int(ktime))
+                        data.boottime = bt.strftime('%Y-%m-%d_%H:%M:%S')
+                        sysvals.stamp['time'] = bt.strftime('%B %d %Y, %I:%M:%S %p')
+                        continue
+                m = re.match('^calling *(?P<f>.*)\+.*', msg)
+                if(m):
+                        devtemp[m.group('f')] = ktime
+                        continue
+                m = re.match('^initcall *(?P<f>.*)\+.* returned (?P<r>.*) after (?P<t>.*) usecs', msg)
+                if(m):
+                        data.valid = True
+                        f, r, t = m.group('f', 'r', 't')
+                        if(f in devtemp):
+                                data.newAction('boot', f, devtemp[f], ktime, int(r), int(t))
+                                data.end = ktime
+                                del devtemp[f]
+                        continue
+                if(re.match('^Freeing unused kernel memory.*', msg)):
+                        break
+
+        data.dmesg['boot']['end'] = data.end
+        lf.close()
+        return data
+
+# Function: loadTraceLog
+# Description:
+#        Check if trace is available and copy to a temp file
+def loadTraceLog(data):
+        # load the data to a temp file if none given
+        if not sysvals.ftracefile:
+                lib = aslib.sysvals
+                aslib.rootCheck(True)
+                if not lib.verifyFtrace():
+                        doError('ftrace not available')
+                if lib.fgetVal('current_tracer').strip() != 'function_graph':
+                        doError('ftrace not configured for a boot callgraph')
+                sysvals.ftracefile = '/tmp/boot_ftrace.%s.txt' % os.getpid()
+                call('cat '+lib.tpath+'trace > '+sysvals.ftracefile, shell=True)
+        if not sysvals.ftracefile:
+                doError('No trace data available')
+
+        # parse the trace log
+        ftemp = dict()
+        tp = aslib.TestProps()
+        tp.setTracerType('function_graph')
+        tf = open(sysvals.ftracefile, 'r')
+        for line in tf:
+                if line[0] == '#':
+                        continue
+                m = re.match(tp.ftrace_line_fmt, line.strip())
+                if(not m):
+                        continue
+                m_time, m_proc, m_pid, m_msg, m_dur = \
+                        m.group('time', 'proc', 'pid', 'msg', 'dur')
+                if float(m_time) > data.end:
+                        break
+                if(m_time and m_pid and m_msg):
+                        t = aslib.FTraceLine(m_time, m_msg, m_dur)
+                        pid = int(m_pid)
+                else:
+                        continue
+                if t.fevent or t.fkprobe:
+                        continue
+                key = (m_proc, pid)
+                if(key not in ftemp):
+                        ftemp[key] = []
+                        ftemp[key].append(aslib.FTraceCallGraph(pid))
+                cg = ftemp[key][-1]
+                if(cg.addLine(t)):
+                        ftemp[key].append(aslib.FTraceCallGraph(pid))
+        tf.close()
+
+        # add the callgraph data to the device hierarchy
+        for key in ftemp:
+                proc, pid = key
+                for cg in ftemp[key]:
+                        if len(cg.list) < 1 or cg.invalid:
+                                continue
+                        if(not cg.postProcess()):
+                                print('Sanity check failed for %s-%d' % (proc, pid))
+                                continue
+                        # match cg data to devices
+                        if not data.deviceMatch(cg):
+                                print ' BAD: %s %s-%d [%f - %f]' % (cg.name, proc, pid, cg.start, cg.end)
+
+# Function: colorForName
+# Description:
+#        Generate a repeatable color from a list for a given name
+def colorForName(name):
+        list = [
+                ('c1', '#ec9999'),
+                ('c2', '#ffc1a6'),
+                ('c3', '#fff0a6'),
+                ('c4', '#adf199'),
+                ('c5', '#9fadea'),
+                ('c6', '#a699c1'),
+                ('c7', '#ad99b4'),
+                ('c8', '#eaffea'),
+                ('c9', '#dcecfb'),
+                ('c10', '#ffffea')
+        ]
+        i = 0
+        total = 0
+        count = len(list)
+        while i < len(name):
+                total += ord(name[i])
+                i += 1
+        return list[total % count]
+
+def cgOverview(cg, minlen):
+        stats = dict()
+        large = []
+        for l in cg.list:
+                if l.fcall and l.depth == 1:
+                        if l.length >= minlen:
+                                large.append(l)
+                        if l.name not in stats:
+                                stats[l.name] = [0, 0.0]
+                        stats[l.name][0] += (l.length * 1000.0)
+                        stats[l.name][1] += 1
+        return (large, stats)
+
+# Function: createBootGraph
+# Description:
+#        Create the output html file from the resident test data
+# Arguments:
+#        testruns: array of Data objects from parseKernelLog or parseTraceLog
+# Output:
+#        True if the html file was created, false if it failed
+def createBootGraph(data, embedded):
+        # html function templates
+        html_srccall = '<div id={6} title="{5}" class="srccall" style="left:{1}%;top:{2}px;height:{3}px;width:{4}%;line-height:{3}px;">{0}</div>\n'
+        html_timetotal = '<table class="time1">\n<tr>'\
+                '<td class="blue">Time from Kernel Boot to start of User Mode: <b>{0} ms</b></td>'\
+                '</tr>\n</table>\n'
+
+        # device timeline
+        devtl = aslib.Timeline(100, 20)
+
+        # write the test title and general info header
+        devtl.createHeader(sysvals, 'noftrace')
+
+        # Generate the header for this timeline
+        t0 = data.start
+        tMax = data.end
+        tTotal = tMax - t0
+        if(tTotal == 0):
+                print('ERROR: No timeline data')
+                return False
+        boot_time = '%.0f'%(tTotal*1000)
+        devtl.html += html_timetotal.format(boot_time)
+
+        # determine the maximum number of rows we need to draw
+        phase = 'boot'
+        list = data.dmesg[phase]['list']
+        devlist = []
+        for devname in list:
+                d = aslib.DevItem(0, phase, list[devname])
+                devlist.append(d)
+        devtl.getPhaseRows(devlist)
+        devtl.calcTotalRows()
+
+        # draw the timeline background
+        devtl.createZoomBox()
+        boot = data.dmesg[phase]
+        length = boot['end']-boot['start']
+        left = '%.3f' % (((boot['start']-t0)*100.0)/tTotal)
+        width = '%.3f' % ((length*100.0)/tTotal)
+        devtl.html += devtl.html_tblock.format(phase, left, width, devtl.scaleH)
+        devtl.html += devtl.html_phase.format('0', '100', \
+                '%.3f'%devtl.scaleH, '%.3f'%devtl.bodyH, \
+                'white', '')
+
+        # draw the device timeline
+        num = 0
+        devstats = dict()
+        for devname in sorted(list):
+                cls, color = colorForName(devname)
+                dev = list[devname]
+                info = '@|%.3f|%.3f|%.3f|%d' % (dev['start']*1000.0, dev['end']*1000.0,
+                        dev['ulen']/1000.0, dev['ret'])
+                devstats[dev['id']] = {'info':info}
+                dev['color'] = color
+                height = devtl.phaseRowHeight(0, phase, dev['row'])
+                top = '%.6f' % ((dev['row']*height) + devtl.scaleH)
+                left = '%.6f' % (((dev['start']-t0)*100)/tTotal)
+                width = '%.6f' % (((dev['end']-dev['start'])*100)/tTotal)
+                length = ' (%0.3f ms) ' % ((dev['end']-dev['start'])*1000)
+                devtl.html += devtl.html_device.format(dev['id'],
+                        devname+length+'kernel_mode', left, top, '%.3f'%height,
+                        width, devname, ' '+cls, '')
+                rowtop = devtl.phaseRowTop(0, phase, dev['row'])
+                height = '%.6f' % (devtl.rowH / 2)
+                top = '%.6f' % (rowtop + devtl.scaleH + (devtl.rowH / 2))
+                if data.do_one_initcall:
+                        if('ftrace' not in dev):
+                                continue
+                        cg = dev['ftrace']
+                        large, stats = cgOverview(cg, 0.001)
+                        devstats[dev['id']]['fstat'] = stats
+                        for l in large:
+                                left = '%f' % (((l.time-t0)*100)/tTotal)
+                                width = '%f' % (l.length*100/tTotal)
+                                title = '%s (%0.3fms)' % (l.name, l.length * 1000.0)
+                                devtl.html += html_srccall.format(l.name, left,
+                                        top, height, width, title, 'x%d'%num)
+                                num += 1
+                        continue
+                if('ftraces' not in dev):
+                        continue
+                for cg in dev['ftraces']:
+                        left = '%f' % (((cg.start-t0)*100)/tTotal)
+                        width = '%f' % ((cg.end-cg.start)*100/tTotal)
+                        cglen = (cg.end - cg.start) * 1000.0
+                        title = '%s (%0.3fms)' % (cg.name, cglen)
+                        cg.id = 'x%d' % num
+                        devtl.html += html_srccall.format(cg.name, left,
+                                top, height, width, title, dev['id']+cg.id)
+                        num += 1
+
+        # draw the time scale, try to make the number of labels readable
+        devtl.createTimeScale(t0, tMax, tTotal, phase)
+        devtl.html += '</div>\n'
+
+        # timeline is finished
+        devtl.html += '</div>\n</div>\n'
+
+        if(sysvals.outfile == sysvals.htmlfile):
+                hf = open(sysvals.htmlfile, 'a')
+        else:
+                hf = open(sysvals.htmlfile, 'w')
+
+        # add the css if this is not an embedded run
+        extra = '\
+                .c1 {background:rgba(209,0,0,0.4);}\n\
+                .c2 {background:rgba(255,102,34,0.4);}\n\
+                .c3 {background:rgba(255,218,33,0.4);}\n\
+                .c4 {background:rgba(51,221,0,0.4);}\n\
+                .c5 {background:rgba(17,51,204,0.4);}\n\
+                .c6 {background:rgba(34,0,102,0.4);}\n\
+                .c7 {background:rgba(51,0,68,0.4);}\n\
+                .c8 {background:rgba(204,255,204,0.4);}\n\
+                .c9 {background:rgba(169,208,245,0.4);}\n\
+                .c10 {background:rgba(255,255,204,0.4);}\n\
+                .vt {transform:rotate(-60deg);transform-origin:0 0;}\n\
+                table.fstat {table-layout:fixed;padding:150px 15px 0 0;font-size:10px;column-width:30px;}\n\
+                .fstat th {width:55px;}\n\
+                .fstat td {text-align:left;width:35px;}\n\
+                .srccall {position:absolute;font-size:10px;z-index:7;overflow:hidden;color:black;text-align:center;white-space:nowrap;border-radius:5px;border:1px solid black;background:linear-gradient(to bottom right,#CCC,#969696);}\n\
+                .srccall:hover {color:white;font-weight:bold;border:1px solid white;}\n'
+        if(not embedded):
+                aslib.addCSS(hf, sysvals, 1, False, extra)
+
+        # write the device timeline
+        hf.write(devtl.html)
+
+        # add boot specific html
+        statinfo = 'var devstats = {\n'
+        for n in sorted(devstats):
+                statinfo += '\t"%s": [\n\t\t"%s",\n' % (n, devstats[n]['info'])
+                if 'fstat' in devstats[n]:
+                        funcs = devstats[n]['fstat']
+                        for f in sorted(funcs, key=funcs.get, reverse=True):
+                                if funcs[f][0] < 0.01 and len(funcs) > 10:
+                                        break
+                                statinfo += '\t\t"%f|%s|%d",\n' % (funcs[f][0], f, funcs[f][1])
+                statinfo += '\t],\n'
+        statinfo += '};\n'
+        html = \
+                '<div id="devicedetailtitle"></div>\n'\
+                '<div id="devicedetail" style="display:none;">\n'\
+                '<div id="devicedetail0">\n'\
+                '<div id="kernel_mode" class="phaselet" style="left:0%;width:100%;background:#DDDDDD"></div>\n'\
+                '</div>\n</div>\n'\
+                '<script type="text/javascript">\n'+statinfo+\
+                '</script>\n'
+        hf.write(html)
+
+        # add the callgraph html
+        if(sysvals.usecallgraph):
+                aslib.addCallgraphs(sysvals, hf, data)
+
+        # add the dmesg log as a hidden div
+        if sysvals.addlogs:
+                hf.write('<div id="dmesglog" style="display:none;">\n')
+                for line in data.dmesgtext:
+                        line = line.replace('<', '&lt').replace('>', '&gt')
+                        hf.write(line)
+                hf.write('</div>\n')
+
+        if(not embedded):
+                # write the footer and close
+                aslib.addScriptCode(hf, [data])
+                hf.write('</body>\n</html>\n')
+        else:
+                # embedded out will be loaded in a page, skip the js
+                hf.write('<div id=bounds style=display:none>%f,%f</div>' % \
+                        (data.start*1000, data.initstart*1000))
+        hf.close()
+        return True
+
+# Function: updateCron
+# Description:
+#    (restore=False) Set the tool to run automatically on reboot
+#    (restore=True) Restore the original crontab
+def updateCron(restore=False):
+        if not restore:
+                sysvals.rootUser(True)
+        crondir = '/var/spool/cron/crontabs/'
+        cronfile = crondir+'root'
+        backfile = crondir+'root-analyze_boot-backup'
+        if not os.path.exists(crondir):
+                doError('%s not found' % crondir)
+        out = Popen(['which', 'crontab'], stdout=PIPE).stdout.read()
+        if not out:
+                doError('crontab not found')
+        # on restore: move the backup cron back into place
+        if restore:
+                if os.path.exists(backfile):
+                        shutil.move(backfile, cronfile)
+                return
+        # backup current cron and install new one with reboot
+        if os.path.exists(cronfile):
+                shutil.move(cronfile, backfile)
+        else:
+                fp = open(backfile, 'w')
+                fp.close()
+        res = -1
+        try:
+                fp = open(backfile, 'r')
+                op = open(cronfile, 'w')
+                for line in fp:
+                        if '@reboot' not in line:
+                                op.write(line)
+                                continue
+                fp.close()
+                op.write('@reboot python %s\n' % sysvals.cronjobCmdString())
+                op.close()
+                res = call('crontab %s' % cronfile, shell=True)
+        except Exception, e:
+                print 'Exception: %s' % str(e)
+                shutil.move(backfile, cronfile)
+                res = -1
+        if res != 0:
+                doError('crontab failed')
+
+# Function: updateGrub
+# Description:
+#        update grub.cfg for all kernels with our parameters
+def updateGrub(restore=False):
+        # call update-grub on restore
+        if restore:
+                try:
+                        call(['update-grub'], stderr=PIPE, stdout=PIPE,
+                                env={'PATH': '.:/sbin:/usr/sbin:/usr/bin:/sbin:/bin'})
+                except Exception, e:
+                        print 'Exception: %s\n' % str(e)
+                return
+        # verify we can do this
+        sysvals.rootUser(True)
+        grubfile = '/etc/default/grub'
+        if not os.path.exists(grubfile):
+                print 'ERROR: Unable to set the kernel parameters via grub.\n'
+                sysvals.manualRebootRequired()
+        out = Popen(['which', 'update-grub'], stdout=PIPE).stdout.read()
+        if not out:
+                print 'ERROR: Unable to set the kernel parameters via grub.\n'
+                sysvals.manualRebootRequired()
+
+        # extract the option and create a grub config without it
+        tgtopt = 'GRUB_CMDLINE_LINUX_DEFAULT'
+        cmdline = ''
+        tempfile = '/etc/default/grub.analyze_boot'
+        shutil.move(grubfile, tempfile)
+        res = -1
+        try:
+                fp = open(tempfile, 'r')
+                op = open(grubfile, 'w')
+                cont = False
+                for line in fp:
+                        line = line.strip()
+                        if len(line) == 0 or line[0] == '#':
+                                continue
+                        opt = line.split('=')[0].strip()
+                        if opt == tgtopt:
+                                cmdline = line.split('=', 1)[1].strip('\\')
+                                if line[-1] == '\\':
+                                        cont = True
+                        elif cont:
+                                cmdline += line.strip('\\')
+                                if line[-1] != '\\':
+                                        cont = False
+                        else:
+                                op.write('%s\n' % line)
+                fp.close()
+                # if the target option value is in quotes, strip them
+                sp = '"'
+                val = cmdline.strip()
+                if val[0] == '\'' or val[0] == '"':
+                        sp = val[0]
+                        val = val.strip(sp)
+                cmdline = val
+                # append our cmd line options
+                if len(cmdline) > 0:
+                        cmdline += ' '
+                cmdline += sysvals.kernelParams()
+                # write out the updated target option
+                op.write('\n%s=%s%s%s\n' % (tgtopt, sp, cmdline, sp))
+                op.close()
+                res = call('update-grub')
+                os.remove(grubfile)
+        except Exception, e:
+                print 'Exception: %s' % str(e)
+                res = -1
+        # cleanup
+        shutil.move(tempfile, grubfile)
+        if res != 0:
+                doError('update-grub failed')
+
+# Function: doError
+# Description:
+#        generic error function for catastrphic failures
+# Arguments:
+#        msg: the error message to print
+#        help: True if printHelp should be called after, False otherwise
+def doError(msg, help=False):
+        if help == True:
+                printHelp()
+        print 'ERROR: %s\n' % msg
+        sys.exit()
+
+# Function: printHelp
+# Description:
+#        print out the help text
+def printHelp():
+        print('')
+        print('%s v%.1f' % (sysvals.title, sysvals.version))
+        print('Usage: bootgraph <options> <command>')
+        print('')
+        print('Description:')
+        print('  This tool reads in a dmesg log of linux kernel boot and')
+        print('  creates an html representation of the boot timeline up to')
+        print('  the start of the init process.')
+        print('')
+        print('  If no specific command is given the tool reads the current dmesg')
+        print('  and/or ftrace log and outputs bootgraph.html')
+        print('')
+        print('Options:')
+        print('  -h            Print this help text')
+        print('  -v            Print the current tool version')
+        print('  -addlogs      Add the dmesg log to the html output')
+        print('  -o file       Html timeline name (default: bootgraph.html)')
+        print(' [advanced]')
+        print('  -f            Use ftrace to add function detail (default: disabled)')
+        print('  -callgraph    Add callgraph detail, can be very large (default: disabled)')
+        print('  -maxdepth N   limit the callgraph data to N call levels (default: 2)')
+        print('  -mincg ms     Discard all callgraphs shorter than ms milliseconds (e.g. 0.001 for us)')
+        print('  -timeprec N   Number of significant digits in timestamps (0:S, 3:ms, [6:us])')
+        print('  -expandcg     pre-expand the callgraph data in the html output (default: disabled)')
+        print('  -filter list  Limit ftrace to comma-delimited list of functions (default: do_one_initcall)')
+        print(' [commands]')
+        print('  -reboot       Reboot the machine automatically and generate a new timeline')
+        print('  -manual       Show the requirements to generate a new timeline manually')
+        print('  -dmesg file   Load a stored dmesg file (used with -ftrace)')
+        print('  -ftrace file  Load a stored ftrace file (used with -dmesg)')
+        print('  -flistall     Print all functions capable of being captured in ftrace')
+        print('')
+        return True
+
+# ----------------- MAIN --------------------
+# exec start (skipped if script is loaded as library)
+if __name__ == '__main__':
+        # loop through the command line arguments
+        cmd = ''
+        simplecmds = ['-updategrub', '-flistall']
+        args = iter(sys.argv[1:])
+        for arg in args:
+                if(arg == '-h'):
+                        printHelp()
+                        sys.exit()
+                elif(arg == '-v'):
+                        print("Version %.1f" % sysvals.version)
+                        sys.exit()
+                elif(arg in simplecmds):
+                        cmd = arg[1:]
+                elif(arg == '-f'):
+                        sysvals.useftrace = True
+                elif(arg == '-callgraph'):
+                        sysvals.useftrace = True
+                        sysvals.usecallgraph = True
+                elif(arg == '-mincg'):
+                        sysvals.mincglen = aslib.getArgFloat('-mincg', args, 0.0, 10000.0)
+                elif(arg == '-timeprec'):
+                        sysvals.setPrecision(aslib.getArgInt('-timeprec', args, 0, 6))
+                elif(arg == '-maxdepth'):
+                        sysvals.max_graph_depth = aslib.getArgInt('-maxdepth', args, 0, 1000)
+                elif(arg == '-filter'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No filter functions supplied', True)
+                        aslib.rootCheck(True)
+                        sysvals.setGraphFilter(val)
+                elif(arg == '-ftrace'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No ftrace file supplied', True)
+                        if(os.path.exists(val) == False):
+                                doError('%s does not exist' % val)
+                        sysvals.ftracefile = val
+                elif(arg == '-addlogs'):
+                        sysvals.addlogs = True
+                elif(arg == '-expandcg'):
+                        sysvals.cgexp = True
+                elif(arg == '-dmesg'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No dmesg file supplied', True)
+                        if(os.path.exists(val) == False):
+                                doError('%s does not exist' % val)
+                        if(sysvals.htmlfile == val or sysvals.outfile == val):
+                                doError('Output filename collision')
+                        sysvals.dmesgfile = val
+                elif(arg == '-o'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No HTML filename supplied', True)
+                        if(sysvals.dmesgfile == val or sysvals.ftracefile == val):
+                                doError('Output filename collision')
+                        sysvals.htmlfile = val
+                elif(arg == '-reboot'):
+                        if sysvals.iscronjob:
+                                doError('-reboot and -cronjob are incompatible')
+                        sysvals.reboot = True
+                elif(arg == '-manual'):
+                        sysvals.reboot = True
+                        sysvals.manual = True
+                # remaining options are only for cron job use
+                elif(arg == '-cronjob'):
+                        sysvals.iscronjob = True
+                        if sysvals.reboot:
+                                doError('-reboot and -cronjob are incompatible')
+                else:
+                        doError('Invalid argument: '+arg, True)
+
+        if cmd != '':
+                if cmd == 'updategrub':
+                        updateGrub()
+                elif cmd == 'flistall':
+                        sysvals.getFtraceFilterFunctions(False)
+                sys.exit()
+
+        # update grub, setup a cronjob, and reboot
+        if sysvals.reboot:
+                if not sysvals.manual:
+                        updateGrub()
+                        updateCron()
+                        call('reboot')
+                else:
+                        sysvals.manualRebootRequired()
+                sys.exit()
+
+        # disable the cronjob
+        if sysvals.iscronjob:
+                updateCron(True)
+                updateGrub(True)
+
+        data = loadKernelLog()
+        if sysvals.useftrace:
+                loadTraceLog(data)
+                if sysvals.iscronjob:
+                        try:
+                                sysvals.fsetVal('0', 'tracing_on')
+                        except:
+                                pass
+
+        if(sysvals.outfile and sysvals.phoronix):
+                fp = open(sysvals.outfile, 'w')
+                fp.write('pass %s initstart %.3f end %.3f boot %s\n' %
+                        (data.valid, data.initstart*1000, data.end*1000, data.boottime))
+                fp.close()
+        if(not data.valid):
+                if sysvals.dmesgfile:
+                        doError('No initcall data found in %s' % sysvals.dmesgfile)
+                else:
+                        doError('No initcall data found, is initcall_debug enabled?')
+
+        print('          Host: %s' % sysvals.hostname)
+        print('     Test time: %s' % sysvals.testtime)
+        print('     Boot time: %s' % data.boottime)
+        print('Kernel Version: %s' % sysvals.kernel)
+        print('  Kernel start: %.3f' % (data.start * 1000))
+        print('    init start: %.3f' % (data.initstart * 1000))
+
+        createBootGraph(data, sysvals.phoronix)
diff --git a/tools/power/pm-graph/analyze_suspend.py b/tools/power/pm-graph/analyze_suspend.py
new file mode 100755
index 000000000000..a9206e67fc1f
--- /dev/null
+++ b/tools/power/pm-graph/analyze_suspend.py
@@ -0,0 +1,5309 @@
+#!/usr/bin/python
+#
+# Tool for analyzing suspend/resume timing
+# Copyright (c) 2013, Intel Corporation.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# Authors:
+#        Todd Brandt <todd.e.brandt@linux.intel.com>
+#
+# Links:
+#        Home Page
+#          https://01.org/suspendresume
+#        Source repo
+#          https://github.com/01org/pm-graph
+#
+# Description:
+#        This tool is designed to assist kernel and OS developers in optimizing
+#        their linux stack's suspend/resume time. Using a kernel image built
+#        with a few extra options enabled, the tool will execute a suspend and
+#        will capture dmesg and ftrace data until resume is complete. This data
+#        is transformed into a device timeline and a callgraph to give a quick
+#        and detailed view of which devices and callbacks are taking the most
+#        time in suspend/resume. The output is a single html file which can be
+#        viewed in firefox or chrome.
+#
+#        The following kernel build options are required:
+#                CONFIG_PM_DEBUG=y
+#                CONFIG_PM_SLEEP_DEBUG=y
+#                CONFIG_FTRACE=y
+#                CONFIG_FUNCTION_TRACER=y
+#                CONFIG_FUNCTION_GRAPH_TRACER=y
+#                CONFIG_KPROBES=y
+#                CONFIG_KPROBES_ON_FTRACE=y
+#
+#        For kernel versions older than 3.15:
+#        The following additional kernel parameters are required:
+#                (e.g. in file /etc/default/grub)
+#                GRUB_CMDLINE_LINUX_DEFAULT="... initcall_debug log_buf_len=16M ..."
+#
+
+# ----------------- LIBRARIES --------------------
+
+import sys
+import time
+import os
+import string
+import re
+import platform
+from datetime import datetime
+import struct
+import ConfigParser
+from threading import Thread
+from subprocess import call, Popen, PIPE
+
+# ----------------- CLASSES --------------------
+
+# Class: SystemValues
+# Description:
+#        A global, single-instance container used to
+#        store system values and test parameters
+class SystemValues:
+        title = 'SleepGraph'
+        version = '4.6'
+        ansi = False
+        verbose = False
+        addlogs = False
+        mindevlen = 0.0
+        mincglen = 0.0
+        cgphase = ''
+        cgtest = -1
+        max_graph_depth = 0
+        callloopmaxgap = 0.0001
+        callloopmaxlen = 0.005
+        srgap = 0
+        cgexp = False
+        outdir = ''
+        testdir = '.'
+        tpath = '/sys/kernel/debug/tracing/'
+        fpdtpath = '/sys/firmware/acpi/tables/FPDT'
+        epath = '/sys/kernel/debug/tracing/events/power/'
+        traceevents = [
+                'suspend_resume',
+                'device_pm_callback_end',
+                'device_pm_callback_start'
+        ]
+        logmsg = ''
+        testcommand = ''
+        mempath = '/dev/mem'
+        powerfile = '/sys/power/state'
+        suspendmode = 'mem'
+        hostname = 'localhost'
+        prefix = 'test'
+        teststamp = ''
+        dmesgstart = 0.0
+        dmesgfile = ''
+        ftracefile = ''
+        htmlfile = ''
+        embedded = False
+        rtcwake = True
+        rtcwaketime = 15
+        rtcpath = ''
+        devicefilter = []
+        stamp = 0
+        execcount = 1
+        x2delay = 0
+        usecallgraph = False
+        usetraceevents = False
+        usetraceeventsonly = False
+        usetracemarkers = True
+        usekprobes = True
+        usedevsrc = False
+        useprocmon = False
+        notestrun = False
+        mixedphaseheight = True
+        devprops = dict()
+        predelay = 0
+        postdelay = 0
+        procexecfmt = 'ps - (?P<ps>.*)$'
+        devpropfmt = '# Device Properties: .*'
+        tracertypefmt = '# tracer: (?P<t>.*)'
+        firmwarefmt = '# fwsuspend (?P<s>[0-9]*) fwresume (?P<r>[0-9]*)$'
+        stampfmt = '# suspend-(?P<m>[0-9]{2})(?P<d>[0-9]{2})(?P<y>[0-9]{2})-'+\
+                                '(?P<H>[0-9]{2})(?P<M>[0-9]{2})(?P<S>[0-9]{2})'+\
+                                ' (?P<host>.*) (?P<mode>.*) (?P<kernel>.*)$'
+        tracefuncs = {
+                'sys_sync': dict(),
+                'pm_prepare_console': dict(),
+                'pm_notifier_call_chain': dict(),
+                'freeze_processes': dict(),
+                'freeze_kernel_threads': dict(),
+                'pm_restrict_gfp_mask': dict(),
+                'acpi_suspend_begin': dict(),
+                'suspend_console': dict(),
+                'acpi_pm_prepare': dict(),
+                'syscore_suspend': dict(),
+                'arch_enable_nonboot_cpus_end': dict(),
+                'syscore_resume': dict(),
+                'acpi_pm_finish': dict(),
+                'resume_console': dict(),
+                'acpi_pm_end': dict(),
+                'pm_restore_gfp_mask': dict(),
+                'thaw_processes': dict(),
+                'pm_restore_console': dict(),
+                'CPU_OFF': {
+                        'func':'_cpu_down',
+                        'args_x86_64': {'cpu':'%di:s32'},
+                        'format': 'CPU_OFF[{cpu}]'
+                },
+                'CPU_ON': {
+                        'func':'_cpu_up',
+                        'args_x86_64': {'cpu':'%di:s32'},
+                        'format': 'CPU_ON[{cpu}]'
+                },
+        }
+        dev_tracefuncs = {
+                # general wait/delay/sleep
+                'msleep': { 'args_x86_64': {'time':'%di:s32'}, 'ub': 1 },
+                'schedule_timeout_uninterruptible': { 'args_x86_64': {'timeout':'%di:s32'}, 'ub': 1 },
+                'schedule_timeout': { 'args_x86_64': {'timeout':'%di:s32'}, 'ub': 1 },
+                'udelay': { 'func':'__const_udelay', 'args_x86_64': {'loops':'%di:s32'}, 'ub': 1 },
+                'usleep_range': { 'args_x86_64': {'min':'%di:s32', 'max':'%si:s32'}, 'ub': 1 },
+                'mutex_lock_slowpath': { 'func':'__mutex_lock_slowpath', 'ub': 1 },
+                'acpi_os_stall': {'ub': 1},
+                # ACPI
+                'acpi_resume_power_resources': dict(),
+                'acpi_ps_parse_aml': dict(),
+                # filesystem
+                'ext4_sync_fs': dict(),
+                # 80211
+                'iwlagn_mac_start': dict(),
+                'iwlagn_alloc_bcast_station': dict(),
+                'iwl_trans_pcie_start_hw': dict(),
+                'iwl_trans_pcie_start_fw': dict(),
+                'iwl_run_init_ucode': dict(),
+                'iwl_load_ucode_wait_alive': dict(),
+                'iwl_alive_start': dict(),
+                'iwlagn_mac_stop': dict(),
+                'iwlagn_mac_suspend': dict(),
+                'iwlagn_mac_resume': dict(),
+                'iwlagn_mac_add_interface': dict(),
+                'iwlagn_mac_remove_interface': dict(),
+                'iwlagn_mac_change_interface': dict(),
+                'iwlagn_mac_config': dict(),
+                'iwlagn_configure_filter': dict(),
+                'iwlagn_mac_hw_scan': dict(),
+                'iwlagn_bss_info_changed': dict(),
+                'iwlagn_mac_channel_switch': dict(),
+                'iwlagn_mac_flush': dict(),
+                # ATA
+                'ata_eh_recover': { 'args_x86_64': {'port':'+36(%di):s32'} },
+                # i915
+                'i915_gem_resume': dict(),
+                'i915_restore_state': dict(),
+                'intel_opregion_setup': dict(),
+                'g4x_pre_enable_dp': dict(),
+                'vlv_pre_enable_dp': dict(),
+                'chv_pre_enable_dp': dict(),
+                'g4x_enable_dp': dict(),
+                'vlv_enable_dp': dict(),
+                'intel_hpd_init': dict(),
+                'intel_opregion_register': dict(),
+                'intel_dp_detect': dict(),
+                'intel_hdmi_detect': dict(),
+                'intel_opregion_init': dict(),
+                'intel_fbdev_set_suspend': dict(),
+        }
+        kprobes = dict()
+        timeformat = '%.3f'
+        def __init__(self):
+                # if this is a phoronix test run, set some default options
+                if('LOG_FILE' in os.environ and 'TEST_RESULTS_IDENTIFIER' in os.environ):
+                        self.embedded = True
+                        self.addlogs = True
+                        self.htmlfile = os.environ['LOG_FILE']
+                self.archargs = 'args_'+platform.machine()
+                self.hostname = platform.node()
+                if(self.hostname == ''):
+                        self.hostname = 'localhost'
+                rtc = "rtc0"
+                if os.path.exists('/dev/rtc'):
+                        rtc = os.readlink('/dev/rtc')
+                rtc = '/sys/class/rtc/'+rtc
+                if os.path.exists(rtc) and os.path.exists(rtc+'/date') and \
+                        os.path.exists(rtc+'/time') and os.path.exists(rtc+'/wakealarm'):
+                        self.rtcpath = rtc
+                if (hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()):
+                        self.ansi = True
+        def rootUser(self, fatal=False):
+                if 'USER' in os.environ and os.environ['USER'] == 'root':
+                        return True
+                if fatal:
+                        doError('This command must be run as root')
+                return False
+        def setPrecision(self, num):
+                if num < 0 or num > 6:
+                        return
+                self.timeformat = '%.{0}f'.format(num)
+        def setOutputFolder(self, value):
+                args = dict()
+                n = datetime.now()
+                args['date'] = n.strftime('%y%m%d')
+                args['time'] = n.strftime('%H%M%S')
+                args['hostname'] = self.hostname
+                self.outdir = value.format(**args)
+        def setOutputFile(self):
+                if((self.htmlfile == '') and (self.dmesgfile != '')):
+                        m = re.match('(?P<name>.*)_dmesg\.txt$', self.dmesgfile)
+                        if(m):
+                                self.htmlfile = m.group('name')+'.html'
+                if((self.htmlfile == '') and (self.ftracefile != '')):
+                        m = re.match('(?P<name>.*)_ftrace\.txt$', self.ftracefile)
+                        if(m):
+                                self.htmlfile = m.group('name')+'.html'
+                if(self.htmlfile == ''):
+                        self.htmlfile = 'output.html'
+        def initTestOutput(self, subdir, testpath=''):
+                self.prefix = self.hostname
+                v = open('/proc/version', 'r').read().strip()
+                kver = string.split(v)[2]
+                n = datetime.now()
+                testtime = n.strftime('suspend-%m%d%y-%H%M%S')
+                if not testpath:
+                        testpath = n.strftime('suspend-%y%m%d-%H%M%S')
+                if(subdir != "."):
+                        self.testdir = subdir+"/"+testpath
+                else:
+                        self.testdir = testpath
+                self.teststamp = \
+                        '# '+testtime+' '+self.prefix+' '+self.suspendmode+' '+kver
+                if(self.embedded):
+                        self.dmesgfile = \
+                                '/tmp/'+testtime+'_'+self.suspendmode+'_dmesg.txt'
+                        self.ftracefile = \
+                                '/tmp/'+testtime+'_'+self.suspendmode+'_ftrace.txt'
+                        return
+                self.dmesgfile = \
+                        self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_dmesg.txt'
+                self.ftracefile = \
+                        self.testdir+'/'+self.prefix+'_'+self.suspendmode+'_ftrace.txt'
+                self.htmlfile = \
+                        self.testdir+'/'+self.prefix+'_'+self.suspendmode+'.html'
+                if not os.path.isdir(self.testdir):
+                        os.mkdir(self.testdir)
+        def setDeviceFilter(self, value):
+                self.devicefilter = []
+                if value:
+                        value = value.split(',')
+                for i in value:
+                        self.devicefilter.append(i.strip())
+        def rtcWakeAlarmOn(self):
+                call('echo 0 > '+self.rtcpath+'/wakealarm', shell=True)
+                outD = open(self.rtcpath+'/date', 'r').read().strip()
+                outT = open(self.rtcpath+'/time', 'r').read().strip()
+                mD = re.match('^(?P<y>[0-9]*)-(?P<m>[0-9]*)-(?P<d>[0-9]*)', outD)
+                mT = re.match('^(?P<h>[0-9]*):(?P<m>[0-9]*):(?P<s>[0-9]*)', outT)
+                if(mD and mT):
+                        # get the current time from hardware
+                        utcoffset = int((datetime.now() - datetime.utcnow()).total_seconds())
+                        dt = datetime(\
+                                int(mD.group('y')), int(mD.group('m')), int(mD.group('d')),
+                                int(mT.group('h')), int(mT.group('m')), int(mT.group('s')))
+                        nowtime = int(dt.strftime('%s')) + utcoffset
+                else:
+                        # if hardware time fails, use the software time
+                        nowtime = int(datetime.now().strftime('%s'))
+                alarm = nowtime + self.rtcwaketime
+                call('echo %d > %s/wakealarm' % (alarm, self.rtcpath), shell=True)
+        def rtcWakeAlarmOff(self):
+                call('echo 0 > %s/wakealarm' % self.rtcpath, shell=True)
+        def initdmesg(self):
+                # get the latest time stamp from the dmesg log
+                fp = Popen('dmesg', stdout=PIPE).stdout
+                ktime = '0'
+                for line in fp:
+                        line = line.replace('\r\n', '')
+                        idx = line.find('[')
+                        if idx > 1:
+                                line = line[idx:]
+                        m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line)
+                        if(m):
+                                ktime = m.group('ktime')
+                fp.close()
+                self.dmesgstart = float(ktime)
+        def getdmesg(self):
+                # store all new dmesg lines since initdmesg was called
+                fp = Popen('dmesg', stdout=PIPE).stdout
+                op = open(self.dmesgfile, 'a')
+                for line in fp:
+                        line = line.replace('\r\n', '')
+                        idx = line.find('[')
+                        if idx > 1:
+                                line = line[idx:]
+                        m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line)
+                        if(not m):
+                                continue
+                        ktime = float(m.group('ktime'))
+                        if ktime > self.dmesgstart:
+                                op.write(line)
+                fp.close()
+                op.close()
+        def addFtraceFilterFunctions(self, file):
+                fp = open(file)
+                list = fp.read().split('\n')
+                fp.close()
+                for i in list:
+                        if len(i) < 2:
+                                continue
+                        self.tracefuncs[i] = dict()
+        def getFtraceFilterFunctions(self, current):
+                rootCheck(True)
+                if not current:
+                        call('cat '+self.tpath+'available_filter_functions', shell=True)
+                        return
+                fp = open(self.tpath+'available_filter_functions')
+                master = fp.read().split('\n')
+                fp.close()
+                for i in self.tracefuncs:
+                        if 'func' in self.tracefuncs[i]:
+                                i = self.tracefuncs[i]['func']
+                        if i in master:
+                                print i
+                        else:
+                                print self.colorText(i)
+        def setFtraceFilterFunctions(self, list):
+                fp = open(self.tpath+'available_filter_functions')
+                master = fp.read().split('\n')
+                fp.close()
+                flist = ''
+                for i in list:
+                        if i not in master:
+                                continue
+                        if ' [' in i:
+                                flist += i.split(' ')[0]+'\n'
+                        else:
+                                flist += i+'\n'
+                fp = open(self.tpath+'set_graph_function', 'w')
+                fp.write(flist)
+                fp.close()
+        def basicKprobe(self, name):
+                self.kprobes[name] = {'name': name,'func': name,'args': dict(),'format': name}
+        def defaultKprobe(self, name, kdata):
+                k = kdata
+                for field in ['name', 'format', 'func']:
+                        if field not in k:
+                                k[field] = name
+                if self.archargs in k:
+                        k['args'] = k[self.archargs]
+                else:
+                        k['args'] = dict()
+                        k['format'] = name
+                self.kprobes[name] = k
+        def kprobeColor(self, name):
+                if name not in self.kprobes or 'color' not in self.kprobes[name]:
+                        return ''
+                return self.kprobes[name]['color']
+        def kprobeDisplayName(self, name, dataraw):
+                if name not in self.kprobes:
+                        self.basicKprobe(name)
+                data = ''
+                quote=0
+                # first remvoe any spaces inside quotes, and the quotes
+                for c in dataraw:
+                        if c == '"':
+                                quote = (quote + 1) % 2
+                        if quote and c == ' ':
+                                data += '_'
+                        elif c != '"':
+                                data += c
+                fmt, args = self.kprobes[name]['format'], self.kprobes[name]['args']
+                arglist = dict()
+                # now process the args
+                for arg in sorted(args):
+                        arglist[arg] = ''
+                        m = re.match('.* '+arg+'=(?P<arg>.*) ', data);
+                        if m:
+                                arglist[arg] = m.group('arg')
+                        else:
+                                m = re.match('.* '+arg+'=(?P<arg>.*)', data);
+                                if m:
+                                        arglist[arg] = m.group('arg')
+                out = fmt.format(**arglist)
+                out = out.replace(' ', '_').replace('"', '')
+                return out
+        def kprobeText(self, kname, kprobe):
+                name = fmt = func = kname
+                args = dict()
+                if 'name' in kprobe:
+                        name = kprobe['name']
+                if 'format' in kprobe:
+                        fmt = kprobe['format']
+                if 'func' in kprobe:
+                        func = kprobe['func']
+                if self.archargs in kprobe:
+                        args = kprobe[self.archargs]
+                if 'args' in kprobe:
+                        args = kprobe['args']
+                if re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', func):
+                        doError('Kprobe "%s" has format info in the function name "%s"' % (name, func))
+                for arg in re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', fmt):
+                        if arg not in args:
+                                doError('Kprobe "%s" is missing argument "%s"' % (name, arg))
+                val = 'p:%s_cal %s' % (name, func)
+                for i in sorted(args):
+                        val += ' %s=%s' % (i, args[i])
+                val += '\nr:%s_ret %s $retval\n' % (name, func)
+                return val
+        def addKprobes(self, output=False):
+                if len(sysvals.kprobes) < 1:
+                        return
+                if output:
+                        print('    kprobe functions in this kernel:')
+                # first test each kprobe
+                rejects = []
+                # sort kprobes: trace, ub-dev, custom, dev
+                kpl = [[], [], [], []]
+                for name in sorted(self.kprobes):
+                        res = self.colorText('YES', 32)
+                        if not self.testKprobe(name, self.kprobes[name]):
+                                res = self.colorText('NO')
+                                rejects.append(name)
+                        else:
+                                if name in self.tracefuncs:
+                                        kpl[0].append(name)
+                                elif name in self.dev_tracefuncs:
+                                        if 'ub' in self.dev_tracefuncs[name]:
+                                                kpl[1].append(name)
+                                        else:
+                                                kpl[3].append(name)
+                                else:
+                                        kpl[2].append(name)
+                        if output:
+                                print('         %s: %s' % (name, res))
+                kplist = kpl[0] + kpl[1] + kpl[2] + kpl[3]
+                # remove all failed ones from the list
+                for name in rejects:
+                        self.kprobes.pop(name)
+                # set the kprobes all at once
+                self.fsetVal('', 'kprobe_events')
+                kprobeevents = ''
+                for kp in kplist:
+                        kprobeevents += self.kprobeText(kp, self.kprobes[kp])
+                self.fsetVal(kprobeevents, 'kprobe_events')
+                # verify that the kprobes were set as ordered
+                check = self.fgetVal('kprobe_events')
+                linesout = len(kprobeevents.split('\n')) - 1
+                linesack = len(check.split('\n')) - 1
+                if output:
+                        res = '%d/%d' % (linesack, linesout)
+                        if linesack < linesout:
+                                res = self.colorText(res, 31)
+                        else:
+                                res = self.colorText(res, 32)
+                        print('    working kprobe functions enabled: %s' % res)
+                self.fsetVal('1', 'events/kprobes/enable')
+        def testKprobe(self, kname, kprobe):
+                self.fsetVal('0', 'events/kprobes/enable')
+                kprobeevents = self.kprobeText(kname, kprobe)
+                if not kprobeevents:
+                        return False
+                try:
+                        self.fsetVal(kprobeevents, 'kprobe_events')
+                        check = self.fgetVal('kprobe_events')
+                except:
+                        return False
+                linesout = len(kprobeevents.split('\n'))
+                linesack = len(check.split('\n'))
+                if linesack < linesout:
+                        return False
+                return True
+        def fsetVal(self, val, path, mode='w'):
+                file = self.tpath+path
+                if not os.path.exists(file):
+                        return False
+                try:
+                        fp = open(file, mode, 0)
+                        fp.write(val)
+                        fp.flush()
+                        fp.close()
+                except:
+                        pass
+                return True
+        def fgetVal(self, path):
+                file = self.tpath+path
+                res = ''
+                if not os.path.exists(file):
+                        return res
+                try:
+                        fp = open(file, 'r')
+                        res = fp.read()
+                        fp.close()
+                except:
+                        pass
+                return res
+        def cleanupFtrace(self):
+                if(self.usecallgraph or self.usetraceevents):
+                        self.fsetVal('0', 'events/kprobes/enable')
+                        self.fsetVal('', 'kprobe_events')
+        def setupAllKprobes(self):
+                for name in self.tracefuncs:
+                        self.defaultKprobe(name, self.tracefuncs[name])
+                for name in self.dev_tracefuncs:
+                        self.defaultKprobe(name, self.dev_tracefuncs[name])
+        def isCallgraphFunc(self, name):
+                if len(self.tracefuncs) < 1 and self.suspendmode == 'command':
+                        return True
+                for i in self.tracefuncs:
+                        if 'func' in self.tracefuncs[i]:
+                                f = self.tracefuncs[i]['func']
+                        else:
+                                f = i
+                        if name == f:
+                                return True
+                return False
+        def initFtrace(self, testing=False):
+                print('INITIALIZING FTRACE...')
+                # turn trace off
+                self.fsetVal('0', 'tracing_on')
+                self.cleanupFtrace()
+                # set the trace clock to global
+                self.fsetVal('global', 'trace_clock')
+                # set trace buffer to a huge value
+                self.fsetVal('nop', 'current_tracer')
+                self.fsetVal('131073', 'buffer_size_kb')
+                # go no further if this is just a status check
+                if testing:
+                        return
+                # initialize the callgraph trace
+                if(self.usecallgraph):
+                        # set trace type
+                        self.fsetVal('function_graph', 'current_tracer')
+                        self.fsetVal('', 'set_ftrace_filter')
+                        # set trace format options
+                        self.fsetVal('print-parent', 'trace_options')
+                        self.fsetVal('funcgraph-abstime', 'trace_options')
+                        self.fsetVal('funcgraph-cpu', 'trace_options')
+                        self.fsetVal('funcgraph-duration', 'trace_options')
+                        self.fsetVal('funcgraph-proc', 'trace_options')
+                        self.fsetVal('funcgraph-tail', 'trace_options')
+                        self.fsetVal('nofuncgraph-overhead', 'trace_options')
+                        self.fsetVal('context-info', 'trace_options')
+                        self.fsetVal('graph-time', 'trace_options')
+                        self.fsetVal('%d' % self.max_graph_depth, 'max_graph_depth')
+                        cf = ['dpm_run_callback']
+                        if(self.usetraceeventsonly):
+                                cf += ['dpm_prepare', 'dpm_complete']
+                        for fn in self.tracefuncs:
+                                if 'func' in self.tracefuncs[fn]:
+                                        cf.append(self.tracefuncs[fn]['func'])
+                                else:
+                                        cf.append(fn)
+                        self.setFtraceFilterFunctions(cf)
+                # initialize the kprobe trace
+                elif self.usekprobes:
+                        for name in self.tracefuncs:
+                                self.defaultKprobe(name, self.tracefuncs[name])
+                        if self.usedevsrc:
+                                for name in self.dev_tracefuncs:
+                                        self.defaultKprobe(name, self.dev_tracefuncs[name])
+                        print('INITIALIZING KPROBES...')
+                        self.addKprobes(self.verbose)
+                if(self.usetraceevents):
+                        # turn trace events on
+                        events = iter(self.traceevents)
+                        for e in events:
+                                self.fsetVal('1', 'events/power/'+e+'/enable')
+                # clear the trace buffer
+                self.fsetVal('', 'trace')
+        def verifyFtrace(self):
+                # files needed for any trace data
+                files = ['buffer_size_kb', 'current_tracer', 'trace', 'trace_clock',
+                                 'trace_marker', 'trace_options', 'tracing_on']
+                # files needed for callgraph trace data
+                tp = self.tpath
+                if(self.usecallgraph):
+                        files += [
+                                'available_filter_functions',
+                                'set_ftrace_filter',
+                                'set_graph_function'
+                        ]
+                for f in files:
+                        if(os.path.exists(tp+f) == False):
+                                return False
+                return True
+        def verifyKprobes(self):
+                # files needed for kprobes to work
+                files = ['kprobe_events', 'events']
+                tp = self.tpath
+                for f in files:
+                        if(os.path.exists(tp+f) == False):
+                                return False
+                return True
+        def colorText(self, str, color=31):
+                if not self.ansi:
+                        return str
+                return '\x1B[%d;40m%s\x1B[m' % (color, str)
+
+sysvals = SystemValues()
+suspendmodename = {
+        'freeze': 'Freeze (S0)',
+        'standby': 'Standby (S1)',
+        'mem': 'Suspend (S3)',
+        'disk': 'Hibernate (S4)'
+}
+
+# Class: DevProps
+# Description:
+#        Simple class which holds property values collected
+#        for all the devices used in the timeline.
+class DevProps:
+        syspath = ''
+        altname = ''
+        async = True
+        xtraclass = ''
+        xtrainfo = ''
+        def out(self, dev):
+                return '%s,%s,%d;' % (dev, self.altname, self.async)
+        def debug(self, dev):
+                print '%s:\n\taltname = %s\n\t  async = %s' % (dev, self.altname, self.async)
+        def altName(self, dev):
+                if not self.altname or self.altname == dev:
+                        return dev
+                return '%s [%s]' % (self.altname, dev)
+        def xtraClass(self):
+                if self.xtraclass:
+                        return ' '+self.xtraclass
+                if not self.async:
+                        return ' sync'
+                return ''
+        def xtraInfo(self):
+                if self.xtraclass:
+                        return ' '+self.xtraclass
+                if self.async:
+                        return ' async_device'
+                return ' sync_device'
+
+# Class: DeviceNode
+# Description:
+#        A container used to create a device hierachy, with a single root node
+#        and a tree of child nodes. Used by Data.deviceTopology()
+class DeviceNode:
+        name = ''
+        children = 0
+        depth = 0
+        def __init__(self, nodename, nodedepth):
+                self.name = nodename
+                self.children = []
+                self.depth = nodedepth
+
+# Class: Data
+# Description:
+#        The primary container for suspend/resume test data. There is one for
+#        each test run. The data is organized into a cronological hierarchy:
+#        Data.dmesg {
+#               phases {
+#                       10 sequential, non-overlapping phases of S/R
+#                       contents: times for phase start/end, order/color data for html
+#                       devlist {
+#                               device callback or action list for this phase
+#                               device {
+#                                       a single device callback or generic action
+#                                       contents: start/stop times, pid/cpu/driver info
+#                                               parents/children, html id for timeline/callgraph
+#                                               optionally includes an ftrace callgraph
+#                                               optionally includes dev/ps data
+#                               }
+#                       }
+#               }
+#       }
+#
+class Data:
+        dmesg = {}  # root data structure
+        phases = [] # ordered list of phases
+        start = 0.0 # test start
+        end = 0.0   # test end
+        tSuspended = 0.0 # low-level suspend start
+        tResumed = 0.0   # low-level resume start
+        tKernSus = 0.0   # kernel level suspend start
+        tKernRes = 0.0   # kernel level resume end
+        tLow = 0.0       # time spent in low-level suspend (standby/freeze)
+        fwValid = False  # is firmware data available
+        fwSuspend = 0    # time spent in firmware suspend
+        fwResume = 0     # time spent in firmware resume
+        dmesgtext = []   # dmesg text file in memory
+        pstl = 0         # process timeline
+        testnumber = 0
+        idstr = ''
+        html_device_id = 0
+        stamp = 0
+        outfile = ''
+        devpids = []
+        kerror = False
+        def __init__(self, num):
+                idchar = 'abcdefghij'
+                self.pstl = dict()
+                self.testnumber = num
+                self.idstr = idchar[num]
+                self.dmesgtext = []
+                self.phases = []
+                self.dmesg = { # fixed list of 10 phases
+                        'suspend_prepare': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#CCFFCC', 'order': 0},
+                                'suspend': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#88FF88', 'order': 1},
+                           'suspend_late': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#00AA00', 'order': 2},
+                          'suspend_noirq': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#008888', 'order': 3},
+                    'suspend_machine': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#0000FF', 'order': 4},
+                         'resume_machine': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#FF0000', 'order': 5},
+                           'resume_noirq': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#FF9900', 'order': 6},
+                           'resume_early': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#FFCC00', 'order': 7},
+                                 'resume': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#FFFF88', 'order': 8},
+                        'resume_complete': {'list': dict(), 'start': -1.0, 'end': -1.0,
+                                                                'row': 0, 'color': '#FFFFCC', 'order': 9}
+                }
+                self.phases = self.sortedPhases()
+                self.devicegroups = []
+                for phase in self.phases:
+                        self.devicegroups.append([phase])
+                self.errorinfo = {'suspend':[],'resume':[]}
+        def extractErrorInfo(self, dmesg):
+                error = ''
+                tm = 0.0
+                for i in range(len(dmesg)):
+                        if 'Call Trace:' in dmesg[i]:
+                                m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) .*', dmesg[i])
+                                if not m:
+                                        continue
+                                tm = float(m.group('ktime'))
+                                if tm < self.start or tm > self.end:
+                                        continue
+                                for j in range(i-10, i+1):
+                                        error += dmesg[j]
+                                continue
+                        if error:
+                                m = re.match('[ \t]*\[ *[0-9\.]*\]  \[\<[0-9a-fA-F]*\>\] .*', dmesg[i])
+                                if m:
+                                        error += dmesg[i]
+                                else:
+                                        if tm < self.tSuspended:
+                                                dir = 'suspend'
+                                        else:
+                                                dir = 'resume'
+                                        error = error.replace('<', '&lt').replace('>', '&gt')
+                                        vprint('kernel error found in %s at %f' % (dir, tm))
+                                        self.errorinfo[dir].append((tm, error))
+                                        self.kerror = True
+                                        error = ''
+        def setStart(self, time):
+                self.start = time
+        def setEnd(self, time):
+                self.end = time
+        def isTraceEventOutsideDeviceCalls(self, pid, time):
+                for phase in self.phases:
+                        list = self.dmesg[phase]['list']
+                        for dev in list:
+                                d = list[dev]
+                                if(d['pid'] == pid and time >= d['start'] and
+                                        time < d['end']):
+                                        return False
+                return True
+        def sourcePhase(self, start):
+                for phase in self.phases:
+                        pend = self.dmesg[phase]['end']
+                        if start <= pend:
+                                return phase
+                return 'resume_complete'
+        def sourceDevice(self, phaselist, start, end, pid, type):
+                tgtdev = ''
+                for phase in phaselist:
+                        list = self.dmesg[phase]['list']
+                        for devname in list:
+                                dev = list[devname]
+                                # pid must match
+                                if dev['pid'] != pid:
+                                        continue
+                                devS = dev['start']
+                                devE = dev['end']
+                                if type == 'device':
+                                        # device target event is entirely inside the source boundary
+                                        if(start < devS or start >= devE or end <= devS or end > devE):
+                                                continue
+                                elif type == 'thread':
+                                        # thread target event will expand the source boundary
+                                        if start < devS:
+                                                dev['start'] = start
+                                        if end > devE:
+                                                dev['end'] = end
+                                tgtdev = dev
+                                break
+                return tgtdev
+        def addDeviceFunctionCall(self, displayname, kprobename, proc, pid, start, end, cdata, rdata):
+                # try to place the call in a device
+                tgtdev = self.sourceDevice(self.phases, start, end, pid, 'device')
+                # calls with device pids that occur outside device bounds are dropped
+                # TODO: include these somehow
+                if not tgtdev and pid in self.devpids:
+                        return False
+                # try to place the call in a thread
+                if not tgtdev:
+                        tgtdev = self.sourceDevice(self.phases, start, end, pid, 'thread')
+                # create new thread blocks, expand as new calls are found
+                if not tgtdev:
+                        if proc == '<...>':
+                                threadname = 'kthread-%d' % (pid)
+                        else:
+                                threadname = '%s-%d' % (proc, pid)
+                        tgtphase = self.sourcePhase(start)
+                        self.newAction(tgtphase, threadname, pid, '', start, end, '', ' kth', '')
+                        return self.addDeviceFunctionCall(displayname, kprobename, proc, pid, start, end, cdata, rdata)
+                # this should not happen
+                if not tgtdev:
+                        vprint('[%f - %f] %s-%d %s %s %s' % \
+                                (start, end, proc, pid, kprobename, cdata, rdata))
+                        return False
+                # place the call data inside the src element of the tgtdev
+                if('src' not in tgtdev):
+                        tgtdev['src'] = []
+                dtf = sysvals.dev_tracefuncs
+                ubiquitous = False
+                if kprobename in dtf and 'ub' in dtf[kprobename]:
+                        ubiquitous = True
+                title = cdata+' '+rdata
+                mstr = '\(.*\) *(?P<args>.*) *\((?P<caller>.*)\+.* arg1=(?P<ret>.*)'
+                m = re.match(mstr, title)
+                if m:
+                        c = m.group('caller')
+                        a = m.group('args').strip()
+                        r = m.group('ret')
+                        if len(r) > 6:
+                                r = ''
+                        else:
+                                r = 'ret=%s ' % r
+                        if ubiquitous and c in dtf and 'ub' in dtf[c]:
+                                return False
+                color = sysvals.kprobeColor(kprobename)
+                e = DevFunction(displayname, a, c, r, start, end, ubiquitous, proc, pid, color)
+                tgtdev['src'].append(e)
+                return True
+        def overflowDevices(self):
+                # get a list of devices that extend beyond the end of this test run
+                devlist = []
+                for phase in self.phases:
+                        list = self.dmesg[phase]['list']
+                        for devname in list:
+                                dev = list[devname]
+                                if dev['end'] > self.end:
+                                        devlist.append(dev)
+                return devlist
+        def mergeOverlapDevices(self, devlist):
+                # merge any devices that overlap devlist
+                for dev in devlist:
+                        devname = dev['name']
+                        for phase in self.phases:
+                                list = self.dmesg[phase]['list']
+                                if devname not in list:
+                                        continue
+                                tdev = list[devname]
+                                o = min(dev['end'], tdev['end']) - max(dev['start'], tdev['start'])
+                                if o <= 0:
+                                        continue
+                                dev['end'] = tdev['end']
+                                if 'src' not in dev or 'src' not in tdev:
+                                        continue
+                                dev['src'] += tdev['src']
+                                del list[devname]
+        def usurpTouchingThread(self, name, dev):
+                # the caller test has priority of this thread, give it to him
+                for phase in self.phases:
+                        list = self.dmesg[phase]['list']
+                        if name in list:
+                                tdev = list[name]
+                                if tdev['start'] - dev['end'] < 0.1:
+                                        dev['end'] = tdev['end']
+                                        if 'src' not in dev:
+                                                dev['src'] = []
+                                        if 'src' in tdev:
+                                                dev['src'] += tdev['src']
+                                        del list[name]
+                                break
+        def stitchTouchingThreads(self, testlist):
+                # merge any threads between tests that touch
+                for phase in self.phases:
+                        list = self.dmesg[phase]['list']
+                        for devname in list:
+                                dev = list[devname]
+                                if 'htmlclass' not in dev or 'kth' not in dev['htmlclass']:
+                                        continue
+                                for data in testlist:
+                                        data.usurpTouchingThread(devname, dev)
+        def optimizeDevSrc(self):
+                # merge any src call loops to reduce timeline size
+                for phase in self.phases:
+                        list = self.dmesg[phase]['list']
+                        for dev in list:
+                                if 'src' not in list[dev]:
+                                        continue
+                                src = list[dev]['src']
+                                p = 0
+                                for e in sorted(src, key=lambda event: event.time):
+                                        if not p or not e.repeat(p):
+                                                p = e
+                                                continue
+                                        # e is another iteration of p, move it into p
+                                        p.end = e.end
+                                        p.length = p.end - p.time
+                                        p.count += 1
+                                        src.remove(e)
+        def trimTimeVal(self, t, t0, dT, left):
+                if left:
+                        if(t > t0):
+                                if(t - dT < t0):
+                                        return t0
+                                return t - dT
+                        else:
+                                return t
+                else:
+                        if(t < t0 + dT):
+                                if(t > t0):
+                                        return t0 + dT
+                                return t + dT
+                        else:
+                                return t
+        def trimTime(self, t0, dT, left):
+                self.tSuspended = self.trimTimeVal(self.tSuspended, t0, dT, left)
+                self.tResumed = self.trimTimeVal(self.tResumed, t0, dT, left)
+                self.start = self.trimTimeVal(self.start, t0, dT, left)
+                self.tKernSus = self.trimTimeVal(self.tKernSus, t0, dT, left)
+                self.tKernRes = self.trimTimeVal(self.tKernRes, t0, dT, left)
+                self.end = self.trimTimeVal(self.end, t0, dT, left)
+                for phase in self.phases:
+                        p = self.dmesg[phase]
+                        p['start'] = self.trimTimeVal(p['start'], t0, dT, left)
+                        p['end'] = self.trimTimeVal(p['end'], t0, dT, left)
+                        list = p['list']
+                        for name in list:
+                                d = list[name]
+                                d['start'] = self.trimTimeVal(d['start'], t0, dT, left)
+                                d['end'] = self.trimTimeVal(d['end'], t0, dT, left)
+                                if('ftrace' in d):
+                                        cg = d['ftrace']
+                                        cg.start = self.trimTimeVal(cg.start, t0, dT, left)
+                                        cg.end = self.trimTimeVal(cg.end, t0, dT, left)
+                                        for line in cg.list:
+                                                line.time = self.trimTimeVal(line.time, t0, dT, left)
+                                if('src' in d):
+                                        for e in d['src']:
+                                                e.time = self.trimTimeVal(e.time, t0, dT, left)
+        def normalizeTime(self, tZero):
+                # trim out any standby or freeze clock time
+                if(self.tSuspended != self.tResumed):
+                        if(self.tResumed > tZero):
+                                self.trimTime(self.tSuspended, \
+                                        self.tResumed-self.tSuspended, True)
+                        else:
+                                self.trimTime(self.tSuspended, \
+                                        self.tResumed-self.tSuspended, False)
+        def setPhase(self, phase, ktime, isbegin):
+                if(isbegin):
+                        self.dmesg[phase]['start'] = ktime
+                else:
+                        self.dmesg[phase]['end'] = ktime
+        def dmesgSortVal(self, phase):
+                return self.dmesg[phase]['order']
+        def sortedPhases(self):
+                return sorted(self.dmesg, key=self.dmesgSortVal)
+        def sortedDevices(self, phase):
+                list = self.dmesg[phase]['list']
+                slist = []
+                tmp = dict()
+                for devname in list:
+                        dev = list[devname]
+                        if dev['length'] == 0:
+                                continue
+                        tmp[dev['start']] = devname
+                for t in sorted(tmp):
+                        slist.append(tmp[t])
+                return slist
+        def fixupInitcalls(self, phase):
+                # if any calls never returned, clip them at system resume end
+                phaselist = self.dmesg[phase]['list']
+                for devname in phaselist:
+                        dev = phaselist[devname]
+                        if(dev['end'] < 0):
+                                for p in self.phases:
+                                        if self.dmesg[p]['end'] > dev['start']:
+                                                dev['end'] = self.dmesg[p]['end']
+                                                break
+                                vprint('%s (%s): callback didnt return' % (devname, phase))
+        def deviceFilter(self, devicefilter):
+                for phase in self.phases:
+                        list = self.dmesg[phase]['list']
+                        rmlist = []
+                        for name in list:
+                                keep = False
+                                for filter in devicefilter:
+                                        if filter in name or \
+                                                ('drv' in list[name] and filter in list[name]['drv']):
+                                                keep = True
+                                if not keep:
+                                        rmlist.append(name)
+                        for name in rmlist:
+                                del list[name]
+        def fixupInitcallsThatDidntReturn(self):
+                # if any calls never returned, clip them at system resume end
+                for phase in self.phases:
+                        self.fixupInitcalls(phase)
+        def phaseOverlap(self, phases):
+                rmgroups = []
+                newgroup = []
+                for group in self.devicegroups:
+                        for phase in phases:
+                                if phase not in group:
+                                        continue
+                                for p in group:
+                                        if p not in newgroup:
+                                                newgroup.append(p)
+                                if group not in rmgroups:
+                                        rmgroups.append(group)
+                for group in rmgroups:
+                        self.devicegroups.remove(group)
+                self.devicegroups.append(newgroup)
+        def newActionGlobal(self, name, start, end, pid=-1, color=''):
+                # which phase is this device callback or action in
+                targetphase = 'none'
+                htmlclass = ''
+                overlap = 0.0
+                phases = []
+                for phase in self.phases:
+                        pstart = self.dmesg[phase]['start']
+                        pend = self.dmesg[phase]['end']
+                        # see if the action overlaps this phase
+                        o = max(0, min(end, pend) - max(start, pstart))
+                        if o > 0:
+                                phases.append(phase)
+                        # set the target phase to the one that overlaps most
+                        if o > overlap:
+                                if overlap > 0 and phase == 'post_resume':
+                                        continue
+                                targetphase = phase
+                                overlap = o
+                # if no target phase was found, pin it to the edge
+                if targetphase == 'none':
+                        p0start = self.dmesg[self.phases[0]]['start']
+                        if start <= p0start:
+                                targetphase = self.phases[0]
+                        else:
+                                targetphase = self.phases[-1]
+                if pid == -2:
+                        htmlclass = ' bg'
+                elif pid == -3:
+                        htmlclass = ' ps'
+                if len(phases) > 1:
+                        htmlclass = ' bg'
+                        self.phaseOverlap(phases)
+                if targetphase in self.phases:
+                        newname = self.newAction(targetphase, name, pid, '', start, end, '', htmlclass, color)
+                        return (targetphase, newname)
+                return False
+        def newAction(self, phase, name, pid, parent, start, end, drv, htmlclass='', color=''):
+                # new device callback for a specific phase
+                self.html_device_id += 1
+                devid = '%s%d' % (self.idstr, self.html_device_id)
+                list = self.dmesg[phase]['list']
+                length = -1.0
+                if(start >= 0 and end >= 0):
+                        length = end - start
+                if pid == -2:
+                        i = 2
+                        origname = name
+                        while(name in list):
+                                name = '%s[%d]' % (origname, i)
+                                i += 1
+                list[name] = {'name': name, 'start': start, 'end': end, 'pid': pid,
+                        'par': parent, 'length': length, 'row': 0, 'id': devid, 'drv': drv }
+                if htmlclass:
+                        list[name]['htmlclass'] = htmlclass
+                if color:
+                        list[name]['color'] = color
+                return name
+        def deviceChildren(self, devname, phase):
+                devlist = []
+                list = self.dmesg[phase]['list']
+                for child in list:
+                        if(list[child]['par'] == devname):
+                                devlist.append(child)
+                return devlist
+        def printDetails(self):
+                vprint('Timeline Details:')
+                vprint('          test start: %f' % self.start)
+                vprint('kernel suspend start: %f' % self.tKernSus)
+                for phase in self.phases:
+                        dc = len(self.dmesg[phase]['list'])
+                        vprint('    %16s: %f - %f (%d devices)' % (phase, \
+                                self.dmesg[phase]['start'], self.dmesg[phase]['end'], dc))
+                vprint('   kernel resume end: %f' % self.tKernRes)
+                vprint('            test end: %f' % self.end)
+        def deviceChildrenAllPhases(self, devname):
+                devlist = []
+                for phase in self.phases:
+                        list = self.deviceChildren(devname, phase)
+                        for dev in list:
+                                if dev not in devlist:
+                                        devlist.append(dev)
+                return devlist
+        def masterTopology(self, name, list, depth):
+                node = DeviceNode(name, depth)
+                for cname in list:
+                        # avoid recursions
+                        if name == cname:
+                                continue
+                        clist = self.deviceChildrenAllPhases(cname)
+                        cnode = self.masterTopology(cname, clist, depth+1)
+                        node.children.append(cnode)
+                return node
+        def printTopology(self, node):
+                html = ''
+                if node.name:
+                        info = ''
+                        drv = ''
+                        for phase in self.phases:
+                                list = self.dmesg[phase]['list']
+                                if node.name in list:
+                                        s = list[node.name]['start']
+                                        e = list[node.name]['end']
+                                        if list[node.name]['drv']:
+                                                drv = ' {'+list[node.name]['drv']+'}'
+                                        info += ('<li>%s: %.3fms</li>' % (phase, (e-s)*1000))
+                        html += '<li><b>'+node.name+drv+'</b>'
+                        if info:
+                                html += '<ul>'+info+'</ul>'
+                        html += '</li>'
+                if len(node.children) > 0:
+                        html += '<ul>'
+                        for cnode in node.children:
+                                html += self.printTopology(cnode)
+                        html += '</ul>'
+                return html
+        def rootDeviceList(self):
+                # list of devices graphed
+                real = []
+                for phase in self.dmesg:
+                        list = self.dmesg[phase]['list']
+                        for dev in list:
+                                if list[dev]['pid'] >= 0 and dev not in real:
+                                        real.append(dev)
+                # list of top-most root devices
+                rootlist = []
+                for phase in self.dmesg:
+                        list = self.dmesg[phase]['list']
+                        for dev in list:
+                                pdev = list[dev]['par']
+                                pid = list[dev]['pid']
+                                if(pid < 0 or re.match('[0-9]*-[0-9]*\.[0-9]*[\.0-9]*\:[\.0-9]*$', pdev)):
+                                        continue
+                                if pdev and pdev not in real and pdev not in rootlist:
+                                        rootlist.append(pdev)
+                return rootlist
+        def deviceTopology(self):
+                rootlist = self.rootDeviceList()
+                master = self.masterTopology('', rootlist, 0)
+                return self.printTopology(master)
+        def selectTimelineDevices(self, widfmt, tTotal, mindevlen):
+                # only select devices that will actually show up in html
+                self.tdevlist = dict()
+                for phase in self.dmesg:
+                        devlist = []
+                        list = self.dmesg[phase]['list']
+                        for dev in list:
+                                length = (list[dev]['end'] - list[dev]['start']) * 1000
+                                width = widfmt % (((list[dev]['end']-list[dev]['start'])*100)/tTotal)
+                                if width != '0.000000' and length >= mindevlen:
+                                        devlist.append(dev)
+                        self.tdevlist[phase] = devlist
+        def addHorizontalDivider(self, devname, devend):
+                phase = 'suspend_prepare'
+                self.newAction(phase, devname, -2, '', \
+                        self.start, devend, '', ' sec', '')
+                if phase not in self.tdevlist:
+                        self.tdevlist[phase] = []
+                self.tdevlist[phase].append(devname)
+                d = DevItem(0, phase, self.dmesg[phase]['list'][devname])
+                return d
+        def addProcessUsageEvent(self, name, times):
+                # get the start and end times for this process
+                maxC = 0
+                tlast = 0
+                start = -1
+                end = -1
+                for t in sorted(times):
+                        if tlast == 0:
+                                tlast = t
+                                continue
+                        if name in self.pstl[t]:
+                                if start == -1 or tlast < start:
+                                        start = tlast
+                                if end == -1 or t > end:
+                                        end = t
+                        tlast = t
+                if start == -1 or end == -1:
+                        return 0
+                # add a new action for this process and get the object
+                out = self.newActionGlobal(name, start, end, -3)
+                if not out:
+                        return 0
+                phase, devname = out
+                dev = self.dmesg[phase]['list'][devname]
+                # get the cpu exec data
+                tlast = 0
+                clast = 0
+                cpuexec = dict()
+                for t in sorted(times):
+                        if tlast == 0 or t <= start or t > end:
+                                tlast = t
+                                continue
+                        list = self.pstl[t]
+                        c = 0
+                        if name in list:
+                                c = list[name]
+                        if c > maxC:
+                                maxC = c
+                        if c != clast:
+                                key = (tlast, t)
+                                cpuexec[key] = c
+                                tlast = t
+                                clast = c
+                dev['cpuexec'] = cpuexec
+                return maxC
+        def createProcessUsageEvents(self):
+                # get an array of process names
+                proclist = []
+                for t in self.pstl:
+                        pslist = self.pstl[t]
+                        for ps in pslist:
+                                if ps not in proclist:
+                                        proclist.append(ps)
+                # get a list of data points for suspend and resume
+                tsus = []
+                tres = []
+                for t in sorted(self.pstl):
+                        if t < self.tSuspended:
+                                tsus.append(t)
+                        else:
+                                tres.append(t)
+                # process the events for suspend and resume
+                if len(proclist) > 0:
+                        vprint('Process Execution:')
+                for ps in proclist:
+                        c = self.addProcessUsageEvent(ps, tsus)
+                        if c > 0:
+                                vprint('%25s (sus): %d' % (ps, c))
+                        c = self.addProcessUsageEvent(ps, tres)
+                        if c > 0:
+                                vprint('%25s (res): %d' % (ps, c))
+
+# Class: DevFunction
+# Description:
+#        A container for kprobe function data we want in the dev timeline
+class DevFunction:
+        row = 0
+        count = 1
+        def __init__(self, name, args, caller, ret, start, end, u, proc, pid, color):
+                self.name = name
+                self.args = args
+                self.caller = caller
+                self.ret = ret
+                self.time = start
+                self.length = end - start
+                self.end = end
+                self.ubiquitous = u
+                self.proc = proc
+                self.pid = pid
+                self.color = color
+        def title(self):
+                cnt = ''
+                if self.count > 1:
+                        cnt = '(x%d)' % self.count
+                l = '%0.3fms' % (self.length * 1000)
+                if self.ubiquitous:
+                        title = '%s(%s)%s <- %s, %s(%s)' % \
+                                (self.name, self.args, cnt, self.caller, self.ret, l)
+                else:
+                        title = '%s(%s) %s%s(%s)' % (self.name, self.args, self.ret, cnt, l)
+                return title.replace('"', '')
+        def text(self):
+                if self.count > 1:
+                        text = '%s(x%d)' % (self.name, self.count)
+                else:
+                        text = self.name
+                return text
+        def repeat(self, tgt):
+                # is the tgt call just a repeat of this call (e.g. are we in a loop)
+                dt = self.time - tgt.end
+                # only combine calls if -all- attributes are identical
+                if tgt.caller == self.caller and \
+                        tgt.name == self.name and tgt.args == self.args and \
+                        tgt.proc == self.proc and tgt.pid == self.pid and \
+                        tgt.ret == self.ret and dt >= 0 and \
+                        dt <= sysvals.callloopmaxgap and \
+                        self.length < sysvals.callloopmaxlen:
+                        return True
+                return False
+
+# Class: FTraceLine
+# Description:
+#        A container for a single line of ftrace data. There are six basic types:
+#                callgraph line:
+#                         call: "  dpm_run_callback() {"
+#                       return: "  }"
+#                         leaf: " dpm_run_callback();"
+#                trace event:
+#                        tracing_mark_write: SUSPEND START or RESUME COMPLETE
+#                        suspend_resume: phase or custom exec block data
+#                        device_pm_callback: device callback info
+class FTraceLine:
+        time = 0.0
+        length = 0.0
+        fcall = False
+        freturn = False
+        fevent = False
+        fkprobe = False
+        depth = 0
+        name = ''
+        type = ''
+        def __init__(self, t, m='', d=''):
+                self.time = float(t)
+                if not m and not d:
+                        return
+                # is this a trace event
+                if(d == 'traceevent' or re.match('^ *\/\* *(?P<msg>.*) \*\/ *$', m)):
+                        if(d == 'traceevent'):
+                                # nop format trace event
+                                msg = m
+                        else:
+                                # function_graph format trace event
+                                em = re.match('^ *\/\* *(?P<msg>.*) \*\/ *$', m)
+                                msg = em.group('msg')
+
+                        emm = re.match('^(?P<call>.*?): (?P<msg>.*)', msg)
+                        if(emm):
+                                self.name = emm.group('msg')
+                                self.type = emm.group('call')
+                        else:
+                                self.name = msg
+                        km = re.match('^(?P<n>.*)_cal$', self.type)
+                        if km:
+                                self.fcall = True
+                                self.fkprobe = True
+                                self.type = km.group('n')
+                                return
+                        km = re.match('^(?P<n>.*)_ret$', self.type)
+                        if km:
+                                self.freturn = True
+                                self.fkprobe = True
+                                self.type = km.group('n')
+                                return
+                        self.fevent = True
+                        return
+                # convert the duration to seconds
+                if(d):
+                        self.length = float(d)/1000000
+                # the indentation determines the depth
+                match = re.match('^(?P<d> *)(?P<o>.*)$', m)
+                if(not match):
+                        return
+                self.depth = self.getDepth(match.group('d'))
+                m = match.group('o')
+                # function return
+                if(m[0] == '}'):
+                        self.freturn = True
+                        if(len(m) > 1):
+                                # includes comment with function name
+                                match = re.match('^} *\/\* *(?P<n>.*) *\*\/$', m)
+                                if(match):
+                                        self.name = match.group('n').strip()
+                # function call
+                else:
+                        self.fcall = True
+                        # function call with children
+                        if(m[-1] == '{'):
+                                match = re.match('^(?P<n>.*) *\(.*', m)
+                                if(match):
+                                        self.name = match.group('n').strip()
+                        # function call with no children (leaf)
+                        elif(m[-1] == ';'):
+                                self.freturn = True
+                                match = re.match('^(?P<n>.*) *\(.*', m)
+                                if(match):
+                                        self.name = match.group('n').strip()
+                        # something else (possibly a trace marker)
+                        else:
+                                self.name = m
+        def getDepth(self, str):
+                return len(str)/2
+        def debugPrint(self, dev=''):
+                if(self.freturn and self.fcall):
+                        print('%s -- %f (%02d): %s(); (%.3f us)' % (dev, self.time, \
+                                self.depth, self.name, self.length*1000000))
+                elif(self.freturn):
+                        print('%s -- %f (%02d): %s} (%.3f us)' % (dev, self.time, \
+                                self.depth, self.name, self.length*1000000))
+                else:
+                        print('%s -- %f (%02d): %s() { (%.3f us)' % (dev, self.time, \
+                                self.depth, self.name, self.length*1000000))
+        def startMarker(self):
+                # Is this the starting line of a suspend?
+                if not self.fevent:
+                        return False
+                if sysvals.usetracemarkers:
+                        if(self.name == 'SUSPEND START'):
+                                return True
+                        return False
+                else:
+                        if(self.type == 'suspend_resume' and
+                                re.match('suspend_enter\[.*\] begin', self.name)):
+                                return True
+                        return False
+        def endMarker(self):
+                # Is this the ending line of a resume?
+                if not self.fevent:
+                        return False
+                if sysvals.usetracemarkers:
+                        if(self.name == 'RESUME COMPLETE'):
+                                return True
+                        return False
+                else:
+                        if(self.type == 'suspend_resume' and
+                                re.match('thaw_processes\[.*\] end', self.name)):
+                                return True
+                        return False
+
+# Class: FTraceCallGraph
+# Description:
+#        A container for the ftrace callgraph of a single recursive function.
+#        This can be a dpm_run_callback, dpm_prepare, or dpm_complete callgraph
+#        Each instance is tied to a single device in a single phase, and is
+#        comprised of an ordered list of FTraceLine objects
+class FTraceCallGraph:
+        id = ''
+        start = -1.0
+        end = -1.0
+        list = []
+        invalid = False
+        depth = 0
+        pid = 0
+        name = ''
+        def __init__(self, pid):
+                self.start = -1.0
+                self.end = -1.0
+                self.list = []
+                self.depth = 0
+                self.pid = pid
+        def addLine(self, line, debug=False):
+                # if this is already invalid, just leave
+                if(self.invalid):
+                        return False
+                # invalidate on too much data or bad depth
+                if(len(self.list) >= 1000000 or self.depth < 0):
+                        self.invalidate(line)
+                        return False
+                # compare current depth with this lines pre-call depth
+                prelinedep = line.depth
+                if(line.freturn and not line.fcall):
+                        prelinedep += 1
+                last = 0
+                lasttime = line.time
+                virtualfname = 'execution_misalignment'
+                if len(self.list) > 0:
+                        last = self.list[-1]
+                        lasttime = last.time
+                # handle low misalignments by inserting returns
+                if prelinedep < self.depth:
+                        if debug and last:
+                                print '-------- task %d --------' % self.pid
+                                last.debugPrint()
+                        idx = 0
+                        # add return calls to get the depth down
+                        while prelinedep < self.depth:
+                                if debug:
+                                        print 'MISALIGN LOW (add returns): C%d - eC%d' % (self.depth, prelinedep)
+                                self.depth -= 1
+                                if idx == 0 and last and last.fcall and not last.freturn:
+                                        # special case, turn last call into a leaf
+                                        last.depth = self.depth
+                                        last.freturn = True
+                                        last.length = line.time - last.time
+                                        if debug:
+                                                last.debugPrint()
+                                else:
+                                        vline = FTraceLine(lasttime)
+                                        vline.depth = self.depth
+                                        vline.name = virtualfname
+                                        vline.freturn = True
+                                        self.list.append(vline)
+                                        if debug:
+                                                vline.debugPrint()
+                                idx += 1
+                        if debug:
+                                line.debugPrint()
+                                print ''
+                # handle high misalignments by inserting calls
+                elif prelinedep > self.depth:
+                        if debug and last:
+                                print '-------- task %d --------' % self.pid
+                                last.debugPrint()
+                        idx = 0
+                        # add calls to get the depth up
+                        while prelinedep > self.depth:
+                                if debug:
+                                        print 'MISALIGN HIGH (add calls): C%d - eC%d' % (self.depth, prelinedep)
+                                if idx == 0 and line.freturn and not line.fcall:
+                                        # special case, turn this return into a leaf
+                                        line.fcall = True
+                                        prelinedep -= 1
+                                else:
+                                        vline = FTraceLine(lasttime)
+                                        vline.depth = self.depth
+                                        vline.name = virtualfname
+                                        vline.fcall = True
+                                        if debug:
+                                                vline.debugPrint()
+                                        self.list.append(vline)
+                                        self.depth += 1
+                                        if not last:
+                                                self.start = vline.time
+                                idx += 1
+                        if debug:
+                                line.debugPrint()
+                                print ''
+                # process the call and set the new depth
+                if(line.fcall and not line.freturn):
+                        self.depth += 1
+                elif(line.freturn and not line.fcall):
+                        self.depth -= 1
+                if len(self.list) < 1:
+                        self.start = line.time
+                self.list.append(line)
+                if(line.depth == 0 and line.freturn):
+                        if(self.start < 0):
+                                self.start = line.time
+                        self.end = line.time
+                        if line.fcall:
+                                self.end += line.length
+                        if self.list[0].name == virtualfname:
+                                self.invalid = True
+                        return True
+                return False
+        def invalidate(self, line):
+                if(len(self.list) > 0):
+                        first = self.list[0]
+                        self.list = []
+                        self.list.append(first)
+                self.invalid = True
+                id = 'task %s' % (self.pid)
+                window = '(%f - %f)' % (self.start, line.time)
+                if(self.depth < 0):
+                        vprint('Too much data for '+id+\
+                                ' (buffer overflow), ignoring this callback')
+                else:
+                        vprint('Too much data for '+id+\
+                                ' '+window+', ignoring this callback')
+        def slice(self, t0, tN):
+                minicg = FTraceCallGraph(0)
+                count = -1
+                firstdepth = 0
+                for l in self.list:
+                        if(l.time < t0 or l.time > tN):
+                                continue
+                        if(count < 0):
+                                if(not l.fcall or l.name == 'dev_driver_string'):
+                                        continue
+                                firstdepth = l.depth
+                                count = 0
+                        l.depth -= firstdepth
+                        minicg.addLine(l)
+                        if((count == 0 and l.freturn and l.fcall) or
+                                (count > 0 and l.depth <= 0)):
+                                break
+                        count += 1
+                return minicg
+        def repair(self, enddepth):
+                # bring the depth back to 0 with additional returns
+                fixed = False
+                last = self.list[-1]
+                for i in reversed(range(enddepth)):
+                        t = FTraceLine(last.time)
+                        t.depth = i
+                        t.freturn = True
+                        fixed = self.addLine(t)
+                        if fixed:
+                                self.end = last.time
+                                return True
+                return False
+        def postProcess(self, debug=False):
+                if len(self.list) > 0:
+                        self.name = self.list[0].name
+                stack = dict()
+                cnt = 0
+                last = 0
+                for l in self.list:
+                        # ftrace bug: reported duration is not reliable
+                        # check each leaf and clip it at max possible length
+                        if(last and last.freturn and last.fcall):
+                                if last.length > l.time - last.time:
+                                        last.length = l.time - last.time
+                        if(l.fcall and not l.freturn):
+                                stack[l.depth] = l
+                                cnt += 1
+                        elif(l.freturn and not l.fcall):
+                                if(l.depth not in stack):
+                                        if debug:
+                                                print 'Post Process Error: Depth missing'
+                                                l.debugPrint()
+                                        return False
+                                # calculate call length from call/return lines
+                                stack[l.depth].length = l.time - stack[l.depth].time
+                                stack.pop(l.depth)
+                                l.length = 0
+                                cnt -= 1
+                        last = l
+                if(cnt == 0):
+                        # trace caught the whole call tree
+                        return True
+                elif(cnt < 0):
+                        if debug:
+                                print 'Post Process Error: Depth is less than 0'
+                        return False
+                # trace ended before call tree finished
+                return self.repair(cnt)
+        def deviceMatch(self, pid, data):
+                found = False
+                # add the callgraph data to the device hierarchy
+                borderphase = {
+                        'dpm_prepare': 'suspend_prepare',
+                        'dpm_complete': 'resume_complete'
+                }
+                if(self.name in borderphase):
+                        p = borderphase[self.name]
+                        list = data.dmesg[p]['list']
+                        for devname in list:
+                                dev = list[devname]
+                                if(pid == dev['pid'] and
+                                        self.start <= dev['start'] and
+                                        self.end >= dev['end']):
+                                        dev['ftrace'] = self.slice(dev['start'], dev['end'])
+                                        found = True
+                        return found
+                for p in data.phases:
+                        if(data.dmesg[p]['start'] <= self.start and
+                                self.start <= data.dmesg[p]['end']):
+                                list = data.dmesg[p]['list']
+                                for devname in list:
+                                        dev = list[devname]
+                                        if(pid == dev['pid'] and
+                                                self.start <= dev['start'] and
+                                                self.end >= dev['end']):
+                                                dev['ftrace'] = self
+                                                found = True
+                                                break
+                                break
+                return found
+        def newActionFromFunction(self, data):
+                name = self.name
+                if name in ['dpm_run_callback', 'dpm_prepare', 'dpm_complete']:
+                        return
+                fs = self.start
+                fe = self.end
+                if fs < data.start or fe > data.end:
+                        return
+                phase = ''
+                for p in data.phases:
+                        if(data.dmesg[p]['start'] <= self.start and
+                                self.start < data.dmesg[p]['end']):
+                                phase = p
+                                break
+                if not phase:
+                        return
+                out = data.newActionGlobal(name, fs, fe, -2)
+                if out:
+                        phase, myname = out
+                        data.dmesg[phase]['list'][myname]['ftrace'] = self
+        def debugPrint(self):
+                print('[%f - %f] %s (%d)') % (self.start, self.end, self.name, self.pid)
+                for l in self.list:
+                        if(l.freturn and l.fcall):
+                                print('%f (%02d): %s(); (%.3f us)' % (l.time, \
+                                        l.depth, l.name, l.length*1000000))
+                        elif(l.freturn):
+                                print('%f (%02d): %s} (%.3f us)' % (l.time, \
+                                        l.depth, l.name, l.length*1000000))
+                        else:
+                                print('%f (%02d): %s() { (%.3f us)' % (l.time, \
+                                        l.depth, l.name, l.length*1000000))
+                print(' ')
+
+class DevItem:
+        def __init__(self, test, phase, dev):
+                self.test = test
+                self.phase = phase
+                self.dev = dev
+        def isa(self, cls):
+                if 'htmlclass' in self.dev and cls in self.dev['htmlclass']:
+                        return True
+                return False
+
+# Class: Timeline
+# Description:
+#        A container for a device timeline which calculates
+#        all the html properties to display it correctly
+class Timeline:
+        html = ''
+        height = 0      # total timeline height
+        scaleH = 20     # timescale (top) row height
+        rowH = 30       # device row height
+        bodyH = 0       # body height
+        rows = 0        # total timeline rows
+        rowlines = dict()
+        rowheight = dict()
+        html_tblock = '<div id="block{0}" class="tblock" style="left:{1}%;width:{2}%;"><div class="tback" style="height:{3}px"></div>\n'
+        html_device = '<div id="{0}" title="{1}" class="thread{7}" style="left:{2}%;top:{3}px;height:{4}px;width:{5}%;{8}">{6}</div>\n'
+        html_phase = '<div class="phase" style="left:{0}%;width:{1}%;top:{2}px;height:{3}px;background:{4}">{5}</div>\n'
+        html_phaselet = '<div id="{0}" class="phaselet" style="left:{1}%;width:{2}%;background:{3}"></div>\n'
+        def __init__(self, rowheight, scaleheight):
+                self.rowH = rowheight
+                self.scaleH = scaleheight
+                self.html = ''
+        def createHeader(self, sv, suppress=''):
+                if(not sv.stamp['time']):
+                        return
+                self.html += '<div class="version"><a href="https://01.org/suspendresume">%s v%s</a></div>' \
+                        % (sv.title, sv.version)
+                if sv.logmsg and 'log' not in suppress:
+                        self.html += '<button id="showtest" class="logbtn">log</button>'
+                if sv.addlogs and 'dmesg' not in suppress:
+                        self.html += '<button id="showdmesg" class="logbtn">dmesg</button>'
+                if sv.addlogs and sv.ftracefile and 'ftrace' not in suppress:
+                        self.html += '<button id="showftrace" class="logbtn">ftrace</button>'
+                headline_stamp = '<div class="stamp">{0} {1} {2} {3}</div>\n'
+                self.html += headline_stamp.format(sv.stamp['host'], sv.stamp['kernel'],
+                        sv.stamp['mode'], sv.stamp['time'])
+        # Function: getDeviceRows
+        # Description:
+        #    determine how may rows the device funcs will take
+        # Arguments:
+        #        rawlist: the list of devices/actions for a single phase
+        # Output:
+        #        The total number of rows needed to display this phase of the timeline
+        def getDeviceRows(self, rawlist):
+                # clear all rows and set them to undefined
+                sortdict = dict()
+                for item in rawlist:
+                        item.row = -1
+                        sortdict[item] = item.length
+                sortlist = sorted(sortdict, key=sortdict.get, reverse=True)
+                remaining = len(sortlist)
+                rowdata = dict()
+                row = 1
+                # try to pack each row with as many ranges as possible
+                while(remaining > 0):
+                        if(row not in rowdata):
+                                rowdata[row] = []
+                        for i in sortlist:
+                                if(i.row >= 0):
+                                        continue
+                                s = i.time
+                                e = i.time + i.length
+                                valid = True
+                                for ritem in rowdata[row]:
+                                        rs = ritem.time
+                                        re = ritem.time + ritem.length
+                                        if(not (((s <= rs) and (e <= rs)) or
+                                                ((s >= re) and (e >= re)))):
+                                                valid = False
+                                                break
+                                if(valid):
+                                        rowdata[row].append(i)
+                                        i.row = row
+                                        remaining -= 1
+                        row += 1
+                return row
+        # Function: getPhaseRows
+        # Description:
+        #        Organize the timeline entries into the smallest
+        #        number of rows possible, with no entry overlapping
+        # Arguments:
+        #        devlist: the list of devices/actions in a group of contiguous phases
+        # Output:
+        #        The total number of rows needed to display this phase of the timeline
+        def getPhaseRows(self, devlist, row=0):
+                # clear all rows and set them to undefined
+                remaining = len(devlist)
+                rowdata = dict()
+                sortdict = dict()
+                myphases = []
+                # initialize all device rows to -1 and calculate devrows
+                for item in devlist:
+                        dev = item.dev
+                        tp = (item.test, item.phase)
+                        if tp not in myphases:
+                                myphases.append(tp)
+                        dev['row'] = -1
+                        # sort by length 1st, then name 2nd
+                        sortdict[item] = (float(dev['end']) - float(dev['start']), item.dev['name'])
+                        if 'src' in dev:
+                                dev['devrows'] = self.getDeviceRows(dev['src'])
+                # sort the devlist by length so that large items graph on top
+                sortlist = sorted(sortdict, key=sortdict.get, reverse=True)
+                orderedlist = []
+                for item in sortlist:
+                        if item.dev['pid'] == -2:
+                                orderedlist.append(item)
+                for item in sortlist:
+                        if item not in orderedlist:
+                                orderedlist.append(item)
+                # try to pack each row with as many devices as possible
+                while(remaining > 0):
+                        rowheight = 1
+                        if(row not in rowdata):
+                                rowdata[row] = []
+                        for item in orderedlist:
+                                dev = item.dev
+                                if(dev['row'] < 0):
+                                        s = dev['start']
+                                        e = dev['end']
+                                        valid = True
+                                        for ritem in rowdata[row]:
+                                                rs = ritem.dev['start']
+                                                re = ritem.dev['end']
+                                                if(not (((s <= rs) and (e <= rs)) or
+                                                        ((s >= re) and (e >= re)))):
+                                                        valid = False
+                                                        break
+                                        if(valid):
+                                                rowdata[row].append(item)
+                                                dev['row'] = row
+                                                remaining -= 1
+                                                if 'devrows' in dev and dev['devrows'] > rowheight:
+                                                        rowheight = dev['devrows']
+                        for t, p in myphases:
+                                if t not in self.rowlines or t not in self.rowheight:
+                                        self.rowlines[t] = dict()
+                                        self.rowheight[t] = dict()
+                                if p not in self.rowlines[t] or p not in self.rowheight[t]:
+                                        self.rowlines[t][p] = dict()
+                                        self.rowheight[t][p] = dict()
+                                rh = self.rowH
+                                # section headers should use a different row height
+                                if len(rowdata[row]) == 1 and \
+                                        'htmlclass' in rowdata[row][0].dev and \
+                                        'sec' in rowdata[row][0].dev['htmlclass']:
+                                        rh = 15
+                                self.rowlines[t][p][row] = rowheight
+                                self.rowheight[t][p][row] = rowheight * rh
+                        row += 1
+                if(row > self.rows):
+                        self.rows = int(row)
+                return row
+        def phaseRowHeight(self, test, phase, row):
+                return self.rowheight[test][phase][row]
+        def phaseRowTop(self, test, phase, row):
+                top = 0
+                for i in sorted(self.rowheight[test][phase]):
+                        if i >= row:
+                                break
+                        top += self.rowheight[test][phase][i]
+                return top
+        def calcTotalRows(self):
+                # Calculate the heights and offsets for the header and rows
+                maxrows = 0
+                standardphases = []
+                for t in self.rowlines:
+                        for p in self.rowlines[t]:
+                                total = 0
+                                for i in sorted(self.rowlines[t][p]):
+                                        total += self.rowlines[t][p][i]
+                                if total > maxrows:
+                                        maxrows = total
+                                if total == len(self.rowlines[t][p]):
+                                        standardphases.append((t, p))
+                self.height = self.scaleH + (maxrows*self.rowH)
+                self.bodyH = self.height - self.scaleH
+                # if there is 1 line per row, draw them the standard way
+                for t, p in standardphases:
+                        for i in sorted(self.rowheight[t][p]):
+                                self.rowheight[t][p][i] = self.bodyH/len(self.rowlines[t][p])
+        def createZoomBox(self, mode='command', testcount=1):
+                # Create bounding box, add buttons
+                html_zoombox = '<center><button id="zoomin">ZOOM IN +</button><button id="zoomout">ZOOM OUT -</button><button id="zoomdef">ZOOM 1:1</button></center>\n'
+                html_timeline = '<div id="dmesgzoombox" class="zoombox">\n<div id="{0}" class="timeline" style="height:{1}px">\n'
+                html_devlist1 = '<button id="devlist1" class="devlist" style="float:left;">Device Detail{0}</button>'
+                html_devlist2 = '<button id="devlist2" class="devlist" style="float:right;">Device Detail2</button>\n'
+                if mode != 'command':
+                        if testcount > 1:
+                                self.html += html_devlist2
+                                self.html += html_devlist1.format('1')
+                        else:
+                                self.html += html_devlist1.format('')
+                self.html += html_zoombox
+                self.html += html_timeline.format('dmesg', self.height)
+        # Function: createTimeScale
+        # Description:
+        #        Create the timescale for a timeline block
+        # Arguments:
+        #        m0: start time (mode begin)
+        #        mMax: end time (mode end)
+        #        tTotal: total timeline time
+        #        mode: suspend or resume
+        # Output:
+        #        The html code needed to display the time scale
+        def createTimeScale(self, m0, mMax, tTotal, mode):
+                timescale = '<div class="t" style="right:{0}%">{1}</div>\n'
+                rline = '<div class="t" style="left:0;border-left:1px solid black;border-right:0;">{0}</div>\n'
+                output = '<div class="timescale">\n'
+                # set scale for timeline
+                mTotal = mMax - m0
+                tS = 0.1
+                if(tTotal <= 0):
+                        return output+'</div>\n'
+                if(tTotal > 4):
+                        tS = 1
+                divTotal = int(mTotal/tS) + 1
+                divEdge = (mTotal - tS*(divTotal-1))*100/mTotal
+                for i in range(divTotal):
+                        htmlline = ''
+                        if(mode == 'suspend'):
+                                pos = '%0.3f' % (100 - ((float(i)*tS*100)/mTotal) - divEdge)
+                                val = '%0.fms' % (float(i-divTotal+1)*tS*1000)
+                                if(i == divTotal - 1):
+                                        val = mode
+                                htmlline = timescale.format(pos, val)
+                        else:
+                                pos = '%0.3f' % (100 - ((float(i)*tS*100)/mTotal))
+                                val = '%0.fms' % (float(i)*tS*1000)
+                                htmlline = timescale.format(pos, val)
+                                if(i == 0):
+                                        htmlline = rline.format(mode)
+                        output += htmlline
+                self.html += output+'</div>\n'
+
+# Class: TestProps
+# Description:
+#        A list of values describing the properties of these test runs
+class TestProps:
+        stamp = ''
+        S0i3 = False
+        fwdata = []
+        ftrace_line_fmt_fg = \
+                '^ *(?P<time>[0-9\.]*) *\| *(?P<cpu>[0-9]*)\)'+\
+                ' *(?P<proc>.*)-(?P<pid>[0-9]*) *\|'+\
+                '[ +!#\*@$]*(?P<dur>[0-9\.]*) .*\|  (?P<msg>.*)'
+        ftrace_line_fmt_nop = \
+                ' *(?P<proc>.*)-(?P<pid>[0-9]*) *\[(?P<cpu>[0-9]*)\] *'+\
+                '(?P<flags>.{4}) *(?P<time>[0-9\.]*): *'+\
+                '(?P<msg>.*)'
+        ftrace_line_fmt = ftrace_line_fmt_nop
+        cgformat = False
+        data = 0
+        ktemp = dict()
+        def __init__(self):
+                self.ktemp = dict()
+        def setTracerType(self, tracer):
+                if(tracer == 'function_graph'):
+                        self.cgformat = True
+                        self.ftrace_line_fmt = self.ftrace_line_fmt_fg
+                elif(tracer == 'nop'):
+                        self.ftrace_line_fmt = self.ftrace_line_fmt_nop
+                else:
+                        doError('Invalid tracer format: [%s]' % tracer)
+
+# Class: TestRun
+# Description:
+#        A container for a suspend/resume test run. This is necessary as
+#        there could be more than one, and they need to be separate.
+class TestRun:
+        ftemp = dict()
+        ttemp = dict()
+        data = 0
+        def __init__(self, dataobj):
+                self.data = dataobj
+                self.ftemp = dict()
+                self.ttemp = dict()
+
+class ProcessMonitor:
+        proclist = dict()
+        running = False
+        def procstat(self):
+                c = ['cat /proc/[1-9]*/stat 2>/dev/null']
+                process = Popen(c, shell=True, stdout=PIPE)
+                running = dict()
+                for line in process.stdout:
+                        data = line.split()
+                        pid = data[0]
+                        name = re.sub('[()]', '', data[1])
+                        user = int(data[13])
+                        kern = int(data[14])
+                        kjiff = ujiff = 0
+                        if pid not in self.proclist:
+                                self.proclist[pid] = {'name' : name, 'user' : user, 'kern' : kern}
+                        else:
+                                val = self.proclist[pid]
+                                ujiff = user - val['user']
+                                kjiff = kern - val['kern']
+                                val['user'] = user
+                                val['kern'] = kern
+                        if ujiff > 0 or kjiff > 0:
+                                running[pid] = ujiff + kjiff
+                process.wait()
+                out = ''
+                for pid in running:
+                        jiffies = running[pid]
+                        val = self.proclist[pid]
+                        if out:
+                                out += ','
+                        out += '%s-%s %d' % (val['name'], pid, jiffies)
+                return 'ps - '+out
+        def processMonitor(self, tid):
+                while self.running:
+                        out = self.procstat()
+                        if out:
+                                sysvals.fsetVal(out, 'trace_marker')
+        def start(self):
+                self.thread = Thread(target=self.processMonitor, args=(0,))
+                self.running = True
+                self.thread.start()
+        def stop(self):
+                self.running = False
+
+# ----------------- FUNCTIONS --------------------
+
+# Function: vprint
+# Description:
+#        verbose print (prints only with -verbose option)
+# Arguments:
+#        msg: the debug/log message to print
+def vprint(msg):
+        sysvals.logmsg += msg+'\n'
+        if(sysvals.verbose):
+                print(msg)
+
+# Function: parseStamp
+# Description:
+#        Pull in the stamp comment line from the data file(s),
+#        create the stamp, and add it to the global sysvals object
+# Arguments:
+#        m: the valid re.match output for the stamp line
+def parseStamp(line, data):
+        m = re.match(sysvals.stampfmt, line)
+        data.stamp = {'time': '', 'host': '', 'mode': ''}
+        dt = datetime(int(m.group('y'))+2000, int(m.group('m')),
+                int(m.group('d')), int(m.group('H')), int(m.group('M')),
+                int(m.group('S')))
+        data.stamp['time'] = dt.strftime('%B %d %Y, %I:%M:%S %p')
+        data.stamp['host'] = m.group('host')
+        data.stamp['mode'] = m.group('mode')
+        data.stamp['kernel'] = m.group('kernel')
+        sysvals.hostname = data.stamp['host']
+        sysvals.suspendmode = data.stamp['mode']
+        if sysvals.suspendmode == 'command' and sysvals.ftracefile != '':
+                modes = ['on', 'freeze', 'standby', 'mem']
+                out = Popen(['grep', 'suspend_enter', sysvals.ftracefile],
+                        stderr=PIPE, stdout=PIPE).stdout.read()
+                m = re.match('.* suspend_enter\[(?P<mode>.*)\]', out)
+                if m and m.group('mode') in ['1', '2', '3']:
+                        sysvals.suspendmode = modes[int(m.group('mode'))]
+                        data.stamp['mode'] = sysvals.suspendmode
+        if not sysvals.stamp:
+                sysvals.stamp = data.stamp
+
+# Function: doesTraceLogHaveTraceEvents
+# Description:
+#        Quickly determine if the ftrace log has some or all of the trace events
+#        required for primary parsing. Set the usetraceevents and/or
+#        usetraceeventsonly flags in the global sysvals object
+def doesTraceLogHaveTraceEvents():
+        # check for kprobes
+        sysvals.usekprobes = False
+        out = call('grep -q "_cal: (" '+sysvals.ftracefile, shell=True)
+        if(out == 0):
+                sysvals.usekprobes = True
+        # check for callgraph data on trace event blocks
+        out = call('grep -q "_cpu_down()" '+sysvals.ftracefile, shell=True)
+        if(out == 0):
+                sysvals.usekprobes = True
+        out = Popen(['head', '-1', sysvals.ftracefile],
+                stderr=PIPE, stdout=PIPE).stdout.read().replace('\n', '')
+        m = re.match(sysvals.stampfmt, out)
+        if m and m.group('mode') == 'command':
+                sysvals.usetraceeventsonly = True
+                sysvals.usetraceevents = True
+                return
+        # figure out what level of trace events are supported
+        sysvals.usetraceeventsonly = True
+        sysvals.usetraceevents = False
+        for e in sysvals.traceevents:
+                out = call('grep -q "'+e+': " '+sysvals.ftracefile, shell=True)
+                if(out != 0):
+                        sysvals.usetraceeventsonly = False
+                if(e == 'suspend_resume' and out == 0):
+                        sysvals.usetraceevents = True
+        # determine is this log is properly formatted
+        for e in ['SUSPEND START', 'RESUME COMPLETE']:
+                out = call('grep -q "'+e+'" '+sysvals.ftracefile, shell=True)
+                if(out != 0):
+                        sysvals.usetracemarkers = False
+
+# Function: appendIncompleteTraceLog
+# Description:
+#        [deprecated for kernel 3.15 or newer]
+#        Legacy support of ftrace outputs that lack the device_pm_callback
+#        and/or suspend_resume trace events. The primary data should be
+#        taken from dmesg, and this ftrace is used only for callgraph data
+#        or custom actions in the timeline. The data is appended to the Data
+#        objects provided.
+# Arguments:
+#        testruns: the array of Data objects obtained from parseKernelLog
+def appendIncompleteTraceLog(testruns):
+        # create TestRun vessels for ftrace parsing
+        testcnt = len(testruns)
+        testidx = 0
+        testrun = []
+        for data in testruns:
+                testrun.append(TestRun(data))
+
+        # extract the callgraph and traceevent data
+        vprint('Analyzing the ftrace data...')
+        tp = TestProps()
+        tf = open(sysvals.ftracefile, 'r')
+        data = 0
+        for line in tf:
+                # remove any latent carriage returns
+                line = line.replace('\r\n', '')
+                # grab the time stamp
+                m = re.match(sysvals.stampfmt, line)
+                if(m):
+                        tp.stamp = line
+                        continue
+                # determine the trace data type (required for further parsing)
+                m = re.match(sysvals.tracertypefmt, line)
+                if(m):
+                        tp.setTracerType(m.group('t'))
+                        continue
+                # device properties line
+                if(re.match(sysvals.devpropfmt, line)):
+                        devProps(line)
+                        continue
+                # parse only valid lines, if this is not one move on
+                m = re.match(tp.ftrace_line_fmt, line)
+                if(not m):
+                        continue
+                # gather the basic message data from the line
+                m_time = m.group('time')
+                m_pid = m.group('pid')
+                m_msg = m.group('msg')
+                if(tp.cgformat):
+                        m_param3 = m.group('dur')
+                else:
+                        m_param3 = 'traceevent'
+                if(m_time and m_pid and m_msg):
+                        t = FTraceLine(m_time, m_msg, m_param3)
+                        pid = int(m_pid)
+                else:
+                        continue
+                # the line should be a call, return, or event
+                if(not t.fcall and not t.freturn and not t.fevent):
+                        continue
+                # look for the suspend start marker
+                if(t.startMarker()):
+                        data = testrun[testidx].data
+                        parseStamp(tp.stamp, data)
+                        data.setStart(t.time)
+                        continue
+                if(not data):
+                        continue
+                # find the end of resume
+                if(t.endMarker()):
+                        data.setEnd(t.time)
+                        testidx += 1
+                        if(testidx >= testcnt):
+                                break
+                        continue
+                # trace event processing
+                if(t.fevent):
+                        # general trace events have two types, begin and end
+                        if(re.match('(?P<name>.*) begin$', t.name)):
+                                isbegin = True
+                        elif(re.match('(?P<name>.*) end$', t.name)):
+                                isbegin = False
+                        else:
+                                continue
+                        m = re.match('(?P<name>.*)\[(?P<val>[0-9]*)\] .*', t.name)
+                        if(m):
+                                val = m.group('val')
+                                if val == '0':
+                                        name = m.group('name')
+                                else:
+                                        name = m.group('name')+'['+val+']'
+                        else:
+                                m = re.match('(?P<name>.*) .*', t.name)
+                                name = m.group('name')
+                        # special processing for trace events
+                        if re.match('dpm_prepare\[.*', name):
+                                continue
+                        elif re.match('machine_suspend.*', name):
+                                continue
+                        elif re.match('suspend_enter\[.*', name):
+                                if(not isbegin):
+                                        data.dmesg['suspend_prepare']['end'] = t.time
+                                continue
+                        elif re.match('dpm_suspend\[.*', name):
+                                if(not isbegin):
+                                        data.dmesg['suspend']['end'] = t.time
+                                continue
+                        elif re.match('dpm_suspend_late\[.*', name):
+                                if(isbegin):
+                                        data.dmesg['suspend_late']['start'] = t.time
+                                else:
+                                        data.dmesg['suspend_late']['end'] = t.time
+                                continue
+                        elif re.match('dpm_suspend_noirq\[.*', name):
+                                if(isbegin):
+                                        data.dmesg['suspend_noirq']['start'] = t.time
+                                else:
+                                        data.dmesg['suspend_noirq']['end'] = t.time
+                                continue
+                        elif re.match('dpm_resume_noirq\[.*', name):
+                                if(isbegin):
+                                        data.dmesg['resume_machine']['end'] = t.time
+                                        data.dmesg['resume_noirq']['start'] = t.time
+                                else:
+                                        data.dmesg['resume_noirq']['end'] = t.time
+                                continue
+                        elif re.match('dpm_resume_early\[.*', name):
+                                if(isbegin):
+                                        data.dmesg['resume_early']['start'] = t.time
+                                else:
+                                        data.dmesg['resume_early']['end'] = t.time
+                                continue
+                        elif re.match('dpm_resume\[.*', name):
+                                if(isbegin):
+                                        data.dmesg['resume']['start'] = t.time
+                                else:
+                                        data.dmesg['resume']['end'] = t.time
+                                continue
+                        elif re.match('dpm_complete\[.*', name):
+                                if(isbegin):
+                                        data.dmesg['resume_complete']['start'] = t.time
+                                else:
+                                        data.dmesg['resume_complete']['end'] = t.time
+                                continue
+                        # skip trace events inside devices calls
+                        if(not data.isTraceEventOutsideDeviceCalls(pid, t.time)):
+                                continue
+                        # global events (outside device calls) are simply graphed
+                        if(isbegin):
+                                # store each trace event in ttemp
+                                if(name not in testrun[testidx].ttemp):
+                                        testrun[testidx].ttemp[name] = []
+                                testrun[testidx].ttemp[name].append(\
+                                        {'begin': t.time, 'end': t.time})
+                        else:
+                                # finish off matching trace event in ttemp
+                                if(name in testrun[testidx].ttemp):
+                                        testrun[testidx].ttemp[name][-1]['end'] = t.time
+                # call/return processing
+                elif sysvals.usecallgraph:
+                        # create a callgraph object for the data
+                        if(pid not in testrun[testidx].ftemp):
+                                testrun[testidx].ftemp[pid] = []
+                                testrun[testidx].ftemp[pid].append(FTraceCallGraph(pid))
+                        # when the call is finished, see which device matches it
+                        cg = testrun[testidx].ftemp[pid][-1]
+                        if(cg.addLine(t)):
+                                testrun[testidx].ftemp[pid].append(FTraceCallGraph(pid))
+        tf.close()
+
+        for test in testrun:
+                # add the traceevent data to the device hierarchy
+                if(sysvals.usetraceevents):
+                        for name in test.ttemp:
+                                for event in test.ttemp[name]:
+                                        test.data.newActionGlobal(name, event['begin'], event['end'])
+
+                # add the callgraph data to the device hierarchy
+                for pid in test.ftemp:
+                        for cg in test.ftemp[pid]:
+                                if len(cg.list) < 1 or cg.invalid:
+                                        continue
+                                if(not cg.postProcess()):
+                                        id = 'task %s cpu %s' % (pid, m.group('cpu'))
+                                        vprint('Sanity check failed for '+\
+                                                id+', ignoring this callback')
+                                        continue
+                                callstart = cg.start
+                                callend = cg.end
+                                for p in test.data.phases:
+                                        if(test.data.dmesg[p]['start'] <= callstart and
+                                                callstart <= test.data.dmesg[p]['end']):
+                                                list = test.data.dmesg[p]['list']
+                                                for devname in list:
+                                                        dev = list[devname]
+                                                        if(pid == dev['pid'] and
+                                                                callstart <= dev['start'] and
+                                                                callend >= dev['end']):
+                                                                dev['ftrace'] = cg
+                                                break
+
+                test.data.printDetails()
+
+# Function: parseTraceLog
+# Description:
+#        Analyze an ftrace log output file generated from this app during
+#        the execution phase. Used when the ftrace log is the primary data source
+#        and includes the suspend_resume and device_pm_callback trace events
+#        The ftrace filename is taken from sysvals
+# Output:
+#        An array of Data objects
+def parseTraceLog():
+        vprint('Analyzing the ftrace data...')
+        if(os.path.exists(sysvals.ftracefile) == False):
+                doError('%s does not exist' % sysvals.ftracefile)
+
+        sysvals.setupAllKprobes()
+        tracewatch = []
+        if sysvals.usekprobes:
+                tracewatch += ['sync_filesystems', 'freeze_processes', 'syscore_suspend',
+                        'syscore_resume', 'resume_console', 'thaw_processes', 'CPU_ON', 'CPU_OFF']
+
+        # extract the callgraph and traceevent data
+        tp = TestProps()
+        testruns = []
+        testdata = []
+        testrun = 0
+        data = 0
+        tf = open(sysvals.ftracefile, 'r')
+        phase = 'suspend_prepare'
+        for line in tf:
+                # remove any latent carriage returns
+                line = line.replace('\r\n', '')
+                # stamp line: each stamp means a new test run
+                m = re.match(sysvals.stampfmt, line)
+                if(m):
+                        tp.stamp = line
+                        continue
+                # firmware line: pull out any firmware data
+                m = re.match(sysvals.firmwarefmt, line)
+                if(m):
+                        tp.fwdata.append((int(m.group('s')), int(m.group('r'))))
+                        continue
+                # tracer type line: determine the trace data type
+                m = re.match(sysvals.tracertypefmt, line)
+                if(m):
+                        tp.setTracerType(m.group('t'))
+                        continue
+                # device properties line
+                if(re.match(sysvals.devpropfmt, line)):
+                        devProps(line)
+                        continue
+                # ignore all other commented lines
+                if line[0] == '#':
+                        continue
+                # ftrace line: parse only valid lines
+                m = re.match(tp.ftrace_line_fmt, line)
+                if(not m):
+                        continue
+                # gather the basic message data from the line
+                m_time = m.group('time')
+                m_proc = m.group('proc')
+                m_pid = m.group('pid')
+                m_msg = m.group('msg')
+                if(tp.cgformat):
+                        m_param3 = m.group('dur')
+                else:
+                        m_param3 = 'traceevent'
+                if(m_time and m_pid and m_msg):
+                        t = FTraceLine(m_time, m_msg, m_param3)
+                        pid = int(m_pid)
+                else:
+                        continue
+                # the line should be a call, return, or event
+                if(not t.fcall and not t.freturn and not t.fevent):
+                        continue
+                # find the start of suspend
+                if(t.startMarker()):
+                        phase = 'suspend_prepare'
+                        data = Data(len(testdata))
+                        testdata.append(data)
+                        testrun = TestRun(data)
+                        testruns.append(testrun)
+                        parseStamp(tp.stamp, data)
+                        data.setStart(t.time)
+                        data.tKernSus = t.time
+                        continue
+                if(not data):
+                        continue
+                # process cpu exec line
+                if t.type == 'tracing_mark_write':
+                        m = re.match(sysvals.procexecfmt, t.name)
+                        if(m):
+                                proclist = dict()
+                                for ps in m.group('ps').split(','):
+                                        val = ps.split()
+                                        if not val:
+                                                continue
+                                        name = val[0].replace('--', '-')
+                                        proclist[name] = int(val[1])
+                                data.pstl[t.time] = proclist
+                                continue
+                # find the end of resume
+                if(t.endMarker()):
+                        data.setEnd(t.time)
+                        if data.tKernRes == 0.0:
+                                data.tKernRes = t.time
+                        if data.dmesg['resume_complete']['end'] < 0:
+                                data.dmesg['resume_complete']['end'] = t.time
+                        if sysvals.suspendmode == 'mem' and len(tp.fwdata) > data.testnumber:
+                                data.fwSuspend, data.fwResume = tp.fwdata[data.testnumber]
+                                if(data.tSuspended != 0 and data.tResumed != 0 and \
+                                        (data.fwSuspend > 0 or data.fwResume > 0)):
+                                        data.fwValid = True
+                        if(not sysvals.usetracemarkers):
+                                # no trace markers? then quit and be sure to finish recording
+                                # the event we used to trigger resume end
+                                if(len(testrun.ttemp['thaw_processes']) > 0):
+                                        # if an entry exists, assume this is its end
+                                        testrun.ttemp['thaw_processes'][-1]['end'] = t.time
+                                break
+                        continue
+                # trace event processing
+                if(t.fevent):
+                        if(phase == 'post_resume'):
+                                data.setEnd(t.time)
+                        if(t.type == 'suspend_resume'):
+                                # suspend_resume trace events have two types, begin and end
+                                if(re.match('(?P<name>.*) begin$', t.name)):
+                                        isbegin = True
+                                elif(re.match('(?P<name>.*) end$', t.name)):
+                                        isbegin = False
+                                else:
+                                        continue
+                                m = re.match('(?P<name>.*)\[(?P<val>[0-9]*)\] .*', t.name)
+                                if(m):
+                                        val = m.group('val')
+                                        if val == '0':
+                                                name = m.group('name')
+                                        else:
+                                                name = m.group('name')+'['+val+']'
+                                else:
+                                        m = re.match('(?P<name>.*) .*', t.name)
+                                        name = m.group('name')
+                                # ignore these events
+                                if(name.split('[')[0] in tracewatch):
+                                        continue
+                                # -- phase changes --
+                                # start of kernel suspend
+                                if(re.match('suspend_enter\[.*', t.name)):
+                                        if(isbegin):
+                                                data.dmesg[phase]['start'] = t.time
+                                                data.tKernSus = t.time
+                                        continue
+                                # suspend_prepare start
+                                elif(re.match('dpm_prepare\[.*', t.name)):
+                                        phase = 'suspend_prepare'
+                                        if(not isbegin):
+                                                data.dmesg[phase]['end'] = t.time
+                                        continue
+                                # suspend start
+                                elif(re.match('dpm_suspend\[.*', t.name)):
+                                        phase = 'suspend'
+                                        data.setPhase(phase, t.time, isbegin)
+                                        continue
+                                # suspend_late start
+                                elif(re.match('dpm_suspend_late\[.*', t.name)):
+                                        phase = 'suspend_late'
+                                        data.setPhase(phase, t.time, isbegin)
+                                        continue
+                                # suspend_noirq start
+                                elif(re.match('dpm_suspend_noirq\[.*', t.name)):
+                                        phase = 'suspend_noirq'
+                                        data.setPhase(phase, t.time, isbegin)
+                                        if(not isbegin):
+                                                phase = 'suspend_machine'
+                                                data.dmesg[phase]['start'] = t.time
+                                        continue
+                                # suspend_machine/resume_machine
+                                elif(re.match('machine_suspend\[.*', t.name)):
+                                        if(isbegin):
+                                                phase = 'suspend_machine'
+                                                data.dmesg[phase]['end'] = t.time
+                                                data.tSuspended = t.time
+                                        else:
+                                                if(sysvals.suspendmode in ['mem', 'disk'] and not tp.S0i3):
+                                                        data.dmesg['suspend_machine']['end'] = t.time
+                                                        data.tSuspended = t.time
+                                                phase = 'resume_machine'
+                                                data.dmesg[phase]['start'] = t.time
+                                                data.tResumed = t.time
+                                                data.tLow = data.tResumed - data.tSuspended
+                                        continue
+                                # acpi_suspend
+                                elif(re.match('acpi_suspend\[.*', t.name)):
+                                        # acpi_suspend[0] S0i3
+                                        if(re.match('acpi_suspend\[0\] begin', t.name)):
+                                                if(sysvals.suspendmode == 'mem'):
+                                                        tp.S0i3 = True
+                                                        data.dmesg['suspend_machine']['end'] = t.time
+                                                        data.tSuspended = t.time
+                                        continue
+                                # resume_noirq start
+                                elif(re.match('dpm_resume_noirq\[.*', t.name)):
+                                        phase = 'resume_noirq'
+                                        data.setPhase(phase, t.time, isbegin)
+                                        if(isbegin):
+                                                data.dmesg['resume_machine']['end'] = t.time
+                                        continue
+                                # resume_early start
+                                elif(re.match('dpm_resume_early\[.*', t.name)):
+                                        phase = 'resume_early'
+                                        data.setPhase(phase, t.time, isbegin)
+                                        continue
+                                # resume start
+                                elif(re.match('dpm_resume\[.*', t.name)):
+                                        phase = 'resume'
+                                        data.setPhase(phase, t.time, isbegin)
+                                        continue
+                                # resume complete start
+                                elif(re.match('dpm_complete\[.*', t.name)):
+                                        phase = 'resume_complete'
+                                        if(isbegin):
+                                                data.dmesg[phase]['start'] = t.time
+                                        continue
+                                # skip trace events inside devices calls
+                                if(not data.isTraceEventOutsideDeviceCalls(pid, t.time)):
+                                        continue
+                                # global events (outside device calls) are graphed
+                                if(name not in testrun.ttemp):
+                                        testrun.ttemp[name] = []
+                                if(isbegin):
+                                        # create a new list entry
+                                        testrun.ttemp[name].append(\
+                                                {'begin': t.time, 'end': t.time, 'pid': pid})
+                                else:
+                                        if(len(testrun.ttemp[name]) > 0):
+                                                # if an entry exists, assume this is its end
+                                                testrun.ttemp[name][-1]['end'] = t.time
+                                        elif(phase == 'post_resume'):
+                                                # post resume events can just have ends
+                                                testrun.ttemp[name].append({
+                                                        'begin': data.dmesg[phase]['start'],
+                                                        'end': t.time})
+                        # device callback start
+                        elif(t.type == 'device_pm_callback_start'):
+                                m = re.match('(?P<drv>.*) (?P<d>.*), parent: *(?P<p>.*), .*',\
+                                        t.name);
+                                if(not m):
+                                        continue
+                                drv = m.group('drv')
+                                n = m.group('d')
+                                p = m.group('p')
+                                if(n and p):
+                                        data.newAction(phase, n, pid, p, t.time, -1, drv)
+                                        if pid not in data.devpids:
+                                                data.devpids.append(pid)
+                        # device callback finish
+                        elif(t.type == 'device_pm_callback_end'):
+                                m = re.match('(?P<drv>.*) (?P<d>.*), err.*', t.name);
+                                if(not m):
+                                        continue
+                                n = m.group('d')
+                                list = data.dmesg[phase]['list']
+                                if(n in list):
+                                        dev = list[n]
+                                        dev['length'] = t.time - dev['start']
+                                        dev['end'] = t.time
+                # kprobe event processing
+                elif(t.fkprobe):
+                        kprobename = t.type
+                        kprobedata = t.name
+                        key = (kprobename, pid)
+                        # displayname is generated from kprobe data
+                        displayname = ''
+                        if(t.fcall):
+                                displayname = sysvals.kprobeDisplayName(kprobename, kprobedata)
+                                if not displayname:
+                                        continue
+                                if(key not in tp.ktemp):
+                                        tp.ktemp[key] = []
+                                tp.ktemp[key].append({
+                                        'pid': pid,
+                                        'begin': t.time,
+                                        'end': t.time,
+                                        'name': displayname,
+                                        'cdata': kprobedata,
+                                        'proc': m_proc,
+                                })
+                        elif(t.freturn):
+                                if(key not in tp.ktemp) or len(tp.ktemp[key]) < 1:
+                                        continue
+                                e = tp.ktemp[key][-1]
+                                if e['begin'] < 0.0 or t.time - e['begin'] < 0.000001:
+                                        tp.ktemp[key].pop()
+                                else:
+                                        e['end'] = t.time
+                                        e['rdata'] = kprobedata
+                                # end of kernel resume
+                                if(kprobename == 'pm_notifier_call_chain' or \
+                                        kprobename == 'pm_restore_console'):
+                                        data.dmesg[phase]['end'] = t.time
+                                        data.tKernRes = t.time
+
+                # callgraph processing
+                elif sysvals.usecallgraph:
+                        # create a callgraph object for the data
+                        key = (m_proc, pid)
+                        if(key not in testrun.ftemp):
+                                testrun.ftemp[key] = []
+                                testrun.ftemp[key].append(FTraceCallGraph(pid))
+                        # when the call is finished, see which device matches it
+                        cg = testrun.ftemp[key][-1]
+                        if(cg.addLine(t)):
+                                testrun.ftemp[key].append(FTraceCallGraph(pid))
+        tf.close()
+
+        if sysvals.suspendmode == 'command':
+                for test in testruns:
+                        for p in test.data.phases:
+                                if p == 'suspend_prepare':
+                                        test.data.dmesg[p]['start'] = test.data.start
+                                        test.data.dmesg[p]['end'] = test.data.end
+                                else:
+                                        test.data.dmesg[p]['start'] = test.data.end
+                                        test.data.dmesg[p]['end'] = test.data.end
+                        test.data.tSuspended = test.data.end
+                        test.data.tResumed = test.data.end
+                        test.data.tLow = 0
+                        test.data.fwValid = False
+
+        # dev source and procmon events can be unreadable with mixed phase height
+        if sysvals.usedevsrc or sysvals.useprocmon:
+                sysvals.mixedphaseheight = False
+
+        for i in range(len(testruns)):
+                test = testruns[i]
+                data = test.data
+                # find the total time range for this test (begin, end)
+                tlb, tle = data.start, data.end
+                if i < len(testruns) - 1:
+                        tle = testruns[i+1].data.start
+                # add the process usage data to the timeline
+                if sysvals.useprocmon:
+                        data.createProcessUsageEvents()
+                # add the traceevent data to the device hierarchy
+                if(sysvals.usetraceevents):
+                        # add actual trace funcs
+                        for name in test.ttemp:
+                                for event in test.ttemp[name]:
+                                        data.newActionGlobal(name, event['begin'], event['end'], event['pid'])
+                        # add the kprobe based virtual tracefuncs as actual devices
+                        for key in tp.ktemp:
+                                name, pid = key
+                                if name not in sysvals.tracefuncs:
+                                        continue
+                                for e in tp.ktemp[key]:
+                                        kb, ke = e['begin'], e['end']
+                                        if kb == ke or tlb > kb or tle <= kb:
+                                                continue
+                                        color = sysvals.kprobeColor(name)
+                                        data.newActionGlobal(e['name'], kb, ke, pid, color)
+                        # add config base kprobes and dev kprobes
+                        if sysvals.usedevsrc:
+                                for key in tp.ktemp:
+                                        name, pid = key
+                                        if name in sysvals.tracefuncs or name not in sysvals.dev_tracefuncs:
+                                                continue
+                                        for e in tp.ktemp[key]:
+                                                kb, ke = e['begin'], e['end']
+                                                if kb == ke or tlb > kb or tle <= kb:
+                                                        continue
+                                                data.addDeviceFunctionCall(e['name'], name, e['proc'], pid, kb,
+                                                        ke, e['cdata'], e['rdata'])
+                if sysvals.usecallgraph:
+                        # add the callgraph data to the device hierarchy
+                        sortlist = dict()
+                        for key in test.ftemp:
+                                proc, pid = key
+                                for cg in test.ftemp[key]:
+                                        if len(cg.list) < 1 or cg.invalid:
+                                                continue
+                                        if(not cg.postProcess()):
+                                                id = 'task %s' % (pid)
+                                                vprint('Sanity check failed for '+\
+                                                        id+', ignoring this callback')
+                                                continue
+                                        # match cg data to devices
+                                        if sysvals.suspendmode == 'command' or not cg.deviceMatch(pid, data):
+                                                sortkey = '%f%f%d' % (cg.start, cg.end, pid)
+                                                sortlist[sortkey] = cg
+                        # create blocks for orphan cg data
+                        for sortkey in sorted(sortlist):
+                                cg = sortlist[sortkey]
+                                name = cg.name
+                                if sysvals.isCallgraphFunc(name):
+                                        vprint('Callgraph found for task %d: %.3fms, %s' % (cg.pid, (cg.end - cg.start)*1000, name))
+                                        cg.newActionFromFunction(data)
+
+        if sysvals.suspendmode == 'command':
+                for data in testdata:
+                        data.printDetails()
+                return testdata
+
+        # fill in any missing phases
+        for data in testdata:
+                lp = data.phases[0]
+                for p in data.phases:
+                        if(data.dmesg[p]['start'] < 0 and data.dmesg[p]['end'] < 0):
+                                vprint('WARNING: phase "%s" is missing!' % p)
+                        if(data.dmesg[p]['start'] < 0):
+                                data.dmesg[p]['start'] = data.dmesg[lp]['end']
+                                if(p == 'resume_machine'):
+                                        data.tSuspended = data.dmesg[lp]['end']
+                                        data.tResumed = data.dmesg[lp]['end']
+                                        data.tLow = 0
+                        if(data.dmesg[p]['end'] < 0):
+                                data.dmesg[p]['end'] = data.dmesg[p]['start']
+                        if(p != lp and not ('machine' in p and 'machine' in lp)):
+                                data.dmesg[lp]['end'] = data.dmesg[p]['start']
+                        lp = p
+
+                if(len(sysvals.devicefilter) > 0):
+                        data.deviceFilter(sysvals.devicefilter)
+                data.fixupInitcallsThatDidntReturn()
+                if sysvals.usedevsrc:
+                        data.optimizeDevSrc()
+                data.printDetails()
+
+        # x2: merge any overlapping devices between test runs
+        if sysvals.usedevsrc and len(testdata) > 1:
+                tc = len(testdata)
+                for i in range(tc - 1):
+                        devlist = testdata[i].overflowDevices()
+                        for j in range(i + 1, tc):
+                                testdata[j].mergeOverlapDevices(devlist)
+                testdata[0].stitchTouchingThreads(testdata[1:])
+        return testdata
+
+# Function: loadKernelLog
+# Description:
+#        [deprecated for kernel 3.15.0 or newer]
+#        load the dmesg file into memory and fix up any ordering issues
+#        The dmesg filename is taken from sysvals
+# Output:
+#        An array of empty Data objects with only their dmesgtext attributes set
+def loadKernelLog(justtext=False):
+        vprint('Analyzing the dmesg data...')
+        if(os.path.exists(sysvals.dmesgfile) == False):
+                doError('%s does not exist' % sysvals.dmesgfile)
+
+        if justtext:
+                dmesgtext = []
+        # there can be multiple test runs in a single file
+        tp = TestProps()
+        tp.stamp = datetime.now().strftime('# suspend-%m%d%y-%H%M%S localhost mem unknown')
+        testruns = []
+        data = 0
+        lf = open(sysvals.dmesgfile, 'r')
+        for line in lf:
+                line = line.replace('\r\n', '')
+                idx = line.find('[')
+                if idx > 1:
+                        line = line[idx:]
+                m = re.match(sysvals.stampfmt, line)
+                if(m):
+                        tp.stamp = line
+                        continue
+                m = re.match(sysvals.firmwarefmt, line)
+                if(m):
+                        tp.fwdata.append((int(m.group('s')), int(m.group('r'))))
+                        continue
+                m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line)
+                if(not m):
+                        continue
+                msg = m.group("msg")
+                if justtext:
+                        dmesgtext.append(line)
+                        continue
+                if(re.match('PM: Syncing filesystems.*', msg)):
+                        if(data):
+                                testruns.append(data)
+                        data = Data(len(testruns))
+                        parseStamp(tp.stamp, data)
+                        if len(tp.fwdata) > data.testnumber:
+                                data.fwSuspend, data.fwResume = tp.fwdata[data.testnumber]
+                                if(data.fwSuspend > 0 or data.fwResume > 0):
+                                        data.fwValid = True
+                if(not data):
+                        continue
+                m = re.match('.* *(?P<k>[0-9]\.[0-9]{2}\.[0-9]-.*) .*', msg)
+                if(m):
+                        sysvals.stamp['kernel'] = m.group('k')
+                m = re.match('PM: Preparing system for (?P<m>.*) sleep', msg)
+                if(m):
+                        sysvals.stamp['mode'] = sysvals.suspendmode = m.group('m')
+                data.dmesgtext.append(line)
+        lf.close()
+
+        if justtext:
+                return dmesgtext
+        if data:
+                testruns.append(data)
+        if len(testruns) < 1:
+                doError(' dmesg log has no suspend/resume data: %s' \
+                        % sysvals.dmesgfile)
+
+        # fix lines with same timestamp/function with the call and return swapped
+        for data in testruns:
+                last = ''
+                for line in data.dmesgtext:
+                        mc = re.match('.*(\[ *)(?P<t>[0-9\.]*)(\]) calling  '+\
+                                '(?P<f>.*)\+ @ .*, parent: .*', line)
+                        mr = re.match('.*(\[ *)(?P<t>[0-9\.]*)(\]) call '+\
+                                '(?P<f>.*)\+ returned .* after (?P<dt>.*) usecs', last)
+                        if(mc and mr and (mc.group('t') == mr.group('t')) and
+                                (mc.group('f') == mr.group('f'))):
+                                i = data.dmesgtext.index(last)
+                                j = data.dmesgtext.index(line)
+                                data.dmesgtext[i] = line
+                                data.dmesgtext[j] = last
+                        last = line
+        return testruns
+
+# Function: parseKernelLog
+# Description:
+#        [deprecated for kernel 3.15.0 or newer]
+#        Analyse a dmesg log output file generated from this app during
+#        the execution phase. Create a set of device structures in memory
+#        for subsequent formatting in the html output file
+#        This call is only for legacy support on kernels where the ftrace
+#        data lacks the suspend_resume or device_pm_callbacks trace events.
+# Arguments:
+#        data: an empty Data object (with dmesgtext) obtained from loadKernelLog
+# Output:
+#        The filled Data object
+def parseKernelLog(data):
+        phase = 'suspend_runtime'
+
+        if(data.fwValid):
+                vprint('Firmware Suspend = %u ns, Firmware Resume = %u ns' % \
+                        (data.fwSuspend, data.fwResume))
+
+        # dmesg phase match table
+        dm = {
+                'suspend_prepare': 'PM: Syncing filesystems.*',
+                        'suspend': 'PM: Entering [a-z]* sleep.*',
+                   'suspend_late': 'PM: suspend of devices complete after.*',
+                  'suspend_noirq': 'PM: late suspend of devices complete after.*',
+                'suspend_machine': 'PM: noirq suspend of devices complete after.*',
+                 'resume_machine': 'ACPI: Low-level resume complete.*',
+                   'resume_noirq': 'ACPI: Waking up from system sleep state.*',
+                   'resume_early': 'PM: noirq resume of devices complete after.*',
+                         'resume': 'PM: early resume of devices complete after.*',
+                'resume_complete': 'PM: resume of devices complete after.*',
+                    'post_resume': '.*Restarting tasks \.\.\..*',
+        }
+        if(sysvals.suspendmode == 'standby'):
+                dm['resume_machine'] = 'PM: Restoring platform NVS memory'
+        elif(sysvals.suspendmode == 'disk'):
+                dm['suspend_late'] = 'PM: freeze of devices complete after.*'
+                dm['suspend_noirq'] = 'PM: late freeze of devices complete after.*'
+                dm['suspend_machine'] = 'PM: noirq freeze of devices complete after.*'
+                dm['resume_machine'] = 'PM: Restoring platform NVS memory'
+                dm['resume_early'] = 'PM: noirq restore of devices complete after.*'
+                dm['resume'] = 'PM: early restore of devices complete after.*'
+                dm['resume_complete'] = 'PM: restore of devices complete after.*'
+        elif(sysvals.suspendmode == 'freeze'):
+                dm['resume_machine'] = 'ACPI: resume from mwait'
+
+        # action table (expected events that occur and show up in dmesg)
+        at = {
+                'sync_filesystems': {
+                        'smsg': 'PM: Syncing filesystems.*',
+                        'emsg': 'PM: Preparing system for mem sleep.*' },
+                'freeze_user_processes': {
+                        'smsg': 'Freezing user space processes .*',
+                        'emsg': 'Freezing remaining freezable tasks.*' },
+                'freeze_tasks': {
+                        'smsg': 'Freezing remaining freezable tasks.*',
+                        'emsg': 'PM: Entering (?P<mode>[a-z,A-Z]*) sleep.*' },
+                'ACPI prepare': {
+                        'smsg': 'ACPI: Preparing to enter system sleep state.*',
+                        'emsg': 'PM: Saving platform NVS memory.*' },
+                'PM vns': {
+                        'smsg': 'PM: Saving platform NVS memory.*',
+                        'emsg': 'Disabling non-boot CPUs .*' },
+        }
+
+        t0 = -1.0
+        cpu_start = -1.0
+        prevktime = -1.0
+        actions = dict()
+        for line in data.dmesgtext:
+                # parse each dmesg line into the time and message
+                m = re.match('[ \t]*(\[ *)(?P<ktime>[0-9\.]*)(\]) (?P<msg>.*)', line)
+                if(m):
+                        val = m.group('ktime')
+                        try:
+                                ktime = float(val)
+                        except:
+                                continue
+                        msg = m.group('msg')
+                        # initialize data start to first line time
+                        if t0 < 0:
+                                data.setStart(ktime)
+                                t0 = ktime
+                else:
+                        continue
+
+                # hack for determining resume_machine end for freeze
+                if(not sysvals.usetraceevents and sysvals.suspendmode == 'freeze' \
+                        and phase == 'resume_machine' and \
+                        re.match('calling  (?P<f>.*)\+ @ .*, parent: .*', msg)):
+                        data.dmesg['resume_machine']['end'] = ktime
+                        phase = 'resume_noirq'
+                        data.dmesg[phase]['start'] = ktime
+
+                # suspend start
+                if(re.match(dm['suspend_prepare'], msg)):
+                        phase = 'suspend_prepare'
+                        data.dmesg[phase]['start'] = ktime
+                        data.setStart(ktime)
+                        data.tKernSus = ktime
+                # suspend start
+                elif(re.match(dm['suspend'], msg)):
+                        data.dmesg['suspend_prepare']['end'] = ktime
+                        phase = 'suspend'
+                        data.dmesg[phase]['start'] = ktime
+                # suspend_late start
+                elif(re.match(dm['suspend_late'], msg)):
+                        data.dmesg['suspend']['end'] = ktime
+                        phase = 'suspend_late'
+                        data.dmesg[phase]['start'] = ktime
+                # suspend_noirq start
+                elif(re.match(dm['suspend_noirq'], msg)):
+                        data.dmesg['suspend_late']['end'] = ktime
+                        phase = 'suspend_noirq'
+                        data.dmesg[phase]['start'] = ktime
+                # suspend_machine start
+                elif(re.match(dm['suspend_machine'], msg)):
+                        data.dmesg['suspend_noirq']['end'] = ktime
+                        phase = 'suspend_machine'
+                        data.dmesg[phase]['start'] = ktime
+                # resume_machine start
+                elif(re.match(dm['resume_machine'], msg)):
+                        if(sysvals.suspendmode in ['freeze', 'standby']):
+                                data.tSuspended = prevktime
+                                data.dmesg['suspend_machine']['end'] = prevktime
+                        else:
+                                data.tSuspended = ktime
+                                data.dmesg['suspend_machine']['end'] = ktime
+                        phase = 'resume_machine'
+                        data.tResumed = ktime
+                        data.tLow = data.tResumed - data.tSuspended
+                        data.dmesg[phase]['start'] = ktime
+                # resume_noirq start
+                elif(re.match(dm['resume_noirq'], msg)):
+                        data.dmesg['resume_machine']['end'] = ktime
+                        phase = 'resume_noirq'
+                        data.dmesg[phase]['start'] = ktime
+                # resume_early start
+                elif(re.match(dm['resume_early'], msg)):
+                        data.dmesg['resume_noirq']['end'] = ktime
+                        phase = 'resume_early'
+                        data.dmesg[phase]['start'] = ktime
+                # resume start
+                elif(re.match(dm['resume'], msg)):
+                        data.dmesg['resume_early']['end'] = ktime
+                        phase = 'resume'
+                        data.dmesg[phase]['start'] = ktime
+                # resume complete start
+                elif(re.match(dm['resume_complete'], msg)):
+                        data.dmesg['resume']['end'] = ktime
+                        phase = 'resume_complete'
+                        data.dmesg[phase]['start'] = ktime
+                # post resume start
+                elif(re.match(dm['post_resume'], msg)):
+                        data.dmesg['resume_complete']['end'] = ktime
+                        data.setEnd(ktime)
+                        data.tKernRes = ktime
+                        break
+
+                # -- device callbacks --
+                if(phase in data.phases):
+                        # device init call
+                        if(re.match('calling  (?P<f>.*)\+ @ .*, parent: .*', msg)):
+                                sm = re.match('calling  (?P<f>.*)\+ @ '+\
+                                        '(?P<n>.*), parent: (?P<p>.*)', msg);
+                                f = sm.group('f')
+                                n = sm.group('n')
+                                p = sm.group('p')
+                                if(f and n and p):
+                                        data.newAction(phase, f, int(n), p, ktime, -1, '')
+                        # device init return
+                        elif(re.match('call (?P<f>.*)\+ returned .* after '+\
+                                '(?P<t>.*) usecs', msg)):
+                                sm = re.match('call (?P<f>.*)\+ returned .* after '+\
+                                        '(?P<t>.*) usecs(?P<a>.*)', msg);
+                                f = sm.group('f')
+                                t = sm.group('t')
+                                list = data.dmesg[phase]['list']
+                                if(f in list):
+                                        dev = list[f]
+                                        dev['length'] = int(t)
+                                        dev['end'] = ktime
+
+                # if trace events are not available, these are better than nothing
+                if(not sysvals.usetraceevents):
+                        # look for known actions
+                        for a in at:
+                                if(re.match(at[a]['smsg'], msg)):
+                                        if(a not in actions):
+                                                actions[a] = []
+                                        actions[a].append({'begin': ktime, 'end': ktime})
+                                if(re.match(at[a]['emsg'], msg)):
+                                        if(a in actions):
+                                                actions[a][-1]['end'] = ktime
+                        # now look for CPU on/off events
+                        if(re.match('Disabling non-boot CPUs .*', msg)):
+                                # start of first cpu suspend
+                                cpu_start = ktime
+                        elif(re.match('Enabling non-boot CPUs .*', msg)):
+                                # start of first cpu resume
+                                cpu_start = ktime
+                        elif(re.match('smpboot: CPU (?P<cpu>[0-9]*) is now offline', msg)):
+                                # end of a cpu suspend, start of the next
+                                m = re.match('smpboot: CPU (?P<cpu>[0-9]*) is now offline', msg)
+                                cpu = 'CPU'+m.group('cpu')
+                                if(cpu not in actions):
+                                        actions[cpu] = []
+                                actions[cpu].append({'begin': cpu_start, 'end': ktime})
+                                cpu_start = ktime
+                        elif(re.match('CPU(?P<cpu>[0-9]*) is up', msg)):
+                                # end of a cpu resume, start of the next
+                                m = re.match('CPU(?P<cpu>[0-9]*) is up', msg)
+                                cpu = 'CPU'+m.group('cpu')
+                                if(cpu not in actions):
+                                        actions[cpu] = []
+                                actions[cpu].append({'begin': cpu_start, 'end': ktime})
+                                cpu_start = ktime
+                prevktime = ktime
+
+        # fill in any missing phases
+        lp = data.phases[0]
+        for p in data.phases:
+                if(data.dmesg[p]['start'] < 0 and data.dmesg[p]['end'] < 0):
+                        print('WARNING: phase "%s" is missing, something went wrong!' % p)
+                        print('    In %s, this dmesg line denotes the start of %s:' % \
+                                (sysvals.suspendmode, p))
+                        print('        "%s"' % dm[p])
+                if(data.dmesg[p]['start'] < 0):
+                        data.dmesg[p]['start'] = data.dmesg[lp]['end']
+                        if(p == 'resume_machine'):
+                                data.tSuspended = data.dmesg[lp]['end']
+                                data.tResumed = data.dmesg[lp]['end']
+                                data.tLow = 0
+                if(data.dmesg[p]['end'] < 0):
+                        data.dmesg[p]['end'] = data.dmesg[p]['start']
+                lp = p
+
+        # fill in any actions we've found
+        for name in actions:
+                for event in actions[name]:
+                        data.newActionGlobal(name, event['begin'], event['end'])
+
+        data.printDetails()
+        if(len(sysvals.devicefilter) > 0):
+                data.deviceFilter(sysvals.devicefilter)
+        data.fixupInitcallsThatDidntReturn()
+        return True
+
+def callgraphHTML(sv, hf, num, cg, title, color, devid):
+        html_func_top = '<article id="{0}" class="atop" style="background:{1}">\n<input type="checkbox" class="pf" id="f{2}" checked/><label for="f{2}">{3} {4}</label>\n'
+        html_func_start = '<article>\n<input type="checkbox" class="pf" id="f{0}" checked/><label for="f{0}">{1} {2}</label>\n'
+        html_func_end = '</article>\n'
+        html_func_leaf = '<article>{0} {1}</article>\n'
+
+        cgid = devid
+        if cg.id:
+                cgid += cg.id
+        cglen = (cg.end - cg.start) * 1000
+        if cglen < sv.mincglen:
+                return num
+
+        fmt = '<r>(%.3f ms @ '+sv.timeformat+' to '+sv.timeformat+')</r>'
+        flen = fmt % (cglen, cg.start, cg.end)
+        hf.write(html_func_top.format(cgid, color, num, title, flen))
+        num += 1
+        for line in cg.list:
+                if(line.length < 0.000000001):
+                        flen = ''
+                else:
+                        fmt = '<n>(%.3f ms @ '+sv.timeformat+')</n>'
+                        flen = fmt % (line.length*1000, line.time)
+                if(line.freturn and line.fcall):
+                        hf.write(html_func_leaf.format(line.name, flen))
+                elif(line.freturn):
+                        hf.write(html_func_end)
+                else:
+                        hf.write(html_func_start.format(num, line.name, flen))
+                        num += 1
+        hf.write(html_func_end)
+        return num
+
+def addCallgraphs(sv, hf, data):
+        hf.write('<section id="callgraphs" class="callgraph">\n')
+        # write out the ftrace data converted to html
+        num = 0
+        for p in data.phases:
+                if sv.cgphase and p != sv.cgphase:
+                        continue
+                list = data.dmesg[p]['list']
+                for devname in data.sortedDevices(p):
+                        dev = list[devname]
+                        color = 'white'
+                        if 'color' in data.dmesg[p]:
+                                color = data.dmesg[p]['color']
+                        if 'color' in dev:
+                                color = dev['color']
+                        name = devname
+                        if(devname in sv.devprops):
+                                name = sv.devprops[devname].altName(devname)
+                        if sv.suspendmode in suspendmodename:
+                                name += ' '+p
+                        if('ftrace' in dev):
+                                cg = dev['ftrace']
+                                num = callgraphHTML(sv, hf, num, cg,
+                                        name, color, dev['id'])
+                        if('ftraces' in dev):
+                                for cg in dev['ftraces']:
+                                        num = callgraphHTML(sv, hf, num, cg,
+                                                name+' &rarr; '+cg.name, color, dev['id'])
+
+        hf.write('\n\n    </section>\n')
+
+# Function: createHTMLSummarySimple
+# Description:
+#        Create summary html file for a series of tests
+# Arguments:
+#        testruns: array of Data objects from parseTraceLog
+def createHTMLSummarySimple(testruns, htmlfile, folder):
+        # write the html header first (html head, css code, up to body start)
+        html = '<!DOCTYPE html>\n<html>\n<head>\n\
+        <meta http-equiv="content-type" content="text/html; charset=UTF-8">\n\
+        <title>SleepGraph Summary</title>\n\
+        <style type=\'text/css\'>\n\
+                .stamp {width: 100%;text-align:center;background:#888;line-height:30px;color:white;font: 25px Arial;}\n\
+                table {width:100%;border-collapse: collapse;}\n\
+                .summary {border:1px solid;}\n\
+                th {border: 1px solid black;background:#222;color:white;}\n\
+                td {font: 16px "Times New Roman";text-align: center;}\n\
+                tr.alt td {background:#ddd;}\n\
+                tr.avg td {background:#aaa;}\n\
+        </style>\n</head>\n<body>\n'
+
+        # group test header
+        html += '<div class="stamp">%s (%d tests)</div>\n' % (folder, len(testruns))
+        th = '\t<th>{0}</th>\n'
+        td = '\t<td>{0}</td>\n'
+        tdlink = '\t<td><a href="{0}">html</a></td>\n'
+
+        # table header
+        html += '<table class="summary">\n<tr>\n' + th.format('#') +\
+                th.format('Mode') + th.format('Host') + th.format('Kernel') +\
+                th.format('Test Time') + th.format('Suspend') + th.format('Resume') +\
+                th.format('Detail') + '</tr>\n'
+
+        # test data, 1 row per test
+        avg = '<tr class="avg"><td></td><td></td><td></td><td></td>'+\
+                '<td>Average of {0} {1} tests</td><td>{2}</td><td>{3}</td><td></td></tr>\n'
+        sTimeAvg = rTimeAvg = 0.0
+        mode = ''
+        num = 0
+        for data in sorted(testruns, key=lambda v:(v['mode'], v['host'], v['kernel'])):
+                if mode != data['mode']:
+                        # test average line
+                        if(num > 0):
+                                sTimeAvg /= (num - 1)
+                                rTimeAvg /= (num - 1)
+                                html += avg.format('%d' % (num - 1), mode,
+                                        '%3.3f ms' % sTimeAvg, '%3.3f ms' % rTimeAvg)
+                        sTimeAvg = rTimeAvg = 0.0
+                        mode = data['mode']
+                        num = 1
+                # alternate row color
+                if num % 2 == 1:
+                        html += '<tr class="alt">\n'
+                else:
+                        html += '<tr>\n'
+                html += td.format("%d" % num)
+                num += 1
+                # basic info
+                for item in ['mode', 'host', 'kernel', 'time']:
+                        val = "unknown"
+                        if(item in data):
+                                val = data[item]
+                        html += td.format(val)
+                # suspend time
+                sTime = float(data['suspend'])
+                sTimeAvg += sTime
+                html += td.format('%.3f ms' % sTime)
+                # resume time
+                rTime = float(data['resume'])
+                rTimeAvg += rTime
+                html += td.format('%.3f ms' % rTime)
+                # link to the output html
+                html += tdlink.format(data['url']) + '</tr>\n'
+        # last test average line
+        if(num > 0):
+                sTimeAvg /= (num - 1)
+                rTimeAvg /= (num - 1)
+                html += avg.format('%d' % (num - 1), mode,
+                        '%3.3f ms' % sTimeAvg, '%3.3f ms' % rTimeAvg)
+
+        # flush the data to file
+        hf = open(htmlfile, 'w')
+        hf.write(html+'</table>\n</body>\n</html>\n')
+        hf.close()
+
+def ordinal(value):
+        suffix = 'th'
+        if value < 10 or value > 19:
+                if value % 10 == 1:
+                        suffix = 'st'
+                elif value % 10 == 2:
+                        suffix = 'nd'
+                elif value % 10 == 3:
+                        suffix = 'rd'
+        return '%d%s' % (value, suffix)
+
+# Function: createHTML
+# Description:
+#        Create the output html file from the resident test data
+# Arguments:
+#        testruns: array of Data objects from parseKernelLog or parseTraceLog
+# Output:
+#        True if the html file was created, false if it failed
+def createHTML(testruns):
+        if len(testruns) < 1:
+                print('ERROR: Not enough test data to build a timeline')
+                return
+
+        kerror = False
+        for data in testruns:
+                if data.kerror:
+                        kerror = True
+                data.normalizeTime(testruns[-1].tSuspended)
+
+        # html function templates
+        html_error = '<div id="{1}" title="kernel error/warning" class="err" style="right:{0}%">ERROR&rarr;</div>\n'
+        html_traceevent = '<div title="{0}" class="traceevent{6}" style="left:{1}%;top:{2}px;height:{3}px;width:{4}%;line-height:{3}px;{7}">{5}</div>\n'
+        html_cpuexec = '<div class="jiffie" style="left:{0}%;top:{1}px;height:{2}px;width:{3}%;background:{4};"></div>\n'
+        html_legend = '<div id="p{3}" class="square" style="left:{0}%;background:{1}">&nbsp;{2}</div>\n'
+        html_timetotal = '<table class="time1">\n<tr>'\
+                '<td class="green" title="{3}">{2} Suspend Time: <b>{0} ms</b></td>'\
+                '<td class="yellow" title="{4}">{2} Resume Time: <b>{1} ms</b></td>'\
+                '</tr>\n</table>\n'
+        html_timetotal2 = '<table class="time1">\n<tr>'\
+                '<td class="green" title="{4}">{3} Suspend Time: <b>{0} ms</b></td>'\
+                '<td class="gray" title="time spent in low-power mode with clock running">'+sysvals.suspendmode+' time: <b>{1} ms</b></td>'\
+                '<td class="yellow" title="{5}">{3} Resume Time: <b>{2} ms</b></td>'\
+                '</tr>\n</table>\n'
+        html_timetotal3 = '<table class="time1">\n<tr>'\
+                '<td class="green">Execution Time: <b>{0} ms</b></td>'\
+                '<td class="yellow">Command: <b>{1}</b></td>'\
+                '</tr>\n</table>\n'
+        html_timegroups = '<table class="time2">\n<tr>'\
+                '<td class="green" title="time from kernel enter_state({5}) to firmware mode [kernel time only]">{4}Kernel Suspend: {0} ms</td>'\
+                '<td class="purple">{4}Firmware Suspend: {1} ms</td>'\
+                '<td class="purple">{4}Firmware Resume: {2} ms</td>'\
+                '<td class="yellow" title="time from firmware mode to return from kernel enter_state({5}) [kernel time only]">{4}Kernel Resume: {3} ms</td>'\
+                '</tr>\n</table>\n'
+
+        # html format variables
+        scaleH = 20
+        if kerror:
+                scaleH = 40
+
+        # device timeline
+        vprint('Creating Device Timeline...')
+
+        devtl = Timeline(30, scaleH)
+
+        # write the test title and general info header
+        devtl.createHeader(sysvals)
+
+        # Generate the header for this timeline
+        for data in testruns:
+                tTotal = data.end - data.start
+                sktime = (data.dmesg['suspend_machine']['end'] - \
+                        data.tKernSus) * 1000
+                rktime = (data.dmesg['resume_complete']['end'] - \
+                        data.dmesg['resume_machine']['start']) * 1000
+                if(tTotal == 0):
+                        print('ERROR: No timeline data')
+                        sys.exit()
+                if(data.tLow > 0):
+                        low_time = '%.0f'%(data.tLow*1000)
+                if sysvals.suspendmode == 'command':
+                        run_time = '%.0f'%((data.end-data.start)*1000)
+                        if sysvals.testcommand:
+                                testdesc = sysvals.testcommand
+                        else:
+                                testdesc = 'unknown'
+                        if(len(testruns) > 1):
+                                testdesc = ordinal(data.testnumber+1)+' '+testdesc
+                        thtml = html_timetotal3.format(run_time, testdesc)
+                        devtl.html += thtml
+                elif data.fwValid:
+                        suspend_time = '%.0f'%(sktime + (data.fwSuspend/1000000.0))
+                        resume_time = '%.0f'%(rktime + (data.fwResume/1000000.0))
+                        testdesc1 = 'Total'
+                        testdesc2 = ''
+                        stitle = 'time from kernel enter_state(%s) to low-power mode [kernel & firmware time]' % sysvals.suspendmode
+                        rtitle = 'time from low-power mode to return from kernel enter_state(%s) [firmware & kernel time]' % sysvals.suspendmode
+                        if(len(testruns) > 1):
+                                testdesc1 = testdesc2 = ordinal(data.testnumber+1)
+                                testdesc2 += ' '
+                        if(data.tLow == 0):
+                                thtml = html_timetotal.format(suspend_time, \
+                                        resume_time, testdesc1, stitle, rtitle)
+                        else:
+                                thtml = html_timetotal2.format(suspend_time, low_time, \
+                                        resume_time, testdesc1, stitle, rtitle)
+                        devtl.html += thtml
+                        sftime = '%.3f'%(data.fwSuspend / 1000000.0)
+                        rftime = '%.3f'%(data.fwResume / 1000000.0)
+                        devtl.html += html_timegroups.format('%.3f'%sktime, \
+                                sftime, rftime, '%.3f'%rktime, testdesc2, sysvals.suspendmode)
+                else:
+                        suspend_time = '%.3f' % sktime
+                        resume_time = '%.3f' % rktime
+                        testdesc = 'Kernel'
+                        stitle = 'time from kernel enter_state(%s) to firmware mode [kernel time only]' % sysvals.suspendmode
+                        rtitle = 'time from firmware mode to return from kernel enter_state(%s) [kernel time only]' % sysvals.suspendmode
+                        if(len(testruns) > 1):
+                                testdesc = ordinal(data.testnumber+1)+' '+testdesc
+                        if(data.tLow == 0):
+                                thtml = html_timetotal.format(suspend_time, \
+                                        resume_time, testdesc, stitle, rtitle)
+                        else:
+                                thtml = html_timetotal2.format(suspend_time, low_time, \
+                                        resume_time, testdesc, stitle, rtitle)
+                        devtl.html += thtml
+
+        # time scale for potentially multiple datasets
+        t0 = testruns[0].start
+        tMax = testruns[-1].end
+        tTotal = tMax - t0
+
+        # determine the maximum number of rows we need to draw
+        fulllist = []
+        threadlist = []
+        pscnt = 0
+        devcnt = 0
+        for data in testruns:
+                data.selectTimelineDevices('%f', tTotal, sysvals.mindevlen)
+                for group in data.devicegroups:
+                        devlist = []
+                        for phase in group:
+                                for devname in data.tdevlist[phase]:
+                                        d = DevItem(data.testnumber, phase, data.dmesg[phase]['list'][devname])
+                                        devlist.append(d)
+                                        if d.isa('kth'):
+                                                threadlist.append(d)
+                                        else:
+                                                if d.isa('ps'):
+                                                        pscnt += 1
+                                                else:
+                                                        devcnt += 1
+                                                fulllist.append(d)
+                        if sysvals.mixedphaseheight:
+                                devtl.getPhaseRows(devlist)
+        if not sysvals.mixedphaseheight:
+                if len(threadlist) > 0 and len(fulllist) > 0:
+                        if pscnt > 0 and devcnt > 0:
+                                msg = 'user processes & device pm callbacks'
+                        elif pscnt > 0:
+                                msg = 'user processes'
+                        else:
+                                msg = 'device pm callbacks'
+                        d = testruns[0].addHorizontalDivider(msg, testruns[-1].end)
+                        fulllist.insert(0, d)
+                devtl.getPhaseRows(fulllist)
+                if len(threadlist) > 0:
+                        d = testruns[0].addHorizontalDivider('asynchronous kernel threads', testruns[-1].end)
+                        threadlist.insert(0, d)
+                        devtl.getPhaseRows(threadlist, devtl.rows)
+        devtl.calcTotalRows()
+
+        # draw the full timeline
+        devtl.createZoomBox(sysvals.suspendmode, len(testruns))
+        phases = {'suspend':[],'resume':[]}
+        for phase in data.dmesg:
+                if 'resume' in phase:
+                        phases['resume'].append(phase)
+                else:
+                        phases['suspend'].append(phase)
+
+        # draw each test run chronologically
+        for data in testruns:
+                # now draw the actual timeline blocks
+                for dir in phases:
+                        # draw suspend and resume blocks separately
+                        bname = '%s%d' % (dir[0], data.testnumber)
+                        if dir == 'suspend':
+                                m0 = data.start
+                                mMax = data.tSuspended
+                                left = '%f' % (((m0-t0)*100.0)/tTotal)
+                        else:
+                                m0 = data.tSuspended
+                                mMax = data.end
+                                # in an x2 run, remove any gap between blocks
+                                if len(testruns) > 1 and data.testnumber == 0:
+                                        mMax = testruns[1].start
+                                left = '%f' % ((((m0-t0)*100.0)+sysvals.srgap/2)/tTotal)
+                        mTotal = mMax - m0
+                        # if a timeline block is 0 length, skip altogether
+                        if mTotal == 0:
+                                continue
+                        width = '%f' % (((mTotal*100.0)-sysvals.srgap/2)/tTotal)
+                        devtl.html += devtl.html_tblock.format(bname, left, width, devtl.scaleH)
+                        for b in sorted(phases[dir]):
+                                # draw the phase color background
+                                phase = data.dmesg[b]
+                                length = phase['end']-phase['start']
+                                left = '%f' % (((phase['start']-m0)*100.0)/mTotal)
+                                width = '%f' % ((length*100.0)/mTotal)
+                                devtl.html += devtl.html_phase.format(left, width, \
+                                        '%.3f'%devtl.scaleH, '%.3f'%devtl.bodyH, \
+                                        data.dmesg[b]['color'], '')
+                        for e in data.errorinfo[dir]:
+                                # draw red lines for any kernel errors found
+                                t, err = e
+                                right = '%f' % (((mMax-t)*100.0)/mTotal)
+                                devtl.html += html_error.format(right, err)
+                        for b in sorted(phases[dir]):
+                                # draw the devices for this phase
+                                phaselist = data.dmesg[b]['list']
+                                for d in data.tdevlist[b]:
+                                        name = d
+                                        drv = ''
+                                        dev = phaselist[d]
+                                        xtraclass = ''
+                                        xtrainfo = ''
+                                        xtrastyle = ''
+                                        if 'htmlclass' in dev:
+                                                xtraclass = dev['htmlclass']
+                                        if 'color' in dev:
+                                                xtrastyle = 'background:%s;' % dev['color']
+                                        if(d in sysvals.devprops):
+                                                name = sysvals.devprops[d].altName(d)
+                                                xtraclass = sysvals.devprops[d].xtraClass()
+                                                xtrainfo = sysvals.devprops[d].xtraInfo()
+                                        elif xtraclass == ' kth':
+                                                xtrainfo = ' kernel_thread'
+                                        if('drv' in dev and dev['drv']):
+                                                drv = ' {%s}' % dev['drv']
+                                        rowheight = devtl.phaseRowHeight(data.testnumber, b, dev['row'])
+                                        rowtop = devtl.phaseRowTop(data.testnumber, b, dev['row'])
+                                        top = '%.3f' % (rowtop + devtl.scaleH)
+                                        left = '%f' % (((dev['start']-m0)*100)/mTotal)
+                                        width = '%f' % (((dev['end']-dev['start'])*100)/mTotal)
+                                        length = ' (%0.3f ms) ' % ((dev['end']-dev['start'])*1000)
+                                        title = name+drv+xtrainfo+length
+                                        if sysvals.suspendmode == 'command':
+                                                title += sysvals.testcommand
+                                        elif xtraclass == ' ps':
+                                                if 'suspend' in b:
+                                                        title += 'pre_suspend_process'
+                                                else:
+                                                        title += 'post_resume_process'
+                                        else:
+                                                title += b
+                                        devtl.html += devtl.html_device.format(dev['id'], \
+                                                title, left, top, '%.3f'%rowheight, width, \
+                                                d+drv, xtraclass, xtrastyle)
+                                        if('cpuexec' in dev):
+                                                for t in sorted(dev['cpuexec']):
+                                                        start, end = t
+                                                        j = float(dev['cpuexec'][t]) / 5
+                                                        if j > 1.0:
+                                                                j = 1.0
+                                                        height = '%.3f' % (rowheight/3)
+                                                        top = '%.3f' % (rowtop + devtl.scaleH + 2*rowheight/3)
+                                                        left = '%f' % (((start-m0)*100)/mTotal)
+                                                        width = '%f' % ((end-start)*100/mTotal)
+                                                        color = 'rgba(255, 0, 0, %f)' % j
+                                                        devtl.html += \
+                                                                html_cpuexec.format(left, top, height, width, color)
+                                        if('src' not in dev):
+                                                continue
+                                        # draw any trace events for this device
+                                        for e in dev['src']:
+                                                height = '%.3f' % devtl.rowH
+                                                top = '%.3f' % (rowtop + devtl.scaleH + (e.row*devtl.rowH))
+                                                left = '%f' % (((e.time-m0)*100)/mTotal)
+                                                width = '%f' % (e.length*100/mTotal)
+                                                xtrastyle = ''
+                                                if e.color:
+                                                        xtrastyle = 'background:%s;' % e.color
+                                                devtl.html += \
+                                                        html_traceevent.format(e.title(), \
+                                                                left, top, height, width, e.text(), '', xtrastyle)
+                        # draw the time scale, try to make the number of labels readable
+                        devtl.createTimeScale(m0, mMax, tTotal, dir)
+                        devtl.html += '</div>\n'
+
+        # timeline is finished
+        devtl.html += '</div>\n</div>\n'
+
+        # draw a legend which describes the phases by color
+        if sysvals.suspendmode != 'command':
+                data = testruns[-1]
+                devtl.html += '<div class="legend">\n'
+                pdelta = 100.0/len(data.phases)
+                pmargin = pdelta / 4.0
+                for phase in data.phases:
+                        tmp = phase.split('_')
+                        id = tmp[0][0]
+                        if(len(tmp) > 1):
+                                id += tmp[1][0]
+                        order = '%.2f' % ((data.dmesg[phase]['order'] * pdelta) + pmargin)
+                        name = string.replace(phase, '_', ' &nbsp;')
+                        devtl.html += html_legend.format(order, \
+                                data.dmesg[phase]['color'], name, id)
+                devtl.html += '</div>\n'
+
+        hf = open(sysvals.htmlfile, 'w')
+
+        # no header or css if its embedded
+        if(sysvals.embedded):
+                hf.write('pass True tSus %.3f tRes %.3f tLow %.3f fwvalid %s tSus %.3f tRes %.3f\n' %
+                        (data.tSuspended-data.start, data.end-data.tSuspended, data.tLow, data.fwValid, \
+                                data.fwSuspend/1000000, data.fwResume/1000000))
+        else:
+                addCSS(hf, sysvals, len(testruns), kerror)
+
+        # write the device timeline
+        hf.write(devtl.html)
+        hf.write('<div id="devicedetailtitle"></div>\n')
+        hf.write('<div id="devicedetail" style="display:none;">\n')
+        # draw the colored boxes for the device detail section
+        for data in testruns:
+                hf.write('<div id="devicedetail%d">\n' % data.testnumber)
+                pscolor = 'linear-gradient(to top left, #ccc, #eee)'
+                hf.write(devtl.html_phaselet.format('pre_suspend_process', \
+                        '0', '0', pscolor))
+                for b in data.phases:
+                        phase = data.dmesg[b]
+                        length = phase['end']-phase['start']
+                        left = '%.3f' % (((phase['start']-t0)*100.0)/tTotal)
+                        width = '%.3f' % ((length*100.0)/tTotal)
+                        hf.write(devtl.html_phaselet.format(b, left, width, \
+                                data.dmesg[b]['color']))
+                hf.write(devtl.html_phaselet.format('post_resume_process', \
+                        '0', '0', pscolor))
+                if sysvals.suspendmode == 'command':
+                        hf.write(devtl.html_phaselet.format('cmdexec', '0', '0', pscolor))
+                hf.write('</div>\n')
+        hf.write('</div>\n')
+
+        # write the ftrace data (callgraph)
+        if sysvals.cgtest >= 0 and len(testruns) > sysvals.cgtest:
+                data = testruns[sysvals.cgtest]
+        else:
+                data = testruns[-1]
+        if(sysvals.usecallgraph and not sysvals.embedded):
+                addCallgraphs(sysvals, hf, data)
+
+        # add the test log as a hidden div
+        if sysvals.logmsg:
+                hf.write('<div id="testlog" style="display:none;">\n'+sysvals.logmsg+'</div>\n')
+        # add the dmesg log as a hidden div
+        if sysvals.addlogs and sysvals.dmesgfile:
+                hf.write('<div id="dmesglog" style="display:none;">\n')
+                lf = open(sysvals.dmesgfile, 'r')
+                for line in lf:
+                        line = line.replace('<', '&lt').replace('>', '&gt')
+                        hf.write(line)
+                lf.close()
+                hf.write('</div>\n')
+        # add the ftrace log as a hidden div
+        if sysvals.addlogs and sysvals.ftracefile:
+                hf.write('<div id="ftracelog" style="display:none;">\n')
+                lf = open(sysvals.ftracefile, 'r')
+                for line in lf:
+                        hf.write(line)
+                lf.close()
+                hf.write('</div>\n')
+
+        if(not sysvals.embedded):
+                # write the footer and close
+                addScriptCode(hf, testruns)
+                hf.write('</body>\n</html>\n')
+        else:
+                # embedded out will be loaded in a page, skip the js
+                t0 = (testruns[0].start - testruns[-1].tSuspended) * 1000
+                tMax = (testruns[-1].end - testruns[-1].tSuspended) * 1000
+                # add js code in a div entry for later evaluation
+                detail = 'var bounds = [%f,%f];\n' % (t0, tMax)
+                detail += 'var devtable = [\n'
+                for data in testruns:
+                        topo = data.deviceTopology()
+                        detail += '\t"%s",\n' % (topo)
+                detail += '];\n'
+                hf.write('<div id=customcode style=display:none>\n'+detail+'</div>\n')
+        hf.close()
+        return True
+
+def addCSS(hf, sv, testcount=1, kerror=False, extra=''):
+        kernel = sv.stamp['kernel']
+        host = sv.hostname[0].upper()+sv.hostname[1:]
+        mode = sv.suspendmode
+        if sv.suspendmode in suspendmodename:
+                mode = suspendmodename[sv.suspendmode]
+        title = host+' '+mode+' '+kernel
+
+        # various format changes by flags
+        cgchk = 'checked'
+        cgnchk = 'not(:checked)'
+        if sv.cgexp:
+                cgchk = 'not(:checked)'
+                cgnchk = 'checked'
+
+        hoverZ = 'z-index:8;'
+        if sv.usedevsrc:
+                hoverZ = ''
+
+        devlistpos = 'absolute'
+        if testcount > 1:
+                devlistpos = 'relative'
+
+        scaleTH = 20
+        if kerror:
+                scaleTH = 60
+
+        # write the html header first (html head, css code, up to body start)
+        html_header = '<!DOCTYPE html>\n<html>\n<head>\n\
+        <meta http-equiv="content-type" content="text/html; charset=UTF-8">\n\
+        <title>'+title+'</title>\n\
+        <style type=\'text/css\'>\n\
+                body {overflow-y:scroll;}\n\
+                .stamp {width:100%;text-align:center;background:gray;line-height:30px;color:white;font:25px Arial;}\n\
+                .callgraph {margin-top:30px;box-shadow:5px 5px 20px black;}\n\
+                .callgraph article * {padding-left:28px;}\n\
+                h1 {color:black;font:bold 30px Times;}\n\
+                t0 {color:black;font:bold 30px Times;}\n\
+                t1 {color:black;font:30px Times;}\n\
+                t2 {color:black;font:25px Times;}\n\
+                t3 {color:black;font:20px Times;white-space:nowrap;}\n\
+                t4 {color:black;font:bold 30px Times;line-height:60px;white-space:nowrap;}\n\
+                cS {font:bold 13px Times;}\n\
+                table {width:100%;}\n\
+                .gray {background:rgba(80,80,80,0.1);}\n\
+                .green {background:rgba(204,255,204,0.4);}\n\
+                .purple {background:rgba(128,0,128,0.2);}\n\
+                .yellow {background:rgba(255,255,204,0.4);}\n\
+                .blue {background:rgba(169,208,245,0.4);}\n\
+                .time1 {font:22px Arial;border:1px solid;}\n\
+                .time2 {font:15px Arial;border-bottom:1px solid;border-left:1px solid;border-right:1px solid;}\n\
+                td {text-align:center;}\n\
+                r {color:#500000;font:15px Tahoma;}\n\
+                n {color:#505050;font:15px Tahoma;}\n\
+                .tdhl {color:red;}\n\
+                .hide {display:none;}\n\
+                .pf {display:none;}\n\
+                .pf:'+cgchk+' + label {background:url(\'data:image/svg+xml;utf,<?xml version="1.0" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" height="18" width="18" version="1.1"><circle cx="9" cy="9" r="8" stroke="black" stroke-width="1" fill="white"/><rect x="4" y="8" width="10" height="2" style="fill:black;stroke-width:0"/><rect x="8" y="4" width="2" height="10" style="fill:black;stroke-width:0"/></svg>\') no-repeat left center;}\n\
+                .pf:'+cgnchk+' ~ label {background:url(\'data:image/svg+xml;utf,<?xml version="1.0" standalone="no"?><svg xmlns="http://www.w3.org/2000/svg" height="18" width="18" version="1.1"><circle cx="9" cy="9" r="8" stroke="black" stroke-width="1" fill="white"/><rect x="4" y="8" width="10" height="2" style="fill:black;stroke-width:0"/></svg>\') no-repeat left center;}\n\
+                .pf:'+cgchk+' ~ *:not(:nth-child(2)) {display:none;}\n\
+                .zoombox {position:relative;width:100%;overflow-x:scroll;-webkit-user-select:none;-moz-user-select:none;user-select:none;}\n\
+                .timeline {position:relative;font-size:14px;cursor:pointer;width:100%; overflow:hidden;background:linear-gradient(#cccccc, white);}\n\
+                .thread {position:absolute;height:0%;overflow:hidden;z-index:7;line-height:30px;font-size:14px;border:1px solid;text-align:center;white-space:nowrap;}\n\
+                .thread.ps {border-radius:3px;background:linear-gradient(to top, #ccc, #eee);}\n\
+                .thread:hover {background:white;border:1px solid red;'+hoverZ+'}\n\
+                .thread.sec,.thread.sec:hover {background:black;border:0;color:white;line-height:15px;font-size:10px;}\n\
+                .hover {background:white;border:1px solid red;'+hoverZ+'}\n\
+                .hover.sync {background:white;}\n\
+                .hover.bg,.hover.kth,.hover.sync,.hover.ps {background:white;}\n\
+                .jiffie {position:absolute;pointer-events: none;z-index:8;}\n\
+                .traceevent {position:absolute;font-size:10px;z-index:7;overflow:hidden;color:black;text-align:center;white-space:nowrap;border-radius:5px;border:1px solid black;background:linear-gradient(to bottom right,#CCC,#969696);}\n\
+                .traceevent:hover {color:white;font-weight:bold;border:1px solid white;}\n\
+                .phase {position:absolute;overflow:hidden;border:0px;text-align:center;}\n\
+                .phaselet {float:left;overflow:hidden;border:0px;text-align:center;min-height:100px;font-size:24px;}\n\
+                .t {position:absolute;line-height:'+('%d'%scaleTH)+'px;pointer-events:none;top:0;height:100%;border-right:1px solid black;z-index:6;}\n\
+                .err {position:absolute;top:0%;height:100%;border-right:3px solid red;color:red;font:bold 14px Times;line-height:18px;}\n\
+                .legend {position:relative; width:100%; height:40px; text-align:center;margin-bottom:20px}\n\
+                .legend .square {position:absolute;cursor:pointer;top:10px; width:0px;height:20px;border:1px solid;padding-left:20px;}\n\
+                button {height:40px;width:200px;margin-bottom:20px;margin-top:20px;font-size:24px;}\n\
+                .logbtn {position:relative;float:right;height:25px;width:50px;margin-top:3px;margin-bottom:0;font-size:10px;text-align:center;}\n\
+                .devlist {position:'+devlistpos+';width:190px;}\n\
+                a:link {color:white;text-decoration:none;}\n\
+                a:visited {color:white;}\n\
+                a:hover {color:white;}\n\
+                a:active {color:white;}\n\
+                .version {position:relative;float:left;color:white;font-size:10px;line-height:30px;margin-left:10px;}\n\
+                #devicedetail {min-height:100px;box-shadow:5px 5px 20px black;}\n\
+                .tblock {position:absolute;height:100%;background:#ddd;}\n\
+                .tback {position:absolute;width:100%;background:linear-gradient(#ccc, #ddd);}\n\
+                .bg {z-index:1;}\n\
+'+extra+'\
+        </style>\n</head>\n<body>\n'
+        hf.write(html_header)
+
+# Function: addScriptCode
+# Description:
+#        Adds the javascript code to the output html
+# Arguments:
+#        hf: the open html file pointer
+#        testruns: array of Data objects from parseKernelLog or parseTraceLog
+def addScriptCode(hf, testruns):
+        t0 = testruns[0].start * 1000
+        tMax = testruns[-1].end * 1000
+        # create an array in javascript memory with the device details
+        detail = '      var devtable = [];\n'
+        for data in testruns:
+                topo = data.deviceTopology()
+                detail += '     devtable[%d] = "%s";\n' % (data.testnumber, topo)
+        detail += '     var bounds = [%f,%f];\n' % (t0, tMax)
+        # add the code which will manipulate the data in the browser
+        script_code = \
+        '<script type="text/javascript">\n'+detail+\
+        '       var resolution = -1;\n'\
+        '       var dragval = [0, 0];\n'\
+        '       function redrawTimescale(t0, tMax, tS) {\n'\
+        '               var rline = \'<div class="t" style="left:0;border-left:1px solid black;border-right:0;">\';\n'\
+        '               var tTotal = tMax - t0;\n'\
+        '               var list = document.getElementsByClassName("tblock");\n'\
+        '               for (var i = 0; i < list.length; i++) {\n'\
+        '                       var timescale = list[i].getElementsByClassName("timescale")[0];\n'\
+        '                       var m0 = t0 + (tTotal*parseFloat(list[i].style.left)/100);\n'\
+        '                       var mTotal = tTotal*parseFloat(list[i].style.width)/100;\n'\
+        '                       var mMax = m0 + mTotal;\n'\
+        '                       var html = "";\n'\
+        '                       var divTotal = Math.floor(mTotal/tS) + 1;\n'\
+        '                       if(divTotal > 1000) continue;\n'\
+        '                       var divEdge = (mTotal - tS*(divTotal-1))*100/mTotal;\n'\
+        '                       var pos = 0.0, val = 0.0;\n'\
+        '                       for (var j = 0; j < divTotal; j++) {\n'\
+        '                               var htmlline = "";\n'\
+        '                               var mode = list[i].id[5];\n'\
+        '                               if(mode == "s") {\n'\
+        '                                       pos = 100 - (((j)*tS*100)/mTotal) - divEdge;\n'\
+        '                                       val = (j-divTotal+1)*tS;\n'\
+        '                                       if(j == divTotal - 1)\n'\
+        '                                               htmlline = \'<div class="t" style="right:\'+pos+\'%"><cS>S&rarr;</cS></div>\';\n'\
+        '                                       else\n'\
+        '                                               htmlline = \'<div class="t" style="right:\'+pos+\'%">\'+val+\'ms</div>\';\n'\
+        '                               } else {\n'\
+        '                                       pos = 100 - (((j)*tS*100)/mTotal);\n'\
+        '                                       val = (j)*tS;\n'\
+        '                                       htmlline = \'<div class="t" style="right:\'+pos+\'%">\'+val+\'ms</div>\';\n'\
+        '                                       if(j == 0)\n'\
+        '                                               if(mode == "r")\n'\
+        '                                                       htmlline = rline+"<cS>&larr;R</cS></div>";\n'\
+        '                                               else\n'\
+        '                                                       htmlline = rline+"<cS>0ms</div>";\n'\
+        '                               }\n'\
+        '                               html += htmlline;\n'\
+        '                       }\n'\
+        '                       timescale.innerHTML = html;\n'\
+        '               }\n'\
+        '       }\n'\
+        '       function zoomTimeline() {\n'\
+        '               var dmesg = document.getElementById("dmesg");\n'\
+        '               var zoombox = document.getElementById("dmesgzoombox");\n'\
+        '               var left = zoombox.scrollLeft;\n'\
+        '               var val = parseFloat(dmesg.style.width);\n'\
+        '               var newval = 100;\n'\
+        '               var sh = window.outerWidth / 2;\n'\
+        '               if(this.id == "zoomin") {\n'\
+        '                       newval = val * 1.2;\n'\
+        '                       if(newval > 910034) newval = 910034;\n'\
+        '                       dmesg.style.width = newval+"%";\n'\
+        '                       zoombox.scrollLeft = ((left + sh) * newval / val) - sh;\n'\
+        '               } else if (this.id == "zoomout") {\n'\
+        '                       newval = val / 1.2;\n'\
+        '                       if(newval < 100) newval = 100;\n'\
+        '                       dmesg.style.width = newval+"%";\n'\
+        '                       zoombox.scrollLeft = ((left + sh) * newval / val) - sh;\n'\
+        '               } else {\n'\
+        '                       zoombox.scrollLeft = 0;\n'\
+        '                       dmesg.style.width = "100%";\n'\
+        '               }\n'\
+        '               var tS = [10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1];\n'\
+        '               var t0 = bounds[0];\n'\
+        '               var tMax = bounds[1];\n'\
+        '               var tTotal = tMax - t0;\n'\
+        '               var wTotal = tTotal * 100.0 / newval;\n'\
+        '               var idx = 7*window.innerWidth/1100;\n'\
+        '               for(var i = 0; (i < tS.length)&&((wTotal / tS[i]) < idx); i++);\n'\
+        '               if(i >= tS.length) i = tS.length - 1;\n'\
+        '               if(tS[i] == resolution) return;\n'\
+        '               resolution = tS[i];\n'\
+        '               redrawTimescale(t0, tMax, tS[i]);\n'\
+        '       }\n'\
+        '       function deviceName(title) {\n'\
+        '               var name = title.slice(0, title.indexOf(" ("));\n'\
+        '               return name;\n'\
+        '       }\n'\
+        '       function deviceHover() {\n'\
+        '               var name = deviceName(this.title);\n'\
+        '               var dmesg = document.getElementById("dmesg");\n'\
+        '               var dev = dmesg.getElementsByClassName("thread");\n'\
+        '               var cpu = -1;\n'\
+        '               if(name.match("CPU_ON\[[0-9]*\]"))\n'\
+        '                       cpu = parseInt(name.slice(7));\n'\
+        '               else if(name.match("CPU_OFF\[[0-9]*\]"))\n'\
+        '                       cpu = parseInt(name.slice(8));\n'\
+        '               for (var i = 0; i < dev.length; i++) {\n'\
+        '                       dname = deviceName(dev[i].title);\n'\
+        '                       var cname = dev[i].className.slice(dev[i].className.indexOf("thread"));\n'\
+        '                       if((cpu >= 0 && dname.match("CPU_O[NF]*\\\[*"+cpu+"\\\]")) ||\n'\
+        '                               (name == dname))\n'\
+        '                       {\n'\
+        '                               dev[i].className = "hover "+cname;\n'\
+        '                       } else {\n'\
+        '                               dev[i].className = cname;\n'\
+        '                       }\n'\
+        '               }\n'\
+        '       }\n'\
+        '       function deviceUnhover() {\n'\
+        '               var dmesg = document.getElementById("dmesg");\n'\
+        '               var dev = dmesg.getElementsByClassName("thread");\n'\
+        '               for (var i = 0; i < dev.length; i++) {\n'\
+        '                       dev[i].className = dev[i].className.slice(dev[i].className.indexOf("thread"));\n'\
+        '               }\n'\
+        '       }\n'\
+        '       function deviceTitle(title, total, cpu) {\n'\
+        '               var prefix = "Total";\n'\
+        '               if(total.length > 3) {\n'\
+        '                       prefix = "Average";\n'\
+        '                       total[1] = (total[1]+total[3])/2;\n'\
+        '                       total[2] = (total[2]+total[4])/2;\n'\
+        '               }\n'\
+        '               var devtitle = document.getElementById("devicedetailtitle");\n'\
+        '               var name = deviceName(title);\n'\
+        '               if(cpu >= 0) name = "CPU"+cpu;\n'\
+        '               var driver = "";\n'\
+        '               var tS = "<t2>(</t2>";\n'\
+        '               var tR = "<t2>)</t2>";\n'\
+        '               if(total[1] > 0)\n'\
+        '                       tS = "<t2>("+prefix+" Suspend:</t2><t0> "+total[1].toFixed(3)+" ms</t0> ";\n'\
+        '               if(total[2] > 0)\n'\
+        '                       tR = " <t2>"+prefix+" Resume:</t2><t0> "+total[2].toFixed(3)+" ms<t2>)</t2></t0>";\n'\
+        '               var s = title.indexOf("{");\n'\
+        '               var e = title.indexOf("}");\n'\
+        '               if((s >= 0) && (e >= 0))\n'\
+        '                       driver = title.slice(s+1, e) + " <t1>@</t1> ";\n'\
+        '               if(total[1] > 0 && total[2] > 0)\n'\
+        '                       devtitle.innerHTML = "<t0>"+driver+name+"</t0> "+tS+tR;\n'\
+        '               else\n'\
+        '                       devtitle.innerHTML = "<t0>"+title+"</t0>";\n'\
+        '               return name;\n'\
+        '       }\n'\
+        '       function deviceDetail() {\n'\
+        '               var devinfo = document.getElementById("devicedetail");\n'\
+        '               devinfo.style.display = "block";\n'\
+        '               var name = deviceName(this.title);\n'\
+        '               var cpu = -1;\n'\
+        '               if(name.match("CPU_ON\[[0-9]*\]"))\n'\
+        '                       cpu = parseInt(name.slice(7));\n'\
+        '               else if(name.match("CPU_OFF\[[0-9]*\]"))\n'\
+        '                       cpu = parseInt(name.slice(8));\n'\
+        '               var dmesg = document.getElementById("dmesg");\n'\
+        '               var dev = dmesg.getElementsByClassName("thread");\n'\
+        '               var idlist = [];\n'\
+        '               var pdata = [[]];\n'\
+        '               if(document.getElementById("devicedetail1"))\n'\
+        '                       pdata = [[], []];\n'\
+        '               var pd = pdata[0];\n'\
+        '               var total = [0.0, 0.0, 0.0];\n'\
+        '               for (var i = 0; i < dev.length; i++) {\n'\
+        '                       dname = deviceName(dev[i].title);\n'\
+        '                       if((cpu >= 0 && dname.match("CPU_O[NF]*\\\[*"+cpu+"\\\]")) ||\n'\
+        '                               (name == dname))\n'\
+        '                       {\n'\
+        '                               idlist[idlist.length] = dev[i].id;\n'\
+        '                               var tidx = 1;\n'\
+        '                               if(dev[i].id[0] == "a") {\n'\
+        '                                       pd = pdata[0];\n'\
+        '                               } else {\n'\
+        '                                       if(pdata.length == 1) pdata[1] = [];\n'\
+        '                                       if(total.length == 3) total[3]=total[4]=0.0;\n'\
+        '                                       pd = pdata[1];\n'\
+        '                                       tidx = 3;\n'\
+        '                               }\n'\
+        '                               var info = dev[i].title.split(" ");\n'\
+        '                               var pname = info[info.length-1];\n'\
+        '                               pd[pname] = parseFloat(info[info.length-3].slice(1));\n'\
+        '                               total[0] += pd[pname];\n'\
+        '                               if(pname.indexOf("suspend") >= 0)\n'\
+        '                                       total[tidx] += pd[pname];\n'\
+        '                               else\n'\
+        '                                       total[tidx+1] += pd[pname];\n'\
+        '                       }\n'\
+        '               }\n'\
+        '               var devname = deviceTitle(this.title, total, cpu);\n'\
+        '               var left = 0.0;\n'\
+        '               for (var t = 0; t < pdata.length; t++) {\n'\
+        '                       pd = pdata[t];\n'\
+        '                       devinfo = document.getElementById("devicedetail"+t);\n'\
+        '                       var phases = devinfo.getElementsByClassName("phaselet");\n'\
+        '                       for (var i = 0; i < phases.length; i++) {\n'\
+        '                               if(phases[i].id in pd) {\n'\
+        '                                       var w = 100.0*pd[phases[i].id]/total[0];\n'\
+        '                                       var fs = 32;\n'\
+        '                                       if(w < 8) fs = 4*w | 0;\n'\
+        '                                       var fs2 = fs*3/4;\n'\
+        '                                       phases[i].style.width = w+"%";\n'\
+        '                                       phases[i].style.left = left+"%";\n'\
+        '                                       phases[i].title = phases[i].id+" "+pd[phases[i].id]+" ms";\n'\
+        '                                       left += w;\n'\
+        '                                       var time = "<t4 style=\\"font-size:"+fs+"px\\">"+pd[phases[i].id]+" ms<br></t4>";\n'\
+        '                                       var pname = "<t3 style=\\"font-size:"+fs2+"px\\">"+phases[i].id.replace(new RegExp("_", "g"), " ")+"</t3>";\n'\
+        '                                       phases[i].innerHTML = time+pname;\n'\
+        '                               } else {\n'\
+        '                                       phases[i].style.width = "0%";\n'\
+        '                                       phases[i].style.left = left+"%";\n'\
+        '                               }\n'\
+        '                       }\n'\
+        '               }\n'\
+        '               if(typeof devstats !== \'undefined\')\n'\
+        '                       callDetail(this.id, this.title);\n'\
+        '               var cglist = document.getElementById("callgraphs");\n'\
+        '               if(!cglist) return;\n'\
+        '               var cg = cglist.getElementsByClassName("atop");\n'\
+        '               if(cg.length < 10) return;\n'\
+        '               for (var i = 0; i < cg.length; i++) {\n'\
+        '                       cgid = cg[i].id.split("x")[0]\n'\
+        '                       if(idlist.indexOf(cgid) >= 0) {\n'\
+        '                               cg[i].style.display = "block";\n'\
+        '                       } else {\n'\
+        '                               cg[i].style.display = "none";\n'\
+        '                       }\n'\
+        '               }\n'\
+        '       }\n'\
+        '       function callDetail(devid, devtitle) {\n'\
+        '               if(!(devid in devstats) || devstats[devid].length < 1)\n'\
+        '                       return;\n'\
+        '               var list = devstats[devid];\n'\
+        '               var tmp = devtitle.split(" ");\n'\
+        '               var name = tmp[0], phase = tmp[tmp.length-1];\n'\
+        '               var dd = document.getElementById(phase);\n'\
+        '               var total = parseFloat(tmp[1].slice(1));\n'\
+        '               var mlist = [];\n'\
+        '               var maxlen = 0;\n'\
+        '               var info = []\n'\
+        '               for(var i in list) {\n'\
+        '                       if(list[i][0] == "@") {\n'\
+        '                               info = list[i].split("|");\n'\
+        '                               continue;\n'\
+        '                       }\n'\
+        '                       var tmp = list[i].split("|");\n'\
+        '                       var t = parseFloat(tmp[0]), f = tmp[1], c = parseInt(tmp[2]);\n'\
+        '                       var p = (t*100.0/total).toFixed(2);\n'\
+        '                       mlist[mlist.length] = [f, c, t.toFixed(2), p+"%"];\n'\
+        '                       if(f.length > maxlen)\n'\
+        '                               maxlen = f.length;\n'\
+        '               }\n'\
+        '               var pad = 5;\n'\
+        '               if(mlist.length == 0) pad = 30;\n'\
+        '               var html = \'<div style="padding-top:\'+pad+\'px"><t3> <b>\'+name+\':</b>\';\n'\
+        '               if(info.length > 2)\n'\
+        '                       html += " start=<b>"+info[1]+"</b>, end=<b>"+info[2]+"</b>";\n'\
+        '               if(info.length > 3)\n'\
+        '                       html += ", length<i>(w/o overhead)</i>=<b>"+info[3]+" ms</b>";\n'\
+        '               if(info.length > 4)\n'\
+        '                       html += ", return=<b>"+info[4]+"</b>";\n'\
+        '               html += "</t3></div>";\n'\
+        '               if(mlist.length > 0) {\n'\
+        '                       html += \'<table class=fstat style="padding-top:\'+(maxlen*5)+\'px;"><tr><th>Function</th>\';\n'\
+        '                       for(var i in mlist)\n'\
+        '                               html += "<td class=vt>"+mlist[i][0]+"</td>";\n'\
+        '                       html += "</tr><tr><th>Calls</th>";\n'\
+        '                       for(var i in mlist)\n'\
+        '                               html += "<td>"+mlist[i][1]+"</td>";\n'\
+        '                       html += "</tr><tr><th>Time(ms)</th>";\n'\
+        '                       for(var i in mlist)\n'\
+        '                               html += "<td>"+mlist[i][2]+"</td>";\n'\
+        '                       html += "</tr><tr><th>Percent</th>";\n'\
+        '                       for(var i in mlist)\n'\
+        '                               html += "<td>"+mlist[i][3]+"</td>";\n'\
+        '                       html += "</tr></table>";\n'\
+        '               }\n'\
+        '               dd.innerHTML = html;\n'\
+        '               var height = (maxlen*5)+100;\n'\
+        '               dd.style.height = height+"px";\n'\
+        '               document.getElementById("devicedetail").style.height = height+"px";\n'\
+        '       }\n'\
+        '       function callSelect() {\n'\
+        '               var cglist = document.getElementById("callgraphs");\n'\
+        '               if(!cglist) return;\n'\
+        '               var cg = cglist.getElementsByClassName("atop");\n'\
+        '               for (var i = 0; i < cg.length; i++) {\n'\
+        '                       if(this.id == cg[i].id) {\n'\
+        '                               cg[i].style.display = "block";\n'\
+        '                       } else {\n'\
+        '                               cg[i].style.display = "none";\n'\
+        '                       }\n'\
+        '               }\n'\
+        '       }\n'\
+        '       function devListWindow(e) {\n'\
+        '               var win = window.open();\n'\
+        '               var html = "<title>"+e.target.innerHTML+"</title>"+\n'\
+        '                       "<style type=\\"text/css\\">"+\n'\
+        '                       "   ul {list-style-type:circle;padding-left:10px;margin-left:10px;}"+\n'\
+        '                       "</style>"\n'\
+        '               var dt = devtable[0];\n'\
+        '               if(e.target.id != "devlist1")\n'\
+        '                       dt = devtable[1];\n'\
+        '               win.document.write(html+dt);\n'\
+        '       }\n'\
+        '       function errWindow() {\n'\
+        '               var text = this.id;\n'\
+        '               var win = window.open();\n'\
+        '               win.document.write("<pre>"+text+"</pre>");\n'\
+        '               win.document.close();\n'\
+        '       }\n'\
+        '       function logWindow(e) {\n'\
+        '               var name = e.target.id.slice(4);\n'\
+        '               var win = window.open();\n'\
+        '               var log = document.getElementById(name+"log");\n'\
+        '               var title = "<title>"+document.title.split(" ")[0]+" "+name+" log</title>";\n'\
+        '               win.document.write(title+"<pre>"+log.innerHTML+"</pre>");\n'\
+        '               win.document.close();\n'\
+        '       }\n'\
+        '       function onClickPhase(e) {\n'\
+        '       }\n'\
+        '       function onMouseDown(e) {\n'\
+        '               dragval[0] = e.clientX;\n'\
+        '               dragval[1] = document.getElementById("dmesgzoombox").scrollLeft;\n'\
+        '               document.onmousemove = onMouseMove;\n'\
+        '       }\n'\
+        '       function onMouseMove(e) {\n'\
+        '               var zoombox = document.getElementById("dmesgzoombox");\n'\
+        '               zoombox.scrollLeft = dragval[1] + dragval[0] - e.clientX;\n'\
+        '       }\n'\
+        '       function onMouseUp(e) {\n'\
+        '               document.onmousemove = null;\n'\
+        '       }\n'\
+        '       function onKeyPress(e) {\n'\
+        '               var c = e.charCode;\n'\
+        '               if(c != 42 && c != 43 && c != 45) return;\n'\
+        '               var click = document.createEvent("Events");\n'\
+        '               click.initEvent("click", true, false);\n'\
+        '               if(c == 43)  \n'\
+        '                       document.getElementById("zoomin").dispatchEvent(click);\n'\
+        '               else if(c == 45)\n'\
+        '                       document.getElementById("zoomout").dispatchEvent(click);\n'\
+        '               else if(c == 42)\n'\
+        '                       document.getElementById("zoomdef").dispatchEvent(click);\n'\
+        '       }\n'\
+        '       window.addEventListener("resize", function () {zoomTimeline();});\n'\
+        '       window.addEventListener("load", function () {\n'\
+        '               var dmesg = document.getElementById("dmesg");\n'\
+        '               dmesg.style.width = "100%"\n'\
+        '               dmesg.onmousedown = onMouseDown;\n'\
+        '               document.onmouseup = onMouseUp;\n'\
+        '               document.onkeypress = onKeyPress;\n'\
+        '               document.getElementById("zoomin").onclick = zoomTimeline;\n'\
+        '               document.getElementById("zoomout").onclick = zoomTimeline;\n'\
+        '               document.getElementById("zoomdef").onclick = zoomTimeline;\n'\
+        '               var list = document.getElementsByClassName("square");\n'\
+        '               for (var i = 0; i < list.length; i++)\n'\
+        '                       list[i].onclick = onClickPhase;\n'\
+        '               var list = document.getElementsByClassName("err");\n'\
+        '               for (var i = 0; i < list.length; i++)\n'\
+        '                       list[i].onclick = errWindow;\n'\
+        '               var list = document.getElementsByClassName("logbtn");\n'\
+        '               for (var i = 0; i < list.length; i++)\n'\
+        '                       list[i].onclick = logWindow;\n'\
+        '               list = document.getElementsByClassName("devlist");\n'\
+        '               for (var i = 0; i < list.length; i++)\n'\
+        '                       list[i].onclick = devListWindow;\n'\
+        '               var dev = dmesg.getElementsByClassName("thread");\n'\
+        '               for (var i = 0; i < dev.length; i++) {\n'\
+        '                       dev[i].onclick = deviceDetail;\n'\
+        '                       dev[i].onmouseover = deviceHover;\n'\
+        '                       dev[i].onmouseout = deviceUnhover;\n'\
+        '               }\n'\
+        '               var dev = dmesg.getElementsByClassName("srccall");\n'\
+        '               for (var i = 0; i < dev.length; i++)\n'\
+        '                       dev[i].onclick = callSelect;\n'\
+        '               zoomTimeline();\n'\
+        '       });\n'\
+        '</script>\n'
+        hf.write(script_code);
+
+# Function: executeSuspend
+# Description:
+#        Execute system suspend through the sysfs interface, then copy the output
+#        dmesg and ftrace files to the test output directory.
+def executeSuspend():
+        pm = ProcessMonitor()
+        tp = sysvals.tpath
+        fwdata = []
+        # mark the start point in the kernel ring buffer just as we start
+        sysvals.initdmesg()
+        # start ftrace
+        if(sysvals.usecallgraph or sysvals.usetraceevents):
+                print('START TRACING')
+                sysvals.fsetVal('1', 'tracing_on')
+                if sysvals.useprocmon:
+                        pm.start()
+        # execute however many s/r runs requested
+        for count in range(1,sysvals.execcount+1):
+                # x2delay in between test runs
+                if(count > 1 and sysvals.x2delay > 0):
+                        sysvals.fsetVal('WAIT %d' % sysvals.x2delay, 'trace_marker')
+                        time.sleep(sysvals.x2delay/1000.0)
+                        sysvals.fsetVal('WAIT END', 'trace_marker')
+                # start message
+                if sysvals.testcommand != '':
+                        print('COMMAND START')
+                else:
+                        if(sysvals.rtcwake):
+                                print('SUSPEND START')
+                        else:
+                                print('SUSPEND START (press a key to resume)')
+                # set rtcwake
+                if(sysvals.rtcwake):
+                        print('will issue an rtcwake in %d seconds' % sysvals.rtcwaketime)
+                        sysvals.rtcWakeAlarmOn()
+                # start of suspend trace marker
+                if(sysvals.usecallgraph or sysvals.usetraceevents):
+                        sysvals.fsetVal('SUSPEND START', 'trace_marker')
+                # predelay delay
+                if(count == 1 and sysvals.predelay > 0):
+                        sysvals.fsetVal('WAIT %d' % sysvals.predelay, 'trace_marker')
+                        time.sleep(sysvals.predelay/1000.0)
+                        sysvals.fsetVal('WAIT END', 'trace_marker')
+                # initiate suspend or command
+                if sysvals.testcommand != '':
+                        call(sysvals.testcommand+' 2>&1', shell=True);
+                else:
+                        pf = open(sysvals.powerfile, 'w')
+                        pf.write(sysvals.suspendmode)
+                        # execution will pause here
+                        try:
+                                pf.close()
+                        except:
+                                pass
+                if(sysvals.rtcwake):
+                        sysvals.rtcWakeAlarmOff()
+                # postdelay delay
+                if(count == sysvals.execcount and sysvals.postdelay > 0):
+                        sysvals.fsetVal('WAIT %d' % sysvals.postdelay, 'trace_marker')
+                        time.sleep(sysvals.postdelay/1000.0)
+                        sysvals.fsetVal('WAIT END', 'trace_marker')
+                # return from suspend
+                print('RESUME COMPLETE')
+                if(sysvals.usecallgraph or sysvals.usetraceevents):
+                        sysvals.fsetVal('RESUME COMPLETE', 'trace_marker')
+                if(sysvals.suspendmode == 'mem' or sysvals.suspendmode == 'command'):
+                        fwdata.append(getFPDT(False))
+        # stop ftrace
+        if(sysvals.usecallgraph or sysvals.usetraceevents):
+                if sysvals.useprocmon:
+                        pm.stop()
+                sysvals.fsetVal('0', 'tracing_on')
+                print('CAPTURING TRACE')
+                writeDatafileHeader(sysvals.ftracefile, fwdata)
+                call('cat '+tp+'trace >> '+sysvals.ftracefile, shell=True)
+                sysvals.fsetVal('', 'trace')
+                devProps()
+        # grab a copy of the dmesg output
+        print('CAPTURING DMESG')
+        writeDatafileHeader(sysvals.dmesgfile, fwdata)
+        sysvals.getdmesg()
+
+def writeDatafileHeader(filename, fwdata):
+        fp = open(filename, 'a')
+        fp.write(sysvals.teststamp+'\n')
+        if(sysvals.suspendmode == 'mem' or sysvals.suspendmode == 'command'):
+                for fw in fwdata:
+                        if(fw):
+                                fp.write('# fwsuspend %u fwresume %u\n' % (fw[0], fw[1]))
+        fp.close()
+
+# Function: setUSBDevicesAuto
+# Description:
+#        Set the autosuspend control parameter of all USB devices to auto
+#        This can be dangerous, so use at your own risk, most devices are set
+#        to always-on since the kernel cant determine if the device can
+#        properly autosuspend
+def setUSBDevicesAuto():
+        rootCheck(True)
+        for dirname, dirnames, filenames in os.walk('/sys/devices'):
+                if(re.match('.*/usb[0-9]*.*', dirname) and
+                        'idVendor' in filenames and 'idProduct' in filenames):
+                        call('echo auto > %s/power/control' % dirname, shell=True)
+                        name = dirname.split('/')[-1]
+                        desc = Popen(['cat', '%s/product' % dirname],
+                                stderr=PIPE, stdout=PIPE).stdout.read().replace('\n', '')
+                        ctrl = Popen(['cat', '%s/power/control' % dirname],
+                                stderr=PIPE, stdout=PIPE).stdout.read().replace('\n', '')
+                        print('control is %s for %6s: %s' % (ctrl, name, desc))
+
+# Function: yesno
+# Description:
+#        Print out an equivalent Y or N for a set of known parameter values
+# Output:
+#        'Y', 'N', or ' ' if the value is unknown
+def yesno(val):
+        yesvals = ['auto', 'enabled', 'active', '1']
+        novals = ['on', 'disabled', 'suspended', 'forbidden', 'unsupported']
+        if val in yesvals:
+                return 'Y'
+        elif val in novals:
+                return 'N'
+        return ' '
+
+# Function: ms2nice
+# Description:
+#        Print out a very concise time string in minutes and seconds
+# Output:
+#        The time string, e.g. "1901m16s"
+def ms2nice(val):
+        ms = 0
+        try:
+                ms = int(val)
+        except:
+                return 0.0
+        m = ms / 60000
+        s = (ms / 1000) - (m * 60)
+        return '%3dm%2ds' % (m, s)
+
+# Function: detectUSB
+# Description:
+#        Detect all the USB hosts and devices currently connected and add
+#        a list of USB device names to sysvals for better timeline readability
+def detectUSB():
+        field = {'idVendor':'', 'idProduct':'', 'product':'', 'speed':''}
+        power = {'async':'', 'autosuspend':'', 'autosuspend_delay_ms':'',
+                         'control':'', 'persist':'', 'runtime_enabled':'',
+                         'runtime_status':'', 'runtime_usage':'',
+                        'runtime_active_time':'',
+                        'runtime_suspended_time':'',
+                        'active_duration':'',
+                        'connected_duration':''}
+
+        print('LEGEND')
+        print('---------------------------------------------------------------------------------------------')
+        print('  A = async/sync PM queue Y/N                       D = autosuspend delay (seconds)')
+        print('  S = autosuspend Y/N                         rACTIVE = runtime active (min/sec)')
+        print('  P = persist across suspend Y/N              rSUSPEN = runtime suspend (min/sec)')
+        print('  E = runtime suspend enabled/forbidden Y/N    ACTIVE = active duration (min/sec)')
+        print('  R = runtime status active/suspended Y/N     CONNECT = connected duration (min/sec)')
+        print('  U = runtime usage count')
+        print('---------------------------------------------------------------------------------------------')
+        print('  NAME       ID      DESCRIPTION         SPEED A S P E R U D rACTIVE rSUSPEN  ACTIVE CONNECT')
+        print('---------------------------------------------------------------------------------------------')
+
+        for dirname, dirnames, filenames in os.walk('/sys/devices'):
+                if(re.match('.*/usb[0-9]*.*', dirname) and
+                        'idVendor' in filenames and 'idProduct' in filenames):
+                        for i in field:
+                                field[i] = Popen(['cat', '%s/%s' % (dirname, i)],
+                                        stderr=PIPE, stdout=PIPE).stdout.read().replace('\n', '')
+                        name = dirname.split('/')[-1]
+                        for i in power:
+                                power[i] = Popen(['cat', '%s/power/%s' % (dirname, i)],
+                                        stderr=PIPE, stdout=PIPE).stdout.read().replace('\n', '')
+                        if(re.match('usb[0-9]*', name)):
+                                first = '%-8s' % name
+                        else:
+                                first = '%8s' % name
+                        print('%s [%s:%s] %-20s %-4s %1s %1s %1s %1s %1s %1s %1s %s %s %s %s' % \
+                                (first, field['idVendor'], field['idProduct'], \
+                                field['product'][0:20], field['speed'], \
+                                yesno(power['async']), \
+                                yesno(power['control']), \
+                                yesno(power['persist']), \
+                                yesno(power['runtime_enabled']), \
+                                yesno(power['runtime_status']), \
+                                power['runtime_usage'], \
+                                power['autosuspend'], \
+                                ms2nice(power['runtime_active_time']), \
+                                ms2nice(power['runtime_suspended_time']), \
+                                ms2nice(power['active_duration']), \
+                                ms2nice(power['connected_duration'])))
+
+# Function: devProps
+# Description:
+#        Retrieve a list of properties for all devices in the trace log
+def devProps(data=0):
+        props = dict()
+
+        if data:
+                idx = data.index(': ') + 2
+                if idx >= len(data):
+                        return
+                devlist = data[idx:].split(';')
+                for dev in devlist:
+                        f = dev.split(',')
+                        if len(f) < 3:
+                                continue
+                        dev = f[0]
+                        props[dev] = DevProps()
+                        props[dev].altname = f[1]
+                        if int(f[2]):
+                                props[dev].async = True
+                        else:
+                                props[dev].async = False
+                        sysvals.devprops = props
+                if sysvals.suspendmode == 'command' and 'testcommandstring' in props:
+                        sysvals.testcommand = props['testcommandstring'].altname
+                return
+
+        if(os.path.exists(sysvals.ftracefile) == False):
+                doError('%s does not exist' % sysvals.ftracefile)
+
+        # first get the list of devices we need properties for
+        msghead = 'Additional data added by AnalyzeSuspend'
+        alreadystamped = False
+        tp = TestProps()
+        tf = open(sysvals.ftracefile, 'r')
+        for line in tf:
+                if msghead in line:
+                        alreadystamped = True
+                        continue
+                # determine the trace data type (required for further parsing)
+                m = re.match(sysvals.tracertypefmt, line)
+                if(m):
+                        tp.setTracerType(m.group('t'))
+                        continue
+                # parse only valid lines, if this is not one move on
+                m = re.match(tp.ftrace_line_fmt, line)
+                if(not m or 'device_pm_callback_start' not in line):
+                        continue
+                m = re.match('.*: (?P<drv>.*) (?P<d>.*), parent: *(?P<p>.*), .*', m.group('msg'));
+                if(not m):
+                        continue
+                dev = m.group('d')
+                if dev not in props:
+                        props[dev] = DevProps()
+        tf.close()
+
+        if not alreadystamped and sysvals.suspendmode == 'command':
+                out = '#\n# '+msghead+'\n# Device Properties: '
+                out += 'testcommandstring,%s,0;' % (sysvals.testcommand)
+                with open(sysvals.ftracefile, 'a') as fp:
+                        fp.write(out+'\n')
+                sysvals.devprops = props
+                return
+
+        # now get the syspath for each of our target devices
+        for dirname, dirnames, filenames in os.walk('/sys/devices'):
+                if(re.match('.*/power', dirname) and 'async' in filenames):
+                        dev = dirname.split('/')[-2]
+                        if dev in props and (not props[dev].syspath or len(dirname) < len(props[dev].syspath)):
+                                props[dev].syspath = dirname[:-6]
+
+        # now fill in the properties for our target devices
+        for dev in props:
+                dirname = props[dev].syspath
+                if not dirname or not os.path.exists(dirname):
+                        continue
+                with open(dirname+'/power/async') as fp:
+                        text = fp.read()
+                        props[dev].async = False
+                        if 'enabled' in text:
+                                props[dev].async = True
+                fields = os.listdir(dirname)
+                if 'product' in fields:
+                        with open(dirname+'/product') as fp:
+                                props[dev].altname = fp.read()
+                elif 'name' in fields:
+                        with open(dirname+'/name') as fp:
+                                props[dev].altname = fp.read()
+                elif 'model' in fields:
+                        with open(dirname+'/model') as fp:
+                                props[dev].altname = fp.read()
+                elif 'description' in fields:
+                        with open(dirname+'/description') as fp:
+                                props[dev].altname = fp.read()
+                elif 'id' in fields:
+                        with open(dirname+'/id') as fp:
+                                props[dev].altname = fp.read()
+                elif 'idVendor' in fields and 'idProduct' in fields:
+                        idv, idp = '', ''
+                        with open(dirname+'/idVendor') as fp:
+                                idv = fp.read().strip()
+                        with open(dirname+'/idProduct') as fp:
+                                idp = fp.read().strip()
+                        props[dev].altname = '%s:%s' % (idv, idp)
+
+                if props[dev].altname:
+                        out = props[dev].altname.strip().replace('\n', ' ')
+                        out = out.replace(',', ' ')
+                        out = out.replace(';', ' ')
+                        props[dev].altname = out
+
+        # and now write the data to the ftrace file
+        if not alreadystamped:
+                out = '#\n# '+msghead+'\n# Device Properties: '
+                for dev in sorted(props):
+                        out += props[dev].out(dev)
+                with open(sysvals.ftracefile, 'a') as fp:
+                        fp.write(out+'\n')
+
+        sysvals.devprops = props
+
+# Function: getModes
+# Description:
+#        Determine the supported power modes on this system
+# Output:
+#        A string list of the available modes
+def getModes():
+        modes = ''
+        if(os.path.exists(sysvals.powerfile)):
+                fp = open(sysvals.powerfile, 'r')
+                modes = string.split(fp.read())
+                fp.close()
+        return modes
+
+# Function: getFPDT
+# Description:
+#        Read the acpi bios tables and pull out FPDT, the firmware data
+# Arguments:
+#        output: True to output the info to stdout, False otherwise
+def getFPDT(output):
+        rectype = {}
+        rectype[0] = 'Firmware Basic Boot Performance Record'
+        rectype[1] = 'S3 Performance Table Record'
+        prectype = {}
+        prectype[0] = 'Basic S3 Resume Performance Record'
+        prectype[1] = 'Basic S3 Suspend Performance Record'
+
+        rootCheck(True)
+        if(not os.path.exists(sysvals.fpdtpath)):
+                if(output):
+                        doError('file does not exist: %s' % sysvals.fpdtpath)
+                return False
+        if(not os.access(sysvals.fpdtpath, os.R_OK)):
+                if(output):
+                        doError('file is not readable: %s' % sysvals.fpdtpath)
+                return False
+        if(not os.path.exists(sysvals.mempath)):
+                if(output):
+                        doError('file does not exist: %s' % sysvals.mempath)
+                return False
+        if(not os.access(sysvals.mempath, os.R_OK)):
+                if(output):
+                        doError('file is not readable: %s' % sysvals.mempath)
+                return False
+
+        fp = open(sysvals.fpdtpath, 'rb')
+        buf = fp.read()
+        fp.close()
+
+        if(len(buf) < 36):
+                if(output):
+                        doError('Invalid FPDT table data, should '+\
+                                'be at least 36 bytes')
+                return False
+
+        table = struct.unpack('4sIBB6s8sI4sI', buf[0:36])
+        if(output):
+                print('')
+                print('Firmware Performance Data Table (%s)' % table[0])
+                print('                  Signature : %s' % table[0])
+                print('               Table Length : %u' % table[1])
+                print('                   Revision : %u' % table[2])
+                print('                   Checksum : 0x%x' % table[3])
+                print('                     OEM ID : %s' % table[4])
+                print('               OEM Table ID : %s' % table[5])
+                print('               OEM Revision : %u' % table[6])
+                print('                 Creator ID : %s' % table[7])
+                print('           Creator Revision : 0x%x' % table[8])
+                print('')
+
+        if(table[0] != 'FPDT'):
+                if(output):
+                        doError('Invalid FPDT table')
+                return False
+        if(len(buf) <= 36):
+                return False
+        i = 0
+        fwData = [0, 0]
+        records = buf[36:]
+        fp = open(sysvals.mempath, 'rb')
+        while(i < len(records)):
+                header = struct.unpack('HBB', records[i:i+4])
+                if(header[0] not in rectype):
+                        i += header[1]
+                        continue
+                if(header[1] != 16):
+                        i += header[1]
+                        continue
+                addr = struct.unpack('Q', records[i+8:i+16])[0]
+                try:
+                        fp.seek(addr)
+                        first = fp.read(8)
+                except:
+                        if(output):
+                                print('Bad address 0x%x in %s' % (addr, sysvals.mempath))
+                        return [0, 0]
+                rechead = struct.unpack('4sI', first)
+                recdata = fp.read(rechead[1]-8)
+                if(rechead[0] == 'FBPT'):
+                        record = struct.unpack('HBBIQQQQQ', recdata)
+                        if(output):
+                                print('%s (%s)' % (rectype[header[0]], rechead[0]))
+                                print('                  Reset END : %u ns' % record[4])
+                                print('  OS Loader LoadImage Start : %u ns' % record[5])
+                                print(' OS Loader StartImage Start : %u ns' % record[6])
+                                print('     ExitBootServices Entry : %u ns' % record[7])
+                                print('      ExitBootServices Exit : %u ns' % record[8])
+                elif(rechead[0] == 'S3PT'):
+                        if(output):
+                                print('%s (%s)' % (rectype[header[0]], rechead[0]))
+                        j = 0
+                        while(j < len(recdata)):
+                                prechead = struct.unpack('HBB', recdata[j:j+4])
+                                if(prechead[0] not in prectype):
+                                        continue
+                                if(prechead[0] == 0):
+                                        record = struct.unpack('IIQQ', recdata[j:j+prechead[1]])
+                                        fwData[1] = record[2]
+                                        if(output):
+                                                print('    %s' % prectype[prechead[0]])
+                                                print('               Resume Count : %u' % \
+                                                        record[1])
+                                                print('                 FullResume : %u ns' % \
+                                                        record[2])
+                                                print('              AverageResume : %u ns' % \
+                                                        record[3])
+                                elif(prechead[0] == 1):
+                                        record = struct.unpack('QQ', recdata[j+4:j+prechead[1]])
+                                        fwData[0] = record[1] - record[0]
+                                        if(output):
+                                                print('    %s' % prectype[prechead[0]])
+                                                print('               SuspendStart : %u ns' % \
+                                                        record[0])
+                                                print('                 SuspendEnd : %u ns' % \
+                                                        record[1])
+                                                print('                SuspendTime : %u ns' % \
+                                                        fwData[0])
+                                j += prechead[1]
+                if(output):
+                        print('')
+                i += header[1]
+        fp.close()
+        return fwData
+
+# Function: statusCheck
+# Description:
+#        Verify that the requested command and options will work, and
+#        print the results to the terminal
+# Output:
+#        True if the test will work, False if not
+def statusCheck(probecheck=False):
+        status = True
+
+        print('Checking this system (%s)...' % platform.node())
+
+        # check we have root access
+        res = sysvals.colorText('NO (No features of this tool will work!)')
+        if(rootCheck(False)):
+                res = 'YES'
+        print('    have root access: %s' % res)
+        if(res != 'YES'):
+                print('    Try running this script with sudo')
+                return False
+
+        # check sysfs is mounted
+        res = sysvals.colorText('NO (No features of this tool will work!)')
+        if(os.path.exists(sysvals.powerfile)):
+                res = 'YES'
+        print('    is sysfs mounted: %s' % res)
+        if(res != 'YES'):
+                return False
+
+        # check target mode is a valid mode
+        if sysvals.suspendmode != 'command':
+                res = sysvals.colorText('NO')
+                modes = getModes()
+                if(sysvals.suspendmode in modes):
+                        res = 'YES'
+                else:
+                        status = False
+                print('    is "%s" a valid power mode: %s' % (sysvals.suspendmode, res))
+                if(res == 'NO'):
+                        print('      valid power modes are: %s' % modes)
+                        print('      please choose one with -m')
+
+        # check if ftrace is available
+        res = sysvals.colorText('NO')
+        ftgood = sysvals.verifyFtrace()
+        if(ftgood):
+                res = 'YES'
+        elif(sysvals.usecallgraph):
+                status = False
+        print('    is ftrace supported: %s' % res)
+
+        # check if kprobes are available
+        res = sysvals.colorText('NO')
+        sysvals.usekprobes = sysvals.verifyKprobes()
+        if(sysvals.usekprobes):
+                res = 'YES'
+        else:
+                sysvals.usedevsrc = False
+        print('    are kprobes supported: %s' % res)
+
+        # what data source are we using
+        res = 'DMESG'
+        if(ftgood):
+                sysvals.usetraceeventsonly = True
+                sysvals.usetraceevents = False
+                for e in sysvals.traceevents:
+                        check = False
+                        if(os.path.exists(sysvals.epath+e)):
+                                check = True
+                        if(not check):
+                                sysvals.usetraceeventsonly = False
+                        if(e == 'suspend_resume' and check):
+                                sysvals.usetraceevents = True
+                if(sysvals.usetraceevents and sysvals.usetraceeventsonly):
+                        res = 'FTRACE (all trace events found)'
+                elif(sysvals.usetraceevents):
+                        res = 'DMESG and FTRACE (suspend_resume trace event found)'
+        print('    timeline data source: %s' % res)
+
+        # check if rtcwake
+        res = sysvals.colorText('NO')
+        if(sysvals.rtcpath != ''):
+                res = 'YES'
+        elif(sysvals.rtcwake):
+                status = False
+        print('    is rtcwake supported: %s' % res)
+
+        if not probecheck:
+                return status
+
+        # verify kprobes
+        if sysvals.usekprobes:
+                for name in sysvals.tracefuncs:
+                        sysvals.defaultKprobe(name, sysvals.tracefuncs[name])
+                if sysvals.usedevsrc:
+                        for name in sysvals.dev_tracefuncs:
+                                sysvals.defaultKprobe(name, sysvals.dev_tracefuncs[name])
+                sysvals.addKprobes(True)
+
+        return status
+
+# Function: doError
+# Description:
+#        generic error function for catastrphic failures
+# Arguments:
+#        msg: the error message to print
+#        help: True if printHelp should be called after, False otherwise
+def doError(msg, help=False):
+        if(help == True):
+                printHelp()
+        print('ERROR: %s\n') % msg
+        sys.exit()
+
+# Function: rootCheck
+# Description:
+#        quick check to see if we have root access
+def rootCheck(fatal):
+        if(os.access(sysvals.powerfile, os.W_OK)):
+                return True
+        if fatal:
+                doError('This command requires sysfs mount and root access')
+        return False
+
+# Function: getArgInt
+# Description:
+#        pull out an integer argument from the command line with checks
+def getArgInt(name, args, min, max, main=True):
+        if main:
+                try:
+                        arg = args.next()
+                except:
+                        doError(name+': no argument supplied', True)
+        else:
+                arg = args
+        try:
+                val = int(arg)
+        except:
+                doError(name+': non-integer value given', True)
+        if(val < min or val > max):
+                doError(name+': value should be between %d and %d' % (min, max), True)
+        return val
+
+# Function: getArgFloat
+# Description:
+#        pull out a float argument from the command line with checks
+def getArgFloat(name, args, min, max, main=True):
+        if main:
+                try:
+                        arg = args.next()
+                except:
+                        doError(name+': no argument supplied', True)
+        else:
+                arg = args
+        try:
+                val = float(arg)
+        except:
+                doError(name+': non-numerical value given', True)
+        if(val < min or val > max):
+                doError(name+': value should be between %f and %f' % (min, max), True)
+        return val
+
+def processData():
+        print('PROCESSING DATA')
+        if(sysvals.usetraceeventsonly):
+                testruns = parseTraceLog()
+                if sysvals.dmesgfile:
+                        dmesgtext = loadKernelLog(True)
+                        for data in testruns:
+                                data.extractErrorInfo(dmesgtext)
+        else:
+                testruns = loadKernelLog()
+                for data in testruns:
+                        parseKernelLog(data)
+                if(sysvals.ftracefile and (sysvals.usecallgraph or sysvals.usetraceevents)):
+                        appendIncompleteTraceLog(testruns)
+        createHTML(testruns)
+
+# Function: rerunTest
+# Description:
+#        generate an output from an existing set of ftrace/dmesg logs
+def rerunTest():
+        if sysvals.ftracefile:
+                doesTraceLogHaveTraceEvents()
+        if not sysvals.dmesgfile and not sysvals.usetraceeventsonly:
+                doError('recreating this html output requires a dmesg file')
+        sysvals.setOutputFile()
+        vprint('Output file: %s' % sysvals.htmlfile)
+        if(os.path.exists(sysvals.htmlfile) and not os.access(sysvals.htmlfile, os.W_OK)):
+                doError('missing permission to write to %s' % sysvals.htmlfile)
+        processData()
+
+# Function: runTest
+# Description:
+#        execute a suspend/resume, gather the logs, and generate the output
+def runTest(subdir, testpath=''):
+        # prepare for the test
+        sysvals.initFtrace()
+        sysvals.initTestOutput(subdir, testpath)
+        vprint('Output files:\n\t%s\n\t%s\n\t%s' % \
+                (sysvals.dmesgfile, sysvals.ftracefile, sysvals.htmlfile))
+
+        # execute the test
+        executeSuspend()
+        sysvals.cleanupFtrace()
+        processData()
+
+        # if running as root, change output dir owner to sudo_user
+        if os.path.isdir(sysvals.testdir) and os.getuid() == 0 and \
+                'SUDO_USER' in os.environ:
+                cmd = 'chown -R {0}:{0} {1} > /dev/null 2>&1'
+                call(cmd.format(os.environ['SUDO_USER'], sysvals.testdir), shell=True)
+
+def find_in_html(html, strs, div=False):
+        for str in strs:
+                l = len(str)
+                i = html.find(str)
+                if i >= 0:
+                        break
+        if i < 0:
+                return ''
+        if not div:
+                return re.search(r'[-+]?\d*\.\d+|\d+', html[i+l:i+l+50]).group()
+        n = html[i+l:].find('</div>')
+        if n < 0:
+                return ''
+        return html[i+l:i+l+n]
+
+# Function: runSummary
+# Description:
+#        create a summary of tests in a sub-directory
+def runSummary(subdir, local=True):
+        inpath = os.path.abspath(subdir)
+        outpath = inpath
+        if local:
+                outpath = os.path.abspath('.')
+        print('Generating a summary of folder "%s"' % inpath)
+        testruns = []
+        for dirname, dirnames, filenames in os.walk(subdir):
+                for filename in filenames:
+                        if(not re.match('.*.html', filename)):
+                                continue
+                        file = os.path.join(dirname, filename)
+                        html = open(file, 'r').read(10000)
+                        suspend = find_in_html(html,
+                                ['Kernel Suspend: ', 'Kernel Suspend Time: '])
+                        resume = find_in_html(html,
+                                ['Kernel Resume: ', 'Kernel Resume Time: '])
+                        line = find_in_html(html, ['<div class="stamp">'], True)
+                        stmp = line.split()
+                        if not suspend or not resume or len(stmp) < 4:
+                                continue
+                        data = {
+                                'host': stmp[0],
+                                'kernel': stmp[1],
+                                'mode': stmp[2],
+                                'time': string.join(stmp[3:], ' '),
+                                'suspend': suspend,
+                                'resume': resume,
+                                'url': os.path.relpath(file, outpath),
+                        }
+                        if len(stmp) == 7:
+                                data['kernel'] = 'unknown'
+                                data['mode'] = stmp[1]
+                                data['time'] = string.join(stmp[2:], ' ')
+                        testruns.append(data)
+        outfile = os.path.join(outpath, 'summary.html')
+        print('Summary file: %s' % outfile)
+        createHTMLSummarySimple(testruns, outfile, inpath)
+
+# Function: checkArgBool
+# Description:
+#        check if a boolean string value is true or false
+def checkArgBool(value):
+        yes = ['1', 'true', 'yes', 'on']
+        if value.lower() in yes:
+                return True
+        return False
+
+# Function: configFromFile
+# Description:
+#        Configure the script via the info in a config file
+def configFromFile(file):
+        Config = ConfigParser.ConfigParser()
+
+        Config.read(file)
+        sections = Config.sections()
+        overridekprobes = False
+        overridedevkprobes = False
+        if 'Settings' in sections:
+                for opt in Config.options('Settings'):
+                        value = Config.get('Settings', opt).lower()
+                        if(opt.lower() == 'verbose'):
+                                sysvals.verbose = checkArgBool(value)
+                        elif(opt.lower() == 'addlogs'):
+                                sysvals.addlogs = checkArgBool(value)
+                        elif(opt.lower() == 'dev'):
+                                sysvals.usedevsrc = checkArgBool(value)
+                        elif(opt.lower() == 'proc'):
+                                sysvals.useprocmon = checkArgBool(value)
+                        elif(opt.lower() == 'x2'):
+                                if checkArgBool(value):
+                                        sysvals.execcount = 2
+                        elif(opt.lower() == 'callgraph'):
+                                sysvals.usecallgraph = checkArgBool(value)
+                        elif(opt.lower() == 'override-timeline-functions'):
+                                overridekprobes = checkArgBool(value)
+                        elif(opt.lower() == 'override-dev-timeline-functions'):
+                                overridedevkprobes = checkArgBool(value)
+                        elif(opt.lower() == 'devicefilter'):
+                                sysvals.setDeviceFilter(value)
+                        elif(opt.lower() == 'expandcg'):
+                                sysvals.cgexp = checkArgBool(value)
+                        elif(opt.lower() == 'srgap'):
+                                if checkArgBool(value):
+                                        sysvals.srgap = 5
+                        elif(opt.lower() == 'mode'):
+                                sysvals.suspendmode = value
+                        elif(opt.lower() == 'command'):
+                                sysvals.testcommand = value
+                        elif(opt.lower() == 'x2delay'):
+                                sysvals.x2delay = getArgInt('-x2delay', value, 0, 60000, False)
+                        elif(opt.lower() == 'predelay'):
+                                sysvals.predelay = getArgInt('-predelay', value, 0, 60000, False)
+                        elif(opt.lower() == 'postdelay'):
+                                sysvals.postdelay = getArgInt('-postdelay', value, 0, 60000, False)
+                        elif(opt.lower() == 'maxdepth'):
+                                sysvals.max_graph_depth = getArgInt('-maxdepth', value, 0, 1000, False)
+                        elif(opt.lower() == 'rtcwake'):
+                                if value.lower() == 'off':
+                                        sysvals.rtcwake = False
+                                else:
+                                        sysvals.rtcwake = True
+                                        sysvals.rtcwaketime = getArgInt('-rtcwake', value, 0, 3600, False)
+                        elif(opt.lower() == 'timeprec'):
+                                sysvals.setPrecision(getArgInt('-timeprec', value, 0, 6, False))
+                        elif(opt.lower() == 'mindev'):
+                                sysvals.mindevlen = getArgFloat('-mindev', value, 0.0, 10000.0, False)
+                        elif(opt.lower() == 'callloop-maxgap'):
+                                sysvals.callloopmaxgap = getArgFloat('-callloop-maxgap', value, 0.0, 1.0, False)
+                        elif(opt.lower() == 'callloop-maxlen'):
+                                sysvals.callloopmaxgap = getArgFloat('-callloop-maxlen', value, 0.0, 1.0, False)
+                        elif(opt.lower() == 'mincg'):
+                                sysvals.mincglen = getArgFloat('-mincg', value, 0.0, 10000.0, False)
+                        elif(opt.lower() == 'output-dir'):
+                                sysvals.setOutputFolder(value)
+
+        if sysvals.suspendmode == 'command' and not sysvals.testcommand:
+                doError('No command supplied for mode "command"')
+
+        # compatibility errors
+        if sysvals.usedevsrc and sysvals.usecallgraph:
+                doError('-dev is not compatible with -f')
+        if sysvals.usecallgraph and sysvals.useprocmon:
+                doError('-proc is not compatible with -f')
+
+        if overridekprobes:
+                sysvals.tracefuncs = dict()
+        if overridedevkprobes:
+                sysvals.dev_tracefuncs = dict()
+
+        kprobes = dict()
+        kprobesec = 'dev_timeline_functions_'+platform.machine()
+        if kprobesec in sections:
+                for name in Config.options(kprobesec):
+                        text = Config.get(kprobesec, name)
+                        kprobes[name] = (text, True)
+        kprobesec = 'timeline_functions_'+platform.machine()
+        if kprobesec in sections:
+                for name in Config.options(kprobesec):
+                        if name in kprobes:
+                                doError('Duplicate timeline function found "%s"' % (name))
+                        text = Config.get(kprobesec, name)
+                        kprobes[name] = (text, False)
+
+        for name in kprobes:
+                function = name
+                format = name
+                color = ''
+                args = dict()
+                text, dev = kprobes[name]
+                data = text.split()
+                i = 0
+                for val in data:
+                        # bracketted strings are special formatting, read them separately
+                        if val[0] == '[' and val[-1] == ']':
+                                for prop in val[1:-1].split(','):
+                                        p = prop.split('=')
+                                        if p[0] == 'color':
+                                                try:
+                                                        color = int(p[1], 16)
+                                                        color = '#'+p[1]
+                                                except:
+                                                        color = p[1]
+                                continue
+                        # first real arg should be the format string
+                        if i == 0:
+                                format = val
+                        # all other args are actual function args
+                        else:
+                                d = val.split('=')
+                                args[d[0]] = d[1]
+                        i += 1
+                if not function or not format:
+                        doError('Invalid kprobe: %s' % name)
+                for arg in re.findall('{(?P<n>[a-z,A-Z,0-9]*)}', format):
+                        if arg not in args:
+                                doError('Kprobe "%s" is missing argument "%s"' % (name, arg))
+                if (dev and name in sysvals.dev_tracefuncs) or (not dev and name in sysvals.tracefuncs):
+                        doError('Duplicate timeline function found "%s"' % (name))
+
+                kp = {
+                        'name': name,
+                        'func': function,
+                        'format': format,
+                        sysvals.archargs: args
+                }
+                if color:
+                        kp['color'] = color
+                if dev:
+                        sysvals.dev_tracefuncs[name] = kp
+                else:
+                        sysvals.tracefuncs[name] = kp
+
+# Function: printHelp
+# Description:
+#        print out the help text
+def printHelp():
+        modes = getModes()
+
+        print('')
+        print('%s v%s' % (sysvals.title, sysvals.version))
+        print('Usage: sudo sleepgraph <options> <commands>')
+        print('')
+        print('Description:')
+        print('  This tool is designed to assist kernel and OS developers in optimizing')
+        print('  their linux stack\'s suspend/resume time. Using a kernel image built')
+        print('  with a few extra options enabled, the tool will execute a suspend and')
+        print('  capture dmesg and ftrace data until resume is complete. This data is')
+        print('  transformed into a device timeline and an optional callgraph to give')
+        print('  a detailed view of which devices/subsystems are taking the most')
+        print('  time in suspend/resume.')
+        print('')
+        print('  If no specific command is given, the default behavior is to initiate')
+        print('  a suspend/resume and capture the dmesg/ftrace output as an html timeline.')
+        print('')
+        print('  Generates output files in subdirectory: suspend-mmddyy-HHMMSS')
+        print('   HTML output:                    <hostname>_<mode>.html')
+        print('   raw dmesg output:               <hostname>_<mode>_dmesg.txt')
+        print('   raw ftrace output:              <hostname>_<mode>_ftrace.txt')
+        print('')
+        print('Options:')
+        print('   -h           Print this help text')
+        print('   -v           Print the current tool version')
+        print('   -config fn   Pull arguments and config options from file fn')
+        print('   -verbose     Print extra information during execution and analysis')
+        print('   -m mode      Mode to initiate for suspend %s (default: %s)') % (modes, sysvals.suspendmode)
+        print('   -o subdir    Override the output subdirectory')
+        print('   -rtcwake t   Wakeup t seconds after suspend, set t to "off" to disable (default: 15)')
+        print('   -addlogs     Add the dmesg and ftrace logs to the html output')
+        print('   -srgap       Add a visible gap in the timeline between sus/res (default: disabled)')
+        print('  [advanced]')
+        print('   -cmd {s}     Run the timeline over a custom command, e.g. "sync -d"')
+        print('   -proc        Add usermode process info into the timeline (default: disabled)')
+        print('   -dev         Add kernel function calls and threads to the timeline (default: disabled)')
+        print('   -x2          Run two suspend/resumes back to back (default: disabled)')
+        print('   -x2delay t   Include t ms delay between multiple test runs (default: 0 ms)')
+        print('   -predelay t  Include t ms delay before 1st suspend (default: 0 ms)')
+        print('   -postdelay t Include t ms delay after last resume (default: 0 ms)')
+        print('   -mindev ms   Discard all device blocks shorter than ms milliseconds (e.g. 0.001 for us)')
+        print('   -multi n d   Execute <n> consecutive tests at <d> seconds intervals. The outputs will')
+        print('                be created in a new subdirectory with a summary page.')
+        print('  [debug]')
+        print('   -f           Use ftrace to create device callgraphs (default: disabled)')
+        print('   -maxdepth N  limit the callgraph data to N call levels (default: 0=all)')
+        print('   -expandcg    pre-expand the callgraph data in the html output (default: disabled)')
+        print('   -fadd file   Add functions to be graphed in the timeline from a list in a text file')
+        print('   -filter "d1,d2,..." Filter out all but this comma-delimited list of device names')
+        print('   -mincg  ms   Discard all callgraphs shorter than ms milliseconds (e.g. 0.001 for us)')
+        print('   -cgphase P   Only show callgraph data for phase P (e.g. suspend_late)')
+        print('   -cgtest N    Only show callgraph data for test N (e.g. 0 or 1 in an x2 run)')
+        print('   -timeprec N  Number of significant digits in timestamps (0:S, [3:ms], 6:us)')
+        print('  [commands]')
+        print('   -ftrace ftracefile  Create HTML output using ftrace input (used with -dmesg)')
+        print('   -dmesg dmesgfile    Create HTML output using dmesg (used with -ftrace)')
+        print('   -summary directory  Create a summary of all test in this dir')
+        print('   -modes       List available suspend modes')
+        print('   -status      Test to see if the system is enabled to run this tool')
+        print('   -fpdt        Print out the contents of the ACPI Firmware Performance Data Table')
+        print('   -usbtopo     Print out the current USB topology with power info')
+        print('   -usbauto     Enable autosuspend for all connected USB devices')
+        print('   -flist       Print the list of functions currently being captured in ftrace')
+        print('   -flistall    Print all functions capable of being captured in ftrace')
+        print('')
+        return True
+
+# ----------------- MAIN --------------------
+# exec start (skipped if script is loaded as library)
+if __name__ == '__main__':
+        cmd = ''
+        cmdarg = ''
+        multitest = {'run': False, 'count': 0, 'delay': 0}
+        simplecmds = ['-modes', '-fpdt', '-flist', '-flistall', '-usbtopo', '-usbauto', '-status']
+        # loop through the command line arguments
+        args = iter(sys.argv[1:])
+        for arg in args:
+                if(arg == '-m'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No mode supplied', True)
+                        if val == 'command' and not sysvals.testcommand:
+                                doError('No command supplied for mode "command"', True)
+                        sysvals.suspendmode = val
+                elif(arg in simplecmds):
+                        cmd = arg[1:]
+                elif(arg == '-h'):
+                        printHelp()
+                        sys.exit()
+                elif(arg == '-v'):
+                        print("Version %s" % sysvals.version)
+                        sys.exit()
+                elif(arg == '-x2'):
+                        sysvals.execcount = 2
+                elif(arg == '-x2delay'):
+                        sysvals.x2delay = getArgInt('-x2delay', args, 0, 60000)
+                elif(arg == '-predelay'):
+                        sysvals.predelay = getArgInt('-predelay', args, 0, 60000)
+                elif(arg == '-postdelay'):
+                        sysvals.postdelay = getArgInt('-postdelay', args, 0, 60000)
+                elif(arg == '-f'):
+                        sysvals.usecallgraph = True
+                elif(arg == '-addlogs'):
+                        sysvals.addlogs = True
+                elif(arg == '-verbose'):
+                        sysvals.verbose = True
+                elif(arg == '-proc'):
+                        sysvals.useprocmon = True
+                elif(arg == '-dev'):
+                        sysvals.usedevsrc = True
+                elif(arg == '-maxdepth'):
+                        sysvals.max_graph_depth = getArgInt('-maxdepth', args, 0, 1000)
+                elif(arg == '-rtcwake'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No rtcwake time supplied', True)
+                        if val.lower() == 'off':
+                                sysvals.rtcwake = False
+                        else:
+                                sysvals.rtcwake = True
+                                sysvals.rtcwaketime = getArgInt('-rtcwake', val, 0, 3600, False)
+                elif(arg == '-timeprec'):
+                        sysvals.setPrecision(getArgInt('-timeprec', args, 0, 6))
+                elif(arg == '-mindev'):
+                        sysvals.mindevlen = getArgFloat('-mindev', args, 0.0, 10000.0)
+                elif(arg == '-mincg'):
+                        sysvals.mincglen = getArgFloat('-mincg', args, 0.0, 10000.0)
+                elif(arg == '-cgtest'):
+                        sysvals.cgtest = getArgInt('-cgtest', args, 0, 1)
+                elif(arg == '-cgphase'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No phase name supplied', True)
+                        d = Data(0)
+                        if val not in d.phases:
+                                doError('Invalid phase, valid phaess are %s' % d.phases, True)
+                        sysvals.cgphase = val
+                elif(arg == '-callloop-maxgap'):
+                        sysvals.callloopmaxgap = getArgFloat('-callloop-maxgap', args, 0.0, 1.0)
+                elif(arg == '-callloop-maxlen'):
+                        sysvals.callloopmaxlen = getArgFloat('-callloop-maxlen', args, 0.0, 1.0)
+                elif(arg == '-cmd'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No command string supplied', True)
+                        sysvals.testcommand = val
+                        sysvals.suspendmode = 'command'
+                elif(arg == '-expandcg'):
+                        sysvals.cgexp = True
+                elif(arg == '-srgap'):
+                        sysvals.srgap = 5
+                elif(arg == '-multi'):
+                        multitest['run'] = True
+                        multitest['count'] = getArgInt('-multi n (exec count)', args, 2, 1000000)
+                        multitest['delay'] = getArgInt('-multi d (delay between tests)', args, 0, 3600)
+                elif(arg == '-o'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No subdirectory name supplied', True)
+                        sysvals.setOutputFolder(val)
+                elif(arg == '-config'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No text file supplied', True)
+                        if(os.path.exists(val) == False):
+                                doError('%s does not exist' % val)
+                        configFromFile(val)
+                elif(arg == '-fadd'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No text file supplied', True)
+                        if(os.path.exists(val) == False):
+                                doError('%s does not exist' % val)
+                        sysvals.addFtraceFilterFunctions(val)
+                elif(arg == '-dmesg'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No dmesg file supplied', True)
+                        sysvals.notestrun = True
+                        sysvals.dmesgfile = val
+                        if(os.path.exists(sysvals.dmesgfile) == False):
+                                doError('%s does not exist' % sysvals.dmesgfile)
+                elif(arg == '-ftrace'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No ftrace file supplied', True)
+                        sysvals.notestrun = True
+                        sysvals.ftracefile = val
+                        if(os.path.exists(sysvals.ftracefile) == False):
+                                doError('%s does not exist' % sysvals.ftracefile)
+                elif(arg == '-summary'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No directory supplied', True)
+                        cmd = 'summary'
+                        cmdarg = val
+                        sysvals.notestrun = True
+                        if(os.path.isdir(val) == False):
+                                doError('%s is not accesible' % val)
+                elif(arg == '-filter'):
+                        try:
+                                val = args.next()
+                        except:
+                                doError('No devnames supplied', True)
+                        sysvals.setDeviceFilter(val)
+                else:
+                        doError('Invalid argument: '+arg, True)
+
+        # compatibility errors
+        if(sysvals.usecallgraph and sysvals.usedevsrc):
+                doError('-dev is not compatible with -f')
+        if(sysvals.usecallgraph and sysvals.useprocmon):
+                doError('-proc is not compatible with -f')
+
+        # callgraph size cannot exceed device size
+        if sysvals.mincglen < sysvals.mindevlen:
+                sysvals.mincglen = sysvals.mindevlen
+
+        # just run a utility command and exit
+        if(cmd != ''):
+                if(cmd == 'status'):
+                        statusCheck(True)
+                elif(cmd == 'fpdt'):
+                        getFPDT(True)
+                elif(cmd == 'usbtopo'):
+                        detectUSB()
+                elif(cmd == 'modes'):
+                        print getModes()
+                elif(cmd == 'flist'):
+                        sysvals.getFtraceFilterFunctions(True)
+                elif(cmd == 'flistall'):
+                        sysvals.getFtraceFilterFunctions(False)
+                elif(cmd == 'usbauto'):
+                        setUSBDevicesAuto()
+                elif(cmd == 'summary'):
+                        runSummary(cmdarg, True)
+                sys.exit()
+
+        # if instructed, re-analyze existing data files
+        if(sysvals.notestrun):
+                rerunTest()
+                sys.exit()
+
+        # verify that we can run a test
+        if(not statusCheck()):
+                print('Check FAILED, aborting the test run!')
+                sys.exit()
+
+        if multitest['run']:
+                # run multiple tests in a separate subdirectory
+                s = 'x%d' % multitest['count']
+                if not sysvals.outdir:
+                        sysvals.outdir = datetime.now().strftime('suspend-'+s+'-%m%d%y-%H%M%S')
+                if not os.path.isdir(sysvals.outdir):
+                        os.mkdir(sysvals.outdir)
+                for i in range(multitest['count']):
+                        if(i != 0):
+                                print('Waiting %d seconds...' % (multitest['delay']))
+                                time.sleep(multitest['delay'])
+                        print('TEST (%d/%d) START' % (i+1, multitest['count']))
+                        runTest(sysvals.outdir)
+                        print('TEST (%d/%d) COMPLETE' % (i+1, multitest['count']))
+                runSummary(sysvals.outdir, False)
+        else:
+                # run the test in the current directory
+                runTest('.', sysvals.outdir)
diff --git a/tools/power/pm-graph/bootgraph.8 b/tools/power/pm-graph/bootgraph.8
new file mode 100644
index 000000000000..55272a67b0e7
--- /dev/null
+++ b/tools/power/pm-graph/bootgraph.8
@@ -0,0 +1,132 @@
+.TH BOOTGRAPH 8
+.SH NAME
+bootgraph \- Kernel boot timing analysis
+.SH SYNOPSIS
+.ft B
+.B bootgraph
+.RB [ OPTIONS ]
+.RB [ COMMAND ]
+.SH DESCRIPTION
+\fBbootgraph \fP reads the dmesg log from kernel boot and
+creates an html representation of the initcall timeline up to the start
+of the init process.
+.PP
+If no specific command is given, the tool reads the current dmesg log and
+outputs bootgraph.html.
+.PP
+The tool can also augment the timeline with ftrace data on custom target
+functions as well as full trace callgraphs.
+.SH OPTIONS
+.TP
+\fB-h\fR
+Print this help text
+.TP
+\fB-v\fR
+Print the current tool version
+.TP
+\fB-addlogs\fR
+Add the dmesg log to the html output. It will be viewable by
+clicking a button in the timeline.
+.TP
+\fB-o \fIfile\fR
+Override the HTML output filename (default: bootgraph.html)
+.SS "Ftrace Debug"
+.TP
+\fB-f\fR
+Use ftrace to add function detail (default: disabled)
+.TP
+\fB-callgraph\fR
+Use ftrace to create initcall callgraphs (default: disabled). If -filter
+is not used there will be one callgraph per initcall. This can produce
+very large outputs, i.e. 10MB - 100MB.
+.TP
+\fB-maxdepth \fIlevel\fR
+limit the callgraph trace depth to \fIlevel\fR (default: 2). This is
+the best way to limit the output size when using -callgraph.
+.TP
+\fB-mincg \fIt\fR
+Discard all callgraphs shorter than \fIt\fR milliseconds (default: 0=all).
+This reduces the html file size as there can be many tiny callgraphs
+which are barely visible in the timeline.
+The value is a float: e.g. 0.001 represents 1 us.
+.TP
+\fB-timeprec \fIn\fR
+Number of significant digits in timestamps (0:S, 3:ms, [6:us])
+.TP
+\fB-expandcg\fR
+pre-expand the callgraph data in the html output (default: disabled)
+.TP
+\fB-filter \fI"func1,func2,..."\fR
+Instead of tracing each initcall, trace a custom list of functions (default: do_one_initcall)
+
+.SH COMMANDS
+.TP
+\fB-reboot\fR
+Reboot the machine and generate a new timeline automatically. Works in 4 steps.
+  1. updates grub with the required kernel parameters
+  2. installs a cron job which re-runs the tool after reboot
+  3. reboots the system
+  4. after startup, extracts the data and generates the timeline
+.TP
+\fB-manual\fR
+Show the requirements to generate a new timeline manually. Requires 3 steps.
+  1. append the string to the kernel command line via your native boot manager.
+  2. reboot the system
+  3. after startup, re-run the tool with the same arguments and no command
+.TP
+\fB-dmesg \fIfile\fR
+Create HTML output from an existing dmesg file.
+.TP
+\fB-ftrace \fIfile\fR
+Create HTML output from an existing ftrace file (used with -dmesg).
+.TP
+\fB-flistall\fR
+Print all ftrace functions capable of being captured. These are all the
+possible values you can add to trace via the -filter argument.
+
+.SH EXAMPLES
+Create a timeline using the current dmesg log.
+.IP
+\f(CW$ bootgraph\fR
+.PP
+Create a timeline using the current dmesg and ftrace log.
+.IP
+\f(CW$ bootgraph -callgraph\fR
+.PP
+Create a timeline using the current dmesg, add the log to the html and change the name.
+.IP
+\f(CW$ bootgraph -addlogs -o myboot.html\fR
+.PP
+Capture a new boot timeline by automatically rebooting the machine.
+.IP
+\f(CW$ sudo bootgraph -reboot -addlogs -o latestboot.html\fR
+.PP
+Capture a new boot timeline with function trace data.
+.IP
+\f(CW$ sudo bootgraph -reboot -f\fR
+.PP
+Capture a new boot timeline with trace & callgraph data. Skip callgraphs smaller than 5ms.
+.IP
+\f(CW$ sudo bootgraph -reboot -callgraph -mincg 5\fR
+.PP
+Capture a new boot timeline with callgraph data over custom functions.
+.IP
+\f(CW$ sudo bootgraph -reboot -callgraph -filter "acpi_ps_parse_aml,msleep"\fR
+.PP
+Capture a brand new boot timeline with manual reboot.
+.IP
+\f(CW$ sudo bootgraph -callgraph -manual\fR
+.IP
+\f(CW$ vi /etc/default/grub      # add the CMDLINE string to your kernel params\fR
+.IP
+\f(CW$ sudo reboot               # reboot the machine\fR
+.IP
+\f(CW$ sudo bootgraph -callgraph # re-run the tool after restart\fR
+.PP
+
+.SH "SEE ALSO"
+dmesg(1), update-grub(8), crontab(1), reboot(8)
+.PP
+.SH AUTHOR
+.nf
+Written by Todd Brandt <todd.e.brandt@linux.intel.com>
diff --git a/tools/power/pm-graph/sleepgraph.8 b/tools/power/pm-graph/sleepgraph.8
new file mode 100644
index 000000000000..610e72ebbc06
--- /dev/null
+++ b/tools/power/pm-graph/sleepgraph.8
@@ -0,0 +1,243 @@
+.TH SLEEPGRAPH 8
+.SH NAME
+sleepgraph \- Suspend/Resume timing analysis
+.SH SYNOPSIS
+.ft B
+.B sleepgraph
+.RB [ OPTIONS ]
+.RB [ COMMAND ]
+.SH DESCRIPTION
+\fBsleepgraph \fP is designed to assist kernel and OS developers
+in optimizing their linux stack's suspend/resume time. Using a kernel
+image built with a few extra options enabled, the tool will execute a
+suspend and capture dmesg and ftrace data until resume is complete.
+This data is transformed into a device timeline and an optional
+callgraph to give a detailed view of which devices/subsystems are
+taking the most time in suspend/resume.
+.PP
+If no specific command is given, the default behavior is to initiate
+a suspend/resume.
+.PP
+Generates output files in subdirectory: suspend-yymmdd-HHMMSS
+   html timeline   :     <hostname>_<mode>.html
+   raw dmesg file  :     <hostname>_<mode>_dmesg.txt
+   raw ftrace file :     <hostname>_<mode>_ftrace.txt
+.SH OPTIONS
+.TP
+\fB-h\fR
+Print the help text.
+.TP
+\fB-v\fR
+Print the current tool version.
+.TP
+\fB-verbose\fR
+Print extra information during execution and analysis.
+.TP
+\fB-config \fIfile\fR
+Pull arguments and config options from a file.
+.TP
+\fB-m \fImode\fR
+Mode to initiate for suspend e.g. standby, freeze, mem (default: mem).
+.TP
+\fB-o \fIsubdir\fR
+Override the output subdirectory. Use {date}, {time}, {hostname} for current values.
+.sp
+e.g. suspend-{hostname}-{date}-{time}
+.TP
+\fB-rtcwake \fIt\fR | off
+Use rtcwake to autoresume after \fIt\fR seconds (default: 15). Set t to "off" to
+disable rtcwake and require a user keypress to resume.
+.TP
+\fB-addlogs\fR
+Add the dmesg and ftrace logs to the html output. They will be viewable by
+clicking buttons in the timeline.
+
+.SS "Advanced"
+.TP
+\fB-cmd \fIstr\fR
+Run the timeline over a custom suspend command, e.g. pm-suspend. By default
+the tool forces suspend via /sys/power/state so this allows testing over
+an OS's official suspend method. The output file will change to
+hostname_command.html and will autodetect which suspend mode was triggered.
+.TP
+\fB-filter \fI"d1,d2,..."\fR
+Filter out all but these device callbacks. These strings can be device names
+or module names. e.g. 0000:00:02.0, ata5, i915, usb, etc.
+.TP
+\fB-mindev \fIt\fR
+Discard all device callbacks shorter than \fIt\fR milliseconds (default: 0.0).
+This reduces the html file size as there can be many tiny callbacks which are barely
+visible. The value is a float: e.g. 0.001 represents 1 us.
+.TP
+\fB-proc\fR
+Add usermode process info into the timeline (default: disabled).
+.TP
+\fB-dev\fR
+Add kernel source calls and threads to the timeline (default: disabled).
+.TP
+\fB-x2\fR
+Run two suspend/resumes back to back (default: disabled).
+.TP
+\fB-x2delay \fIt\fR
+Include \fIt\fR ms delay between multiple test runs (default: 0 ms).
+.TP
+\fB-predelay \fIt\fR
+Include \fIt\fR ms delay before 1st suspend (default: 0 ms).
+.TP
+\fB-postdelay \fIt\fR
+Include \fIt\fR ms delay after last resume (default: 0 ms).
+.TP
+\fB-multi \fIn d\fR
+Execute \fIn\fR consecutive tests at \fId\fR seconds intervals. The outputs will
+be created in a new subdirectory with a summary page: suspend-xN-{date}-{time}.
+
+.SS "Ftrace Debug"
+.TP
+\fB-f\fR
+Use ftrace to create device callgraphs (default: disabled). This can produce
+very large outputs, i.e. 10MB - 100MB.
+.TP
+\fB-maxdepth \fIlevel\fR
+limit the callgraph trace depth to \fIlevel\fR (default: 0=all). This is
+the best way to limit the output size when using callgraphs via -f.
+.TP
+\fB-expandcg\fR
+pre-expand the callgraph data in the html output (default: disabled)
+.TP
+\fB-fadd \fIfile\fR
+Add functions to be graphed in the timeline from a list in a text file
+.TP
+\fB-mincg \fIt\fR
+Discard all callgraphs shorter than \fIt\fR milliseconds (default: 0.0).
+This reduces the html file size as there can be many tiny callgraphs
+which are barely visible in the timeline.
+The value is a float: e.g. 0.001 represents 1 us.
+.TP
+\fB-cgphase \fIp\fR
+Only show callgraph data for phase \fIp\fR (e.g. suspend_late).
+.TP
+\fB-cgtest \fIn\fR
+In an x2 run, only show callgraph data for test \fIn\fR (e.g. 0 or 1).
+.TP
+\fB-timeprec \fIn\fR
+Number of significant digits in timestamps (0:S, [3:ms], 6:us).
+
+.SH COMMANDS
+.TP
+\fB-ftrace \fIfile\fR
+Create HTML output from an existing ftrace file.
+.TP
+\fB-dmesg \fIfile\fR
+Create HTML output from an existing dmesg file.
+.TP
+\fB-summary \fIindir\fR
+Create a summary page of all tests in \fIindir\fR. Creates summary.html
+in the current folder. The output page is a table of tests with
+suspend and resume values sorted by suspend mode, host, and kernel.
+Includes test averages by mode and links to the test html files.
+.TP
+\fB-modes\fR
+List available suspend modes.
+.TP
+\fB-status\fR
+Test to see if the system is able to run this tool. Use this along
+with any options you intend to use to see if they will work.
+.TP
+\fB-fpdt\fR
+Print out the contents of the ACPI Firmware Performance Data Table.
+.TP
+\fB-usbtopo\fR
+Print out the current USB topology with power info.
+.TP
+\fB-usbauto\fR
+Enable autosuspend for all connected USB devices.
+.TP
+\fB-flist\fR
+Print the list of ftrace functions currently being captured. Functions
+that are not available as symbols in the current kernel are shown in red.
+By default, the tool traces a list of important suspend/resume functions
+in order to better fill out the timeline. If the user has added their own
+with -fadd they will also be checked.
+.TP
+\fB-flistall\fR
+Print all ftrace functions capable of being captured. These are all the
+possible values you can add to trace via the -fadd argument.
+
+.SH EXAMPLES
+.SS "Simple Commands"
+Check which suspend modes are currently supported.
+.IP
+\f(CW$ sleepgraph -modes\fR
+.PP
+Read the Firmware Performance Data Table (FPDT)
+.IP
+\f(CW$ sudo sleepgraph -fpdt\fR
+.PP
+Print out the current USB power topology
+.IP
+\f(CW$ sleepgraph -usbtopo
+.PP
+Verify that you can run a command with a set of arguments
+.IP
+\f(CW$ sudo sleepgraph -f -rtcwake 30 -status
+.PP
+Generate a summary of all timelines in a particular folder.
+.IP
+\f(CW$ sleepgraph -summary ~/workspace/myresults/\fR
+.PP
+Re-generate the html output from a previous run's dmesg and ftrace log.
+.IP
+\f(CW$ sleepgraph -dmesg myhost_mem_dmesg.txt -ftrace myhost_mem_ftrace.txt\fR
+.PP
+
+.SS "Capturing Simple Timelines"
+Execute a mem suspend with a 15 second wakeup. Include the logs in the html.
+.IP
+\f(CW$ sudo sleepgraph -rtcwake 15 -addlogs\fR
+.PP
+Execute a standby with a 15 second wakeup. Change the output folder name.
+.IP
+\f(CW$ sudo sleepgraph -m standby -rtcwake 15 -o "standby-{hostname}-{date}-{time}"\fR
+.PP
+Execute a freeze with no wakeup (require keypress). Change output folder name.
+.IP
+\f(CW$ sudo sleepgraph -m freeze -rtcwake off -o "freeze-{hostname}-{date}-{time}"\fR
+.PP
+
+.SS "Capturing Advanced Timelines"
+Execute a suspend & include dev mode source calls, limit callbacks to 5ms or larger.
+.IP
+\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -dev -mindev 5\fR
+.PP
+Run two suspends back to back, include a 500ms delay before, after, and in between runs.
+.IP
+\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -x2 -predelay 500 -x2delay 500 -postdelay 500\fR
+.PP
+Do a batch run of 10 freezes with 30 seconds delay between runs.
+.IP
+\f(CW$ sudo sleepgraph -m freeze -rtcwake 15 -multi 10 30\fR
+.PP
+Execute a suspend using a custom command.
+.IP
+\f(CW$ sudo sleepgraph -cmd "echo mem > /sys/power/state" -rtcwake 15\fR
+.PP
+
+
+.SS "Capturing Timelines with Callgraph Data"
+Add device callgraphs. Limit the trace depth and only show callgraphs 10ms or larger.
+.IP
+\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -f -maxdepth 5 -mincg 10\fR
+.PP
+Capture a full callgraph across all suspend, then filter the html by a single phase.
+.IP
+\f(CW$ sudo sleepgraph -m mem -rtcwake 15 -f\fR
+.IP
+\f(CW$ sleepgraph -dmesg host_mem_dmesg.txt -ftrace host_mem_ftrace.txt -f -cgphase resume
+.PP
+
+.SH "SEE ALSO"
+dmesg(1)
+.PP
+.SH AUTHOR
+.nf
+Written by Todd Brandt <todd.e.brandt@linux.intel.com>
diff --git a/tools/power/x86/intel_pstate_tracer/intel_pstate_tracer.py b/tools/power/x86/intel_pstate_tracer/intel_pstate_tracer.py
index fd706ac0f347..0b24dd9d01ff 100755
--- a/tools/power/x86/intel_pstate_tracer/intel_pstate_tracer.py
+++ b/tools/power/x86/intel_pstate_tracer/intel_pstate_tracer.py
@@ -353,6 +353,14 @@ def split_csv():
                 os.system('grep -m 1 common_cpu cpu.csv > cpu{:0>3}.csv'.format(index))
                 os.system('grep CPU_{:0>3} cpu.csv >> cpu{:0>3}.csv'.format(index, index))
 
+def fix_ownership(path):
+    """Change the owner of the file to SUDO_UID, if required"""
+
+    uid = os.environ.get('SUDO_UID')
+    gid = os.environ.get('SUDO_GID')
+    if uid is not None:
+        os.chown(path, int(uid), int(gid))
+
 def cleanup_data_files():
     """ clean up existing data files """
 
@@ -518,12 +526,16 @@ else:
 
 if not os.path.exists('results'):
     os.mkdir('results')
+    # The regular user needs to own the directory, not root.
+    fix_ownership('results')
 
 os.chdir('results')
 if os.path.exists(testname):
     print('The test name directory already exists. Please provide a unique test name. Test re-run not supported, yet.')
     sys.exit()
 os.mkdir(testname)
+# The regular user needs to own the directory, not root.
+fix_ownership(testname)
 os.chdir(testname)
 
 # Temporary (or perhaps not)
@@ -566,4 +578,9 @@ plot_scaled_cpu()
 plot_boost_cpu()
 plot_ghz_cpu()
 
+# It is preferrable, but not necessary, that the regular user owns the files, not root.
+for root, dirs, files in os.walk('.'):
+    for f in files:
+        fix_ownership(f)
+
 os.chdir('../../')
diff --git a/tools/power/x86/turbostat/turbostat.8 b/tools/power/x86/turbostat/turbostat.8
index fedca3285326..ccf2a69365cc 100644
--- a/tools/power/x86/turbostat/turbostat.8
+++ b/tools/power/x86/turbostat/turbostat.8
@@ -100,6 +100,8 @@ The system configuration dump (if --quiet is not used) is followed by statistics
 \fBCPU%c1, CPU%c3, CPU%c6, CPU%c7\fP show the percentage residency in hardware core idle states.  These numbers are from hardware residency counters.
 \fBCoreTmp\fP Degrees Celsius reported by the per-core Digital Thermal Sensor.
 \fBPkgTtmp\fP Degrees Celsius reported by the per-package Package Thermal Monitor.
+\fBGFX%rc6\fP The percentage of time the GPU is in the "render C6" state, rc6, during the measurement interval. From /sys/class/drm/card0/power/rc6_residency_ms.
+\fBGFXMHz\fP Instantaneous snapshot of what sysfs presents at the end of the measurement interval. From /sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz.
 \fBPkg%pc2, Pkg%pc3, Pkg%pc6, Pkg%pc7\fP percentage residency in hardware package idle states.  These numbers are from hardware residency counters.
 \fBPkgWatt\fP Watts consumed by the whole package.
 \fBCorWatt\fP Watts consumed by the core part of the package.
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 828dccd3f01e..b11294730771 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -1142,7 +1142,7 @@ delta_thread(struct thread_data *new, struct thread_data *old,
                  * it is possible for mperf's non-halted cycles + idle states
                  * to exceed TSC's all cycles: show c1 = 0% in that case.
                  */
-                if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
+                if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > (old->tsc * tsc_tweak))
                         old->c1 = 0;
                 else {
                         /* normal case, derive c1 */
@@ -2485,8 +2485,10 @@ int snapshot_gfx_mhz(void)
 
         if (fp == NULL)
                 fp = fopen_or_die("/sys/class/graphics/fb0/device/drm/card0/gt_cur_freq_mhz", "r");
-        else
+        else {
                 rewind(fp);
+                fflush(fp);
+        }
 
         retval = fscanf(fp, "%d", &gfx_cur_mhz);
         if (retval != 1)
@@ -3111,7 +3113,7 @@ int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                 return 0;
 
         fprintf(outf, "cpu%d: MSR_HWP_CAPABILITIES: 0x%08llx "
-                        "(high 0x%x guar 0x%x eff 0x%x low 0x%x)\n",
+                        "(high %d guar %d eff %d low %d)\n",
                         cpu, msr,
                         (unsigned int)HWP_HIGHEST_PERF(msr),
                         (unsigned int)HWP_GUARANTEED_PERF(msr),
@@ -3122,7 +3124,7 @@ int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                 return 0;
 
         fprintf(outf, "cpu%d: MSR_HWP_REQUEST: 0x%08llx "
-                        "(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x pkg 0x%x)\n",
+                        "(min %d max %d des %d epp 0x%x window 0x%x pkg 0x%x)\n",
                         cpu, msr,
                         (unsigned int)(((msr) >> 0) & 0xff),
                         (unsigned int)(((msr) >> 8) & 0xff),
@@ -3136,7 +3138,7 @@ int print_hwp(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                         return 0;
 
                 fprintf(outf, "cpu%d: MSR_HWP_REQUEST_PKG: 0x%08llx "
-                        "(min 0x%x max 0x%x des 0x%x epp 0x%x window 0x%x)\n",
+                        "(min %d max %d des %d epp 0x%x window 0x%x)\n",
                         cpu, msr,
                         (unsigned int)(((msr) >> 0) & 0xff),
                         (unsigned int)(((msr) >> 8) & 0xff),
@@ -3353,17 +3355,19 @@ void rapl_probe(unsigned int family, unsigned int model)
         case INTEL_FAM6_SKYLAKE_DESKTOP:        /* SKL */
         case INTEL_FAM6_KABYLAKE_MOBILE:        /* KBL */
         case INTEL_FAM6_KABYLAKE_DESKTOP:       /* KBL */
-                do_rapl = RAPL_PKG | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_PKG_POWER_INFO;
+                do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_DRAM | RAPL_DRAM_PERF_STATUS | RAPL_PKG_PERF_STATUS | RAPL_GFX | RAPL_PKG_POWER_INFO;
                 BIC_PRESENT(BIC_PKG__);
                 BIC_PRESENT(BIC_RAM__);
                 if (rapl_joules) {
                         BIC_PRESENT(BIC_Pkg_J);
                         BIC_PRESENT(BIC_Cor_J);
                         BIC_PRESENT(BIC_RAM_J);
+                        BIC_PRESENT(BIC_GFX_J);
                 } else {
                         BIC_PRESENT(BIC_PkgWatt);
                         BIC_PRESENT(BIC_CorWatt);
                         BIC_PRESENT(BIC_RAMWatt);
+                        BIC_PRESENT(BIC_GFXWatt);
                 }
                 break;
         case INTEL_FAM6_HASWELL_X:      /* HSX */
@@ -3478,7 +3482,7 @@ void perf_limit_reasons_probe(unsigned int family, unsigned int model)
 int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 {
         unsigned long long msr;
-        unsigned int dts;
+        unsigned int dts, dts2;
         int cpu;
 
         if (!(do_dts || do_ptm))
@@ -3503,7 +3507,6 @@ int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p
                 fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_STATUS: 0x%08llx (%d C)\n",
                         cpu, msr, tcc_activation_temp - dts);
 
-#ifdef  THERM_DEBUG
                 if (get_msr(cpu, MSR_IA32_PACKAGE_THERM_INTERRUPT, &msr))
                         return 0;
 
@@ -3511,11 +3514,10 @@ int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p
                 dts2 = (msr >> 8) & 0x7F;
                 fprintf(outf, "cpu%d: MSR_IA32_PACKAGE_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
                         cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
-#endif
         }
 
 
-        if (do_dts) {
+        if (do_dts && debug) {
                 unsigned int resolution;
 
                 if (get_msr(cpu, MSR_IA32_THERM_STATUS, &msr))
@@ -3526,7 +3528,6 @@ int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p
                 fprintf(outf, "cpu%d: MSR_IA32_THERM_STATUS: 0x%08llx (%d C +/- %d)\n",
                         cpu, msr, tcc_activation_temp - dts, resolution);
 
-#ifdef THERM_DEBUG
                 if (get_msr(cpu, MSR_IA32_THERM_INTERRUPT, &msr))
                         return 0;
 
@@ -3534,7 +3535,6 @@ int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p
                 dts2 = (msr >> 8) & 0x7F;
                 fprintf(outf, "cpu%d: MSR_IA32_THERM_INTERRUPT: 0x%08llx (%d C, %d C)\n",
                         cpu, msr, tcc_activation_temp - dts, tcc_activation_temp - dts2);
-#endif
         }
 
         return 0;
@@ -4578,7 +4578,7 @@ int get_and_dump_counters(void)
 }
 
 void print_version() {
-        fprintf(outf, "turbostat version 17.02.24"
+        fprintf(outf, "turbostat version 17.04.12"
                 " - Len Brown <lenb@kernel.org>\n");
 }
 
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
diff --git a/tools/spi/spidev_test.c b/tools/spi/spidev_test.c
index 816f119c9b7b..8c590cd1171a 100644
--- a/tools/spi/spidev_test.c
+++ b/tools/spi/spidev_test.c
@@ -18,6 +18,7 @@
 #include <string.h>
 #include <getopt.h>
 #include <fcntl.h>
+#include <time.h>
 #include <sys/ioctl.h>
 #include <linux/ioctl.h>
 #include <sys/stat.h>
@@ -40,6 +41,9 @@ static char *output_file;
 static uint32_t speed = 500000;
 static uint16_t delay;
 static int verbose;
+static int transfer_size;
+static int iterations;
+static int interval = 5; /* interval in seconds for showing transfer rate */
 
 uint8_t default_tx[] = {
         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
@@ -156,13 +160,13 @@ static void transfer(int fd, uint8_t const *tx, uint8_t const *rx, size_t len)
                 close(out_fd);
         }
 
-        if (verbose || !output_file)
+        if (verbose)
                 hex_dump(rx, len, 32, "RX");
 }
 
 static void print_usage(const char *prog)
 {
-        printf("Usage: %s [-DsbdlHOLC3]\n", prog);
+        printf("Usage: %s [-DsbdlHOLC3vpNR24SI]\n", prog);
         puts("  -D --device   device to use (default /dev/spidev1.1)\n"
              "  -s --speed    max speed (Hz)\n"
              "  -d --delay    delay (usec)\n"
@@ -180,7 +184,9 @@ static void print_usage(const char *prog)
              "  -N --no-cs    no chip select\n"
              "  -R --ready    slave pulls low to pause\n"
              "  -2 --dual     dual transfer\n"
-             "  -4 --quad     quad transfer\n");
+             "  -4 --quad     quad transfer\n"
+             "  -S --size     transfer size\n"
+             "  -I --iter     iterations\n");
         exit(1);
 }
 
@@ -205,11 +211,13 @@ static void parse_opts(int argc, char *argv[])
                         { "dual",    0, 0, '2' },
                         { "verbose", 0, 0, 'v' },
                         { "quad",    0, 0, '4' },
+                        { "size",    1, 0, 'S' },
+                        { "iter",    1, 0, 'I' },
                         { NULL, 0, 0, 0 },
                 };
                 int c;
 
-                c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3NR24p:v",
+                c = getopt_long(argc, argv, "D:s:d:b:i:o:lHOLC3NR24p:vS:I:",
                                 lopts, NULL);
 
                 if (c == -1)
@@ -270,6 +278,12 @@ static void parse_opts(int argc, char *argv[])
                 case '4':
                         mode |= SPI_TX_QUAD;
                         break;
+                case 'S':
+                        transfer_size = atoi(optarg);
+                        break;
+                case 'I':
+                        iterations = atoi(optarg);
+                        break;
                 default:
                         print_usage(argv[0]);
                         break;
@@ -336,6 +350,57 @@ static void transfer_file(int fd, char *filename)
         close(tx_fd);
 }
 
+static uint64_t _read_count;
+static uint64_t _write_count;
+
+static void show_transfer_rate(void)
+{
+        static uint64_t prev_read_count, prev_write_count;
+        double rx_rate, tx_rate;
+
+        rx_rate = ((_read_count - prev_read_count) * 8) / (interval*1000.0);
+        tx_rate = ((_write_count - prev_write_count) * 8) / (interval*1000.0);
+
+        printf("rate: tx %.1fkbps, rx %.1fkbps\n", rx_rate, tx_rate);
+
+        prev_read_count = _read_count;
+        prev_write_count = _write_count;
+}
+
+static void transfer_buf(int fd, int len)
+{
+        uint8_t *tx;
+        uint8_t *rx;
+        int i;
+
+        tx = malloc(len);
+        if (!tx)
+                pabort("can't allocate tx buffer");
+        for (i = 0; i < len; i++)
+                tx[i] = random();
+
+        rx = malloc(len);
+        if (!rx)
+                pabort("can't allocate rx buffer");
+
+        transfer(fd, tx, rx, len);
+
+        _write_count += len;
+        _read_count += len;
+
+        if (mode & SPI_LOOP) {
+                if (memcmp(tx, rx, len)) {
+                        fprintf(stderr, "transfer error !\n");
+                        hex_dump(tx, len, 32, "TX");
+                        hex_dump(rx, len, 32, "RX");
+                        exit(1);
+                }
+        }
+
+        free(rx);
+        free(tx);
+}
+
 int main(int argc, char *argv[])
 {
         int ret = 0;
@@ -391,7 +456,25 @@ int main(int argc, char *argv[])
                 transfer_escaped_string(fd, input_tx);
         else if (input_file)
                 transfer_file(fd, input_file);
-        else
+        else if (transfer_size) {
+                struct timespec last_stat;
+
+                clock_gettime(CLOCK_MONOTONIC, &last_stat);
+
+                while (iterations-- > 0) {
+                        struct timespec current;
+
+                        transfer_buf(fd, transfer_size);
+
+                        clock_gettime(CLOCK_MONOTONIC, &current);
+                        if (current.tv_sec - last_stat.tv_sec > interval) {
+                                show_transfer_rate();
+                                last_stat = current;
+                        }
+                }
+                printf("total: tx %.1fKB, rx %.1fKB\n",
+                       _write_count/1024.0, _read_count/1024.0);
+        } else
                 transfer(fd, default_tx, default_rx, sizeof(default_tx));
 
         close(fd);
diff --git a/tools/testing/nvdimm/Kbuild b/tools/testing/nvdimm/Kbuild
index 405212be044a..d870520da68b 100644
--- a/tools/testing/nvdimm/Kbuild
+++ b/tools/testing/nvdimm/Kbuild
@@ -28,7 +28,10 @@ obj-$(CONFIG_ND_BTT) += nd_btt.o
 obj-$(CONFIG_ND_BLK) += nd_blk.o
 obj-$(CONFIG_X86_PMEM_LEGACY) += nd_e820.o
 obj-$(CONFIG_ACPI_NFIT) += nfit.o
-obj-$(CONFIG_DEV_DAX) += dax.o
+ifeq ($(CONFIG_DAX),m)
+obj-$(CONFIG_DAX) += dax.o
+endif
+obj-$(CONFIG_DEV_DAX) += device_dax.o
 obj-$(CONFIG_DEV_DAX_PMEM) += dax_pmem.o
 
 nfit-y := $(ACPI_SRC)/core.o
@@ -48,9 +51,13 @@ nd_blk-y += config_check.o
 nd_e820-y := $(NVDIMM_SRC)/e820.o
 nd_e820-y += config_check.o
 
-dax-y := $(DAX_SRC)/dax.o
+dax-y := $(DAX_SRC)/super.o
 dax-y += config_check.o
 
+device_dax-y := $(DAX_SRC)/device.o
+device_dax-y += dax-dev.o
+device_dax-y += config_check.o
+
 dax_pmem-y := $(DAX_SRC)/pmem.o
 dax_pmem-y += config_check.o
 
diff --git a/tools/testing/nvdimm/dax-dev.c b/tools/testing/nvdimm/dax-dev.c
new file mode 100644
index 000000000000..36ee3d8797c3
--- /dev/null
+++ b/tools/testing/nvdimm/dax-dev.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+#include "test/nfit_test.h"
+#include <linux/mm.h>
+#include "../../../drivers/dax/dax-private.h"
+
+phys_addr_t dax_pgoff_to_phys(struct dev_dax *dev_dax, pgoff_t pgoff,
+                unsigned long size)
+{
+        struct resource *res;
+        phys_addr_t addr;
+        int i;
+
+        for (i = 0; i < dev_dax->num_resources; i++) {
+                res = &dev_dax->res[i];
+                addr = pgoff * PAGE_SIZE + res->start;
+                if (addr >= res->start && addr <= res->end)
+                        break;
+                pgoff -= PHYS_PFN(resource_size(res));
+        }
+
+        if (i < dev_dax->num_resources) {
+                res = &dev_dax->res[i];
+                if (addr + size - 1 <= res->end) {
+                        if (get_nfit_res(addr)) {
+                                struct page *page;
+
+                                if (dev_dax->region->align > PAGE_SIZE)
+                                        return -1;
+
+                                page = vmalloc_to_page((void *)addr);
+                                return PFN_PHYS(page_to_pfn(page));
+                        } else
+                                return addr;
+                }
+        }
+
+        return -1;
+}
diff --git a/tools/testing/nvdimm/pmem-dax.c b/tools/testing/nvdimm/pmem-dax.c
index c9b8c48f85fc..b53596ad601b 100644
--- a/tools/testing/nvdimm/pmem-dax.c
+++ b/tools/testing/nvdimm/pmem-dax.c
@@ -15,13 +15,13 @@
 #include <pmem.h>
 #include <nd.h>
 
-long pmem_direct_access(struct block_device *bdev, sector_t sector,
-                void **kaddr, pfn_t *pfn, long size)
+long __pmem_direct_access(struct pmem_device *pmem, pgoff_t pgoff,
+                long nr_pages, void **kaddr, pfn_t *pfn)
 {
-        struct pmem_device *pmem = bdev->bd_queue->queuedata;
-        resource_size_t offset = sector * 512 + pmem->data_offset;
+        resource_size_t offset = PFN_PHYS(pgoff) + pmem->data_offset;
 
-        if (unlikely(is_bad_pmem(&pmem->bb, sector, size)))
+        if (unlikely(is_bad_pmem(&pmem->bb, PFN_PHYS(pgoff) / 512,
+                                        PFN_PHYS(nr_pages))))
                 return -EIO;
 
         /*
@@ -34,11 +34,10 @@ long pmem_direct_access(struct block_device *bdev, sector_t sector,
                 *kaddr = pmem->virt_addr + offset;
                 page = vmalloc_to_page(pmem->virt_addr + offset);
                 *pfn = page_to_pfn_t(page);
-                dev_dbg_ratelimited(disk_to_dev(bdev->bd_disk)->parent,
-                                "%s: sector: %#llx pfn: %#lx\n", __func__,
-                                (unsigned long long) sector, page_to_pfn(page));
+                pr_debug_ratelimited("%s: pmem: %p pgoff: %#lx pfn: %#lx\n",
+                                __func__, pmem, pgoff, page_to_pfn(page));
 
-                return PAGE_SIZE;
+                return 1;
         }
 
         *kaddr = pmem->virt_addr + offset;
@@ -49,6 +48,6 @@ long pmem_direct_access(struct block_device *bdev, sector_t sector,
          * requested range.
          */
         if (unlikely(pmem->bb.count))
-                return size;
-        return pmem->size - pmem->pfn_pad - offset;
+                return nr_pages;
+        return PHYS_PFN(pmem->size - pmem->pfn_pad - offset);
 }
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index 798f17655433..c2187178fb13 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -132,6 +132,7 @@ static u32 handle[] = {
         [3] = NFIT_DIMM_HANDLE(0, 0, 1, 0, 1),
         [4] = NFIT_DIMM_HANDLE(0, 1, 0, 0, 0),
         [5] = NFIT_DIMM_HANDLE(1, 0, 0, 0, 0),
+        [6] = NFIT_DIMM_HANDLE(1, 0, 0, 0, 1),
 };
 
 static unsigned long dimm_fail_cmd_flags[NUM_DCR];
@@ -728,8 +729,8 @@ static int nfit_test0_alloc(struct nfit_test *t)
 static int nfit_test1_alloc(struct nfit_test *t)
 {
         size_t nfit_size = sizeof(struct acpi_nfit_system_address) * 2
-                + sizeof(struct acpi_nfit_memory_map)
-                + offsetof(struct acpi_nfit_control_region, window_size);
+                + sizeof(struct acpi_nfit_memory_map) * 2
+                + offsetof(struct acpi_nfit_control_region, window_size) * 2;
         int i;
 
         t->nfit_buf = test_alloc(t, nfit_size, &t->nfit_dma);
@@ -906,6 +907,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         memdev->address = 0;
         memdev->interleave_index = 0;
         memdev->interleave_ways = 2;
+        memdev->flags = ACPI_NFIT_MEM_HEALTH_ENABLED;
 
         /* mem-region2 (spa1, dimm0) */
         memdev = nfit_buf + offset + sizeof(struct acpi_nfit_memory_map) * 2;
@@ -921,6 +923,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         memdev->address = SPA0_SIZE/2;
         memdev->interleave_index = 0;
         memdev->interleave_ways = 4;
+        memdev->flags = ACPI_NFIT_MEM_HEALTH_ENABLED;
 
         /* mem-region3 (spa1, dimm1) */
         memdev = nfit_buf + offset + sizeof(struct acpi_nfit_memory_map) * 3;
@@ -951,6 +954,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         memdev->address = SPA0_SIZE/2;
         memdev->interleave_index = 0;
         memdev->interleave_ways = 4;
+        memdev->flags = ACPI_NFIT_MEM_HEALTH_ENABLED;
 
         /* mem-region5 (spa1, dimm3) */
         memdev = nfit_buf + offset + sizeof(struct acpi_nfit_memory_map) * 5;
@@ -1086,6 +1090,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         memdev->address = 0;
         memdev->interleave_index = 0;
         memdev->interleave_ways = 1;
+        memdev->flags = ACPI_NFIT_MEM_HEALTH_ENABLED;
 
         offset = offset + sizeof(struct acpi_nfit_memory_map) * 14;
         /* dcr-descriptor0: blk */
@@ -1384,6 +1389,7 @@ static void nfit_test0_setup(struct nfit_test *t)
                 memdev->address = 0;
                 memdev->interleave_index = 0;
                 memdev->interleave_ways = 1;
+                memdev->flags = ACPI_NFIT_MEM_HEALTH_ENABLED;
 
                 /* mem-region16 (spa/bdw4, dimm4) */
                 memdev = nfit_buf + offset +
@@ -1486,6 +1492,34 @@ static void nfit_test1_setup(struct nfit_test *t)
         dcr->code = NFIT_FIC_BYTE;
         dcr->windows = 0;
 
+        offset += dcr->header.length;
+        memdev = nfit_buf + offset;
+        memdev->header.type = ACPI_NFIT_TYPE_MEMORY_MAP;
+        memdev->header.length = sizeof(*memdev);
+        memdev->device_handle = handle[6];
+        memdev->physical_id = 0;
+        memdev->region_id = 0;
+        memdev->range_index = 0;
+        memdev->region_index = 0+2;
+        memdev->region_size = SPA2_SIZE;
+        memdev->region_offset = 0;
+        memdev->address = 0;
+        memdev->interleave_index = 0;
+        memdev->interleave_ways = 1;
+        memdev->flags = ACPI_NFIT_MEM_MAP_FAILED;
+
+        /* dcr-descriptor1 */
+        offset += sizeof(*memdev);
+        dcr = nfit_buf + offset;
+        dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
+        dcr->header.length = offsetof(struct acpi_nfit_control_region,
+                        window_size);
+        dcr->region_index = 0+2;
+        dcr_common_init(dcr);
+        dcr->serial_number = ~handle[6];
+        dcr->code = NFIT_FIC_BYTE;
+        dcr->windows = 0;
+
         post_ars_status(&t->ars_state, t->spa_set_dma[0], SPA2_SIZE);
 
         acpi_desc = &t->acpi_desc;
@@ -1817,6 +1851,10 @@ static int nfit_test_probe(struct platform_device *pdev)
         if (rc)
                 return rc;
 
+        rc = devm_add_action_or_reset(&pdev->dev, acpi_nfit_shutdown, acpi_desc);
+        if (rc)
+                return rc;
+
         if (nfit_test->setup != nfit_test0_setup)
                 return 0;
 
@@ -1907,7 +1945,7 @@ static __init int nfit_test_init(void)
                 case 1:
                         nfit_test->num_pm = 1;
                         nfit_test->dcr_idx = NUM_DCR;
-                        nfit_test->num_dcr = 1;
+                        nfit_test->num_dcr = 2;
                         nfit_test->alloc = nfit_test1_alloc;
                         nfit_test->setup = nfit_test1_setup;
                         break;
@@ -1924,6 +1962,7 @@ static __init int nfit_test_init(void)
                         put_device(&pdev->dev);
                         goto err_register;
                 }
+                get_device(&pdev->dev);
 
                 rc = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
                 if (rc)
@@ -1942,6 +1981,10 @@ static __init int nfit_test_init(void)
                 if (instances[i])
                         platform_device_unregister(&instances[i]->pdev);
         nfit_test_teardown();
+        for (i = 0; i < NUM_NFITS; i++)
+                if (instances[i])
+                        put_device(&instances[i]->pdev.dev);
+
         return rc;
 }
 
@@ -1949,10 +1992,13 @@ static __exit void nfit_test_exit(void)
 {
         int i;
 
-        platform_driver_unregister(&nfit_test_driver);
         for (i = 0; i < NUM_NFITS; i++)
                 platform_device_unregister(&instances[i]->pdev);
+        platform_driver_unregister(&nfit_test_driver);
         nfit_test_teardown();
+
+        for (i = 0; i < NUM_NFITS; i++)
+                put_device(&instances[i]->pdev.dev);
         class_destroy(nfit_test_dimm);
 }
 
diff --git a/tools/testing/selftests/.gitignore b/tools/testing/selftests/.gitignore
index f0600d20ce7d..91750352459d 100644
--- a/tools/testing/selftests/.gitignore
+++ b/tools/testing/selftests/.gitignore
@@ -1 +1,5 @@
 kselftest
+gpiogpio-event-mon
+gpiogpio-hammer
+gpioinclude/
+gpiolsgpio
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index d8593f1251ec..26ce4f7168be 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -39,7 +39,7 @@ TARGETS += x86
 TARGETS += zram
 #Please keep the TARGETS list alphabetically sorted
 # Run "make quicktest=1 run_tests" or
-# "make quicktest=1 kselftest from top level Makefile
+# "make quicktest=1 kselftest" from top level Makefile
 
 TARGETS_HOTPLUG = cpu-hotplug
 TARGETS_HOTPLUG += memory-hotplug
@@ -133,4 +133,4 @@ clean:
                 make OUTPUT=$$BUILD_TARGET -C $$TARGET clean;\
         done;
 
-.PHONY: install
+.PHONY: all run_tests hotplug run_hotplug clean_hotplug run_pstore_crash install clean
diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile
index 6a1ad58cb66f..f389b02d43a0 100644
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -1,16 +1,26 @@
 LIBDIR := ../../../lib
 BPFDIR := $(LIBDIR)/bpf
+APIDIR := ../../../include/uapi
+GENDIR := ../../../../include/generated
+GENHDR := $(GENDIR)/autoconf.h
 
-CFLAGS += -Wall -O2 -I../../../include/uapi -I$(LIBDIR)
-LDLIBS += -lcap
+ifneq ($(wildcard $(GENHDR)),)
+  GENFLAGS := -DHAVE_GENHDR
+endif
 
-TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map
+CFLAGS += -Wall -O2 -I$(APIDIR) -I$(LIBDIR) -I$(GENDIR) $(GENFLAGS) -I../../../include
+LDLIBS += -lcap -lelf
+
+TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \
+        test_align
+
+TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o
 
 TEST_PROGS := test_kmod.sh
 
 include ../lib.mk
 
-BPFOBJ := $(OUTPUT)/bpf.o
+BPFOBJ := $(OUTPUT)/libbpf.a
 
 $(TEST_GEN_PROGS): $(BPFOBJ)
 
@@ -21,3 +31,11 @@ force:
 
 $(BPFOBJ): force
         $(MAKE) -C $(BPFDIR) OUTPUT=$(OUTPUT)/
+
+CLANG ?= clang
+
+%.o: %.c
+        $(CLANG) -I. -I./include/uapi -I../../../include/uapi \
+                -I../../../../samples/bpf/ \
+                -Wno-compare-distinct-pointer-types \
+                -O2 -target bpf -c $< -o $@
diff --git a/tools/testing/selftests/bpf/bpf_endian.h b/tools/testing/selftests/bpf/bpf_endian.h
new file mode 100644
index 000000000000..19d0604f8694
--- /dev/null
+++ b/tools/testing/selftests/bpf/bpf_endian.h
@@ -0,0 +1,23 @@
+#ifndef __BPF_ENDIAN__
+#define __BPF_ENDIAN__
+
+#include <asm/byteorder.h>
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+# define __bpf_ntohs(x)         __builtin_bswap16(x)
+# define __bpf_htons(x)         __builtin_bswap16(x)
+#elif __BYTE_ORDER == __BIG_ENDIAN
+# define __bpf_ntohs(x)         (x)
+# define __bpf_htons(x)         (x)
+#else
+# error "Fix your __BYTE_ORDER?!"
+#endif
+
+#define bpf_htons(x)                            \
+        (__builtin_constant_p(x) ?              \
+         __constant_htons(x) : __bpf_htons(x))
+#define bpf_ntohs(x)                            \
+        (__builtin_constant_p(x) ?              \
+         __constant_ntohs(x) : __bpf_ntohs(x))
+
+#endif
diff --git a/tools/testing/selftests/bpf/bpf_util.h b/tools/testing/selftests/bpf/bpf_util.h
index 84a5d1823f02..20ecbaa0d85d 100644
--- a/tools/testing/selftests/bpf/bpf_util.h
+++ b/tools/testing/selftests/bpf/bpf_util.h
@@ -35,4 +35,11 @@ static inline unsigned int bpf_num_possible_cpus(void)
         return possible_cpus;
 }
 
+#define __bpf_percpu_val_align  __attribute__((__aligned__(8)))
+
+#define BPF_DECLARE_PERCPU(type, name)                          \
+        struct { type v; /* padding */ } __bpf_percpu_val_align \
+                name[bpf_num_possible_cpus()]
+#define bpf_percpu(name, cpu) name[(cpu)].v
+
 #endif /* __BPF_UTIL__ */
diff --git a/tools/testing/selftests/bpf/gnu/stubs.h b/tools/testing/selftests/bpf/gnu/stubs.h
new file mode 100644
index 000000000000..719225b16626
--- /dev/null
+++ b/tools/testing/selftests/bpf/gnu/stubs.h
@@ -0,0 +1 @@
+/* dummy .h to trick /usr/include/features.h to work with 'clang -target bpf' */
diff --git a/tools/testing/selftests/bpf/include/uapi/linux/types.h b/tools/testing/selftests/bpf/include/uapi/linux/types.h
new file mode 100644
index 000000000000..51841848fbfe
--- /dev/null
+++ b/tools/testing/selftests/bpf/include/uapi/linux/types.h
@@ -0,0 +1,22 @@
+#ifndef _UAPI_LINUX_TYPES_H
+#define _UAPI_LINUX_TYPES_H
+
+#include <asm-generic/int-ll64.h>
+
+/* copied from linux:include/uapi/linux/types.h */
+#define __bitwise
+typedef __u16 __bitwise __le16;
+typedef __u16 __bitwise __be16;
+typedef __u32 __bitwise __le32;
+typedef __u32 __bitwise __be32;
+typedef __u64 __bitwise __le64;
+typedef __u64 __bitwise __be64;
+
+typedef __u16 __bitwise __sum16;
+typedef __u32 __bitwise __wsum;
+
+#define __aligned_u64 __u64 __attribute__((aligned(8)))
+#define __aligned_be64 __be64 __attribute__((aligned(8)))
+#define __aligned_le64 __le64 __attribute__((aligned(8)))
+
+#endif /* _UAPI_LINUX_TYPES_H */
diff --git a/tools/testing/selftests/bpf/test_align.c b/tools/testing/selftests/bpf/test_align.c
new file mode 100644
index 000000000000..9644d4e069de
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_align.c
@@ -0,0 +1,453 @@
+#include <asm/types.h>
+#include <linux/types.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include <linux/unistd.h>
+#include <linux/filter.h>
+#include <linux/bpf_perf_event.h>
+#include <linux/bpf.h>
+
+#include <bpf/bpf.h>
+
+#include "../../../include/linux/filter.h"
+
+#ifndef ARRAY_SIZE
+# define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+#define MAX_INSNS       512
+#define MAX_MATCHES     16
+
+struct bpf_align_test {
+        const char *descr;
+        struct bpf_insn insns[MAX_INSNS];
+        enum {
+                UNDEF,
+                ACCEPT,
+                REJECT
+        } result;
+        enum bpf_prog_type prog_type;
+        const char *matches[MAX_MATCHES];
+};
+
+static struct bpf_align_test tests[] = {
+        {
+                .descr = "mov",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_3, 2),
+                        BPF_MOV64_IMM(BPF_REG_3, 4),
+                        BPF_MOV64_IMM(BPF_REG_3, 8),
+                        BPF_MOV64_IMM(BPF_REG_3, 16),
+                        BPF_MOV64_IMM(BPF_REG_3, 32),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "1: R1=ctx R3=imm2,min_value=2,max_value=2,min_align=2 R10=fp",
+                        "2: R1=ctx R3=imm4,min_value=4,max_value=4,min_align=4 R10=fp",
+                        "3: R1=ctx R3=imm8,min_value=8,max_value=8,min_align=8 R10=fp",
+                        "4: R1=ctx R3=imm16,min_value=16,max_value=16,min_align=16 R10=fp",
+                        "5: R1=ctx R3=imm32,min_value=32,max_value=32,min_align=32 R10=fp",
+                },
+        },
+        {
+                .descr = "shift",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_3, 4),
+                        BPF_MOV64_IMM(BPF_REG_4, 32),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "1: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R10=fp",
+                        "2: R1=ctx R3=imm2,min_value=2,max_value=2,min_align=2 R10=fp",
+                        "3: R1=ctx R3=imm4,min_value=4,max_value=4,min_align=4 R10=fp",
+                        "4: R1=ctx R3=imm8,min_value=8,max_value=8,min_align=8 R10=fp",
+                        "5: R1=ctx R3=imm16,min_value=16,max_value=16,min_align=16 R10=fp",
+                        "6: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R10=fp",
+                        "7: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R4=imm32,min_value=32,max_value=32,min_align=32 R10=fp",
+                        "8: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R4=imm16,min_value=16,max_value=16,min_align=16 R10=fp",
+                        "9: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R4=imm8,min_value=8,max_value=8,min_align=8 R10=fp",
+                        "10: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R4=imm4,min_value=4,max_value=4,min_align=4 R10=fp",
+                        "11: R1=ctx R3=imm1,min_value=1,max_value=1,min_align=1 R4=imm2,min_value=2,max_value=2,min_align=2 R10=fp",
+                },
+        },
+        {
+                .descr = "addsub",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_3, 4),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 4),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 2),
+                        BPF_MOV64_IMM(BPF_REG_4, 8),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 4),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 2),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "1: R1=ctx R3=imm4,min_value=4,max_value=4,min_align=4 R10=fp",
+                        "2: R1=ctx R3=imm8,min_value=8,max_value=8,min_align=4 R10=fp",
+                        "3: R1=ctx R3=imm10,min_value=10,max_value=10,min_align=2 R10=fp",
+                        "4: R1=ctx R3=imm10,min_value=10,max_value=10,min_align=2 R4=imm8,min_value=8,max_value=8,min_align=8 R10=fp",
+                        "5: R1=ctx R3=imm10,min_value=10,max_value=10,min_align=2 R4=imm12,min_value=12,max_value=12,min_align=4 R10=fp",
+                        "6: R1=ctx R3=imm10,min_value=10,max_value=10,min_align=2 R4=imm14,min_value=14,max_value=14,min_align=2 R10=fp",
+                },
+        },
+        {
+                .descr = "mul",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_3, 7),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_3, 2),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_3, 4),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "1: R1=ctx R3=imm7,min_value=7,max_value=7,min_align=1 R10=fp",
+                        "2: R1=ctx R3=imm7,min_value=7,max_value=7,min_align=1 R10=fp",
+                        "3: R1=ctx R3=imm14,min_value=14,max_value=14,min_align=2 R10=fp",
+                        "4: R1=ctx R3=imm56,min_value=56,max_value=56,min_align=4 R10=fp",
+                },
+        },
+
+#define PREP_PKT_POINTERS \
+        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, \
+                    offsetof(struct __sk_buff, data)), \
+        BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, \
+                    offsetof(struct __sk_buff, data_end))
+
+#define LOAD_UNKNOWN(DST_REG) \
+        PREP_PKT_POINTERS, \
+        BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), \
+        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8), \
+        BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_0, 1), \
+        BPF_EXIT_INSN(), \
+        BPF_LDX_MEM(BPF_B, DST_REG, BPF_REG_2, 0)
+
+        {
+                .descr = "unknown shift",
+                .insns = {
+                        LOAD_UNKNOWN(BPF_REG_3),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_3, 1),
+                        LOAD_UNKNOWN(BPF_REG_4),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_4, 5),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_ALU64_IMM(BPF_RSH, BPF_REG_4, 1),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "7: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R10=fp",
+                        "8: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv55,min_align=2 R10=fp",
+                        "9: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv54,min_align=4 R10=fp",
+                        "10: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv53,min_align=8 R10=fp",
+                        "11: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv52,min_align=16 R10=fp",
+                        "18: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv56 R10=fp",
+                        "19: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv51,min_align=32 R10=fp",
+                        "20: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv52,min_align=16 R10=fp",
+                        "21: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv53,min_align=8 R10=fp",
+                        "22: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv54,min_align=4 R10=fp",
+                        "23: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv55,min_align=2 R10=fp",
+                },
+        },
+        {
+                .descr = "unknown mul",
+                .insns = {
+                        LOAD_UNKNOWN(BPF_REG_3),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_3),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_4, 1),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_3),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_4, 2),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_3),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_4, 4),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_3),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_4, 8),
+                        BPF_ALU64_IMM(BPF_MUL, BPF_REG_4, 2),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "7: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R10=fp",
+                        "8: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv56 R10=fp",
+                        "9: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv55,min_align=1 R10=fp",
+                        "10: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv56 R10=fp",
+                        "11: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv54,min_align=2 R10=fp",
+                        "12: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv56 R10=fp",
+                        "13: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv53,min_align=4 R10=fp",
+                        "14: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv56 R10=fp",
+                        "15: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv52,min_align=8 R10=fp",
+                        "16: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=inv56 R4=inv50,min_align=8 R10=fp"
+                },
+        },
+        {
+                .descr = "packet const offset",
+                .insns = {
+                        PREP_PKT_POINTERS,
+                        BPF_MOV64_REG(BPF_REG_5, BPF_REG_2),
+
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+
+                        /* Skip over ethernet header.  */
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_5, 14),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_5),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 4),
+                        BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_4, 1),
+                        BPF_EXIT_INSN(),
+
+                        BPF_LDX_MEM(BPF_B, BPF_REG_4, BPF_REG_5, 0),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_4, BPF_REG_5, 1),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_4, BPF_REG_5, 2),
+                        BPF_LDX_MEM(BPF_B, BPF_REG_4, BPF_REG_5, 3),
+                        BPF_LDX_MEM(BPF_H, BPF_REG_4, BPF_REG_5, 0),
+                        BPF_LDX_MEM(BPF_H, BPF_REG_4, BPF_REG_5, 2),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_4, BPF_REG_5, 0),
+
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        "4: R0=imm0,min_value=0,max_value=0,min_align=2147483648 R1=ctx R2=pkt(id=0,off=0,r=0) R3=pkt_end R5=pkt(id=0,off=0,r=0) R10=fp",
+                        "5: R0=imm0,min_value=0,max_value=0,min_align=2147483648 R1=ctx R2=pkt(id=0,off=0,r=0) R3=pkt_end R5=pkt(id=0,off=14,r=0) R10=fp",
+                        "6: R0=imm0,min_value=0,max_value=0,min_align=2147483648 R1=ctx R2=pkt(id=0,off=0,r=0) R3=pkt_end R4=pkt(id=0,off=14,r=0) R5=pkt(id=0,off=14,r=0) R10=fp",
+                        "10: R0=imm0,min_value=0,max_value=0,min_align=2147483648 R1=ctx R2=pkt(id=0,off=0,r=18) R3=pkt_end R4=inv56 R5=pkt(id=0,off=14,r=18) R10=fp",
+                        "14: R0=imm0,min_value=0,max_value=0,min_align=2147483648 R1=ctx R2=pkt(id=0,off=0,r=18) R3=pkt_end R4=inv48 R5=pkt(id=0,off=14,r=18) R10=fp",
+                        "15: R0=imm0,min_value=0,max_value=0,min_align=2147483648 R1=ctx R2=pkt(id=0,off=0,r=18) R3=pkt_end R4=inv48 R5=pkt(id=0,off=14,r=18) R10=fp",
+                },
+        },
+        {
+                .descr = "packet variable offset",
+                .insns = {
+                        LOAD_UNKNOWN(BPF_REG_6),
+                        BPF_ALU64_IMM(BPF_LSH, BPF_REG_6, 2),
+
+                        /* First, add a constant to the R5 packet pointer,
+                         * then a variable with a known alignment.
+                         */
+                        BPF_MOV64_REG(BPF_REG_5, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_5, 14),
+                        BPF_ALU64_REG(BPF_ADD, BPF_REG_5, BPF_REG_6),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_5),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 4),
+                        BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_4, 1),
+                        BPF_EXIT_INSN(),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_4, BPF_REG_5, 0),
+
+                        /* Now, test in the other direction.  Adding first
+                         * the variable offset to R5, then the constant.
+                         */
+                        BPF_MOV64_REG(BPF_REG_5, BPF_REG_2),
+                        BPF_ALU64_REG(BPF_ADD, BPF_REG_5, BPF_REG_6),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_5, 14),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_5),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 4),
+                        BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_4, 1),
+                        BPF_EXIT_INSN(),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_4, BPF_REG_5, 0),
+
+                        /* Test multiple accumulations of unknown values
+                         * into a packet pointer.
+                         */
+                        BPF_MOV64_REG(BPF_REG_5, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_5, 14),
+                        BPF_ALU64_REG(BPF_ADD, BPF_REG_5, BPF_REG_6),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_5, 4),
+                        BPF_ALU64_REG(BPF_ADD, BPF_REG_5, BPF_REG_6),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_5),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 4),
+                        BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_4, 1),
+                        BPF_EXIT_INSN(),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_4, BPF_REG_5, 0),
+
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+                .matches = {
+                        /* Calculated offset in R6 has unknown value, but known
+                         * alignment of 4.
+                         */
+                        "8: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R6=inv54,min_align=4 R10=fp",
+
+                        /* Offset is added to packet pointer R5, resulting in known
+                         * auxiliary alignment and offset.
+                         */
+                        "11: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R5=pkt(id=1,off=0,r=0),aux_off=14,aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+
+                        /* At the time the word size load is performed from R5,
+                         * it's total offset is NET_IP_ALIGN + reg->off (0) +
+                         * reg->aux_off (14) which is 16.  Then the variable
+                         * offset is considered using reg->aux_off_align which
+                         * is 4 and meets the load's requirements.
+                         */
+                        "15: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=pkt(id=1,off=4,r=4),aux_off=14,aux_off_align=4 R5=pkt(id=1,off=0,r=4),aux_off=14,aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+
+
+                        /* Variable offset is added to R5 packet pointer,
+                         * resulting in auxiliary alignment of 4.
+                         */
+                        "18: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv,aux_off=14,aux_off_align=4 R5=pkt(id=2,off=0,r=0),aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+
+                        /* Constant offset is added to R5, resulting in
+                         * reg->off of 14.
+                         */
+                        "19: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv,aux_off=14,aux_off_align=4 R5=pkt(id=2,off=14,r=0),aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+
+                        /* At the time the word size load is performed from R5,
+                         * it's total offset is NET_IP_ALIGN + reg->off (14) which
+                         * is 16.  Then the variable offset is considered using
+                         * reg->aux_off_align which is 4 and meets the load's
+                         * requirements.
+                         */
+                        "23: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=pkt(id=2,off=18,r=18),aux_off_align=4 R5=pkt(id=2,off=14,r=18),aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+
+                        /* Constant offset is added to R5 packet pointer,
+                         * resulting in reg->off value of 14.
+                         */
+                        "26: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv,aux_off_align=4 R5=pkt(id=0,off=14,r=8) R6=inv54,min_align=4 R10=fp",
+                        /* Variable offset is added to R5, resulting in an
+                         * auxiliary offset of 14, and an auxiliary alignment of 4.
+                         */
+                        "27: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv,aux_off_align=4 R5=pkt(id=3,off=0,r=0),aux_off=14,aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+                        /* Constant is added to R5 again, setting reg->off to 4. */
+                        "28: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv,aux_off_align=4 R5=pkt(id=3,off=4,r=0),aux_off=14,aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+                        /* And once more we add a variable, which causes an accumulation
+                         * of reg->off into reg->aux_off_align, with resulting value of
+                         * 18.  The auxiliary alignment stays at 4.
+                         */
+                        "29: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=inv,aux_off_align=4 R5=pkt(id=4,off=0,r=0),aux_off=18,aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+                        /* At the time the word size load is performed from R5,
+                         * it's total offset is NET_IP_ALIGN + reg->off (0) +
+                         * reg->aux_off (18) which is 20.  Then the variable offset
+                         * is considered using reg->aux_off_align which is 4 and meets
+                         * the load's requirements.
+                         */
+                        "33: R0=pkt(id=0,off=8,r=8) R1=ctx R2=pkt(id=0,off=0,r=8) R3=pkt_end R4=pkt(id=4,off=4,r=4),aux_off=18,aux_off_align=4 R5=pkt(id=4,off=0,r=4),aux_off=18,aux_off_align=4 R6=inv54,min_align=4 R10=fp",
+                },
+        },
+};
+
+static int probe_filter_length(const struct bpf_insn *fp)
+{
+        int len;
+
+        for (len = MAX_INSNS - 1; len > 0; --len)
+                if (fp[len].code != 0 || fp[len].imm != 0)
+                        break;
+        return len + 1;
+}
+
+static char bpf_vlog[32768];
+
+static int do_test_single(struct bpf_align_test *test)
+{
+        struct bpf_insn *prog = test->insns;
+        int prog_type = test->prog_type;
+        int prog_len, i;
+        int fd_prog;
+        int ret;
+
+        prog_len = probe_filter_length(prog);
+        fd_prog = bpf_verify_program(prog_type ? : BPF_PROG_TYPE_SOCKET_FILTER,
+                                     prog, prog_len, 1, "GPL", 0,
+                                     bpf_vlog, sizeof(bpf_vlog));
+        if (fd_prog < 0) {
+                printf("Failed to load program.\n");
+                printf("%s", bpf_vlog);
+                ret = 1;
+        } else {
+                ret = 0;
+                for (i = 0; i < MAX_MATCHES; i++) {
+                        const char *t, *m = test->matches[i];
+
+                        if (!m)
+                                break;
+                        t = strstr(bpf_vlog, m);
+                        if (!t) {
+                                printf("Failed to find match: %s\n", m);
+                                ret = 1;
+                                printf("%s", bpf_vlog);
+                                break;
+                        }
+                }
+                close(fd_prog);
+        }
+        return ret;
+}
+
+static int do_test(unsigned int from, unsigned int to)
+{
+        int all_pass = 0;
+        int all_fail = 0;
+        unsigned int i;
+
+        for (i = from; i < to; i++) {
+                struct bpf_align_test *test = &tests[i];
+                int fail;
+
+                printf("Test %3d: %s ... ",
+                       i, test->descr);
+                fail = do_test_single(test);
+                if (fail) {
+                        all_fail++;
+                        printf("FAIL\n");
+                } else {
+                        all_pass++;
+                        printf("PASS\n");
+                }
+        }
+        printf("Results: %d pass %d fail\n",
+               all_pass, all_fail);
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        unsigned int from = 0, to = ARRAY_SIZE(tests);
+
+        if (argc == 3) {
+                unsigned int l = atoi(argv[argc - 2]);
+                unsigned int u = atoi(argv[argc - 1]);
+
+                if (l < to && u < to) {
+                        from = l;
+                        to   = u + 1;
+                }
+        } else if (argc == 2) {
+                unsigned int t = atoi(argv[argc - 1]);
+
+                if (t < to) {
+                        from = t;
+                        to   = t + 1;
+                }
+        }
+        return do_test(from, to);
+}
diff --git a/tools/testing/selftests/bpf/test_iptunnel_common.h b/tools/testing/selftests/bpf/test_iptunnel_common.h
new file mode 100644
index 000000000000..e4cd252a1b20
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_iptunnel_common.h
@@ -0,0 +1,37 @@
+/* Copyright (c) 2016 Facebook
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+#ifndef _TEST_IPTNL_COMMON_H
+#define _TEST_IPTNL_COMMON_H
+
+#include <linux/types.h>
+
+#define MAX_IPTNL_ENTRIES 256U
+
+struct vip {
+        union {
+                __u32 v6[4];
+                __u32 v4;
+        } daddr;
+        __u16 dport;
+        __u16 family;
+        __u8 protocol;
+};
+
+struct iptnl_info {
+        union {
+                __u32 v6[4];
+                __u32 v4;
+        } saddr;
+        union {
+                __u32 v6[4];
+                __u32 v4;
+        } daddr;
+        __u16 family;
+        __u8 dmac[6];
+};
+
+#endif
diff --git a/tools/testing/selftests/bpf/test_l4lb.c b/tools/testing/selftests/bpf/test_l4lb.c
new file mode 100644
index 000000000000..1e10c9590991
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_l4lb.c
@@ -0,0 +1,473 @@
+/* Copyright (c) 2017 Facebook
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+#include <stddef.h>
+#include <stdbool.h>
+#include <string.h>
+#include <linux/pkt_cls.h>
+#include <linux/bpf.h>
+#include <linux/in.h>
+#include <linux/if_ether.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/icmp.h>
+#include <linux/icmpv6.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include "bpf_helpers.h"
+#include "test_iptunnel_common.h"
+#include "bpf_endian.h"
+
+int _version SEC("version") = 1;
+
+static inline __u32 rol32(__u32 word, unsigned int shift)
+{
+        return (word << shift) | (word >> ((-shift) & 31));
+}
+
+/* copy paste of jhash from kernel sources to make sure llvm
+ * can compile it into valid sequence of bpf instructions
+ */
+#define __jhash_mix(a, b, c)                    \
+{                                               \
+        a -= c;  a ^= rol32(c, 4);  c += b;     \
+        b -= a;  b ^= rol32(a, 6);  a += c;     \
+        c -= b;  c ^= rol32(b, 8);  b += a;     \
+        a -= c;  a ^= rol32(c, 16); c += b;     \
+        b -= a;  b ^= rol32(a, 19); a += c;     \
+        c -= b;  c ^= rol32(b, 4);  b += a;     \
+}
+
+#define __jhash_final(a, b, c)                  \
+{                                               \
+        c ^= b; c -= rol32(b, 14);              \
+        a ^= c; a -= rol32(c, 11);              \
+        b ^= a; b -= rol32(a, 25);              \
+        c ^= b; c -= rol32(b, 16);              \
+        a ^= c; a -= rol32(c, 4);               \
+        b ^= a; b -= rol32(a, 14);              \
+        c ^= b; c -= rol32(b, 24);              \
+}
+
+#define JHASH_INITVAL           0xdeadbeef
+
+typedef unsigned int u32;
+
+static inline u32 jhash(const void *key, u32 length, u32 initval)
+{
+        u32 a, b, c;
+        const unsigned char *k = key;
+
+        a = b = c = JHASH_INITVAL + length + initval;
+
+        while (length > 12) {
+                a += *(u32 *)(k);
+                b += *(u32 *)(k + 4);
+                c += *(u32 *)(k + 8);
+                __jhash_mix(a, b, c);
+                length -= 12;
+                k += 12;
+        }
+        switch (length) {
+        case 12: c += (u32)k[11]<<24;
+        case 11: c += (u32)k[10]<<16;
+        case 10: c += (u32)k[9]<<8;
+        case 9:  c += k[8];
+        case 8:  b += (u32)k[7]<<24;
+        case 7:  b += (u32)k[6]<<16;
+        case 6:  b += (u32)k[5]<<8;
+        case 5:  b += k[4];
+        case 4:  a += (u32)k[3]<<24;
+        case 3:  a += (u32)k[2]<<16;
+        case 2:  a += (u32)k[1]<<8;
+        case 1:  a += k[0];
+                 __jhash_final(a, b, c);
+        case 0: /* Nothing left to add */
+                break;
+        }
+
+        return c;
+}
+
+static inline u32 __jhash_nwords(u32 a, u32 b, u32 c, u32 initval)
+{
+        a += initval;
+        b += initval;
+        c += initval;
+        __jhash_final(a, b, c);
+        return c;
+}
+
+static inline u32 jhash_2words(u32 a, u32 b, u32 initval)
+{
+        return __jhash_nwords(a, b, 0, initval + JHASH_INITVAL + (2 << 2));
+}
+
+#define PCKT_FRAGMENTED 65343
+#define IPV4_HDR_LEN_NO_OPT 20
+#define IPV4_PLUS_ICMP_HDR 28
+#define IPV6_PLUS_ICMP_HDR 48
+#define RING_SIZE 2
+#define MAX_VIPS 12
+#define MAX_REALS 5
+#define CTL_MAP_SIZE 16
+#define CH_RINGS_SIZE (MAX_VIPS * RING_SIZE)
+#define F_IPV6 (1 << 0)
+#define F_HASH_NO_SRC_PORT (1 << 0)
+#define F_ICMP (1 << 0)
+#define F_SYN_SET (1 << 1)
+
+struct packet_description {
+        union {
+                __be32 src;
+                __be32 srcv6[4];
+        };
+        union {
+                __be32 dst;
+                __be32 dstv6[4];
+        };
+        union {
+                __u32 ports;
+                __u16 port16[2];
+        };
+        __u8 proto;
+        __u8 flags;
+};
+
+struct ctl_value {
+        union {
+                __u64 value;
+                __u32 ifindex;
+                __u8 mac[6];
+        };
+};
+
+struct vip_meta {
+        __u32 flags;
+        __u32 vip_num;
+};
+
+struct real_definition {
+        union {
+                __be32 dst;
+                __be32 dstv6[4];
+        };
+        __u8 flags;
+};
+
+struct vip_stats {
+        __u64 bytes;
+        __u64 pkts;
+};
+
+struct eth_hdr {
+        unsigned char eth_dest[ETH_ALEN];
+        unsigned char eth_source[ETH_ALEN];
+        unsigned short eth_proto;
+};
+
+struct bpf_map_def SEC("maps") vip_map = {
+        .type = BPF_MAP_TYPE_HASH,
+        .key_size = sizeof(struct vip),
+        .value_size = sizeof(struct vip_meta),
+        .max_entries = MAX_VIPS,
+};
+
+struct bpf_map_def SEC("maps") ch_rings = {
+        .type = BPF_MAP_TYPE_ARRAY,
+        .key_size = sizeof(__u32),
+        .value_size = sizeof(__u32),
+        .max_entries = CH_RINGS_SIZE,
+};
+
+struct bpf_map_def SEC("maps") reals = {
+        .type = BPF_MAP_TYPE_ARRAY,
+        .key_size = sizeof(__u32),
+        .value_size = sizeof(struct real_definition),
+        .max_entries = MAX_REALS,
+};
+
+struct bpf_map_def SEC("maps") stats = {
+        .type = BPF_MAP_TYPE_PERCPU_ARRAY,
+        .key_size = sizeof(__u32),
+        .value_size = sizeof(struct vip_stats),
+        .max_entries = MAX_VIPS,
+};
+
+struct bpf_map_def SEC("maps") ctl_array = {
+        .type = BPF_MAP_TYPE_ARRAY,
+        .key_size = sizeof(__u32),
+        .value_size = sizeof(struct ctl_value),
+        .max_entries = CTL_MAP_SIZE,
+};
+
+static __always_inline __u32 get_packet_hash(struct packet_description *pckt,
+                                             bool ipv6)
+{
+        if (ipv6)
+                return jhash_2words(jhash(pckt->srcv6, 16, MAX_VIPS),
+                                    pckt->ports, CH_RINGS_SIZE);
+        else
+                return jhash_2words(pckt->src, pckt->ports, CH_RINGS_SIZE);
+}
+
+static __always_inline bool get_packet_dst(struct real_definition **real,
+                                           struct packet_description *pckt,
+                                           struct vip_meta *vip_info,
+                                           bool is_ipv6)
+{
+        __u32 hash = get_packet_hash(pckt, is_ipv6) % RING_SIZE;
+        __u32 key = RING_SIZE * vip_info->vip_num + hash;
+        __u32 *real_pos;
+
+        real_pos = bpf_map_lookup_elem(&ch_rings, &key);
+        if (!real_pos)
+                return false;
+        key = *real_pos;
+        *real = bpf_map_lookup_elem(&reals, &key);
+        if (!(*real))
+                return false;
+        return true;
+}
+
+static __always_inline int parse_icmpv6(void *data, void *data_end, __u64 off,
+                                        struct packet_description *pckt)
+{
+        struct icmp6hdr *icmp_hdr;
+        struct ipv6hdr *ip6h;
+
+        icmp_hdr = data + off;
+        if (icmp_hdr + 1 > data_end)
+                return TC_ACT_SHOT;
+        if (icmp_hdr->icmp6_type != ICMPV6_PKT_TOOBIG)
+                return TC_ACT_OK;
+        off += sizeof(struct icmp6hdr);
+        ip6h = data + off;
+        if (ip6h + 1 > data_end)
+                return TC_ACT_SHOT;
+        pckt->proto = ip6h->nexthdr;
+        pckt->flags |= F_ICMP;
+        memcpy(pckt->srcv6, ip6h->daddr.s6_addr32, 16);
+        memcpy(pckt->dstv6, ip6h->saddr.s6_addr32, 16);
+        return TC_ACT_UNSPEC;
+}
+
+static __always_inline int parse_icmp(void *data, void *data_end, __u64 off,
+                                      struct packet_description *pckt)
+{
+        struct icmphdr *icmp_hdr;
+        struct iphdr *iph;
+
+        icmp_hdr = data + off;
+        if (icmp_hdr + 1 > data_end)
+                return TC_ACT_SHOT;
+        if (icmp_hdr->type != ICMP_DEST_UNREACH ||
+            icmp_hdr->code != ICMP_FRAG_NEEDED)
+                return TC_ACT_OK;
+        off += sizeof(struct icmphdr);
+        iph = data + off;
+        if (iph + 1 > data_end)
+                return TC_ACT_SHOT;
+        if (iph->ihl != 5)
+                return TC_ACT_SHOT;
+        pckt->proto = iph->protocol;
+        pckt->flags |= F_ICMP;
+        pckt->src = iph->daddr;
+        pckt->dst = iph->saddr;
+        return TC_ACT_UNSPEC;
+}
+
+static __always_inline bool parse_udp(void *data, __u64 off, void *data_end,
+                                      struct packet_description *pckt)
+{
+        struct udphdr *udp;
+        udp = data + off;
+
+        if (udp + 1 > data_end)
+                return false;
+
+        if (!(pckt->flags & F_ICMP)) {
+                pckt->port16[0] = udp->source;
+                pckt->port16[1] = udp->dest;
+        } else {
+                pckt->port16[0] = udp->dest;
+                pckt->port16[1] = udp->source;
+        }
+        return true;
+}
+
+static __always_inline bool parse_tcp(void *data, __u64 off, void *data_end,
+                                      struct packet_description *pckt)
+{
+        struct tcphdr *tcp;
+
+        tcp = data + off;
+        if (tcp + 1 > data_end)
+                return false;
+
+        if (tcp->syn)
+                pckt->flags |= F_SYN_SET;
+
+        if (!(pckt->flags & F_ICMP)) {
+                pckt->port16[0] = tcp->source;
+                pckt->port16[1] = tcp->dest;
+        } else {
+                pckt->port16[0] = tcp->dest;
+                pckt->port16[1] = tcp->source;
+        }
+        return true;
+}
+
+static __always_inline int process_packet(void *data, __u64 off, void *data_end,
+                                          bool is_ipv6, struct __sk_buff *skb)
+{
+        void *pkt_start = (void *)(long)skb->data;
+        struct packet_description pckt = {};
+        struct eth_hdr *eth = pkt_start;
+        struct bpf_tunnel_key tkey = {};
+        struct vip_stats *data_stats;
+        struct real_definition *dst;
+        struct vip_meta *vip_info;
+        struct ctl_value *cval;
+        __u32 v4_intf_pos = 1;
+        __u32 v6_intf_pos = 2;
+        struct ipv6hdr *ip6h;
+        struct vip vip = {};
+        struct iphdr *iph;
+        int tun_flag = 0;
+        __u16 pkt_bytes;
+        __u64 iph_len;
+        __u32 ifindex;
+        __u8 protocol;
+        __u32 vip_num;
+        int action;
+
+        tkey.tunnel_ttl = 64;
+        if (is_ipv6) {
+                ip6h = data + off;
+                if (ip6h + 1 > data_end)
+                        return TC_ACT_SHOT;
+
+                iph_len = sizeof(struct ipv6hdr);
+                protocol = ip6h->nexthdr;
+                pckt.proto = protocol;
+                pkt_bytes = bpf_ntohs(ip6h->payload_len);
+                off += iph_len;
+                if (protocol == IPPROTO_FRAGMENT) {
+                        return TC_ACT_SHOT;
+                } else if (protocol == IPPROTO_ICMPV6) {
+                        action = parse_icmpv6(data, data_end, off, &pckt);
+                        if (action >= 0)
+                                return action;
+                        off += IPV6_PLUS_ICMP_HDR;
+                } else {
+                        memcpy(pckt.srcv6, ip6h->saddr.s6_addr32, 16);
+                        memcpy(pckt.dstv6, ip6h->daddr.s6_addr32, 16);
+                }
+        } else {
+                iph = data + off;
+                if (iph + 1 > data_end)
+                        return TC_ACT_SHOT;
+                if (iph->ihl != 5)
+                        return TC_ACT_SHOT;
+
+                protocol = iph->protocol;
+                pckt.proto = protocol;
+                pkt_bytes = bpf_ntohs(iph->tot_len);
+                off += IPV4_HDR_LEN_NO_OPT;
+
+                if (iph->frag_off & PCKT_FRAGMENTED)
+                        return TC_ACT_SHOT;
+                if (protocol == IPPROTO_ICMP) {
+                        action = parse_icmp(data, data_end, off, &pckt);
+                        if (action >= 0)
+                                return action;
+                        off += IPV4_PLUS_ICMP_HDR;
+                } else {
+                        pckt.src = iph->saddr;
+                        pckt.dst = iph->daddr;
+                }
+        }
+        protocol = pckt.proto;
+
+        if (protocol == IPPROTO_TCP) {
+                if (!parse_tcp(data, off, data_end, &pckt))
+                        return TC_ACT_SHOT;
+        } else if (protocol == IPPROTO_UDP) {
+                if (!parse_udp(data, off, data_end, &pckt))
+                        return TC_ACT_SHOT;
+        } else {
+                return TC_ACT_SHOT;
+        }
+
+        if (is_ipv6)
+                memcpy(vip.daddr.v6, pckt.dstv6, 16);
+        else
+                vip.daddr.v4 = pckt.dst;
+
+        vip.dport = pckt.port16[1];
+        vip.protocol = pckt.proto;
+        vip_info = bpf_map_lookup_elem(&vip_map, &vip);
+        if (!vip_info) {
+                vip.dport = 0;
+                vip_info = bpf_map_lookup_elem(&vip_map, &vip);
+                if (!vip_info)
+                        return TC_ACT_SHOT;
+                pckt.port16[1] = 0;
+        }
+
+        if (vip_info->flags & F_HASH_NO_SRC_PORT)
+                pckt.port16[0] = 0;
+
+        if (!get_packet_dst(&dst, &pckt, vip_info, is_ipv6))
+                return TC_ACT_SHOT;
+
+        if (dst->flags & F_IPV6) {
+                cval = bpf_map_lookup_elem(&ctl_array, &v6_intf_pos);
+                if (!cval)
+                        return TC_ACT_SHOT;
+                ifindex = cval->ifindex;
+                memcpy(tkey.remote_ipv6, dst->dstv6, 16);
+                tun_flag = BPF_F_TUNINFO_IPV6;
+        } else {
+                cval = bpf_map_lookup_elem(&ctl_array, &v4_intf_pos);
+                if (!cval)
+                        return TC_ACT_SHOT;
+                ifindex = cval->ifindex;
+                tkey.remote_ipv4 = dst->dst;
+        }
+        vip_num = vip_info->vip_num;
+        data_stats = bpf_map_lookup_elem(&stats, &vip_num);
+        if (!data_stats)
+                return TC_ACT_SHOT;
+        data_stats->pkts++;
+        data_stats->bytes += pkt_bytes;
+        bpf_skb_set_tunnel_key(skb, &tkey, sizeof(tkey), tun_flag);
+        *(u32 *)eth->eth_dest = tkey.remote_ipv4;
+        return bpf_redirect(ifindex, 0);
+}
+
+SEC("l4lb-demo")
+int balancer_ingress(struct __sk_buff *ctx)
+{
+        void *data_end = (void *)(long)ctx->data_end;
+        void *data = (void *)(long)ctx->data;
+        struct eth_hdr *eth = data;
+        __u32 eth_proto;
+        __u32 nh_off;
+
+        nh_off = sizeof(struct eth_hdr);
+        if (data + nh_off > data_end)
+                return TC_ACT_SHOT;
+        eth_proto = eth->eth_proto;
+        if (eth_proto == bpf_htons(ETH_P_IP))
+                return process_packet(data, nh_off, data_end, false, ctx);
+        else if (eth_proto == bpf_htons(ETH_P_IPV6))
+                return process_packet(data, nh_off, data_end, true, ctx);
+        else
+                return TC_ACT_SHOT;
+}
+char _license[] SEC("license") = "GPL";
diff --git a/tools/testing/selftests/bpf/test_lru_map.c b/tools/testing/selftests/bpf/test_lru_map.c
index 00b0aff56e2e..8c10c9180c1a 100644
--- a/tools/testing/selftests/bpf/test_lru_map.c
+++ b/tools/testing/selftests/bpf/test_lru_map.c
@@ -22,7 +22,7 @@
 #include "bpf_util.h"
 
 #define LOCAL_FREE_TARGET       (128)
-#define PERCPU_FREE_TARGET      (16)
+#define PERCPU_FREE_TARGET      (4)
 
 static int nr_cpus;
 
@@ -191,12 +191,7 @@ static void test_lru_sanity1(int map_type, int map_flags, unsigned int tgt_free)
         int next_cpu = 0;
 
         if (map_flags & BPF_F_NO_COMMON_LRU)
-                /* Ther percpu lru list (i.e each cpu has its own LRU
-                 * list) does not have a local free list.  Hence,
-                 * it will only free old nodes till there is no free
-                 * from the LRU list.  Hence, this test does not apply
-                 * to BPF_F_NO_COMMON_LRU
-                 */
+                /* This test is only applicable to common LRU list */
                 return;
 
         printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type,
@@ -227,7 +222,7 @@ static void test_lru_sanity1(int map_type, int map_flags, unsigned int tgt_free)
         for (key = 1; key < end_key; key++) {
                 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value));
                 assert(!bpf_map_update_elem(expected_map_fd, &key, value,
-                                            BPF_NOEXIST));
+                                            BPF_NOEXIST));
         }
 
         /* Insert 1+tgt_free to 2*tgt_free
@@ -273,12 +268,7 @@ static void test_lru_sanity2(int map_type, int map_flags, unsigned int tgt_free)
         int next_cpu = 0;
 
         if (map_flags & BPF_F_NO_COMMON_LRU)
-                /* Ther percpu lru list (i.e each cpu has its own LRU
-                 * list) does not have a local free list.  Hence,
-                 * it will only free old nodes till there is no free
-                 * from the LRU list.  Hence, this test does not apply
-                 * to BPF_F_NO_COMMON_LRU
-                 */
+                /* This test is only applicable to common LRU list */
                 return;
 
         printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type,
@@ -290,11 +280,7 @@ static void test_lru_sanity2(int map_type, int map_flags, unsigned int tgt_free)
         assert(batch_size * 2 == tgt_free);
 
         map_size = tgt_free + batch_size;
-        if (map_flags & BPF_F_NO_COMMON_LRU)
-                lru_map_fd = create_map(map_type, map_flags,
-                                        map_size * nr_cpus);
-        else
-                lru_map_fd = create_map(map_type, map_flags, map_size);
+        lru_map_fd = create_map(map_type, map_flags, map_size);
         assert(lru_map_fd != -1);
 
         expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size);
@@ -341,7 +327,7 @@ static void test_lru_sanity2(int map_type, int map_flags, unsigned int tgt_free)
                 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value));
                 assert(value[0] == 4321);
                 assert(!bpf_map_update_elem(expected_map_fd, &key, value,
-                                            BPF_NOEXIST));
+                                            BPF_NOEXIST));
         }
 
         value[0] = 1234;
@@ -361,7 +347,7 @@ static void test_lru_sanity2(int map_type, int map_flags, unsigned int tgt_free)
                 assert(!bpf_map_update_elem(lru_map_fd, &key, value,
                                             BPF_NOEXIST));
                 assert(!bpf_map_update_elem(expected_map_fd, &key, value,
-                                            BPF_NOEXIST));
+                                            BPF_NOEXIST));
         }
 
         assert(map_equal(lru_map_fd, expected_map_fd));
@@ -387,6 +373,10 @@ static void test_lru_sanity3(int map_type, int map_flags, unsigned int tgt_free)
         unsigned int map_size;
         int next_cpu = 0;
 
+        if (map_flags & BPF_F_NO_COMMON_LRU)
+                /* This test is only applicable to common LRU list */
+                return;
+
         printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type,
                map_flags);
 
@@ -396,11 +386,7 @@ static void test_lru_sanity3(int map_type, int map_flags, unsigned int tgt_free)
         assert(batch_size * 2 == tgt_free);
 
         map_size = tgt_free * 2;
-        if (map_flags & BPF_F_NO_COMMON_LRU)
-                lru_map_fd = create_map(map_type, map_flags,
-                                        map_size * nr_cpus);
-        else
-                lru_map_fd = create_map(map_type, map_flags, map_size);
+        lru_map_fd = create_map(map_type, map_flags, map_size);
         assert(lru_map_fd != -1);
 
         expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size);
@@ -419,7 +405,7 @@ static void test_lru_sanity3(int map_type, int map_flags, unsigned int tgt_free)
         for (key = 1; key < end_key; key++) {
                 assert(!bpf_map_lookup_elem(lru_map_fd, &key, value));
                 assert(!bpf_map_update_elem(expected_map_fd, &key, value,
-                                            BPF_NOEXIST));
+                                            BPF_NOEXIST));
         }
 
         /* Add 1+2*tgt_free to tgt_free*5/2
@@ -431,7 +417,7 @@ static void test_lru_sanity3(int map_type, int map_flags, unsigned int tgt_free)
                 assert(!bpf_map_update_elem(lru_map_fd, &key, value,
                                             BPF_NOEXIST));
                 assert(!bpf_map_update_elem(expected_map_fd, &key, value,
-                                            BPF_NOEXIST));
+                                            BPF_NOEXIST));
         }
 
         assert(map_equal(lru_map_fd, expected_map_fd));
@@ -491,7 +477,7 @@ static void test_lru_sanity4(int map_type, int map_flags, unsigned int tgt_free)
                 assert(!bpf_map_update_elem(lru_map_fd, &key, value,
                                             BPF_NOEXIST));
                 assert(!bpf_map_update_elem(expected_map_fd, &key, value,
-                                            BPF_NOEXIST));
+                                            BPF_NOEXIST));
         }
 
         assert(map_equal(lru_map_fd, expected_map_fd));
@@ -566,6 +552,65 @@ static void test_lru_sanity5(int map_type, int map_flags)
         printf("Pass\n");
 }
 
+/* Test list rotation for BPF_F_NO_COMMON_LRU map */
+static void test_lru_sanity6(int map_type, int map_flags, int tgt_free)
+{
+        int lru_map_fd, expected_map_fd;
+        unsigned long long key, value[nr_cpus];
+        unsigned int map_size = tgt_free * 2;
+        int next_cpu = 0;
+
+        if (!(map_flags & BPF_F_NO_COMMON_LRU))
+                return;
+
+        printf("%s (map_type:%d map_flags:0x%X): ", __func__, map_type,
+               map_flags);
+
+        assert(sched_next_online(0, &next_cpu) != -1);
+
+        expected_map_fd = create_map(BPF_MAP_TYPE_HASH, 0, map_size);
+        assert(expected_map_fd != -1);
+
+        lru_map_fd = create_map(map_type, map_flags, map_size * nr_cpus);
+        assert(lru_map_fd != -1);
+
+        value[0] = 1234;
+
+        for (key = 1; key <= tgt_free; key++) {
+                assert(!bpf_map_update_elem(lru_map_fd, &key, value,
+                                            BPF_NOEXIST));
+                assert(!bpf_map_update_elem(expected_map_fd, &key, value,
+                                            BPF_NOEXIST));
+        }
+
+        for (; key <= tgt_free * 2; key++) {
+                unsigned long long stable_key;
+
+                /* Make ref bit sticky for key: [1, tgt_free] */
+                for (stable_key = 1; stable_key <= tgt_free; stable_key++) {
+                        /* Mark the ref bit */
+                        assert(!bpf_map_lookup_elem(lru_map_fd, &stable_key,
+                                                    value));
+                }
+                assert(!bpf_map_update_elem(lru_map_fd, &key, value,
+                                            BPF_NOEXIST));
+        }
+
+        for (; key <= tgt_free * 3; key++) {
+                assert(!bpf_map_update_elem(lru_map_fd, &key, value,
+                                            BPF_NOEXIST));
+                assert(!bpf_map_update_elem(expected_map_fd, &key, value,
+                                            BPF_NOEXIST));
+        }
+
+        assert(map_equal(lru_map_fd, expected_map_fd));
+
+        close(expected_map_fd);
+        close(lru_map_fd);
+
+        printf("Pass\n");
+}
+
 int main(int argc, char **argv)
 {
         struct rlimit r = {RLIM_INFINITY, RLIM_INFINITY};
@@ -593,6 +638,7 @@ int main(int argc, char **argv)
                         test_lru_sanity3(map_types[t], map_flags[f], tgt_free);
                         test_lru_sanity4(map_types[t], map_flags[f], tgt_free);
                         test_lru_sanity5(map_types[t], map_flags[f]);
+                        test_lru_sanity6(map_types[t], map_flags[f], tgt_free);
 
                         printf("\n");
                 }
diff --git a/tools/testing/selftests/bpf/test_maps.c b/tools/testing/selftests/bpf/test_maps.c
index a0aa2009b0e0..93314524de0d 100644
--- a/tools/testing/selftests/bpf/test_maps.c
+++ b/tools/testing/selftests/bpf/test_maps.c
@@ -28,7 +28,7 @@ static int map_flags;
 
 static void test_hashmap(int task, void *data)
 {
-        long long key, next_key, value;
+        long long key, next_key, first_key, value;
         int fd;
 
         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
@@ -89,10 +89,13 @@ static void test_hashmap(int task, void *data)
         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
 
         /* Iterate over two elements. */
+        assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
+               (first_key == 1 || first_key == 2));
         assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
-               (next_key == 1 || next_key == 2));
+               (next_key == first_key));
         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
-               (next_key == 1 || next_key == 2));
+               (next_key == 1 || next_key == 2) &&
+               (next_key != first_key));
         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
                errno == ENOENT);
 
@@ -105,6 +108,8 @@ static void test_hashmap(int task, void *data)
 
         key = 0;
         /* Check that map is empty. */
+        assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
+               errno == ENOENT);
         assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
                errno == ENOENT);
 
@@ -132,20 +137,20 @@ static void test_hashmap_sizes(int task, void *data)
 static void test_hashmap_percpu(int task, void *data)
 {
         unsigned int nr_cpus = bpf_num_possible_cpus();
-        long long value[nr_cpus];
-        long long key, next_key;
+        BPF_DECLARE_PERCPU(long, value);
+        long long key, next_key, first_key;
         int expected_key_mask = 0;
         int fd, i;
 
         fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_HASH, sizeof(key),
-                            sizeof(value[0]), 2, map_flags);
+                            sizeof(bpf_percpu(value, 0)), 2, map_flags);
         if (fd < 0) {
                 printf("Failed to create hashmap '%s'!\n", strerror(errno));
                 exit(1);
         }
 
         for (i = 0; i < nr_cpus; i++)
-                value[i] = i + 100;
+                bpf_percpu(value, i) = i + 100;
 
         key = 1;
         /* Insert key=1 element. */
@@ -165,8 +170,9 @@ static void test_hashmap_percpu(int task, void *data)
         /* Check that key=1 can be found. Value could be 0 if the lookup
          * was run from a different CPU.
          */
-        value[0] = 1;
-        assert(bpf_map_lookup_elem(fd, &key, value) == 0 && value[0] == 100);
+        bpf_percpu(value, 0) = 1;
+        assert(bpf_map_lookup_elem(fd, &key, value) == 0 &&
+               bpf_percpu(value, 0) == 100);
 
         key = 2;
         /* Check that key=2 is not found. */
@@ -193,14 +199,20 @@ static void test_hashmap_percpu(int task, void *data)
         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
 
         /* Iterate over two elements. */
+        assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
+               ((expected_key_mask & first_key) == first_key));
         while (!bpf_map_get_next_key(fd, &key, &next_key)) {
+                if (first_key) {
+                        assert(next_key == first_key);
+                        first_key = 0;
+                }
                 assert((expected_key_mask & next_key) == next_key);
                 expected_key_mask &= ~next_key;
 
                 assert(bpf_map_lookup_elem(fd, &next_key, value) == 0);
 
                 for (i = 0; i < nr_cpus; i++)
-                        assert(value[i] == i + 100);
+                        assert(bpf_percpu(value, i) == i + 100);
 
                 key = next_key;
         }
@@ -219,6 +231,8 @@ static void test_hashmap_percpu(int task, void *data)
 
         key = 0;
         /* Check that map is empty. */
+        assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
+               errno == ENOENT);
         assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
                errno == ENOENT);
 
@@ -264,6 +278,8 @@ static void test_arraymap(int task, void *data)
         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
 
         /* Iterate over two elements. */
+        assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
+               next_key == 0);
         assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
                next_key == 0);
         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
@@ -281,34 +297,36 @@ static void test_arraymap(int task, void *data)
 static void test_arraymap_percpu(int task, void *data)
 {
         unsigned int nr_cpus = bpf_num_possible_cpus();
+        BPF_DECLARE_PERCPU(long, values);
         int key, next_key, fd, i;
-        long values[nr_cpus];
 
         fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
-                            sizeof(values[0]), 2, 0);
+                            sizeof(bpf_percpu(values, 0)), 2, 0);
         if (fd < 0) {
                 printf("Failed to create arraymap '%s'!\n", strerror(errno));
                 exit(1);
         }
 
         for (i = 0; i < nr_cpus; i++)
-                values[i] = i + 100;
+                bpf_percpu(values, i) = i + 100;
 
         key = 1;
         /* Insert key=1 element. */
         assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
 
-        values[0] = 0;
+        bpf_percpu(values, 0) = 0;
         assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) == -1 &&
                errno == EEXIST);
 
         /* Check that key=1 can be found. */
-        assert(bpf_map_lookup_elem(fd, &key, values) == 0 && values[0] == 100);
+        assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
+               bpf_percpu(values, 0) == 100);
 
         key = 0;
         /* Check that key=0 is also found and zero initialized. */
         assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
-               values[0] == 0 && values[nr_cpus - 1] == 0);
+               bpf_percpu(values, 0) == 0 &&
+               bpf_percpu(values, nr_cpus - 1) == 0);
 
         /* Check that key=2 cannot be inserted due to max_entries limit. */
         key = 2;
@@ -319,6 +337,8 @@ static void test_arraymap_percpu(int task, void *data)
         assert(bpf_map_lookup_elem(fd, &key, values) == -1 && errno == ENOENT);
 
         /* Iterate over two elements. */
+        assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
+               next_key == 0);
         assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
                next_key == 0);
         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
@@ -336,15 +356,15 @@ static void test_arraymap_percpu(int task, void *data)
 static void test_arraymap_percpu_many_keys(void)
 {
         unsigned int nr_cpus = bpf_num_possible_cpus();
+        BPF_DECLARE_PERCPU(long, values);
         /* nr_keys is not too large otherwise the test stresses percpu
          * allocator more than anything else
          */
         unsigned int nr_keys = 2000;
-        long values[nr_cpus];
         int key, fd, i;
 
         fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
-                            sizeof(values[0]), nr_keys, 0);
+                            sizeof(bpf_percpu(values, 0)), nr_keys, 0);
         if (fd < 0) {
                 printf("Failed to create per-cpu arraymap '%s'!\n",
                        strerror(errno));
@@ -352,19 +372,19 @@ static void test_arraymap_percpu_many_keys(void)
         }
 
         for (i = 0; i < nr_cpus; i++)
-                values[i] = i + 10;
+                bpf_percpu(values, i) = i + 10;
 
         for (key = 0; key < nr_keys; key++)
                 assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
 
         for (key = 0; key < nr_keys; key++) {
                 for (i = 0; i < nr_cpus; i++)
-                        values[i] = 0;
+                        bpf_percpu(values, i) = 0;
 
                 assert(bpf_map_lookup_elem(fd, &key, values) == 0);
 
                 for (i = 0; i < nr_cpus; i++)
-                        assert(values[i] == i + 10);
+                        assert(bpf_percpu(values, i) == i + 10);
         }
 
         close(fd);
@@ -400,6 +420,8 @@ static void test_map_large(void)
                errno == E2BIG);
 
         /* Iterate through all elements. */
+        assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
+        key.c = -1;
         for (i = 0; i < MAP_SIZE; i++)
                 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
@@ -499,6 +521,7 @@ static void test_map_parallel(void)
                errno == EEXIST);
 
         /* Check that all elements were inserted. */
+        assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
         key = -1;
         for (i = 0; i < MAP_SIZE; i++)
                 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
@@ -518,6 +541,7 @@ static void test_map_parallel(void)
 
         /* Nothing should be left. */
         key = -1;
+        assert(bpf_map_get_next_key(fd, NULL, &key) == -1 && errno == ENOENT);
         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
 }
 
diff --git a/tools/testing/selftests/bpf/test_pkt_access.c b/tools/testing/selftests/bpf/test_pkt_access.c
new file mode 100644
index 000000000000..6e11ba11709e
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_pkt_access.c
@@ -0,0 +1,65 @@
+/* Copyright (c) 2017 Facebook
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+#include <stddef.h>
+#include <string.h>
+#include <linux/bpf.h>
+#include <linux/if_ether.h>
+#include <linux/if_packet.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/in.h>
+#include <linux/tcp.h>
+#include <linux/pkt_cls.h>
+#include "bpf_helpers.h"
+#include "bpf_endian.h"
+
+#define barrier() __asm__ __volatile__("": : :"memory")
+int _version SEC("version") = 1;
+
+SEC("test1")
+int process(struct __sk_buff *skb)
+{
+        void *data_end = (void *)(long)skb->data_end;
+        void *data = (void *)(long)skb->data;
+        struct ethhdr *eth = (struct ethhdr *)(data);
+        struct tcphdr *tcp = NULL;
+        __u8 proto = 255;
+        __u64 ihl_len;
+
+        if (eth + 1 > data_end)
+                return TC_ACT_SHOT;
+
+        if (eth->h_proto == bpf_htons(ETH_P_IP)) {
+                struct iphdr *iph = (struct iphdr *)(eth + 1);
+
+                if (iph + 1 > data_end)
+                        return TC_ACT_SHOT;
+                ihl_len = iph->ihl * 4;
+                proto = iph->protocol;
+                tcp = (struct tcphdr *)((void *)(iph) + ihl_len);
+        } else if (eth->h_proto == bpf_htons(ETH_P_IPV6)) {
+                struct ipv6hdr *ip6h = (struct ipv6hdr *)(eth + 1);
+
+                if (ip6h + 1 > data_end)
+                        return TC_ACT_SHOT;
+                ihl_len = sizeof(*ip6h);
+                proto = ip6h->nexthdr;
+                tcp = (struct tcphdr *)((void *)(ip6h) + ihl_len);
+        }
+
+        if (tcp) {
+                if (((void *)(tcp) + 20) > data_end || proto != 6)
+                        return TC_ACT_SHOT;
+                barrier(); /* to force ordering of checks */
+                if (((void *)(tcp) + 18) > data_end)
+                        return TC_ACT_SHOT;
+                if (tcp->urg_ptr == 123)
+                        return TC_ACT_OK;
+        }
+
+        return TC_ACT_UNSPEC;
+}
diff --git a/tools/testing/selftests/bpf/test_progs.c b/tools/testing/selftests/bpf/test_progs.c
new file mode 100644
index 000000000000..b59f5ed4ae40
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_progs.c
@@ -0,0 +1,299 @@
+/* Copyright (c) 2017 Facebook
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include <linux/types.h>
+typedef __u16 __sum16;
+#include <arpa/inet.h>
+#include <linux/if_ether.h>
+#include <linux/if_packet.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/tcp.h>
+
+#include <sys/wait.h>
+#include <sys/resource.h>
+
+#include <linux/bpf.h>
+#include <linux/err.h>
+#include <bpf/bpf.h>
+#include <bpf/libbpf.h>
+#include "test_iptunnel_common.h"
+#include "bpf_util.h"
+#include "bpf_endian.h"
+
+static int error_cnt, pass_cnt;
+
+#define MAGIC_BYTES 123
+
+/* ipv4 test vector */
+static struct {
+        struct ethhdr eth;
+        struct iphdr iph;
+        struct tcphdr tcp;
+} __packed pkt_v4 = {
+        .eth.h_proto = bpf_htons(ETH_P_IP),
+        .iph.ihl = 5,
+        .iph.protocol = 6,
+        .iph.tot_len = bpf_htons(MAGIC_BYTES),
+        .tcp.urg_ptr = 123,
+};
+
+/* ipv6 test vector */
+static struct {
+        struct ethhdr eth;
+        struct ipv6hdr iph;
+        struct tcphdr tcp;
+} __packed pkt_v6 = {
+        .eth.h_proto = bpf_htons(ETH_P_IPV6),
+        .iph.nexthdr = 6,
+        .iph.payload_len = bpf_htons(MAGIC_BYTES),
+        .tcp.urg_ptr = 123,
+};
+
+#define CHECK(condition, tag, format...) ({                             \
+        int __ret = !!(condition);                                      \
+        if (__ret) {                                                    \
+                error_cnt++;                                            \
+                printf("%s:FAIL:%s ", __func__, tag);                   \
+                printf(format);                                         \
+        } else {                                                        \
+                pass_cnt++;                                             \
+                printf("%s:PASS:%s %d nsec\n", __func__, tag, duration);\
+        }                                                               \
+})
+
+static int bpf_prog_load(const char *file, enum bpf_prog_type type,
+                         struct bpf_object **pobj, int *prog_fd)
+{
+        struct bpf_program *prog;
+        struct bpf_object *obj;
+        int err;
+
+        obj = bpf_object__open(file);
+        if (IS_ERR(obj)) {
+                error_cnt++;
+                return -ENOENT;
+        }
+
+        prog = bpf_program__next(NULL, obj);
+        if (!prog) {
+                bpf_object__close(obj);
+                error_cnt++;
+                return -ENOENT;
+        }
+
+        bpf_program__set_type(prog, type);
+        err = bpf_object__load(obj);
+        if (err) {
+                bpf_object__close(obj);
+                error_cnt++;
+                return -EINVAL;
+        }
+
+        *pobj = obj;
+        *prog_fd = bpf_program__fd(prog);
+        return 0;
+}
+
+static int bpf_find_map(const char *test, struct bpf_object *obj,
+                        const char *name)
+{
+        struct bpf_map *map;
+
+        map = bpf_object__find_map_by_name(obj, name);
+        if (!map) {
+                printf("%s:FAIL:map '%s' not found\n", test, name);
+                error_cnt++;
+                return -1;
+        }
+        return bpf_map__fd(map);
+}
+
+static void test_pkt_access(void)
+{
+        const char *file = "./test_pkt_access.o";
+        struct bpf_object *obj;
+        __u32 duration, retval;
+        int err, prog_fd;
+
+        err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+        if (err)
+                return;
+
+        err = bpf_prog_test_run(prog_fd, 100000, &pkt_v4, sizeof(pkt_v4),
+                                NULL, NULL, &retval, &duration);
+        CHECK(err || errno || retval, "ipv4",
+              "err %d errno %d retval %d duration %d\n",
+              err, errno, retval, duration);
+
+        err = bpf_prog_test_run(prog_fd, 100000, &pkt_v6, sizeof(pkt_v6),
+                                NULL, NULL, &retval, &duration);
+        CHECK(err || errno || retval, "ipv6",
+              "err %d errno %d retval %d duration %d\n",
+              err, errno, retval, duration);
+        bpf_object__close(obj);
+}
+
+static void test_xdp(void)
+{
+        struct vip key4 = {.protocol = 6, .family = AF_INET};
+        struct vip key6 = {.protocol = 6, .family = AF_INET6};
+        struct iptnl_info value4 = {.family = AF_INET};
+        struct iptnl_info value6 = {.family = AF_INET6};
+        const char *file = "./test_xdp.o";
+        struct bpf_object *obj;
+        char buf[128];
+        struct ipv6hdr *iph6 = (void *)buf + sizeof(struct ethhdr);
+        struct iphdr *iph = (void *)buf + sizeof(struct ethhdr);
+        __u32 duration, retval, size;
+        int err, prog_fd, map_fd;
+
+        err = bpf_prog_load(file, BPF_PROG_TYPE_XDP, &obj, &prog_fd);
+        if (err)
+                return;
+
+        map_fd = bpf_find_map(__func__, obj, "vip2tnl");
+        if (map_fd < 0)
+                goto out;
+        bpf_map_update_elem(map_fd, &key4, &value4, 0);
+        bpf_map_update_elem(map_fd, &key6, &value6, 0);
+
+        err = bpf_prog_test_run(prog_fd, 1, &pkt_v4, sizeof(pkt_v4),
+                                buf, &size, &retval, &duration);
+
+        CHECK(err || errno || retval != XDP_TX || size != 74 ||
+              iph->protocol != IPPROTO_IPIP, "ipv4",
+              "err %d errno %d retval %d size %d\n",
+              err, errno, retval, size);
+
+        err = bpf_prog_test_run(prog_fd, 1, &pkt_v6, sizeof(pkt_v6),
+                                buf, &size, &retval, &duration);
+        CHECK(err || errno || retval != XDP_TX || size != 114 ||
+              iph6->nexthdr != IPPROTO_IPV6, "ipv6",
+              "err %d errno %d retval %d size %d\n",
+              err, errno, retval, size);
+out:
+        bpf_object__close(obj);
+}
+
+#define MAGIC_VAL 0x1234
+#define NUM_ITER 100000
+#define VIP_NUM 5
+
+static void test_l4lb(void)
+{
+        unsigned int nr_cpus = bpf_num_possible_cpus();
+        const char *file = "./test_l4lb.o";
+        struct vip key = {.protocol = 6};
+        struct vip_meta {
+                __u32 flags;
+                __u32 vip_num;
+        } value = {.vip_num = VIP_NUM};
+        __u32 stats_key = VIP_NUM;
+        struct vip_stats {
+                __u64 bytes;
+                __u64 pkts;
+        } stats[nr_cpus];
+        struct real_definition {
+                union {
+                        __be32 dst;
+                        __be32 dstv6[4];
+                };
+                __u8 flags;
+        } real_def = {.dst = MAGIC_VAL};
+        __u32 ch_key = 11, real_num = 3;
+        __u32 duration, retval, size;
+        int err, i, prog_fd, map_fd;
+        __u64 bytes = 0, pkts = 0;
+        struct bpf_object *obj;
+        char buf[128];
+        u32 *magic = (u32 *)buf;
+
+        err = bpf_prog_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
+        if (err)
+                return;
+
+        map_fd = bpf_find_map(__func__, obj, "vip_map");
+        if (map_fd < 0)
+                goto out;
+        bpf_map_update_elem(map_fd, &key, &value, 0);
+
+        map_fd = bpf_find_map(__func__, obj, "ch_rings");
+        if (map_fd < 0)
+                goto out;
+        bpf_map_update_elem(map_fd, &ch_key, &real_num, 0);
+
+        map_fd = bpf_find_map(__func__, obj, "reals");
+        if (map_fd < 0)
+                goto out;
+        bpf_map_update_elem(map_fd, &real_num, &real_def, 0);
+
+        err = bpf_prog_test_run(prog_fd, NUM_ITER, &pkt_v4, sizeof(pkt_v4),
+                                buf, &size, &retval, &duration);
+        CHECK(err || errno || retval != 7/*TC_ACT_REDIRECT*/ || size != 54 ||
+              *magic != MAGIC_VAL, "ipv4",
+              "err %d errno %d retval %d size %d magic %x\n",
+              err, errno, retval, size, *magic);
+
+        err = bpf_prog_test_run(prog_fd, NUM_ITER, &pkt_v6, sizeof(pkt_v6),
+                                buf, &size, &retval, &duration);
+        CHECK(err || errno || retval != 7/*TC_ACT_REDIRECT*/ || size != 74 ||
+              *magic != MAGIC_VAL, "ipv6",
+              "err %d errno %d retval %d size %d magic %x\n",
+              err, errno, retval, size, *magic);
+
+        map_fd = bpf_find_map(__func__, obj, "stats");
+        if (map_fd < 0)
+                goto out;
+        bpf_map_lookup_elem(map_fd, &stats_key, stats);
+        for (i = 0; i < nr_cpus; i++) {
+                bytes += stats[i].bytes;
+                pkts += stats[i].pkts;
+        }
+        if (bytes != MAGIC_BYTES * NUM_ITER * 2 || pkts != NUM_ITER * 2) {
+                error_cnt++;
+                printf("test_l4lb:FAIL:stats %lld %lld\n", bytes, pkts);
+        }
+out:
+        bpf_object__close(obj);
+}
+
+static void test_tcp_estats(void)
+{
+        const char *file = "./test_tcp_estats.o";
+        int err, prog_fd;
+        struct bpf_object *obj;
+        __u32 duration = 0;
+
+        err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
+        CHECK(err, "", "err %d errno %d\n", err, errno);
+        if (err)
+                return;
+
+        bpf_object__close(obj);
+}
+
+int main(void)
+{
+        struct rlimit rinf = { RLIM_INFINITY, RLIM_INFINITY };
+
+        setrlimit(RLIMIT_MEMLOCK, &rinf);
+
+        test_pkt_access();
+        test_xdp();
+        test_l4lb();
+        test_tcp_estats();
+
+        printf("Summary: %d PASSED, %d FAILED\n", pass_cnt, error_cnt);
+        return 0;
+}
diff --git a/tools/testing/selftests/bpf/test_tcp_estats.c b/tools/testing/selftests/bpf/test_tcp_estats.c
new file mode 100644
index 000000000000..bee3bbecc0c4
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_tcp_estats.c
@@ -0,0 +1,258 @@
+/* Copyright (c) 2017 Facebook
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+
+/* This program shows clang/llvm is able to generate code pattern
+ * like:
+ *   _tcp_send_active_reset:
+ *      0:       bf 16 00 00 00 00 00 00         r6 = r1
+ *    ......
+ *    335:       b7 01 00 00 0f 00 00 00         r1 = 15
+ *    336:       05 00 48 00 00 00 00 00         goto 72
+ *
+ *   LBB0_3:
+ *    337:       b7 01 00 00 01 00 00 00         r1 = 1
+ *    338:       63 1a d0 ff 00 00 00 00         *(u32 *)(r10 - 48) = r1
+ *    408:       b7 01 00 00 03 00 00 00         r1 = 3
+ *
+ *   LBB0_4:
+ *    409:       71 a2 fe ff 00 00 00 00         r2 = *(u8 *)(r10 - 2)
+ *    410:       bf a7 00 00 00 00 00 00         r7 = r10
+ *    411:       07 07 00 00 b8 ff ff ff         r7 += -72
+ *    412:       bf 73 00 00 00 00 00 00         r3 = r7
+ *    413:       0f 13 00 00 00 00 00 00         r3 += r1
+ *    414:       73 23 2d 00 00 00 00 00         *(u8 *)(r3 + 45) = r2
+ *
+ * From the above code snippet, the code generated by the compiler
+ * is reasonable. The "r1" is assigned to different values in basic
+ * blocks "_tcp_send_active_reset" and "LBB0_3", and used in "LBB0_4".
+ * The verifier should be able to handle such code patterns.
+ */
+#include <string.h>
+#include <linux/bpf.h>
+#include <linux/ipv6.h>
+#include <linux/version.h>
+#include <sys/socket.h>
+#include "bpf_helpers.h"
+
+#define _(P) ({typeof(P) val = 0; bpf_probe_read(&val, sizeof(val), &P); val;})
+#define TCP_ESTATS_MAGIC 0xBAADBEEF
+
+/* This test case needs "sock" and "pt_regs" data structure.
+ * Recursively, "sock" needs "sock_common" and "inet_sock".
+ * However, this is a unit test case only for
+ * verifier purpose without bpf program execution.
+ * We can safely mock much simpler data structures, basically
+ * only taking the necessary fields from kernel headers.
+ */
+typedef __u32 __bitwise __portpair;
+typedef __u64 __bitwise __addrpair;
+
+struct sock_common {
+        unsigned short          skc_family;
+        union {
+                __addrpair      skc_addrpair;
+                struct {
+                        __be32  skc_daddr;
+                        __be32  skc_rcv_saddr;
+                };
+        };
+        union {
+                __portpair      skc_portpair;
+                struct {
+                        __be16  skc_dport;
+                        __u16   skc_num;
+                };
+        };
+        struct in6_addr         skc_v6_daddr;
+        struct in6_addr         skc_v6_rcv_saddr;
+};
+
+struct sock {
+        struct sock_common      __sk_common;
+#define sk_family               __sk_common.skc_family
+#define sk_v6_daddr             __sk_common.skc_v6_daddr
+#define sk_v6_rcv_saddr         __sk_common.skc_v6_rcv_saddr
+};
+
+struct inet_sock {
+        struct sock             sk;
+#define inet_daddr              sk.__sk_common.skc_daddr
+#define inet_dport              sk.__sk_common.skc_dport
+        __be32                  inet_saddr;
+        __be16                  inet_sport;
+};
+
+struct pt_regs {
+        long di;
+};
+
+static inline struct inet_sock *inet_sk(const struct sock *sk)
+{
+        return (struct inet_sock *)sk;
+}
+
+/* Define various data structures for state recording.
+ * Some fields are not used due to test simplification.
+ */
+enum tcp_estats_addrtype {
+        TCP_ESTATS_ADDRTYPE_IPV4 = 1,
+        TCP_ESTATS_ADDRTYPE_IPV6 = 2
+};
+
+enum tcp_estats_event_type {
+        TCP_ESTATS_ESTABLISH,
+        TCP_ESTATS_PERIODIC,
+        TCP_ESTATS_TIMEOUT,
+        TCP_ESTATS_RETRANSMIT_TIMEOUT,
+        TCP_ESTATS_RETRANSMIT_OTHER,
+        TCP_ESTATS_SYN_RETRANSMIT,
+        TCP_ESTATS_SYNACK_RETRANSMIT,
+        TCP_ESTATS_TERM,
+        TCP_ESTATS_TX_RESET,
+        TCP_ESTATS_RX_RESET,
+        TCP_ESTATS_WRITE_TIMEOUT,
+        TCP_ESTATS_CONN_TIMEOUT,
+        TCP_ESTATS_ACK_LATENCY,
+        TCP_ESTATS_NEVENTS,
+};
+
+struct tcp_estats_event {
+        int pid;
+        int cpu;
+        unsigned long ts;
+        unsigned int magic;
+        enum tcp_estats_event_type event_type;
+};
+
+/* The below data structure is packed in order for
+ * llvm compiler to generate expected code.
+ */
+struct tcp_estats_conn_id {
+        unsigned int localaddressType;
+        struct {
+                unsigned char data[16];
+        } localaddress;
+        struct {
+                unsigned char data[16];
+        } remaddress;
+        unsigned short    localport;
+        unsigned short    remport;
+} __attribute__((__packed__));
+
+struct tcp_estats_basic_event {
+        struct tcp_estats_event event;
+        struct tcp_estats_conn_id conn_id;
+};
+
+struct bpf_map_def SEC("maps") ev_record_map = {
+        .type = BPF_MAP_TYPE_HASH,
+        .key_size = sizeof(__u32),
+        .value_size = sizeof(struct tcp_estats_basic_event),
+        .max_entries = 1024,
+};
+
+struct dummy_tracepoint_args {
+        unsigned long long pad;
+        struct sock *sock;
+};
+
+static __always_inline void tcp_estats_ev_init(struct tcp_estats_event *event,
+                                               enum tcp_estats_event_type type)
+{
+        event->magic = TCP_ESTATS_MAGIC;
+        event->ts = bpf_ktime_get_ns();
+        event->event_type = type;
+}
+
+static __always_inline void unaligned_u32_set(unsigned char *to, __u8 *from)
+{
+        to[0] = _(from[0]);
+        to[1] = _(from[1]);
+        to[2] = _(from[2]);
+        to[3] = _(from[3]);
+}
+
+static __always_inline void conn_id_ipv4_init(struct tcp_estats_conn_id *conn_id,
+                                              __be32 *saddr, __be32 *daddr)
+{
+        conn_id->localaddressType = TCP_ESTATS_ADDRTYPE_IPV4;
+
+        unaligned_u32_set(conn_id->localaddress.data, (__u8 *)saddr);
+        unaligned_u32_set(conn_id->remaddress.data, (__u8 *)daddr);
+}
+
+static __always_inline void conn_id_ipv6_init(struct tcp_estats_conn_id *conn_id,
+                                              __be32 *saddr, __be32 *daddr)
+{
+        conn_id->localaddressType = TCP_ESTATS_ADDRTYPE_IPV6;
+
+        unaligned_u32_set(conn_id->localaddress.data, (__u8 *)saddr);
+        unaligned_u32_set(conn_id->localaddress.data + sizeof(__u32),
+                          (__u8 *)(saddr + 1));
+        unaligned_u32_set(conn_id->localaddress.data + sizeof(__u32) * 2,
+                          (__u8 *)(saddr + 2));
+        unaligned_u32_set(conn_id->localaddress.data + sizeof(__u32) * 3,
+                          (__u8 *)(saddr + 3));
+
+        unaligned_u32_set(conn_id->remaddress.data,
+                          (__u8 *)(daddr));
+        unaligned_u32_set(conn_id->remaddress.data + sizeof(__u32),
+                          (__u8 *)(daddr + 1));
+        unaligned_u32_set(conn_id->remaddress.data + sizeof(__u32) * 2,
+                          (__u8 *)(daddr + 2));
+        unaligned_u32_set(conn_id->remaddress.data + sizeof(__u32) * 3,
+                          (__u8 *)(daddr + 3));
+}
+
+static __always_inline void tcp_estats_conn_id_init(struct tcp_estats_conn_id *conn_id,
+                                                    struct sock *sk)
+{
+        conn_id->localport = _(inet_sk(sk)->inet_sport);
+        conn_id->remport = _(inet_sk(sk)->inet_dport);
+
+        if (_(sk->sk_family) == AF_INET6)
+                conn_id_ipv6_init(conn_id,
+                                  sk->sk_v6_rcv_saddr.s6_addr32,
+                                  sk->sk_v6_daddr.s6_addr32);
+        else
+                conn_id_ipv4_init(conn_id,
+                                  &inet_sk(sk)->inet_saddr,
+                                  &inet_sk(sk)->inet_daddr);
+}
+
+static __always_inline void tcp_estats_init(struct sock *sk,
+                                            struct tcp_estats_event *event,
+                                            struct tcp_estats_conn_id *conn_id,
+                                            enum tcp_estats_event_type type)
+{
+        tcp_estats_ev_init(event, type);
+        tcp_estats_conn_id_init(conn_id, sk);
+}
+
+static __always_inline void send_basic_event(struct sock *sk,
+                                             enum tcp_estats_event_type type)
+{
+        struct tcp_estats_basic_event ev;
+        __u32 key = bpf_get_prandom_u32();
+
+        memset(&ev, 0, sizeof(ev));
+        tcp_estats_init(sk, &ev.event, &ev.conn_id, type);
+        bpf_map_update_elem(&ev_record_map, &key, &ev, BPF_ANY);
+}
+
+SEC("dummy_tracepoint")
+int _dummy_tracepoint(struct dummy_tracepoint_args *arg)
+{
+        if (!arg->sock)
+                return 0;
+
+        send_basic_event(arg->sock, TCP_ESTATS_TX_RESET);
+        return 0;
+}
+
+char _license[] SEC("license") = "GPL";
+__u32 _version SEC("version") = 1; /* ignored by tracepoints, required by libbpf.a */
diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
index d1555e4240c0..3773562056da 100644
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@ -30,6 +30,14 @@
 
 #include <bpf/bpf.h>
 
+#ifdef HAVE_GENHDR
+# include "autoconf.h"
+#else
+# if defined(__i386) || defined(__x86_64) || defined(__s390x__) || defined(__aarch64__)
+#  define CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 1
+# endif
+#endif
+
 #include "../../../include/linux/filter.h"
 
 #ifndef ARRAY_SIZE
@@ -38,6 +46,9 @@
 
 #define MAX_INSNS       512
 #define MAX_FIXUPS      8
+#define MAX_NR_MAPS     4
+
+#define F_NEEDS_EFFICIENT_UNALIGNED_ACCESS      (1 << 0)
 
 struct bpf_test {
         const char *descr;
@@ -45,6 +56,7 @@ struct bpf_test {
         int fixup_map1[MAX_FIXUPS];
         int fixup_map2[MAX_FIXUPS];
         int fixup_prog[MAX_FIXUPS];
+        int fixup_map_in_map[MAX_FIXUPS];
         const char *errstr;
         const char *errstr_unpriv;
         enum {
@@ -53,6 +65,7 @@ struct bpf_test {
                 REJECT
         } result, result_unpriv;
         enum bpf_prog_type prog_type;
+        uint8_t flags;
 };
 
 /* Note we want this to be 64 bit aligned so that the end of our array is
@@ -178,6 +191,86 @@ static struct bpf_test tests[] = {
                 .result = REJECT,
         },
         {
+                "test6 ld_imm64",
+                .insns = {
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, 0, 0, 0),
+                        BPF_RAW_INSN(0, 0, 0, 0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+        },
+        {
+                "test7 ld_imm64",
+                .insns = {
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, 0, 0, 1),
+                        BPF_RAW_INSN(0, 0, 0, 0, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+        },
+        {
+                "test8 ld_imm64",
+                .insns = {
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, 0, 1, 1),
+                        BPF_RAW_INSN(0, 0, 0, 0, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "uses reserved fields",
+                .result = REJECT,
+        },
+        {
+                "test9 ld_imm64",
+                .insns = {
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, 0, 0, 1),
+                        BPF_RAW_INSN(0, 0, 0, 1, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "invalid bpf_ld_imm64 insn",
+                .result = REJECT,
+        },
+        {
+                "test10 ld_imm64",
+                .insns = {
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, 0, 0, 1),
+                        BPF_RAW_INSN(0, BPF_REG_1, 0, 0, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "invalid bpf_ld_imm64 insn",
+                .result = REJECT,
+        },
+        {
+                "test11 ld_imm64",
+                .insns = {
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, 0, 0, 1),
+                        BPF_RAW_INSN(0, 0, BPF_REG_1, 0, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "invalid bpf_ld_imm64 insn",
+                .result = REJECT,
+        },
+        {
+                "test12 ld_imm64",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_1, 0),
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, BPF_REG_1, 0, 1),
+                        BPF_RAW_INSN(0, 0, 0, 0, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "not pointing to valid bpf_map",
+                .result = REJECT,
+        },
+        {
+                "test13 ld_imm64",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_1, 0),
+                        BPF_RAW_INSN(BPF_LD | BPF_IMM | BPF_DW, 0, BPF_REG_1, 0, 1),
+                        BPF_RAW_INSN(0, 0, BPF_REG_1, 0, 1),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "invalid bpf_ld_imm64 insn",
+                .result = REJECT,
+        },
+        {
                 "no bpf_exit",
                 .insns = {
                         BPF_ALU64_REG(BPF_MOV, BPF_REG_0, BPF_REG_2),
@@ -318,6 +411,30 @@ static struct bpf_test tests[] = {
                 .result = REJECT,
         },
         {
+                "invalid fp arithmetic",
+                /* If this gets ever changed, make sure JITs can deal with it. */
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_SUB, BPF_REG_1, 8),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr_unpriv = "R1 pointer arithmetic",
+                .result_unpriv = REJECT,
+                .errstr = "R1 invalid mem access",
+                .result = REJECT,
+        },
+        {
+                "non-invalid fp arithmetic",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_0, -8),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+        },
+        {
                 "invalid argument register",
                 .insns = {
                         BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
@@ -759,6 +876,9 @@ static struct bpf_test tests[] = {
                         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
                                     offsetof(struct __sk_buff, vlan_tci)),
                         BPF_JMP_IMM(BPF_JGE, BPF_REG_0, 0, 0),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
+                                    offsetof(struct __sk_buff, napi_id)),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_0, 0, 0),
                         BPF_EXIT_INSN(),
                 },
                 .result = ACCEPT,
@@ -1785,6 +1905,20 @@ static struct bpf_test tests[] = {
                 .result = ACCEPT,
         },
         {
+                "unpriv: adding of fp",
+                .insns = {
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_MOV64_IMM(BPF_REG_1, 0),
+                        BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_10),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr_unpriv = "pointer arithmetic prohibited",
+                .result_unpriv = REJECT,
+                .errstr = "R1 invalid mem access",
+                .result = REJECT,
+        },
+        {
                 "unpriv: cmp of stack pointer",
                 .insns = {
                         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
@@ -1798,16 +1932,22 @@ static struct bpf_test tests[] = {
                 .result = ACCEPT,
         },
         {
-                "unpriv: obfuscate stack pointer",
+                "stack pointer arithmetic",
                 .insns = {
-                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
-                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
-                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_MOV64_IMM(BPF_REG_1, 4),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, 0),
+                        BPF_MOV64_REG(BPF_REG_7, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, -10),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_7),
+                        BPF_ALU64_REG(BPF_ADD, BPF_REG_2, BPF_REG_1),
+                        BPF_ST_MEM(0, BPF_REG_2, 4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_7),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 8),
+                        BPF_ST_MEM(0, BPF_REG_2, 4, 0),
                         BPF_MOV64_IMM(BPF_REG_0, 0),
                         BPF_EXIT_INSN(),
                 },
-                .errstr_unpriv = "R2 pointer arithmetic",
-                .result_unpriv = REJECT,
                 .result = ACCEPT,
         },
         {
@@ -2432,6 +2572,49 @@ static struct bpf_test tests[] = {
                 .prog_type = BPF_PROG_TYPE_SCHED_CLS,
         },
         {
+                "direct packet access: test15 (spill with xadd)",
+                .insns = {
+                        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data)),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data_end)),
+                        BPF_MOV64_REG(BPF_REG_0, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8),
+                        BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 8),
+                        BPF_MOV64_IMM(BPF_REG_5, 4096),
+                        BPF_MOV64_REG(BPF_REG_4, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, -8),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_4, BPF_REG_2, 0),
+                        BPF_STX_XADD(BPF_DW, BPF_REG_4, BPF_REG_5, 0),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_4, 0),
+                        BPF_STX_MEM(BPF_W, BPF_REG_2, BPF_REG_5, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "R2 invalid mem access 'inv'",
+                .result = REJECT,
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+        },
+        {
+                "direct packet access: test16 (arith on data_end)",
+                .insns = {
+                        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data)),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data_end)),
+                        BPF_MOV64_REG(BPF_REG_0, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 16),
+                        BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 1),
+                        BPF_STX_MEM(BPF_B, BPF_REG_2, BPF_REG_2, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .errstr = "invalid access to packet",
+                .result = REJECT,
+                .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+        },
+        {
                 "helper access to packet: test1, valid packet_ptr range",
                 .insns = {
                         BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
@@ -2934,6 +3117,7 @@ static struct bpf_test tests[] = {
                 .errstr_unpriv = "R0 pointer arithmetic prohibited",
                 .result_unpriv = REJECT,
                 .result = ACCEPT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "valid map access into an array with a variable",
@@ -2957,6 +3141,7 @@ static struct bpf_test tests[] = {
                 .errstr_unpriv = "R0 pointer arithmetic prohibited",
                 .result_unpriv = REJECT,
                 .result = ACCEPT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "valid map access into an array with a signed variable",
@@ -2984,6 +3169,7 @@ static struct bpf_test tests[] = {
                 .errstr_unpriv = "R0 pointer arithmetic prohibited",
                 .result_unpriv = REJECT,
                 .result = ACCEPT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "invalid map access into an array with a constant",
@@ -3025,6 +3211,7 @@ static struct bpf_test tests[] = {
                 .errstr = "R0 min value is outside of the array range",
                 .result_unpriv = REJECT,
                 .result = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "invalid map access into an array with a variable",
@@ -3048,6 +3235,7 @@ static struct bpf_test tests[] = {
                 .errstr = "R0 min value is negative, either use unsigned index or do a if (index >=0) check.",
                 .result_unpriv = REJECT,
                 .result = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "invalid map access into an array with no floor check",
@@ -3074,6 +3262,7 @@ static struct bpf_test tests[] = {
                 .errstr = "R0 min value is negative, either use unsigned index or do a if (index >=0) check.",
                 .result_unpriv = REJECT,
                 .result = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "invalid map access into an array with a invalid max check",
@@ -3100,6 +3289,7 @@ static struct bpf_test tests[] = {
                 .errstr = "invalid access to map value, value_size=48 off=44 size=8",
                 .result_unpriv = REJECT,
                 .result = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "invalid map access into an array with a invalid max check",
@@ -3129,6 +3319,7 @@ static struct bpf_test tests[] = {
                 .errstr = "R0 min value is negative, either use unsigned index or do a if (index >=0) check.",
                 .result_unpriv = REJECT,
                 .result = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "multiple registers share map_lookup_elem result",
@@ -3252,6 +3443,7 @@ static struct bpf_test tests[] = {
                 .result = REJECT,
                 .errstr_unpriv = "R0 pointer arithmetic prohibited",
                 .result_unpriv = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "constant register |= constant should keep constant type",
@@ -3418,6 +3610,26 @@ static struct bpf_test tests[] = {
                 .prog_type = BPF_PROG_TYPE_LWT_XMIT,
         },
         {
+                "overlapping checks for direct packet access",
+                .insns = {
+                        BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data)),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+                                    offsetof(struct __sk_buff, data_end)),
+                        BPF_MOV64_REG(BPF_REG_0, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 8),
+                        BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_3, 4),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
+                        BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
+                        BPF_LDX_MEM(BPF_H, BPF_REG_0, BPF_REG_2, 6),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .result = ACCEPT,
+                .prog_type = BPF_PROG_TYPE_LWT_XMIT,
+        },
+        {
                 "invalid access of tc_classid for LWT_IN",
                 .insns = {
                         BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,
@@ -3961,7 +4173,208 @@ static struct bpf_test tests[] = {
                 .result_unpriv = REJECT,
         },
         {
-                "map element value (adjusted) is preserved across register spilling",
+                "map element value or null is marked on register spilling",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -152),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_1, 0),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_3, 0, 42),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 leaks addr",
+                .result = ACCEPT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value store of cleared call register",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 1),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R1 !read_ok",
+                .errstr = "R1 !read_ok",
+                .result = REJECT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value with unaligned store",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 17),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 3),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 42),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 2, 43),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, -2, 44),
+                        BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_8, 0, 32),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_8, 2, 33),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_8, -2, 34),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_8, 5),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_8, 0, 22),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_8, 4, 23),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_8, -7, 24),
+                        BPF_MOV64_REG(BPF_REG_7, BPF_REG_8),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_7, 3),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_7, 0, 22),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_7, 4, 23),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_7, -4, 24),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 pointer arithmetic prohibited",
+                .result = ACCEPT,
+                .result_unpriv = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+        },
+        {
+                "map element value with unaligned load",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 11),
+                        BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_1, MAX_ENTRIES, 9),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 3),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 2),
+                        BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 0),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_8, 2),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 5),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 0),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_0, 4),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 pointer arithmetic prohibited",
+                .result = ACCEPT,
+                .result_unpriv = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+        },
+        {
+                "map element value illegal alu op, 1",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
+                        BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 22),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 pointer arithmetic prohibited",
+                .errstr = "invalid mem access 'inv'",
+                .result = REJECT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value illegal alu op, 2",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
+                        BPF_ALU32_IMM(BPF_ADD, BPF_REG_0, 0),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 22),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 pointer arithmetic prohibited",
+                .errstr = "invalid mem access 'inv'",
+                .result = REJECT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value illegal alu op, 3",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
+                        BPF_ALU64_IMM(BPF_DIV, BPF_REG_0, 42),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 22),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 pointer arithmetic prohibited",
+                .errstr = "invalid mem access 'inv'",
+                .result = REJECT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value illegal alu op, 4",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
+                        BPF_ENDIAN(BPF_FROM_BE, BPF_REG_0, 64),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 22),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 pointer arithmetic prohibited",
+                .errstr = "invalid mem access 'inv'",
+                .result = REJECT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value illegal alu op, 5",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 7),
+                        BPF_MOV64_IMM(BPF_REG_3, 4096),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_2, BPF_REG_0, 0),
+                        BPF_STX_XADD(BPF_DW, BPF_REG_2, BPF_REG_3, 0),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, 0),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_0, 0, 22),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map2 = { 3 },
+                .errstr_unpriv = "R0 invalid mem access 'inv'",
+                .errstr = "R0 invalid mem access 'inv'",
+                .result = REJECT,
+                .result_unpriv = REJECT,
+        },
+        {
+                "map element value is preserved across register spilling",
                 .insns = {
                         BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
                         BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
@@ -3983,6 +4396,7 @@ static struct bpf_test tests[] = {
                 .errstr_unpriv = "R0 pointer arithmetic prohibited",
                 .result = ACCEPT,
                 .result_unpriv = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "helper access to variable memory: stack, bitwise AND + JMP, correct bounds",
@@ -4421,6 +4835,7 @@ static struct bpf_test tests[] = {
                 .errstr = "R0 min value is negative, either use unsigned index or do a if (index >=0) check.",
                 .result = REJECT,
                 .result_unpriv = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
         },
         {
                 "invalid range check",
@@ -4452,6 +4867,76 @@ static struct bpf_test tests[] = {
                 .errstr = "R0 min value is negative, either use unsigned index or do a if (index >=0) check.",
                 .result = REJECT,
                 .result_unpriv = REJECT,
+                .flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
+        },
+        {
+                "map in map access",
+                .insns = {
+                        BPF_ST_MEM(0, BPF_REG_10, -4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 5),
+                        BPF_ST_MEM(0, BPF_REG_10, -4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_map_lookup_elem),
+                        BPF_MOV64_REG(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map_in_map = { 3 },
+                .result = ACCEPT,
+        },
+        {
+                "invalid inner map pointer",
+                .insns = {
+                        BPF_ST_MEM(0, BPF_REG_10, -4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 6),
+                        BPF_ST_MEM(0, BPF_REG_10, -4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_map_lookup_elem),
+                        BPF_MOV64_REG(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map_in_map = { 3 },
+                .errstr = "R1 type=inv expected=map_ptr",
+                .errstr_unpriv = "R1 pointer arithmetic prohibited",
+                .result = REJECT,
+        },
+        {
+                "forgot null checking on the inner map pointer",
+                .insns = {
+                        BPF_ST_MEM(0, BPF_REG_10, -4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_map_lookup_elem),
+                        BPF_ST_MEM(0, BPF_REG_10, -4, 0),
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4),
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+                        BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+                                     BPF_FUNC_map_lookup_elem),
+                        BPF_MOV64_REG(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map_in_map = { 3 },
+                .errstr = "R1 type=map_value_or_null expected=map_ptr",
+                .result = REJECT,
         }
 };
 
@@ -4489,55 +4974,90 @@ static int create_prog_array(void)
         return fd;
 }
 
+static int create_map_in_map(void)
+{
+        int inner_map_fd, outer_map_fd;
+
+        inner_map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(int),
+                                      sizeof(int), 1, 0);
+        if (inner_map_fd < 0) {
+                printf("Failed to create array '%s'!\n", strerror(errno));
+                return inner_map_fd;
+        }
+
+        outer_map_fd = bpf_create_map_in_map(BPF_MAP_TYPE_ARRAY_OF_MAPS,
+                                             sizeof(int), inner_map_fd, 1, 0);
+        if (outer_map_fd < 0)
+                printf("Failed to create array of maps '%s'!\n",
+                       strerror(errno));
+
+        close(inner_map_fd);
+
+        return outer_map_fd;
+}
+
 static char bpf_vlog[32768];
 
 static void do_test_fixup(struct bpf_test *test, struct bpf_insn *prog,
-                          int *fd_f1, int *fd_f2, int *fd_f3)
+                          int *map_fds)
 {
         int *fixup_map1 = test->fixup_map1;
         int *fixup_map2 = test->fixup_map2;
         int *fixup_prog = test->fixup_prog;
+        int *fixup_map_in_map = test->fixup_map_in_map;
 
         /* Allocating HTs with 1 elem is fine here, since we only test
          * for verifier and not do a runtime lookup, so the only thing
          * that really matters is value size in this case.
          */
         if (*fixup_map1) {
-                *fd_f1 = create_map(sizeof(long long), 1);
+                map_fds[0] = create_map(sizeof(long long), 1);
                 do {
-                        prog[*fixup_map1].imm = *fd_f1;
+                        prog[*fixup_map1].imm = map_fds[0];
                         fixup_map1++;
                 } while (*fixup_map1);
         }
 
         if (*fixup_map2) {
-                *fd_f2 = create_map(sizeof(struct test_val), 1);
+                map_fds[1] = create_map(sizeof(struct test_val), 1);
                 do {
-                        prog[*fixup_map2].imm = *fd_f2;
+                        prog[*fixup_map2].imm = map_fds[1];
                         fixup_map2++;
                 } while (*fixup_map2);
         }
 
         if (*fixup_prog) {
-                *fd_f3 = create_prog_array();
+                map_fds[2] = create_prog_array();
                 do {
-                        prog[*fixup_prog].imm = *fd_f3;
+                        prog[*fixup_prog].imm = map_fds[2];
                         fixup_prog++;
                 } while (*fixup_prog);
         }
+
+        if (*fixup_map_in_map) {
+                map_fds[3] = create_map_in_map();
+                do {
+                        prog[*fixup_map_in_map].imm = map_fds[3];
+                        fixup_map_in_map++;
+                } while (*fixup_map_in_map);
+        }
 }
 
 static void do_test_single(struct bpf_test *test, bool unpriv,
                            int *passes, int *errors)
 {
+        int fd_prog, expected_ret, reject_from_alignment;
         struct bpf_insn *prog = test->insns;
         int prog_len = probe_filter_length(prog);
         int prog_type = test->prog_type;
-        int fd_f1 = -1, fd_f2 = -1, fd_f3 = -1;
-        int fd_prog, expected_ret;
+        int map_fds[MAX_NR_MAPS];
         const char *expected_err;
+        int i;
+
+        for (i = 0; i < MAX_NR_MAPS; i++)
+                map_fds[i] = -1;
 
-        do_test_fixup(test, prog, &fd_f1, &fd_f2, &fd_f3);
+        do_test_fixup(test, prog, map_fds);
 
         fd_prog = bpf_load_program(prog_type ? : BPF_PROG_TYPE_SOCKET_FILTER,
                                    prog, prog_len, "GPL", 0, bpf_vlog,
@@ -4547,8 +5067,19 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                        test->result_unpriv : test->result;
         expected_err = unpriv && test->errstr_unpriv ?
                        test->errstr_unpriv : test->errstr;
+
+        reject_from_alignment = fd_prog < 0 &&
+                                (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS) &&
+                                strstr(bpf_vlog, "Unknown alignment.");
+#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+        if (reject_from_alignment) {
+                printf("FAIL\nFailed due to alignment despite having efficient unaligned access: '%s'!\n",
+                       strerror(errno));
+                goto fail_log;
+        }
+#endif
         if (expected_ret == ACCEPT) {
-                if (fd_prog < 0) {
+                if (fd_prog < 0 && !reject_from_alignment) {
                         printf("FAIL\nFailed to load prog '%s'!\n",
                                strerror(errno));
                         goto fail_log;
@@ -4558,19 +5089,19 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                         printf("FAIL\nUnexpected success to load!\n");
                         goto fail_log;
                 }
-                if (!strstr(bpf_vlog, expected_err)) {
+                if (!strstr(bpf_vlog, expected_err) && !reject_from_alignment) {
                         printf("FAIL\nUnexpected error message!\n");
                         goto fail_log;
                 }
         }
 
         (*passes)++;
-        printf("OK\n");
+        printf("OK%s\n", reject_from_alignment ?
+               " (NOTE: reject due to unknown alignment)" : "");
 close_fds:
         close(fd_prog);
-        close(fd_f1);
-        close(fd_f2);
-        close(fd_f3);
+        for (i = 0; i < MAX_NR_MAPS; i++)
+                close(map_fds[i]);
         sched_yield();
         return;
 fail_log:
diff --git a/tools/testing/selftests/bpf/test_xdp.c b/tools/testing/selftests/bpf/test_xdp.c
new file mode 100644
index 000000000000..5e7df8bb5b5d
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_xdp.c
@@ -0,0 +1,235 @@
+/* Copyright (c) 2016,2017 Facebook
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+#include <stddef.h>
+#include <string.h>
+#include <linux/bpf.h>
+#include <linux/if_ether.h>
+#include <linux/if_packet.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/in.h>
+#include <linux/udp.h>
+#include <linux/tcp.h>
+#include <linux/pkt_cls.h>
+#include <sys/socket.h>
+#include "bpf_helpers.h"
+#include "bpf_endian.h"
+#include "test_iptunnel_common.h"
+
+int _version SEC("version") = 1;
+
+struct bpf_map_def SEC("maps") rxcnt = {
+        .type = BPF_MAP_TYPE_PERCPU_ARRAY,
+        .key_size = sizeof(__u32),
+        .value_size = sizeof(__u64),
+        .max_entries = 256,
+};
+
+struct bpf_map_def SEC("maps") vip2tnl = {
+        .type = BPF_MAP_TYPE_HASH,
+        .key_size = sizeof(struct vip),
+        .value_size = sizeof(struct iptnl_info),
+        .max_entries = MAX_IPTNL_ENTRIES,
+};
+
+static __always_inline void count_tx(__u32 protocol)
+{
+        __u64 *rxcnt_count;
+
+        rxcnt_count = bpf_map_lookup_elem(&rxcnt, &protocol);
+        if (rxcnt_count)
+                *rxcnt_count += 1;
+}
+
+static __always_inline int get_dport(void *trans_data, void *data_end,
+                                     __u8 protocol)
+{
+        struct tcphdr *th;
+        struct udphdr *uh;
+
+        switch (protocol) {
+        case IPPROTO_TCP:
+                th = (struct tcphdr *)trans_data;
+                if (th + 1 > data_end)
+                        return -1;
+                return th->dest;
+        case IPPROTO_UDP:
+                uh = (struct udphdr *)trans_data;
+                if (uh + 1 > data_end)
+                        return -1;
+                return uh->dest;
+        default:
+                return 0;
+        }
+}
+
+static __always_inline void set_ethhdr(struct ethhdr *new_eth,
+                                       const struct ethhdr *old_eth,
+                                       const struct iptnl_info *tnl,
+                                       __be16 h_proto)
+{
+        memcpy(new_eth->h_source, old_eth->h_dest, sizeof(new_eth->h_source));
+        memcpy(new_eth->h_dest, tnl->dmac, sizeof(new_eth->h_dest));
+        new_eth->h_proto = h_proto;
+}
+
+static __always_inline int handle_ipv4(struct xdp_md *xdp)
+{
+        void *data_end = (void *)(long)xdp->data_end;
+        void *data = (void *)(long)xdp->data;
+        struct iptnl_info *tnl;
+        struct ethhdr *new_eth;
+        struct ethhdr *old_eth;
+        struct iphdr *iph = data + sizeof(struct ethhdr);
+        __u16 *next_iph;
+        __u16 payload_len;
+        struct vip vip = {};
+        int dport;
+        __u32 csum = 0;
+        int i;
+
+        if (iph + 1 > data_end)
+                return XDP_DROP;
+
+        dport = get_dport(iph + 1, data_end, iph->protocol);
+        if (dport == -1)
+                return XDP_DROP;
+
+        vip.protocol = iph->protocol;
+        vip.family = AF_INET;
+        vip.daddr.v4 = iph->daddr;
+        vip.dport = dport;
+        payload_len = bpf_ntohs(iph->tot_len);
+
+        tnl = bpf_map_lookup_elem(&vip2tnl, &vip);
+        /* It only does v4-in-v4 */
+        if (!tnl || tnl->family != AF_INET)
+                return XDP_PASS;
+
+        if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(struct iphdr)))
+                return XDP_DROP;
+
+        data = (void *)(long)xdp->data;
+        data_end = (void *)(long)xdp->data_end;
+
+        new_eth = data;
+        iph = data + sizeof(*new_eth);
+        old_eth = data + sizeof(*iph);
+
+        if (new_eth + 1 > data_end ||
+            old_eth + 1 > data_end ||
+            iph + 1 > data_end)
+                return XDP_DROP;
+
+        set_ethhdr(new_eth, old_eth, tnl, bpf_htons(ETH_P_IP));
+
+        iph->version = 4;
+        iph->ihl = sizeof(*iph) >> 2;
+        iph->frag_off = 0;
+        iph->protocol = IPPROTO_IPIP;
+        iph->check = 0;
+        iph->tos = 0;
+        iph->tot_len = bpf_htons(payload_len + sizeof(*iph));
+        iph->daddr = tnl->daddr.v4;
+        iph->saddr = tnl->saddr.v4;
+        iph->ttl = 8;
+
+        next_iph = (__u16 *)iph;
+#pragma clang loop unroll(full)
+        for (i = 0; i < sizeof(*iph) >> 1; i++)
+                csum += *next_iph++;
+
+        iph->check = ~((csum & 0xffff) + (csum >> 16));
+
+        count_tx(vip.protocol);
+
+        return XDP_TX;
+}
+
+static __always_inline int handle_ipv6(struct xdp_md *xdp)
+{
+        void *data_end = (void *)(long)xdp->data_end;
+        void *data = (void *)(long)xdp->data;
+        struct iptnl_info *tnl;
+        struct ethhdr *new_eth;
+        struct ethhdr *old_eth;
+        struct ipv6hdr *ip6h = data + sizeof(struct ethhdr);
+        __u16 payload_len;
+        struct vip vip = {};
+        int dport;
+
+        if (ip6h + 1 > data_end)
+                return XDP_DROP;
+
+        dport = get_dport(ip6h + 1, data_end, ip6h->nexthdr);
+        if (dport == -1)
+                return XDP_DROP;
+
+        vip.protocol = ip6h->nexthdr;
+        vip.family = AF_INET6;
+        memcpy(vip.daddr.v6, ip6h->daddr.s6_addr32, sizeof(vip.daddr));
+        vip.dport = dport;
+        payload_len = ip6h->payload_len;
+
+        tnl = bpf_map_lookup_elem(&vip2tnl, &vip);
+        /* It only does v6-in-v6 */
+        if (!tnl || tnl->family != AF_INET6)
+                return XDP_PASS;
+
+        if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(struct ipv6hdr)))
+                return XDP_DROP;
+
+        data = (void *)(long)xdp->data;
+        data_end = (void *)(long)xdp->data_end;
+
+        new_eth = data;
+        ip6h = data + sizeof(*new_eth);
+        old_eth = data + sizeof(*ip6h);
+
+        if (new_eth + 1 > data_end || old_eth + 1 > data_end ||
+            ip6h + 1 > data_end)
+                return XDP_DROP;
+
+        set_ethhdr(new_eth, old_eth, tnl, bpf_htons(ETH_P_IPV6));
+
+        ip6h->version = 6;
+        ip6h->priority = 0;
+        memset(ip6h->flow_lbl, 0, sizeof(ip6h->flow_lbl));
+        ip6h->payload_len = bpf_htons(bpf_ntohs(payload_len) + sizeof(*ip6h));
+        ip6h->nexthdr = IPPROTO_IPV6;
+        ip6h->hop_limit = 8;
+        memcpy(ip6h->saddr.s6_addr32, tnl->saddr.v6, sizeof(tnl->saddr.v6));
+        memcpy(ip6h->daddr.s6_addr32, tnl->daddr.v6, sizeof(tnl->daddr.v6));
+
+        count_tx(vip.protocol);
+
+        return XDP_TX;
+}
+
+SEC("xdp_tx_iptunnel")
+int _xdp_tx_iptunnel(struct xdp_md *xdp)
+{
+        void *data_end = (void *)(long)xdp->data_end;
+        void *data = (void *)(long)xdp->data;
+        struct ethhdr *eth = data;
+        __u16 h_proto;
+
+        if (eth + 1 > data_end)
+                return XDP_DROP;
+
+        h_proto = eth->h_proto;
+
+        if (h_proto == bpf_htons(ETH_P_IP))
+                return handle_ipv4(xdp);
+        else if (h_proto == bpf_htons(ETH_P_IPV6))
+
+                return handle_ipv6(xdp);
+        else
+                return XDP_DROP;
+}
+
+char _license[] SEC("license") = "GPL";
diff --git a/tools/testing/selftests/breakpoints/Makefile b/tools/testing/selftests/breakpoints/Makefile
index 72aa103e4141..6b214b7b10fb 100644
--- a/tools/testing/selftests/breakpoints/Makefile
+++ b/tools/testing/selftests/breakpoints/Makefile
@@ -5,7 +5,7 @@ ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/x86/ -e s/x86_64/x86/)
 ifeq ($(ARCH),x86)
 TEST_GEN_PROGS := breakpoint_test
 endif
-ifeq ($(ARCH),aarch64)
+ifneq (,$(filter $(ARCH),aarch64 arm64))
 TEST_GEN_PROGS := breakpoint_test_arm64
 endif
 
diff --git a/tools/testing/selftests/cpufreq/config b/tools/testing/selftests/cpufreq/config
new file mode 100644
index 000000000000..27ff72ebd0f5
--- /dev/null
+++ b/tools/testing/selftests/cpufreq/config
@@ -0,0 +1,15 @@
+CONFIG_CPU_FREQ=y
+CONFIG_CPU_FREQ_STAT=y
+CONFIG_CPU_FREQ_GOV_POWERSAVE=y
+CONFIG_CPU_FREQ_GOV_USERSPACE=y
+CONFIG_CPU_FREQ_GOV_ONDEMAND=y
+CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
+CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y
+CONFIG_DEBUG_RT_MUTEXES=y
+CONFIG_DEBUG_PI_LIST=y
+CONFIG_DEBUG_SPINLOCK=y
+CONFIG_DEBUG_MUTEXES=y
+CONFIG_DEBUG_LOCK_ALLOC=y
+CONFIG_PROVE_LOCKING=y
+CONFIG_LOCKDEP=y
+CONFIG_DEBUG_ATOMIC_SLEEP=y
diff --git a/tools/testing/selftests/drivers/gpu/i915.sh b/tools/testing/selftests/drivers/gpu/i915.sh
index d407f0fa1e3a..c06d6e8a8dcc 100755
--- a/tools/testing/selftests/drivers/gpu/i915.sh
+++ b/tools/testing/selftests/drivers/gpu/i915.sh
@@ -7,6 +7,7 @@ if ! /sbin/modprobe -q -r i915; then
 fi
 
 if /sbin/modprobe -q i915 mock_selftests=-1; then
+        /sbin/modprobe -q -r i915
         echo "drivers/gpu/i915: ok"
 else
         echo "drivers/gpu/i915: [FAIL]"
diff --git a/tools/testing/selftests/ftrace/config b/tools/testing/selftests/ftrace/config
index ef8214661612..8a1c9f949fe0 100644
--- a/tools/testing/selftests/ftrace/config
+++ b/tools/testing/selftests/ftrace/config
@@ -1 +1,2 @@
+CONFIG_KPROBES=y
 CONFIG_FTRACE=y
diff --git a/tools/testing/selftests/ftrace/ftracetest b/tools/testing/selftests/ftrace/ftracetest
index 52e3c4df28d6..717581145cfc 100755
--- a/tools/testing/selftests/ftrace/ftracetest
+++ b/tools/testing/selftests/ftrace/ftracetest
@@ -16,6 +16,7 @@ echo "		-k|--keep  Keep passed test logs"
 echo "          -v|--verbose Increase verbosity of test messages"
 echo "          -vv        Alias of -v -v (Show all results in stdout)"
 echo "          -d|--debug Debug mode (trace all shell commands)"
+echo "          -l|--logdir <dir> Save logs on the <dir>"
 exit $1
 }
 
@@ -57,13 +58,17 @@ parse_opts() { # opts
     ;;
     --verbose|-v|-vv)
       VERBOSE=$((VERBOSE + 1))
-      [ $1 == '-vv' ] && VERBOSE=$((VERBOSE + 1))
+      [ $1 = '-vv' ] && VERBOSE=$((VERBOSE + 1))
       shift 1
     ;;
     --debug|-d)
       DEBUG=1
       shift 1
     ;;
+    --logdir|-l)
+      LOG_DIR=$2
+      shift 2
+    ;;
     *.tc)
       if [ -f "$1" ]; then
         OPT_TEST_CASES="$OPT_TEST_CASES `abspath $1`"
@@ -145,11 +150,16 @@ XFAILED_CASES=
 UNDEFINED_CASES=
 TOTAL_RESULT=0
 
+INSTANCE=
 CASENO=0
 testcase() { # testfile
   CASENO=$((CASENO+1))
   desc=`grep "^#[ \t]*description:" $1 | cut -f2 -d:`
-  prlog -n "[$CASENO]$desc"
+  prlog -n "[$CASENO]$INSTANCE$desc"
+}
+
+test_on_instance() { # testfile
+  grep -q "^#[ \t]*flags:.*instance" $1
 }
 
 eval_result() { # sigval
@@ -266,6 +276,17 @@ for t in $TEST_CASES; do
   run_test $t
 done
 
+# Test on instance loop
+INSTANCE=" (instance) "
+for t in $TEST_CASES; do
+  test_on_instance $t || continue
+  SAVED_TRACING_DIR=$TRACING_DIR
+  export TRACING_DIR=`mktemp -d $TRACING_DIR/instances/ftracetest.XXXXXX`
+  run_test $t
+  rmdir $TRACING_DIR
+  TRACING_DIR=$SAVED_TRACING_DIR
+done
+
 prlog ""
 prlog "# of passed: " `echo $PASSED_CASES | wc -w`
 prlog "# of failed: " `echo $FAILED_CASES | wc -w`
diff --git a/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc b/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc
index bf9a7b037924..ebfce83f35b4 100644
--- a/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc
+++ b/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: Basic test for tracers
+# flags: instance
 test -f available_tracers
 for t in `cat available_tracers`; do
   echo $t > current_tracer
diff --git a/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc b/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc
index bde6625d9785..9e33f841812f 100644
--- a/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc
+++ b/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: Basic trace clock test
+# flags: instance
 test -f trace_clock
 for c in `cat trace_clock | tr  -d \[\]`; do
   echo $c > trace_clock
diff --git a/tools/testing/selftests/ftrace/test.d/event/event-enable.tc b/tools/testing/selftests/ftrace/test.d/event/event-enable.tc
index 87eb9d6dd4ca..283b45ecb199 100644
--- a/tools/testing/selftests/ftrace/test.d/event/event-enable.tc
+++ b/tools/testing/selftests/ftrace/test.d/event/event-enable.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event tracing - enable/disable with event level files
+# flags: instance
 
 do_reset() {
     echo > set_event
diff --git a/tools/testing/selftests/ftrace/test.d/event/event-pid.tc b/tools/testing/selftests/ftrace/test.d/event/event-pid.tc
index d4ab27b522f8..96c1a95be4f7 100644
--- a/tools/testing/selftests/ftrace/test.d/event/event-pid.tc
+++ b/tools/testing/selftests/ftrace/test.d/event/event-pid.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event tracing - restricts events based on pid
+# flags: instance
 
 do_reset() {
     echo > set_event
diff --git a/tools/testing/selftests/ftrace/test.d/event/subsystem-enable.tc b/tools/testing/selftests/ftrace/test.d/event/subsystem-enable.tc
index ced27ef0638f..b8fe2e5b9e67 100644
--- a/tools/testing/selftests/ftrace/test.d/event/subsystem-enable.tc
+++ b/tools/testing/selftests/ftrace/test.d/event/subsystem-enable.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event tracing - enable/disable with subsystem level files
+# flags: instance
 
 do_reset() {
     echo > set_event
diff --git a/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-pid.tc b/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-pid.tc
new file mode 100644
index 000000000000..bab5ff7c607e
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/ftrace/func-filter-pid.tc
@@ -0,0 +1,117 @@
+#!/bin/sh
+# description: ftrace - function pid filters
+
+# Make sure that function pid matching filter works.
+# Also test it on an instance directory
+
+if ! grep -q function available_tracers; then
+    echo "no function tracer configured"
+    exit_unsupported
+fi
+
+if [ ! -f set_ftrace_pid ]; then
+    echo "set_ftrace_pid not found? Is function tracer not set?"
+    exit_unsupported
+fi
+
+if [ ! -f set_ftrace_filter ]; then
+    echo "set_ftrace_filter not found? Is function tracer not set?"
+    exit_unsupported
+fi
+
+do_function_fork=1
+
+if [ ! -f options/function-fork ]; then
+    do_function_fork=0
+    echo "no option for function-fork found. Option will not be tested."
+fi
+
+read PID _ < /proc/self/stat
+
+if [ $do_function_fork -eq 1 ]; then
+    # default value of function-fork option
+    orig_value=`grep function-fork trace_options`
+fi
+
+do_reset() {
+    reset_tracer
+    clear_trace
+    enable_tracing
+    echo > set_ftrace_filter
+    echo > set_ftrace_pid
+
+    if [ $do_function_fork -eq 0 ]; then
+        return
+    fi
+
+    echo $orig_value > trace_options
+}
+
+fail() { # msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+
+yield() {
+    ping localhost -c 1 || sleep .001 || usleep 1 || sleep 1
+}
+
+do_test() {
+    disable_tracing
+
+    echo do_execve* > set_ftrace_filter
+    echo *do_fork >> set_ftrace_filter
+
+    echo $PID > set_ftrace_pid
+    echo function > current_tracer
+
+    if [ $do_function_fork -eq 1 ]; then
+        # don't allow children to be traced
+        echo nofunction-fork > trace_options
+    fi
+
+    enable_tracing
+    yield
+
+    count_pid=`cat trace | grep -v ^# | grep $PID | wc -l`
+    count_other=`cat trace | grep -v ^# | grep -v $PID | wc -l`
+
+    # count_other should be 0
+    if [ $count_pid -eq 0 -o $count_other -ne 0 ]; then
+        fail "PID filtering not working?"
+    fi
+
+    disable_tracing
+    clear_trace
+
+    if [ $do_function_fork -eq 0 ]; then
+        return
+    fi
+
+    # allow children to be traced
+    echo function-fork > trace_options
+
+    enable_tracing
+    yield
+
+    count_pid=`cat trace | grep -v ^# | grep $PID | wc -l`
+    count_other=`cat trace | grep -v ^# | grep -v $PID | wc -l`
+
+    # count_other should NOT be 0
+    if [ $count_pid -eq 0 -o $count_other -eq 0 ]; then
+        fail "PID filtering not following fork?"
+    fi
+}
+
+do_test
+
+mkdir instances/foo
+cd instances/foo
+do_test
+cd ../../
+rmdir instances/foo
+
+do_reset
+
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/ftrace/func_event_triggers.tc b/tools/testing/selftests/ftrace/test.d/ftrace/func_event_triggers.tc
new file mode 100644
index 000000000000..aa31368851c9
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/ftrace/func_event_triggers.tc
@@ -0,0 +1,114 @@
+#!/bin/sh
+# description: ftrace - test for function event triggers
+# flags: instance
+#
+# Ftrace allows to add triggers to functions, such as enabling or disabling
+# tracing, enabling or disabling trace events, or recording a stack trace
+# within the ring buffer.
+#
+# This test is designed to test event triggers
+#
+
+# The triggers are set within the set_ftrace_filter file
+if [ ! -f set_ftrace_filter ]; then
+    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
+    exit_unsupported
+fi
+
+do_reset() {
+    reset_ftrace_filter
+    reset_tracer
+    disable_events
+    clear_trace
+    enable_tracing
+}
+
+fail() { # mesg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+
+SLEEP_TIME=".1"
+
+do_reset
+
+echo "Testing function probes with events:"
+
+EVENT="sched:sched_switch"
+EVENT_ENABLE="events/sched/sched_switch/enable"
+
+cnt_trace() {
+    grep -v '^#' trace | wc -l
+}
+
+test_event_enabled() {
+    val=$1
+
+    e=`cat $EVENT_ENABLE`
+    if [ "$e" != $val ]; then
+        echo "Expected $val but found $e"
+        exit 1
+    fi
+}
+
+run_enable_disable() {
+    enable=$1                   # enable
+    Enable=$2                   # Enable
+    check_disable=$3            # 0
+    check_enable_star=$4        # 1*
+    check_disable_star=$5       # 0*
+
+    cnt=`cnt_trace`
+    if [ $cnt -ne 0 ]; then
+        fail "Found junk in trace file"
+    fi
+
+    echo "$Enable event all the time"
+
+    echo $check_disable > $EVENT_ENABLE
+    sleep $SLEEP_TIME
+
+    test_event_enabled $check_disable
+
+    echo "schedule:${enable}_event:$EVENT" > set_ftrace_filter
+
+    echo " make sure it works 5 times"
+
+    for i in `seq 5`; do
+        sleep $SLEEP_TIME
+        echo "  test $i"
+        test_event_enabled $check_enable_star
+
+        echo $check_disable > $EVENT_ENABLE
+    done
+    sleep $SLEEP_TIME
+    echo " make sure it's still works"
+    test_event_enabled $check_enable_star
+
+    reset_ftrace_filter
+
+    echo " make sure it only works 3 times"
+
+    echo $check_disable > $EVENT_ENABLE
+    sleep $SLEEP_TIME
+
+    echo "schedule:${enable}_event:$EVENT:3" > set_ftrace_filter
+
+    for i in `seq 3`; do
+        sleep $SLEEP_TIME
+        echo "  test $i"
+        test_event_enabled $check_enable_star
+
+        echo $check_disable > $EVENT_ENABLE
+    done
+
+    sleep $SLEEP_TIME
+    echo " make sure it stop working"
+    test_event_enabled $check_disable_star
+
+    do_reset
+}
+
+run_enable_disable enable Enable 0 "1*" "0*"
+run_enable_disable disable Disable 1 "0*" "1*"
diff --git a/tools/testing/selftests/ftrace/test.d/ftrace/func_set_ftrace_file.tc b/tools/testing/selftests/ftrace/test.d/ftrace/func_set_ftrace_file.tc
new file mode 100644
index 000000000000..113b4d9bc733
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/ftrace/func_set_ftrace_file.tc
@@ -0,0 +1,132 @@
+#!/bin/sh
+# description: ftrace - test reading of set_ftrace_filter
+#
+# The set_ftrace_filter file of ftrace is used to list functions as well as
+# triggers (probes) attached to functions. The code to read this file is not
+# straight forward and has had various bugs in the past. This test is designed
+# to add functions and triggers to that file in various ways and read that
+# file in various ways (cat vs dd).
+#
+
+# The triggers are set within the set_ftrace_filter file
+if [ ! -f set_ftrace_filter ]; then
+    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
+    exit_unsupported
+fi
+
+do_reset() {
+    reset_tracer
+    reset_ftrace_filter
+    disable_events
+    clear_trace
+    enable_tracing
+}
+
+fail() { # mesg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+
+do_reset
+
+FILTER=set_ftrace_filter
+FUNC1="schedule"
+FUNC2="do_IRQ"
+
+ALL_FUNCS="#### all functions enabled ####"
+
+test_func() {
+    if ! echo "$1" | grep -q "^$2\$"; then
+        return 0
+    fi
+    echo "$1" | grep -v "^$2\$"
+    return 1
+}
+
+check_set_ftrace_filter() {
+    cat=`cat $FILTER`
+    dd1=`dd if=$FILTER bs=1 | grep -v -e 'records in' -e 'records out' -e 'bytes copied'`
+    dd100=`dd if=$FILTER bs=100 | grep -v -e 'records in' -e 'records out' -e 'bytes copied'`
+
+    echo "Testing '$@'"
+
+    while [ $# -gt 0 ]; do
+        echo "test $1"
+        if cat=`test_func "$cat" "$1"`; then
+            return 0
+        fi
+        if dd1=`test_func "$dd1" "$1"`; then
+            return 0
+        fi
+        if dd100=`test_func "$dd100" "$1"`; then
+            return 0
+        fi
+        shift
+    done
+
+    if [ -n "$cat" ]; then
+        return 0
+    fi
+    if [ -n "$dd1" ]; then
+        return 0
+    fi
+    if [ -n "$dd100" ]; then
+        return 0
+    fi
+    return 1;
+}
+
+if check_set_ftrace_filter "$ALL_FUNCS"; then
+    fail "Expected only $ALL_FUNCS"
+fi
+
+echo "$FUNC1:traceoff" > set_ftrace_filter
+if check_set_ftrace_filter "$ALL_FUNCS" "$FUNC1:traceoff:unlimited"; then
+    fail "Expected $ALL_FUNCS and $FUNC1:traceoff:unlimited"
+fi
+
+echo "$FUNC1" > set_ftrace_filter
+if check_set_ftrace_filter "$FUNC1" "$FUNC1:traceoff:unlimited"; then
+    fail "Expected $FUNC1 and $FUNC1:traceoff:unlimited"
+fi
+
+echo "$FUNC2" >> set_ftrace_filter
+if check_set_ftrace_filter "$FUNC1" "$FUNC2" "$FUNC1:traceoff:unlimited"; then
+    fail "Expected $FUNC1 $FUNC2 and $FUNC1:traceoff:unlimited"
+fi
+
+echo "$FUNC2:traceoff" >> set_ftrace_filter
+if check_set_ftrace_filter "$FUNC1" "$FUNC2" "$FUNC1:traceoff:unlimited" "$FUNC2:traceoff:unlimited"; then
+    fail "Expected $FUNC1 $FUNC2 $FUNC1:traceoff:unlimited and $FUNC2:traceoff:unlimited"
+fi
+
+echo "$FUNC1" > set_ftrace_filter
+if check_set_ftrace_filter "$FUNC1" "$FUNC1:traceoff:unlimited" "$FUNC2:traceoff:unlimited"; then
+    fail "Expected $FUNC1 $FUNC1:traceoff:unlimited and $FUNC2:traceoff:unlimited"
+fi
+
+echo > set_ftrace_filter
+if check_set_ftrace_filter "$ALL_FUNCS" "$FUNC1:traceoff:unlimited" "$FUNC2:traceoff:unlimited"; then
+    fail "Expected $ALL_FUNCS $FUNC1:traceoff:unlimited and $FUNC2:traceoff:unlimited"
+fi
+
+reset_ftrace_filter
+
+if check_set_ftrace_filter "$ALL_FUNCS"; then
+    fail "Expected $ALL_FUNCS"
+fi
+
+echo "$FUNC1" > set_ftrace_filter
+if check_set_ftrace_filter "$FUNC1" ; then
+    fail "Expected $FUNC1"
+fi
+
+echo "$FUNC2" >> set_ftrace_filter
+if check_set_ftrace_filter "$FUNC1" "$FUNC2" ; then
+    fail "Expected $FUNC1 and $FUNC2"
+fi
+
+do_reset
+
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/ftrace/func_traceonoff_triggers.tc b/tools/testing/selftests/ftrace/test.d/ftrace/func_traceonoff_triggers.tc
new file mode 100644
index 000000000000..c8e02ec01eaf
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/ftrace/func_traceonoff_triggers.tc
@@ -0,0 +1,172 @@
+#!/bin/sh
+# description: ftrace - test for function traceon/off triggers
+# flags: instance
+#
+# Ftrace allows to add triggers to functions, such as enabling or disabling
+# tracing, enabling or disabling trace events, or recording a stack trace
+# within the ring buffer.
+#
+# This test is designed to test enabling and disabling tracing triggers
+#
+
+# The triggers are set within the set_ftrace_filter file
+if [ ! -f set_ftrace_filter ]; then
+    echo "set_ftrace_filter not found? Is dynamic ftrace not set?"
+    exit_unsupported
+fi
+
+do_reset() {
+    reset_ftrace_filter
+    reset_tracer
+    disable_events
+    clear_trace
+    enable_tracing
+}
+
+fail() { # mesg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+
+SLEEP_TIME=".1"
+
+do_reset
+
+echo "Testing function probes with enabling disabling tracing:"
+
+cnt_trace() {
+    grep -v '^#' trace | wc -l
+}
+
+echo '** DISABLE TRACING'
+disable_tracing
+clear_trace
+
+cnt=`cnt_trace`
+if [ $cnt -ne 0 ]; then
+    fail "Found junk in trace"
+fi
+
+
+echo '** ENABLE EVENTS'
+
+echo 1 > events/enable
+
+echo '** ENABLE TRACING'
+enable_tracing
+
+cnt=`cnt_trace`
+if [ $cnt -eq 0 ]; then
+   fail "Nothing found in trace"
+fi
+
+# powerpc uses .schedule
+func="schedule"
+x=`grep '^\.schedule$' available_filter_functions | wc -l`
+if [ "$x" -eq 1 ]; then
+   func=".schedule"
+fi
+
+echo '** SET TRACEOFF'
+
+echo "$func:traceoff" > set_ftrace_filter
+
+cnt=`grep schedule set_ftrace_filter | wc -l`
+if [ $cnt -ne 1 ]; then
+   fail "Did not find traceoff trigger"
+fi
+
+cnt=`cnt_trace`
+sleep $SLEEP_TIME
+cnt2=`cnt_trace`
+
+if [ $cnt -ne $cnt2 ]; then
+   fail "Tracing is not stopped"
+fi
+
+on=`cat tracing_on`
+if [ $on != "0" ]; then
+    fail "Tracing is not off"
+fi
+
+line1=`cat trace | tail -1`
+sleep $SLEEP_TIME
+line2=`cat trace | tail -1`
+
+if [ "$line1" != "$line2" ]; then
+    fail "Tracing file is still changing"
+fi
+
+clear_trace
+
+cnt=`cnt_trace`
+if [ $cnt -ne 0 ]; then
+    fail "Tracing is still happeing"
+fi
+
+echo "!$func:traceoff" >> set_ftrace_filter
+
+cnt=`grep schedule set_ftrace_filter | wc -l`
+if [ $cnt -ne 0 ]; then
+    fail "traceoff trigger still exists"
+fi
+
+on=`cat tracing_on`
+if [ $on != "0" ]; then
+    fail "Tracing is started again"
+fi
+
+echo "$func:traceon" > set_ftrace_filter
+
+cnt=`grep schedule set_ftrace_filter | wc -l`
+if [ $cnt -ne 1 ]; then
+    fail "traceon trigger not found"
+fi
+
+cnt=`cnt_trace`
+if [ $cnt -eq 0 ]; then
+   fail "Tracing did not start"
+fi
+
+on=`cat tracing_on`
+if [ $on != "1" ]; then
+    fail "Tracing was not enabled"
+fi
+
+
+echo "!$func:traceon" >> set_ftrace_filter
+
+cnt=`grep schedule set_ftrace_filter | wc -l`
+if [ $cnt -ne 0 ]; then
+   fail "traceon trigger still exists"
+fi
+
+check_sleep() {
+    val=$1
+    sleep $SLEEP_TIME
+    cat set_ftrace_filter
+    on=`cat tracing_on`
+    if [ $on != "$val" ]; then
+        fail "Expected tracing_on to be $val, but it was $on"
+    fi
+}
+
+
+echo "$func:traceoff:3" > set_ftrace_filter
+check_sleep "0"
+echo 1 > tracing_on
+check_sleep "0"
+echo 1 > tracing_on
+check_sleep "0"
+echo 1 > tracing_on
+check_sleep "1"
+echo "!$func:traceoff:0" > set_ftrace_filter
+
+if grep -e traceon -e traceoff set_ftrace_filter; then
+    fail "Tracing on and off triggers still exist"
+fi
+
+disable_events
+
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/functions b/tools/testing/selftests/ftrace/test.d/functions
index 91de1a8e4f19..f2019b37370d 100644
--- a/tools/testing/selftests/ftrace/test.d/functions
+++ b/tools/testing/selftests/ftrace/test.d/functions
@@ -30,6 +30,27 @@ reset_events_filter() { # reset all current setting filters
     done
 }
 
+reset_ftrace_filter() { # reset all triggers in set_ftrace_filter
+    echo > set_ftrace_filter
+    grep -v '^#' set_ftrace_filter | while read t; do
+        tr=`echo $t | cut -d: -f2`
+        if [ "$tr" = "" ]; then
+            continue
+        fi
+        if [ $tr = "enable_event" -o $tr = "disable_event" ]; then
+            tr=`echo $t | cut -d: -f1-4`
+            limit=`echo $t | cut -d: -f5`
+        else
+            tr=`echo $t | cut -d: -f1-2`
+            limit=`echo $t | cut -d: -f3`
+        fi
+        if [ "$limit" != "unlimited" ]; then
+            tr="$tr:$limit"
+        fi
+        echo "!$tr" > set_ftrace_filter
+    done
+}
+
 disable_events() {
     echo 0 > events/enable
 }
diff --git a/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc b/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc
index 4c5a061a5b4e..c73db7863adb 100644
--- a/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc
+++ b/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc
@@ -75,9 +75,13 @@ rmdir foo
 if [ -d foo ]; then
         fail "foo still exists"
 fi
-exit 0
-
 
+mkdir foo
+echo "schedule:enable_event:sched:sched_switch" > foo/set_ftrace_filter
+rmdir foo
+if [ -d foo ]; then
+        fail "foo still exists"
+fi
 
 
 instance_slam() {
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_type.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_type.tc
index 0a78705b43b2..c75faefb4fff 100644
--- a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_type.tc
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args_type.tc
@@ -26,7 +26,7 @@ check_types() {
   test $X2 = $X3
   test 0x$X3 = $3
 
-  B4=`printf "%x" $4`
+  B4=`printf "%02x" $4`
   B3=`echo -n $X3 | tail -c 3 | head -c 2`
   test $B3 = $B4
 }
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kretprobe_maxactive.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kretprobe_maxactive.tc
new file mode 100644
index 000000000000..57abdf1caabf
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/kretprobe_maxactive.tc
@@ -0,0 +1,39 @@
+#!/bin/sh
+# description: Kretprobe dynamic event with maxactive
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+echo > kprobe_events
+
+# Test if we successfully reject unknown messages
+if echo 'a:myprobeaccept inet_csk_accept' > kprobe_events; then false; else true; fi
+
+# Test if we successfully reject too big maxactive
+if echo 'r1000000:myprobeaccept inet_csk_accept' > kprobe_events; then false; else true; fi
+
+# Test if we successfully reject unparsable numbers for maxactive
+if echo 'r10fuzz:myprobeaccept inet_csk_accept' > kprobe_events; then false; else true; fi
+
+# Test for kretprobe with event name without maxactive
+echo 'r:myprobeaccept inet_csk_accept' > kprobe_events
+grep myprobeaccept kprobe_events
+test -d events/kprobes/myprobeaccept
+echo '-:myprobeaccept' >> kprobe_events
+
+# Test for kretprobe with event name with a small maxactive
+echo 'r10:myprobeaccept inet_csk_accept' > kprobe_events
+grep myprobeaccept kprobe_events
+test -d events/kprobes/myprobeaccept
+echo '-:myprobeaccept' >> kprobe_events
+
+# Test for kretprobe without event name without maxactive
+echo 'r inet_csk_accept' > kprobe_events
+grep inet_csk_accept kprobe_events
+echo > kprobe_events
+
+# Test for kretprobe without event name with a small maxactive
+echo 'r10 inet_csk_accept' > kprobe_events
+grep inet_csk_accept kprobe_events
+echo > kprobe_events
+
+clear_trace
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc
index 1a9445021bf1..c5435adfdd93 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event trigger - test event enable/disable trigger
+# flags: instance
 
 do_reset() {
     reset_trigger
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc
index 514e466e198b..48849a8d577f 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event trigger - test trigger filter
+# flags: instance
 
 do_reset() {
     reset_trigger
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
index 400e98b64948..b7f86d10b549 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event trigger - test histogram modifiers
+# flags: instance
 
 do_reset() {
     reset_trigger
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
index a00184cd9c95..fb66f7d9339d 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event trigger - test histogram trigger
+# flags: instance
 
 do_reset() {
     reset_trigger
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
index 3478b00ead57..f9153087dd7c 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
@@ -1,5 +1,6 @@
 #!/bin/sh
 # description: event trigger - test multiple histogram triggers
+# flags: instance
 
 do_reset() {
     reset_trigger
diff --git a/tools/testing/selftests/futex/Makefile b/tools/testing/selftests/futex/Makefile
index 653c5cd9e44d..e2fbb890aef9 100644
--- a/tools/testing/selftests/futex/Makefile
+++ b/tools/testing/selftests/futex/Makefile
@@ -8,7 +8,7 @@ include ../lib.mk
 
 all:
         for DIR in $(SUBDIRS); do               \
-                BUILD_TARGET=$$OUTPUT/$$DIR;    \
+                BUILD_TARGET=$(OUTPUT)/$$DIR;   \
                 mkdir $$BUILD_TARGET  -p;       \
                 make OUTPUT=$$BUILD_TARGET -C $$DIR $@;\
         done
@@ -22,7 +22,7 @@ override define INSTALL_RULE
         install -t $(INSTALL_PATH) $(TEST_PROGS) $(TEST_PROGS_EXTENDED) $(TEST_FILES)
 
         @for SUBDIR in $(SUBDIRS); do \
-                BUILD_TARGET=$$OUTPUT/$$SUBDIR; \
+                BUILD_TARGET=$(OUTPUT)/$$SUBDIR;        \
                 mkdir $$BUILD_TARGET  -p;       \
                 $(MAKE) OUTPUT=$$BUILD_TARGET -C $$SUBDIR INSTALL_PATH=$(INSTALL_PATH)/$$SUBDIR install; \
         done;
@@ -32,9 +32,10 @@ override define EMIT_TESTS
         echo "./run.sh"
 endef
 
-clean:
+override define CLEAN
         for DIR in $(SUBDIRS); do               \
-                BUILD_TARGET=$$OUTPUT/$$DIR;    \
+                BUILD_TARGET=$(OUTPUT)/$$DIR;   \
                 mkdir $$BUILD_TARGET  -p;       \
                 make OUTPUT=$$BUILD_TARGET -C $$DIR $@;\
         done
+endef
diff --git a/tools/testing/selftests/gpio/Makefile b/tools/testing/selftests/gpio/Makefile
index 205e4d10e085..298929df97e6 100644
--- a/tools/testing/selftests/gpio/Makefile
+++ b/tools/testing/selftests/gpio/Makefile
@@ -2,13 +2,20 @@
 TEST_PROGS := gpio-mockup.sh
 TEST_FILES := gpio-mockup-sysfs.sh $(BINARIES)
 BINARIES := gpio-mockup-chardev
+EXTRA_PROGS := ../gpiogpio-event-mon ../gpiogpio-hammer ../gpiolsgpio
+EXTRA_DIRS := ../gpioinclude/
+EXTRA_OBJS := ../gpiogpio-event-mon-in.o ../gpiogpio-event-mon.o
+EXTRA_OBJS += ../gpiogpio-hammer-in.o ../gpiogpio-utils.o ../gpiolsgpio-in.o
+EXTRA_OBJS += ../gpiolsgpio.o
 
 include ../lib.mk
 
 all: $(BINARIES)
 
-clean:
-        $(RM) $(BINARIES)
+override define CLEAN
+        $(RM) $(BINARIES) $(EXTRA_PROGS) $(EXTRA_OBJS)
+        $(RM) -r $(EXTRA_DIRS)
+endef
 
 CFLAGS += -O2 -g -std=gnu99 -Wall -I../../../../usr/include/
 LDLIBS += -lmount -I/usr/include/libmount
diff --git a/tools/testing/selftests/gpio/config b/tools/testing/selftests/gpio/config
new file mode 100644
index 000000000000..abaa6902b7b6
--- /dev/null
+++ b/tools/testing/selftests/gpio/config
@@ -0,0 +1,2 @@
+CONFIG_GPIOLIB=y
+CONFIG_GPIO_MOCKUP=m
diff --git a/tools/testing/selftests/lib.mk b/tools/testing/selftests/lib.mk
index 775c589ac3c0..959273c3a52e 100644
--- a/tools/testing/selftests/lib.mk
+++ b/tools/testing/selftests/lib.mk
@@ -51,8 +51,12 @@ endef
 emit_tests:
         $(EMIT_TESTS)
 
-clean:
+define CLEAN
         $(RM) -r $(TEST_GEN_PROGS) $(TEST_GEN_PROGS_EXTENDED) $(TEST_GEN_FILES) $(EXTRA_CLEAN)
+endef
+
+clean:
+        $(CLEAN)
 
 $(OUTPUT)/%:%.c
         $(LINK.c) $^ $(LDLIBS) -o $@
diff --git a/tools/testing/selftests/lib/config b/tools/testing/selftests/lib/config
new file mode 100644
index 000000000000..126933bcc950
--- /dev/null
+++ b/tools/testing/selftests/lib/config
@@ -0,0 +1,3 @@
+CONFIG_TEST_PRINTF=m
+CONFIG_TEST_BITMAP=m
+CONFIG_PRIME_NUMBERS=m
diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile
index fbfe5d0d5c2e..35cbb4cba410 100644
--- a/tools/testing/selftests/net/Makefile
+++ b/tools/testing/selftests/net/Makefile
@@ -5,7 +5,7 @@ CFLAGS += -I../../../../usr/include/
 
 reuseport_bpf_numa: LDFLAGS += -lnuma
 
-TEST_PROGS := run_netsocktests run_afpackettests test_bpf.sh
+TEST_PROGS := run_netsocktests run_afpackettests test_bpf.sh netdevice.sh
 TEST_GEN_FILES =  socket
 TEST_GEN_FILES += psock_fanout psock_tpacket
 TEST_GEN_FILES += reuseport_bpf reuseport_bpf_cpu reuseport_bpf_numa
diff --git a/tools/testing/selftests/net/netdevice.sh b/tools/testing/selftests/net/netdevice.sh
new file mode 100755
index 000000000000..4e00568d70c2
--- /dev/null
+++ b/tools/testing/selftests/net/netdevice.sh
@@ -0,0 +1,200 @@
+#!/bin/sh
+#
+# This test is for checking network interface
+# For the moment it tests only ethernet interface (but wifi could be easily added)
+#
+# We assume that all network driver are loaded
+# if not they probably have failed earlier in the boot process and their logged error will be catched by another test
+#
+
+# this function will try to up the interface
+# if already up, nothing done
+# arg1: network interface name
+kci_net_start()
+{
+        netdev=$1
+
+        ip link show "$netdev" |grep -q UP
+        if [ $? -eq 0 ];then
+                echo "SKIP: $netdev: interface already up"
+                return 0
+        fi
+
+        ip link set "$netdev" up
+        if [ $? -ne 0 ];then
+                echo "FAIL: $netdev: Fail to up interface"
+                return 1
+        else
+                echo "PASS: $netdev: set interface up"
+                NETDEV_STARTED=1
+        fi
+        return 0
+}
+
+# this function will try to setup an IP and MAC address on a network interface
+# Doing nothing if the interface was already up
+# arg1: network interface name
+kci_net_setup()
+{
+        netdev=$1
+
+        # do nothing if the interface was already up
+        if [ $NETDEV_STARTED -eq 0 ];then
+                return 0
+        fi
+
+        MACADDR='02:03:04:05:06:07'
+        ip link set dev $netdev address "$MACADDR"
+        if [ $? -ne 0 ];then
+                echo "FAIL: $netdev: Cannot set MAC address"
+        else
+                ip link show $netdev |grep -q "$MACADDR"
+                if [ $? -eq 0 ];then
+                        echo "PASS: $netdev: set MAC address"
+                else
+                        echo "FAIL: $netdev: Cannot set MAC address"
+                fi
+        fi
+
+        #check that the interface did not already have an IP
+        ip address show "$netdev" |grep '^[[:space:]]*inet'
+        if [ $? -eq 0 ];then
+                echo "SKIP: $netdev: already have an IP"
+                return 0
+        fi
+
+        # TODO what ipaddr to set ? DHCP ?
+        echo "SKIP: $netdev: set IP address"
+        return 0
+}
+
+# test an ethtool command
+# arg1: return code for not supported (see ethtool code source)
+# arg2: summary of the command
+# arg3: command to execute
+kci_netdev_ethtool_test()
+{
+        if [ $# -le 2 ];then
+                echo "SKIP: $netdev: ethtool: invalid number of arguments"
+                return 1
+        fi
+        $3 >/dev/null
+        ret=$?
+        if [ $ret -ne 0 ];then
+                if [ $ret -eq "$1" ];then
+                        echo "SKIP: $netdev: ethtool $2 not supported"
+                else
+                        echo "FAIL: $netdev: ethtool $2"
+                        return 1
+                fi
+        else
+                echo "PASS: $netdev: ethtool $2"
+        fi
+        return 0
+}
+
+# test ethtool commands
+# arg1: network interface name
+kci_netdev_ethtool()
+{
+        netdev=$1
+
+        #check presence of ethtool
+        ethtool --version 2>/dev/null >/dev/null
+        if [ $? -ne 0 ];then
+                echo "SKIP: ethtool not present"
+                return 1
+        fi
+
+        TMP_ETHTOOL_FEATURES="$(mktemp)"
+        if [ ! -e "$TMP_ETHTOOL_FEATURES" ];then
+                echo "SKIP: Cannot create a tmp file"
+                return 1
+        fi
+
+        ethtool -k "$netdev" > "$TMP_ETHTOOL_FEATURES"
+        if [ $? -ne 0 ];then
+                echo "FAIL: $netdev: ethtool list features"
+                rm "$TMP_ETHTOOL_FEATURES"
+                return 1
+        fi
+        echo "PASS: $netdev: ethtool list features"
+        #TODO for each non fixed features, try to turn them on/off
+        rm "$TMP_ETHTOOL_FEATURES"
+
+        kci_netdev_ethtool_test 74 'dump' "ethtool -d $netdev"
+        kci_netdev_ethtool_test 94 'stats' "ethtool -S $netdev"
+        return 0
+}
+
+# stop a netdev
+# arg1: network interface name
+kci_netdev_stop()
+{
+        netdev=$1
+
+        if [ $NETDEV_STARTED -eq 0 ];then
+                echo "SKIP: $netdev: interface kept up"
+                return 0
+        fi
+
+        ip link set "$netdev" down
+        if [ $? -ne 0 ];then
+                echo "FAIL: $netdev: stop interface"
+                return 1
+        fi
+        echo "PASS: $netdev: stop interface"
+        return 0
+}
+
+# run all test on a netdev
+# arg1: network interface name
+kci_test_netdev()
+{
+        NETDEV_STARTED=0
+        IFACE_TO_UPDOWN="$1"
+        IFACE_TO_TEST="$1"
+        #check for VLAN interface
+        MASTER_IFACE="$(echo $1 | cut -d@ -f2)"
+        if [ ! -z "$MASTER_IFACE" ];then
+                IFACE_TO_UPDOWN="$MASTER_IFACE"
+                IFACE_TO_TEST="$(echo $1 | cut -d@ -f1)"
+        fi
+
+        NETDEV_STARTED=0
+        kci_net_start "$IFACE_TO_UPDOWN"
+
+        kci_net_setup "$IFACE_TO_TEST"
+
+        kci_netdev_ethtool "$IFACE_TO_TEST"
+
+        kci_netdev_stop "$IFACE_TO_UPDOWN"
+        return 0
+}
+
+#check for needed privileges
+if [ "$(id -u)" -ne 0 ];then
+        echo "SKIP: Need root privileges"
+        exit 0
+fi
+
+ip -Version 2>/dev/null >/dev/null
+if [ $? -ne 0 ];then
+        echo "SKIP: Could not run test without the ip tool"
+        exit 0
+fi
+
+TMP_LIST_NETDEV="$(mktemp)"
+if [ ! -e "$TMP_LIST_NETDEV" ];then
+        echo "FAIL: Cannot create a tmp file"
+        exit 1
+fi
+
+ip link show |grep '^[0-9]' | grep -oE '[[:space:]].*eth[0-9]*:|[[:space:]].*enp[0-9]s[0-9]:' | cut -d\  -f2 | cut -d: -f1> "$TMP_LIST_NETDEV"
+while read netdev
+do
+        kci_test_netdev "$netdev"
+done < "$TMP_LIST_NETDEV"
+
+rm "$TMP_LIST_NETDEV"
+exit 0
diff --git a/tools/testing/selftests/net/psock_fanout.c b/tools/testing/selftests/net/psock_fanout.c
index 412459369686..989f917068d1 100644
--- a/tools/testing/selftests/net/psock_fanout.c
+++ b/tools/testing/selftests/net/psock_fanout.c
@@ -71,18 +71,17 @@
 
 /* Open a socket in a given fanout mode.
  * @return -1 if mode is bad, a valid socket otherwise */
-static int sock_fanout_open(uint16_t typeflags, int num_packets)
+static int sock_fanout_open(uint16_t typeflags, uint16_t group_id)
 {
         int fd, val;
 
-        fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
+        fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP));
         if (fd < 0) {
                 perror("socket packet");
                 exit(1);
         }
 
-        /* fanout group ID is always 0: tests whether old groups are deleted */
-        val = ((int) typeflags) << 16;
+        val = (((int) typeflags) << 16) | group_id;
         if (setsockopt(fd, SOL_PACKET, PACKET_FANOUT, &val, sizeof(val))) {
                 if (close(fd)) {
                         perror("close packet");
@@ -95,6 +94,38 @@ static int sock_fanout_open(uint16_t typeflags, int num_packets)
         return fd;
 }
 
+static void sock_fanout_set_cbpf(int fd)
+{
+        struct sock_filter bpf_filter[] = {
+                BPF_STMT(BPF_LD+BPF_B+BPF_ABS, 80),           /* ldb [80] */
+                BPF_STMT(BPF_RET+BPF_A, 0),                   /* ret A */
+        };
+        struct sock_fprog bpf_prog;
+
+        bpf_prog.filter = bpf_filter;
+        bpf_prog.len = sizeof(bpf_filter) / sizeof(struct sock_filter);
+
+        if (setsockopt(fd, SOL_PACKET, PACKET_FANOUT_DATA, &bpf_prog,
+                       sizeof(bpf_prog))) {
+                perror("fanout data cbpf");
+                exit(1);
+        }
+}
+
+static void sock_fanout_getopts(int fd, uint16_t *typeflags, uint16_t *group_id)
+{
+        int sockopt;
+        socklen_t sockopt_len = sizeof(sockopt);
+
+        if (getsockopt(fd, SOL_PACKET, PACKET_FANOUT,
+                       &sockopt, &sockopt_len)) {
+                perror("failed to getsockopt");
+                exit(1);
+        }
+        *typeflags = sockopt >> 16;
+        *group_id = sockopt & 0xfffff;
+}
+
 static void sock_fanout_set_ebpf(int fd)
 {
         const int len_off = __builtin_offsetof(struct __sk_buff, len);
@@ -223,26 +254,26 @@ static void test_control_group(void)
 
         fprintf(stderr, "test: control multiple sockets\n");
 
-        fds[0] = sock_fanout_open(PACKET_FANOUT_HASH, 20);
+        fds[0] = sock_fanout_open(PACKET_FANOUT_HASH, 0);
         if (fds[0] == -1) {
                 fprintf(stderr, "ERROR: failed to open HASH socket\n");
                 exit(1);
         }
         if (sock_fanout_open(PACKET_FANOUT_HASH |
-                               PACKET_FANOUT_FLAG_DEFRAG, 10) != -1) {
+                               PACKET_FANOUT_FLAG_DEFRAG, 0) != -1) {
                 fprintf(stderr, "ERROR: joined group with wrong flag defrag\n");
                 exit(1);
         }
         if (sock_fanout_open(PACKET_FANOUT_HASH |
-                               PACKET_FANOUT_FLAG_ROLLOVER, 10) != -1) {
+                               PACKET_FANOUT_FLAG_ROLLOVER, 0) != -1) {
                 fprintf(stderr, "ERROR: joined group with wrong flag ro\n");
                 exit(1);
         }
-        if (sock_fanout_open(PACKET_FANOUT_CPU, 10) != -1) {
+        if (sock_fanout_open(PACKET_FANOUT_CPU, 0) != -1) {
                 fprintf(stderr, "ERROR: joined group with wrong mode\n");
                 exit(1);
         }
-        fds[1] = sock_fanout_open(PACKET_FANOUT_HASH, 20);
+        fds[1] = sock_fanout_open(PACKET_FANOUT_HASH, 0);
         if (fds[1] == -1) {
                 fprintf(stderr, "ERROR: failed to join group\n");
                 exit(1);
@@ -253,6 +284,61 @@ static void test_control_group(void)
         }
 }
 
+/* Test creating a unique fanout group ids */
+static void test_unique_fanout_group_ids(void)
+{
+        int fds[3];
+        uint16_t typeflags, first_group_id, second_group_id;
+
+        fprintf(stderr, "test: unique ids\n");
+
+        fds[0] = sock_fanout_open(PACKET_FANOUT_HASH |
+                                  PACKET_FANOUT_FLAG_UNIQUEID, 0);
+        if (fds[0] == -1) {
+                fprintf(stderr, "ERROR: failed to create a unique id group.\n");
+                exit(1);
+        }
+
+        sock_fanout_getopts(fds[0], &typeflags, &first_group_id);
+        if (typeflags != PACKET_FANOUT_HASH) {
+                fprintf(stderr, "ERROR: unexpected typeflags %x\n", typeflags);
+                exit(1);
+        }
+
+        if (sock_fanout_open(PACKET_FANOUT_CPU, first_group_id) != -1) {
+                fprintf(stderr, "ERROR: joined group with wrong type.\n");
+                exit(1);
+        }
+
+        fds[1] = sock_fanout_open(PACKET_FANOUT_HASH, first_group_id);
+        if (fds[1] == -1) {
+                fprintf(stderr,
+                        "ERROR: failed to join previously created group.\n");
+                exit(1);
+        }
+
+        fds[2] = sock_fanout_open(PACKET_FANOUT_HASH |
+                                  PACKET_FANOUT_FLAG_UNIQUEID, 0);
+        if (fds[2] == -1) {
+                fprintf(stderr,
+                        "ERROR: failed to create a second unique id group.\n");
+                exit(1);
+        }
+
+        sock_fanout_getopts(fds[2], &typeflags, &second_group_id);
+        if (sock_fanout_open(PACKET_FANOUT_HASH | PACKET_FANOUT_FLAG_UNIQUEID,
+                             second_group_id) != -1) {
+                fprintf(stderr,
+                        "ERROR: specified a group id when requesting unique id\n");
+                exit(1);
+        }
+
+        if (close(fds[0]) || close(fds[1]) || close(fds[2])) {
+                fprintf(stderr, "ERROR: closing sockets\n");
+                exit(1);
+        }
+}
+
 static int test_datapath(uint16_t typeflags, int port_off,
                          const int expect1[], const int expect2[])
 {
@@ -263,14 +349,14 @@ static int test_datapath(uint16_t typeflags, int port_off,
 
         fprintf(stderr, "test: datapath 0x%hx\n", typeflags);
 
-        fds[0] = sock_fanout_open(typeflags, 20);
-        fds[1] = sock_fanout_open(typeflags, 20);
+        fds[0] = sock_fanout_open(typeflags, 0);
+        fds[1] = sock_fanout_open(typeflags, 0);
         if (fds[0] == -1 || fds[1] == -1) {
                 fprintf(stderr, "ERROR: failed open\n");
                 exit(1);
         }
         if (type == PACKET_FANOUT_CBPF)
-                sock_setfilter(fds[0], SOL_PACKET, PACKET_FANOUT_DATA);
+                sock_fanout_set_cbpf(fds[0]);
         else if (type == PACKET_FANOUT_EBPF)
                 sock_fanout_set_ebpf(fds[0]);
 
@@ -331,10 +417,12 @@ int main(int argc, char **argv)
         const int expect_cpu0[2][2]     = { { 20, 0 },  { 20, 0 } };
         const int expect_cpu1[2][2]     = { { 0, 20 },  { 0, 20 } };
         const int expect_bpf[2][2]      = { { 15, 5 },  { 15, 20 } };
+        const int expect_uniqueid[2][2] = { { 20, 20},  { 20, 20 } };
         int port_off = 2, tries = 5, ret;
 
         test_control_single();
         test_control_group();
+        test_unique_fanout_group_ids();
 
         /* find a set of ports that do not collide onto the same socket */
         ret = test_datapath(PACKET_FANOUT_HASH, port_off,
@@ -365,6 +453,9 @@ int main(int argc, char **argv)
                 ret |= test_datapath(PACKET_FANOUT_CPU, port_off,
                                      expect_cpu1[0], expect_cpu1[1]);
 
+        ret |= test_datapath(PACKET_FANOUT_FLAG_UNIQUEID, port_off,
+                             expect_uniqueid[0], expect_uniqueid[1]);
+
         if (ret)
                 return 1;
 
diff --git a/tools/testing/selftests/net/psock_lib.h b/tools/testing/selftests/net/psock_lib.h
index a77da88bf946..7d990d6c861b 100644
--- a/tools/testing/selftests/net/psock_lib.h
+++ b/tools/testing/selftests/net/psock_lib.h
@@ -38,7 +38,7 @@
 # define __maybe_unused         __attribute__ ((__unused__))
 #endif
 
-static __maybe_unused void sock_setfilter(int fd, int lvl, int optnum)
+static __maybe_unused void pair_udp_setfilter(int fd)
 {
         /* the filter below checks for all of the following conditions that
          * are based on the contents of create_payload()
@@ -76,23 +76,16 @@ static __maybe_unused void sock_setfilter(int fd, int lvl, int optnum)
         };
         struct sock_fprog bpf_prog;
 
-        if (lvl == SOL_PACKET && optnum == PACKET_FANOUT_DATA)
-                bpf_filter[5].code = 0x16;   /* RET A                         */
-
         bpf_prog.filter = bpf_filter;
         bpf_prog.len = sizeof(bpf_filter) / sizeof(struct sock_filter);
-        if (setsockopt(fd, lvl, optnum, &bpf_prog,
+
+        if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &bpf_prog,
                        sizeof(bpf_prog))) {
                 perror("setsockopt SO_ATTACH_FILTER");
                 exit(1);
         }
 }
 
-static __maybe_unused void pair_udp_setfilter(int fd)
-{
-        sock_setfilter(fd, SOL_SOCKET, SO_ATTACH_FILTER);
-}
-
 static __maybe_unused void pair_udp_open(int fds[], uint16_t port)
 {
         struct sockaddr_in saddr, daddr;
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index 1c5d0575802e..72c3ac2323e1 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -8,12 +8,13 @@ ifeq ($(ARCH),powerpc)
 
 GIT_VERSION = $(shell git describe --always --long --dirty || echo "unknown")
 
-CFLAGS := -std=gnu99 -Wall -O2 -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CURDIR)/include $(CFLAGS)
+CFLAGS := -std=gnu99 -O2 -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CURDIR)/include $(CFLAGS)
 
 export CFLAGS
 
 SUB_DIRS = alignment            \
            benchmarks           \
+           cache_shape          \
            copyloops            \
            context_switch       \
            dscr                 \
@@ -34,37 +35,38 @@ endif
 all: $(SUB_DIRS)
 
 $(SUB_DIRS):
-        BUILD_TARGET=$$OUTPUT/$@; mkdir -p $$BUILD_TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -k -C $@ all
+        BUILD_TARGET=$(OUTPUT)/$@; mkdir -p $$BUILD_TARGET; $(MAKE) OUTPUT=$$BUILD_TARGET -k -C $@ all
 
 include ../lib.mk
 
 override define RUN_TESTS
         @for TARGET in $(SUB_DIRS); do \
-                BUILD_TARGET=$$OUTPUT/$$TARGET; \
+                BUILD_TARGET=$(OUTPUT)/$$TARGET;        \
                 $(MAKE) OUTPUT=$$BUILD_TARGET -C $$TARGET run_tests;\
         done;
 endef
 
 override define INSTALL_RULE
         @for TARGET in $(SUB_DIRS); do \
-                BUILD_TARGET=$$OUTPUT/$$TARGET; \
+                BUILD_TARGET=$(OUTPUT)/$$TARGET;        \
                 $(MAKE) OUTPUT=$$BUILD_TARGET -C $$TARGET install;\
         done;
 endef
 
 override define EMIT_TESTS
         @for TARGET in $(SUB_DIRS); do \
-                BUILD_TARGET=$$OUTPUT/$$TARGET; \
+                BUILD_TARGET=$(OUTPUT)/$$TARGET;        \
                 $(MAKE) OUTPUT=$$BUILD_TARGET -s -C $$TARGET emit_tests;\
         done;
 endef
 
-clean:
+override define CLEAN
         @for TARGET in $(SUB_DIRS); do \
-                BUILD_TARGET=$$OUTPUT/$$TARGET; \
+                BUILD_TARGET=$(OUTPUT)/$$TARGET;        \
                 $(MAKE) OUTPUT=$$BUILD_TARGET -C $$TARGET clean; \
         done;
         rm -f tags
+endef
 
 tags:
         find . -name '*.c' -o -name '*.h' | xargs ctags
diff --git a/tools/testing/selftests/powerpc/cache_shape/.gitignore b/tools/testing/selftests/powerpc/cache_shape/.gitignore
new file mode 100644
index 000000000000..ec1848434be5
--- /dev/null
+++ b/tools/testing/selftests/powerpc/cache_shape/.gitignore
@@ -0,0 +1 @@
+cache_shape
diff --git a/tools/testing/selftests/powerpc/cache_shape/Makefile b/tools/testing/selftests/powerpc/cache_shape/Makefile
new file mode 100644
index 000000000000..b24485ab30e2
--- /dev/null
+++ b/tools/testing/selftests/powerpc/cache_shape/Makefile
@@ -0,0 +1,10 @@
+TEST_PROGS := cache_shape
+
+all: $(TEST_PROGS)
+
+$(TEST_PROGS): ../harness.c ../utils.c
+
+include ../../lib.mk
+
+clean:
+        rm -f $(TEST_PROGS) *.o
diff --git a/tools/testing/selftests/powerpc/cache_shape/cache_shape.c b/tools/testing/selftests/powerpc/cache_shape/cache_shape.c
new file mode 100644
index 000000000000..29ec07eba7f9
--- /dev/null
+++ b/tools/testing/selftests/powerpc/cache_shape/cache_shape.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2017, Michael Ellerman, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <elf.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <link.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "utils.h"
+
+#ifndef AT_L1I_CACHESIZE
+#define AT_L1I_CACHESIZE        40
+#define AT_L1I_CACHEGEOMETRY    41
+#define AT_L1D_CACHESIZE        42
+#define AT_L1D_CACHEGEOMETRY    43
+#define AT_L2_CACHESIZE         44
+#define AT_L2_CACHEGEOMETRY     45
+#define AT_L3_CACHESIZE         46
+#define AT_L3_CACHEGEOMETRY     47
+#endif
+
+static void print_size(const char *label, uint32_t val)
+{
+        printf("%s cache size: %#10x %10dB %10dK\n", label, val, val, val / 1024);
+}
+
+static void print_geo(const char *label, uint32_t val)
+{
+        uint16_t assoc;
+
+        printf("%s line size:  %#10x       ", label, val & 0xFFFF);
+
+        assoc = val >> 16;
+        if (assoc)
+                printf("%u-way", assoc);
+        else
+                printf("fully");
+
+        printf(" associative\n");
+}
+
+static int test_cache_shape()
+{
+        static char buffer[4096];
+        ElfW(auxv_t) *p;
+        int found;
+
+        FAIL_IF(read_auxv(buffer, sizeof(buffer)));
+
+        found = 0;
+
+        p = find_auxv_entry(AT_L1I_CACHESIZE, buffer);
+        if (p) {
+                found++;
+                print_size("L1I ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L1I_CACHEGEOMETRY, buffer);
+        if (p) {
+                found++;
+                print_geo("L1I ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L1D_CACHESIZE, buffer);
+        if (p) {
+                found++;
+                print_size("L1D ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L1D_CACHEGEOMETRY, buffer);
+        if (p) {
+                found++;
+                print_geo("L1D ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L2_CACHESIZE, buffer);
+        if (p) {
+                found++;
+                print_size("L2  ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L2_CACHEGEOMETRY, buffer);
+        if (p) {
+                found++;
+                print_geo("L2  ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L3_CACHESIZE, buffer);
+        if (p) {
+                found++;
+                print_size("L3  ", (uint32_t)p->a_un.a_val);
+        }
+
+        p = find_auxv_entry(AT_L3_CACHEGEOMETRY, buffer);
+        if (p) {
+                found++;
+                print_geo("L3  ", (uint32_t)p->a_un.a_val);
+        }
+
+        /* If we found none we're probably on a system where they don't exist */
+        SKIP_IF(found == 0);
+
+        /* But if we found any, we expect to find them all */
+        FAIL_IF(found != 8);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_cache_shape, "cache_shape");
+}
diff --git a/tools/testing/selftests/powerpc/include/utils.h b/tools/testing/selftests/powerpc/include/utils.h
index 53405e8a52ab..735815b3ad7f 100644
--- a/tools/testing/selftests/powerpc/include/utils.h
+++ b/tools/testing/selftests/powerpc/include/utils.h
@@ -24,7 +24,11 @@ typedef uint8_t u8;
 
 void test_harness_set_timeout(uint64_t time);
 int test_harness(int (test_function)(void), char *name);
-extern void *get_auxv_entry(int type);
+
+int read_auxv(char *buf, ssize_t buf_size);
+void *find_auxv_entry(int type, char *auxv);
+void *get_auxv_entry(int type);
+
 int pick_online_cpu(void);
 
 static inline bool have_hwcap(unsigned long ftr)
diff --git a/tools/testing/selftests/powerpc/tm/.gitignore b/tools/testing/selftests/powerpc/tm/.gitignore
index 427621792229..2f1f7b013293 100644
--- a/tools/testing/selftests/powerpc/tm/.gitignore
+++ b/tools/testing/selftests/powerpc/tm/.gitignore
@@ -11,3 +11,4 @@ tm-signal-context-chk-fpu
 tm-signal-context-chk-gpr
 tm-signal-context-chk-vmx
 tm-signal-context-chk-vsx
+tm-vmx-unavail
diff --git a/tools/testing/selftests/powerpc/tm/Makefile b/tools/testing/selftests/powerpc/tm/Makefile
index 5576ee6a51f2..958c11c14acd 100644
--- a/tools/testing/selftests/powerpc/tm/Makefile
+++ b/tools/testing/selftests/powerpc/tm/Makefile
@@ -2,7 +2,8 @@ SIGNAL_CONTEXT_CHK_TESTS := tm-signal-context-chk-gpr tm-signal-context-chk-fpu
         tm-signal-context-chk-vmx tm-signal-context-chk-vsx
 
 TEST_GEN_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack \
-        tm-vmxcopy tm-fork tm-tar tm-tmspr $(SIGNAL_CONTEXT_CHK_TESTS)
+        tm-vmxcopy tm-fork tm-tar tm-tmspr tm-vmx-unavail \
+        $(SIGNAL_CONTEXT_CHK_TESTS)
 
 include ../../lib.mk
 
@@ -13,6 +14,7 @@ CFLAGS += -mhtm
 $(OUTPUT)/tm-syscall: tm-syscall-asm.S
 $(OUTPUT)/tm-syscall: CFLAGS += -I../../../../../usr/include
 $(OUTPUT)/tm-tmspr: CFLAGS += -pthread
+$(OUTPUT)/tm-vmx-unavail: CFLAGS += -pthread -m64
 
 SIGNAL_CONTEXT_CHK_TESTS := $(patsubst %,$(OUTPUT)/%,$(SIGNAL_CONTEXT_CHK_TESTS))
 $(SIGNAL_CONTEXT_CHK_TESTS): tm-signal.S
diff --git a/tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c b/tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c
new file mode 100644
index 000000000000..137185ba4937
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2017, Michael Neuling, IBM Corp.
+ * Licensed under GPLv2.
+ * Original: Breno Leitao <brenohl@br.ibm.com> &
+ *           Gustavo Bueno Romero <gromero@br.ibm.com>
+ * Edited: Michael Neuling
+ *
+ * Force VMX unavailable during a transaction and see if it corrupts
+ * the checkpointed VMX register state after the abort.
+ */
+
+#include <inttypes.h>
+#include <htmintrin.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <pthread.h>
+
+#include "tm.h"
+#include "utils.h"
+
+int passed;
+
+void *worker(void *unused)
+{
+        __int128 vmx0;
+        uint64_t texasr;
+
+        asm goto (
+                "li       3, 1;"  /* Stick non-zero value in VMX0 */
+                "std      3, 0(%[vmx0_ptr]);"
+                "lvx      0, 0, %[vmx0_ptr];"
+
+                /* Wait here a bit so we get scheduled out 255 times */
+                "lis      3, 0x3fff;"
+                "1: ;"
+                "addi     3, 3, -1;"
+                "cmpdi    3, 0;"
+                "bne      1b;"
+
+                /* Kernel will hopefully turn VMX off now */
+
+                "tbegin. ;"
+                "beq      failure;"
+
+                /* Cause VMX unavail. Any VMX instruction */
+                "vaddcuw  0,0,0;"
+
+                "tend. ;"
+                "b        %l[success];"
+
+                /* Check VMX0 sanity after abort */
+                "failure: ;"
+                "lvx       1,  0, %[vmx0_ptr];"
+                "vcmpequb. 2,  0, 1;"
+                "bc        4, 24, %l[value_mismatch];"
+                "b        %l[value_match];"
+                :
+                : [vmx0_ptr] "r"(&vmx0)
+                : "r3"
+                : success, value_match, value_mismatch
+                );
+
+        /* HTM aborted and VMX0 is corrupted */
+value_mismatch:
+        texasr = __builtin_get_texasr();
+
+        printf("\n\n==============\n\n");
+        printf("Failure with error: %lx\n",   _TEXASR_FAILURE_CODE(texasr));
+        printf("Summary error     : %lx\n",   _TEXASR_FAILURE_SUMMARY(texasr));
+        printf("TFIAR exact       : %lx\n\n", _TEXASR_TFIAR_EXACT(texasr));
+
+        passed = 0;
+        return NULL;
+
+        /* HTM aborted but VMX0 is correct */
+value_match:
+//      printf("!");
+        return NULL;
+
+success:
+//      printf(".");
+        return NULL;
+}
+
+int tm_vmx_unavail_test()
+{
+        int threads;
+        pthread_t *thread;
+
+        SKIP_IF(!have_htm());
+
+        passed = 1;
+
+        threads = sysconf(_SC_NPROCESSORS_ONLN) * 4;
+        thread = malloc(sizeof(pthread_t)*threads);
+        if (!thread)
+                return EXIT_FAILURE;
+
+        for (uint64_t i = 0; i < threads; i++)
+                pthread_create(&thread[i], NULL, &worker, NULL);
+
+        for (uint64_t i = 0; i < threads; i++)
+                pthread_join(thread[i], NULL);
+
+        free(thread);
+
+        return passed ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+
+int main(int argc, char **argv)
+{
+        return test_harness(tm_vmx_unavail_test, "tm_vmx_unavail_test");
+}
diff --git a/tools/testing/selftests/powerpc/utils.c b/tools/testing/selftests/powerpc/utils.c
index dcf74184bfd0..d46916867a6f 100644
--- a/tools/testing/selftests/powerpc/utils.c
+++ b/tools/testing/selftests/powerpc/utils.c
@@ -19,45 +19,64 @@
 
 static char auxv[4096];
 
-void *get_auxv_entry(int type)
+int read_auxv(char *buf, ssize_t buf_size)
 {
-        ElfW(auxv_t) *p;
-        void *result;
         ssize_t num;
-        int fd;
+        int rc, fd;
 
         fd = open("/proc/self/auxv", O_RDONLY);
         if (fd == -1) {
                 perror("open");
-                return NULL;
+                return -errno;
         }
 
-        result = NULL;
-
-        num = read(fd, auxv, sizeof(auxv));
+        num = read(fd, buf, buf_size);
         if (num < 0) {
                 perror("read");
+                rc = -EIO;
                 goto out;
         }
 
-        if (num > sizeof(auxv)) {
-                printf("Overflowed auxv buffer\n");
+        if (num > buf_size) {
+                printf("overflowed auxv buffer\n");
+                rc = -EOVERFLOW;
                 goto out;
         }
 
+        rc = 0;
+out:
+        close(fd);
+        return rc;
+}
+
+void *find_auxv_entry(int type, char *auxv)
+{
+        ElfW(auxv_t) *p;
+
         p = (ElfW(auxv_t) *)auxv;
 
         while (p->a_type != AT_NULL) {
-                if (p->a_type == type) {
-                        result = (void *)p->a_un.a_val;
-                        break;
-                }
+                if (p->a_type == type)
+                        return p;
 
                 p++;
         }
-out:
-        close(fd);
-        return result;
+
+        return NULL;
+}
+
+void *get_auxv_entry(int type)
+{
+        ElfW(auxv_t) *p;
+
+        if (read_auxv(auxv, sizeof(auxv)))
+                return NULL;
+
+        p = find_auxv_entry(type, auxv);
+        if (p)
+                return (void *)p->a_un.a_val;
+
+        return NULL;
 }
 
 int pick_online_cpu(void)
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
index ea6e373edc27..93eede4e8fbe 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
@@ -170,7 +170,7 @@ qemu_append="`identify_qemu_append "$QEMU"`"
 # Pull in Kconfig-fragment boot parameters
 boot_args="`configfrag_boot_params "$boot_args" "$config_template"`"
 # Generate kernel-version-specific boot parameters
-boot_args="`per_version_boot_params "$boot_args" $builddir/.config $seconds`"
+boot_args="`per_version_boot_params "$boot_args" $resdir/.config $seconds`"
 
 if test -n "$TORTURE_BUILDONLY"
 then
diff --git a/tools/testing/selftests/splice/Makefile b/tools/testing/selftests/splice/Makefile
index de51f439d4a6..9fc78e5e5451 100644
--- a/tools/testing/selftests/splice/Makefile
+++ b/tools/testing/selftests/splice/Makefile
@@ -4,5 +4,4 @@ all: $(TEST_PROGS) $(EXTRA)
 
 include ../lib.mk
 
-clean:
-        rm -fr $(TEST_PROGS) $(EXTRA)
+EXTRA_CLEAN := $(EXTRA)
diff --git a/tools/testing/selftests/sync/Makefile b/tools/testing/selftests/sync/Makefile
index 87ac400507c0..4981c6b6d050 100644
--- a/tools/testing/selftests/sync/Makefile
+++ b/tools/testing/selftests/sync/Makefile
@@ -20,5 +20,4 @@ TESTS += sync_stress_merge.o
 
 sync_test: $(OBJS) $(TESTS)
 
-clean:
-        $(RM) sync_test $(OBJS) $(TESTS)
+EXTRA_CLEAN := sync_test $(OBJS) $(TESTS)
diff --git a/tools/testing/selftests/timers/Makefile b/tools/testing/selftests/timers/Makefile
index b90e50c36f9f..5fa1d7e9a915 100644
--- a/tools/testing/selftests/timers/Makefile
+++ b/tools/testing/selftests/timers/Makefile
@@ -3,7 +3,7 @@ CFLAGS += -O3 -Wl,-no-as-needed -Wall $(BUILD_FLAGS)
 LDFLAGS += -lrt -lpthread
 
 # these are all "safe" tests that don't modify
-# system time or require escalated privledges
+# system time or require escalated privileges
 TEST_GEN_PROGS = posix_timers nanosleep nsleep-lat set-timer-lat mqueue-lat \
              inconsistency-check raw_skew threadtest rtctest
 
@@ -14,7 +14,7 @@ TEST_GEN_PROGS_EXTENDED = alarmtimer-suspend valid-adjtimex adjtick change_skew
 
 include ../lib.mk
 
-# these tests require escalated privledges
+# these tests require escalated privileges
 # and may modify the system time or trigger
 # other behavior like suspend
 run_destructive_tests: run_tests
diff --git a/tools/testing/selftests/timers/clocksource-switch.c b/tools/testing/selftests/timers/clocksource-switch.c
index fd88e3025bed..5ff165373f8b 100644
--- a/tools/testing/selftests/timers/clocksource-switch.c
+++ b/tools/testing/selftests/timers/clocksource-switch.c
@@ -159,7 +159,7 @@ int main(int argv, char **argc)
         }
 
 
-        printf("Running Asyncrhonous Switching Tests...\n");
+        printf("Running Asynchronous Switching Tests...\n");
         pid = fork();
         if (!pid)
                 return run_tests(60);
diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile
index 41642ba5e318..cbb29e41ef2b 100644
--- a/tools/testing/selftests/vm/Makefile
+++ b/tools/testing/selftests/vm/Makefile
@@ -15,21 +15,15 @@ TEST_GEN_FILES += on-fault-limit
 TEST_GEN_FILES += thuge-gen
 TEST_GEN_FILES += transhuge-stress
 TEST_GEN_FILES += userfaultfd
-TEST_GEN_FILES += userfaultfd_hugetlb
-TEST_GEN_FILES += userfaultfd_shmem
 TEST_GEN_FILES += mlock-random-test
+TEST_GEN_FILES += virtual_address_range
 
 TEST_PROGS := run_vmtests
 
 include ../lib.mk
 
-$(OUTPUT)/userfaultfd: LDLIBS += -lpthread ../../../../usr/include/linux/kernel.h
-
-$(OUTPUT)/userfaultfd_hugetlb: userfaultfd.c ../../../../usr/include/linux/kernel.h
-        $(CC) $(CFLAGS) -DHUGETLB_TEST -O2 -o $@ $< -lpthread
-
-$(OUTPUT)/userfaultfd_shmem: userfaultfd.c  ../../../../usr/include/linux/kernel.h
-        $(CC) $(CFLAGS) -DSHMEM_TEST -O2 -o $@ $< -lpthread
+$(OUTPUT)/userfaultfd: ../../../../usr/include/linux/kernel.h
+$(OUTPUT)/userfaultfd: LDLIBS += -lpthread
 
 $(OUTPUT)/mlock-random-test: LDLIBS += -lcap
 
diff --git a/tools/testing/selftests/vm/config b/tools/testing/selftests/vm/config
index 698c7ed28a26..1c0d76cb5adf 100644
--- a/tools/testing/selftests/vm/config
+++ b/tools/testing/selftests/vm/config
@@ -1 +1,2 @@
+CONFIG_SYSVIPC=y
 CONFIG_USERFAULTFD=y
diff --git a/tools/testing/selftests/vm/map_hugetlb.c b/tools/testing/selftests/vm/map_hugetlb.c
index addcd6fc1ecc..77687ab59f77 100644
--- a/tools/testing/selftests/vm/map_hugetlb.c
+++ b/tools/testing/selftests/vm/map_hugetlb.c
@@ -62,7 +62,7 @@ int main(void)
         void *addr;
         int ret;
 
-        addr = mmap(ADDR, LENGTH, PROTECTION, FLAGS, 0, 0);
+        addr = mmap(ADDR, LENGTH, PROTECTION, FLAGS, -1, 0);
         if (addr == MAP_FAILED) {
                 perror("mmap");
                 exit(1);
diff --git a/tools/testing/selftests/vm/mlock2-tests.c b/tools/testing/selftests/vm/mlock2-tests.c
index ff0cda2b19c9..e5dbc87b4297 100644
--- a/tools/testing/selftests/vm/mlock2-tests.c
+++ b/tools/testing/selftests/vm/mlock2-tests.c
@@ -293,7 +293,7 @@ static int test_mlock_lock()
         unsigned long page_size = getpagesize();
 
         map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
         if (map == MAP_FAILED) {
                 perror("test_mlock_locked mmap");
                 goto out;
@@ -402,7 +402,7 @@ static int test_mlock_onfault()
         unsigned long page_size = getpagesize();
 
         map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
         if (map == MAP_FAILED) {
                 perror("test_mlock_locked mmap");
                 goto out;
@@ -445,7 +445,7 @@ static int test_lock_onfault_of_present()
         uint64_t page1_flags, page2_flags;
 
         map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
         if (map == MAP_FAILED) {
                 perror("test_mlock_locked mmap");
                 goto out;
@@ -492,7 +492,7 @@ static int test_munlockall()
         unsigned long page_size = getpagesize();
 
         map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
 
         if (map == MAP_FAILED) {
                 perror("test_munlockall mmap");
@@ -518,7 +518,7 @@ static int test_munlockall()
         munmap(map, 2 * page_size);
 
         map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
 
         if (map == MAP_FAILED) {
                 perror("test_munlockall second mmap");
@@ -573,7 +573,7 @@ static int test_vma_management(bool call_mlock)
         struct vm_boundaries page3;
 
         map = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
         if (map == MAP_FAILED) {
                 perror("mmap()");
                 return ret;
diff --git a/tools/testing/selftests/vm/on-fault-limit.c b/tools/testing/selftests/vm/on-fault-limit.c
index 0ae458f32fdb..7f96a5c2e292 100644
--- a/tools/testing/selftests/vm/on-fault-limit.c
+++ b/tools/testing/selftests/vm/on-fault-limit.c
@@ -26,7 +26,7 @@ static int test_limit(void)
         }
 
         map = mmap(NULL, 2 * lims.rlim_max, PROT_READ | PROT_WRITE,
-                   MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, 0, 0);
+                   MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
         if (map != MAP_FAILED)
                 printf("mmap should have failed, but didn't\n");
         else {
diff --git a/tools/testing/selftests/vm/run_vmtests b/tools/testing/selftests/vm/run_vmtests
index c92f6cf31d0a..07548a1fa901 100755
--- a/tools/testing/selftests/vm/run_vmtests
+++ b/tools/testing/selftests/vm/run_vmtests
@@ -49,9 +49,9 @@ fi
 mkdir $mnt
 mount -t hugetlbfs none $mnt
 
-echo "--------------------"
+echo "---------------------"
 echo "running hugepage-mmap"
-echo "--------------------"
+echo "---------------------"
 ./hugepage-mmap
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
@@ -77,9 +77,9 @@ fi
 echo $shmmax > /proc/sys/kernel/shmmax
 echo $shmall > /proc/sys/kernel/shmall
 
-echo "--------------------"
+echo "-------------------"
 echo "running map_hugetlb"
-echo "--------------------"
+echo "-------------------"
 ./map_hugetlb
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
@@ -92,10 +92,10 @@ echo "NOTE: The above hugetlb tests provide minimal coverage.  Use"
 echo "      https://github.com/libhugetlbfs/libhugetlbfs.git for"
 echo "      hugetlb regression testing."
 
-echo "--------------------"
+echo "-------------------"
 echo "running userfaultfd"
-echo "--------------------"
-./userfaultfd 128 32
+echo "-------------------"
+./userfaultfd anon 128 32
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
         exitcode=1
@@ -103,11 +103,11 @@ else
         echo "[PASS]"
 fi
 
-echo "----------------------------"
+echo "---------------------------"
 echo "running userfaultfd_hugetlb"
-echo "----------------------------"
-# 258MB total huge pages == 128MB src and 128MB dst
-./userfaultfd_hugetlb 128 32 $mnt/ufd_test_file
+echo "---------------------------"
+# 256MB total huge pages == 128MB src and 128MB dst
+./userfaultfd hugetlb 128 32 $mnt/ufd_test_file
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
         exitcode=1
@@ -116,10 +116,10 @@ else
 fi
 rm -f $mnt/ufd_test_file
 
-echo "----------------------------"
+echo "-------------------------"
 echo "running userfaultfd_shmem"
-echo "----------------------------"
-./userfaultfd_shmem 128 32
+echo "-------------------------"
+./userfaultfd shmem 128 32
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
         exitcode=1
@@ -143,9 +143,9 @@ else
         echo "[PASS]"
 fi
 
-echo "--------------------"
+echo "----------------------"
 echo "running on-fault-limit"
-echo "--------------------"
+echo "----------------------"
 sudo -u nobody ./on-fault-limit
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
@@ -165,4 +165,15 @@ else
         echo "[PASS]"
 fi
 
+echo "-----------------------------"
+echo "running virtual_address_range"
+echo "-----------------------------"
+./virtual_address_range
+if [ $? -ne 0 ]; then
+        echo "[FAIL]"
+        exitcode=1
+else
+        echo "[PASS]"
+fi
+
 exit $exitcode
diff --git a/tools/testing/selftests/vm/thuge-gen.c b/tools/testing/selftests/vm/thuge-gen.c
index 0bc737a75150..88a2ab535e01 100644
--- a/tools/testing/selftests/vm/thuge-gen.c
+++ b/tools/testing/selftests/vm/thuge-gen.c
@@ -146,7 +146,7 @@ void test_mmap(unsigned long size, unsigned flags)
 
         before = read_free(size);
         map = mmap(NULL, size*NUM_PAGES, PROT_READ|PROT_WRITE,
-                        MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB|flags, 0, 0);
+                        MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB|flags, -1, 0);
 
         if (map == (char *)-1) err("mmap");
         memset(map, 0xff, size*NUM_PAGES);
diff --git a/tools/testing/selftests/vm/userfaultfd.c b/tools/testing/selftests/vm/userfaultfd.c
index e9449c801888..1eae79ae5b4e 100644
--- a/tools/testing/selftests/vm/userfaultfd.c
+++ b/tools/testing/selftests/vm/userfaultfd.c
@@ -77,10 +77,13 @@ static unsigned long nr_cpus, nr_pages, nr_pages_per_cpu, page_size;
 #define BOUNCE_POLL             (1<<3)
 static int bounces;
 
-#ifdef HUGETLB_TEST
+#define TEST_ANON       1
+#define TEST_HUGETLB    2
+#define TEST_SHMEM      3
+static int test_type;
+
 static int huge_fd;
 static char *huge_fd_off0;
-#endif
 static unsigned long long *count_verify;
 static int uffd, uffd_flags, finished, *pipefd;
 static char *area_src, *area_dst;
@@ -102,14 +105,7 @@ pthread_attr_t attr;
                                  ~(unsigned long)(sizeof(unsigned long long) \
                                                   -  1)))
 
-#if !defined(HUGETLB_TEST) && !defined(SHMEM_TEST)
-
-/* Anonymous memory */
-#define EXPECTED_IOCTLS         ((1 << _UFFDIO_WAKE) | \
-                                 (1 << _UFFDIO_COPY) | \
-                                 (1 << _UFFDIO_ZEROPAGE))
-
-static int release_pages(char *rel_area)
+static int anon_release_pages(char *rel_area)
 {
         int ret = 0;
 
@@ -121,7 +117,7 @@ static int release_pages(char *rel_area)
         return ret;
 }
 
-static void allocate_area(void **alloc_area)
+static void anon_allocate_area(void **alloc_area)
 {
         if (posix_memalign(alloc_area, page_size, nr_pages * page_size)) {
                 fprintf(stderr, "out of memory\n");
@@ -129,14 +125,9 @@ static void allocate_area(void **alloc_area)
         }
 }
 
-#else /* HUGETLB_TEST or SHMEM_TEST */
-
-#define EXPECTED_IOCTLS         UFFD_API_RANGE_IOCTLS_BASIC
-
-#ifdef HUGETLB_TEST
 
 /* HugeTLB memory */
-static int release_pages(char *rel_area)
+static int hugetlb_release_pages(char *rel_area)
 {
         int ret = 0;
 
@@ -152,7 +143,7 @@ static int release_pages(char *rel_area)
 }
 
 
-static void allocate_area(void **alloc_area)
+static void hugetlb_allocate_area(void **alloc_area)
 {
         *alloc_area = mmap(NULL, nr_pages * page_size, PROT_READ | PROT_WRITE,
                                 MAP_PRIVATE | MAP_HUGETLB, huge_fd,
@@ -167,10 +158,8 @@ static void allocate_area(void **alloc_area)
                 huge_fd_off0 = *alloc_area;
 }
 
-#elif defined(SHMEM_TEST)
-
 /* Shared memory */
-static int release_pages(char *rel_area)
+static int shmem_release_pages(char *rel_area)
 {
         int ret = 0;
 
@@ -182,7 +171,7 @@ static int release_pages(char *rel_area)
         return ret;
 }
 
-static void allocate_area(void **alloc_area)
+static void shmem_allocate_area(void **alloc_area)
 {
         *alloc_area = mmap(NULL, nr_pages * page_size, PROT_READ | PROT_WRITE,
                            MAP_ANONYMOUS | MAP_SHARED, -1, 0);
@@ -192,11 +181,35 @@ static void allocate_area(void **alloc_area)
         }
 }
 
-#else /* SHMEM_TEST */
-#error "Undefined test type"
-#endif /* HUGETLB_TEST */
-
-#endif /* !defined(HUGETLB_TEST) && !defined(SHMEM_TEST) */
+struct uffd_test_ops {
+        unsigned long expected_ioctls;
+        void (*allocate_area)(void **alloc_area);
+        int (*release_pages)(char *rel_area);
+};
+
+#define ANON_EXPECTED_IOCTLS            ((1 << _UFFDIO_WAKE) | \
+                                         (1 << _UFFDIO_COPY) | \
+                                         (1 << _UFFDIO_ZEROPAGE))
+
+static struct uffd_test_ops anon_uffd_test_ops = {
+        .expected_ioctls = ANON_EXPECTED_IOCTLS,
+        .allocate_area  = anon_allocate_area,
+        .release_pages  = anon_release_pages,
+};
+
+static struct uffd_test_ops shmem_uffd_test_ops = {
+        .expected_ioctls = UFFD_API_RANGE_IOCTLS_BASIC,
+        .allocate_area  = shmem_allocate_area,
+        .release_pages  = shmem_release_pages,
+};
+
+static struct uffd_test_ops hugetlb_uffd_test_ops = {
+        .expected_ioctls = UFFD_API_RANGE_IOCTLS_BASIC,
+        .allocate_area  = hugetlb_allocate_area,
+        .release_pages  = hugetlb_release_pages,
+};
+
+static struct uffd_test_ops *uffd_test_ops;
 
 static int my_bcmp(char *str1, char *str2, size_t n)
 {
@@ -505,7 +518,7 @@ static int stress(unsigned long *userfaults)
          * UFFDIO_COPY without writing zero pages into area_dst
          * because the background threads already completed).
          */
-        if (release_pages(area_src))
+        if (uffd_test_ops->release_pages(area_src))
                 return 1;
 
         for (cpu = 0; cpu < nr_cpus; cpu++) {
@@ -577,12 +590,12 @@ static int faulting_process(void)
 {
         unsigned long nr;
         unsigned long long count;
+        unsigned long split_nr_pages;
 
-#ifndef HUGETLB_TEST
-        unsigned long split_nr_pages = (nr_pages + 1) / 2;
-#else
-        unsigned long split_nr_pages = nr_pages;
-#endif
+        if (test_type != TEST_HUGETLB)
+                split_nr_pages = (nr_pages + 1) / 2;
+        else
+                split_nr_pages = nr_pages;
 
         for (nr = 0; nr < split_nr_pages; nr++) {
                 count = *area_count(area_dst, nr);
@@ -594,7 +607,9 @@ static int faulting_process(void)
                 }
         }
 
-#ifndef HUGETLB_TEST
+        if (test_type == TEST_HUGETLB)
+                return 0;
+
         area_dst = mremap(area_dst, nr_pages * page_size,  nr_pages * page_size,
                           MREMAP_MAYMOVE | MREMAP_FIXED, area_src);
         if (area_dst == MAP_FAILED)
@@ -610,7 +625,7 @@ static int faulting_process(void)
                 }
         }
 
-        if (release_pages(area_dst))
+        if (uffd_test_ops->release_pages(area_dst))
                 return 1;
 
         for (nr = 0; nr < nr_pages; nr++) {
@@ -618,8 +633,6 @@ static int faulting_process(void)
                         fprintf(stderr, "nr %lu is not zero\n", nr), exit(1);
         }
 
-#endif /* HUGETLB_TEST */
-
         return 0;
 }
 
@@ -627,7 +640,9 @@ static int uffdio_zeropage(int ufd, unsigned long offset)
 {
         struct uffdio_zeropage uffdio_zeropage;
         int ret;
-        unsigned long has_zeropage = EXPECTED_IOCTLS & (1 << _UFFDIO_ZEROPAGE);
+        unsigned long has_zeropage;
+
+        has_zeropage = uffd_test_ops->expected_ioctls & (1 << _UFFDIO_ZEROPAGE);
 
         if (offset >= nr_pages * page_size)
                 fprintf(stderr, "unexpected offset %lu\n",
@@ -675,7 +690,7 @@ static int userfaultfd_zeropage_test(void)
         printf("testing UFFDIO_ZEROPAGE: ");
         fflush(stdout);
 
-        if (release_pages(area_dst))
+        if (uffd_test_ops->release_pages(area_dst))
                 return 1;
 
         if (userfaultfd_open(0) < 0)
@@ -686,7 +701,7 @@ static int userfaultfd_zeropage_test(void)
         if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register))
                 fprintf(stderr, "register failure\n"), exit(1);
 
-        expected_ioctls = EXPECTED_IOCTLS;
+        expected_ioctls = uffd_test_ops->expected_ioctls;
         if ((uffdio_register.ioctls & expected_ioctls) !=
             expected_ioctls)
                 fprintf(stderr,
@@ -716,7 +731,7 @@ static int userfaultfd_events_test(void)
         printf("testing events (fork, remap, remove): ");
         fflush(stdout);
 
-        if (release_pages(area_dst))
+        if (uffd_test_ops->release_pages(area_dst))
                 return 1;
 
         features = UFFD_FEATURE_EVENT_FORK | UFFD_FEATURE_EVENT_REMAP |
@@ -731,7 +746,7 @@ static int userfaultfd_events_test(void)
         if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register))
                 fprintf(stderr, "register failure\n"), exit(1);
 
-        expected_ioctls = EXPECTED_IOCTLS;
+        expected_ioctls = uffd_test_ops->expected_ioctls;
         if ((uffdio_register.ioctls & expected_ioctls) !=
             expected_ioctls)
                 fprintf(stderr,
@@ -773,10 +788,10 @@ static int userfaultfd_stress(void)
         int err;
         unsigned long userfaults[nr_cpus];
 
-        allocate_area((void **)&area_src);
+        uffd_test_ops->allocate_area((void **)&area_src);
         if (!area_src)
                 return 1;
-        allocate_area((void **)&area_dst);
+        uffd_test_ops->allocate_area((void **)&area_dst);
         if (!area_dst)
                 return 1;
 
@@ -856,7 +871,7 @@ static int userfaultfd_stress(void)
                         fprintf(stderr, "register failure\n");
                         return 1;
                 }
-                expected_ioctls = EXPECTED_IOCTLS;
+                expected_ioctls = uffd_test_ops->expected_ioctls;
                 if ((uffdio_register.ioctls & expected_ioctls) !=
                     expected_ioctls) {
                         fprintf(stderr,
@@ -888,7 +903,7 @@ static int userfaultfd_stress(void)
                  * MADV_DONTNEED only after the UFFDIO_REGISTER, so it's
                  * required to MADV_DONTNEED here.
                  */
-                if (release_pages(area_dst))
+                if (uffd_test_ops->release_pages(area_dst))
                         return 1;
 
                 /* bounce pass */
@@ -934,36 +949,6 @@ static int userfaultfd_stress(void)
         return userfaultfd_zeropage_test() || userfaultfd_events_test();
 }
 
-#ifndef HUGETLB_TEST
-
-int main(int argc, char **argv)
-{
-        if (argc < 3)
-                fprintf(stderr, "Usage: <MiB> <bounces>\n"), exit(1);
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        page_size = sysconf(_SC_PAGE_SIZE);
-        if ((unsigned long) area_count(NULL, 0) + sizeof(unsigned long long) * 2
-            > page_size)
-                fprintf(stderr, "Impossible to run this test\n"), exit(2);
-        nr_pages_per_cpu = atol(argv[1]) * 1024*1024 / page_size /
-                nr_cpus;
-        if (!nr_pages_per_cpu) {
-                fprintf(stderr, "invalid MiB\n");
-                fprintf(stderr, "Usage: <MiB> <bounces>\n"), exit(1);
-        }
-        bounces = atoi(argv[2]);
-        if (bounces <= 0) {
-                fprintf(stderr, "invalid bounces\n");
-                fprintf(stderr, "Usage: <MiB> <bounces>\n"), exit(1);
-        }
-        nr_pages = nr_pages_per_cpu * nr_cpus;
-        printf("nr_pages: %lu, nr_pages_per_cpu: %lu\n",
-               nr_pages, nr_pages_per_cpu);
-        return userfaultfd_stress();
-}
-
-#else /* HUGETLB_TEST */
-
 /*
  * Copied from mlock2-tests.c
  */
@@ -988,48 +973,78 @@ unsigned long default_huge_page_size(void)
         return hps;
 }
 
-int main(int argc, char **argv)
+static void set_test_type(const char *type)
 {
-        if (argc < 4)
-                fprintf(stderr, "Usage: <MiB> <bounces> <hugetlbfs_file>\n"),
-                                exit(1);
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        page_size = default_huge_page_size();
+        if (!strcmp(type, "anon")) {
+                test_type = TEST_ANON;
+                uffd_test_ops = &anon_uffd_test_ops;
+        } else if (!strcmp(type, "hugetlb")) {
+                test_type = TEST_HUGETLB;
+                uffd_test_ops = &hugetlb_uffd_test_ops;
+        } else if (!strcmp(type, "shmem")) {
+                test_type = TEST_SHMEM;
+                uffd_test_ops = &shmem_uffd_test_ops;
+        } else {
+                fprintf(stderr, "Unknown test type: %s\n", type), exit(1);
+        }
+
+        if (test_type == TEST_HUGETLB)
+                page_size = default_huge_page_size();
+        else
+                page_size = sysconf(_SC_PAGE_SIZE);
+
         if (!page_size)
-                fprintf(stderr, "Unable to determine huge page size\n"),
+                fprintf(stderr, "Unable to determine page size\n"),
                                 exit(2);
         if ((unsigned long) area_count(NULL, 0) + sizeof(unsigned long long) * 2
             > page_size)
                 fprintf(stderr, "Impossible to run this test\n"), exit(2);
-        nr_pages_per_cpu = atol(argv[1]) * 1024*1024 / page_size /
+}
+
+int main(int argc, char **argv)
+{
+        if (argc < 4)
+                fprintf(stderr, "Usage: <test type> <MiB> <bounces> [hugetlbfs_file]\n"),
+                                exit(1);
+
+        set_test_type(argv[1]);
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        nr_pages_per_cpu = atol(argv[2]) * 1024*1024 / page_size /
                 nr_cpus;
         if (!nr_pages_per_cpu) {
                 fprintf(stderr, "invalid MiB\n");
                 fprintf(stderr, "Usage: <MiB> <bounces>\n"), exit(1);
         }
-        bounces = atoi(argv[2]);
+
+        bounces = atoi(argv[3]);
         if (bounces <= 0) {
                 fprintf(stderr, "invalid bounces\n");
                 fprintf(stderr, "Usage: <MiB> <bounces>\n"), exit(1);
         }
         nr_pages = nr_pages_per_cpu * nr_cpus;
-        huge_fd = open(argv[3], O_CREAT | O_RDWR, 0755);
-        if (huge_fd < 0) {
-                fprintf(stderr, "Open of %s failed", argv[3]);
-                perror("open");
-                exit(1);
-        }
-        if (ftruncate(huge_fd, 0)) {
-                fprintf(stderr, "ftruncate %s to size 0 failed", argv[3]);
-                perror("ftruncate");
-                exit(1);
+
+        if (test_type == TEST_HUGETLB) {
+                if (argc < 5)
+                        fprintf(stderr, "Usage: hugetlb <MiB> <bounces> <hugetlbfs_file>\n"),
+                                exit(1);
+                huge_fd = open(argv[4], O_CREAT | O_RDWR, 0755);
+                if (huge_fd < 0) {
+                        fprintf(stderr, "Open of %s failed", argv[3]);
+                        perror("open");
+                        exit(1);
+                }
+                if (ftruncate(huge_fd, 0)) {
+                        fprintf(stderr, "ftruncate %s to size 0 failed", argv[3]);
+                        perror("ftruncate");
+                        exit(1);
+                }
         }
         printf("nr_pages: %lu, nr_pages_per_cpu: %lu\n",
                nr_pages, nr_pages_per_cpu);
         return userfaultfd_stress();
 }
 
-#endif
 #else /* __NR_userfaultfd */
 
 #warning "missing __NR_userfaultfd definition"
diff --git a/tools/testing/selftests/vm/virtual_address_range.c b/tools/testing/selftests/vm/virtual_address_range.c
new file mode 100644
index 000000000000..3b02aa6eb9da
--- /dev/null
+++ b/tools/testing/selftests/vm/virtual_address_range.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2017, Anshuman Khandual, IBM Corp.
+ * Licensed under GPLv2.
+ *
+ * Works on architectures which support 128TB virtual
+ * address range and beyond.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <numaif.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+
+/*
+ * Maximum address range mapped with a single mmap()
+ * call is little bit more than 16GB. Hence 16GB is
+ * chosen as the single chunk size for address space
+ * mapping.
+ */
+#define MAP_CHUNK_SIZE   17179869184UL /* 16GB */
+
+/*
+ * Address space till 128TB is mapped without any hint
+ * and is enabled by default. Address space beyond 128TB
+ * till 512TB is obtained by passing hint address as the
+ * first argument into mmap() system call.
+ *
+ * The process heap address space is divided into two
+ * different areas one below 128TB and one above 128TB
+ * till it reaches 512TB. One with size 128TB and the
+ * other being 384TB.
+ */
+#define NR_CHUNKS_128TB   8192UL /* Number of 16GB chunks for 128TB */
+#define NR_CHUNKS_384TB  24576UL /* Number of 16GB chunks for 384TB */
+
+#define ADDR_MARK_128TB  (1UL << 47) /* First address beyond 128TB */
+
+static char *hind_addr(void)
+{
+        int bits = 48 + rand() % 15;
+
+        return (char *) (1UL << bits);
+}
+
+static int validate_addr(char *ptr, int high_addr)
+{
+        unsigned long addr = (unsigned long) ptr;
+
+        if (high_addr) {
+                if (addr < ADDR_MARK_128TB) {
+                        printf("Bad address %lx\n", addr);
+                        return 1;
+                }
+                return 0;
+        }
+
+        if (addr > ADDR_MARK_128TB) {
+                printf("Bad address %lx\n", addr);
+                return 1;
+        }
+        return 0;
+}
+
+static int validate_lower_address_hint(void)
+{
+        char *ptr;
+
+        ptr = mmap((void *) (1UL << 45), MAP_CHUNK_SIZE, PROT_READ |
+                        PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+        if (ptr == MAP_FAILED)
+                return 0;
+
+        return 1;
+}
+
+int main(int argc, char *argv[])
+{
+        char *ptr[NR_CHUNKS_128TB];
+        char *hptr[NR_CHUNKS_384TB];
+        char *hint;
+        unsigned long i, lchunks, hchunks;
+
+        for (i = 0; i < NR_CHUNKS_128TB; i++) {
+                ptr[i] = mmap(NULL, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE,
+                                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+                if (ptr[i] == MAP_FAILED) {
+                        if (validate_lower_address_hint())
+                                return 1;
+                        break;
+                }
+
+                if (validate_addr(ptr[i], 0))
+                        return 1;
+        }
+        lchunks = i;
+
+        for (i = 0; i < NR_CHUNKS_384TB; i++) {
+                hint = hind_addr();
+                hptr[i] = mmap(hint, MAP_CHUNK_SIZE, PROT_READ | PROT_WRITE,
+                                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+                if (hptr[i] == MAP_FAILED)
+                        break;
+
+                if (validate_addr(hptr[i], 1))
+                        return 1;
+        }
+        hchunks = i;
+
+        for (i = 0; i < lchunks; i++)
+                munmap(ptr[i], MAP_CHUNK_SIZE);
+
+        for (i = 0; i < hchunks; i++)
+                munmap(hptr[i], MAP_CHUNK_SIZE);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/watchdog/watchdog-test.c b/tools/testing/selftests/watchdog/watchdog-test.c
index 6983d05097e2..a74c9d739d07 100644
--- a/tools/testing/selftests/watchdog/watchdog-test.c
+++ b/tools/testing/selftests/watchdog/watchdog-test.c
@@ -24,9 +24,11 @@ const char v = 'V';
 static void keep_alive(void)
 {
     int dummy;
+    int ret;
 
-    printf(".");
-    ioctl(fd, WDIOC_KEEPALIVE, &dummy);
+    ret = ioctl(fd, WDIOC_KEEPALIVE, &dummy);
+    if (!ret)
+        printf(".");
 }
 
 /*
@@ -51,6 +53,7 @@ int main(int argc, char *argv[])
     int flags;
     unsigned int ping_rate = 1;
     int ret;
+    int i;
 
     setbuf(stdout, NULL);
 
@@ -61,31 +64,35 @@ int main(int argc, char *argv[])
         exit(-1);
     }
 
-    if (argc > 1) {
-        if (!strncasecmp(argv[1], "-d", 2)) {
-            flags = WDIOS_DISABLECARD;
-            ioctl(fd, WDIOC_SETOPTIONS, &flags);
-            printf("Watchdog card disabled.\n");
-            goto end;
-        } else if (!strncasecmp(argv[1], "-e", 2)) {
-            flags = WDIOS_ENABLECARD;
-            ioctl(fd, WDIOC_SETOPTIONS, &flags);
-            printf("Watchdog card enabled.\n");
-            goto end;
-        } else if (!strncasecmp(argv[1], "-t", 2) && argv[2]) {
-            flags = atoi(argv[2]);
-            ioctl(fd, WDIOC_SETTIMEOUT, &flags);
-            printf("Watchdog timeout set to %u seconds.\n", flags);
-            goto end;
-        } else if (!strncasecmp(argv[1], "-p", 2) && argv[2]) {
-            ping_rate = strtoul(argv[2], NULL, 0);
-            printf("Watchdog ping rate set to %u seconds.\n", ping_rate);
-        } else {
-            printf("-d to disable, -e to enable, -t <n> to set " \
-                "the timeout,\n-p <n> to set the ping rate, and \n");
-            printf("run by itself to tick the card.\n");
-            goto end;
-        }
+    for (i = 1; i < argc; i++) {
+        if (!strncasecmp(argv[i], "-d", 2)) {
+            flags = WDIOS_DISABLECARD;
+            ret = ioctl(fd, WDIOC_SETOPTIONS, &flags);
+            if (!ret)
+                printf("Watchdog card disabled.\n");
+        } else if (!strncasecmp(argv[i], "-e", 2)) {
+            flags = WDIOS_ENABLECARD;
+            ret = ioctl(fd, WDIOC_SETOPTIONS, &flags);
+            if (!ret)
+                printf("Watchdog card enabled.\n");
+        } else if (!strncasecmp(argv[i], "-t", 2) && argv[2]) {
+            flags = atoi(argv[i + 1]);
+            ret = ioctl(fd, WDIOC_SETTIMEOUT, &flags);
+            if (!ret)
+                printf("Watchdog timeout set to %u seconds.\n", flags);
+            i++;
+        } else if (!strncasecmp(argv[i], "-p", 2) && argv[2]) {
+            ping_rate = strtoul(argv[i + 1], NULL, 0);
+            printf("Watchdog ping rate set to %u seconds.\n", ping_rate);
+            i++;
+        } else {
+            printf("-d to disable, -e to enable, -t <n> to set "
+                "the timeout,\n-p <n> to set the ping rate, and ");
+            printf("run by itself to tick the card.\n");
+            printf("Parameters are parsed left-to-right in real-time.\n");
+            printf("Example: %s -d -t 10 -p 5 -e\n", argv[0]);
+            goto end;
+        }
     }
 
     printf("Watchdog Ticking Away!\n");
diff --git a/tools/testing/selftests/x86/.gitignore b/tools/testing/selftests/x86/.gitignore
index 15034fef9698..7757f73ff9a3 100644
--- a/tools/testing/selftests/x86/.gitignore
+++ b/tools/testing/selftests/x86/.gitignore
@@ -1,2 +1,15 @@
 *_32
 *_64
+single_step_syscall
+sysret_ss_attrs
+syscall_nt
+ptrace_syscall
+test_mremap_vdso
+check_initial_reg_state
+sigreturn
+ldt_gdt
+iopl
+mpx-mini-test
+ioperm
+protection_keys
+test_vdso
diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile
index 38e0a9ca5d71..97f187e2663f 100644
--- a/tools/testing/selftests/x86/Makefile
+++ b/tools/testing/selftests/x86/Makefile
@@ -40,8 +40,7 @@ all_32: $(BINARIES_32)
 
 all_64: $(BINARIES_64)
 
-clean:
-        $(RM) $(BINARIES_32) $(BINARIES_64)
+EXTRA_CLEAN := $(BINARIES_32) $(BINARIES_64)
 
 $(BINARIES_32): $(OUTPUT)/%_32: %.c
         $(CC) -m32 -o $@ $(CFLAGS) $(EXTRA_CFLAGS) $^ -lrt -ldl -lm
diff --git a/tools/testing/selftests/x86/ldt_gdt.c b/tools/testing/selftests/x86/ldt_gdt.c
index f6121612e769..b9a22f18566a 100644
--- a/tools/testing/selftests/x86/ldt_gdt.c
+++ b/tools/testing/selftests/x86/ldt_gdt.c
@@ -409,6 +409,51 @@ static void *threadproc(void *ctx)
         }
 }
 
+#ifdef __i386__
+
+#ifndef SA_RESTORE
+#define SA_RESTORER 0x04000000
+#endif
+
+/*
+ * The UAPI header calls this 'struct sigaction', which conflicts with
+ * glibc.  Sigh.
+ */
+struct fake_ksigaction {
+        void *handler;  /* the real type is nasty */
+        unsigned long sa_flags;
+        void (*sa_restorer)(void);
+        unsigned char sigset[8];
+};
+
+static void fix_sa_restorer(int sig)
+{
+        struct fake_ksigaction ksa;
+
+        if (syscall(SYS_rt_sigaction, sig, NULL, &ksa, 8) == 0) {
+                /*
+                 * glibc has a nasty bug: it sometimes writes garbage to
+                 * sa_restorer.  This interacts quite badly with anything
+                 * that fiddles with SS because it can trigger legacy
+                 * stack switching.  Patch it up.  See:
+                 *
+                 * https://sourceware.org/bugzilla/show_bug.cgi?id=21269
+                 */
+                if (!(ksa.sa_flags & SA_RESTORER) && ksa.sa_restorer) {
+                        ksa.sa_restorer = NULL;
+                        if (syscall(SYS_rt_sigaction, sig, &ksa, NULL,
+                                    sizeof(ksa.sigset)) != 0)
+                                err(1, "rt_sigaction");
+                }
+        }
+}
+#else
+static void fix_sa_restorer(int sig)
+{
+        /* 64-bit glibc works fine. */
+}
+#endif
+
 static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
                        int flags)
 {
@@ -420,6 +465,7 @@ static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
         if (sigaction(sig, &sa, 0))
                 err(1, "sigaction");
 
+        fix_sa_restorer(sig);
 }
 
 static jmp_buf jmpbuf;
diff --git a/tools/testing/selftests/x86/mpx-mini-test.c b/tools/testing/selftests/x86/mpx-mini-test.c
index 616ee9673339..a8df159a8924 100644
--- a/tools/testing/selftests/x86/mpx-mini-test.c
+++ b/tools/testing/selftests/x86/mpx-mini-test.c
@@ -404,8 +404,6 @@ void handler(int signum, siginfo_t *si, void *vucontext)
                 dprintf2("info->si_lower: %p\n", __si_bounds_lower(si));
                 dprintf2("info->si_upper: %p\n", __si_bounds_upper(si));
 
-                check_siginfo_vs_shadow(si);
-
                 for (i = 0; i < 8; i++)
                         dprintf3("[%d]: %p\n", i, si_addr_ptr[i]);
                 switch (br_reason) {
@@ -416,6 +414,9 @@ void handler(int signum, siginfo_t *si, void *vucontext)
                         exit(5);
                 case 1: /* #BR MPX bounds exception */
                         /* these are normal and we expect to see them */
+
+                        check_siginfo_vs_shadow(si);
+
                         dprintf1("bounds exception (normal): status 0x%jx at %p si_addr: %p\n",
                                 status, (void *)ip, si->si_addr);
                         num_bnd_chk++;
diff --git a/tools/usb/.gitignore b/tools/usb/.gitignore
new file mode 100644
index 000000000000..1b7448981435
--- /dev/null
+++ b/tools/usb/.gitignore
@@ -0,0 +1,2 @@
+ffs-test
+testusb
diff --git a/tools/usb/usbip/README b/tools/usb/usbip/README
index 5eb2b6c7722b..7844490fc603 100644
--- a/tools/usb/usbip/README
+++ b/tools/usb/usbip/README
@@ -244,7 +244,7 @@ Detach the imported device:
     - See 'Debug Tips' on the project wiki.
         - http://usbip.wiki.sourceforge.net/how-to-debug-usbip
     - usbip-host.ko must be bound to the target device.
-        - See /proc/bus/usb/devices and find "Driver=..." lines of the device.
+        - See /sys/kernel/debug/usb/devices and find "Driver=..." lines of the device.
     - Target USB gadget must be bound to vudc
       (using USB gadget susbsys, not usbip bind command)
     - Shutdown firewall.
diff --git a/tools/usb/usbip/libsrc/usbip_common.c b/tools/usb/usbip/libsrc/usbip_common.c
index ac73710473de..1517a232ab18 100644
--- a/tools/usb/usbip/libsrc/usbip_common.c
+++ b/tools/usb/usbip/libsrc/usbip_common.c
@@ -215,9 +215,16 @@ int read_usb_interface(struct usbip_usb_device *udev, int i,
                        struct usbip_usb_interface *uinf)
 {
         char busid[SYSFS_BUS_ID_SIZE];
+        int size;
         struct udev_device *sif;
 
-        sprintf(busid, "%s:%d.%d", udev->busid, udev->bConfigurationValue, i);
+        size = snprintf(busid, sizeof(busid), "%s:%d.%d",
+                        udev->busid, udev->bConfigurationValue, i);
+        if (size < 0 || (unsigned int)size >= sizeof(busid)) {
+                err("busid length %i >= %lu or < 0", size,
+                    (long unsigned)sizeof(busid));
+                return -1;
+        }
 
         sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid);
         if (!sif) {
diff --git a/tools/usb/usbip/libsrc/usbip_host_common.c b/tools/usb/usbip/libsrc/usbip_host_common.c
index 9d415228883d..6ff7b601f854 100644
--- a/tools/usb/usbip/libsrc/usbip_host_common.c
+++ b/tools/usb/usbip/libsrc/usbip_host_common.c
@@ -40,13 +40,20 @@ struct udev *udev_context;
 static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
 {
         char status_attr_path[SYSFS_PATH_MAX];
+        int size;
         int fd;
         int length;
         char status;
         int value = 0;
 
-        snprintf(status_attr_path, SYSFS_PATH_MAX, "%s/usbip_status",
-                 udev->path);
+        size = snprintf(status_attr_path, sizeof(status_attr_path),
+                        "%s/usbip_status", udev->path);
+        if (size < 0 || (unsigned int)size >= sizeof(status_attr_path)) {
+                err("usbip_status path length %i >= %lu or < 0", size,
+                    (long unsigned)sizeof(status_attr_path));
+                return -1;
+        }
+
 
         fd = open(status_attr_path, O_RDONLY);
         if (fd < 0) {
@@ -218,6 +225,7 @@ int usbip_export_device(struct usbip_exported_device *edev, int sockfd)
 {
         char attr_name[] = "usbip_sockfd";
         char sockfd_attr_path[SYSFS_PATH_MAX];
+        int size;
         char sockfd_buff[30];
         int ret;
 
@@ -237,10 +245,20 @@ int usbip_export_device(struct usbip_exported_device *edev, int sockfd)
         }
 
         /* only the first interface is true */
-        snprintf(sockfd_attr_path, sizeof(sockfd_attr_path), "%s/%s",
-                 edev->udev.path, attr_name);
+        size = snprintf(sockfd_attr_path, sizeof(sockfd_attr_path), "%s/%s",
+                        edev->udev.path, attr_name);
+        if (size < 0 || (unsigned int)size >= sizeof(sockfd_attr_path)) {
+                err("exported device path length %i >= %lu or < 0", size,
+                    (long unsigned)sizeof(sockfd_attr_path));
+                return -1;
+        }
 
-        snprintf(sockfd_buff, sizeof(sockfd_buff), "%d\n", sockfd);
+        size = snprintf(sockfd_buff, sizeof(sockfd_buff), "%d\n", sockfd);
+        if (size < 0 || (unsigned int)size >= sizeof(sockfd_buff)) {
+                err("socket length %i >= %lu or < 0", size,
+                    (long unsigned)sizeof(sockfd_buff));
+                return -1;
+        }
 
         ret = write_sysfs_attribute(sockfd_attr_path, sockfd_buff,
                                     strlen(sockfd_buff));
diff --git a/tools/usb/usbip/libsrc/vhci_driver.c b/tools/usb/usbip/libsrc/vhci_driver.c
index ad9204773533..f659c146cdc8 100644
--- a/tools/usb/usbip/libsrc/vhci_driver.c
+++ b/tools/usb/usbip/libsrc/vhci_driver.c
@@ -123,33 +123,15 @@ static int refresh_imported_device_list(void)
 
 static int get_nports(void)
 {
-        char *c;
-        int nports = 0;
-        const char *attr_status;
+        const char *attr_nports;
 
-        attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
-                                               "status");
-        if (!attr_status) {
-                err("udev_device_get_sysattr_value failed");
+        attr_nports = udev_device_get_sysattr_value(vhci_driver->hc_device, "nports");
+        if (!attr_nports) {
+                err("udev_device_get_sysattr_value nports failed");
                 return -1;
         }
 
-        /* skip a header line */
-        c = strchr(attr_status, '\n');
-        if (!c)
-                return 0;
-        c++;
-
-        while (*c != '\0') {
-                /* go to the next line */
-                c = strchr(c, '\n');
-                if (!c)
-                        return nports;
-                c++;
-                nports += 1;
-        }
-
-        return nports;
+        return (int)strtoul(attr_nports, NULL, 10);
 }
 
 /*
diff --git a/tools/usb/usbip/src/usbip.c b/tools/usb/usbip/src/usbip.c
index d7599d943529..73d8eee8130b 100644
--- a/tools/usb/usbip/src/usbip.c
+++ b/tools/usb/usbip/src/usbip.c
@@ -176,6 +176,8 @@ int main(int argc, char *argv[])
                         break;
                 case '?':
                         printf("usbip: invalid option\n");
+                        /* Terminate after printing error */
+                        /* FALLTHRU */
                 default:
                         usbip_usage();
                         goto out;
diff --git a/tools/virtio/linux/virtio.h b/tools/virtio/linux/virtio.h
index 9377c8b4ac16..d8f534025b7f 100644
--- a/tools/virtio/linux/virtio.h
+++ b/tools/virtio/linux/virtio.h
@@ -57,6 +57,7 @@ struct virtqueue *vring_new_virtqueue(unsigned int index,
                                       unsigned int vring_align,
                                       struct virtio_device *vdev,
                                       bool weak_barriers,
+                                      bool ctx,
                                       void *pages,
                                       bool (*notify)(struct virtqueue *vq),
                                       void (*callback)(struct virtqueue *vq),
diff --git a/tools/virtio/ringtest/main.c b/tools/virtio/ringtest/main.c
index f31353fac541..453ca3c21193 100644
--- a/tools/virtio/ringtest/main.c
+++ b/tools/virtio/ringtest/main.c
@@ -20,6 +20,7 @@
 int runcycles = 10000000;
 int max_outstanding = INT_MAX;
 int batch = 1;
+int param = 0;
 
 bool do_sleep = false;
 bool do_relax = false;
@@ -86,7 +87,7 @@ void set_affinity(const char *arg)
         cpu = strtol(arg, &endptr, 0);
         assert(!*endptr);
 
-        assert(cpu >= 0 || cpu < CPU_SETSIZE);
+        assert(cpu >= 0 && cpu < CPU_SETSIZE);
 
         self = pthread_self();
         CPU_ZERO(&cpuset);
@@ -247,6 +248,11 @@ static const struct option longopts[] = {
                 .val = 'b',
         },
         {
+                .name = "param",
+                .has_arg = required_argument,
+                .val = 'p',
+        },
+        {
                 .name = "sleep",
                 .has_arg = no_argument,
                 .val = 's',
@@ -274,6 +280,7 @@ static void help(void)
                 " [--run-cycles C (default: %d)]"
                 " [--batch b]"
                 " [--outstanding o]"
+                " [--param p]"
                 " [--sleep]"
                 " [--relax]"
                 " [--exit]"
@@ -328,6 +335,12 @@ int main(int argc, char **argv)
                         assert(c > 0 && c < INT_MAX);
                         max_outstanding = c;
                         break;
+                case 'p':
+                        c = strtol(optarg, &endptr, 0);
+                        assert(!*endptr);
+                        assert(c > 0 && c < INT_MAX);
+                        param = c;
+                        break;
                 case 'b':
                         c = strtol(optarg, &endptr, 0);
                         assert(!*endptr);
diff --git a/tools/virtio/ringtest/main.h b/tools/virtio/ringtest/main.h
index 14142faf040b..90b0133004e1 100644
--- a/tools/virtio/ringtest/main.h
+++ b/tools/virtio/ringtest/main.h
@@ -10,6 +10,8 @@
 
 #include <stdbool.h>
 
+extern int param;
+
 extern bool do_exit;
 
 #if defined(__x86_64__) || defined(__i386__)
diff --git a/tools/virtio/ringtest/ptr_ring.c b/tools/virtio/ringtest/ptr_ring.c
index 635b07b4fdd3..7b22f1b20652 100644
--- a/tools/virtio/ringtest/ptr_ring.c
+++ b/tools/virtio/ringtest/ptr_ring.c
@@ -97,6 +97,9 @@ void alloc_ring(void)
 {
         int ret = ptr_ring_init(&array, ring_size, 0);
         assert(!ret);
+        /* Hacky way to poke at ring internals. Useful for testing though. */
+        if (param)
+                array.batch = param;
 }
 
 /* guest side */
diff --git a/tools/virtio/virtio_test.c b/tools/virtio/virtio_test.c
index e0445898f08f..0fecaec90d0d 100644
--- a/tools/virtio/virtio_test.c
+++ b/tools/virtio/virtio_test.c
@@ -100,7 +100,7 @@ static void vq_info_add(struct vdev_info *dev, int num)
         vring_init(&info->vring, num, info->ring, 4096);
         info->vq = vring_new_virtqueue(info->idx,
                                        info->vring.num, 4096, &dev->vdev,
-                                       true, info->ring,
+                                       true, false, info->ring,
                                        vq_notify, vq_callback, "test");
         assert(info->vq);
         info->vq->priv = info;
@@ -202,7 +202,7 @@ static void run_test(struct vdev_info *dev, struct vq_info *vq,
         test = 0;
         r = ioctl(dev->control, VHOST_TEST_RUN, &test);
         assert(r >= 0);
-        fprintf(stderr, "spurious wakeus: 0x%llx\n", spurious);
+        fprintf(stderr, "spurious wakeups: 0x%llx\n", spurious);
 }
 
 const char optstring[] = "h";
diff --git a/tools/virtio/vringh_test.c b/tools/virtio/vringh_test.c
index 5f94f5105678..9476c616d064 100644
--- a/tools/virtio/vringh_test.c
+++ b/tools/virtio/vringh_test.c
@@ -314,7 +314,8 @@ static int parallel_test(u64 features,
                         err(1, "Could not set affinity to cpu %u", first_cpu);
 
                 vq = vring_new_virtqueue(0, RINGSIZE, ALIGN, &gvdev.vdev, true,
-                                         guest_map, fast_vringh ? no_notify_host
+                                         false, guest_map,
+                                         fast_vringh ? no_notify_host
                                          : parallel_notify_host,
                                          never_callback_guest, "guest vq");
 
@@ -479,7 +480,7 @@ int main(int argc, char *argv[])
         memset(__user_addr_min, 0, vring_size(RINGSIZE, ALIGN));
 
         /* Set up guest side. */
-        vq = vring_new_virtqueue(0, RINGSIZE, ALIGN, &vdev, true,
+        vq = vring_new_virtqueue(0, RINGSIZE, ALIGN, &vdev, true, false,
                                  __user_addr_min,
                                  never_notify_host, never_callback_guest,
                                  "guest vq");
@@ -663,7 +664,7 @@ int main(int argc, char *argv[])
                 /* Force creation of direct, which we modify. */
                 __virtio_clear_bit(&vdev, VIRTIO_RING_F_INDIRECT_DESC);
                 vq = vring_new_virtqueue(0, RINGSIZE, ALIGN, &vdev, true,
-                                         __user_addr_min,
+                                         false, __user_addr_min,
                                          never_notify_host,
                                          never_callback_guest,
                                          "guest vq");