156 files changed, 6903 insertions, 2605 deletions

diff --git a/tools/perf/Documentation/build-xed.txt b/tools/perf/Documentation/build-xed.txt
new file mode 100644
index 000000000000..6222c1e7231f
--- /dev/null
+++ b/tools/perf/Documentation/build-xed.txt
@@ -0,0 +1,19 @@
+
+For --xed the xed tool is needed. Here is how to install it:
+
+  $ git clone https://github.com/intelxed/mbuild.git mbuild
+  $ git clone https://github.com/intelxed/xed
+  $ cd xed
+  $ ./mfile.py --share
+  $ ./mfile.py examples
+  $ sudo ./mfile.py --prefix=/usr/local install
+  $ sudo ldconfig
+  $ sudo cp obj/examples/xed /usr/local/bin
+
+Basic xed testing:
+
+  $ xed | head -3
+  ERROR: required argument(s) were missing
+  Copyright (C) 2017, Intel Corporation. All rights reserved.
+  XED version: [v10.0-328-g7d62c8c49b7b]
+  $
diff --git a/tools/perf/Documentation/intel-pt.txt b/tools/perf/Documentation/intel-pt.txt
index 76971d2e4164..115eaacc455f 100644
--- a/tools/perf/Documentation/intel-pt.txt
+++ b/tools/perf/Documentation/intel-pt.txt
@@ -106,7 +106,7 @@ in transaction, respectively.
 While it is possible to create scripts to analyze the data, an alternative
 approach is available to export the data to a sqlite or postgresql database.
 Refer to script export-to-sqlite.py or export-to-postgresql.py for more details,
-and to script call-graph-from-sql.py for an example of using the database.
+and to script exported-sql-viewer.py for an example of using the database.
 
 There is also script intel-pt-events.py which provides an example of how to
 unpack the raw data for power events and PTWRITE.
diff --git a/tools/perf/Documentation/itrace.txt b/tools/perf/Documentation/itrace.txt
index a3abe04c779d..c2182cbabde3 100644
--- a/tools/perf/Documentation/itrace.txt
+++ b/tools/perf/Documentation/itrace.txt
@@ -11,10 +11,11 @@
                 l       synthesize last branch entries (use with i or x)
                 s       skip initial number of events
 
-        The default is all events i.e. the same as --itrace=ibxwpe
+        The default is all events i.e. the same as --itrace=ibxwpe,
+        except for perf script where it is --itrace=ce
 
-        In addition, the period (default 100000) for instructions events
-        can be specified in units of:
+        In addition, the period (default 100000, except for perf script where it is 1)
+        for instructions events can be specified in units of:
 
                 i       instructions
                 t       ticks
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index afdafe2110a1..a2b37ce48094 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -383,6 +383,24 @@ include::itrace.txt[]
         will be printed. Each entry has function name and file/line. Enabled by
         default, disable with --no-inline.
 
+--insn-trace::
+        Show instruction stream for intel_pt traces. Combine with --xed to
+        show disassembly.
+
+--xed::
+        Run xed disassembler on output. Requires installing the xed disassembler.
+
+--call-trace::
+        Show call stream for intel_pt traces. The CPUs are interleaved, but
+        can be filtered with -C.
+
+--call-ret-trace::
+        Show call and return stream for intel_pt traces.
+
+--graph-function::
+        For itrace only show specified functions and their callees for
+        itrace. Multiple functions can be separated by comma.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script-perl[1],
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 114fda12aa49..808b664343c9 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -242,6 +242,16 @@ Default is to monitor all CPUS.
 --hierarchy::
         Enable hierarchy output.
 
+--overwrite::
+        Enable this to use just the most recent records, which helps in high core count
+        machines such as Knights Landing/Mill, but right now is disabled by default as
+        the pausing used in this technique is leading to loss of metadata events such
+        as PERF_RECORD_MMAP which makes 'perf top' unable to resolve samples, leading
+        to lots of unknown samples appearing on the UI. Enable this if you are in such
+        machines and profiling a workload that doesn't creates short lived threads and/or
+        doesn't uses many executable mmap operations. Work is being planed to solve
+        this situation, till then, this will remain disabled by default.
+
 --force::
         Don't do ownership validation.
 
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 115db9e06ecd..e113450503d2 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -171,6 +171,11 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
 --kernel-syscall-graph::
          Show the kernel callchains on the syscall exit path.
 
+--max-events=N::
+        Stop after processing N events. Note that strace-like events are considered
+        only at exit time or when a syscall is interrupted, i.e. in those cases this
+        option is equivalent to the number of lines printed.
+
 --max-stack::
         Set the stack depth limit when parsing the callchain, anything
         beyond the specified depth will be ignored. Note that at this point
@@ -238,6 +243,68 @@ Trace syscalls, major and minor pagefaults:
   As you can see, there was major pagefault in python process, from
   CRYPTO_push_info_ routine which faulted somewhere in libcrypto.so.
 
+Trace the first 4 open, openat or open_by_handle_at syscalls (in the future more syscalls may match here):
+
+  $ perf trace -e open* --max-events 4
+  [root@jouet perf]# trace -e open* --max-events 4
+  2272.992 ( 0.037 ms): gnome-shell/1370 openat(dfd: CWD, filename: /proc/self/stat) = 31
+  2277.481 ( 0.139 ms): gnome-shell/3039 openat(dfd: CWD, filename: /proc/self/stat) = 65
+  3026.398 ( 0.076 ms): gnome-shell/3039 openat(dfd: CWD, filename: /proc/self/stat) = 65
+  4294.665 ( 0.015 ms): sed/15879 openat(dfd: CWD, filename: /etc/ld.so.cache, flags: CLOEXEC) = 3
+  $
+
+Trace the first minor page fault when running a workload:
+
+  # perf trace -F min --max-stack=7 --max-events 1 sleep 1
+     0.000 ( 0.000 ms): sleep/18006 minfault [__clear_user+0x1a] => 0x5626efa56080 (?k)
+                                       __clear_user ([kernel.kallsyms])
+                                       load_elf_binary ([kernel.kallsyms])
+                                       search_binary_handler ([kernel.kallsyms])
+                                       __do_execve_file.isra.33 ([kernel.kallsyms])
+                                       __x64_sys_execve ([kernel.kallsyms])
+                                       do_syscall_64 ([kernel.kallsyms])
+                                       entry_SYSCALL_64 ([kernel.kallsyms])
+  #
+
+Trace the next min page page fault to take place on the first CPU:
+
+  # perf trace -F min --call-graph=dwarf --max-events 1 --cpu 0
+     0.000 ( 0.000 ms): Web Content/17136 minfault [js::gc::Chunk::fetchNextDecommittedArena+0x4b] => 0x7fbe6181b000 (?.)
+                                       js::gc::FreeSpan::initAsEmpty (inlined)
+                                       js::gc::Arena::setAsNotAllocated (inlined)
+                                       js::gc::Chunk::fetchNextDecommittedArena (/usr/lib64/firefox/libxul.so)
+                                       js::gc::Chunk::allocateArena (/usr/lib64/firefox/libxul.so)
+                                       js::gc::GCRuntime::allocateArena (/usr/lib64/firefox/libxul.so)
+                                       js::gc::ArenaLists::allocateFromArena (/usr/lib64/firefox/libxul.so)
+                                       js::gc::GCRuntime::tryNewTenuredThing<JSString, (js::AllowGC)1> (inlined)
+                                       js::AllocateString<JSString, (js::AllowGC)1> (/usr/lib64/firefox/libxul.so)
+                                       js::Allocate<JSThinInlineString, (js::AllowGC)1> (inlined)
+                                       JSThinInlineString::new_<(js::AllowGC)1> (inlined)
+                                       AllocateInlineString<(js::AllowGC)1, unsigned char> (inlined)
+                                       js::ConcatStrings<(js::AllowGC)1> (/usr/lib64/firefox/libxul.so)
+                                       [0x18b26e6bc2bd] (/tmp/perf-17136.map)
+  #
+
+Trace the next two sched:sched_switch events, four block:*_plug events, the
+next block:*_unplug and the next three net:*dev_queue events, this last one
+with a backtrace of at most 16 entries, system wide:
+
+  # perf trace -e sched:*switch/nr=2/,block:*_plug/nr=4/,block:*_unplug/nr=1/,net:*dev_queue/nr=3,max-stack=16/
+     0.000 :0/0 sched:sched_switch:swapper/2:0 [120] S ==> rcu_sched:10 [120]
+     0.015 rcu_sched/10 sched:sched_switch:rcu_sched:10 [120] R ==> swapper/2:0 [120]
+   254.198 irq/50-iwlwifi/680 net:net_dev_queue:dev=wlp3s0 skbaddr=0xffff93498051f600 len=66
+                                       __dev_queue_xmit ([kernel.kallsyms])
+   273.977 :0/0 net:net_dev_queue:dev=wlp3s0 skbaddr=0xffff93498051f600 len=78
+                                       __dev_queue_xmit ([kernel.kallsyms])
+   274.007 :0/0 net:net_dev_queue:dev=wlp3s0 skbaddr=0xffff93498051ff00 len=78
+                                       __dev_queue_xmit ([kernel.kallsyms])
+  2930.140 kworker/u16:58/2722 block:block_plug:[kworker/u16:58]
+  2930.162 kworker/u16:58/2722 block:block_unplug:[kworker/u16:58] 1
+  4466.094 jbd2/dm-2-8/748 block:block_plug:[jbd2/dm-2-8]
+  8050.123 kworker/u16:30/2694 block:block_plug:[kworker/u16:30]
+  8050.271 kworker/u16:30/2694 block:block_plug:[kworker/u16:30]
+  #
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script[1]
diff --git a/tools/perf/Makefile.config b/tools/perf/Makefile.config
index f6d1a03c7523..e30d20fb482d 100644
--- a/tools/perf/Makefile.config
+++ b/tools/perf/Makefile.config
@@ -833,7 +833,7 @@ ifndef NO_JVMTI
     JDIR=$(shell /usr/sbin/update-java-alternatives -l | head -1 | awk '{print $$3}')
   else
     ifneq (,$(wildcard /usr/sbin/alternatives))
-      JDIR=$(shell alternatives --display java | tail -1 | cut -d' ' -f 5 | sed 's%/jre/bin/java.%%g')
+      JDIR=$(shell /usr/sbin/alternatives --display java | tail -1 | cut -d' ' -f 5 | sed 's%/jre/bin/java.%%g')
     endif
   endif
   ifndef JDIR
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index 5224ade3d5af..3ccb4f0bf088 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -1,4 +1,5 @@
 include ../scripts/Makefile.include
+include ../scripts/Makefile.arch
 
 # The default target of this Makefile is...
 all:
@@ -385,6 +386,8 @@ export INSTALL SHELL_PATH
 SHELL = $(SHELL_PATH)
 
 linux_uapi_dir := $(srctree)/tools/include/uapi/linux
+asm_generic_uapi_dir := $(srctree)/tools/include/uapi/asm-generic
+arch_asm_uapi_dir := $(srctree)/tools/arch/$(ARCH)/include/uapi/asm/
 
 beauty_outdir := $(OUTPUT)trace/beauty/generated
 beauty_ioctl_outdir := $(beauty_outdir)/ioctl
@@ -460,6 +463,18 @@ madvise_behavior_tbl := $(srctree)/tools/perf/trace/beauty/madvise_behavior.sh
 $(madvise_behavior_array): $(madvise_hdr_dir)/mman-common.h $(madvise_behavior_tbl)
         $(Q)$(SHELL) '$(madvise_behavior_tbl)' $(madvise_hdr_dir) > $@
 
+mmap_flags_array := $(beauty_outdir)/mmap_flags_array.c
+mmap_flags_tbl := $(srctree)/tools/perf/trace/beauty/mmap_flags.sh
+
+$(mmap_flags_array): $(asm_generic_uapi_dir)/mman.h $(asm_generic_uapi_dir)/mman-common.h $(arch_asm_uapi_dir)/mman.h $(mmap_flags_tbl)
+        $(Q)$(SHELL) '$(mmap_flags_tbl)' $(asm_generic_uapi_dir) $(arch_asm_uapi_dir) > $@
+
+mount_flags_array := $(beauty_outdir)/mount_flags_array.c
+mount_flags_tbl := $(srctree)/tools/perf/trace/beauty/mount_flags.sh
+
+$(mount_flags_array): $(linux_uapi_dir)/fs.h $(mount_flags_tbl)
+        $(Q)$(SHELL) '$(mount_flags_tbl)' $(linux_uapi_dir) > $@
+
 prctl_option_array := $(beauty_outdir)/prctl_option_array.c
 prctl_hdr_dir := $(srctree)/tools/include/uapi/linux/
 prctl_option_tbl := $(srctree)/tools/perf/trace/beauty/prctl_option.sh
@@ -577,6 +592,8 @@ prepare: $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h archheaders $(drm_ioc
         $(socket_ipproto_array) \
         $(vhost_virtio_ioctl_array) \
         $(madvise_behavior_array) \
+        $(mmap_flags_array) \
+        $(mount_flags_array) \
         $(perf_ioctl_array) \
         $(prctl_option_array) \
         $(arch_errno_name_array)
@@ -635,7 +652,7 @@ $(LIBPERF_IN): prepare FORCE
 $(LIB_FILE): $(LIBPERF_IN)
         $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIBPERF_IN) $(LIB_OBJS)
 
-LIBTRACEEVENT_FLAGS += plugin_dir=$(plugindir_SQ)
+LIBTRACEEVENT_FLAGS += plugin_dir=$(plugindir_SQ) 'EXTRA_CFLAGS=$(EXTRA_CFLAGS)' 'LDFLAGS=$(LDFLAGS)'
 
 $(LIBTRACEEVENT): FORCE
         $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) O=$(OUTPUT) $(OUTPUT)libtraceevent.a
@@ -779,7 +796,9 @@ endif
 ifndef NO_LIBBPF
         $(call QUIET_INSTALL, bpf-headers) \
                 $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf'; \
-                $(INSTALL) include/bpf/*.h -t '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf'
+                $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf/linux'; \
+                $(INSTALL) include/bpf/*.h -t '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf'; \
+                $(INSTALL) include/bpf/linux/*.h -t '$(DESTDIR_SQ)$(perf_include_instdir_SQ)/bpf/linux'
         $(call QUIET_INSTALL, bpf-examples) \
                 $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perf_examples_instdir_SQ)/bpf'; \
                 $(INSTALL) examples/bpf/*.c -t '$(DESTDIR_SQ)$(perf_examples_instdir_SQ)/bpf'
@@ -861,6 +880,8 @@ clean:: $(LIBTRACEEVENT)-clean $(LIBAPI)-clean $(LIBBPF)-clean $(LIBSUBCMD)-clea
                 $(OUTPUT)tests/llvm-src-{base,kbuild,prologue,relocation}.c \
                 $(OUTPUT)pmu-events/pmu-events.c \
                 $(OUTPUT)$(madvise_behavior_array) \
+                $(OUTPUT)$(mmap_flags_array) \
+                $(OUTPUT)$(mount_flags_array) \
                 $(OUTPUT)$(drm_ioctl_array) \
                 $(OUTPUT)$(pkey_alloc_access_rights_array) \
                 $(OUTPUT)$(sndrv_ctl_ioctl_array) \
diff --git a/tools/perf/arch/arm64/annotate/instructions.c b/tools/perf/arch/arm64/annotate/instructions.c
index 6688977e4ac7..76c6345a57d5 100644
--- a/tools/perf/arch/arm64/annotate/instructions.c
+++ b/tools/perf/arch/arm64/annotate/instructions.c
@@ -8,6 +8,63 @@ struct arm64_annotate {
                 jump_insn;
 };
 
+static int arm64_mov__parse(struct arch *arch __maybe_unused,
+                            struct ins_operands *ops,
+                            struct map_symbol *ms __maybe_unused)
+{
+        char *s = strchr(ops->raw, ','), *target, *endptr;
+
+        if (s == NULL)
+                return -1;
+
+        *s = '\0';
+        ops->source.raw = strdup(ops->raw);
+        *s = ',';
+
+        if (ops->source.raw == NULL)
+                return -1;
+
+        target = ++s;
+        ops->target.raw = strdup(target);
+        if (ops->target.raw == NULL)
+                goto out_free_source;
+
+        ops->target.addr = strtoull(target, &endptr, 16);
+        if (endptr == target)
+                goto out_free_target;
+
+        s = strchr(endptr, '<');
+        if (s == NULL)
+                goto out_free_target;
+        endptr = strchr(s + 1, '>');
+        if (endptr == NULL)
+                goto out_free_target;
+
+        *endptr = '\0';
+        *s = ' ';
+        ops->target.name = strdup(s);
+        *s = '<';
+        *endptr = '>';
+        if (ops->target.name == NULL)
+                goto out_free_target;
+
+        return 0;
+
+out_free_target:
+        zfree(&ops->target.raw);
+out_free_source:
+        zfree(&ops->source.raw);
+        return -1;
+}
+
+static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
+                          struct ins_operands *ops);
+
+static struct ins_ops arm64_mov_ops = {
+        .parse     = arm64_mov__parse,
+        .scnprintf = mov__scnprintf,
+};
+
 static struct ins_ops *arm64__associate_instruction_ops(struct arch *arch, const char *name)
 {
         struct arm64_annotate *arm = arch->priv;
@@ -21,7 +78,7 @@ static struct ins_ops *arm64__associate_instruction_ops(struct arch *arch, const
         else if (!strcmp(name, "ret"))
                 ops = &ret_ops;
         else
-                return NULL;
+                ops = &arm64_mov_ops;
 
         arch__associate_ins_ops(arch, name, ops);
         return ops;
diff --git a/tools/perf/arch/arm64/entry/syscalls/mksyscalltbl b/tools/perf/arch/arm64/entry/syscalls/mksyscalltbl
index 2dbb8cade048..c88fd32563eb 100755
--- a/tools/perf/arch/arm64/entry/syscalls/mksyscalltbl
+++ b/tools/perf/arch/arm64/entry/syscalls/mksyscalltbl
@@ -23,7 +23,7 @@ create_table_from_c()
 {
         local sc nr last_sc
 
-        create_table_exe=`mktemp /tmp/create-table-XXXXXX`
+        create_table_exe=`mktemp ${TMPDIR:-/tmp}/create-table-XXXXXX`
 
         {
 
diff --git a/tools/perf/arch/powerpc/util/book3s_hv_exits.h b/tools/perf/arch/powerpc/util/book3s_hv_exits.h
index 853b95d1e139..2011376c7ab5 100644
--- a/tools/perf/arch/powerpc/util/book3s_hv_exits.h
+++ b/tools/perf/arch/powerpc/util/book3s_hv_exits.h
@@ -15,7 +15,6 @@
         {0x400, "INST_STORAGE"}, \
         {0x480, "INST_SEGMENT"}, \
         {0x500, "EXTERNAL"}, \
-        {0x501, "EXTERNAL_LEVEL"}, \
         {0x502, "EXTERNAL_HV"}, \
         {0x600, "ALIGNMENT"}, \
         {0x700, "PROGRAM"}, \
diff --git a/tools/perf/arch/s390/annotate/instructions.c b/tools/perf/arch/s390/annotate/instructions.c
index cee4e2f7c057..de0dd66dbb48 100644
--- a/tools/perf/arch/s390/annotate/instructions.c
+++ b/tools/perf/arch/s390/annotate/instructions.c
@@ -100,8 +100,6 @@ out_free_source:
         return -1;
 }
 
-static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops);
 
 static struct ins_ops s390_mov_ops = {
         .parse     = s390_mov__parse,
diff --git a/tools/perf/arch/sparc/Makefile b/tools/perf/arch/sparc/Makefile
index 7fbca175099e..275dea7ff59a 100644
--- a/tools/perf/arch/sparc/Makefile
+++ b/tools/perf/arch/sparc/Makefile
@@ -1,3 +1,5 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
 endif
+
+PERF_HAVE_JITDUMP := 1
diff --git a/tools/perf/arch/sparc/annotate/instructions.c b/tools/perf/arch/sparc/annotate/instructions.c
new file mode 100644
index 000000000000..2614c010c235
--- /dev/null
+++ b/tools/perf/arch/sparc/annotate/instructions.c
@@ -0,0 +1,169 @@
+// SPDX-License-Identifier: GPL-2.0
+
+static int is_branch_cond(const char *cond)
+{
+        if (cond[0] == '\0')
+                return 1;
+
+        if (cond[0] == 'a' && cond[1] == '\0')
+                return 1;
+
+        if (cond[0] == 'c' &&
+            (cond[1] == 'c' || cond[1] == 's') &&
+            cond[2] == '\0')
+                return 1;
+
+        if (cond[0] == 'e' &&
+            (cond[1] == '\0' ||
+             (cond[1] == 'q' && cond[2] == '\0')))
+                return 1;
+
+        if (cond[0] == 'g' &&
+            (cond[1] == '\0' ||
+             (cond[1] == 't' && cond[2] == '\0') ||
+             (cond[1] == 'e' && cond[2] == '\0') ||
+             (cond[1] == 'e' && cond[2] == 'u' && cond[3] == '\0')))
+                return 1;
+
+        if (cond[0] == 'l' &&
+            (cond[1] == '\0' ||
+             (cond[1] == 't' && cond[2] == '\0') ||
+             (cond[1] == 'u' && cond[2] == '\0') ||
+             (cond[1] == 'e' && cond[2] == '\0') ||
+             (cond[1] == 'e' && cond[2] == 'u' && cond[3] == '\0')))
+                return 1;
+
+        if (cond[0] == 'n' &&
+            (cond[1] == '\0' ||
+             (cond[1] == 'e' && cond[2] == '\0') ||
+             (cond[1] == 'z' && cond[2] == '\0') ||
+             (cond[1] == 'e' && cond[2] == 'g' && cond[3] == '\0')))
+                return 1;
+
+        if (cond[0] == 'b' &&
+            cond[1] == 'p' &&
+            cond[2] == 'o' &&
+            cond[3] == 's' &&
+            cond[4] == '\0')
+                return 1;
+
+        if (cond[0] == 'v' &&
+            (cond[1] == 'c' || cond[1] == 's') &&
+            cond[2] == '\0')
+                return 1;
+
+        if (cond[0] == 'b' &&
+            cond[1] == 'z' &&
+            cond[2] == '\0')
+                return 1;
+
+        return 0;
+}
+
+static int is_branch_reg_cond(const char *cond)
+{
+        if ((cond[0] == 'n' || cond[0] == 'l') &&
+            cond[1] == 'z' &&
+            cond[2] == '\0')
+                return 1;
+
+        if (cond[0] == 'z' &&
+            cond[1] == '\0')
+                return 1;
+
+        if ((cond[0] == 'g' || cond[0] == 'l') &&
+            cond[1] == 'e' &&
+            cond[2] == 'z' &&
+            cond[3] == '\0')
+                return 1;
+
+        if (cond[0] == 'g' &&
+            cond[1] == 'z' &&
+            cond[2] == '\0')
+                return 1;
+
+        return 0;
+}
+
+static int is_branch_float_cond(const char *cond)
+{
+        if (cond[0] == '\0')
+                return 1;
+
+        if ((cond[0] == 'a' || cond[0] == 'e' ||
+             cond[0] == 'z' || cond[0] == 'g' ||
+             cond[0] == 'l' || cond[0] == 'n' ||
+             cond[0] == 'o' || cond[0] == 'u') &&
+            cond[1] == '\0')
+                return 1;
+
+        if (((cond[0] == 'g' && cond[1] == 'e') ||
+             (cond[0] == 'l' && (cond[1] == 'e' ||
+                                 cond[1] == 'g')) ||
+             (cond[0] == 'n' && (cond[1] == 'e' ||
+                                 cond[1] == 'z')) ||
+             (cond[0] == 'u' && (cond[1] == 'e' ||
+                                 cond[1] == 'g' ||
+                                 cond[1] == 'l'))) &&
+            cond[2] == '\0')
+                return 1;
+
+        if (cond[0] == 'u' &&
+            (cond[1] == 'g' || cond[1] == 'l') &&
+            cond[2] == 'e' &&
+            cond[3] == '\0')
+                return 1;
+
+        return 0;
+}
+
+static struct ins_ops *sparc__associate_instruction_ops(struct arch *arch, const char *name)
+{
+        struct ins_ops *ops = NULL;
+
+        if (!strcmp(name, "call") ||
+            !strcmp(name, "jmp") ||
+            !strcmp(name, "jmpl")) {
+                ops = &call_ops;
+        } else if (!strcmp(name, "ret") ||
+                   !strcmp(name, "retl") ||
+                   !strcmp(name, "return")) {
+                ops = &ret_ops;
+        } else if (!strcmp(name, "mov")) {
+                ops = &mov_ops;
+        } else {
+                if (name[0] == 'c' &&
+                    (name[1] == 'w' || name[1] == 'x'))
+                        name += 2;
+
+                if (name[0] == 'b') {
+                        const char *cond = name + 1;
+
+                        if (cond[0] == 'r') {
+                                if (is_branch_reg_cond(cond + 1))
+                                        ops = &jump_ops;
+                        } else if (is_branch_cond(cond)) {
+                                ops = &jump_ops;
+                        }
+                } else if (name[0] == 'f' && name[1] == 'b') {
+                        if (is_branch_float_cond(name + 2))
+                                ops = &jump_ops;
+                }
+        }
+
+        if (ops)
+                arch__associate_ins_ops(arch, name, ops);
+
+        return ops;
+}
+
+static int sparc__annotate_init(struct arch *arch, char *cpuid __maybe_unused)
+{
+        if (!arch->initialized) {
+                arch->initialized = true;
+                arch->associate_instruction_ops = sparc__associate_instruction_ops;
+                arch->objdump.comment_char = '#';
+        }
+
+        return 0;
+}
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 830481b8db26..93d679eaf1f4 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -283,12 +283,11 @@ out_put:
         return ret;
 }
 
-static int process_feature_event(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+static int process_feature_event(struct perf_session *session,
+                                 union perf_event *event)
 {
         if (event->feat.feat_id < HEADER_LAST_FEATURE)
-                return perf_event__process_feature(tool, event, session);
+                return perf_event__process_feature(session, event);
         return 0;
 }
 
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index a3b346359ba0..eda41673c4f3 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -86,12 +86,10 @@ static int perf_event__drop_oe(struct perf_tool *tool __maybe_unused,
 }
 #endif
 
-static int perf_event__repipe_op2_synth(struct perf_tool *tool,
-                                        union perf_event *event,
-                                        struct perf_session *session
-                                        __maybe_unused)
+static int perf_event__repipe_op2_synth(struct perf_session *session,
+                                        union perf_event *event)
 {
-        return perf_event__repipe_synth(tool, event);
+        return perf_event__repipe_synth(session->tool, event);
 }
 
 static int perf_event__repipe_attr(struct perf_tool *tool,
@@ -133,10 +131,10 @@ static int copy_bytes(struct perf_inject *inject, int fd, off_t size)
         return 0;
 }
 
-static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
-                                       union perf_event *event,
-                                       struct perf_session *session)
+static s64 perf_event__repipe_auxtrace(struct perf_session *session,
+                                       union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_inject *inject = container_of(tool, struct perf_inject,
                                                   tool);
         int ret;
@@ -174,9 +172,8 @@ static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
 #else
 
 static s64
-perf_event__repipe_auxtrace(struct perf_tool *tool __maybe_unused,
-                            union perf_event *event __maybe_unused,
-                            struct perf_session *session __maybe_unused)
+perf_event__repipe_auxtrace(struct perf_session *session __maybe_unused,
+                            union perf_event *event __maybe_unused)
 {
         pr_err("AUX area tracing not supported\n");
         return -EINVAL;
@@ -362,26 +359,24 @@ static int perf_event__repipe_exit(struct perf_tool *tool,
         return err;
 }
 
-static int perf_event__repipe_tracing_data(struct perf_tool *tool,
-                                           union perf_event *event,
-                                           struct perf_session *session)
+static int perf_event__repipe_tracing_data(struct perf_session *session,
+                                           union perf_event *event)
 {
         int err;
 
-        perf_event__repipe_synth(tool, event);
-        err = perf_event__process_tracing_data(tool, event, session);
+        perf_event__repipe_synth(session->tool, event);
+        err = perf_event__process_tracing_data(session, event);
 
         return err;
 }
 
-static int perf_event__repipe_id_index(struct perf_tool *tool,
-                                       union perf_event *event,
-                                       struct perf_session *session)
+static int perf_event__repipe_id_index(struct perf_session *session,
+                                       union perf_event *event)
 {
         int err;
 
-        perf_event__repipe_synth(tool, event);
-        err = perf_event__process_id_index(tool, event, session);
+        perf_event__repipe_synth(session->tool, event);
+        err = perf_event__process_id_index(session, event);
 
         return err;
 }
@@ -803,7 +798,8 @@ int cmd_inject(int argc, const char **argv)
                            "kallsyms pathname"),
                 OPT_BOOLEAN('f', "force", &data.force, "don't complain, do it"),
                 OPT_CALLBACK_OPTARG(0, "itrace", &inject.itrace_synth_opts,
-                                    NULL, "opts", "Instruction Tracing options",
+                                    NULL, "opts", "Instruction Tracing options\n"
+                                    ITRACE_HELP,
                                     itrace_parse_synth_opts),
                 OPT_BOOLEAN(0, "strip", &inject.strip,
                             "strip non-synthesized events (use with --itrace)"),
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 22ebeb92ac51..10cf889c6d75 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -106,9 +106,12 @@ static bool switch_output_time(struct record *rec)
                trigger_is_ready(&switch_output_trigger);
 }
 
-static int record__write(struct record *rec, void *bf, size_t size)
+static int record__write(struct record *rec, struct perf_mmap *map __maybe_unused,
+                         void *bf, size_t size)
 {
-        if (perf_data__write(rec->session->data, bf, size) < 0) {
+        struct perf_data_file *file = &rec->session->data->file;
+
+        if (perf_data_file__write(file, bf, size) < 0) {
                 pr_err("failed to write perf data, error: %m\n");
                 return -1;
         }
@@ -127,15 +130,15 @@ static int process_synthesized_event(struct perf_tool *tool,
                                      struct machine *machine __maybe_unused)
 {
         struct record *rec = container_of(tool, struct record, tool);
-        return record__write(rec, event, event->header.size);
+        return record__write(rec, NULL, event, event->header.size);
 }
 
-static int record__pushfn(void *to, void *bf, size_t size)
+static int record__pushfn(struct perf_mmap *map, void *to, void *bf, size_t size)
 {
         struct record *rec = to;
 
         rec->samples++;
-        return record__write(rec, bf, size);
+        return record__write(rec, map, bf, size);
 }
 
 static volatile int done;
@@ -170,6 +173,7 @@ static void record__sig_exit(void)
 #ifdef HAVE_AUXTRACE_SUPPORT
 
 static int record__process_auxtrace(struct perf_tool *tool,
+                                    struct perf_mmap *map,
                                     union perf_event *event, void *data1,
                                     size_t len1, void *data2, size_t len2)
 {
@@ -197,21 +201,21 @@ static int record__process_auxtrace(struct perf_tool *tool,
         if (padding)
                 padding = 8 - padding;
 
-        record__write(rec, event, event->header.size);
-        record__write(rec, data1, len1);
+        record__write(rec, map, event, event->header.size);
+        record__write(rec, map, data1, len1);
         if (len2)
-                record__write(rec, data2, len2);
-        record__write(rec, &pad, padding);
+                record__write(rec, map, data2, len2);
+        record__write(rec, map, &pad, padding);
 
         return 0;
 }
 
 static int record__auxtrace_mmap_read(struct record *rec,
-                                      struct auxtrace_mmap *mm)
+                                      struct perf_mmap *map)
 {
         int ret;
 
-        ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
+        ret = auxtrace_mmap__read(map, rec->itr, &rec->tool,
                                   record__process_auxtrace);
         if (ret < 0)
                 return ret;
@@ -223,11 +227,11 @@ static int record__auxtrace_mmap_read(struct record *rec,
 }
 
 static int record__auxtrace_mmap_read_snapshot(struct record *rec,
-                                               struct auxtrace_mmap *mm)
+                                               struct perf_mmap *map)
 {
         int ret;
 
-        ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
+        ret = auxtrace_mmap__read_snapshot(map, rec->itr, &rec->tool,
                                            record__process_auxtrace,
                                            rec->opts.auxtrace_snapshot_size);
         if (ret < 0)
@@ -245,13 +249,12 @@ static int record__auxtrace_read_snapshot_all(struct record *rec)
         int rc = 0;
 
         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
-                struct auxtrace_mmap *mm =
-                                &rec->evlist->mmap[i].auxtrace_mmap;
+                struct perf_mmap *map = &rec->evlist->mmap[i];
 
-                if (!mm->base)
+                if (!map->auxtrace_mmap.base)
                         continue;
 
-                if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
+                if (record__auxtrace_mmap_read_snapshot(rec, map) != 0) {
                         rc = -1;
                         goto out;
                 }
@@ -295,7 +298,7 @@ static int record__auxtrace_init(struct record *rec)
 
 static inline
 int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
-                               struct auxtrace_mmap *mm __maybe_unused)
+                               struct perf_mmap *map __maybe_unused)
 {
         return 0;
 }
@@ -529,17 +532,17 @@ static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evli
                 return 0;
 
         for (i = 0; i < evlist->nr_mmaps; i++) {
-                struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
+                struct perf_mmap *map = &maps[i];
 
-                if (maps[i].base) {
-                        if (perf_mmap__push(&maps[i], rec, record__pushfn) != 0) {
+                if (map->base) {
+                        if (perf_mmap__push(map, rec, record__pushfn) != 0) {
                                 rc = -1;
                                 goto out;
                         }
                 }
 
-                if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
-                    record__auxtrace_mmap_read(rec, mm) != 0) {
+                if (map->auxtrace_mmap.base && !rec->opts.auxtrace_snapshot_mode &&
+                    record__auxtrace_mmap_read(rec, map) != 0) {
                         rc = -1;
                         goto out;
                 }
@@ -550,7 +553,7 @@ static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evli
          * at least one event.
          */
         if (bytes_written != rec->bytes_written)
-                rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
+                rc = record__write(rec, NULL, &finished_round_event, sizeof(finished_round_event));
 
         if (overwrite)
                 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
@@ -589,6 +592,9 @@ static void record__init_features(struct record *rec)
         if (!rec->opts.full_auxtrace)
                 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
 
+        if (!(rec->opts.use_clockid && rec->opts.clockid_res_ns))
+                perf_header__clear_feat(&session->header, HEADER_CLOCKID);
+
         perf_header__clear_feat(&session->header, HEADER_STAT);
 }
 
@@ -758,7 +764,7 @@ static int record__synthesize(struct record *rec, bool tail)
                  * We need to synthesize events first, because some
                  * features works on top of them (on report side).
                  */
-                err = perf_event__synthesize_attrs(tool, session,
+                err = perf_event__synthesize_attrs(tool, rec->evlist,
                                                    process_synthesized_event);
                 if (err < 0) {
                         pr_err("Couldn't synthesize attrs.\n");
@@ -894,6 +900,9 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
 
         record__init_features(rec);
 
+        if (rec->opts.use_clockid && rec->opts.clockid_res_ns)
+                session->header.env.clockid_res_ns = rec->opts.clockid_res_ns;
+
         if (forks) {
                 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
                                                     argv, data->is_pipe,
@@ -1334,6 +1343,19 @@ static const struct clockid_map clockids[] = {
         CLOCKID_END,
 };
 
+static int get_clockid_res(clockid_t clk_id, u64 *res_ns)
+{
+        struct timespec res;
+
+        *res_ns = 0;
+        if (!clock_getres(clk_id, &res))
+                *res_ns = res.tv_nsec + res.tv_sec * NSEC_PER_SEC;
+        else
+                pr_warning("WARNING: Failed to determine specified clock resolution.\n");
+
+        return 0;
+}
+
 static int parse_clockid(const struct option *opt, const char *str, int unset)
 {
         struct record_opts *opts = (struct record_opts *)opt->value;
@@ -1357,7 +1379,7 @@ static int parse_clockid(const struct option *opt, const char *str, int unset)
 
         /* if its a number, we're done */
         if (sscanf(str, "%d", &opts->clockid) == 1)
-                return 0;
+                return get_clockid_res(opts->clockid, &opts->clockid_res_ns);
 
         /* allow a "CLOCK_" prefix to the name */
         if (!strncasecmp(str, "CLOCK_", 6))
@@ -1366,7 +1388,8 @@ static int parse_clockid(const struct option *opt, const char *str, int unset)
         for (cm = clockids; cm->name; cm++) {
                 if (!strcasecmp(str, cm->name)) {
                         opts->clockid = cm->clockid;
-                        return 0;
+                        return get_clockid_res(opts->clockid,
+                                               &opts->clockid_res_ns);
                 }
         }
 
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 76e12bcd1765..257c9c18cb7e 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -201,14 +201,13 @@ static void setup_forced_leader(struct report *report,
                 perf_evlist__force_leader(evlist);
 }
 
-static int process_feature_event(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session __maybe_unused)
+static int process_feature_event(struct perf_session *session,
+                                 union perf_event *event)
 {
-        struct report *rep = container_of(tool, struct report, tool);
+        struct report *rep = container_of(session->tool, struct report, tool);
 
         if (event->feat.feat_id < HEADER_LAST_FEATURE)
-                return perf_event__process_feature(tool, event, session);
+                return perf_event__process_feature(session, event);
 
         if (event->feat.feat_id != HEADER_LAST_FEATURE) {
                 pr_err("failed: wrong feature ID: %" PRIu64 "\n",
@@ -981,6 +980,7 @@ int cmd_report(int argc, const char **argv)
                         .id_index        = perf_event__process_id_index,
                         .auxtrace_info   = perf_event__process_auxtrace_info,
                         .auxtrace        = perf_event__process_auxtrace,
+                        .event_update    = perf_event__process_event_update,
                         .feature         = process_feature_event,
                         .ordered_events  = true,
                         .ordering_requires_timestamps = true,
@@ -1105,7 +1105,7 @@ int cmd_report(int argc, const char **argv)
         OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
                      "how to display percentage of filtered entries", parse_filter_percentage),
         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
-                            "Instruction Tracing options",
+                            "Instruction Tracing options\n" ITRACE_HELP,
                             itrace_parse_synth_opts),
         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
                         "Show full source file name path for source lines"),
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index ba481d73f910..b5bc85bd0bbe 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -44,6 +44,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <subcmd/pager.h>
 
 #include "sane_ctype.h"
 
@@ -406,9 +407,10 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                                         PERF_OUTPUT_WEIGHT))
                 return -EINVAL;
 
-        if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
+        if (PRINT_FIELD(SYM) &&
+                !(evsel->attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
                 pr_err("Display of symbols requested but neither sample IP nor "
-                           "sample address\nis selected. Hence, no addresses to convert "
+                           "sample address\navailable. Hence, no addresses to convert "
                        "to symbols.\n");
                 return -EINVAL;
         }
@@ -417,10 +419,9 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                        "selected.\n");
                 return -EINVAL;
         }
-        if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR) &&
-            !PRINT_FIELD(BRSTACK) && !PRINT_FIELD(BRSTACKSYM) && !PRINT_FIELD(BRSTACKOFF)) {
-                pr_err("Display of DSO requested but no address to convert.  Select\n"
-                       "sample IP, sample address, brstack, brstacksym, or brstackoff.\n");
+        if (PRINT_FIELD(DSO) &&
+                !(evsel->attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
+                pr_err("Display of DSO requested but no address to convert.\n");
                 return -EINVAL;
         }
         if (PRINT_FIELD(SRCLINE) && !PRINT_FIELD(IP)) {
@@ -912,7 +913,7 @@ static int grab_bb(u8 *buffer, u64 start, u64 end,
 
 static int ip__fprintf_jump(uint64_t ip, struct branch_entry *en,
                             struct perf_insn *x, u8 *inbuf, int len,
-                            int insn, FILE *fp)
+                            int insn, FILE *fp, int *total_cycles)
 {
         int printed = fprintf(fp, "\t%016" PRIx64 "\t%-30s\t#%s%s%s%s", ip,
                               dump_insn(x, ip, inbuf, len, NULL),
@@ -921,7 +922,8 @@ static int ip__fprintf_jump(uint64_t ip, struct branch_entry *en,
                               en->flags.in_tx ? " INTX" : "",
                               en->flags.abort ? " ABORT" : "");
         if (en->flags.cycles) {
-                printed += fprintf(fp, " %d cycles", en->flags.cycles);
+                *total_cycles += en->flags.cycles;
+                printed += fprintf(fp, " %d cycles [%d]", en->flags.cycles, *total_cycles);
                 if (insn)
                         printed += fprintf(fp, " %.2f IPC", (float)insn / en->flags.cycles);
         }
@@ -978,6 +980,7 @@ static int perf_sample__fprintf_brstackinsn(struct perf_sample *sample,
         u8 buffer[MAXBB];
         unsigned off;
         struct symbol *lastsym = NULL;
+        int total_cycles = 0;
 
         if (!(br && br->nr))
                 return 0;
@@ -998,7 +1001,7 @@ static int perf_sample__fprintf_brstackinsn(struct perf_sample *sample,
                 printed += ip__fprintf_sym(br->entries[nr - 1].from, thread,
                                            x.cpumode, x.cpu, &lastsym, attr, fp);
                 printed += ip__fprintf_jump(br->entries[nr - 1].from, &br->entries[nr - 1],
-                                            &x, buffer, len, 0, fp);
+                                            &x, buffer, len, 0, fp, &total_cycles);
         }
 
         /* Print all blocks */
@@ -1026,7 +1029,8 @@ static int perf_sample__fprintf_brstackinsn(struct perf_sample *sample,
 
                         printed += ip__fprintf_sym(ip, thread, x.cpumode, x.cpu, &lastsym, attr, fp);
                         if (ip == end) {
-                                printed += ip__fprintf_jump(ip, &br->entries[i], &x, buffer + off, len - off, insn, fp);
+                                printed += ip__fprintf_jump(ip, &br->entries[i], &x, buffer + off, len - off, insn, fp,
+                                                            &total_cycles);
                                 break;
                         } else {
                                 printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", ip,
@@ -1104,6 +1108,35 @@ out:
         return printed;
 }
 
+static const char *resolve_branch_sym(struct perf_sample *sample,
+                                      struct perf_evsel *evsel,
+                                      struct thread *thread,
+                                      struct addr_location *al,
+                                      u64 *ip)
+{
+        struct addr_location addr_al;
+        struct perf_event_attr *attr = &evsel->attr;
+        const char *name = NULL;
+
+        if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
+                if (sample_addr_correlates_sym(attr)) {
+                        thread__resolve(thread, &addr_al, sample);
+                        if (addr_al.sym)
+                                name = addr_al.sym->name;
+                        else
+                                *ip = sample->addr;
+                } else {
+                        *ip = sample->addr;
+                }
+        } else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
+                if (al->sym)
+                        name = al->sym->name;
+                else
+                        *ip = sample->ip;
+        }
+        return name;
+}
+
 static int perf_sample__fprintf_callindent(struct perf_sample *sample,
                                            struct perf_evsel *evsel,
                                            struct thread *thread,
@@ -1111,10 +1144,10 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample,
 {
         struct perf_event_attr *attr = &evsel->attr;
         size_t depth = thread_stack__depth(thread);
-        struct addr_location addr_al;
         const char *name = NULL;
         static int spacing;
         int len = 0;
+        int dlen = 0;
         u64 ip = 0;
 
         /*
@@ -1124,21 +1157,12 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample,
         if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN)
                 depth += 1;
 
-        if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
-                if (sample_addr_correlates_sym(attr)) {
-                        thread__resolve(thread, &addr_al, sample);
-                        if (addr_al.sym)
-                                name = addr_al.sym->name;
-                        else
-                                ip = sample->addr;
-                } else {
-                        ip = sample->addr;
-                }
-        } else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
-                if (al->sym)
-                        name = al->sym->name;
-                else
-                        ip = sample->ip;
+        name = resolve_branch_sym(sample, evsel, thread, al, &ip);
+
+        if (PRINT_FIELD(DSO) && !(PRINT_FIELD(IP) || PRINT_FIELD(ADDR))) {
+                dlen += fprintf(fp, "(");
+                dlen += map__fprintf_dsoname(al->map, fp);
+                dlen += fprintf(fp, ")\t");
         }
 
         if (name)
@@ -1159,7 +1183,7 @@ static int perf_sample__fprintf_callindent(struct perf_sample *sample,
         if (len < spacing)
                 len += fprintf(fp, "%*s", spacing - len, "");
 
-        return len;
+        return len + dlen;
 }
 
 static int perf_sample__fprintf_insn(struct perf_sample *sample,
@@ -1255,6 +1279,18 @@ static struct {
         {0, NULL}
 };
 
+static const char *sample_flags_to_name(u32 flags)
+{
+        int i;
+
+        for (i = 0; sample_flags[i].name ; i++) {
+                if (sample_flags[i].flags == flags)
+                        return sample_flags[i].name;
+        }
+
+        return NULL;
+}
+
 static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
 {
         const char *chars = PERF_IP_FLAG_CHARS;
@@ -1264,11 +1300,20 @@ static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
         char str[33];
         int i, pos = 0;
 
-        for (i = 0; sample_flags[i].name ; i++) {
-                if (sample_flags[i].flags == (flags & ~PERF_IP_FLAG_IN_TX)) {
-                        name = sample_flags[i].name;
-                        break;
-                }
+        name = sample_flags_to_name(flags & ~PERF_IP_FLAG_IN_TX);
+        if (name)
+                return fprintf(fp, "  %-15s%4s ", name, in_tx ? "(x)" : "");
+
+        if (flags & PERF_IP_FLAG_TRACE_BEGIN) {
+                name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_BEGIN));
+                if (name)
+                        return fprintf(fp, "  tr strt %-7s%4s ", name, in_tx ? "(x)" : "");
+        }
+
+        if (flags & PERF_IP_FLAG_TRACE_END) {
+                name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_END));
+                if (name)
+                        return fprintf(fp, "  tr end  %-7s%4s ", name, in_tx ? "(x)" : "");
         }
 
         for (i = 0; i < n; i++, flags >>= 1) {
@@ -1281,10 +1326,7 @@ static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
         }
         str[pos] = 0;
 
-        if (name)
-                return fprintf(fp, "  %-7s%4s ", name, in_tx ? "(x)" : "");
-
-        return fprintf(fp, "  %-11s ", str);
+        return fprintf(fp, "  %-19s ", str);
 }
 
 struct printer_data {
@@ -1544,7 +1586,8 @@ struct metric_ctx {
         FILE                    *fp;
 };
 
-static void script_print_metric(void *ctx, const char *color,
+static void script_print_metric(struct perf_stat_config *config __maybe_unused,
+                                void *ctx, const char *color,
                                 const char *fmt,
                                 const char *unit, double val)
 {
@@ -1562,7 +1605,8 @@ static void script_print_metric(void *ctx, const char *color,
         fprintf(mctx->fp, " %s\n", unit);
 }
 
-static void script_new_line(void *ctx)
+static void script_new_line(struct perf_stat_config *config __maybe_unused,
+                            void *ctx)
 {
         struct metric_ctx *mctx = ctx;
 
@@ -1608,7 +1652,7 @@ static void perf_sample__fprint_metric(struct perf_script *script,
         evsel_script(evsel)->val = val;
         if (evsel_script(evsel->leader)->gnum == evsel->leader->nr_members) {
                 for_each_group_member (ev2, evsel->leader) {
-                        perf_stat__print_shadow_stats(ev2,
+                        perf_stat__print_shadow_stats(&stat_config, ev2,
                                                       evsel_script(ev2)->val,
                                                       sample->cpu,
                                                       &ctx,
@@ -1619,6 +1663,47 @@ static void perf_sample__fprint_metric(struct perf_script *script,
         }
 }
 
+static bool show_event(struct perf_sample *sample,
+                       struct perf_evsel *evsel,
+                       struct thread *thread,
+                       struct addr_location *al)
+{
+        int depth = thread_stack__depth(thread);
+
+        if (!symbol_conf.graph_function)
+                return true;
+
+        if (thread->filter) {
+                if (depth <= thread->filter_entry_depth) {
+                        thread->filter = false;
+                        return false;
+                }
+                return true;
+        } else {
+                const char *s = symbol_conf.graph_function;
+                u64 ip;
+                const char *name = resolve_branch_sym(sample, evsel, thread, al,
+                                &ip);
+                unsigned nlen;
+
+                if (!name)
+                        return false;
+                nlen = strlen(name);
+                while (*s) {
+                        unsigned len = strcspn(s, ",");
+                        if (nlen == len && !strncmp(name, s, len)) {
+                                thread->filter = true;
+                                thread->filter_entry_depth = depth;
+                                return true;
+                        }
+                        s += len;
+                        if (*s == ',')
+                                s++;
+                }
+                return false;
+        }
+}
+
 static void process_event(struct perf_script *script,
                           struct perf_sample *sample, struct perf_evsel *evsel,
                           struct addr_location *al,
@@ -1633,6 +1718,9 @@ static void process_event(struct perf_script *script,
         if (output[type].fields == 0)
                 return;
 
+        if (!show_event(sample, evsel, thread, al))
+                return;
+
         ++es->samples;
 
         perf_sample__fprintf_start(sample, thread, evsel,
@@ -1710,6 +1798,9 @@ static void process_event(struct perf_script *script,
 
         if (PRINT_FIELD(METRIC))
                 perf_sample__fprint_metric(script, thread, evsel, sample, fp);
+
+        if (verbose)
+                fflush(fp);
 }
 
 static struct scripting_ops     *scripting_ops;
@@ -2489,6 +2580,8 @@ parse:
                                                 output[j].fields &= ~all_output_options[i].field;
                                         else
                                                 output[j].fields |= all_output_options[i].field;
+                                        output[j].user_set = true;
+                                        output[j].wildcard_set = true;
                                 }
                         }
                 } else {
@@ -2499,7 +2592,8 @@ parse:
                                 rc = -EINVAL;
                                 goto out;
                         }
-                        output[type].fields |= all_output_options[i].field;
+                        output[type].user_set = true;
+                        output[type].wildcard_set = true;
                 }
         }
 
@@ -2963,9 +3057,8 @@ static void script__setup_sample_type(struct perf_script *script)
         }
 }
 
-static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
-                                    union perf_event *event,
-                                    struct perf_session *session)
+static int process_stat_round_event(struct perf_session *session,
+                                    union perf_event *event)
 {
         struct stat_round_event *round = &event->stat_round;
         struct perf_evsel *counter;
@@ -2979,9 +3072,8 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_stat_config_event(struct perf_tool *tool __maybe_unused,
-                                     union perf_event *event,
-                                     struct perf_session *session __maybe_unused)
+static int process_stat_config_event(struct perf_session *session __maybe_unused,
+                                     union perf_event *event)
 {
         perf_event__read_stat_config(&stat_config, &event->stat_config);
         return 0;
@@ -3007,10 +3099,10 @@ static int set_maps(struct perf_script *script)
 }
 
 static
-int process_thread_map_event(struct perf_tool *tool,
-                             union perf_event *event,
-                             struct perf_session *session __maybe_unused)
+int process_thread_map_event(struct perf_session *session,
+                             union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_script *script = container_of(tool, struct perf_script, tool);
 
         if (script->threads) {
@@ -3026,10 +3118,10 @@ int process_thread_map_event(struct perf_tool *tool,
 }
 
 static
-int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
-                          union perf_event *event,
-                          struct perf_session *session __maybe_unused)
+int process_cpu_map_event(struct perf_session *session,
+                          union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_script *script = container_of(tool, struct perf_script, tool);
 
         if (script->cpus) {
@@ -3044,21 +3136,21 @@ int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
         return set_maps(script);
 }
 
-static int process_feature_event(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+static int process_feature_event(struct perf_session *session,
+                                 union perf_event *event)
 {
         if (event->feat.feat_id < HEADER_LAST_FEATURE)
-                return perf_event__process_feature(tool, event, session);
+                return perf_event__process_feature(session, event);
         return 0;
 }
 
 #ifdef HAVE_AUXTRACE_SUPPORT
-static int perf_script__process_auxtrace_info(struct perf_tool *tool,
-                                              union perf_event *event,
-                                              struct perf_session *session)
+static int perf_script__process_auxtrace_info(struct perf_session *session,
+                                              union perf_event *event)
 {
-        int ret = perf_event__process_auxtrace_info(tool, event, session);
+        struct perf_tool *tool = session->tool;
+
+        int ret = perf_event__process_auxtrace_info(session, event);
 
         if (ret == 0) {
                 struct perf_script *script = container_of(tool, struct perf_script, tool);
@@ -3072,6 +3164,44 @@ static int perf_script__process_auxtrace_info(struct perf_tool *tool,
 #define perf_script__process_auxtrace_info 0
 #endif
 
+static int parse_insn_trace(const struct option *opt __maybe_unused,
+                            const char *str __maybe_unused,
+                            int unset __maybe_unused)
+{
+        parse_output_fields(NULL, "+insn,-event,-period", 0);
+        itrace_parse_synth_opts(opt, "i0ns", 0);
+        nanosecs = true;
+        return 0;
+}
+
+static int parse_xed(const struct option *opt __maybe_unused,
+                     const char *str __maybe_unused,
+                     int unset __maybe_unused)
+{
+        force_pager("xed -F insn: -A -64 | less");
+        return 0;
+}
+
+static int parse_call_trace(const struct option *opt __maybe_unused,
+                            const char *str __maybe_unused,
+                            int unset __maybe_unused)
+{
+        parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent", 0);
+        itrace_parse_synth_opts(opt, "cewp", 0);
+        nanosecs = true;
+        return 0;
+}
+
+static int parse_callret_trace(const struct option *opt __maybe_unused,
+                            const char *str __maybe_unused,
+                            int unset __maybe_unused)
+{
+        parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent,+flags", 0);
+        itrace_parse_synth_opts(opt, "crewp", 0);
+        nanosecs = true;
+        return 0;
+}
+
 int cmd_script(int argc, const char **argv)
 {
         bool show_full_info = false;
@@ -3081,7 +3211,10 @@ int cmd_script(int argc, const char **argv)
         char *rec_script_path = NULL;
         char *rep_script_path = NULL;
         struct perf_session *session;
-        struct itrace_synth_opts itrace_synth_opts = { .set = false, };
+        struct itrace_synth_opts itrace_synth_opts = {
+                .set = false,
+                .default_no_sample = true,
+        };
         char *script_path = NULL;
         const char **__argv;
         int i, j, err = 0;
@@ -3156,6 +3289,16 @@ int cmd_script(int argc, const char **argv)
                     "system-wide collection from all CPUs"),
         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
                    "only consider these symbols"),
+        OPT_CALLBACK_OPTARG(0, "insn-trace", &itrace_synth_opts, NULL, NULL,
+                        "Decode instructions from itrace", parse_insn_trace),
+        OPT_CALLBACK_OPTARG(0, "xed", NULL, NULL, NULL,
+                        "Run xed disassembler on output", parse_xed),
+        OPT_CALLBACK_OPTARG(0, "call-trace", &itrace_synth_opts, NULL, NULL,
+                        "Decode calls from from itrace", parse_call_trace),
+        OPT_CALLBACK_OPTARG(0, "call-ret-trace", &itrace_synth_opts, NULL, NULL,
+                        "Decode calls and returns from itrace", parse_callret_trace),
+        OPT_STRING(0, "graph-function", &symbol_conf.graph_function, "symbol[,symbol...]",
+                        "Only print symbols and callees with --call-trace/--call-ret-trace"),
         OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
                    "Stop display of callgraph at these symbols"),
         OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
@@ -3193,7 +3336,7 @@ int cmd_script(int argc, const char **argv)
         OPT_BOOLEAN(0, "ns", &nanosecs,
                     "Use 9 decimal places when displaying time"),
         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
-                            "Instruction Tracing options",
+                            "Instruction Tracing options\n" ITRACE_HELP,
                             itrace_parse_synth_opts),
         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
                         "Show full source file name path for source lines"),
@@ -3389,8 +3532,10 @@ int cmd_script(int argc, const char **argv)
                 exit(-1);
         }
 
-        if (!script_name)
+        if (!script_name) {
                 setup_pager();
+                use_browser = 0;
+        }
 
         session = perf_session__new(&data, false, &script.tool);
         if (session == NULL)
@@ -3411,7 +3556,8 @@ int cmd_script(int argc, const char **argv)
         script.session = session;
         script__setup_sample_type(&script);
 
-        if (output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT)
+        if ((output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT) ||
+            symbol_conf.graph_function)
                 itrace_synth_opts.thread_stack = true;
 
         session->itrace_synth_opts = &itrace_synth_opts;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index d097b5b47eb8..d1028d7755bb 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -88,8 +88,6 @@
 #include "sane_ctype.h"
 
 #define DEFAULT_SEPARATOR       " "
-#define CNTR_NOT_SUPPORTED      "<not supported>"
-#define CNTR_NOT_COUNTED        "<not counted>"
 #define FREEZE_ON_SMI_PATH      "devices/cpu/freeze_on_smi"
 
 static void print_counters(struct timespec *ts, int argc, const char **argv);
@@ -137,54 +135,30 @@ static const char *smi_cost_attrs = {
 
 static struct perf_evlist       *evsel_list;
 
-static struct rblist             metric_events;
-
 static struct target target = {
         .uid    = UINT_MAX,
 };
 
-typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu);
-
 #define METRIC_ONLY_LEN 20
 
-static int                      run_count                       =  1;
-static bool                     no_inherit                      = false;
 static volatile pid_t           child_pid                       = -1;
-static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
 static bool                     transaction_run;
 static bool                     topdown_run                     = false;
 static bool                     smi_cost                        = false;
 static bool                     smi_reset                       = false;
-static bool                     big_num                         =  true;
 static int                      big_num_opt                     =  -1;
-static const char               *csv_sep                        = NULL;
-static bool                     csv_output                      = false;
 static bool                     group                           = false;
 static const char               *pre_cmd                        = NULL;
 static const char               *post_cmd                       = NULL;
 static bool                     sync_run                        = false;
-static unsigned int             initial_delay                   = 0;
-static unsigned int             unit_width                      = 4; /* strlen("unit") */
 static bool                     forever                         = false;
-static bool                     metric_only                     = false;
 static bool                     force_metric_only               = false;
-static bool                     no_merge                        = false;
-static bool                     walltime_run_table              = false;
 static struct timespec          ref_time;
-static struct cpu_map           *aggr_map;
-static aggr_get_id_t            aggr_get_id;
 static bool                     append_file;
 static bool                     interval_count;
-static bool                     interval_clear;
 static const char               *output_name;
 static int                      output_fd;
-static int                      print_free_counters_hint;
-static int                      print_mixed_hw_group_error;
-static u64                      *walltime_run;
-static bool                     ru_display                      = false;
-static struct rusage            ru_data;
-static unsigned int             metric_only_len                 = METRIC_ONLY_LEN;
 
 struct perf_stat {
         bool                     record;
@@ -204,15 +178,15 @@ static struct perf_stat		perf_stat;
 static volatile int done = 0;
 
 static struct perf_stat_config stat_config = {
-        .aggr_mode      = AGGR_GLOBAL,
-        .scale          = true,
+        .aggr_mode              = AGGR_GLOBAL,
+        .scale                  = true,
+        .unit_width             = 4, /* strlen("unit") */
+        .run_count              = 1,
+        .metric_only_len        = METRIC_ONLY_LEN,
+        .walltime_nsecs_stats   = &walltime_nsecs_stats,
+        .big_num                = true,
 };
 
-static bool is_duration_time(struct perf_evsel *evsel)
-{
-        return !strcmp(evsel->name, "duration_time");
-}
-
 static inline void diff_timespec(struct timespec *r, struct timespec *a,
                                  struct timespec *b)
 {
@@ -236,66 +210,6 @@ static void perf_stat__reset_stats(void)
                 perf_stat__reset_shadow_per_stat(&stat_config.stats[i]);
 }
 
-static int create_perf_stat_counter(struct perf_evsel *evsel)
-{
-        struct perf_event_attr *attr = &evsel->attr;
-        struct perf_evsel *leader = evsel->leader;
-
-        if (stat_config.scale) {
-                attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
-                                    PERF_FORMAT_TOTAL_TIME_RUNNING;
-        }
-
-        /*
-         * The event is part of non trivial group, let's enable
-         * the group read (for leader) and ID retrieval for all
-         * members.
-         */
-        if (leader->nr_members > 1)
-                attr->read_format |= PERF_FORMAT_ID|PERF_FORMAT_GROUP;
-
-        attr->inherit = !no_inherit;
-
-        /*
-         * Some events get initialized with sample_(period/type) set,
-         * like tracepoints. Clear it up for counting.
-         */
-        attr->sample_period = 0;
-
-        /*
-         * But set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
-         * while avoiding that older tools show confusing messages.
-         *
-         * However for pipe sessions we need to keep it zero,
-         * because script's perf_evsel__check_attr is triggered
-         * by attr->sample_type != 0, and we can't run it on
-         * stat sessions.
-         */
-        if (!(STAT_RECORD && perf_stat.data.is_pipe))
-                attr->sample_type = PERF_SAMPLE_IDENTIFIER;
-
-        /*
-         * Disabling all counters initially, they will be enabled
-         * either manually by us or by kernel via enable_on_exec
-         * set later.
-         */
-        if (perf_evsel__is_group_leader(evsel)) {
-                attr->disabled = 1;
-
-                /*
-                 * In case of initial_delay we enable tracee
-                 * events manually.
-                 */
-                if (target__none(&target) && !initial_delay)
-                        attr->enable_on_exec = 1;
-        }
-
-        if (target__has_cpu(&target) && !target__has_per_thread(&target))
-                return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
-
-        return perf_evsel__open_per_thread(evsel, evsel_list->threads);
-}
-
 static int process_synthesized_event(struct perf_tool *tool __maybe_unused,
                                      union perf_event *event,
                                      struct perf_sample *sample __maybe_unused,
@@ -428,15 +342,15 @@ static void process_interval(void)
 
 static void enable_counters(void)
 {
-        if (initial_delay)
-                usleep(initial_delay * USEC_PER_MSEC);
+        if (stat_config.initial_delay)
+                usleep(stat_config.initial_delay * USEC_PER_MSEC);
 
         /*
          * We need to enable counters only if:
          * - we don't have tracee (attaching to task or cpu)
          * - we have initial delay configured
          */
-        if (!target__none(&target) || initial_delay)
+        if (!target__none(&target) || stat_config.initial_delay)
                 perf_evlist__enable(evsel_list);
 }
 
@@ -464,80 +378,6 @@ static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *inf
         workload_exec_errno = info->si_value.sival_int;
 }
 
-static int perf_stat_synthesize_config(bool is_pipe)
-{
-        int err;
-
-        if (is_pipe) {
-                err = perf_event__synthesize_attrs(NULL, perf_stat.session,
-                                                   process_synthesized_event);
-                if (err < 0) {
-                        pr_err("Couldn't synthesize attrs.\n");
-                        return err;
-                }
-        }
-
-        err = perf_event__synthesize_extra_attr(NULL,
-                                                evsel_list,
-                                                process_synthesized_event,
-                                                is_pipe);
-
-        err = perf_event__synthesize_thread_map2(NULL, evsel_list->threads,
-                                                process_synthesized_event,
-                                                NULL);
-        if (err < 0) {
-                pr_err("Couldn't synthesize thread map.\n");
-                return err;
-        }
-
-        err = perf_event__synthesize_cpu_map(NULL, evsel_list->cpus,
-                                             process_synthesized_event, NULL);
-        if (err < 0) {
-                pr_err("Couldn't synthesize thread map.\n");
-                return err;
-        }
-
-        err = perf_event__synthesize_stat_config(NULL, &stat_config,
-                                                 process_synthesized_event, NULL);
-        if (err < 0) {
-                pr_err("Couldn't synthesize config.\n");
-                return err;
-        }
-
-        return 0;
-}
-
-#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
-
-static int __store_counter_ids(struct perf_evsel *counter)
-{
-        int cpu, thread;
-
-        for (cpu = 0; cpu < xyarray__max_x(counter->fd); cpu++) {
-                for (thread = 0; thread < xyarray__max_y(counter->fd);
-                     thread++) {
-                        int fd = FD(counter, cpu, thread);
-
-                        if (perf_evlist__id_add_fd(evsel_list, counter,
-                                                   cpu, thread, fd) < 0)
-                                return -1;
-                }
-        }
-
-        return 0;
-}
-
-static int store_counter_ids(struct perf_evsel *counter)
-{
-        struct cpu_map *cpus = counter->cpus;
-        struct thread_map *threads = counter->threads;
-
-        if (perf_evsel__alloc_id(counter, cpus->nr, threads->nr))
-                return -ENOMEM;
-
-        return __store_counter_ids(counter);
-}
-
 static bool perf_evsel__should_store_id(struct perf_evsel *counter)
 {
         return STAT_RECORD || counter->attr.read_format & PERF_FORMAT_ID;
@@ -569,6 +409,28 @@ static struct perf_evsel *perf_evsel__reset_weak_group(struct perf_evsel *evsel)
         return leader;
 }
 
+static bool is_target_alive(struct target *_target,
+                            struct thread_map *threads)
+{
+        struct stat st;
+        int i;
+
+        if (!target__has_task(_target))
+                return true;
+
+        for (i = 0; i < threads->nr; i++) {
+                char path[PATH_MAX];
+
+                scnprintf(path, PATH_MAX, "%s/%d", procfs__mountpoint(),
+                          threads->map[i].pid);
+
+                if (!stat(path, &st))
+                        return true;
+        }
+
+        return false;
+}
+
 static int __run_perf_stat(int argc, const char **argv, int run_idx)
 {
         int interval = stat_config.interval;
@@ -609,7 +471,7 @@ static int __run_perf_stat(int argc, const char **argv, int run_idx)
 
         evlist__for_each_entry(evsel_list, counter) {
 try_again:
-                if (create_perf_stat_counter(counter) < 0) {
+                if (create_perf_stat_counter(counter, &stat_config, &target) < 0) {
 
                         /* Weak group failed. Reset the group. */
                         if ((errno == EINVAL || errno == EBADF) &&
@@ -664,11 +526,11 @@ try_again:
                 counter->supported = true;
 
                 l = strlen(counter->unit);
-                if (l > unit_width)
-                        unit_width = l;
+                if (l > stat_config.unit_width)
+                        stat_config.unit_width = l;
 
                 if (perf_evsel__should_store_id(counter) &&
-                    store_counter_ids(counter))
+                    perf_evsel__store_ids(counter, evsel_list))
                         return -1;
         }
 
@@ -699,7 +561,8 @@ try_again:
                 if (err < 0)
                         return err;
 
-                err = perf_stat_synthesize_config(is_pipe);
+                err = perf_stat_synthesize_config(&stat_config, NULL, evsel_list,
+                                                  process_synthesized_event, is_pipe);
                 if (err < 0)
                         return err;
         }
@@ -724,7 +587,7 @@ try_again:
                                         break;
                         }
                 }
-                wait4(child_pid, &status, 0, &ru_data);
+                wait4(child_pid, &status, 0, &stat_config.ru_data);
 
                 if (workload_exec_errno) {
                         const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
@@ -738,6 +601,8 @@ try_again:
                 enable_counters();
                 while (!done) {
                         nanosleep(&ts, NULL);
+                        if (!is_target_alive(&target, evsel_list->threads))
+                                break;
                         if (timeout)
                                 break;
                         if (interval) {
@@ -752,8 +617,8 @@ try_again:
 
         t1 = rdclock();
 
-        if (walltime_run_table)
-                walltime_run[run_idx] = t1 - t0;
+        if (stat_config.walltime_run_table)
+                stat_config.walltime_run[run_idx] = t1 - t0;
 
         update_stats(&walltime_nsecs_stats, t1 - t0);
 
@@ -795,1105 +660,14 @@ static int run_perf_stat(int argc, const char **argv, int run_idx)
         return ret;
 }
 
-static void print_running(u64 run, u64 ena)
-{
-        if (csv_output) {
-                fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f",
-                                        csv_sep,
-                                        run,
-                                        csv_sep,
-                                        ena ? 100.0 * run / ena : 100.0);
-        } else if (run != ena) {
-                fprintf(stat_config.output, "  (%.2f%%)", 100.0 * run / ena);
-        }
-}
-
-static void print_noise_pct(double total, double avg)
-{
-        double pct = rel_stddev_stats(total, avg);
-
-        if (csv_output)
-                fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct);
-        else if (pct)
-                fprintf(stat_config.output, "  ( +-%6.2f%% )", pct);
-}
-
-static void print_noise(struct perf_evsel *evsel, double avg)
-{
-        struct perf_stat_evsel *ps;
-
-        if (run_count == 1)
-                return;
-
-        ps = evsel->stats;
-        print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
-}
-
-static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
-{
-        switch (stat_config.aggr_mode) {
-        case AGGR_CORE:
-                fprintf(stat_config.output, "S%d-C%*d%s%*d%s",
-                        cpu_map__id_to_socket(id),
-                        csv_output ? 0 : -8,
-                        cpu_map__id_to_cpu(id),
-                        csv_sep,
-                        csv_output ? 0 : 4,
-                        nr,
-                        csv_sep);
-                break;
-        case AGGR_SOCKET:
-                fprintf(stat_config.output, "S%*d%s%*d%s",
-                        csv_output ? 0 : -5,
-                        id,
-                        csv_sep,
-                        csv_output ? 0 : 4,
-                        nr,
-                        csv_sep);
-                        break;
-        case AGGR_NONE:
-                fprintf(stat_config.output, "CPU%*d%s",
-                        csv_output ? 0 : -4,
-                        perf_evsel__cpus(evsel)->map[id], csv_sep);
-                break;
-        case AGGR_THREAD:
-                fprintf(stat_config.output, "%*s-%*d%s",
-                        csv_output ? 0 : 16,
-                        thread_map__comm(evsel->threads, id),
-                        csv_output ? 0 : -8,
-                        thread_map__pid(evsel->threads, id),
-                        csv_sep);
-                break;
-        case AGGR_GLOBAL:
-        case AGGR_UNSET:
-        default:
-                break;
-        }
-}
-
-struct outstate {
-        FILE *fh;
-        bool newline;
-        const char *prefix;
-        int  nfields;
-        int  id, nr;
-        struct perf_evsel *evsel;
-};
-
-#define METRIC_LEN  35
-
-static void new_line_std(void *ctx)
-{
-        struct outstate *os = ctx;
-
-        os->newline = true;
-}
-
-static void do_new_line_std(struct outstate *os)
-{
-        fputc('\n', os->fh);
-        fputs(os->prefix, os->fh);
-        aggr_printout(os->evsel, os->id, os->nr);
-        if (stat_config.aggr_mode == AGGR_NONE)
-                fprintf(os->fh, "        ");
-        fprintf(os->fh, "                                                 ");
-}
-
-static void print_metric_std(void *ctx, const char *color, const char *fmt,
-                             const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        int n;
-        bool newline = os->newline;
-
-        os->newline = false;
-
-        if (unit == NULL || fmt == NULL) {
-                fprintf(out, "%-*s", METRIC_LEN, "");
-                return;
-        }
-
-        if (newline)
-                do_new_line_std(os);
-
-        n = fprintf(out, " # ");
-        if (color)
-                n += color_fprintf(out, color, fmt, val);
-        else
-                n += fprintf(out, fmt, val);
-        fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
-}
-
-static void new_line_csv(void *ctx)
-{
-        struct outstate *os = ctx;
-        int i;
-
-        fputc('\n', os->fh);
-        if (os->prefix)
-                fprintf(os->fh, "%s%s", os->prefix, csv_sep);
-        aggr_printout(os->evsel, os->id, os->nr);
-        for (i = 0; i < os->nfields; i++)
-                fputs(csv_sep, os->fh);
-}
-
-static void print_metric_csv(void *ctx,
-                             const char *color __maybe_unused,
-                             const char *fmt, const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        char buf[64], *vals, *ends;
-
-        if (unit == NULL || fmt == NULL) {
-                fprintf(out, "%s%s", csv_sep, csv_sep);
-                return;
-        }
-        snprintf(buf, sizeof(buf), fmt, val);
-        ends = vals = ltrim(buf);
-        while (isdigit(*ends) || *ends == '.')
-                ends++;
-        *ends = 0;
-        while (isspace(*unit))
-                unit++;
-        fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit);
-}
-
-/* Filter out some columns that don't work well in metrics only mode */
-
-static bool valid_only_metric(const char *unit)
-{
-        if (!unit)
-                return false;
-        if (strstr(unit, "/sec") ||
-            strstr(unit, "hz") ||
-            strstr(unit, "Hz") ||
-            strstr(unit, "CPUs utilized"))
-                return false;
-        return true;
-}
-
-static const char *fixunit(char *buf, struct perf_evsel *evsel,
-                           const char *unit)
-{
-        if (!strncmp(unit, "of all", 6)) {
-                snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel),
-                         unit);
-                return buf;
-        }
-        return unit;
-}
-
-static void print_metric_only(void *ctx, const char *color, const char *fmt,
-                              const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        char buf[1024], str[1024];
-        unsigned mlen = metric_only_len;
-
-        if (!valid_only_metric(unit))
-                return;
-        unit = fixunit(buf, os->evsel, unit);
-        if (mlen < strlen(unit))
-                mlen = strlen(unit) + 1;
-
-        if (color)
-                mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
-
-        color_snprintf(str, sizeof(str), color ?: "", fmt, val);
-        fprintf(out, "%*s ", mlen, str);
-}
-
-static void print_metric_only_csv(void *ctx, const char *color __maybe_unused,
-                                  const char *fmt,
-                                  const char *unit, double val)
-{
-        struct outstate *os = ctx;
-        FILE *out = os->fh;
-        char buf[64], *vals, *ends;
-        char tbuf[1024];
-
-        if (!valid_only_metric(unit))
-                return;
-        unit = fixunit(tbuf, os->evsel, unit);
-        snprintf(buf, sizeof buf, fmt, val);
-        ends = vals = ltrim(buf);
-        while (isdigit(*ends) || *ends == '.')
-                ends++;
-        *ends = 0;
-        fprintf(out, "%s%s", vals, csv_sep);
-}
-
-static void new_line_metric(void *ctx __maybe_unused)
-{
-}
-
-static void print_metric_header(void *ctx, const char *color __maybe_unused,
-                                const char *fmt __maybe_unused,
-                                const char *unit, double val __maybe_unused)
-{
-        struct outstate *os = ctx;
-        char tbuf[1024];
-
-        if (!valid_only_metric(unit))
-                return;
-        unit = fixunit(tbuf, os->evsel, unit);
-        if (csv_output)
-                fprintf(os->fh, "%s%s", unit, csv_sep);
-        else
-                fprintf(os->fh, "%*s ", metric_only_len, unit);
-}
-
-static int first_shadow_cpu(struct perf_evsel *evsel, int id)
-{
-        int i;
-
-        if (!aggr_get_id)
-                return 0;
-
-        if (stat_config.aggr_mode == AGGR_NONE)
-                return id;
-
-        if (stat_config.aggr_mode == AGGR_GLOBAL)
-                return 0;
-
-        for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) {
-                int cpu2 = perf_evsel__cpus(evsel)->map[i];
-
-                if (aggr_get_id(evsel_list->cpus, cpu2) == id)
-                        return cpu2;
-        }
-        return 0;
-}
-
-static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
-{
-        FILE *output = stat_config.output;
-        double sc =  evsel->scale;
-        const char *fmt;
-
-        if (csv_output) {
-                fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
-        } else {
-                if (big_num)
-                        fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
-                else
-                        fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
-        }
-
-        aggr_printout(evsel, id, nr);
-
-        fprintf(output, fmt, avg, csv_sep);
-
-        if (evsel->unit)
-                fprintf(output, "%-*s%s",
-                        csv_output ? 0 : unit_width,
-                        evsel->unit, csv_sep);
-
-        fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel));
-
-        if (evsel->cgrp)
-                fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
-}
-
-static bool is_mixed_hw_group(struct perf_evsel *counter)
-{
-        struct perf_evlist *evlist = counter->evlist;
-        u32 pmu_type = counter->attr.type;
-        struct perf_evsel *pos;
-
-        if (counter->nr_members < 2)
-                return false;
-
-        evlist__for_each_entry(evlist, pos) {
-                /* software events can be part of any hardware group */
-                if (pos->attr.type == PERF_TYPE_SOFTWARE)
-                        continue;
-                if (pmu_type == PERF_TYPE_SOFTWARE) {
-                        pmu_type = pos->attr.type;
-                        continue;
-                }
-                if (pmu_type != pos->attr.type)
-                        return true;
-        }
-
-        return false;
-}
-
-static void printout(int id, int nr, struct perf_evsel *counter, double uval,
-                     char *prefix, u64 run, u64 ena, double noise,
-                     struct runtime_stat *st)
-{
-        struct perf_stat_output_ctx out;
-        struct outstate os = {
-                .fh = stat_config.output,
-                .prefix = prefix ? prefix : "",
-                .id = id,
-                .nr = nr,
-                .evsel = counter,
-        };
-        print_metric_t pm = print_metric_std;
-        void (*nl)(void *);
-
-        if (metric_only) {
-                nl = new_line_metric;
-                if (csv_output)
-                        pm = print_metric_only_csv;
-                else
-                        pm = print_metric_only;
-        } else
-                nl = new_line_std;
-
-        if (csv_output && !metric_only) {
-                static int aggr_fields[] = {
-                        [AGGR_GLOBAL] = 0,
-                        [AGGR_THREAD] = 1,
-                        [AGGR_NONE] = 1,
-                        [AGGR_SOCKET] = 2,
-                        [AGGR_CORE] = 2,
-                };
-
-                pm = print_metric_csv;
-                nl = new_line_csv;
-                os.nfields = 3;
-                os.nfields += aggr_fields[stat_config.aggr_mode];
-                if (counter->cgrp)
-                        os.nfields++;
-        }
-        if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
-                if (metric_only) {
-                        pm(&os, NULL, "", "", 0);
-                        return;
-                }
-                aggr_printout(counter, id, nr);
-
-                fprintf(stat_config.output, "%*s%s",
-                        csv_output ? 0 : 18,
-                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
-                        csv_sep);
-
-                if (counter->supported) {
-                        print_free_counters_hint = 1;
-                        if (is_mixed_hw_group(counter))
-                                print_mixed_hw_group_error = 1;
-                }
-
-                fprintf(stat_config.output, "%-*s%s",
-                        csv_output ? 0 : unit_width,
-                        counter->unit, csv_sep);
-
-                fprintf(stat_config.output, "%*s",
-                        csv_output ? 0 : -25,
-                        perf_evsel__name(counter));
-
-                if (counter->cgrp)
-                        fprintf(stat_config.output, "%s%s",
-                                csv_sep, counter->cgrp->name);
-
-                if (!csv_output)
-                        pm(&os, NULL, NULL, "", 0);
-                print_noise(counter, noise);
-                print_running(run, ena);
-                if (csv_output)
-                        pm(&os, NULL, NULL, "", 0);
-                return;
-        }
-
-        if (!metric_only)
-                abs_printout(id, nr, counter, uval);
-
-        out.print_metric = pm;
-        out.new_line = nl;
-        out.ctx = &os;
-        out.force_header = false;
-
-        if (csv_output && !metric_only) {
-                print_noise(counter, noise);
-                print_running(run, ena);
-        }
-
-        perf_stat__print_shadow_stats(counter, uval,
-                                first_shadow_cpu(counter, id),
-                                &out, &metric_events, st);
-        if (!csv_output && !metric_only) {
-                print_noise(counter, noise);
-                print_running(run, ena);
-        }
-}
-
-static void aggr_update_shadow(void)
-{
-        int cpu, s2, id, s;
-        u64 val;
-        struct perf_evsel *counter;
-
-        for (s = 0; s < aggr_map->nr; s++) {
-                id = aggr_map->map[s];
-                evlist__for_each_entry(evsel_list, counter) {
-                        val = 0;
-                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                                s2 = aggr_get_id(evsel_list->cpus, cpu);
-                                if (s2 != id)
-                                        continue;
-                                val += perf_counts(counter->counts, cpu, 0)->val;
-                        }
-                        perf_stat__update_shadow_stats(counter, val,
-                                        first_shadow_cpu(counter, id),
-                                        &rt_stat);
-                }
-        }
-}
-
-static void uniquify_event_name(struct perf_evsel *counter)
-{
-        char *new_name;
-        char *config;
-
-        if (counter->uniquified_name ||
-            !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
-                                           strlen(counter->pmu_name)))
-                return;
-
-        config = strchr(counter->name, '/');
-        if (config) {
-                if (asprintf(&new_name,
-                             "%s%s", counter->pmu_name, config) > 0) {
-                        free(counter->name);
-                        counter->name = new_name;
-                }
-        } else {
-                if (asprintf(&new_name,
-                             "%s [%s]", counter->name, counter->pmu_name) > 0) {
-                        free(counter->name);
-                        counter->name = new_name;
-                }
-        }
-
-        counter->uniquified_name = true;
-}
-
-static void collect_all_aliases(struct perf_evsel *counter,
-                            void (*cb)(struct perf_evsel *counter, void *data,
-                                       bool first),
-                            void *data)
-{
-        struct perf_evsel *alias;
-
-        alias = list_prepare_entry(counter, &(evsel_list->entries), node);
-        list_for_each_entry_continue (alias, &evsel_list->entries, node) {
-                if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
-                    alias->scale != counter->scale ||
-                    alias->cgrp != counter->cgrp ||
-                    strcmp(alias->unit, counter->unit) ||
-                    perf_evsel__is_clock(alias) != perf_evsel__is_clock(counter))
-                        break;
-                alias->merged_stat = true;
-                cb(alias, data, false);
-        }
-}
-
-static bool collect_data(struct perf_evsel *counter,
-                            void (*cb)(struct perf_evsel *counter, void *data,
-                                       bool first),
-                            void *data)
-{
-        if (counter->merged_stat)
-                return false;
-        cb(counter, data, true);
-        if (no_merge)
-                uniquify_event_name(counter);
-        else if (counter->auto_merge_stats)
-                collect_all_aliases(counter, cb, data);
-        return true;
-}
-
-struct aggr_data {
-        u64 ena, run, val;
-        int id;
-        int nr;
-        int cpu;
-};
-
-static void aggr_cb(struct perf_evsel *counter, void *data, bool first)
-{
-        struct aggr_data *ad = data;
-        int cpu, s2;
-
-        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                struct perf_counts_values *counts;
-
-                s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
-                if (s2 != ad->id)
-                        continue;
-                if (first)
-                        ad->nr++;
-                counts = perf_counts(counter->counts, cpu, 0);
-                /*
-                 * When any result is bad, make them all to give
-                 * consistent output in interval mode.
-                 */
-                if (counts->ena == 0 || counts->run == 0 ||
-                    counter->counts->scaled == -1) {
-                        ad->ena = 0;
-                        ad->run = 0;
-                        break;
-                }
-                ad->val += counts->val;
-                ad->ena += counts->ena;
-                ad->run += counts->run;
-        }
-}
-
-static void print_aggr(char *prefix)
-{
-        FILE *output = stat_config.output;
-        struct perf_evsel *counter;
-        int s, id, nr;
-        double uval;
-        u64 ena, run, val;
-        bool first;
-
-        if (!(aggr_map || aggr_get_id))
-                return;
-
-        aggr_update_shadow();
-
-        /*
-         * With metric_only everything is on a single line.
-         * Without each counter has its own line.
-         */
-        for (s = 0; s < aggr_map->nr; s++) {
-                struct aggr_data ad;
-                if (prefix && metric_only)
-                        fprintf(output, "%s", prefix);
-
-                ad.id = id = aggr_map->map[s];
-                first = true;
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-
-                        ad.val = ad.ena = ad.run = 0;
-                        ad.nr = 0;
-                        if (!collect_data(counter, aggr_cb, &ad))
-                                continue;
-                        nr = ad.nr;
-                        ena = ad.ena;
-                        run = ad.run;
-                        val = ad.val;
-                        if (first && metric_only) {
-                                first = false;
-                                aggr_printout(counter, id, nr);
-                        }
-                        if (prefix && !metric_only)
-                                fprintf(output, "%s", prefix);
-
-                        uval = val * counter->scale;
-                        printout(id, nr, counter, uval, prefix, run, ena, 1.0,
-                                 &rt_stat);
-                        if (!metric_only)
-                                fputc('\n', output);
-                }
-                if (metric_only)
-                        fputc('\n', output);
-        }
-}
-
-static int cmp_val(const void *a, const void *b)
-{
-        return ((struct perf_aggr_thread_value *)b)->val -
-                ((struct perf_aggr_thread_value *)a)->val;
-}
-
-static struct perf_aggr_thread_value *sort_aggr_thread(
-                                        struct perf_evsel *counter,
-                                        int nthreads, int ncpus,
-                                        int *ret)
-{
-        int cpu, thread, i = 0;
-        double uval;
-        struct perf_aggr_thread_value *buf;
-
-        buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
-        if (!buf)
-                return NULL;
-
-        for (thread = 0; thread < nthreads; thread++) {
-                u64 ena = 0, run = 0, val = 0;
-
-                for (cpu = 0; cpu < ncpus; cpu++) {
-                        val += perf_counts(counter->counts, cpu, thread)->val;
-                        ena += perf_counts(counter->counts, cpu, thread)->ena;
-                        run += perf_counts(counter->counts, cpu, thread)->run;
-                }
-
-                uval = val * counter->scale;
-
-                /*
-                 * Skip value 0 when enabling --per-thread globally,
-                 * otherwise too many 0 output.
-                 */
-                if (uval == 0.0 && target__has_per_thread(&target))
-                        continue;
-
-                buf[i].counter = counter;
-                buf[i].id = thread;
-                buf[i].uval = uval;
-                buf[i].val = val;
-                buf[i].run = run;
-                buf[i].ena = ena;
-                i++;
-        }
-
-        qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);
-
-        if (ret)
-                *ret = i;
-
-        return buf;
-}
-
-static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
-{
-        FILE *output = stat_config.output;
-        int nthreads = thread_map__nr(counter->threads);
-        int ncpus = cpu_map__nr(counter->cpus);
-        int thread, sorted_threads, id;
-        struct perf_aggr_thread_value *buf;
-
-        buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads);
-        if (!buf) {
-                perror("cannot sort aggr thread");
-                return;
-        }
-
-        for (thread = 0; thread < sorted_threads; thread++) {
-                if (prefix)
-                        fprintf(output, "%s", prefix);
-
-                id = buf[thread].id;
-                if (stat_config.stats)
-                        printout(id, 0, buf[thread].counter, buf[thread].uval,
-                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
-                                 &stat_config.stats[id]);
-                else
-                        printout(id, 0, buf[thread].counter, buf[thread].uval,
-                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
-                                 &rt_stat);
-                fputc('\n', output);
-        }
-
-        free(buf);
-}
-
-struct caggr_data {
-        double avg, avg_enabled, avg_running;
-};
-
-static void counter_aggr_cb(struct perf_evsel *counter, void *data,
-                            bool first __maybe_unused)
-{
-        struct caggr_data *cd = data;
-        struct perf_stat_evsel *ps = counter->stats;
-
-        cd->avg += avg_stats(&ps->res_stats[0]);
-        cd->avg_enabled += avg_stats(&ps->res_stats[1]);
-        cd->avg_running += avg_stats(&ps->res_stats[2]);
-}
-
-/*
- * Print out the results of a single counter:
- * aggregated counts in system-wide mode
- */
-static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
-{
-        FILE *output = stat_config.output;
-        double uval;
-        struct caggr_data cd = { .avg = 0.0 };
-
-        if (!collect_data(counter, counter_aggr_cb, &cd))
-                return;
-
-        if (prefix && !metric_only)
-                fprintf(output, "%s", prefix);
-
-        uval = cd.avg * counter->scale;
-        printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
-                 cd.avg, &rt_stat);
-        if (!metric_only)
-                fprintf(output, "\n");
-}
-
-static void counter_cb(struct perf_evsel *counter, void *data,
-                       bool first __maybe_unused)
-{
-        struct aggr_data *ad = data;
-
-        ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
-        ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
-        ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
-}
-
-/*
- * Print out the results of a single counter:
- * does not use aggregated count in system-wide
- */
-static void print_counter(struct perf_evsel *counter, char *prefix)
-{
-        FILE *output = stat_config.output;
-        u64 ena, run, val;
-        double uval;
-        int cpu;
-
-        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                struct aggr_data ad = { .cpu = cpu };
-
-                if (!collect_data(counter, counter_cb, &ad))
-                        return;
-                val = ad.val;
-                ena = ad.ena;
-                run = ad.run;
-
-                if (prefix)
-                        fprintf(output, "%s", prefix);
-
-                uval = val * counter->scale;
-                printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
-                         &rt_stat);
-
-                fputc('\n', output);
-        }
-}
-
-static void print_no_aggr_metric(char *prefix)
-{
-        int cpu;
-        int nrcpus = 0;
-        struct perf_evsel *counter;
-        u64 ena, run, val;
-        double uval;
-
-        nrcpus = evsel_list->cpus->nr;
-        for (cpu = 0; cpu < nrcpus; cpu++) {
-                bool first = true;
-
-                if (prefix)
-                        fputs(prefix, stat_config.output);
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-                        if (first) {
-                                aggr_printout(counter, cpu, 0);
-                                first = false;
-                        }
-                        val = perf_counts(counter->counts, cpu, 0)->val;
-                        ena = perf_counts(counter->counts, cpu, 0)->ena;
-                        run = perf_counts(counter->counts, cpu, 0)->run;
-
-                        uval = val * counter->scale;
-                        printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
-                                 &rt_stat);
-                }
-                fputc('\n', stat_config.output);
-        }
-}
-
-static int aggr_header_lens[] = {
-        [AGGR_CORE] = 18,
-        [AGGR_SOCKET] = 12,
-        [AGGR_NONE] = 6,
-        [AGGR_THREAD] = 24,
-        [AGGR_GLOBAL] = 0,
-};
-
-static const char *aggr_header_csv[] = {
-        [AGGR_CORE]     =       "core,cpus,",
-        [AGGR_SOCKET]   =       "socket,cpus",
-        [AGGR_NONE]     =       "cpu,",
-        [AGGR_THREAD]   =       "comm-pid,",
-        [AGGR_GLOBAL]   =       ""
-};
-
-static void print_metric_headers(const char *prefix, bool no_indent)
-{
-        struct perf_stat_output_ctx out;
-        struct perf_evsel *counter;
-        struct outstate os = {
-                .fh = stat_config.output
-        };
-
-        if (prefix)
-                fprintf(stat_config.output, "%s", prefix);
-
-        if (!csv_output && !no_indent)
-                fprintf(stat_config.output, "%*s",
-                        aggr_header_lens[stat_config.aggr_mode], "");
-        if (csv_output) {
-                if (stat_config.interval)
-                        fputs("time,", stat_config.output);
-                fputs(aggr_header_csv[stat_config.aggr_mode],
-                        stat_config.output);
-        }
-
-        /* Print metrics headers only */
-        evlist__for_each_entry(evsel_list, counter) {
-                if (is_duration_time(counter))
-                        continue;
-                os.evsel = counter;
-                out.ctx = &os;
-                out.print_metric = print_metric_header;
-                out.new_line = new_line_metric;
-                out.force_header = true;
-                os.evsel = counter;
-                perf_stat__print_shadow_stats(counter, 0,
-                                              0,
-                                              &out,
-                                              &metric_events,
-                                              &rt_stat);
-        }
-        fputc('\n', stat_config.output);
-}
-
-static void print_interval(char *prefix, struct timespec *ts)
-{
-        FILE *output = stat_config.output;
-        static int num_print_interval;
-
-        if (interval_clear)
-                puts(CONSOLE_CLEAR);
-
-        sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep);
-
-        if ((num_print_interval == 0 && !csv_output) || interval_clear) {
-                switch (stat_config.aggr_mode) {
-                case AGGR_SOCKET:
-                        fprintf(output, "#           time socket cpus");
-                        if (!metric_only)
-                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_CORE:
-                        fprintf(output, "#           time core         cpus");
-                        if (!metric_only)
-                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_NONE:
-                        fprintf(output, "#           time CPU    ");
-                        if (!metric_only)
-                                fprintf(output, "                counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_THREAD:
-                        fprintf(output, "#           time             comm-pid");
-                        if (!metric_only)
-                                fprintf(output, "                  counts %*s events\n", unit_width, "unit");
-                        break;
-                case AGGR_GLOBAL:
-                default:
-                        fprintf(output, "#           time");
-                        if (!metric_only)
-                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
-                case AGGR_UNSET:
-                        break;
-                }
-        }
-
-        if ((num_print_interval == 0 || interval_clear) && metric_only)
-                print_metric_headers(" ", true);
-        if (++num_print_interval == 25)
-                num_print_interval = 0;
-}
-
-static void print_header(int argc, const char **argv)
-{
-        FILE *output = stat_config.output;
-        int i;
-
-        fflush(stdout);
-
-        if (!csv_output) {
-                fprintf(output, "\n");
-                fprintf(output, " Performance counter stats for ");
-                if (target.system_wide)
-                        fprintf(output, "\'system wide");
-                else if (target.cpu_list)
-                        fprintf(output, "\'CPU(s) %s", target.cpu_list);
-                else if (!target__has_task(&target)) {
-                        fprintf(output, "\'%s", argv ? argv[0] : "pipe");
-                        for (i = 1; argv && (i < argc); i++)
-                                fprintf(output, " %s", argv[i]);
-                } else if (target.pid)
-                        fprintf(output, "process id \'%s", target.pid);
-                else
-                        fprintf(output, "thread id \'%s", target.tid);
-
-                fprintf(output, "\'");
-                if (run_count > 1)
-                        fprintf(output, " (%d runs)", run_count);
-                fprintf(output, ":\n\n");
-        }
-}
-
-static int get_precision(double num)
-{
-        if (num > 1)
-                return 0;
-
-        return lround(ceil(-log10(num)));
-}
-
-static void print_table(FILE *output, int precision, double avg)
-{
-        char tmp[64];
-        int idx, indent = 0;
-
-        scnprintf(tmp, 64, " %17.*f", precision, avg);
-        while (tmp[indent] == ' ')
-                indent++;
-
-        fprintf(output, "%*s# Table of individual measurements:\n", indent, "");
-
-        for (idx = 0; idx < run_count; idx++) {
-                double run = (double) walltime_run[idx] / NSEC_PER_SEC;
-                int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
-
-                fprintf(output, " %17.*f (%+.*f) ",
-                        precision, run, precision, run - avg);
-
-                for (h = 0; h < n; h++)
-                        fprintf(output, "#");
-
-                fprintf(output, "\n");
-        }
-
-        fprintf(output, "\n%*s# Final result:\n", indent, "");
-}
-
-static double timeval2double(struct timeval *t)
-{
-        return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
-}
-
-static void print_footer(void)
-{
-        double avg = avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC;
-        FILE *output = stat_config.output;
-        int n;
-
-        if (!null_run)
-                fprintf(output, "\n");
-
-        if (run_count == 1) {
-                fprintf(output, " %17.9f seconds time elapsed", avg);
-
-                if (ru_display) {
-                        double ru_utime = timeval2double(&ru_data.ru_utime);
-                        double ru_stime = timeval2double(&ru_data.ru_stime);
-
-                        fprintf(output, "\n\n");
-                        fprintf(output, " %17.9f seconds user\n", ru_utime);
-                        fprintf(output, " %17.9f seconds sys\n", ru_stime);
-                }
-        } else {
-                double sd = stddev_stats(&walltime_nsecs_stats) / NSEC_PER_SEC;
-                /*
-                 * Display at most 2 more significant
-                 * digits than the stddev inaccuracy.
-                 */
-                int precision = get_precision(sd) + 2;
-
-                if (walltime_run_table)
-                        print_table(output, precision, avg);
-
-                fprintf(output, " %17.*f +- %.*f seconds time elapsed",
-                        precision, avg, precision, sd);
-
-                print_noise_pct(sd, avg);
-        }
-        fprintf(output, "\n\n");
-
-        if (print_free_counters_hint &&
-            sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
-            n > 0)
-                fprintf(output,
-"Some events weren't counted. Try disabling the NMI watchdog:\n"
-"       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
-"       perf stat ...\n"
-"       echo 1 > /proc/sys/kernel/nmi_watchdog\n");
-
-        if (print_mixed_hw_group_error)
-                fprintf(output,
-                        "The events in group usually have to be from "
-                        "the same PMU. Try reorganizing the group.\n");
-}
-
 static void print_counters(struct timespec *ts, int argc, const char **argv)
 {
-        int interval = stat_config.interval;
-        struct perf_evsel *counter;
-        char buf[64], *prefix = NULL;
-
         /* Do not print anything if we record to the pipe. */
         if (STAT_RECORD && perf_stat.data.is_pipe)
                 return;
 
-        if (interval)
-                print_interval(prefix = buf, ts);
-        else
-                print_header(argc, argv);
-
-        if (metric_only) {
-                static int num_print_iv;
-
-                if (num_print_iv == 0 && !interval)
-                        print_metric_headers(prefix, false);
-                if (num_print_iv++ == 25)
-                        num_print_iv = 0;
-                if (stat_config.aggr_mode == AGGR_GLOBAL && prefix)
-                        fprintf(stat_config.output, "%s", prefix);
-        }
-
-        switch (stat_config.aggr_mode) {
-        case AGGR_CORE:
-        case AGGR_SOCKET:
-                print_aggr(prefix);
-                break;
-        case AGGR_THREAD:
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-                        print_aggr_thread(counter, prefix);
-                }
-                break;
-        case AGGR_GLOBAL:
-                evlist__for_each_entry(evsel_list, counter) {
-                        if (is_duration_time(counter))
-                                continue;
-                        print_counter_aggr(counter, prefix);
-                }
-                if (metric_only)
-                        fputc('\n', stat_config.output);
-                break;
-        case AGGR_NONE:
-                if (metric_only)
-                        print_no_aggr_metric(prefix);
-                else {
-                        evlist__for_each_entry(evsel_list, counter) {
-                                if (is_duration_time(counter))
-                                        continue;
-                                print_counter(counter, prefix);
-                        }
-                }
-                break;
-        case AGGR_UNSET:
-        default:
-                break;
-        }
-
-        if (!interval && !csv_output)
-                print_footer();
-
-        fflush(stat_config.output);
+        perf_evlist__print_counters(evsel_list, &stat_config, &target,
+                                    ts, argc, argv);
 }
 
 static volatile int signr = -1;
@@ -1950,7 +724,7 @@ static int enable_metric_only(const struct option *opt __maybe_unused,
                               const char *s __maybe_unused, int unset)
 {
         force_metric_only = true;
-        metric_only = !unset;
+        stat_config.metric_only = !unset;
         return 0;
 }
 
@@ -1958,7 +732,7 @@ static int parse_metric_groups(const struct option *opt,
                                const char *str,
                                int unset __maybe_unused)
 {
-        return metricgroup__parse_groups(opt, str, &metric_events);
+        return metricgroup__parse_groups(opt, str, &stat_config.metric_events);
 }
 
 static const struct option stat_options[] = {
@@ -1969,7 +743,7 @@ static const struct option stat_options[] = {
                      parse_events_option),
         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
                      "event filter", parse_filter),
-        OPT_BOOLEAN('i', "no-inherit", &no_inherit,
+        OPT_BOOLEAN('i', "no-inherit", &stat_config.no_inherit,
                     "child tasks do not inherit counters"),
         OPT_STRING('p', "pid", &target.pid, "pid",
                    "stat events on existing process id"),
@@ -1982,11 +756,11 @@ static const struct option stat_options[] = {
         OPT_BOOLEAN('c', "scale", &stat_config.scale, "scale/normalize counters"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
-        OPT_INTEGER('r', "repeat", &run_count,
+        OPT_INTEGER('r', "repeat", &stat_config.run_count,
                     "repeat command and print average + stddev (max: 100, forever: 0)"),
-        OPT_BOOLEAN(0, "table", &walltime_run_table,
+        OPT_BOOLEAN(0, "table", &stat_config.walltime_run_table,
                     "display details about each run (only with -r option)"),
-        OPT_BOOLEAN('n', "null", &null_run,
+        OPT_BOOLEAN('n', "null", &stat_config.null_run,
                     "null run - dont start any counters"),
         OPT_INCR('d', "detailed", &detailed_run,
                     "detailed run - start a lot of events"),
@@ -1999,8 +773,8 @@ static const struct option stat_options[] = {
                     "list of cpus to monitor in system-wide"),
         OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
                     "disable CPU count aggregation", AGGR_NONE),
-        OPT_BOOLEAN(0, "no-merge", &no_merge, "Do not merge identical named events"),
-        OPT_STRING('x', "field-separator", &csv_sep, "separator",
+        OPT_BOOLEAN(0, "no-merge", &stat_config.no_merge, "Do not merge identical named events"),
+        OPT_STRING('x', "field-separator", &stat_config.csv_sep, "separator",
                    "print counts with custom separator"),
         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
                      "monitor event in cgroup name only", parse_cgroups),
@@ -2017,7 +791,7 @@ static const struct option stat_options[] = {
                     "(overhead is possible for values <= 100ms)"),
         OPT_INTEGER(0, "interval-count", &stat_config.times,
                     "print counts for fixed number of times"),
-        OPT_BOOLEAN(0, "interval-clear", &interval_clear,
+        OPT_BOOLEAN(0, "interval-clear", &stat_config.interval_clear,
                     "clear screen in between new interval"),
         OPT_UINTEGER(0, "timeout", &stat_config.timeout,
                     "stop workload and print counts after a timeout period in ms (>= 10ms)"),
@@ -2027,9 +801,9 @@ static const struct option stat_options[] = {
                      "aggregate counts per physical processor core", AGGR_CORE),
         OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode,
                      "aggregate counts per thread", AGGR_THREAD),
-        OPT_UINTEGER('D', "delay", &initial_delay,
+        OPT_UINTEGER('D', "delay", &stat_config.initial_delay,
                      "ms to wait before starting measurement after program start"),
-        OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL,
+        OPT_CALLBACK_NOOPT(0, "metric-only", &stat_config.metric_only, NULL,
                         "Only print computed metrics. No raw values", enable_metric_only),
         OPT_BOOLEAN(0, "topdown", &topdown_run,
                         "measure topdown level 1 statistics"),
@@ -2041,12 +815,14 @@ static const struct option stat_options[] = {
         OPT_END()
 };
 
-static int perf_stat__get_socket(struct cpu_map *map, int cpu)
+static int perf_stat__get_socket(struct perf_stat_config *config __maybe_unused,
+                                 struct cpu_map *map, int cpu)
 {
         return cpu_map__get_socket(map, cpu, NULL);
 }
 
-static int perf_stat__get_core(struct cpu_map *map, int cpu)
+static int perf_stat__get_core(struct perf_stat_config *config __maybe_unused,
+                               struct cpu_map *map, int cpu)
 {
         return cpu_map__get_core(map, cpu, NULL);
 }
@@ -2063,9 +839,8 @@ static int cpu_map__get_max(struct cpu_map *map)
         return max;
 }
 
-static struct cpu_map *cpus_aggr_map;
-
-static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int idx)
+static int perf_stat__get_aggr(struct perf_stat_config *config,
+                               aggr_get_id_t get_id, struct cpu_map *map, int idx)
 {
         int cpu;
 
@@ -2074,20 +849,22 @@ static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int id
 
         cpu = map->map[idx];
 
-        if (cpus_aggr_map->map[cpu] == -1)
-                cpus_aggr_map->map[cpu] = get_id(map, idx);
+        if (config->cpus_aggr_map->map[cpu] == -1)
+                config->cpus_aggr_map->map[cpu] = get_id(config, map, idx);
 
-        return cpus_aggr_map->map[cpu];
+        return config->cpus_aggr_map->map[cpu];
 }
 
-static int perf_stat__get_socket_cached(struct cpu_map *map, int idx)
+static int perf_stat__get_socket_cached(struct perf_stat_config *config,
+                                        struct cpu_map *map, int idx)
 {
-        return perf_stat__get_aggr(perf_stat__get_socket, map, idx);
+        return perf_stat__get_aggr(config, perf_stat__get_socket, map, idx);
 }
 
-static int perf_stat__get_core_cached(struct cpu_map *map, int idx)
+static int perf_stat__get_core_cached(struct perf_stat_config *config,
+                                      struct cpu_map *map, int idx)
 {
-        return perf_stat__get_aggr(perf_stat__get_core, map, idx);
+        return perf_stat__get_aggr(config, perf_stat__get_core, map, idx);
 }
 
 static int perf_stat_init_aggr_mode(void)
@@ -2096,18 +873,18 @@ static int perf_stat_init_aggr_mode(void)
 
         switch (stat_config.aggr_mode) {
         case AGGR_SOCKET:
-                if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
+                if (cpu_map__build_socket_map(evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build socket map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_socket_cached;
+                stat_config.aggr_get_id = perf_stat__get_socket_cached;
                 break;
         case AGGR_CORE:
-                if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
+                if (cpu_map__build_core_map(evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build core map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_core_cached;
+                stat_config.aggr_get_id = perf_stat__get_core_cached;
                 break;
         case AGGR_NONE:
         case AGGR_GLOBAL:
@@ -2123,16 +900,16 @@ static int perf_stat_init_aggr_mode(void)
          * the aggregation translate cpumap.
          */
         nr = cpu_map__get_max(evsel_list->cpus);
-        cpus_aggr_map = cpu_map__empty_new(nr + 1);
-        return cpus_aggr_map ? 0 : -ENOMEM;
+        stat_config.cpus_aggr_map = cpu_map__empty_new(nr + 1);
+        return stat_config.cpus_aggr_map ? 0 : -ENOMEM;
 }
 
 static void perf_stat__exit_aggr_mode(void)
 {
-        cpu_map__put(aggr_map);
-        cpu_map__put(cpus_aggr_map);
-        aggr_map = NULL;
-        cpus_aggr_map = NULL;
+        cpu_map__put(stat_config.aggr_map);
+        cpu_map__put(stat_config.cpus_aggr_map);
+        stat_config.aggr_map = NULL;
+        stat_config.cpus_aggr_map = NULL;
 }
 
 static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, int idx)
@@ -2190,12 +967,14 @@ static int perf_env__build_core_map(struct perf_env *env, struct cpu_map *cpus,
         return cpu_map__build_map(cpus, corep, perf_env__get_core, env);
 }
 
-static int perf_stat__get_socket_file(struct cpu_map *map, int idx)
+static int perf_stat__get_socket_file(struct perf_stat_config *config __maybe_unused,
+                                      struct cpu_map *map, int idx)
 {
         return perf_env__get_socket(map, idx, &perf_stat.session->header.env);
 }
 
-static int perf_stat__get_core_file(struct cpu_map *map, int idx)
+static int perf_stat__get_core_file(struct perf_stat_config *config __maybe_unused,
+                                    struct cpu_map *map, int idx)
 {
         return perf_env__get_core(map, idx, &perf_stat.session->header.env);
 }
@@ -2206,18 +985,18 @@ static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
 
         switch (stat_config.aggr_mode) {
         case AGGR_SOCKET:
-                if (perf_env__build_socket_map(env, evsel_list->cpus, &aggr_map)) {
+                if (perf_env__build_socket_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build socket map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_socket_file;
+                stat_config.aggr_get_id = perf_stat__get_socket_file;
                 break;
         case AGGR_CORE:
-                if (perf_env__build_core_map(env, evsel_list->cpus, &aggr_map)) {
+                if (perf_env__build_core_map(env, evsel_list->cpus, &stat_config.aggr_map)) {
                         perror("cannot build core map");
                         return -1;
                 }
-                aggr_get_id = perf_stat__get_core_file;
+                stat_config.aggr_get_id = perf_stat__get_core_file;
                 break;
         case AGGR_NONE:
         case AGGR_GLOBAL:
@@ -2401,7 +1180,7 @@ static int add_default_attributes(void)
         struct parse_events_error errinfo;
 
         /* Set attrs if no event is selected and !null_run: */
-        if (null_run)
+        if (stat_config.null_run)
                 return 0;
 
         if (transaction_run) {
@@ -2414,7 +1193,7 @@ static int add_default_attributes(void)
                         struct option opt = { .value = &evsel_list };
 
                         return metricgroup__parse_groups(&opt, "transaction",
-                                                         &metric_events);
+                                                         &stat_config.metric_events);
                 }
 
                 if (pmu_have_event("cpu", "cycles-ct") &&
@@ -2452,7 +1231,7 @@ static int add_default_attributes(void)
                 if (pmu_have_event("msr", "aperf") &&
                     pmu_have_event("msr", "smi")) {
                         if (!force_metric_only)
-                                metric_only = true;
+                                stat_config.metric_only = true;
                         err = parse_events(evsel_list, smi_cost_attrs, &errinfo);
                 } else {
                         fprintf(stderr, "To measure SMI cost, it needs "
@@ -2483,7 +1262,7 @@ static int add_default_attributes(void)
                 }
 
                 if (!force_metric_only)
-                        metric_only = true;
+                        stat_config.metric_only = true;
                 if (topdown_filter_events(topdown_attrs, &str,
                                 arch_topdown_check_group(&warn)) < 0) {
                         pr_err("Out of memory\n");
@@ -2580,7 +1359,7 @@ static int __cmd_record(int argc, const char **argv)
         if (output_name)
                 data->file.path = output_name;
 
-        if (run_count != 1 || forever) {
+        if (stat_config.run_count != 1 || forever) {
                 pr_err("Cannot use -r option with perf stat record.\n");
                 return -1;
         }
@@ -2599,9 +1378,8 @@ static int __cmd_record(int argc, const char **argv)
         return argc;
 }
 
-static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
-                                    union perf_event *event,
-                                    struct perf_session *session)
+static int process_stat_round_event(struct perf_session *session,
+                                    union perf_event *event)
 {
         struct stat_round_event *stat_round = &event->stat_round;
         struct perf_evsel *counter;
@@ -2626,10 +1404,10 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
 }
 
 static
-int process_stat_config_event(struct perf_tool *tool,
-                              union perf_event *event,
-                              struct perf_session *session __maybe_unused)
+int process_stat_config_event(struct perf_session *session,
+                              union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
 
         perf_event__read_stat_config(&stat_config, &event->stat_config);
@@ -2669,10 +1447,10 @@ static int set_maps(struct perf_stat *st)
 }
 
 static
-int process_thread_map_event(struct perf_tool *tool,
-                             union perf_event *event,
-                             struct perf_session *session __maybe_unused)
+int process_thread_map_event(struct perf_session *session,
+                             union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
 
         if (st->threads) {
@@ -2688,10 +1466,10 @@ int process_thread_map_event(struct perf_tool *tool,
 }
 
 static
-int process_cpu_map_event(struct perf_tool *tool,
-                          union perf_event *event,
-                          struct perf_session *session __maybe_unused)
+int process_cpu_map_event(struct perf_session *session,
+                          union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct perf_stat *st = container_of(tool, struct perf_stat, tool);
         struct cpu_map *cpus;
 
@@ -2853,12 +1631,12 @@ int cmd_stat(int argc, const char **argv)
         perf_stat__collect_metric_expr(evsel_list);
         perf_stat__init_shadow_stats();
 
-        if (csv_sep) {
-                csv_output = true;
-                if (!strcmp(csv_sep, "\\t"))
-                        csv_sep = "\t";
+        if (stat_config.csv_sep) {
+                stat_config.csv_output = true;
+                if (!strcmp(stat_config.csv_sep, "\\t"))
+                        stat_config.csv_sep = "\t";
         } else
-                csv_sep = DEFAULT_SEPARATOR;
+                stat_config.csv_sep = DEFAULT_SEPARATOR;
 
         if (argc && !strncmp(argv[0], "rec", 3)) {
                 argc = __cmd_record(argc, argv);
@@ -2883,17 +1661,17 @@ int cmd_stat(int argc, const char **argv)
                 goto out;
         }
 
-        if (metric_only && stat_config.aggr_mode == AGGR_THREAD) {
+        if (stat_config.metric_only && stat_config.aggr_mode == AGGR_THREAD) {
                 fprintf(stderr, "--metric-only is not supported with --per-thread\n");
                 goto out;
         }
 
-        if (metric_only && run_count > 1) {
+        if (stat_config.metric_only && stat_config.run_count > 1) {
                 fprintf(stderr, "--metric-only is not supported with -r\n");
                 goto out;
         }
 
-        if (walltime_run_table && run_count <= 1) {
+        if (stat_config.walltime_run_table && stat_config.run_count <= 1) {
                 fprintf(stderr, "--table is only supported with -r\n");
                 parse_options_usage(stat_usage, stat_options, "r", 1);
                 parse_options_usage(NULL, stat_options, "table", 0);
@@ -2931,7 +1709,7 @@ int cmd_stat(int argc, const char **argv)
         /*
          * let the spreadsheet do the pretty-printing
          */
-        if (csv_output) {
+        if (stat_config.csv_output) {
                 /* User explicitly passed -B? */
                 if (big_num_opt == 1) {
                         fprintf(stderr, "-B option not supported with -x\n");
@@ -2939,9 +1717,9 @@ int cmd_stat(int argc, const char **argv)
                         parse_options_usage(NULL, stat_options, "x", 1);
                         goto out;
                 } else /* Nope, so disable big number formatting */
-                        big_num = false;
+                        stat_config.big_num = false;
         } else if (big_num_opt == 0) /* User passed --no-big-num */
-                big_num = false;
+                stat_config.big_num = false;
 
         setup_system_wide(argc);
 
@@ -2949,21 +1727,21 @@ int cmd_stat(int argc, const char **argv)
          * Display user/system times only for single
          * run and when there's specified tracee.
          */
-        if ((run_count == 1) && target__none(&target))
-                ru_display = true;
+        if ((stat_config.run_count == 1) && target__none(&target))
+                stat_config.ru_display = true;
 
-        if (run_count < 0) {
+        if (stat_config.run_count < 0) {
                 pr_err("Run count must be a positive number\n");
                 parse_options_usage(stat_usage, stat_options, "r", 1);
                 goto out;
-        } else if (run_count == 0) {
+        } else if (stat_config.run_count == 0) {
                 forever = true;
-                run_count = 1;
+                stat_config.run_count = 1;
         }
 
-        if (walltime_run_table) {
-                walltime_run = zalloc(run_count * sizeof(walltime_run[0]));
-                if (!walltime_run) {
+        if (stat_config.walltime_run_table) {
+                stat_config.walltime_run = zalloc(stat_config.run_count * sizeof(stat_config.walltime_run[0]));
+                if (!stat_config.walltime_run) {
                         pr_err("failed to setup -r option");
                         goto out;
                 }
@@ -3066,6 +1844,17 @@ int cmd_stat(int argc, const char **argv)
                 goto out;
 
         /*
+         * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
+         * while avoiding that older tools show confusing messages.
+         *
+         * However for pipe sessions we need to keep it zero,
+         * because script's perf_evsel__check_attr is triggered
+         * by attr->sample_type != 0, and we can't run it on
+         * stat sessions.
+         */
+        stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe);
+
+        /*
          * We dont want to block the signals - that would cause
          * child tasks to inherit that and Ctrl-C would not work.
          * What we want is for Ctrl-C to work in the exec()-ed
@@ -3079,8 +1868,8 @@ int cmd_stat(int argc, const char **argv)
         signal(SIGABRT, skip_signal);
 
         status = 0;
-        for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
-                if (run_count != 1 && verbose > 0)
+        for (run_idx = 0; forever || run_idx < stat_config.run_count; run_idx++) {
+                if (stat_config.run_count != 1 && verbose > 0)
                         fprintf(output, "[ perf stat: executing run #%d ... ]\n",
                                 run_idx + 1);
 
@@ -3132,7 +1921,7 @@ int cmd_stat(int argc, const char **argv)
         perf_stat__exit_aggr_mode();
         perf_evlist__free_stats(evsel_list);
 out:
-        free(walltime_run);
+        free(stat_config.walltime_run);
 
         if (smi_cost && smi_reset)
                 sysfs__write_int(FREEZE_ON_SMI_PATH, 0);
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index d21d8751e749..b2838de13de0 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -1134,11 +1134,6 @@ static int __cmd_top(struct perf_top *top)
         if (!target__none(&opts->target))
                 perf_evlist__enable(top->evlist);
 
-        /* Wait for a minimal set of events before starting the snapshot */
-        perf_evlist__poll(top->evlist, 100);
-
-        perf_top__mmap_read(top);
-
         ret = -1;
         if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
                                                             display_thread), top)) {
@@ -1156,6 +1151,11 @@ static int __cmd_top(struct perf_top *top)
                 }
         }
 
+        /* Wait for a minimal set of events before starting the snapshot */
+        perf_evlist__poll(top->evlist, 100);
+
+        perf_top__mmap_read(top);
+
         while (!done) {
                 u64 hits = top->samples;
 
@@ -1257,7 +1257,14 @@ int cmd_top(int argc, const char **argv)
                                 .uses_mmap   = true,
                         },
                         .proc_map_timeout    = 500,
-                        .overwrite      = 1,
+                        /*
+                         * FIXME: This will lose PERF_RECORD_MMAP and other metadata
+                         * when we pause, fix that and reenable. Probably using a
+                         * separate evlist with a dummy event, i.e. a non-overwrite
+                         * ring buffer just for metadata events, while PERF_RECORD_SAMPLE
+                         * stays in overwrite mode. -acme
+                         * */
+                        .overwrite      = 0,
                 },
                 .max_stack           = sysctl__max_stack(),
                 .annotation_opts     = annotation__default_options,
@@ -1372,6 +1379,8 @@ int cmd_top(int argc, const char **argv)
                     "Show raw trace event output (do not use print fmt or plugins)"),
         OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
                     "Show entries in a hierarchy"),
+        OPT_BOOLEAN(0, "overwrite", &top.record_opts.overwrite,
+                    "Use a backward ring buffer, default: no"),
         OPT_BOOLEAN(0, "force", &symbol_conf.force, "don't complain, do it"),
         OPT_UINTEGER(0, "num-thread-synthesize", &top.nr_threads_synthesize,
                         "number of thread to run event synthesize"),
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 22ab8e67c760..dc8a6c4986ce 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -89,6 +89,8 @@ struct trace {
         u64                     base_time;
         FILE                    *output;
         unsigned long           nr_events;
+        unsigned long           nr_events_printed;
+        unsigned long           max_events;
         struct strlist          *ev_qualifier;
         struct {
                 size_t          nr;
@@ -181,7 +183,7 @@ static int __tp_field__init_uint(struct tp_field *field, int size, int offset, b
         return 0;
 }
 
-static int tp_field__init_uint(struct tp_field *field, struct format_field *format_field, bool needs_swap)
+static int tp_field__init_uint(struct tp_field *field, struct tep_format_field *format_field, bool needs_swap)
 {
         return __tp_field__init_uint(field, format_field->size, format_field->offset, needs_swap);
 }
@@ -198,7 +200,7 @@ static int __tp_field__init_ptr(struct tp_field *field, int offset)
         return 0;
 }
 
-static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
+static int tp_field__init_ptr(struct tp_field *field, struct tep_format_field *format_field)
 {
         return __tp_field__init_ptr(field, format_field->offset);
 }
@@ -214,7 +216,7 @@ static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
                                           struct tp_field *field,
                                           const char *name)
 {
-        struct format_field *format_field = perf_evsel__field(evsel, name);
+        struct tep_format_field *format_field = perf_evsel__field(evsel, name);
 
         if (format_field == NULL)
                 return -1;
@@ -230,7 +232,7 @@ static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
                                          struct tp_field *field,
                                          const char *name)
 {
-        struct format_field *format_field = perf_evsel__field(evsel, name);
+        struct tep_format_field *format_field = perf_evsel__field(evsel, name);
 
         if (format_field == NULL)
                 return -1;
@@ -288,6 +290,13 @@ static int perf_evsel__init_augmented_syscall_tp_args(struct perf_evsel *evsel)
         return __tp_field__init_ptr(&sc->args, sc->id.offset + sizeof(u64));
 }
 
+static int perf_evsel__init_augmented_syscall_tp_ret(struct perf_evsel *evsel)
+{
+        struct syscall_tp *sc = evsel->priv;
+
+        return __tp_field__init_uint(&sc->ret, sizeof(u64), sc->id.offset + sizeof(u64), evsel->needs_swap);
+}
+
 static int perf_evsel__init_raw_syscall_tp(struct perf_evsel *evsel, void *handler)
 {
         evsel->priv = malloc(sizeof(struct syscall_tp));
@@ -498,16 +507,6 @@ static const char *clockid[] = {
 };
 static DEFINE_STRARRAY(clockid);
 
-static const char *socket_families[] = {
-        "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
-        "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
-        "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
-        "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
-        "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
-        "ALG", "NFC", "VSOCK",
-};
-static DEFINE_STRARRAY(socket_families);
-
 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
                                                  struct syscall_arg *arg)
 {
@@ -615,6 +614,7 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 
 struct syscall_arg_fmt {
         size_t     (*scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
+        unsigned long (*mask_val)(struct syscall_arg *arg, unsigned long val);
         void       *parm;
         const char *name;
         bool       show_zero;
@@ -631,6 +631,8 @@ static struct syscall_fmt {
 } syscall_fmts[] = {
         { .name     = "access",
           .arg = { [1] = { .scnprintf = SCA_ACCMODE,  /* mode */ }, }, },
+        { .name     = "bind",
+          .arg = { [1] = { .scnprintf = SCA_SOCKADDR, /* umyaddr */ }, }, },
         { .name     = "bpf",
           .arg = { [0] = STRARRAY(cmd, bpf_cmd), }, },
         { .name     = "brk",        .hexret = true,
@@ -645,6 +647,8 @@ static struct syscall_fmt {
                    [4] = { .name = "tls",           .scnprintf = SCA_HEX, }, }, },
         { .name     = "close",
           .arg = { [0] = { .scnprintf = SCA_CLOSE_FD, /* fd */ }, }, },
+        { .name     = "connect",
+          .arg = { [1] = { .scnprintf = SCA_SOCKADDR, /* servaddr */ }, }, },
         { .name     = "epoll_ctl",
           .arg = { [1] = STRARRAY(op, epoll_ctl_ops), }, },
         { .name     = "eventfd2",
@@ -722,6 +726,10 @@ static struct syscall_fmt {
           .arg = { [0] = { .scnprintf = SCA_HEX,        /* addr */ },
                    [2] = { .scnprintf = SCA_MMAP_PROT,  /* prot */ },
                    [3] = { .scnprintf = SCA_MMAP_FLAGS, /* flags */ }, }, },
+        { .name     = "mount",
+          .arg = { [0] = { .scnprintf = SCA_FILENAME, /* dev_name */ },
+                   [3] = { .scnprintf = SCA_MOUNT_FLAGS, /* flags */
+                           .mask_val  = SCAMV_MOUNT_FLAGS, /* flags */ }, }, },
         { .name     = "mprotect",
           .arg = { [0] = { .scnprintf = SCA_HEX,        /* start */ },
                    [2] = { .scnprintf = SCA_MMAP_PROT,  /* prot */ }, }, },
@@ -801,7 +809,8 @@ static struct syscall_fmt {
         { .name     = "sendmsg",
           .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
         { .name     = "sendto",
-          .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
+          .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ },
+                   [4] = { .scnprintf = SCA_SOCKADDR, /* addr */ }, }, },
         { .name     = "set_tid_address", .errpid = true, },
         { .name     = "setitimer",
           .arg = { [0] = STRARRAY(which, itimers), }, },
@@ -830,6 +839,8 @@ static struct syscall_fmt {
           .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
         { .name     = "tkill",
           .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
+        { .name     = "umount2", .alias = "umount",
+          .arg = { [0] = { .scnprintf = SCA_FILENAME, /* name */ }, }, },
         { .name     = "uname", .alias = "newuname", },
         { .name     = "unlinkat",
           .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
@@ -853,16 +864,30 @@ static struct syscall_fmt *syscall_fmt__find(const char *name)
         return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
 }
 
+static struct syscall_fmt *syscall_fmt__find_by_alias(const char *alias)
+{
+        int i, nmemb = ARRAY_SIZE(syscall_fmts);
+
+        for (i = 0; i < nmemb; ++i) {
+                if (syscall_fmts[i].alias && strcmp(syscall_fmts[i].alias, alias) == 0)
+                        return &syscall_fmts[i];
+        }
+
+        return NULL;
+}
+
 /*
  * is_exit: is this "exit" or "exit_group"?
  * is_open: is this "open" or "openat"? To associate the fd returned in sys_exit with the pathname in sys_enter.
+ * args_size: sum of the sizes of the syscall arguments, anything after that is augmented stuff: pathname for openat, etc.
  */
 struct syscall {
-        struct event_format *tp_format;
+        struct tep_event_format *tp_format;
         int                 nr_args;
+        int                 args_size;
         bool                is_exit;
         bool                is_open;
-        struct format_field *args;
+        struct tep_format_field *args;
         const char          *name;
         struct syscall_fmt  *fmt;
         struct syscall_arg_fmt *arg_fmt;
@@ -1095,11 +1120,21 @@ static void thread__set_filename_pos(struct thread *thread, const char *bf,
         ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
 }
 
+static size_t syscall_arg__scnprintf_augmented_string(struct syscall_arg *arg, char *bf, size_t size)
+{
+        struct augmented_arg *augmented_arg = arg->augmented.args;
+
+        return scnprintf(bf, size, "%.*s", augmented_arg->size, augmented_arg->value);
+}
+
 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
                                               struct syscall_arg *arg)
 {
         unsigned long ptr = arg->val;
 
+        if (arg->augmented.args)
+                return syscall_arg__scnprintf_augmented_string(arg, bf, size);
+
         if (!arg->trace->vfs_getname)
                 return scnprintf(bf, size, "%#x", ptr);
 
@@ -1142,11 +1177,9 @@ static void sig_handler(int sig)
         interrupted = sig == SIGINT;
 }
 
-static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
-                                        u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
+static size_t trace__fprintf_comm_tid(struct trace *trace, struct thread *thread, FILE *fp)
 {
-        size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
-        printed += fprintf_duration(duration, duration_calculated, fp);
+        size_t printed = 0;
 
         if (trace->multiple_threads) {
                 if (trace->show_comm)
@@ -1157,6 +1190,14 @@ static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thre
         return printed;
 }
 
+static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
+                                        u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
+{
+        size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
+        printed += fprintf_duration(duration, duration_calculated, fp);
+        return printed + trace__fprintf_comm_tid(trace, thread, fp);
+}
+
 static int trace__process_event(struct trace *trace, struct machine *machine,
                                 union perf_event *event, struct perf_sample *sample)
 {
@@ -1258,10 +1299,12 @@ static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
 
 static int syscall__set_arg_fmts(struct syscall *sc)
 {
-        struct format_field *field;
+        struct tep_format_field *field, *last_field = NULL;
         int idx = 0, len;
 
         for (field = sc->args; field; field = field->next, ++idx) {
+                last_field = field;
+
                 if (sc->fmt && sc->fmt->arg[idx].scnprintf)
                         continue;
 
@@ -1270,7 +1313,7 @@ static int syscall__set_arg_fmts(struct syscall *sc)
                           strcmp(field->name, "path") == 0 ||
                           strcmp(field->name, "pathname") == 0))
                         sc->arg_fmt[idx].scnprintf = SCA_FILENAME;
-                else if (field->flags & FIELD_IS_POINTER)
+                else if (field->flags & TEP_FIELD_IS_POINTER)
                         sc->arg_fmt[idx].scnprintf = syscall_arg__scnprintf_hex;
                 else if (strcmp(field->type, "pid_t") == 0)
                         sc->arg_fmt[idx].scnprintf = SCA_PID;
@@ -1292,6 +1335,9 @@ static int syscall__set_arg_fmts(struct syscall *sc)
                 }
         }
 
+        if (last_field)
+                sc->args_size = last_field->offset + last_field->size;
+
         return 0;
 }
 
@@ -1459,6 +1505,19 @@ static size_t syscall__scnprintf_name(struct syscall *sc, char *bf, size_t size,
         return scnprintf(bf, size, "arg%d: ", arg->idx);
 }
 
+/*
+ * Check if the value is in fact zero, i.e. mask whatever needs masking, such
+ * as mount 'flags' argument that needs ignoring some magic flag, see comment
+ * in tools/perf/trace/beauty/mount_flags.c
+ */
+static unsigned long syscall__mask_val(struct syscall *sc, struct syscall_arg *arg, unsigned long val)
+{
+        if (sc->arg_fmt && sc->arg_fmt[arg->idx].mask_val)
+                return sc->arg_fmt[arg->idx].mask_val(arg, val);
+
+        return val;
+}
+
 static size_t syscall__scnprintf_val(struct syscall *sc, char *bf, size_t size,
                                      struct syscall_arg *arg, unsigned long val)
 {
@@ -1472,14 +1531,18 @@ static size_t syscall__scnprintf_val(struct syscall *sc, char *bf, size_t size,
 }
 
 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
-                                      unsigned char *args, struct trace *trace,
-                                      struct thread *thread)
+                                      unsigned char *args, void *augmented_args, int augmented_args_size,
+                                      struct trace *trace, struct thread *thread)
 {
         size_t printed = 0;
         unsigned long val;
         u8 bit = 1;
         struct syscall_arg arg = {
                 .args   = args,
+                .augmented = {
+                        .size = augmented_args_size,
+                        .args = augmented_args,
+                },
                 .idx    = 0,
                 .mask   = 0,
                 .trace  = trace,
@@ -1495,7 +1558,7 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
         ttrace->ret_scnprintf = NULL;
 
         if (sc->args != NULL) {
-                struct format_field *field;
+                struct tep_format_field *field;
 
                 for (field = sc->args; field;
                      field = field->next, ++arg.idx, bit <<= 1) {
@@ -1503,6 +1566,11 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                                 continue;
 
                         val = syscall_arg__val(&arg, arg.idx);
+                        /*
+                         * Some syscall args need some mask, most don't and
+                         * return val untouched.
+                         */
+                        val = syscall__mask_val(sc, &arg, val);
 
                         /*
                          * Suppress this argument if its value is zero and
@@ -1634,6 +1702,8 @@ static int trace__printf_interrupted_entry(struct trace *trace)
         printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
         ttrace->entry_pending = false;
 
+        ++trace->nr_events_printed;
+
         return printed;
 }
 
@@ -1654,6 +1724,17 @@ static int trace__fprintf_sample(struct trace *trace, struct perf_evsel *evsel,
         return printed;
 }
 
+static void *syscall__augmented_args(struct syscall *sc, struct perf_sample *sample, int *augmented_args_size)
+{
+        void *augmented_args = NULL;
+
+        *augmented_args_size = sample->raw_size - sc->args_size;
+        if (*augmented_args_size > 0)
+                augmented_args = sample->raw_data + sc->args_size;
+
+        return augmented_args;
+}
+
 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                             union perf_event *event __maybe_unused,
                             struct perf_sample *sample)
@@ -1663,6 +1744,8 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
         size_t printed = 0;
         struct thread *thread;
         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
+        int augmented_args_size = 0;
+        void *augmented_args = NULL;
         struct syscall *sc = trace__syscall_info(trace, evsel, id);
         struct thread_trace *ttrace;
 
@@ -1686,13 +1769,24 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
 
         if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
                 trace__printf_interrupted_entry(trace);
-
+        /*
+         * If this is raw_syscalls.sys_enter, then it always comes with the 6 possible
+         * arguments, even if the syscall being handled, say "openat", uses only 4 arguments
+         * this breaks syscall__augmented_args() check for augmented args, as we calculate
+         * syscall->args_size using each syscalls:sys_enter_NAME tracefs format file,
+         * so when handling, say the openat syscall, we end up getting 6 args for the
+         * raw_syscalls:sys_enter event, when we expected just 4, we end up mistakenly
+         * thinking that the extra 2 u64 args are the augmented filename, so just check
+         * here and avoid using augmented syscalls when the evsel is the raw_syscalls one.
+         */
+        if (evsel != trace->syscalls.events.sys_enter)
+                augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size);
         ttrace->entry_time = sample->time;
         msg = ttrace->entry_str;
         printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
 
         printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
-                                           args, trace, thread);
+                                           args, augmented_args, augmented_args_size, trace, thread);
 
         if (sc->is_exit) {
                 if (!(trace->duration_filter || trace->summary_only || trace->failure_only || trace->min_stack)) {
@@ -1723,7 +1817,8 @@ static int trace__fprintf_sys_enter(struct trace *trace, struct perf_evsel *evse
         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
         struct syscall *sc = trace__syscall_info(trace, evsel, id);
         char msg[1024];
-        void *args;
+        void *args, *augmented_args = NULL;
+        int augmented_args_size;
 
         if (sc == NULL)
                 return -1;
@@ -1738,7 +1833,8 @@ static int trace__fprintf_sys_enter(struct trace *trace, struct perf_evsel *evse
                 goto out_put;
 
         args = perf_evsel__sc_tp_ptr(evsel, args, sample);
-        syscall__scnprintf_args(sc, msg, sizeof(msg), args, trace, thread);
+        augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size);
+        syscall__scnprintf_args(sc, msg, sizeof(msg), args, augmented_args, augmented_args_size, trace, thread);
         fprintf(trace->output, "%s", msg);
         err = 0;
 out_put:
@@ -1754,12 +1850,14 @@ static int trace__resolve_callchain(struct trace *trace, struct perf_evsel *evse
         int max_stack = evsel->attr.sample_max_stack ?
                         evsel->attr.sample_max_stack :
                         trace->max_stack;
+        int err;
 
-        if (machine__resolve(trace->host, &al, sample) < 0 ||
-            thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, max_stack))
+        if (machine__resolve(trace->host, &al, sample) < 0)
                 return -1;
 
-        return 0;
+        err = thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, max_stack);
+        addr_location__put(&al);
+        return err;
 }
 
 static int trace__fprintf_callchain(struct trace *trace, struct perf_sample *sample)
@@ -1884,6 +1982,13 @@ errno_print: {
 
         fputc('\n', trace->output);
 
+        /*
+         * We only consider an 'event' for the sake of --max-events a non-filtered
+         * sys_enter + sys_exit and other tracepoint events.
+         */
+        if (++trace->nr_events_printed == trace->max_events && trace->max_events != ULONG_MAX)
+                interrupted = true;
+
         if (callchain_ret > 0)
                 trace__fprintf_callchain(trace, sample);
         else if (callchain_ret < 0)
@@ -2016,13 +2121,25 @@ static void bpf_output__fprintf(struct trace *trace,
 {
         binary__fprintf(sample->raw_data, sample->raw_size, 8,
                         bpf_output__printer, NULL, trace->output);
+        ++trace->nr_events_printed;
 }
 
 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
                                 union perf_event *event __maybe_unused,
                                 struct perf_sample *sample)
 {
+        struct thread *thread;
         int callchain_ret = 0;
+        /*
+         * Check if we called perf_evsel__disable(evsel) due to, for instance,
+         * this event's max_events having been hit and this is an entry coming
+         * from the ring buffer that we should discard, since the max events
+         * have already been considered/printed.
+         */
+        if (evsel->disabled)
+                return 0;
+
+        thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
 
         if (sample->callchain) {
                 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
@@ -2039,22 +2156,47 @@ static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
         if (trace->trace_syscalls)
                 fprintf(trace->output, "(         ): ");
 
+        if (thread)
+                trace__fprintf_comm_tid(trace, thread, trace->output);
+
+        if (evsel == trace->syscalls.events.augmented) {
+                int id = perf_evsel__sc_tp_uint(evsel, id, sample);
+                struct syscall *sc = trace__syscall_info(trace, evsel, id);
+
+                if (sc) {
+                        fprintf(trace->output, "%s(", sc->name);
+                        trace__fprintf_sys_enter(trace, evsel, sample);
+                        fputc(')', trace->output);
+                        goto newline;
+                }
+
+                /*
+                 * XXX: Not having the associated syscall info or not finding/adding
+                 *      the thread should never happen, but if it does...
+                 *      fall thru and print it as a bpf_output event.
+                 */
+        }
+
         fprintf(trace->output, "%s:", evsel->name);
 
         if (perf_evsel__is_bpf_output(evsel)) {
-                if (evsel == trace->syscalls.events.augmented)
-                        trace__fprintf_sys_enter(trace, evsel, sample);
-                else
-                        bpf_output__fprintf(trace, sample);
+                bpf_output__fprintf(trace, sample);
         } else if (evsel->tp_format) {
                 if (strncmp(evsel->tp_format->name, "sys_enter_", 10) ||
                     trace__fprintf_sys_enter(trace, evsel, sample)) {
                         event_format__fprintf(evsel->tp_format, sample->cpu,
                                               sample->raw_data, sample->raw_size,
                                               trace->output);
+                        ++trace->nr_events_printed;
+
+                        if (evsel->max_events != ULONG_MAX && ++evsel->nr_events_printed == evsel->max_events) {
+                                perf_evsel__disable(evsel);
+                                perf_evsel__close(evsel);
+                        }
                 }
         }
 
+newline:
         fprintf(trace->output, "\n");
 
         if (callchain_ret > 0)
@@ -2062,6 +2204,7 @@ static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
         else if (callchain_ret < 0)
                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
 out:
+        thread__put(thread);
         return 0;
 }
 
@@ -2148,6 +2291,8 @@ static int trace__pgfault(struct trace *trace,
                 trace__fprintf_callchain(trace, sample);
         else if (callchain_ret < 0)
                 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
+
+        ++trace->nr_events_printed;
 out:
         err = 0;
 out_put:
@@ -2325,6 +2470,9 @@ static void trace__handle_event(struct trace *trace, union perf_event *event, st
                 tracepoint_handler handler = evsel->handler;
                 handler(trace, evsel, event, sample);
         }
+
+        if (trace->nr_events_printed >= trace->max_events && trace->max_events != ULONG_MAX)
+                interrupted = true;
 }
 
 static int trace__add_syscall_newtp(struct trace *trace)
@@ -2629,7 +2777,7 @@ next_event:
                 int timeout = done ? 100 : -1;
 
                 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
-                        if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
+                        if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP | POLLNVAL) == 0)
                                 draining = true;
 
                         goto again;
@@ -3061,6 +3209,7 @@ static int trace__parse_events_option(const struct option *opt, const char *str,
         int len = strlen(str) + 1, err = -1, list, idx;
         char *strace_groups_dir = system_path(STRACE_GROUPS_DIR);
         char group_name[PATH_MAX];
+        struct syscall_fmt *fmt;
 
         if (strace_groups_dir == NULL)
                 return -1;
@@ -3078,12 +3227,19 @@ static int trace__parse_events_option(const struct option *opt, const char *str,
                 if (syscalltbl__id(trace->sctbl, s) >= 0 ||
                     syscalltbl__strglobmatch_first(trace->sctbl, s, &idx) >= 0) {
                         list = 1;
+                        goto do_concat;
+                }
+
+                fmt = syscall_fmt__find_by_alias(s);
+                if (fmt != NULL) {
+                        list = 1;
+                        s = fmt->name;
                 } else {
                         path__join(group_name, sizeof(group_name), strace_groups_dir, s);
                         if (access(group_name, R_OK) == 0)
                                 list = 1;
                 }
-
+do_concat:
                 if (lists[list]) {
                         sprintf(lists[list] + strlen(lists[list]), ",%s", s);
                 } else {
@@ -3172,6 +3328,7 @@ int cmd_trace(int argc, const char **argv)
                 .trace_syscalls = false,
                 .kernel_syscallchains = false,
                 .max_stack = UINT_MAX,
+                .max_events = ULONG_MAX,
         };
         const char *output_name = NULL;
         const struct option trace_options[] = {
@@ -3224,6 +3381,8 @@ int cmd_trace(int argc, const char **argv)
                      &record_parse_callchain_opt),
         OPT_BOOLEAN(0, "kernel-syscall-graph", &trace.kernel_syscallchains,
                     "Show the kernel callchains on the syscall exit path"),
+        OPT_ULONG(0, "max-events", &trace.max_events,
+                "Set the maximum number of events to print, exit after that is reached. "),
         OPT_UINTEGER(0, "min-stack", &trace.min_stack,
                      "Set the minimum stack depth when parsing the callchain, "
                      "anything below the specified depth will be ignored."),
@@ -3276,12 +3435,8 @@ int cmd_trace(int argc, const char **argv)
                 goto out;
         }
 
-        if (evsel) {
-                if (perf_evsel__init_augmented_syscall_tp(evsel) ||
-                    perf_evsel__init_augmented_syscall_tp_args(evsel))
-                        goto out;
+        if (evsel)
                 trace.syscalls.events.augmented = evsel;
-        }
 
         err = bpf__setup_stdout(trace.evlist);
         if (err) {
@@ -3326,6 +3481,34 @@ int cmd_trace(int argc, const char **argv)
                 }
         }
 
+        /*
+         * If we are augmenting syscalls, then combine what we put in the
+         * __augmented_syscalls__ BPF map with what is in the
+         * syscalls:sys_exit_FOO tracepoints, i.e. just like we do without BPF,
+         * combining raw_syscalls:sys_enter with raw_syscalls:sys_exit.
+         *
+         * We'll switch to look at two BPF maps, one for sys_enter and the
+         * other for sys_exit when we start augmenting the sys_exit paths with
+         * buffers that are being copied from kernel to userspace, think 'read'
+         * syscall.
+         */
+        if (trace.syscalls.events.augmented) {
+                evsel = trace.syscalls.events.augmented;
+
+                if (perf_evsel__init_augmented_syscall_tp(evsel) ||
+                    perf_evsel__init_augmented_syscall_tp_args(evsel))
+                        goto out;
+                evsel->handler = trace__sys_enter;
+
+                evlist__for_each_entry(trace.evlist, evsel) {
+                        if (strstarts(perf_evsel__name(evsel), "syscalls:sys_exit_")) {
+                                perf_evsel__init_augmented_syscall_tp(evsel);
+                                perf_evsel__init_augmented_syscall_tp_ret(evsel);
+                                evsel->handler = trace__sys_exit;
+                        }
+                }
+        }
+
         if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
                 return trace__record(&trace, argc-1, &argv[1]);
 
diff --git a/tools/perf/check-headers.sh b/tools/perf/check-headers.sh
index 466540ee8ea7..9531f7bd7d9b 100755
--- a/tools/perf/check-headers.sh
+++ b/tools/perf/check-headers.sh
@@ -5,6 +5,7 @@ HEADERS='
 include/uapi/drm/drm.h
 include/uapi/drm/i915_drm.h
 include/uapi/linux/fcntl.h
+include/uapi/linux/fs.h
 include/uapi/linux/kcmp.h
 include/uapi/linux/kvm.h
 include/uapi/linux/in.h
@@ -14,6 +15,7 @@ include/uapi/linux/sched.h
 include/uapi/linux/stat.h
 include/uapi/linux/vhost.h
 include/uapi/sound/asound.h
+include/linux/bits.h
 include/linux/hash.h
 include/uapi/linux/hw_breakpoint.h
 arch/x86/include/asm/disabled-features.h
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 2d0caf20ff3a..bc6c585f74fc 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -30,3 +30,4 @@ perf-test			mainporcelain common
 perf-timechart                  mainporcelain common
 perf-top                        mainporcelain common
 perf-trace                      mainporcelain audit
+perf-version                    mainporcelain common
diff --git a/tools/perf/examples/bpf/augmented_syscalls.c b/tools/perf/examples/bpf/augmented_syscalls.c
index 69a31386d8cd..2ae44813ef2d 100644
--- a/tools/perf/examples/bpf/augmented_syscalls.c
+++ b/tools/perf/examples/bpf/augmented_syscalls.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * Augment the openat syscall with the contents of the filename pointer argument.
+ * Augment syscalls with the contents of the pointer arguments.
  *
  * Test it with:
  *
@@ -10,15 +10,14 @@
  * the last one should be the one for '/etc/passwd'.
  *
  * This matches what is marshalled into the raw_syscall:sys_enter payload
- * expected by the 'perf trace' beautifiers, and can be used by them unmodified,
- * which will be done as that feature is implemented in the next csets, for now
- * it will appear in a dump done by the default tracepoint handler in 'perf trace',
- * that uses bpf_output__fprintf() to just dump those contents, as done with
- * the bpf-output event associated with the __bpf_output__ map declared in
- * tools/perf/include/bpf/stdio.h.
+ * expected by the 'perf trace' beautifiers, and can be used by them, that will
+ * check if perf_sample->raw_data is more than what is expected for each
+ * syscalls:sys_{enter,exit}_SYSCALL tracepoint, uing the extra data as the
+ * contents of pointer arguments.
  */
 
 #include <stdio.h>
+#include <linux/socket.h>
 
 struct bpf_map SEC("maps") __augmented_syscalls__ = {
        .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
@@ -27,6 +26,44 @@ struct bpf_map SEC("maps") __augmented_syscalls__ = {
        .max_entries = __NR_CPUS__,
 };
 
+struct syscall_exit_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               ret;
+};
+
+struct augmented_filename {
+        unsigned int    size;
+        int             reserved;
+        char            value[256];
+};
+
+#define augmented_filename_syscall(syscall)                                                     \
+struct augmented_enter_##syscall##_args {                                                       \
+        struct syscall_enter_##syscall##_args   args;                                           \
+        struct augmented_filename               filename;                                       \
+};                                                                                              \
+int syscall_enter(syscall)(struct syscall_enter_##syscall##_args *args)                         \
+{                                                                                               \
+        struct augmented_enter_##syscall##_args augmented_args = { .filename.reserved = 0, };   \
+        unsigned int len = sizeof(augmented_args);                                              \
+        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);                    \
+        augmented_args.filename.size = probe_read_str(&augmented_args.filename.value,           \
+                                                      sizeof(augmented_args.filename.value),    \
+                                                      args->filename_ptr);                      \
+        if (augmented_args.filename.size < sizeof(augmented_args.filename.value)) {             \
+                len -= sizeof(augmented_args.filename.value) - augmented_args.filename.size;    \
+                len &= sizeof(augmented_args.filename.value) - 1;                               \
+        }                                                                                       \
+        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,                     \
+                          &augmented_args, len);                                                \
+        return 0;                                                                               \
+}                                                                                               \
+int syscall_exit(syscall)(struct syscall_exit_args *args)                                       \
+{                                                                                               \
+       return 1; /* 0 as soon as we start copying data returned by the kernel, e.g. 'read' */   \
+}
+
 struct syscall_enter_openat_args {
         unsigned long long common_tp_fields;
         long               syscall_nr;
@@ -36,20 +73,101 @@ struct syscall_enter_openat_args {
         long               mode;
 };
 
-struct augmented_enter_openat_args {
-        struct syscall_enter_openat_args args;
-        char                             filename[64];
+augmented_filename_syscall(openat);
+
+struct syscall_enter_open_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        char               *filename_ptr;
+        long               flags;
+        long               mode;
+};
+
+augmented_filename_syscall(open);
+
+struct syscall_enter_inotify_add_watch_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        char               *filename_ptr;
+        long               mask;
+};
+
+augmented_filename_syscall(inotify_add_watch);
+
+struct statbuf;
+
+struct syscall_enter_newstat_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        char               *filename_ptr;
+        struct stat        *statbuf;
 };
 
-int syscall_enter(openat)(struct syscall_enter_openat_args *args)
-{
-        struct augmented_enter_openat_args augmented_args;
+augmented_filename_syscall(newstat);
+
+#ifndef _K_SS_MAXSIZE
+#define _K_SS_MAXSIZE 128
+#endif
 
-        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);
-        probe_read_str(&augmented_args.filename, sizeof(augmented_args.filename), args->filename_ptr);
-        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,
-                          &augmented_args, sizeof(augmented_args));
-        return 1;
+#define augmented_sockaddr_syscall(syscall)                                             \
+struct augmented_enter_##syscall##_args {                                                       \
+        struct syscall_enter_##syscall##_args   args;                                           \
+        struct sockaddr_storage                 addr;                                           \
+};                                                                                              \
+int syscall_enter(syscall)(struct syscall_enter_##syscall##_args *args)                         \
+{                                                                                               \
+        struct augmented_enter_##syscall##_args augmented_args;                                 \
+        unsigned long addrlen = sizeof(augmented_args.addr);                                    \
+        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);                    \
+/* FIXME_CLANG_OPTIMIZATION_THAT_ACCESSES_USER_CONTROLLED_ADDRLEN_DESPITE_THIS_CHECK */         \
+/*      if (addrlen > augmented_args.args.addrlen)                                   */         \
+/*              addrlen = augmented_args.args.addrlen;                               */         \
+/*                                                                                   */         \
+        probe_read(&augmented_args.addr, addrlen, args->addr_ptr);                              \
+        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,                     \
+                          &augmented_args,                                                      \
+                          sizeof(augmented_args) - sizeof(augmented_args.addr) + addrlen);      \
+        return 0;                                                                               \
+}                                                                                               \
+int syscall_exit(syscall)(struct syscall_exit_args *args)                                       \
+{                                                                                               \
+       return 1; /* 0 as soon as we start copying data returned by the kernel, e.g. 'read' */   \
 }
 
+struct sockaddr;
+
+struct syscall_enter_bind_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        struct sockaddr    *addr_ptr;
+        unsigned long      addrlen;
+};
+
+augmented_sockaddr_syscall(bind);
+
+struct syscall_enter_connect_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        struct sockaddr    *addr_ptr;
+        unsigned long      addrlen;
+};
+
+augmented_sockaddr_syscall(connect);
+
+struct syscall_enter_sendto_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               fd;
+        void               *buff;
+        long               len;
+        unsigned long      flags;
+        struct sockaddr    *addr_ptr;
+        long               addr_len;
+};
+
+augmented_sockaddr_syscall(sendto);
+
 license(GPL);
diff --git a/tools/perf/examples/bpf/etcsnoop.c b/tools/perf/examples/bpf/etcsnoop.c
new file mode 100644
index 000000000000..b59e8812ee8c
--- /dev/null
+++ b/tools/perf/examples/bpf/etcsnoop.c
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Augment the filename syscalls with the contents of the filename pointer argument
+ * filtering only those that do not start with /etc/.
+ *
+ * Test it with:
+ *
+ * perf trace -e tools/perf/examples/bpf/augmented_syscalls.c cat /etc/passwd > /dev/null
+ *
+ * It'll catch some openat syscalls related to the dynamic linked and
+ * the last one should be the one for '/etc/passwd'.
+ *
+ * This matches what is marshalled into the raw_syscall:sys_enter payload
+ * expected by the 'perf trace' beautifiers, and can be used by them unmodified,
+ * which will be done as that feature is implemented in the next csets, for now
+ * it will appear in a dump done by the default tracepoint handler in 'perf trace',
+ * that uses bpf_output__fprintf() to just dump those contents, as done with
+ * the bpf-output event associated with the __bpf_output__ map declared in
+ * tools/perf/include/bpf/stdio.h.
+ */
+
+#include <stdio.h>
+
+struct bpf_map SEC("maps") __augmented_syscalls__ = {
+       .type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
+       .key_size = sizeof(int),
+       .value_size = sizeof(u32),
+       .max_entries = __NR_CPUS__,
+};
+
+struct augmented_filename {
+        int     size;
+        int     reserved;
+        char    value[64];
+};
+
+#define augmented_filename_syscall_enter(syscall)                                               \
+struct augmented_enter_##syscall##_args {                                                       \
+        struct syscall_enter_##syscall##_args   args;                                           \
+        struct augmented_filename               filename;                                       \
+};                                                                                              \
+int syscall_enter(syscall)(struct syscall_enter_##syscall##_args *args)                         \
+{                                                                                               \
+        char etc[6] = "/etc/";                                                                  \
+        struct augmented_enter_##syscall##_args augmented_args = { .filename.reserved = 0, };   \
+        probe_read(&augmented_args.args, sizeof(augmented_args.args), args);                    \
+        augmented_args.filename.size = probe_read_str(&augmented_args.filename.value,           \
+                                                      sizeof(augmented_args.filename.value),    \
+                                                      args->filename_ptr);                      \
+        if (__builtin_memcmp(augmented_args.filename.value, etc, 4) != 0)                       \
+                return 0;                                                                       \
+        perf_event_output(args, &__augmented_syscalls__, BPF_F_CURRENT_CPU,                     \
+                          &augmented_args,                                                      \
+                          (sizeof(augmented_args) - sizeof(augmented_args.filename.value) +     \
+                           augmented_args.filename.size));                                      \
+        return 0;                                                                               \
+}
+
+struct syscall_enter_openat_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        long               dfd;
+        char               *filename_ptr;
+        long               flags;
+        long               mode;
+};
+
+augmented_filename_syscall_enter(openat);
+
+struct syscall_enter_open_args {
+        unsigned long long common_tp_fields;
+        long               syscall_nr;
+        char               *filename_ptr;
+        long               flags;
+        long               mode;
+};
+
+augmented_filename_syscall_enter(open);
+
+license(GPL);
diff --git a/tools/perf/include/bpf/bpf.h b/tools/perf/include/bpf/bpf.h
index 47897d65e799..52b6d87fe822 100644
--- a/tools/perf/include/bpf/bpf.h
+++ b/tools/perf/include/bpf/bpf.h
@@ -26,6 +26,9 @@ struct bpf_map {
 #define syscall_enter(name) \
         SEC("syscalls:sys_enter_" #name) syscall_enter_ ## name
 
+#define syscall_exit(name) \
+        SEC("syscalls:sys_exit_" #name) syscall_exit_ ## name
+
 #define license(name) \
 char _license[] SEC("license") = #name; \
 int _version SEC("version") = LINUX_VERSION_CODE;
diff --git a/tools/perf/include/bpf/linux/socket.h b/tools/perf/include/bpf/linux/socket.h
new file mode 100644
index 000000000000..7f844568dab8
--- /dev/null
+++ b/tools/perf/include/bpf/linux/socket.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_SOCKET_H
+#define _UAPI_LINUX_SOCKET_H
+
+/*
+ * Desired design of maximum size and alignment (see RFC2553)
+ */
+#define _K_SS_MAXSIZE   128     /* Implementation specific max size */
+#define _K_SS_ALIGNSIZE (__alignof__ (struct sockaddr *))
+                                /* Implementation specific desired alignment */
+
+typedef unsigned short __kernel_sa_family_t;
+
+struct __kernel_sockaddr_storage {
+        __kernel_sa_family_t    ss_family;              /* address family */
+        /* Following field(s) are implementation specific */
+        char            __data[_K_SS_MAXSIZE - sizeof(unsigned short)];
+                                /* space to achieve desired size, */
+                                /* _SS_MAXSIZE value minus size of ss_family */
+} __attribute__ ((aligned(_K_SS_ALIGNSIZE)));   /* force desired alignment */
+
+#define sockaddr_storage __kernel_sockaddr_storage
+
+#endif /* _UAPI_LINUX_SOCKET_H */
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 21bf7f5a3cf5..0ed4a34c74c4 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -81,6 +81,7 @@ struct record_opts {
         unsigned     initial_delay;
         bool         use_clockid;
         clockid_t    clockid;
+        u64          clockid_res_ns;
         unsigned int proc_map_timeout;
 };
 
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/branch.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/branch.json
new file mode 100644
index 000000000000..abc98b018446
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/branch.json
@@ -0,0 +1,23 @@
+[
+    {
+        "ArchStdEvent": "BR_IMMED_SPEC",
+    },
+    {
+        "ArchStdEvent": "BR_RETURN_SPEC",
+    },
+    {
+        "ArchStdEvent": "BR_INDIRECT_SPEC",
+    },
+    {
+        "PublicDescription": "Mispredicted or not predicted branch speculatively executed",
+        "EventCode": "0x10",
+        "EventName": "BR_MIS_PRED",
+        "BriefDescription": "Branch mispredicted"
+    },
+    {
+        "PublicDescription": "Predictable branch speculatively executed",
+        "EventCode": "0x12",
+        "EventName": "BR_PRED",
+        "BriefDescription": "Predictable branch"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/bus.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/bus.json
new file mode 100644
index 000000000000..687b2629e1d1
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/bus.json
@@ -0,0 +1,26 @@
+[
+    {
+        "ArchStdEvent": "BUS_ACCESS_RD",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_WR",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_SHARED",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_NOT_SHARED",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_NORMAL",
+    },
+    {
+        "ArchStdEvent": "BUS_ACCESS_PERIPH",
+    },
+    {
+        "PublicDescription": "Bus access",
+        "EventCode": "0x19",
+        "EventName": "BUS_ACCESS",
+        "BriefDescription": "Bus access"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/cache.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/cache.json
new file mode 100644
index 000000000000..df9201434cb6
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/cache.json
@@ -0,0 +1,191 @@
+[
+    {
+        "ArchStdEvent": "L1D_CACHE_RD",
+    },
+    {
+        "ArchStdEvent": "L1D_CACHE_WR",
+    },
+    {
+        "ArchStdEvent": "L1D_CACHE_REFILL_RD",
+    },
+    {
+        "ArchStdEvent": "L1D_CACHE_INVAL",
+    },
+    {
+        "ArchStdEvent": "L1D_TLB_REFILL_RD",
+    },
+    {
+        "ArchStdEvent": "L1D_TLB_REFILL_WR",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_RD",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_WR",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_REFILL_RD",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_REFILL_WR",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_WB_VICTIM",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_WB_CLEAN",
+    },
+    {
+        "ArchStdEvent": "L2D_CACHE_INVAL",
+    },
+    {
+        "PublicDescription": "Level 1 instruction cache refill",
+        "EventCode": "0x01",
+        "EventName": "L1I_CACHE_REFILL",
+        "BriefDescription": "L1I cache refill"
+    },
+    {
+        "PublicDescription": "Level 1 instruction TLB refill",
+        "EventCode": "0x02",
+        "EventName": "L1I_TLB_REFILL",
+        "BriefDescription": "L1I TLB refill"
+    },
+    {
+        "PublicDescription": "Level 1 data cache refill",
+        "EventCode": "0x03",
+        "EventName": "L1D_CACHE_REFILL",
+        "BriefDescription": "L1D cache refill"
+    },
+    {
+        "PublicDescription": "Level 1 data cache access",
+        "EventCode": "0x04",
+        "EventName": "L1D_CACHE_ACCESS",
+        "BriefDescription": "L1D cache access"
+    },
+    {
+        "PublicDescription": "Level 1 data TLB refill",
+        "EventCode": "0x05",
+        "EventName": "L1D_TLB_REFILL",
+        "BriefDescription": "L1D TLB refill"
+    },
+    {
+        "PublicDescription": "Level 1 instruction cache access",
+        "EventCode": "0x14",
+        "EventName": "L1I_CACHE_ACCESS",
+        "BriefDescription": "L1I cache access"
+    },
+    {
+        "PublicDescription": "Level 2 data cache access",
+        "EventCode": "0x16",
+        "EventName": "L2D_CACHE_ACCESS",
+        "BriefDescription": "L2D cache access"
+    },
+    {
+        "PublicDescription": "Level 2 data refill",
+        "EventCode": "0x17",
+        "EventName": "L2D_CACHE_REFILL",
+        "BriefDescription": "L2D cache refill"
+    },
+    {
+        "PublicDescription": "Level 2 data cache, Write-Back",
+        "EventCode": "0x18",
+        "EventName": "L2D_CACHE_WB",
+        "BriefDescription": "L2D cache Write-Back"
+    },
+    {
+        "PublicDescription": "Level 1 data TLB access. This event counts any load or store operation which accesses the data L1 TLB",
+        "EventCode": "0x25",
+        "EventName": "L1D_TLB_ACCESS",
+        "BriefDescription": "L1D TLB access"
+    },
+    {
+        "PublicDescription": "Level 1 instruction TLB access. This event counts any instruction fetch which accesses the instruction L1 TLB",
+        "EventCode": "0x26",
+        "EventName": "L1I_TLB_ACCESS",
+        "BriefDescription": "L1I TLB access"
+    },
+    {
+        "PublicDescription": "Level 2 access to data TLB that caused a page table walk. This event counts on any data access which causes L2D_TLB_REFILL to count",
+        "EventCode": "0x34",
+        "EventName": "L2D_TLB_ACCESS",
+        "BriefDescription": "L2D TLB access"
+    },
+    {
+        "PublicDescription": "Level 2 access to instruciton TLB that caused a page table walk. This event counts on any instruciton access which causes L2I_TLB_REFILL to count",
+        "EventCode": "0x35",
+        "EventName": "L2I_TLB_ACCESS",
+        "BriefDescription": "L2D TLB access"
+    },
+    {
+        "PublicDescription": "Branch target buffer misprediction",
+        "EventCode": "0x102",
+        "EventName": "BTB_MIS_PRED",
+        "BriefDescription": "BTB misprediction"
+    },
+    {
+        "PublicDescription": "ITB miss",
+        "EventCode": "0x103",
+        "EventName": "ITB_MISS",
+        "BriefDescription": "ITB miss"
+    },
+    {
+        "PublicDescription": "DTB miss",
+        "EventCode": "0x104",
+        "EventName": "DTB_MISS",
+        "BriefDescription": "DTB miss"
+    },
+    {
+        "PublicDescription": "Level 1 data cache late miss",
+        "EventCode": "0x105",
+        "EventName": "L1D_CACHE_LATE_MISS",
+        "BriefDescription": "L1D cache late miss"
+    },
+    {
+        "PublicDescription": "Level 1 data cache prefetch request",
+        "EventCode": "0x106",
+        "EventName": "L1D_CACHE_PREFETCH",
+        "BriefDescription": "L1D cache prefetch"
+    },
+    {
+        "PublicDescription": "Level 2 data cache prefetch request",
+        "EventCode": "0x107",
+        "EventName": "L2D_CACHE_PREFETCH",
+        "BriefDescription": "L2D cache prefetch"
+    },
+    {
+        "PublicDescription": "Level 1 stage 2 TLB refill",
+        "EventCode": "0x111",
+        "EventName": "L1_STAGE2_TLB_REFILL",
+        "BriefDescription": "L1 stage 2 TLB refill"
+    },
+    {
+        "PublicDescription": "Page walk cache level-0 stage-1 hit",
+        "EventCode": "0x112",
+        "EventName": "PAGE_WALK_L0_STAGE1_HIT",
+        "BriefDescription": "Page walk, L0 stage-1 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-1 stage-1 hit",
+        "EventCode": "0x113",
+        "EventName": "PAGE_WALK_L1_STAGE1_HIT",
+        "BriefDescription": "Page walk, L1 stage-1 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-2 stage-1 hit",
+        "EventCode": "0x114",
+        "EventName": "PAGE_WALK_L2_STAGE1_HIT",
+        "BriefDescription": "Page walk, L2 stage-1 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-1 stage-2 hit",
+        "EventCode": "0x115",
+        "EventName": "PAGE_WALK_L1_STAGE2_HIT",
+        "BriefDescription": "Page walk, L1 stage-2 hit"
+    },
+    {
+        "PublicDescription": "Page walk cache level-2 stage-2 hit",
+        "EventCode": "0x116",
+        "EventName": "PAGE_WALK_L2_STAGE2_HIT",
+        "BriefDescription": "Page walk, L2 stage-2 hit"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/clock.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/clock.json
new file mode 100644
index 000000000000..38cd1f1a70dc
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/clock.json
@@ -0,0 +1,20 @@
+[
+    {
+        "PublicDescription": "The number of core clock cycles",
+        "EventCode": "0x11",
+        "EventName": "CPU_CYCLES",
+        "BriefDescription": "Clock cycles"
+    },
+    {
+        "PublicDescription": "FSU clocking gated off cycle",
+        "EventCode": "0x101",
+        "EventName": "FSU_CLOCK_OFF_CYCLES",
+        "BriefDescription": "FSU clocking gated off cycle"
+    },
+    {
+        "PublicDescription": "Wait state cycle",
+        "EventCode": "0x110",
+        "EventName": "Wait_CYCLES",
+        "BriefDescription": "Wait state cycle"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/core-imp-def.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/core-imp-def.json
deleted file mode 100644
index bc03c06c3918..000000000000
--- a/tools/perf/pmu-events/arch/arm64/ampere/emag/core-imp-def.json
+++ /dev/null
@@ -1,32 +0,0 @@
-[
-    {
-        "ArchStdEvent": "L1D_CACHE_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_CACHE_WR",
-    },
-    {
-        "ArchStdEvent": "L1D_CACHE_REFILL_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_CACHE_REFILL_WR",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_REFILL_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_REFILL_WR",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_RD",
-    },
-    {
-        "ArchStdEvent": "L1D_TLB_WR",
-    },
-    {
-        "ArchStdEvent": "BUS_ACCESS_RD",
-   },
-   {
-        "ArchStdEvent": "BUS_ACCESS_WR",
-   }
-]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/exception.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/exception.json
new file mode 100644
index 000000000000..3720dc28a15f
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/exception.json
@@ -0,0 +1,50 @@
+[
+    {
+        "ArchStdEvent": "EXC_UNDEF",
+    },
+    {
+        "ArchStdEvent": "EXC_SVC",
+    },
+    {
+        "ArchStdEvent": "EXC_PABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_DABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_IRQ",
+    },
+    {
+        "ArchStdEvent": "EXC_FIQ",
+    },
+    {
+        "ArchStdEvent": "EXC_HVC",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_PABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_DABORT",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_OTHER",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_IRQ",
+    },
+    {
+        "ArchStdEvent": "EXC_TRAP_FIQ",
+    },
+    {
+        "PublicDescription": "Exception taken",
+        "EventCode": "0x09",
+        "EventName": "EXC_TAKEN",
+        "BriefDescription": "Exception taken"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, condition check pass, exception return",
+        "EventCode": "0x0a",
+        "EventName": "EXC_RETURN",
+        "BriefDescription": "Exception return"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/instruction.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/instruction.json
new file mode 100644
index 000000000000..82cf753e6472
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/instruction.json
@@ -0,0 +1,89 @@
+[
+    {
+        "ArchStdEvent": "LD_SPEC",
+    },
+    {
+        "ArchStdEvent": "ST_SPEC",
+    },
+    {
+        "ArchStdEvent": "LDST_SPEC",
+    },
+    {
+        "ArchStdEvent": "DP_SPEC",
+    },
+    {
+        "ArchStdEvent": "ASE_SPEC",
+    },
+    {
+        "ArchStdEvent": "VFP_SPEC",
+    },
+    {
+        "ArchStdEvent": "PC_WRITE_SPEC",
+    },
+    {
+        "ArchStdEvent": "CRYPTO_SPEC",
+    },
+    {
+        "ArchStdEvent": "ISB_SPEC",
+    },
+    {
+        "ArchStdEvent": "DSB_SPEC",
+    },
+    {
+        "ArchStdEvent": "DMB_SPEC",
+    },
+    {
+        "ArchStdEvent": "RC_LD_SPEC",
+    },
+    {
+        "ArchStdEvent": "RC_ST_SPEC",
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, software increment",
+        "EventCode": "0x00",
+        "EventName": "SW_INCR",
+        "BriefDescription": "Software increment"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed",
+        "EventCode": "0x08",
+        "EventName": "INST_RETIRED",
+        "BriefDescription": "Instruction retired"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, condition code check pass, write to CONTEXTIDR",
+        "EventCode": "0x0b",
+        "EventName": "CID_WRITE_RETIRED",
+        "BriefDescription": "Write to CONTEXTIDR"
+    },
+    {
+        "PublicDescription": "Operation speculatively executed",
+        "EventCode": "0x1b",
+        "EventName": "INST_SPEC",
+        "BriefDescription": "Speculatively executed"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed (condition check pass), write to TTBR",
+        "EventCode": "0x1c",
+        "EventName": "TTBR_WRITE_RETIRED",
+        "BriefDescription": "Instruction executed, TTBR write"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, branch. This event counts all branches, taken or not. This excludes exception entries, debug entries and CCFAIL branches",
+        "EventCode": "0x21",
+        "EventName": "BR_RETIRED",
+        "BriefDescription": "Branch retired"
+    },
+    {
+        "PublicDescription": "Instruction architecturally executed, mispredicted branch. This event counts any branch counted by BR_RETIRED which is not correctly predicted and causes a pipeline flush",
+        "EventCode": "0x22",
+        "EventName": "BR_MISPRED_RETIRED",
+        "BriefDescription": "Mispredicted branch retired"
+    },
+    {
+        "PublicDescription": "Operation speculatively executed, NOP",
+        "EventCode": "0x100",
+        "EventName": "NOP_SPEC",
+        "BriefDescription": "Speculatively executed, NOP"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/intrinsic.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/intrinsic.json
new file mode 100644
index 000000000000..2aecc5c2347d
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/intrinsic.json
@@ -0,0 +1,14 @@
+[
+    {
+        "ArchStdEvent": "LDREX_SPEC",
+    },
+    {
+        "ArchStdEvent": "STREX_PASS_SPEC",
+    },
+    {
+        "ArchStdEvent": "STREX_FAIL_SPEC",
+    },
+    {
+        "ArchStdEvent": "STREX_SPEC",
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/memory.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/memory.json
new file mode 100644
index 000000000000..08508697b318
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/memory.json
@@ -0,0 +1,29 @@
+[
+    {
+        "ArchStdEvent": "MEM_ACCESS_RD",
+    },
+    {
+        "ArchStdEvent": "MEM_ACCESS_WR",
+    },
+    {
+        "ArchStdEvent": "UNALIGNED_LD_SPEC",
+    },
+    {
+        "ArchStdEvent": "UNALIGNED_ST_SPEC",
+    },
+    {
+        "ArchStdEvent": "UNALIGNED_LDST_SPEC",
+    },
+    {
+        "PublicDescription": "Data memory access",
+        "EventCode": "0x13",
+        "EventName": "MEM_ACCESS",
+        "BriefDescription": "Memory access"
+    },
+    {
+        "PublicDescription": "Local memory error. This event counts any correctable or uncorrectable memory error (ECC or parity) in the protected core RAMs",
+        "EventCode": "0x1a",
+        "EventName": "MEM_ERROR",
+        "BriefDescription": "Memory error"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/arm64/ampere/emag/pipeline.json b/tools/perf/pmu-events/arch/arm64/ampere/emag/pipeline.json
new file mode 100644
index 000000000000..e2087de586bf
--- /dev/null
+++ b/tools/perf/pmu-events/arch/arm64/ampere/emag/pipeline.json
@@ -0,0 +1,50 @@
+[
+    {
+        "PublicDescription": "Decode starved for instruction cycle",
+        "EventCode": "0x108",
+        "EventName": "DECODE_STALL",
+        "BriefDescription": "Decode starved"
+    },
+    {
+        "PublicDescription": "Op dispatch stalled cycle",
+        "EventCode": "0x109",
+        "EventName": "DISPATCH_STALL",
+        "BriefDescription": "Dispatch stalled"
+    },
+    {
+        "PublicDescription": "IXA Op non-issue",
+        "EventCode": "0x10a",
+        "EventName": "IXA_STALL",
+        "BriefDescription": "IXA stalled"
+    },
+    {
+        "PublicDescription": "IXB Op non-issue",
+        "EventCode": "0x10b",
+        "EventName": "IXB_STALL",
+        "BriefDescription": "IXB stalled"
+    },
+    {
+        "PublicDescription": "BX Op non-issue",
+        "EventCode": "0x10c",
+        "EventName": "BX_STALL",
+        "BriefDescription": "BX stalled"
+    },
+    {
+        "PublicDescription": "LX Op non-issue",
+        "EventCode": "0x10d",
+        "EventName": "LX_STALL",
+        "BriefDescription": "LX stalled"
+    },
+    {
+        "PublicDescription": "SX Op non-issue",
+        "EventCode": "0x10e",
+        "EventName": "SX_STALL",
+        "BriefDescription": "SX stalled"
+    },
+    {
+        "PublicDescription": "FX Op non-issue",
+        "EventCode": "0x10f",
+        "EventName": "FX_STALL",
+        "BriefDescription": "FX stalled"
+    },
+]
diff --git a/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json b/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json
index d40498f2cb1e..635c09fda1d9 100644
--- a/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/ivytown/uncore-power.json
@@ -188,7 +188,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xb",
         "EventName": "UNC_P_FREQ_GE_1200MHZ_CYCLES",
-        "Filter": "filter_band0=1200",
+        "Filter": "filter_band0=12",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
@@ -199,7 +199,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xc",
         "EventName": "UNC_P_FREQ_GE_2000MHZ_CYCLES",
-        "Filter": "filter_band1=2000",
+        "Filter": "filter_band1=20",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
@@ -210,7 +210,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_P_FREQ_GE_3000MHZ_CYCLES",
-        "Filter": "filter_band2=3000",
+        "Filter": "filter_band2=30",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
@@ -221,7 +221,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xe",
         "EventName": "UNC_P_FREQ_GE_4000MHZ_CYCLES",
-        "Filter": "filter_band3=4000",
+        "Filter": "filter_band3=40",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
@@ -232,7 +232,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xb",
         "EventName": "UNC_P_FREQ_GE_1200MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band0=1200",
+        "Filter": "edge=1,filter_band0=12",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
@@ -243,7 +243,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xc",
         "EventName": "UNC_P_FREQ_GE_2000MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band1=2000",
+        "Filter": "edge=1,filter_band1=20",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
@@ -254,7 +254,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_P_FREQ_GE_3000MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band2=4000",
+        "Filter": "edge=1,filter_band2=30",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
@@ -265,7 +265,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xe",
         "EventName": "UNC_P_FREQ_GE_4000MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band3=4000",
+        "Filter": "edge=1,filter_band3=40",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
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 16034bfd06dd..8755693d86c6 100644
--- a/tools/perf/pmu-events/arch/x86/jaketown/uncore-power.json
+++ b/tools/perf/pmu-events/arch/x86/jaketown/uncore-power.json
@@ -187,7 +187,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xb",
         "EventName": "UNC_P_FREQ_GE_1200MHZ_CYCLES",
-        "Filter": "filter_band0=1200",
+        "Filter": "filter_band0=12",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
@@ -198,7 +198,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xc",
         "EventName": "UNC_P_FREQ_GE_2000MHZ_CYCLES",
-        "Filter": "filter_band1=2000",
+        "Filter": "filter_band1=20",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
@@ -209,7 +209,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_P_FREQ_GE_3000MHZ_CYCLES",
-        "Filter": "filter_band2=3000",
+        "Filter": "filter_band2=30",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
@@ -220,7 +220,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xe",
         "EventName": "UNC_P_FREQ_GE_4000MHZ_CYCLES",
-        "Filter": "filter_band3=4000",
+        "Filter": "filter_band3=40",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
@@ -231,7 +231,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xb",
         "EventName": "UNC_P_FREQ_GE_1200MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band0=1200",
+        "Filter": "edge=1,filter_band0=12",
         "MetricExpr": "(UNC_P_FREQ_GE_1200MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_1200mhz_cycles %",
         "PerPkg": "1",
@@ -242,7 +242,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xc",
         "EventName": "UNC_P_FREQ_GE_2000MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band1=2000",
+        "Filter": "edge=1,filter_band1=20",
         "MetricExpr": "(UNC_P_FREQ_GE_2000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_2000mhz_cycles %",
         "PerPkg": "1",
@@ -253,7 +253,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xd",
         "EventName": "UNC_P_FREQ_GE_3000MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band2=4000",
+        "Filter": "edge=1,filter_band2=30",
         "MetricExpr": "(UNC_P_FREQ_GE_3000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_3000mhz_cycles %",
         "PerPkg": "1",
@@ -264,7 +264,7 @@
         "Counter": "0,1,2,3",
         "EventCode": "0xe",
         "EventName": "UNC_P_FREQ_GE_4000MHZ_TRANSITIONS",
-        "Filter": "edge=1,filter_band3=4000",
+        "Filter": "edge=1,filter_band3=40",
         "MetricExpr": "(UNC_P_FREQ_GE_4000MHZ_CYCLES / UNC_P_CLOCKTICKS) * 100.",
         "MetricName": "freq_ge_4000mhz_cycles %",
         "PerPkg": "1",
diff --git a/tools/perf/scripts/python/call-graph-from-sql.py b/tools/perf/scripts/python/call-graph-from-sql.py
deleted file mode 100644
index b494a67a1c67..000000000000
--- a/tools/perf/scripts/python/call-graph-from-sql.py
+++ /dev/null
@@ -1,339 +0,0 @@
-#!/usr/bin/python2
-# call-graph-from-sql.py: create call-graph from sql database
-# Copyright (c) 2014-2017, 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.
-
-# To use this script you will need to have exported data using either the
-# export-to-sqlite.py or the export-to-postgresql.py script.  Refer to those
-# scripts for details.
-#
-# Following on from the example in the export scripts, a
-# call-graph can be displayed for the pt_example database like this:
-#
-#       python tools/perf/scripts/python/call-graph-from-sql.py pt_example
-#
-# Note that for PostgreSQL, this script supports connecting to remote databases
-# by setting hostname, port, username, password, and dbname e.g.
-#
-#       python tools/perf/scripts/python/call-graph-from-sql.py "hostname=myhost username=myuser password=mypassword dbname=pt_example"
-#
-# The result is a GUI window with a tree representing a context-sensitive
-# call-graph.  Expanding a couple of levels of the tree and adjusting column
-# widths to suit will display something like:
-#
-#                                         Call Graph: pt_example
-# Call Path                          Object      Count   Time(ns)  Time(%)  Branch Count   Branch Count(%)
-# v- ls
-#     v- 2638:2638
-#         v- _start                  ld-2.19.so    1     10074071   100.0         211135            100.0
-#           |- unknown               unknown       1        13198     0.1              1              0.0
-#           >- _dl_start             ld-2.19.so    1      1400980    13.9          19637              9.3
-#           >- _d_linit_internal     ld-2.19.so    1       448152     4.4          11094              5.3
-#           v-__libc_start_main@plt  ls            1      8211741    81.5         180397             85.4
-#              >- _dl_fixup          ld-2.19.so    1         7607     0.1            108              0.1
-#              >- __cxa_atexit       libc-2.19.so  1        11737     0.1             10              0.0
-#              >- __libc_csu_init    ls            1        10354     0.1             10              0.0
-#              |- _setjmp            libc-2.19.so  1            0     0.0              4              0.0
-#              v- main               ls            1      8182043    99.6         180254             99.9
-#
-# Points to note:
-#       The top level is a command name (comm)
-#       The next level is a thread (pid:tid)
-#       Subsequent levels are functions
-#       'Count' is the number of calls
-#       'Time' is the elapsed time until the function returns
-#       Percentages are relative to the level above
-#       'Branch Count' is the total number of branches for that function and all
-#       functions that it calls
-
-import sys
-from PySide.QtCore import *
-from PySide.QtGui import *
-from PySide.QtSql import *
-from decimal import *
-
-class TreeItem():
-
-        def __init__(self, db, row, parent_item):
-                self.db = db
-                self.row = row
-                self.parent_item = parent_item
-                self.query_done = False;
-                self.child_count = 0
-                self.child_items = []
-                self.data = ["", "", "", "", "", "", ""]
-                self.comm_id = 0
-                self.thread_id = 0
-                self.call_path_id = 1
-                self.branch_count = 0
-                self.time = 0
-                if not parent_item:
-                        self.setUpRoot()
-
-        def setUpRoot(self):
-                self.query_done = True
-                query = QSqlQuery(self.db)
-                ret = query.exec_('SELECT id, comm FROM comms')
-                if not ret:
-                        raise Exception("Query failed: " + query.lastError().text())
-                while query.next():
-                        if not query.value(0):
-                                continue
-                        child_item = TreeItem(self.db, self.child_count, self)
-                        self.child_items.append(child_item)
-                        self.child_count += 1
-                        child_item.setUpLevel1(query.value(0), query.value(1))
-
-        def setUpLevel1(self, comm_id, comm):
-                self.query_done = True;
-                self.comm_id = comm_id
-                self.data[0] = comm
-                self.child_items = []
-                self.child_count = 0
-                query = QSqlQuery(self.db)
-                ret = query.exec_('SELECT thread_id, ( SELECT pid FROM threads WHERE id = thread_id ), ( SELECT tid FROM threads WHERE id = thread_id ) FROM comm_threads WHERE comm_id = ' + str(comm_id))
-                if not ret:
-                        raise Exception("Query failed: " + query.lastError().text())
-                while query.next():
-                        child_item = TreeItem(self.db, self.child_count, self)
-                        self.child_items.append(child_item)
-                        self.child_count += 1
-                        child_item.setUpLevel2(comm_id, query.value(0), query.value(1), query.value(2))
-
-        def setUpLevel2(self, comm_id, thread_id, pid, tid):
-                self.comm_id = comm_id
-                self.thread_id = thread_id
-                self.data[0] = str(pid) + ":" + str(tid)
-
-        def getChildItem(self, row):
-                return self.child_items[row]
-
-        def getParentItem(self):
-                return self.parent_item
-
-        def getRow(self):
-                return self.row
-
-        def timePercent(self, b):
-                if not self.time:
-                        return "0.0"
-                x = (b * Decimal(100)) / self.time
-                return str(x.quantize(Decimal('.1'), rounding=ROUND_HALF_UP))
-
-        def branchPercent(self, b):
-                if not self.branch_count:
-                        return "0.0"
-                x = (b * Decimal(100)) / self.branch_count
-                return str(x.quantize(Decimal('.1'), rounding=ROUND_HALF_UP))
-
-        def addChild(self, call_path_id, name, dso, count, time, branch_count):
-                child_item = TreeItem(self.db, self.child_count, self)
-                child_item.comm_id = self.comm_id
-                child_item.thread_id = self.thread_id
-                child_item.call_path_id = call_path_id
-                child_item.branch_count = branch_count
-                child_item.time = time
-                child_item.data[0] = name
-                if dso == "[kernel.kallsyms]":
-                        dso = "[kernel]"
-                child_item.data[1] = dso
-                child_item.data[2] = str(count)
-                child_item.data[3] = str(time)
-                child_item.data[4] = self.timePercent(time)
-                child_item.data[5] = str(branch_count)
-                child_item.data[6] = self.branchPercent(branch_count)
-                self.child_items.append(child_item)
-                self.child_count += 1
-
-        def selectCalls(self):
-                self.query_done = True;
-                query = QSqlQuery(self.db)
-                ret = query.exec_('SELECT id, call_path_id, branch_count, call_time, return_time, '
-                                  '( SELECT name FROM symbols WHERE id = ( SELECT symbol_id FROM call_paths WHERE id = call_path_id ) ), '
-                                  '( SELECT short_name FROM dsos WHERE id = ( SELECT dso_id FROM symbols WHERE id = ( SELECT symbol_id FROM call_paths WHERE id = call_path_id ) ) ), '
-                                  '( SELECT ip FROM call_paths where id = call_path_id ) '
-                                  'FROM calls WHERE parent_call_path_id = ' + str(self.call_path_id) + ' AND comm_id = ' + str(self.comm_id) + ' AND thread_id = ' + str(self.thread_id) +
-                                  ' ORDER BY call_path_id')
-                if not ret:
-                        raise Exception("Query failed: " + query.lastError().text())
-                last_call_path_id = 0
-                name = ""
-                dso = ""
-                count = 0
-                branch_count = 0
-                total_branch_count = 0
-                time = 0
-                total_time = 0
-                while query.next():
-                        if query.value(1) == last_call_path_id:
-                                count += 1
-                                branch_count += query.value(2)
-                                time += query.value(4) - query.value(3)
-                        else:
-                                if count:
-                                        self.addChild(last_call_path_id, name, dso, count, time, branch_count)
-                                last_call_path_id = query.value(1)
-                                name = query.value(5)
-                                dso = query.value(6)
-                                count = 1
-                                total_branch_count += branch_count
-                                total_time += time
-                                branch_count = query.value(2)
-                                time = query.value(4) - query.value(3)
-                if count:
-                        self.addChild(last_call_path_id, name, dso, count, time, branch_count)
-                total_branch_count += branch_count
-                total_time += time
-                # Top level does not have time or branch count, so fix that here
-                if total_branch_count > self.branch_count:
-                        self.branch_count = total_branch_count
-                        if self.branch_count:
-                                for child_item in self.child_items:
-                                        child_item.data[6] = self.branchPercent(child_item.branch_count)
-                if total_time > self.time:
-                        self.time = total_time
-                        if self.time:
-                                for child_item in self.child_items:
-                                        child_item.data[4] = self.timePercent(child_item.time)
-
-        def childCount(self):
-                if not self.query_done:
-                        self.selectCalls()
-                return self.child_count
-
-        def columnCount(self):
-                return 7
-
-        def columnHeader(self, column):
-                headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
-                return headers[column]
-
-        def getData(self, column):
-                return self.data[column]
-
-class TreeModel(QAbstractItemModel):
-
-        def __init__(self, db, parent=None):
-                super(TreeModel, self).__init__(parent)
-                self.db = db
-                self.root = TreeItem(db, 0, None)
-
-        def columnCount(self, parent):
-                return self.root.columnCount()
-
-        def rowCount(self, parent):
-                if parent.isValid():
-                        parent_item = parent.internalPointer()
-                else:
-                        parent_item = self.root
-                return parent_item.childCount()
-
-        def headerData(self, section, orientation, role):
-                if role == Qt.TextAlignmentRole:
-                        if section > 1:
-                                return Qt.AlignRight
-                if role != Qt.DisplayRole:
-                        return None
-                if orientation != Qt.Horizontal:
-                        return None
-                return self.root.columnHeader(section)
-
-        def parent(self, child):
-                child_item = child.internalPointer()
-                if child_item is self.root:
-                        return QModelIndex()
-                parent_item = child_item.getParentItem()
-                return self.createIndex(parent_item.getRow(), 0, parent_item)
-
-        def index(self, row, column, parent):
-                if parent.isValid():
-                        parent_item = parent.internalPointer()
-                else:
-                        parent_item = self.root
-                child_item = parent_item.getChildItem(row)
-                return self.createIndex(row, column, child_item)
-
-        def data(self, index, role):
-                if role == Qt.TextAlignmentRole:
-                        if index.column() > 1:
-                                return Qt.AlignRight
-                if role != Qt.DisplayRole:
-                        return None
-                index_item = index.internalPointer()
-                return index_item.getData(index.column())
-
-class MainWindow(QMainWindow):
-
-        def __init__(self, db, dbname, parent=None):
-                super(MainWindow, self).__init__(parent)
-
-                self.setObjectName("MainWindow")
-                self.setWindowTitle("Call Graph: " + dbname)
-                self.move(100, 100)
-                self.resize(800, 600)
-                style = self.style()
-                icon = style.standardIcon(QStyle.SP_MessageBoxInformation)
-                self.setWindowIcon(icon);
-
-                self.model = TreeModel(db)
-
-                self.view = QTreeView()
-                self.view.setModel(self.model)
-
-                self.setCentralWidget(self.view)
-
-if __name__ == '__main__':
-        if (len(sys.argv) < 2):
-                print >> sys.stderr, "Usage is: call-graph-from-sql.py <database name>"
-                raise Exception("Too few arguments")
-
-        dbname = sys.argv[1]
-
-        is_sqlite3 = False
-        try:
-                f = open(dbname)
-                if f.read(15) == "SQLite format 3":
-                        is_sqlite3 = True
-                f.close()
-        except:
-                pass
-
-        if is_sqlite3:
-                db = QSqlDatabase.addDatabase('QSQLITE')
-        else:
-                db = QSqlDatabase.addDatabase('QPSQL')
-                opts = dbname.split()
-                for opt in opts:
-                        if '=' in opt:
-                                opt = opt.split('=')
-                                if opt[0] == 'hostname':
-                                        db.setHostName(opt[1])
-                                elif opt[0] == 'port':
-                                        db.setPort(int(opt[1]))
-                                elif opt[0] == 'username':
-                                        db.setUserName(opt[1])
-                                elif opt[0] == 'password':
-                                        db.setPassword(opt[1])
-                                elif opt[0] == 'dbname':
-                                        dbname = opt[1]
-                        else:
-                                dbname = opt
-
-        db.setDatabaseName(dbname)
-        if not db.open():
-                raise Exception("Failed to open database " + dbname + " error: " + db.lastError().text())
-
-        app = QApplication(sys.argv)
-        window = MainWindow(db, dbname)
-        window.show()
-        err = app.exec_()
-        db.close()
-        sys.exit(err)
diff --git a/tools/perf/scripts/python/export-to-postgresql.py b/tools/perf/scripts/python/export-to-postgresql.py
index efcaf6cac2eb..0564dd7377f2 100644
--- a/tools/perf/scripts/python/export-to-postgresql.py
+++ b/tools/perf/scripts/python/export-to-postgresql.py
@@ -59,7 +59,7 @@ import datetime
 #       pt_example=# \q
 #
 # An example of using the database is provided by the script
-# call-graph-from-sql.py.  Refer to that script for details.
+# exported-sql-viewer.py.  Refer to that script for details.
 #
 # Tables:
 #
@@ -204,14 +204,23 @@ from ctypes import *
 libpq = CDLL("libpq.so.5")
 PQconnectdb = libpq.PQconnectdb
 PQconnectdb.restype = c_void_p
+PQconnectdb.argtypes = [ c_char_p ]
 PQfinish = libpq.PQfinish
+PQfinish.argtypes = [ c_void_p ]
 PQstatus = libpq.PQstatus
+PQstatus.restype = c_int
+PQstatus.argtypes = [ c_void_p ]
 PQexec = libpq.PQexec
 PQexec.restype = c_void_p
+PQexec.argtypes = [ c_void_p, c_char_p ]
 PQresultStatus = libpq.PQresultStatus
+PQresultStatus.restype = c_int
+PQresultStatus.argtypes = [ c_void_p ]
 PQputCopyData = libpq.PQputCopyData
+PQputCopyData.restype = c_int
 PQputCopyData.argtypes = [ c_void_p, c_void_p, c_int ]
 PQputCopyEnd = libpq.PQputCopyEnd
+PQputCopyEnd.restype = c_int
 PQputCopyEnd.argtypes = [ c_void_p, c_void_p ]
 
 sys.path.append(os.environ['PERF_EXEC_PATH'] + \
diff --git a/tools/perf/scripts/python/export-to-sqlite.py b/tools/perf/scripts/python/export-to-sqlite.py
index f827bf77e9d2..245caf2643ed 100644
--- a/tools/perf/scripts/python/export-to-sqlite.py
+++ b/tools/perf/scripts/python/export-to-sqlite.py
@@ -40,7 +40,7 @@ import datetime
 #       sqlite> .quit
 #
 # An example of using the database is provided by the script
-# call-graph-from-sql.py.  Refer to that script for details.
+# exported-sql-viewer.py.  Refer to that script for details.
 #
 # The database structure is practically the same as created by the script
 # export-to-postgresql.py. Refer to that script for details.  A notable
@@ -440,7 +440,11 @@ def branch_type_table(*x):
 
 def sample_table(*x):
         if branches:
-                bind_exec(sample_query, 18, x)
+                for xx in x[0:15]:
+                        sample_query.addBindValue(str(xx))
+                for xx in x[19:22]:
+                        sample_query.addBindValue(str(xx))
+                do_query_(sample_query)
         else:
                 bind_exec(sample_query, 22, x)
 
diff --git a/tools/perf/scripts/python/exported-sql-viewer.py b/tools/perf/scripts/python/exported-sql-viewer.py
new file mode 100755
index 000000000000..24cb0bd56afa
--- /dev/null
+++ b/tools/perf/scripts/python/exported-sql-viewer.py
@@ -0,0 +1,2128 @@
+#!/usr/bin/python2
+# SPDX-License-Identifier: GPL-2.0
+# exported-sql-viewer.py: view data from sql database
+# Copyright (c) 2014-2018, Intel Corporation.
+
+# To use this script you will need to have exported data using either the
+# export-to-sqlite.py or the export-to-postgresql.py script.  Refer to those
+# scripts for details.
+#
+# Following on from the example in the export scripts, a
+# call-graph can be displayed for the pt_example database like this:
+#
+#       python tools/perf/scripts/python/exported-sql-viewer.py pt_example
+#
+# Note that for PostgreSQL, this script supports connecting to remote databases
+# by setting hostname, port, username, password, and dbname e.g.
+#
+#       python tools/perf/scripts/python/exported-sql-viewer.py "hostname=myhost username=myuser password=mypassword dbname=pt_example"
+#
+# The result is a GUI window with a tree representing a context-sensitive
+# call-graph.  Expanding a couple of levels of the tree and adjusting column
+# widths to suit will display something like:
+#
+#                                         Call Graph: pt_example
+# Call Path                          Object      Count   Time(ns)  Time(%)  Branch Count   Branch Count(%)
+# v- ls
+#     v- 2638:2638
+#         v- _start                  ld-2.19.so    1     10074071   100.0         211135            100.0
+#           |- unknown               unknown       1        13198     0.1              1              0.0
+#           >- _dl_start             ld-2.19.so    1      1400980    13.9          19637              9.3
+#           >- _d_linit_internal     ld-2.19.so    1       448152     4.4          11094              5.3
+#           v-__libc_start_main@plt  ls            1      8211741    81.5         180397             85.4
+#              >- _dl_fixup          ld-2.19.so    1         7607     0.1            108              0.1
+#              >- __cxa_atexit       libc-2.19.so  1        11737     0.1             10              0.0
+#              >- __libc_csu_init    ls            1        10354     0.1             10              0.0
+#              |- _setjmp            libc-2.19.so  1            0     0.0              4              0.0
+#              v- main               ls            1      8182043    99.6         180254             99.9
+#
+# Points to note:
+#       The top level is a command name (comm)
+#       The next level is a thread (pid:tid)
+#       Subsequent levels are functions
+#       'Count' is the number of calls
+#       'Time' is the elapsed time until the function returns
+#       Percentages are relative to the level above
+#       'Branch Count' is the total number of branches for that function and all
+#       functions that it calls
+
+# There is also a "All branches" report, which displays branches and
+# possibly disassembly.  However, presently, the only supported disassembler is
+# Intel XED, and additionally the object code must be present in perf build ID
+# cache. To use Intel XED, libxed.so must be present. To build and install
+# libxed.so:
+#            git clone https://github.com/intelxed/mbuild.git mbuild
+#            git clone https://github.com/intelxed/xed
+#            cd xed
+#            ./mfile.py --share
+#            sudo ./mfile.py --prefix=/usr/local install
+#            sudo ldconfig
+#
+# Example report:
+#
+# Time           CPU  Command  PID    TID    Branch Type            In Tx  Branch
+# 8107675239590  2    ls       22011  22011  return from interrupt  No     ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
+#                                                                              7fab593ea260 48 89 e7                                        mov %rsp, %rdi
+# 8107675239899  2    ls       22011  22011  hardware interrupt     No         7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
+# 8107675241900  2    ls       22011  22011  return from interrupt  No     ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
+#                                                                              7fab593ea260 48 89 e7                                        mov %rsp, %rdi
+#                                                                              7fab593ea263 e8 c8 06 00 00                                  callq  0x7fab593ea930
+# 8107675241900  2    ls       22011  22011  call                   No         7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so)
+#                                                                              7fab593ea930 55                                              pushq  %rbp
+#                                                                              7fab593ea931 48 89 e5                                        mov %rsp, %rbp
+#                                                                              7fab593ea934 41 57                                           pushq  %r15
+#                                                                              7fab593ea936 41 56                                           pushq  %r14
+#                                                                              7fab593ea938 41 55                                           pushq  %r13
+#                                                                              7fab593ea93a 41 54                                           pushq  %r12
+#                                                                              7fab593ea93c 53                                              pushq  %rbx
+#                                                                              7fab593ea93d 48 89 fb                                        mov %rdi, %rbx
+#                                                                              7fab593ea940 48 83 ec 68                                     sub $0x68, %rsp
+#                                                                              7fab593ea944 0f 31                                           rdtsc
+#                                                                              7fab593ea946 48 c1 e2 20                                     shl $0x20, %rdx
+#                                                                              7fab593ea94a 89 c0                                           mov %eax, %eax
+#                                                                              7fab593ea94c 48 09 c2                                        or %rax, %rdx
+#                                                                              7fab593ea94f 48 8b 05 1a 15 22 00                            movq  0x22151a(%rip), %rax
+# 8107675242232  2    ls       22011  22011  hardware interrupt     No         7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
+# 8107675242900  2    ls       22011  22011  return from interrupt  No     ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so)
+#                                                                              7fab593ea94f 48 8b 05 1a 15 22 00                            movq  0x22151a(%rip), %rax
+#                                                                              7fab593ea956 48 89 15 3b 13 22 00                            movq  %rdx, 0x22133b(%rip)
+# 8107675243232  2    ls       22011  22011  hardware interrupt     No         7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
+
+import sys
+import weakref
+import threading
+import string
+import cPickle
+import re
+import os
+from PySide.QtCore import *
+from PySide.QtGui import *
+from PySide.QtSql import *
+from decimal import *
+from ctypes import *
+from multiprocessing import Process, Array, Value, Event
+
+# Data formatting helpers
+
+def tohex(ip):
+        if ip < 0:
+                ip += 1 << 64
+        return "%x" % ip
+
+def offstr(offset):
+        if offset:
+                return "+0x%x" % offset
+        return ""
+
+def dsoname(name):
+        if name == "[kernel.kallsyms]":
+                return "[kernel]"
+        return name
+
+# Percent to one decimal place
+
+def PercentToOneDP(n, d):
+        if not d:
+                return "0.0"
+        x = (n * Decimal(100)) / d
+        return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP))
+
+# Helper for queries that must not fail
+
+def QueryExec(query, stmt):
+        ret = query.exec_(stmt)
+        if not ret:
+                raise Exception("Query failed: " + query.lastError().text())
+
+# Background thread
+
+class Thread(QThread):
+
+        done = Signal(object)
+
+        def __init__(self, task, param=None, parent=None):
+                super(Thread, self).__init__(parent)
+                self.task = task
+                self.param = param
+
+        def run(self):
+                while True:
+                        if self.param is None:
+                                done, result = self.task()
+                        else:
+                                done, result = self.task(self.param)
+                        self.done.emit(result)
+                        if done:
+                                break
+
+# Tree data model
+
+class TreeModel(QAbstractItemModel):
+
+        def __init__(self, root, parent=None):
+                super(TreeModel, self).__init__(parent)
+                self.root = root
+                self.last_row_read = 0
+
+        def Item(self, parent):
+                if parent.isValid():
+                        return parent.internalPointer()
+                else:
+                        return self.root
+
+        def rowCount(self, parent):
+                result = self.Item(parent).childCount()
+                if result < 0:
+                        result = 0
+                        self.dataChanged.emit(parent, parent)
+                return result
+
+        def hasChildren(self, parent):
+                return self.Item(parent).hasChildren()
+
+        def headerData(self, section, orientation, role):
+                if role == Qt.TextAlignmentRole:
+                        return self.columnAlignment(section)
+                if role != Qt.DisplayRole:
+                        return None
+                if orientation != Qt.Horizontal:
+                        return None
+                return self.columnHeader(section)
+
+        def parent(self, child):
+                child_item = child.internalPointer()
+                if child_item is self.root:
+                        return QModelIndex()
+                parent_item = child_item.getParentItem()
+                return self.createIndex(parent_item.getRow(), 0, parent_item)
+
+        def index(self, row, column, parent):
+                child_item = self.Item(parent).getChildItem(row)
+                return self.createIndex(row, column, child_item)
+
+        def DisplayData(self, item, index):
+                return item.getData(index.column())
+
+        def FetchIfNeeded(self, row):
+                if row > self.last_row_read:
+                        self.last_row_read = row
+                        if row + 10 >= self.root.child_count:
+                                self.fetcher.Fetch(glb_chunk_sz)
+
+        def columnAlignment(self, column):
+                return Qt.AlignLeft
+
+        def columnFont(self, column):
+                return None
+
+        def data(self, index, role):
+                if role == Qt.TextAlignmentRole:
+                        return self.columnAlignment(index.column())
+                if role == Qt.FontRole:
+                        return self.columnFont(index.column())
+                if role != Qt.DisplayRole:
+                        return None
+                item = index.internalPointer()
+                return self.DisplayData(item, index)
+
+# Table data model
+
+class TableModel(QAbstractTableModel):
+
+        def __init__(self, parent=None):
+                super(TableModel, self).__init__(parent)
+                self.child_count = 0
+                self.child_items = []
+                self.last_row_read = 0
+
+        def Item(self, parent):
+                if parent.isValid():
+                        return parent.internalPointer()
+                else:
+                        return self
+
+        def rowCount(self, parent):
+                return self.child_count
+
+        def headerData(self, section, orientation, role):
+                if role == Qt.TextAlignmentRole:
+                        return self.columnAlignment(section)
+                if role != Qt.DisplayRole:
+                        return None
+                if orientation != Qt.Horizontal:
+                        return None
+                return self.columnHeader(section)
+
+        def index(self, row, column, parent):
+                return self.createIndex(row, column, self.child_items[row])
+
+        def DisplayData(self, item, index):
+                return item.getData(index.column())
+
+        def FetchIfNeeded(self, row):
+                if row > self.last_row_read:
+                        self.last_row_read = row
+                        if row + 10 >= self.child_count:
+                                self.fetcher.Fetch(glb_chunk_sz)
+
+        def columnAlignment(self, column):
+                return Qt.AlignLeft
+
+        def columnFont(self, column):
+                return None
+
+        def data(self, index, role):
+                if role == Qt.TextAlignmentRole:
+                        return self.columnAlignment(index.column())
+                if role == Qt.FontRole:
+                        return self.columnFont(index.column())
+                if role != Qt.DisplayRole:
+                        return None
+                item = index.internalPointer()
+                return self.DisplayData(item, index)
+
+# Model cache
+
+model_cache = weakref.WeakValueDictionary()
+model_cache_lock = threading.Lock()
+
+def LookupCreateModel(model_name, create_fn):
+        model_cache_lock.acquire()
+        try:
+                model = model_cache[model_name]
+        except:
+                model = None
+        if model is None:
+                model = create_fn()
+                model_cache[model_name] = model
+        model_cache_lock.release()
+        return model
+
+# Find bar
+
+class FindBar():
+
+        def __init__(self, parent, finder, is_reg_expr=False):
+                self.finder = finder
+                self.context = []
+                self.last_value = None
+                self.last_pattern = None
+
+                label = QLabel("Find:")
+                label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+                self.textbox = QComboBox()
+                self.textbox.setEditable(True)
+                self.textbox.currentIndexChanged.connect(self.ValueChanged)
+
+                self.progress = QProgressBar()
+                self.progress.setRange(0, 0)
+                self.progress.hide()
+
+                if is_reg_expr:
+                        self.pattern = QCheckBox("Regular Expression")
+                else:
+                        self.pattern = QCheckBox("Pattern")
+                self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+                self.next_button = QToolButton()
+                self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
+                self.next_button.released.connect(lambda: self.NextPrev(1))
+
+                self.prev_button = QToolButton()
+                self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
+                self.prev_button.released.connect(lambda: self.NextPrev(-1))
+
+                self.close_button = QToolButton()
+                self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
+                self.close_button.released.connect(self.Deactivate)
+
+                self.hbox = QHBoxLayout()
+                self.hbox.setContentsMargins(0, 0, 0, 0)
+
+                self.hbox.addWidget(label)
+                self.hbox.addWidget(self.textbox)
+                self.hbox.addWidget(self.progress)
+                self.hbox.addWidget(self.pattern)
+                self.hbox.addWidget(self.next_button)
+                self.hbox.addWidget(self.prev_button)
+                self.hbox.addWidget(self.close_button)
+
+                self.bar = QWidget()
+                self.bar.setLayout(self.hbox);
+                self.bar.hide()
+
+        def Widget(self):
+                return self.bar
+
+        def Activate(self):
+                self.bar.show()
+                self.textbox.setFocus()
+
+        def Deactivate(self):
+                self.bar.hide()
+
+        def Busy(self):
+                self.textbox.setEnabled(False)
+                self.pattern.hide()
+                self.next_button.hide()
+                self.prev_button.hide()
+                self.progress.show()
+
+        def Idle(self):
+                self.textbox.setEnabled(True)
+                self.progress.hide()
+                self.pattern.show()
+                self.next_button.show()
+                self.prev_button.show()
+
+        def Find(self, direction):
+                value = self.textbox.currentText()
+                pattern = self.pattern.isChecked()
+                self.last_value = value
+                self.last_pattern = pattern
+                self.finder.Find(value, direction, pattern, self.context)
+
+        def ValueChanged(self):
+                value = self.textbox.currentText()
+                pattern = self.pattern.isChecked()
+                index = self.textbox.currentIndex()
+                data = self.textbox.itemData(index)
+                # Store the pattern in the combo box to keep it with the text value
+                if data == None:
+                        self.textbox.setItemData(index, pattern)
+                else:
+                        self.pattern.setChecked(data)
+                self.Find(0)
+
+        def NextPrev(self, direction):
+                value = self.textbox.currentText()
+                pattern = self.pattern.isChecked()
+                if value != self.last_value:
+                        index = self.textbox.findText(value)
+                        # Allow for a button press before the value has been added to the combo box
+                        if index < 0:
+                                index = self.textbox.count()
+                                self.textbox.addItem(value, pattern)
+                                self.textbox.setCurrentIndex(index)
+                                return
+                        else:
+                                self.textbox.setItemData(index, pattern)
+                elif pattern != self.last_pattern:
+                        # Keep the pattern recorded in the combo box up to date
+                        index = self.textbox.currentIndex()
+                        self.textbox.setItemData(index, pattern)
+                self.Find(direction)
+
+        def NotFound(self):
+                QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
+
+# Context-sensitive call graph data model item base
+
+class CallGraphLevelItemBase(object):
+
+        def __init__(self, glb, row, parent_item):
+                self.glb = glb
+                self.row = row
+                self.parent_item = parent_item
+                self.query_done = False;
+                self.child_count = 0
+                self.child_items = []
+
+        def getChildItem(self, row):
+                return self.child_items[row]
+
+        def getParentItem(self):
+                return self.parent_item
+
+        def getRow(self):
+                return self.row
+
+        def childCount(self):
+                if not self.query_done:
+                        self.Select()
+                        if not self.child_count:
+                                return -1
+                return self.child_count
+
+        def hasChildren(self):
+                if not self.query_done:
+                        return True
+                return self.child_count > 0
+
+        def getData(self, column):
+                return self.data[column]
+
+# Context-sensitive call graph data model level 2+ item base
+
+class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase):
+
+        def __init__(self, glb, row, comm_id, thread_id, call_path_id, time, branch_count, parent_item):
+                super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, row, parent_item)
+                self.comm_id = comm_id
+                self.thread_id = thread_id
+                self.call_path_id = call_path_id
+                self.branch_count = branch_count
+                self.time = time
+
+        def Select(self):
+                self.query_done = True;
+                query = QSqlQuery(self.glb.db)
+                QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time), SUM(branch_count)"
+                                        " FROM calls"
+                                        " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+                                        " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+                                        " INNER JOIN dsos ON symbols.dso_id = dsos.id"
+                                        " WHERE parent_call_path_id = " + str(self.call_path_id) +
+                                        " AND comm_id = " + str(self.comm_id) +
+                                        " AND thread_id = " + str(self.thread_id) +
+                                        " GROUP BY call_path_id, name, short_name"
+                                        " ORDER BY call_path_id")
+                while query.next():
+                        child_item = CallGraphLevelThreeItem(self.glb, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), int(query.value(5)), self)
+                        self.child_items.append(child_item)
+                        self.child_count += 1
+
+# Context-sensitive call graph data model level three item
+
+class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase):
+
+        def __init__(self, glb, row, comm_id, thread_id, call_path_id, name, dso, count, time, branch_count, parent_item):
+                super(CallGraphLevelThreeItem, self).__init__(glb, row, comm_id, thread_id, call_path_id, time, branch_count, parent_item)
+                dso = dsoname(dso)
+                self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
+                self.dbid = call_path_id
+
+# Context-sensitive call graph data model level two item
+
+class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase):
+
+        def __init__(self, glb, row, comm_id, thread_id, pid, tid, parent_item):
+                super(CallGraphLevelTwoItem, self).__init__(glb, row, comm_id, thread_id, 1, 0, 0, parent_item)
+                self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
+                self.dbid = thread_id
+
+        def Select(self):
+                super(CallGraphLevelTwoItem, self).Select()
+                for child_item in self.child_items:
+                        self.time += child_item.time
+                        self.branch_count += child_item.branch_count
+                for child_item in self.child_items:
+                        child_item.data[4] = PercentToOneDP(child_item.time, self.time)
+                        child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
+
+# Context-sensitive call graph data model level one item
+
+class CallGraphLevelOneItem(CallGraphLevelItemBase):
+
+        def __init__(self, glb, row, comm_id, comm, parent_item):
+                super(CallGraphLevelOneItem, self).__init__(glb, row, parent_item)
+                self.data = [comm, "", "", "", "", "", ""]
+                self.dbid = comm_id
+
+        def Select(self):
+                self.query_done = True;
+                query = QSqlQuery(self.glb.db)
+                QueryExec(query, "SELECT thread_id, pid, tid"
+                                        " FROM comm_threads"
+                                        " INNER JOIN threads ON thread_id = threads.id"
+                                        " WHERE comm_id = " + str(self.dbid))
+                while query.next():
+                        child_item = CallGraphLevelTwoItem(self.glb, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
+                        self.child_items.append(child_item)
+                        self.child_count += 1
+
+# Context-sensitive call graph data model root item
+
+class CallGraphRootItem(CallGraphLevelItemBase):
+
+        def __init__(self, glb):
+                super(CallGraphRootItem, self).__init__(glb, 0, None)
+                self.dbid = 0
+                self.query_done = True;
+                query = QSqlQuery(glb.db)
+                QueryExec(query, "SELECT id, comm FROM comms")
+                while query.next():
+                        if not query.value(0):
+                                continue
+                        child_item = CallGraphLevelOneItem(glb, self.child_count, query.value(0), query.value(1), self)
+                        self.child_items.append(child_item)
+                        self.child_count += 1
+
+# Context-sensitive call graph data model
+
+class CallGraphModel(TreeModel):
+
+        def __init__(self, glb, parent=None):
+                super(CallGraphModel, self).__init__(CallGraphRootItem(glb), parent)
+                self.glb = glb
+
+        def columnCount(self, parent=None):
+                return 7
+
+        def columnHeader(self, column):
+                headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
+                return headers[column]
+
+        def columnAlignment(self, column):
+                alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
+                return alignment[column]
+
+        def FindSelect(self, value, pattern, query):
+                if pattern:
+                        # postgresql and sqlite pattern patching differences:
+                        #   postgresql LIKE is case sensitive but sqlite LIKE is not
+                        #   postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not
+                        #   postgresql supports ILIKE which is case insensitive
+                        #   sqlite supports GLOB (text only) which uses * and ? and is case sensitive
+                        if not self.glb.dbref.is_sqlite3:
+                                # Escape % and _
+                                s = value.replace("%", "\%")
+                                s = s.replace("_", "\_")
+                                # Translate * and ? into SQL LIKE pattern characters % and _
+                                trans = string.maketrans("*?", "%_")
+                                match = " LIKE '" + str(s).translate(trans) + "'"
+                        else:
+                                match = " GLOB '" + str(value) + "'"
+                else:
+                        match = " = '" + str(value) + "'"
+                QueryExec(query, "SELECT call_path_id, comm_id, thread_id"
+                                                " FROM calls"
+                                                " INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
+                                                " INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
+                                                " WHERE symbols.name" + match +
+                                                " GROUP BY comm_id, thread_id, call_path_id"
+                                                " ORDER BY comm_id, thread_id, call_path_id")
+
+        def FindPath(self, query):
+                # Turn the query result into a list of ids that the tree view can walk
+                # to open the tree at the right place.
+                ids = []
+                parent_id = query.value(0)
+                while parent_id:
+                        ids.insert(0, parent_id)
+                        q2 = QSqlQuery(self.glb.db)
+                        QueryExec(q2, "SELECT parent_id"
+                                        " FROM call_paths"
+                                        " WHERE id = " + str(parent_id))
+                        if not q2.next():
+                                break
+                        parent_id = q2.value(0)
+                # The call path root is not used
+                if ids[0] == 1:
+                        del ids[0]
+                ids.insert(0, query.value(2))
+                ids.insert(0, query.value(1))
+                return ids
+
+        def Found(self, query, found):
+                if found:
+                        return self.FindPath(query)
+                return []
+
+        def FindValue(self, value, pattern, query, last_value, last_pattern):
+                if last_value == value and pattern == last_pattern:
+                        found = query.first()
+                else:
+                        self.FindSelect(value, pattern, query)
+                        found = query.next()
+                return self.Found(query, found)
+
+        def FindNext(self, query):
+                found = query.next()
+                if not found:
+                        found = query.first()
+                return self.Found(query, found)
+
+        def FindPrev(self, query):
+                found = query.previous()
+                if not found:
+                        found = query.last()
+                return self.Found(query, found)
+
+        def FindThread(self, c):
+                if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern:
+                        ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
+                elif c.direction > 0:
+                        ids = self.FindNext(c.query)
+                else:
+                        ids = self.FindPrev(c.query)
+                return (True, ids)
+
+        def Find(self, value, direction, pattern, context, callback):
+                class Context():
+                        def __init__(self, *x):
+                                self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
+                        def Update(self, *x):
+                                self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern)
+                if len(context):
+                        context[0].Update(value, direction, pattern)
+                else:
+                        context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
+                # Use a thread so the UI is not blocked during the SELECT
+                thread = Thread(self.FindThread, context[0])
+                thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection)
+                thread.start()
+
+        def FindDone(self, thread, callback, ids):
+                callback(ids)
+
+# Vertical widget layout
+
+class VBox():
+
+        def __init__(self, w1, w2, w3=None):
+                self.vbox = QWidget()
+                self.vbox.setLayout(QVBoxLayout());
+
+                self.vbox.layout().setContentsMargins(0, 0, 0, 0)
+
+                self.vbox.layout().addWidget(w1)
+                self.vbox.layout().addWidget(w2)
+                if w3:
+                        self.vbox.layout().addWidget(w3)
+
+        def Widget(self):
+                return self.vbox
+
+# Context-sensitive call graph window
+
+class CallGraphWindow(QMdiSubWindow):
+
+        def __init__(self, glb, parent=None):
+                super(CallGraphWindow, self).__init__(parent)
+
+                self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
+
+                self.view = QTreeView()
+                self.view.setModel(self.model)
+
+                for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)):
+                        self.view.setColumnWidth(c, w)
+
+                self.find_bar = FindBar(self, self)
+
+                self.vbox = VBox(self.view, self.find_bar.Widget())
+
+                self.setWidget(self.vbox.Widget())
+
+                AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
+
+        def DisplayFound(self, ids):
+                if not len(ids):
+                        return False
+                parent = QModelIndex()
+                for dbid in ids:
+                        found = False
+                        n = self.model.rowCount(parent)
+                        for row in xrange(n):
+                                child = self.model.index(row, 0, parent)
+                                if child.internalPointer().dbid == dbid:
+                                        found = True
+                                        self.view.setCurrentIndex(child)
+                                        parent = child
+                                        break
+                        if not found:
+                                break
+                return found
+
+        def Find(self, value, direction, pattern, context):
+                self.view.setFocus()
+                self.find_bar.Busy()
+                self.model.Find(value, direction, pattern, context, self.FindDone)
+
+        def FindDone(self, ids):
+                found = True
+                if not self.DisplayFound(ids):
+                        found = False
+                self.find_bar.Idle()
+                if not found:
+                        self.find_bar.NotFound()
+
+# Child data item  finder
+
+class ChildDataItemFinder():
+
+        def __init__(self, root):
+                self.root = root
+                self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
+                self.rows = []
+                self.pos = 0
+
+        def FindSelect(self):
+                self.rows = []
+                if self.pattern:
+                        pattern = re.compile(self.value)
+                        for child in self.root.child_items:
+                                for column_data in child.data:
+                                        if re.search(pattern, str(column_data)) is not None:
+                                                self.rows.append(child.row)
+                                                break
+                else:
+                        for child in self.root.child_items:
+                                for column_data in child.data:
+                                        if self.value in str(column_data):
+                                                self.rows.append(child.row)
+                                                break
+
+        def FindValue(self):
+                self.pos = 0
+                if self.last_value != self.value or self.pattern != self.last_pattern:
+                        self.FindSelect()
+                if not len(self.rows):
+                        return -1
+                return self.rows[self.pos]
+
+        def FindThread(self):
+                if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
+                        row = self.FindValue()
+                elif len(self.rows):
+                        if self.direction > 0:
+                                self.pos += 1
+                                if self.pos >= len(self.rows):
+                                        self.pos = 0
+                        else:
+                                self.pos -= 1
+                                if self.pos < 0:
+                                        self.pos = len(self.rows) - 1
+                        row = self.rows[self.pos]
+                else:
+                        row = -1
+                return (True, row)
+
+        def Find(self, value, direction, pattern, context, callback):
+                self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern)
+                # Use a thread so the UI is not blocked
+                thread = Thread(self.FindThread)
+                thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection)
+                thread.start()
+
+        def FindDone(self, thread, callback, row):
+                callback(row)
+
+# Number of database records to fetch in one go
+
+glb_chunk_sz = 10000
+
+# size of pickled integer big enough for record size
+
+glb_nsz = 8
+
+# Background process for SQL data fetcher
+
+class SQLFetcherProcess():
+
+        def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep):
+                # Need a unique connection name
+                conn_name = "SQLFetcher" + str(os.getpid())
+                self.db, dbname = dbref.Open(conn_name)
+                self.sql = sql
+                self.buffer = buffer
+                self.head = head
+                self.tail = tail
+                self.fetch_count = fetch_count
+                self.fetching_done = fetching_done
+                self.process_target = process_target
+                self.wait_event = wait_event
+                self.fetched_event = fetched_event
+                self.prep = prep
+                self.query = QSqlQuery(self.db)
+                self.query_limit = 0 if "$$last_id$$" in sql else 2
+                self.last_id = -1
+                self.fetched = 0
+                self.more = True
+                self.local_head = self.head.value
+                self.local_tail = self.tail.value
+
+        def Select(self):
+                if self.query_limit:
+                        if self.query_limit == 1:
+                                return
+                        self.query_limit -= 1
+                stmt = self.sql.replace("$$last_id$$", str(self.last_id))
+                QueryExec(self.query, stmt)
+
+        def Next(self):
+                if not self.query.next():
+                        self.Select()
+                        if not self.query.next():
+                                return None
+                self.last_id = self.query.value(0)
+                return self.prep(self.query)
+
+        def WaitForTarget(self):
+                while True:
+                        self.wait_event.clear()
+                        target = self.process_target.value
+                        if target > self.fetched or target < 0:
+                                break
+                        self.wait_event.wait()
+                return target
+
+        def HasSpace(self, sz):
+                if self.local_tail <= self.local_head:
+                        space = len(self.buffer) - self.local_head
+                        if space > sz:
+                                return True
+                        if space >= glb_nsz:
+                                # Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer
+                                nd = cPickle.dumps(0, cPickle.HIGHEST_PROTOCOL)
+                                self.buffer[self.local_head : self.local_head + len(nd)] = nd
+                        self.local_head = 0
+                if self.local_tail - self.local_head > sz:
+                        return True
+                return False
+
+        def WaitForSpace(self, sz):
+                if self.HasSpace(sz):
+                        return
+                while True:
+                        self.wait_event.clear()
+                        self.local_tail = self.tail.value
+                        if self.HasSpace(sz):
+                                return
+                        self.wait_event.wait()
+
+        def AddToBuffer(self, obj):
+                d = cPickle.dumps(obj, cPickle.HIGHEST_PROTOCOL)
+                n = len(d)
+                nd = cPickle.dumps(n, cPickle.HIGHEST_PROTOCOL)
+                sz = n + glb_nsz
+                self.WaitForSpace(sz)
+                pos = self.local_head
+                self.buffer[pos : pos + len(nd)] = nd
+                self.buffer[pos + glb_nsz : pos + sz] = d
+                self.local_head += sz
+
+        def FetchBatch(self, batch_size):
+                fetched = 0
+                while batch_size > fetched:
+                        obj = self.Next()
+                        if obj is None:
+                                self.more = False
+                                break
+                        self.AddToBuffer(obj)
+                        fetched += 1
+                if fetched:
+                        self.fetched += fetched
+                        with self.fetch_count.get_lock():
+                                self.fetch_count.value += fetched
+                        self.head.value = self.local_head
+                        self.fetched_event.set()
+
+        def Run(self):
+                while self.more:
+                        target = self.WaitForTarget()
+                        if target < 0:
+                                break
+                        batch_size = min(glb_chunk_sz, target - self.fetched)
+                        self.FetchBatch(batch_size)
+                self.fetching_done.value = True
+                self.fetched_event.set()
+
+def SQLFetcherFn(*x):
+        process = SQLFetcherProcess(*x)
+        process.Run()
+
+# SQL data fetcher
+
+class SQLFetcher(QObject):
+
+        done = Signal(object)
+
+        def __init__(self, glb, sql, prep, process_data, parent=None):
+                super(SQLFetcher, self).__init__(parent)
+                self.process_data = process_data
+                self.more = True
+                self.target = 0
+                self.last_target = 0
+                self.fetched = 0
+                self.buffer_size = 16 * 1024 * 1024
+                self.buffer = Array(c_char, self.buffer_size, lock=False)
+                self.head = Value(c_longlong)
+                self.tail = Value(c_longlong)
+                self.local_tail = 0
+                self.fetch_count = Value(c_longlong)
+                self.fetching_done = Value(c_bool)
+                self.last_count = 0
+                self.process_target = Value(c_longlong)
+                self.wait_event = Event()
+                self.fetched_event = Event()
+                glb.AddInstanceToShutdownOnExit(self)
+                self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tail, self.fetch_count, self.fetching_done, self.process_target, self.wait_event, self.fetched_event, prep))
+                self.process.start()
+                self.thread = Thread(self.Thread)
+                self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
+                self.thread.start()
+
+        def Shutdown(self):
+                # Tell the thread and process to exit
+                self.process_target.value = -1
+                self.wait_event.set()
+                self.more = False
+                self.fetching_done.value = True
+                self.fetched_event.set()
+
+        def Thread(self):
+                if not self.more:
+                        return True, 0
+                while True:
+                        self.fetched_event.clear()
+                        fetch_count = self.fetch_count.value
+                        if fetch_count != self.last_count:
+                                break
+                        if self.fetching_done.value:
+                                self.more = False
+                                return True, 0
+                        self.fetched_event.wait()
+                count = fetch_count - self.last_count
+                self.last_count = fetch_count
+                self.fetched += count
+                return False, count
+
+        def Fetch(self, nr):
+                if not self.more:
+                        # -1 inidcates there are no more
+                        return -1
+                result = self.fetched
+                extra = result + nr - self.target
+                if extra > 0:
+                        self.target += extra
+                        # process_target < 0 indicates shutting down
+                        if self.process_target.value >= 0:
+                                self.process_target.value = self.target
+                        self.wait_event.set()
+                return result
+
+        def RemoveFromBuffer(self):
+                pos = self.local_tail
+                if len(self.buffer) - pos < glb_nsz:
+                        pos = 0
+                n = cPickle.loads(self.buffer[pos : pos + glb_nsz])
+                if n == 0:
+                        pos = 0
+                        n = cPickle.loads(self.buffer[0 : glb_nsz])
+                pos += glb_nsz
+                obj = cPickle.loads(self.buffer[pos : pos + n])
+                self.local_tail = pos + n
+                return obj
+
+        def ProcessData(self, count):
+                for i in xrange(count):
+                        obj = self.RemoveFromBuffer()
+                        self.process_data(obj)
+                self.tail.value = self.local_tail
+                self.wait_event.set()
+                self.done.emit(count)
+
+# Fetch more records bar
+
+class FetchMoreRecordsBar():
+
+        def __init__(self, model, parent):
+                self.model = model
+
+                self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
+                self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+                self.fetch_count = QSpinBox()
+                self.fetch_count.setRange(1, 1000000)
+                self.fetch_count.setValue(10)
+                self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+                self.fetch = QPushButton("Go!")
+                self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+                self.fetch.released.connect(self.FetchMoreRecords)
+
+                self.progress = QProgressBar()
+                self.progress.setRange(0, 100)
+                self.progress.hide()
+
+                self.done_label = QLabel("All records fetched")
+                self.done_label.hide()
+
+                self.spacer = QLabel("")
+
+                self.close_button = QToolButton()
+                self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
+                self.close_button.released.connect(self.Deactivate)
+
+                self.hbox = QHBoxLayout()
+                self.hbox.setContentsMargins(0, 0, 0, 0)
+
+                self.hbox.addWidget(self.label)
+                self.hbox.addWidget(self.fetch_count)
+                self.hbox.addWidget(self.fetch)
+                self.hbox.addWidget(self.spacer)
+                self.hbox.addWidget(self.progress)
+                self.hbox.addWidget(self.done_label)
+                self.hbox.addWidget(self.close_button)
+
+                self.bar = QWidget()
+                self.bar.setLayout(self.hbox);
+                self.bar.show()
+
+                self.in_progress = False
+                self.model.progress.connect(self.Progress)
+
+                self.done = False
+
+                if not model.HasMoreRecords():
+                        self.Done()
+
+        def Widget(self):
+                return self.bar
+
+        def Activate(self):
+                self.bar.show()
+                self.fetch.setFocus()
+
+        def Deactivate(self):
+                self.bar.hide()
+
+        def Enable(self, enable):
+                self.fetch.setEnabled(enable)
+                self.fetch_count.setEnabled(enable)
+
+        def Busy(self):
+                self.Enable(False)
+                self.fetch.hide()
+                self.spacer.hide()
+                self.progress.show()
+
+        def Idle(self):
+                self.in_progress = False
+                self.Enable(True)
+                self.progress.hide()
+                self.fetch.show()
+                self.spacer.show()
+
+        def Target(self):
+                return self.fetch_count.value() * glb_chunk_sz
+
+        def Done(self):
+                self.done = True
+                self.Idle()
+                self.label.hide()
+                self.fetch_count.hide()
+                self.fetch.hide()
+                self.spacer.hide()
+                self.done_label.show()
+
+        def Progress(self, count):
+                if self.in_progress:
+                        if count:
+                                percent = ((count - self.start) * 100) / self.Target()
+                                if percent >= 100:
+                                        self.Idle()
+                                else:
+                                        self.progress.setValue(percent)
+                if not count:
+                        # Count value of zero means no more records
+                        self.Done()
+
+        def FetchMoreRecords(self):
+                if self.done:
+                        return
+                self.progress.setValue(0)
+                self.Busy()
+                self.in_progress = True
+                self.start = self.model.FetchMoreRecords(self.Target())
+
+# Brance data model level two item
+
+class BranchLevelTwoItem():
+
+        def __init__(self, row, text, parent_item):
+                self.row = row
+                self.parent_item = parent_item
+                self.data = [""] * 8
+                self.data[7] = text
+                self.level = 2
+
+        def getParentItem(self):
+                return self.parent_item
+
+        def getRow(self):
+                return self.row
+
+        def childCount(self):
+                return 0
+
+        def hasChildren(self):
+                return False
+
+        def getData(self, column):
+                return self.data[column]
+
+# Brance data model level one item
+
+class BranchLevelOneItem():
+
+        def __init__(self, glb, row, data, parent_item):
+                self.glb = glb
+                self.row = row
+                self.parent_item = parent_item
+                self.child_count = 0
+                self.child_items = []
+                self.data = data[1:]
+                self.dbid = data[0]
+                self.level = 1
+                self.query_done = False
+
+        def getChildItem(self, row):
+                return self.child_items[row]
+
+        def getParentItem(self):
+                return self.parent_item
+
+        def getRow(self):
+                return self.row
+
+        def Select(self):
+                self.query_done = True
+
+                if not self.glb.have_disassembler:
+                        return
+
+                query = QSqlQuery(self.glb.db)
+
+                QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip"
+                                  " FROM samples"
+                                  " INNER JOIN dsos ON samples.to_dso_id = dsos.id"
+                                  " INNER JOIN symbols ON samples.to_symbol_id = symbols.id"
+                                  " WHERE samples.id = " + str(self.dbid))
+                if not query.next():
+                        return
+                cpu = query.value(0)
+                dso = query.value(1)
+                sym = query.value(2)
+                if dso == 0 or sym == 0:
+                        return
+                off = query.value(3)
+                short_name = query.value(4)
+                long_name = query.value(5)
+                build_id = query.value(6)
+                sym_start = query.value(7)
+                ip = query.value(8)
+
+                QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start"
+                                  " FROM samples"
+                                  " INNER JOIN symbols ON samples.symbol_id = symbols.id"
+                                  " WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
+                                  " ORDER BY samples.id"
+                                  " LIMIT 1")
+                if not query.next():
+                        return
+                if query.value(0) != dso:
+                        # Cannot disassemble from one dso to another
+                        return
+                bsym = query.value(1)
+                boff = query.value(2)
+                bsym_start = query.value(3)
+                if bsym == 0:
+                        return
+                tot = bsym_start + boff + 1 - sym_start - off
+                if tot <= 0 or tot > 16384:
+                        return
+
+                inst = self.glb.disassembler.Instruction()
+                f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
+                if not f:
+                        return
+                mode = 0 if Is64Bit(f) else 1
+                self.glb.disassembler.SetMode(inst, mode)
+
+                buf_sz = tot + 16
+                buf = create_string_buffer(tot + 16)
+                f.seek(sym_start + off)
+                buf.value = f.read(buf_sz)
+                buf_ptr = addressof(buf)
+                i = 0
+                while tot > 0:
+                        cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
+                        if cnt:
+                                byte_str = tohex(ip).rjust(16)
+                                for k in xrange(cnt):
+                                        byte_str += " %02x" % ord(buf[i])
+                                        i += 1
+                                while k < 15:
+                                        byte_str += "   "
+                                        k += 1
+                                self.child_items.append(BranchLevelTwoItem(0, byte_str + " " + text, self))
+                                self.child_count += 1
+                        else:
+                                return
+                        buf_ptr += cnt
+                        tot -= cnt
+                        buf_sz -= cnt
+                        ip += cnt
+
+        def childCount(self):
+                if not self.query_done:
+                        self.Select()
+                        if not self.child_count:
+                                return -1
+                return self.child_count
+
+        def hasChildren(self):
+                if not self.query_done:
+                        return True
+                return self.child_count > 0
+
+        def getData(self, column):
+                return self.data[column]
+
+# Brance data model root item
+
+class BranchRootItem():
+
+        def __init__(self):
+                self.child_count = 0
+                self.child_items = []
+                self.level = 0
+
+        def getChildItem(self, row):
+                return self.child_items[row]
+
+        def getParentItem(self):
+                return None
+
+        def getRow(self):
+                return 0
+
+        def childCount(self):
+                return self.child_count
+
+        def hasChildren(self):
+                return self.child_count > 0
+
+        def getData(self, column):
+                return ""
+
+# Branch data preparation
+
+def BranchDataPrep(query):
+        data = []
+        for i in xrange(0, 8):
+                data.append(query.value(i))
+        data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) +
+                        " (" + dsoname(query.value(11)) + ")" + " -> " +
+                        tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) +
+                        " (" + dsoname(query.value(15)) + ")")
+        return data
+
+# Branch data model
+
+class BranchModel(TreeModel):
+
+        progress = Signal(object)
+
+        def __init__(self, glb, event_id, where_clause, parent=None):
+                super(BranchModel, self).__init__(BranchRootItem(), parent)
+                self.glb = glb
+                self.event_id = event_id
+                self.more = True
+                self.populated = 0
+                sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name,"
+                        " CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END,"
+                        " ip, symbols.name, sym_offset, dsos.short_name,"
+                        " to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name"
+                        " FROM samples"
+                        " INNER JOIN comms ON comm_id = comms.id"
+                        " INNER JOIN threads ON thread_id = threads.id"
+                        " INNER JOIN branch_types ON branch_type = branch_types.id"
+                        " INNER JOIN symbols ON symbol_id = symbols.id"
+                        " INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id"
+                        " INNER JOIN dsos ON samples.dso_id = dsos.id"
+                        " INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id"
+                        " WHERE samples.id > $$last_id$$" + where_clause +
+                        " AND evsel_id = " + str(self.event_id) +
+                        " ORDER BY samples.id"
+                        " LIMIT " + str(glb_chunk_sz))
+                self.fetcher = SQLFetcher(glb, sql, BranchDataPrep, self.AddSample)
+                self.fetcher.done.connect(self.Update)
+                self.fetcher.Fetch(glb_chunk_sz)
+
+        def columnCount(self, parent=None):
+                return 8
+
+        def columnHeader(self, column):
+                return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column]
+
+        def columnFont(self, column):
+                if column != 7:
+                        return None
+                return QFont("Monospace")
+
+        def DisplayData(self, item, index):
+                if item.level == 1:
+                        self.FetchIfNeeded(item.row)
+                return item.getData(index.column())
+
+        def AddSample(self, data):
+                child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
+                self.root.child_items.append(child)
+                self.populated += 1
+
+        def Update(self, fetched):
+                if not fetched:
+                        self.more = False
+                        self.progress.emit(0)
+                child_count = self.root.child_count
+                count = self.populated - child_count
+                if count > 0:
+                        parent = QModelIndex()
+                        self.beginInsertRows(parent, child_count, child_count + count - 1)
+                        self.insertRows(child_count, count, parent)
+                        self.root.child_count += count
+                        self.endInsertRows()
+                        self.progress.emit(self.root.child_count)
+
+        def FetchMoreRecords(self, count):
+                current = self.root.child_count
+                if self.more:
+                        self.fetcher.Fetch(count)
+                else:
+                        self.progress.emit(0)
+                return current
+
+        def HasMoreRecords(self):
+                return self.more
+
+# Branch window
+
+class BranchWindow(QMdiSubWindow):
+
+        def __init__(self, glb, event_id, name, where_clause, parent=None):
+                super(BranchWindow, self).__init__(parent)
+
+                model_name = "Branch Events " + str(event_id)
+                if len(where_clause):
+                        model_name = where_clause + " " + model_name
+
+                self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, where_clause))
+
+                self.view = QTreeView()
+                self.view.setUniformRowHeights(True)
+                self.view.setModel(self.model)
+
+                self.ResizeColumnsToContents()
+
+                self.find_bar = FindBar(self, self, True)
+
+                self.finder = ChildDataItemFinder(self.model.root)
+
+                self.fetch_bar = FetchMoreRecordsBar(self.model, self)
+
+                self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
+
+                self.setWidget(self.vbox.Widget())
+
+                AddSubWindow(glb.mainwindow.mdi_area, self, name + " Branch Events")
+
+        def ResizeColumnToContents(self, column, n):
+                # Using the view's resizeColumnToContents() here is extrememly slow
+                # so implement a crude alternative
+                mm = "MM" if column else "MMMM"
+                font = self.view.font()
+                metrics = QFontMetrics(font)
+                max = 0
+                for row in xrange(n):
+                        val = self.model.root.child_items[row].data[column]
+                        len = metrics.width(str(val) + mm)
+                        max = len if len > max else max
+                val = self.model.columnHeader(column)
+                len = metrics.width(str(val) + mm)
+                max = len if len > max else max
+                self.view.setColumnWidth(column, max)
+
+        def ResizeColumnsToContents(self):
+                n = min(self.model.root.child_count, 100)
+                if n < 1:
+                        # No data yet, so connect a signal to notify when there is
+                        self.model.rowsInserted.connect(self.UpdateColumnWidths)
+                        return
+                columns = self.model.columnCount()
+                for i in xrange(columns):
+                        self.ResizeColumnToContents(i, n)
+
+        def UpdateColumnWidths(self, *x):
+                # This only needs to be done once, so disconnect the signal now
+                self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
+                self.ResizeColumnsToContents()
+
+        def Find(self, value, direction, pattern, context):
+                self.view.setFocus()
+                self.find_bar.Busy()
+                self.finder.Find(value, direction, pattern, context, self.FindDone)
+
+        def FindDone(self, row):
+                self.find_bar.Idle()
+                if row >= 0:
+                        self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
+                else:
+                        self.find_bar.NotFound()
+
+# Event list
+
+def GetEventList(db):
+        events = []
+        query = QSqlQuery(db)
+        QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id")
+        while query.next():
+                events.append(query.value(0))
+        return events
+
+# SQL data preparation
+
+def SQLTableDataPrep(query, count):
+        data = []
+        for i in xrange(count):
+                data.append(query.value(i))
+        return data
+
+# SQL table data model item
+
+class SQLTableItem():
+
+        def __init__(self, row, data):
+                self.row = row
+                self.data = data
+
+        def getData(self, column):
+                return self.data[column]
+
+# SQL table data model
+
+class SQLTableModel(TableModel):
+
+        progress = Signal(object)
+
+        def __init__(self, glb, sql, column_count, parent=None):
+                super(SQLTableModel, self).__init__(parent)
+                self.glb = glb
+                self.more = True
+                self.populated = 0
+                self.fetcher = SQLFetcher(glb, sql, lambda x, y=column_count: SQLTableDataPrep(x, y), self.AddSample)
+                self.fetcher.done.connect(self.Update)
+                self.fetcher.Fetch(glb_chunk_sz)
+
+        def DisplayData(self, item, index):
+                self.FetchIfNeeded(item.row)
+                return item.getData(index.column())
+
+        def AddSample(self, data):
+                child = SQLTableItem(self.populated, data)
+                self.child_items.append(child)
+                self.populated += 1
+
+        def Update(self, fetched):
+                if not fetched:
+                        self.more = False
+                        self.progress.emit(0)
+                child_count = self.child_count
+                count = self.populated - child_count
+                if count > 0:
+                        parent = QModelIndex()
+                        self.beginInsertRows(parent, child_count, child_count + count - 1)
+                        self.insertRows(child_count, count, parent)
+                        self.child_count += count
+                        self.endInsertRows()
+                        self.progress.emit(self.child_count)
+
+        def FetchMoreRecords(self, count):
+                current = self.child_count
+                if self.more:
+                        self.fetcher.Fetch(count)
+                else:
+                        self.progress.emit(0)
+                return current
+
+        def HasMoreRecords(self):
+                return self.more
+
+# SQL automatic table data model
+
+class SQLAutoTableModel(SQLTableModel):
+
+        def __init__(self, glb, table_name, parent=None):
+                sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz)
+                if table_name == "comm_threads_view":
+                        # For now, comm_threads_view has no id column
+                        sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz)
+                self.column_headers = []
+                query = QSqlQuery(glb.db)
+                if glb.dbref.is_sqlite3:
+                        QueryExec(query, "PRAGMA table_info(" + table_name + ")")
+                        while query.next():
+                                self.column_headers.append(query.value(1))
+                        if table_name == "sqlite_master":
+                                sql = "SELECT * FROM " + table_name
+                else:
+                        if table_name[:19] == "information_schema.":
+                                sql = "SELECT * FROM " + table_name
+                                select_table_name = table_name[19:]
+                                schema = "information_schema"
+                        else:
+                                select_table_name = table_name
+                                schema = "public"
+                        QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'")
+                        while query.next():
+                                self.column_headers.append(query.value(0))
+                super(SQLAutoTableModel, self).__init__(glb, sql, len(self.column_headers), parent)
+
+        def columnCount(self, parent=None):
+                return len(self.column_headers)
+
+        def columnHeader(self, column):
+                return self.column_headers[column]
+
+# Base class for custom ResizeColumnsToContents
+
+class ResizeColumnsToContentsBase(QObject):
+
+        def __init__(self, parent=None):
+                super(ResizeColumnsToContentsBase, self).__init__(parent)
+
+        def ResizeColumnToContents(self, column, n):
+                # Using the view's resizeColumnToContents() here is extrememly slow
+                # so implement a crude alternative
+                font = self.view.font()
+                metrics = QFontMetrics(font)
+                max = 0
+                for row in xrange(n):
+                        val = self.data_model.child_items[row].data[column]
+                        len = metrics.width(str(val) + "MM")
+                        max = len if len > max else max
+                val = self.data_model.columnHeader(column)
+                len = metrics.width(str(val) + "MM")
+                max = len if len > max else max
+                self.view.setColumnWidth(column, max)
+
+        def ResizeColumnsToContents(self):
+                n = min(self.data_model.child_count, 100)
+                if n < 1:
+                        # No data yet, so connect a signal to notify when there is
+                        self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
+                        return
+                columns = self.data_model.columnCount()
+                for i in xrange(columns):
+                        self.ResizeColumnToContents(i, n)
+
+        def UpdateColumnWidths(self, *x):
+                # This only needs to be done once, so disconnect the signal now
+                self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
+                self.ResizeColumnsToContents()
+
+# Table window
+
+class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
+
+        def __init__(self, glb, table_name, parent=None):
+                super(TableWindow, self).__init__(parent)
+
+                self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name))
+
+                self.model = QSortFilterProxyModel()
+                self.model.setSourceModel(self.data_model)
+
+                self.view = QTableView()
+                self.view.setModel(self.model)
+                self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
+                self.view.verticalHeader().setVisible(False)
+                self.view.sortByColumn(-1, Qt.AscendingOrder)
+                self.view.setSortingEnabled(True)
+
+                self.ResizeColumnsToContents()
+
+                self.find_bar = FindBar(self, self, True)
+
+                self.finder = ChildDataItemFinder(self.data_model)
+
+                self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
+
+                self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
+
+                self.setWidget(self.vbox.Widget())
+
+                AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
+
+        def Find(self, value, direction, pattern, context):
+                self.view.setFocus()
+                self.find_bar.Busy()
+                self.finder.Find(value, direction, pattern, context, self.FindDone)
+
+        def FindDone(self, row):
+                self.find_bar.Idle()
+                if row >= 0:
+                        self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
+                else:
+                        self.find_bar.NotFound()
+
+# Table list
+
+def GetTableList(glb):
+        tables = []
+        query = QSqlQuery(glb.db)
+        if glb.dbref.is_sqlite3:
+                QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name")
+        else:
+                QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name")
+        while query.next():
+                tables.append(query.value(0))
+        if glb.dbref.is_sqlite3:
+                tables.append("sqlite_master")
+        else:
+                tables.append("information_schema.tables")
+                tables.append("information_schema.views")
+                tables.append("information_schema.columns")
+        return tables
+
+# Action Definition
+
+def CreateAction(label, tip, callback, parent=None, shortcut=None):
+        action = QAction(label, parent)
+        if shortcut != None:
+                action.setShortcuts(shortcut)
+        action.setStatusTip(tip)
+        action.triggered.connect(callback)
+        return action
+
+# Typical application actions
+
+def CreateExitAction(app, parent=None):
+        return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit)
+
+# Typical MDI actions
+
+def CreateCloseActiveWindowAction(mdi_area):
+        return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area)
+
+def CreateCloseAllWindowsAction(mdi_area):
+        return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area)
+
+def CreateTileWindowsAction(mdi_area):
+        return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area)
+
+def CreateCascadeWindowsAction(mdi_area):
+        return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area)
+
+def CreateNextWindowAction(mdi_area):
+        return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild)
+
+def CreatePreviousWindowAction(mdi_area):
+        return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild)
+
+# Typical MDI window menu
+
+class WindowMenu():
+
+        def __init__(self, mdi_area, menu):
+                self.mdi_area = mdi_area
+                self.window_menu = menu.addMenu("&Windows")
+                self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
+                self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
+                self.tile_windows = CreateTileWindowsAction(mdi_area)
+                self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
+                self.next_window = CreateNextWindowAction(mdi_area)
+                self.previous_window = CreatePreviousWindowAction(mdi_area)
+                self.window_menu.aboutToShow.connect(self.Update)
+
+        def Update(self):
+                self.window_menu.clear()
+                sub_window_count = len(self.mdi_area.subWindowList())
+                have_sub_windows = sub_window_count != 0
+                self.close_active_window.setEnabled(have_sub_windows)
+                self.close_all_windows.setEnabled(have_sub_windows)
+                self.tile_windows.setEnabled(have_sub_windows)
+                self.cascade_windows.setEnabled(have_sub_windows)
+                self.next_window.setEnabled(have_sub_windows)
+                self.previous_window.setEnabled(have_sub_windows)
+                self.window_menu.addAction(self.close_active_window)
+                self.window_menu.addAction(self.close_all_windows)
+                self.window_menu.addSeparator()
+                self.window_menu.addAction(self.tile_windows)
+                self.window_menu.addAction(self.cascade_windows)
+                self.window_menu.addSeparator()
+                self.window_menu.addAction(self.next_window)
+                self.window_menu.addAction(self.previous_window)
+                if sub_window_count == 0:
+                        return
+                self.window_menu.addSeparator()
+                nr = 1
+                for sub_window in self.mdi_area.subWindowList():
+                        label = str(nr) + " " + sub_window.name
+                        if nr < 10:
+                                label = "&" + label
+                        action = self.window_menu.addAction(label)
+                        action.setCheckable(True)
+                        action.setChecked(sub_window == self.mdi_area.activeSubWindow())
+                        action.triggered.connect(lambda x=nr: self.setActiveSubWindow(x))
+                        self.window_menu.addAction(action)
+                        nr += 1
+
+        def setActiveSubWindow(self, nr):
+                self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
+
+# Font resize
+
+def ResizeFont(widget, diff):
+        font = widget.font()
+        sz = font.pointSize()
+        font.setPointSize(sz + diff)
+        widget.setFont(font)
+
+def ShrinkFont(widget):
+        ResizeFont(widget, -1)
+
+def EnlargeFont(widget):
+        ResizeFont(widget, 1)
+
+# Unique name for sub-windows
+
+def NumberedWindowName(name, nr):
+        if nr > 1:
+                name += " <" + str(nr) + ">"
+        return name
+
+def UniqueSubWindowName(mdi_area, name):
+        nr = 1
+        while True:
+                unique_name = NumberedWindowName(name, nr)
+                ok = True
+                for sub_window in mdi_area.subWindowList():
+                        if sub_window.name == unique_name:
+                                ok = False
+                                break
+                if ok:
+                        return unique_name
+                nr += 1
+
+# Add a sub-window
+
+def AddSubWindow(mdi_area, sub_window, name):
+        unique_name = UniqueSubWindowName(mdi_area, name)
+        sub_window.setMinimumSize(200, 100)
+        sub_window.resize(800, 600)
+        sub_window.setWindowTitle(unique_name)
+        sub_window.setAttribute(Qt.WA_DeleteOnClose)
+        sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon))
+        sub_window.name = unique_name
+        mdi_area.addSubWindow(sub_window)
+        sub_window.show()
+
+# Main window
+
+class MainWindow(QMainWindow):
+
+        def __init__(self, glb, parent=None):
+                super(MainWindow, self).__init__(parent)
+
+                self.glb = glb
+
+                self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
+                self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
+                self.setMinimumSize(200, 100)
+
+                self.mdi_area = QMdiArea()
+                self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+                self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+
+                self.setCentralWidget(self.mdi_area)
+
+                menu = self.menuBar()
+
+                file_menu = menu.addMenu("&File")
+                file_menu.addAction(CreateExitAction(glb.app, self))
+
+                edit_menu = menu.addMenu("&Edit")
+                edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
+                edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)]))
+                edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")]))
+                edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")]))
+
+                reports_menu = menu.addMenu("&Reports")
+                reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
+
+                self.EventMenu(GetEventList(glb.db), reports_menu)
+
+                self.TableMenu(GetTableList(glb), menu)
+
+                self.window_menu = WindowMenu(self.mdi_area, menu)
+
+        def Find(self):
+                win = self.mdi_area.activeSubWindow()
+                if win:
+                        try:
+                                win.find_bar.Activate()
+                        except:
+                                pass
+
+        def FetchMoreRecords(self):
+                win = self.mdi_area.activeSubWindow()
+                if win:
+                        try:
+                                win.fetch_bar.Activate()
+                        except:
+                                pass
+
+        def ShrinkFont(self):
+                win = self.mdi_area.activeSubWindow()
+                ShrinkFont(win.view)
+
+        def EnlargeFont(self):
+                win = self.mdi_area.activeSubWindow()
+                EnlargeFont(win.view)
+
+        def EventMenu(self, events, reports_menu):
+                branches_events = 0
+                for event in events:
+                        event = event.split(":")[0]
+                        if event == "branches":
+                                branches_events += 1
+                dbid = 0
+                for event in events:
+                        dbid += 1
+                        event = event.split(":")[0]
+                        if event == "branches":
+                                label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")"
+                                reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda x=dbid: self.NewBranchView(x), self))
+
+        def TableMenu(self, tables, menu):
+                table_menu = menu.addMenu("&Tables")
+                for table in tables:
+                        table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda t=table: self.NewTableView(t), self))
+
+        def NewCallGraph(self):
+                CallGraphWindow(self.glb, self)
+
+        def NewBranchView(self, event_id):
+                BranchWindow(self.glb, event_id, "", "", self)
+
+        def NewTableView(self, table_name):
+                TableWindow(self.glb, table_name, self)
+
+# XED Disassembler
+
+class xed_state_t(Structure):
+
+        _fields_ = [
+                ("mode", c_int),
+                ("width", c_int)
+        ]
+
+class XEDInstruction():
+
+        def __init__(self, libxed):
+                # Current xed_decoded_inst_t structure is 192 bytes. Use 512 to allow for future expansion
+                xedd_t = c_byte * 512
+                self.xedd = xedd_t()
+                self.xedp = addressof(self.xedd)
+                libxed.xed_decoded_inst_zero(self.xedp)
+                self.state = xed_state_t()
+                self.statep = addressof(self.state)
+                # Buffer for disassembled instruction text
+                self.buffer = create_string_buffer(256)
+                self.bufferp = addressof(self.buffer)
+
+class LibXED():
+
+        def __init__(self):
+                self.libxed = CDLL("libxed.so")
+
+                self.xed_tables_init = self.libxed.xed_tables_init
+                self.xed_tables_init.restype = None
+                self.xed_tables_init.argtypes = []
+
+                self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero
+                self.xed_decoded_inst_zero.restype = None
+                self.xed_decoded_inst_zero.argtypes = [ c_void_p ]
+
+                self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode
+                self.xed_operand_values_set_mode.restype = None
+                self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ]
+
+                self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode
+                self.xed_decoded_inst_zero_keep_mode.restype = None
+                self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ]
+
+                self.xed_decode = self.libxed.xed_decode
+                self.xed_decode.restype = c_int
+                self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ]
+
+                self.xed_format_context = self.libxed.xed_format_context
+                self.xed_format_context.restype = c_uint
+                self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_void_p ]
+
+                self.xed_tables_init()
+
+        def Instruction(self):
+                return XEDInstruction(self)
+
+        def SetMode(self, inst, mode):
+                if mode:
+                        inst.state.mode = 4 # 32-bit
+                        inst.state.width = 4 # 4 bytes
+                else:
+                        inst.state.mode = 1 # 64-bit
+                        inst.state.width = 8 # 8 bytes
+                self.xed_operand_values_set_mode(inst.xedp, inst.statep)
+
+        def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip):
+                self.xed_decoded_inst_zero_keep_mode(inst.xedp)
+                err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt)
+                if err:
+                        return 0, ""
+                # Use AT&T mode (2), alternative is Intel (3)
+                ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0)
+                if not ok:
+                        return 0, ""
+                # Return instruction length and the disassembled instruction text
+                # For now, assume the length is in byte 166
+                return inst.xedd[166], inst.buffer.value
+
+def TryOpen(file_name):
+        try:
+                return open(file_name, "rb")
+        except:
+                return None
+
+def Is64Bit(f):
+        result = sizeof(c_void_p)
+        # ELF support only
+        pos = f.tell()
+        f.seek(0)
+        header = f.read(7)
+        f.seek(pos)
+        magic = header[0:4]
+        eclass = ord(header[4])
+        encoding = ord(header[5])
+        version = ord(header[6])
+        if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1:
+                result = True if eclass == 2 else False
+        return result
+
+# Global data
+
+class Glb():
+
+        def __init__(self, dbref, db, dbname):
+                self.dbref = dbref
+                self.db = db
+                self.dbname = dbname
+                self.home_dir = os.path.expanduser("~")
+                self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
+                if self.buildid_dir:
+                        self.buildid_dir += "/.build-id/"
+                else:
+                        self.buildid_dir = self.home_dir + "/.debug/.build-id/"
+                self.app = None
+                self.mainwindow = None
+                self.instances_to_shutdown_on_exit = weakref.WeakSet()
+                try:
+                        self.disassembler = LibXED()
+                        self.have_disassembler = True
+                except:
+                        self.have_disassembler = False
+
+        def FileFromBuildId(self, build_id):
+                file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
+                return TryOpen(file_name)
+
+        def FileFromNamesAndBuildId(self, short_name, long_name, build_id):
+                # Assume current machine i.e. no support for virtualization
+                if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore":
+                        file_name = os.getenv("PERF_KCORE")
+                        f = TryOpen(file_name) if file_name else None
+                        if f:
+                                return f
+                        # For now, no special handling if long_name is /proc/kcore
+                        f = TryOpen(long_name)
+                        if f:
+                                return f
+                f = self.FileFromBuildId(build_id)
+                if f:
+                        return f
+                return None
+
+        def AddInstanceToShutdownOnExit(self, instance):
+                self.instances_to_shutdown_on_exit.add(instance)
+
+        # Shutdown any background processes or threads
+        def ShutdownInstances(self):
+                for x in self.instances_to_shutdown_on_exit:
+                        try:
+                                x.Shutdown()
+                        except:
+                                pass
+
+# Database reference
+
+class DBRef():
+
+        def __init__(self, is_sqlite3, dbname):
+                self.is_sqlite3 = is_sqlite3
+                self.dbname = dbname
+
+        def Open(self, connection_name):
+                dbname = self.dbname
+                if self.is_sqlite3:
+                        db = QSqlDatabase.addDatabase("QSQLITE", connection_name)
+                else:
+                        db = QSqlDatabase.addDatabase("QPSQL", connection_name)
+                        opts = dbname.split()
+                        for opt in opts:
+                                if "=" in opt:
+                                        opt = opt.split("=")
+                                        if opt[0] == "hostname":
+                                                db.setHostName(opt[1])
+                                        elif opt[0] == "port":
+                                                db.setPort(int(opt[1]))
+                                        elif opt[0] == "username":
+                                                db.setUserName(opt[1])
+                                        elif opt[0] == "password":
+                                                db.setPassword(opt[1])
+                                        elif opt[0] == "dbname":
+                                                dbname = opt[1]
+                                else:
+                                        dbname = opt
+
+                db.setDatabaseName(dbname)
+                if not db.open():
+                        raise Exception("Failed to open database " + dbname + " error: " + db.lastError().text())
+                return db, dbname
+
+# Main
+
+def Main():
+        if (len(sys.argv) < 2):
+                print >> sys.stderr, "Usage is: exported-sql-viewer.py <database name>"
+                raise Exception("Too few arguments")
+
+        dbname = sys.argv[1]
+
+        is_sqlite3 = False
+        try:
+                f = open(dbname)
+                if f.read(15) == "SQLite format 3":
+                        is_sqlite3 = True
+                f.close()
+        except:
+                pass
+
+        dbref = DBRef(is_sqlite3, dbname)
+        db, dbname = dbref.Open("main")
+        glb = Glb(dbref, db, dbname)
+        app = QApplication(sys.argv)
+        glb.app = app
+        mainwindow = MainWindow(glb)
+        glb.mainwindow = mainwindow
+        mainwindow.show()
+        err = app.exec_()
+        glb.ShutdownInstances()
+        db.close()
+        sys.exit(err)
+
+if __name__ == "__main__":
+        Main()
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 6c108fa79ae3..0b2b8305c965 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -21,6 +21,7 @@ perf-y += python-use.o
 perf-y += bp_signal.o
 perf-y += bp_signal_overflow.o
 perf-y += bp_account.o
+perf-y += wp.o
 perf-y += task-exit.o
 perf-y += sw-clock.o
 perf-y += mmap-thread-lookup.o
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index d7a5e1b9aa6f..12c09e0ece71 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -121,6 +121,16 @@ static struct test generic_tests[] = {
                 .is_supported = test__bp_signal_is_supported,
         },
         {
+                .desc = "Watchpoint",
+                .func = test__wp,
+                .is_supported = test__wp_is_supported,
+                .subtest = {
+                        .skip_if_fail   = false,
+                        .get_nr         = test__wp_subtest_get_nr,
+                        .get_desc       = test__wp_subtest_get_desc,
+                },
+        },
+        {
                 .desc = "Number of exit events of a simple workload",
                 .func = test__task_exit,
         },
diff --git a/tools/perf/tests/evsel-tp-sched.c b/tools/perf/tests/evsel-tp-sched.c
index 699561fa512c..5f8501c68da4 100644
--- a/tools/perf/tests/evsel-tp-sched.c
+++ b/tools/perf/tests/evsel-tp-sched.c
@@ -8,7 +8,7 @@
 static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
                                   int size, bool should_be_signed)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
+        struct tep_format_field *field = perf_evsel__field(evsel, name);
         int is_signed;
         int ret = 0;
 
@@ -17,7 +17,7 @@ static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
                 return -1;
         }
 
-        is_signed = !!(field->flags | FIELD_IS_SIGNED);
+        is_signed = !!(field->flags | TEP_FIELD_IS_SIGNED);
         if (should_be_signed && !is_signed) {
                 pr_debug("%s: \"%s\" signedness(%d) is wrong, should be %d\n",
                          evsel->name, name, is_signed, should_be_signed);
diff --git a/tools/perf/tests/shell/record+probe_libc_inet_pton.sh b/tools/perf/tests/shell/record+probe_libc_inet_pton.sh
index 3013ac8f83d0..cab7b0aea6ea 100755
--- a/tools/perf/tests/shell/record+probe_libc_inet_pton.sh
+++ b/tools/perf/tests/shell/record+probe_libc_inet_pton.sh
@@ -48,7 +48,7 @@ trace_libc_inet_pton_backtrace() {
         *)
                 eventattr='max-stack=3'
                 echo "getaddrinfo\+0x[[:xdigit:]]+[[:space:]]\($libc\)$" >> $expected
-                echo ".*\+0x[[:xdigit:]]+[[:space:]]\(.*/bin/ping.*\)$" >> $expected
+                echo ".*(\+0x[[:xdigit:]]+|\[unknown\])[[:space:]]\(.*/bin/ping.*\)$" >> $expected
                 ;;
         esac
 
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index a9760e790563..b82f55fcc294 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -59,6 +59,9 @@ int test__python_use(struct test *test, int subtest);
 int test__bp_signal(struct test *test, int subtest);
 int test__bp_signal_overflow(struct test *test, int subtest);
 int test__bp_accounting(struct test *test, int subtest);
+int test__wp(struct test *test, int subtest);
+const char *test__wp_subtest_get_desc(int subtest);
+int test__wp_subtest_get_nr(void);
 int test__task_exit(struct test *test, int subtest);
 int test__mem(struct test *test, int subtest);
 int test__sw_clock_freq(struct test *test, int subtest);
@@ -106,6 +109,7 @@ int test__unit_number__scnprint(struct test *test, int subtest);
 int test__mem2node(struct test *t, int subtest);
 
 bool test__bp_signal_is_supported(void);
+bool test__wp_is_supported(void);
 
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/tests/wp.c b/tools/perf/tests/wp.c
new file mode 100644
index 000000000000..f89e6806557b
--- /dev/null
+++ b/tools/perf/tests/wp.c
@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <linux/hw_breakpoint.h>
+#include "tests.h"
+#include "debug.h"
+#include "cloexec.h"
+
+#define WP_TEST_ASSERT_VAL(fd, text, val)       \
+do {                                            \
+        long long count;                        \
+        wp_read(fd, &count, sizeof(long long)); \
+        TEST_ASSERT_VAL(text, count == val);    \
+} while (0)
+
+volatile u64 data1;
+volatile u8 data2[3];
+
+static int wp_read(int fd, long long *count, int size)
+{
+        int ret = read(fd, count, size);
+
+        if (ret != size) {
+                pr_debug("failed to read: %d\n", ret);
+                return -1;
+        }
+        return 0;
+}
+
+static void get__perf_event_attr(struct perf_event_attr *attr, int wp_type,
+                                 void *wp_addr, unsigned long wp_len)
+{
+        memset(attr, 0, sizeof(struct perf_event_attr));
+        attr->type           = PERF_TYPE_BREAKPOINT;
+        attr->size           = sizeof(struct perf_event_attr);
+        attr->config         = 0;
+        attr->bp_type        = wp_type;
+        attr->bp_addr        = (unsigned long)wp_addr;
+        attr->bp_len         = wp_len;
+        attr->sample_period  = 1;
+        attr->sample_type    = PERF_SAMPLE_IP;
+        attr->exclude_kernel = 1;
+        attr->exclude_hv     = 1;
+}
+
+static int __event(int wp_type, void *wp_addr, unsigned long wp_len)
+{
+        int fd;
+        struct perf_event_attr attr;
+
+        get__perf_event_attr(&attr, wp_type, wp_addr, wp_len);
+        fd = sys_perf_event_open(&attr, 0, -1, -1,
+                                 perf_event_open_cloexec_flag());
+        if (fd < 0)
+                pr_debug("failed opening event %x\n", attr.bp_type);
+
+        return fd;
+}
+
+static int wp_ro_test(void)
+{
+        int fd;
+        unsigned long tmp, tmp1 = rand();
+
+        fd = __event(HW_BREAKPOINT_R, (void *)&data1, sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        tmp = data1;
+        WP_TEST_ASSERT_VAL(fd, "RO watchpoint", 1);
+
+        data1 = tmp1 + tmp;
+        WP_TEST_ASSERT_VAL(fd, "RO watchpoint", 1);
+
+        close(fd);
+        return 0;
+}
+
+static int wp_wo_test(void)
+{
+        int fd;
+        unsigned long tmp, tmp1 = rand();
+
+        fd = __event(HW_BREAKPOINT_W, (void *)&data1, sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        tmp = data1;
+        WP_TEST_ASSERT_VAL(fd, "WO watchpoint", 0);
+
+        data1 = tmp1 + tmp;
+        WP_TEST_ASSERT_VAL(fd, "WO watchpoint", 1);
+
+        close(fd);
+        return 0;
+}
+
+static int wp_rw_test(void)
+{
+        int fd;
+        unsigned long tmp, tmp1 = rand();
+
+        fd = __event(HW_BREAKPOINT_R | HW_BREAKPOINT_W, (void *)&data1,
+                     sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        tmp = data1;
+        WP_TEST_ASSERT_VAL(fd, "RW watchpoint", 1);
+
+        data1 = tmp1 + tmp;
+        WP_TEST_ASSERT_VAL(fd, "RW watchpoint", 2);
+
+        close(fd);
+        return 0;
+}
+
+static int wp_modify_test(void)
+{
+        int fd, ret;
+        unsigned long tmp = rand();
+        struct perf_event_attr new_attr;
+
+        fd = __event(HW_BREAKPOINT_W, (void *)&data1, sizeof(data1));
+        if (fd < 0)
+                return -1;
+
+        data1 = tmp;
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 1);
+
+        /* Modify watchpoint with disabled = 1 */
+        get__perf_event_attr(&new_attr, HW_BREAKPOINT_W, (void *)&data2[0],
+                             sizeof(u8) * 2);
+        new_attr.disabled = 1;
+        ret = ioctl(fd, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, &new_attr);
+        if (ret < 0) {
+                pr_debug("ioctl(PERF_EVENT_IOC_MODIFY_ATTRIBUTES) failed\n");
+                close(fd);
+                return ret;
+        }
+
+        data2[1] = tmp; /* Not Counted */
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 1);
+
+        /* Enable the event */
+        ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
+        if (ret < 0) {
+                pr_debug("Failed to enable event\n");
+                close(fd);
+                return ret;
+        }
+
+        data2[1] = tmp; /* Counted */
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 2);
+
+        data2[2] = tmp; /* Not Counted */
+        WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 2);
+
+        close(fd);
+        return 0;
+}
+
+static bool wp_ro_supported(void)
+{
+#if defined (__x86_64__) || defined (__i386__)
+        return false;
+#else
+        return true;
+#endif
+}
+
+static void wp_ro_skip_msg(void)
+{
+#if defined (__x86_64__) || defined (__i386__)
+        pr_debug("Hardware does not support read only watchpoints.\n");
+#endif
+}
+
+static struct {
+        const char *desc;
+        int (*target_func)(void);
+        bool (*is_supported)(void);
+        void (*skip_msg)(void);
+} wp_testcase_table[] = {
+        {
+                .desc = "Read Only Watchpoint",
+                .target_func = &wp_ro_test,
+                .is_supported = &wp_ro_supported,
+                .skip_msg = &wp_ro_skip_msg,
+        },
+        {
+                .desc = "Write Only Watchpoint",
+                .target_func = &wp_wo_test,
+        },
+        {
+                .desc = "Read / Write Watchpoint",
+                .target_func = &wp_rw_test,
+        },
+        {
+                .desc = "Modify Watchpoint",
+                .target_func = &wp_modify_test,
+        },
+};
+
+int test__wp_subtest_get_nr(void)
+{
+        return (int)ARRAY_SIZE(wp_testcase_table);
+}
+
+const char *test__wp_subtest_get_desc(int i)
+{
+        if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
+                return NULL;
+        return wp_testcase_table[i].desc;
+}
+
+int test__wp(struct test *test __maybe_unused, int i)
+{
+        if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
+                return TEST_FAIL;
+
+        if (wp_testcase_table[i].is_supported &&
+            !wp_testcase_table[i].is_supported()) {
+                wp_testcase_table[i].skip_msg();
+                return TEST_SKIP;
+        }
+
+        return !wp_testcase_table[i].target_func() ? TEST_OK : TEST_FAIL;
+}
+
+/* The s390 so far does not have support for
+ * instruction breakpoint using the perf_event_open() system call.
+ */
+bool test__wp_is_supported(void)
+{
+#if defined(__s390x__)
+        return false;
+#else
+        return true;
+#endif
+}
diff --git a/tools/perf/trace/beauty/Build b/tools/perf/trace/beauty/Build
index f528ba35e140..304313073242 100644
--- a/tools/perf/trace/beauty/Build
+++ b/tools/perf/trace/beauty/Build
@@ -5,7 +5,9 @@ ifeq ($(SRCARCH),$(filter $(SRCARCH),x86))
 libperf-y += ioctl.o
 endif
 libperf-y += kcmp.o
+libperf-y += mount_flags.o
 libperf-y += pkey_alloc.o
 libperf-y += prctl.o
+libperf-y += sockaddr.o
 libperf-y += socket.o
 libperf-y += statx.o
diff --git a/tools/perf/trace/beauty/beauty.h b/tools/perf/trace/beauty/beauty.h
index 9615af5d412b..039c29039b2c 100644
--- a/tools/perf/trace/beauty/beauty.h
+++ b/tools/perf/trace/beauty/beauty.h
@@ -24,15 +24,43 @@ struct strarray {
 }
 
 size_t strarray__scnprintf(struct strarray *sa, char *bf, size_t size, const char *intfmt, int val);
+size_t strarray__scnprintf_flags(struct strarray *sa, char *bf, size_t size, unsigned long flags);
 
 struct trace;
 struct thread;
 
 size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_t size);
 
+extern struct strarray strarray__socket_families;
+
+/**
+ * augmented_arg: extra payload for syscall pointer arguments
+ 
+ * If perf_sample->raw_size is more than what a syscall sys_enter_FOO puts,
+ * then its the arguments contents, so that we can show more than just a
+ * pointer. This will be done initially with eBPF, the start of that is at the
+ * tools/perf/examples/bpf/augmented_syscalls.c example for the openat, but
+ * will eventually be done automagically caching the running kernel tracefs
+ * events data into an eBPF C script, that then gets compiled and its .o file
+ * cached for subsequent use. For char pointers like the ones for 'open' like
+ * syscalls its easy, for the rest we should use DWARF or better, BTF, much
+ * more compact.
+ *
+ * @size: 8 if all we need is an integer, otherwise all of the augmented arg.
+ * @int_arg: will be used for integer like pointer contents, like 'accept's 'upeer_addrlen'
+ * @value: u64 aligned, for structs, pathnames
+ */
+struct augmented_arg {
+        int  size;
+        int  int_arg;
+        u64  value[];
+};
+
 /**
  * @val: value of syscall argument being formatted
  * @args: All the args, use syscall_args__val(arg, nth) to access one
+ * @augmented_args: Extra data that can be collected, for instance, with eBPF for expanding the pathname for open, etc
+ * @augmented_args_size: augmented_args total payload size
  * @thread: tid state (maps, pid, tid, etc)
  * @trace: 'perf trace' internals: all threads, etc
  * @parm: private area, may be an strarray, for instance
@@ -43,6 +71,10 @@ size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_
 struct syscall_arg {
         unsigned long val;
         unsigned char *args;
+        struct {
+                struct augmented_arg *args;
+                int                  size;
+        } augmented;
         struct thread *thread;
         struct trace  *trace;
         void          *parm;
@@ -91,6 +123,12 @@ size_t syscall_arg__scnprintf_kcmp_type(char *bf, size_t size, struct syscall_ar
 size_t syscall_arg__scnprintf_kcmp_idx(char *bf, size_t size, struct syscall_arg *arg);
 #define SCA_KCMP_IDX syscall_arg__scnprintf_kcmp_idx
 
+unsigned long syscall_arg__mask_val_mount_flags(struct syscall_arg *arg, unsigned long flags);
+#define SCAMV_MOUNT_FLAGS syscall_arg__mask_val_mount_flags
+
+size_t syscall_arg__scnprintf_mount_flags(char *bf, size_t size, struct syscall_arg *arg);
+#define SCA_MOUNT_FLAGS syscall_arg__scnprintf_mount_flags
+
 size_t syscall_arg__scnprintf_pkey_alloc_access_rights(char *bf, size_t size, struct syscall_arg *arg);
 #define SCA_PKEY_ALLOC_ACCESS_RIGHTS syscall_arg__scnprintf_pkey_alloc_access_rights
 
@@ -106,6 +144,9 @@ size_t syscall_arg__scnprintf_prctl_arg2(char *bf, size_t size, struct syscall_a
 size_t syscall_arg__scnprintf_prctl_arg3(char *bf, size_t size, struct syscall_arg *arg);
 #define SCA_PRCTL_ARG3 syscall_arg__scnprintf_prctl_arg3
 
+size_t syscall_arg__scnprintf_sockaddr(char *bf, size_t size, struct syscall_arg *arg);
+#define SCA_SOCKADDR syscall_arg__scnprintf_sockaddr
+
 size_t syscall_arg__scnprintf_socket_protocol(char *bf, size_t size, struct syscall_arg *arg);
 #define SCA_SK_PROTO syscall_arg__scnprintf_socket_protocol
 
diff --git a/tools/perf/trace/beauty/clone.c b/tools/perf/trace/beauty/clone.c
index d64d049ab991..010406500c30 100644
--- a/tools/perf/trace/beauty/clone.c
+++ b/tools/perf/trace/beauty/clone.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/cone.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"
diff --git a/tools/perf/trace/beauty/drm_ioctl.sh b/tools/perf/trace/beauty/drm_ioctl.sh
index 9d3816815e60..9aa94fd523a9 100755
--- a/tools/perf/trace/beauty/drm_ioctl.sh
+++ b/tools/perf/trace/beauty/drm_ioctl.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/drm/
 
diff --git a/tools/perf/trace/beauty/eventfd.c b/tools/perf/trace/beauty/eventfd.c
index 5d6a477a6400..db5b9b492113 100644
--- a/tools/perf/trace/beauty/eventfd.c
+++ b/tools/perf/trace/beauty/eventfd.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #ifndef EFD_SEMAPHORE
 #define EFD_SEMAPHORE           1
 #endif
diff --git a/tools/perf/trace/beauty/fcntl.c b/tools/perf/trace/beauty/fcntl.c
index 9e8900c13cb1..e6de31674e24 100644
--- a/tools/perf/trace/beauty/fcntl.c
+++ b/tools/perf/trace/beauty/fcntl.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/fcntl.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"
diff --git a/tools/perf/trace/beauty/flock.c b/tools/perf/trace/beauty/flock.c
index c4ff6ad30b06..cf02ae5f0ba6 100644
--- a/tools/perf/trace/beauty/flock.c
+++ b/tools/perf/trace/beauty/flock.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 
 #include "trace/beauty/beauty.h"
 #include <linux/kernel.h>
diff --git a/tools/perf/trace/beauty/futex_op.c b/tools/perf/trace/beauty/futex_op.c
index 61850fbc85ff..1136bde56406 100644
--- a/tools/perf/trace/beauty/futex_op.c
+++ b/tools/perf/trace/beauty/futex_op.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <linux/futex.h>
 
 #ifndef FUTEX_WAIT_BITSET
diff --git a/tools/perf/trace/beauty/futex_val3.c b/tools/perf/trace/beauty/futex_val3.c
index 26f6b3253511..138b7d588a70 100644
--- a/tools/perf/trace/beauty/futex_val3.c
+++ b/tools/perf/trace/beauty/futex_val3.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <linux/futex.h>
 
 #ifndef FUTEX_BITSET_MATCH_ANY
diff --git a/tools/perf/trace/beauty/ioctl.c b/tools/perf/trace/beauty/ioctl.c
index 1be3b4cf0827..5d2a7fd8d407 100644
--- a/tools/perf/trace/beauty/ioctl.c
+++ b/tools/perf/trace/beauty/ioctl.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/ioctl.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"
diff --git a/tools/perf/trace/beauty/kcmp.c b/tools/perf/trace/beauty/kcmp.c
index f62040eb9d5c..b276a274f203 100644
--- a/tools/perf/trace/beauty/kcmp.c
+++ b/tools/perf/trace/beauty/kcmp.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/kcmp.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"
diff --git a/tools/perf/trace/beauty/kcmp_type.sh b/tools/perf/trace/beauty/kcmp_type.sh
index a3c304caa336..df8b17486d57 100755
--- a/tools/perf/trace/beauty/kcmp_type.sh
+++ b/tools/perf/trace/beauty/kcmp_type.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
 
diff --git a/tools/perf/trace/beauty/kvm_ioctl.sh b/tools/perf/trace/beauty/kvm_ioctl.sh
index c4699fd46bb6..4ce54f5bf756 100755
--- a/tools/perf/trace/beauty/kvm_ioctl.sh
+++ b/tools/perf/trace/beauty/kvm_ioctl.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
 
diff --git a/tools/perf/trace/beauty/madvise_behavior.sh b/tools/perf/trace/beauty/madvise_behavior.sh
index 431639eb4d29..4527d290cdfc 100755
--- a/tools/perf/trace/beauty/madvise_behavior.sh
+++ b/tools/perf/trace/beauty/madvise_behavior.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/asm-generic/
 
diff --git a/tools/perf/trace/beauty/mmap.c b/tools/perf/trace/beauty/mmap.c
index 9f68077b241b..c534bd96ef5c 100644
--- a/tools/perf/trace/beauty/mmap.c
+++ b/tools/perf/trace/beauty/mmap.c
@@ -1,5 +1,6 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <uapi/linux/mman.h>
+#include <linux/log2.h>
 
 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
                                                struct syscall_arg *arg)
@@ -30,50 +31,23 @@ static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
 
 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
 
+static size_t mmap__scnprintf_flags(unsigned long flags, char *bf, size_t size)
+{
+#include "trace/beauty/generated/mmap_flags_array.c"
+       static DEFINE_STRARRAY(mmap_flags);
+
+       return strarray__scnprintf_flags(&strarray__mmap_flags, bf, size, flags);
+}
+
 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
                                                 struct syscall_arg *arg)
 {
-        int printed = 0, flags = arg->val;
+        unsigned long flags = arg->val;
 
         if (flags & MAP_ANONYMOUS)
                 arg->mask |= (1 << 4) | (1 << 5); /* Mask 4th ('fd') and 5th ('offset') args, ignored */
 
-#define P_MMAP_FLAG(n) \
-        if (flags & MAP_##n) { \
-                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
-                flags &= ~MAP_##n; \
-        }
-
-        P_MMAP_FLAG(SHARED);
-        P_MMAP_FLAG(PRIVATE);
-#ifdef MAP_32BIT
-        P_MMAP_FLAG(32BIT);
-#endif
-        P_MMAP_FLAG(ANONYMOUS);
-        P_MMAP_FLAG(DENYWRITE);
-        P_MMAP_FLAG(EXECUTABLE);
-        P_MMAP_FLAG(FILE);
-        P_MMAP_FLAG(FIXED);
-#ifdef MAP_FIXED_NOREPLACE
-        P_MMAP_FLAG(FIXED_NOREPLACE);
-#endif
-        P_MMAP_FLAG(GROWSDOWN);
-        P_MMAP_FLAG(HUGETLB);
-        P_MMAP_FLAG(LOCKED);
-        P_MMAP_FLAG(NONBLOCK);
-        P_MMAP_FLAG(NORESERVE);
-        P_MMAP_FLAG(POPULATE);
-        P_MMAP_FLAG(STACK);
-        P_MMAP_FLAG(UNINITIALIZED);
-#ifdef MAP_SYNC
-        P_MMAP_FLAG(SYNC);
-#endif
-#undef P_MMAP_FLAG
-
-        if (flags)
-                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
-
-        return printed;
+        return mmap__scnprintf_flags(flags, bf, size);
 }
 
 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
diff --git a/tools/perf/trace/beauty/mmap_flags.sh b/tools/perf/trace/beauty/mmap_flags.sh
new file mode 100755
index 000000000000..22c3fdca8975
--- /dev/null
+++ b/tools/perf/trace/beauty/mmap_flags.sh
@@ -0,0 +1,32 @@
+#!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
+
+if [ $# -ne 2 ] ; then
+        [ $# -eq 1 ] && hostarch=$1 || hostarch=`uname -m | sed -e s/i.86/x86/ -e s/x86_64/x86/`
+        header_dir=tools/include/uapi/asm-generic
+        arch_header_dir=tools/arch/${hostarch}/include/uapi/asm
+else
+        header_dir=$1
+        arch_header_dir=$2
+fi
+
+arch_mman=${arch_header_dir}/mman.h
+
+# those in egrep -vw are flags, we want just the bits
+
+printf "static const char *mmap_flags[] = {\n"
+regex='^[[:space:]]*#[[:space:]]*define[[:space:]]+MAP_([[:alnum:]_]+)[[:space:]]+(0x[[:xdigit:]]+)[[:space:]]*.*'
+egrep -q $regex ${arch_mman} && \
+(egrep $regex ${arch_mman} | \
+        sed -r "s/$regex/\2 \1/g"       | \
+        xargs printf "\t[ilog2(%s) + 1] = \"%s\",\n")
+egrep -q '#[[:space:]]*include[[:space:]]+<uapi/asm-generic/mman.*' ${arch_mman} &&
+(egrep $regex ${header_dir}/mman-common.h | \
+        egrep -vw 'MAP_(UNINITIALIZED|TYPE|SHARED_VALIDATE)' | \
+        sed -r "s/$regex/\2 \1/g"       | \
+        xargs printf "\t[ilog2(%s) + 1] = \"%s\",\n")
+egrep -q '#[[:space:]]*include[[:space:]]+<uapi/asm-generic/mman.h>.*' ${arch_mman} &&
+(egrep $regex ${header_dir}/mman.h | \
+        sed -r "s/$regex/\2 \1/g"       | \
+        xargs printf "\t[ilog2(%s) + 1] = \"%s\",\n")
+printf "};\n"
diff --git a/tools/perf/trace/beauty/mode_t.c b/tools/perf/trace/beauty/mode_t.c
index d929ad7dd97b..6879d36d3004 100644
--- a/tools/perf/trace/beauty/mode_t.c
+++ b/tools/perf/trace/beauty/mode_t.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
diff --git a/tools/perf/trace/beauty/mount_flags.c b/tools/perf/trace/beauty/mount_flags.c
new file mode 100644
index 000000000000..712935c6620a
--- /dev/null
+++ b/tools/perf/trace/beauty/mount_flags.c
@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: LGPL-2.1
+/*
+ * trace/beauty/mount_flags.c
+ *
+ *  Copyright (C) 2018, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+
+#include "trace/beauty/beauty.h"
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <linux/log2.h>
+#include <sys/mount.h>
+
+static size_t mount__scnprintf_flags(unsigned long flags, char *bf, size_t size)
+{
+#include "trace/beauty/generated/mount_flags_array.c"
+        static DEFINE_STRARRAY(mount_flags);
+
+        return strarray__scnprintf_flags(&strarray__mount_flags, bf, size, flags);
+}
+
+unsigned long syscall_arg__mask_val_mount_flags(struct syscall_arg *arg __maybe_unused, unsigned long flags)
+{
+        // do_mount in fs/namespace.c:
+        /*
+         * Pre-0.97 versions of mount() didn't have a flags word.  When the
+         * flags word was introduced its top half was required to have the
+         * magic value 0xC0ED, and this remained so until 2.4.0-test9.
+         * Therefore, if this magic number is present, it carries no
+         * information and must be discarded.
+         */
+        if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
+                flags &= ~MS_MGC_MSK;
+
+        return flags;
+}
+
+size_t syscall_arg__scnprintf_mount_flags(char *bf, size_t size, struct syscall_arg *arg)
+{
+        unsigned long flags = arg->val;
+
+        return mount__scnprintf_flags(flags, bf, size);
+}
diff --git a/tools/perf/trace/beauty/mount_flags.sh b/tools/perf/trace/beauty/mount_flags.sh
new file mode 100755
index 000000000000..45547573a1db
--- /dev/null
+++ b/tools/perf/trace/beauty/mount_flags.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
+
+[ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
+
+printf "static const char *mount_flags[] = {\n"
+regex='^[[:space:]]*#[[:space:]]*define[[:space:]]+MS_([[:alnum:]_]+)[[:space:]]+([[:digit:]]+)[[:space:]]*.*'
+egrep $regex ${header_dir}/fs.h | egrep -v '(MSK|VERBOSE|MGC_VAL)\>' | \
+        sed -r "s/$regex/\2 \2 \1/g" | sort -n | \
+        xargs printf "\t[%s ? (ilog2(%s) + 1) : 0] = \"%s\",\n"
+regex='^[[:space:]]*#[[:space:]]*define[[:space:]]+MS_([[:alnum:]_]+)[[:space:]]+\(1<<([[:digit:]]+)\)[[:space:]]*.*'
+egrep $regex ${header_dir}/fs.h | \
+        sed -r "s/$regex/\2 \1/g" | \
+        xargs printf "\t[%s + 1] = \"%s\",\n"
+printf "};\n"
diff --git a/tools/perf/trace/beauty/msg_flags.c b/tools/perf/trace/beauty/msg_flags.c
index c064d6aae659..1b9d6306d274 100644
--- a/tools/perf/trace/beauty/msg_flags.c
+++ b/tools/perf/trace/beauty/msg_flags.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <sys/types.h>
 #include <sys/socket.h>
 
diff --git a/tools/perf/trace/beauty/open_flags.c b/tools/perf/trace/beauty/open_flags.c
index 6aec6178a99d..cc673fec9184 100644
--- a/tools/perf/trace/beauty/open_flags.c
+++ b/tools/perf/trace/beauty/open_flags.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
diff --git a/tools/perf/trace/beauty/perf_event_open.c b/tools/perf/trace/beauty/perf_event_open.c
index 2bafd7c995ff..981185c1974b 100644
--- a/tools/perf/trace/beauty/perf_event_open.c
+++ b/tools/perf/trace/beauty/perf_event_open.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #ifndef PERF_FLAG_FD_NO_GROUP
 # define PERF_FLAG_FD_NO_GROUP          (1UL << 0)
 #endif
diff --git a/tools/perf/trace/beauty/perf_ioctl.sh b/tools/perf/trace/beauty/perf_ioctl.sh
index 6492c74df928..9aabd9743ef6 100755
--- a/tools/perf/trace/beauty/perf_ioctl.sh
+++ b/tools/perf/trace/beauty/perf_ioctl.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
 
diff --git a/tools/perf/trace/beauty/pid.c b/tools/perf/trace/beauty/pid.c
index 0313df342830..1a6acc46807b 100644
--- a/tools/perf/trace/beauty/pid.c
+++ b/tools/perf/trace/beauty/pid.c
@@ -1,4 +1,5 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
+
 size_t syscall_arg__scnprintf_pid(char *bf, size_t size, struct syscall_arg *arg)
 {
         int pid = arg->val;
diff --git a/tools/perf/trace/beauty/pkey_alloc.c b/tools/perf/trace/beauty/pkey_alloc.c
index 2ba784a3734a..1b8ed4cac815 100644
--- a/tools/perf/trace/beauty/pkey_alloc.c
+++ b/tools/perf/trace/beauty/pkey_alloc.c
@@ -1,40 +1,36 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/pkey_alloc.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 <linux/log2.h>
 
-static size_t pkey_alloc__scnprintf_access_rights(int access_rights, char *bf, size_t size)
+size_t strarray__scnprintf_flags(struct strarray *sa, char *bf, size_t size, unsigned long flags)
 {
         int i, printed = 0;
 
-#include "trace/beauty/generated/pkey_alloc_access_rights_array.c"
-        static DEFINE_STRARRAY(pkey_alloc_access_rights);
-
-        if (access_rights == 0) {
-                const char *s = strarray__pkey_alloc_access_rights.entries[0];
+        if (flags == 0) {
+                const char *s = sa->entries[0];
                 if (s)
                         return scnprintf(bf, size, "%s", s);
                 return scnprintf(bf, size, "%d", 0);
         }
 
-        for (i = 1; i < strarray__pkey_alloc_access_rights.nr_entries; ++i) {
-                int bit = 1 << (i - 1);
+        for (i = 1; i < sa->nr_entries; ++i) {
+                unsigned long bit = 1UL << (i - 1);
 
-                if (!(access_rights & bit))
+                if (!(flags & bit))
                         continue;
 
                 if (printed != 0)
                         printed += scnprintf(bf + printed, size - printed, "|");
 
-                if (strarray__pkey_alloc_access_rights.entries[i] != NULL)
-                        printed += scnprintf(bf + printed, size - printed, "%s", strarray__pkey_alloc_access_rights.entries[i]);
+                if (sa->entries[i] != NULL)
+                        printed += scnprintf(bf + printed, size - printed, "%s", sa->entries[i]);
                 else
                         printed += scnprintf(bf + printed, size - printed, "0x%#", bit);
         }
@@ -42,6 +38,14 @@ static size_t pkey_alloc__scnprintf_access_rights(int access_rights, char *bf, s
         return printed;
 }
 
+static size_t pkey_alloc__scnprintf_access_rights(int access_rights, char *bf, size_t size)
+{
+#include "trace/beauty/generated/pkey_alloc_access_rights_array.c"
+        static DEFINE_STRARRAY(pkey_alloc_access_rights);
+
+        return strarray__scnprintf_flags(&strarray__pkey_alloc_access_rights, bf, size, access_rights);
+}
+
 size_t syscall_arg__scnprintf_pkey_alloc_access_rights(char *bf, size_t size, struct syscall_arg *arg)
 {
         unsigned long cmd = arg->val;
diff --git a/tools/perf/trace/beauty/pkey_alloc_access_rights.sh b/tools/perf/trace/beauty/pkey_alloc_access_rights.sh
index e0a51aeb20b2..f8f1b560cf8a 100755
--- a/tools/perf/trace/beauty/pkey_alloc_access_rights.sh
+++ b/tools/perf/trace/beauty/pkey_alloc_access_rights.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/asm-generic/
 
diff --git a/tools/perf/trace/beauty/prctl.c b/tools/perf/trace/beauty/prctl.c
index 246130dad6c4..be7a5d395975 100644
--- a/tools/perf/trace/beauty/prctl.c
+++ b/tools/perf/trace/beauty/prctl.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/prctl.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"
diff --git a/tools/perf/trace/beauty/prctl_option.sh b/tools/perf/trace/beauty/prctl_option.sh
index f24722146ebe..d32f8f1124af 100755
--- a/tools/perf/trace/beauty/prctl_option.sh
+++ b/tools/perf/trace/beauty/prctl_option.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
 
diff --git a/tools/perf/trace/beauty/sched_policy.c b/tools/perf/trace/beauty/sched_policy.c
index ba5096ae76b6..48f2b5c9aa3e 100644
--- a/tools/perf/trace/beauty/sched_policy.c
+++ b/tools/perf/trace/beauty/sched_policy.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <sched.h>
 
 /*
diff --git a/tools/perf/trace/beauty/seccomp.c b/tools/perf/trace/beauty/seccomp.c
index b7097fd5fed9..e36156b19c70 100644
--- a/tools/perf/trace/beauty/seccomp.c
+++ b/tools/perf/trace/beauty/seccomp.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #ifndef SECCOMP_SET_MODE_STRICT
 #define SECCOMP_SET_MODE_STRICT 0
 #endif
diff --git a/tools/perf/trace/beauty/signum.c b/tools/perf/trace/beauty/signum.c
index bde18a53f090..587fec545b8a 100644
--- a/tools/perf/trace/beauty/signum.c
+++ b/tools/perf/trace/beauty/signum.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #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/sndrv_ctl_ioctl.sh b/tools/perf/trace/beauty/sndrv_ctl_ioctl.sh
index eb511bb5fbd3..e0803b957593 100755
--- a/tools/perf/trace/beauty/sndrv_ctl_ioctl.sh
+++ b/tools/perf/trace/beauty/sndrv_ctl_ioctl.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/sound/
 
diff --git a/tools/perf/trace/beauty/sndrv_pcm_ioctl.sh b/tools/perf/trace/beauty/sndrv_pcm_ioctl.sh
index 6818392968b2..7a464a7bf913 100755
--- a/tools/perf/trace/beauty/sndrv_pcm_ioctl.sh
+++ b/tools/perf/trace/beauty/sndrv_pcm_ioctl.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/sound/
 
diff --git a/tools/perf/trace/beauty/sockaddr.c b/tools/perf/trace/beauty/sockaddr.c
new file mode 100644
index 000000000000..9410ad230f10
--- /dev/null
+++ b/tools/perf/trace/beauty/sockaddr.c
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: LGPL-2.1
+// Copyright (C) 2018, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
+
+#include "trace/beauty/beauty.h"
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <arpa/inet.h>
+
+static const char *socket_families[] = {
+        "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
+        "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
+        "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
+        "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
+        "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
+        "ALG", "NFC", "VSOCK",
+};
+DEFINE_STRARRAY(socket_families);
+
+static size_t af_inet__scnprintf(struct sockaddr *sa, char *bf, size_t size)
+{
+        struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+        char tmp[16];
+        return scnprintf(bf, size, ", port: %d, addr: %s", ntohs(sin->sin_port),
+                         inet_ntop(sin->sin_family, &sin->sin_addr, tmp, sizeof(tmp)));
+}
+
+static size_t af_inet6__scnprintf(struct sockaddr *sa, char *bf, size_t size)
+{
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
+        u32 flowinfo = ntohl(sin6->sin6_flowinfo);
+        char tmp[512];
+        size_t printed = scnprintf(bf, size, ", port: %d, addr: %s", ntohs(sin6->sin6_port),
+                                   inet_ntop(sin6->sin6_family, &sin6->sin6_addr, tmp, sizeof(tmp)));
+        if (flowinfo != 0)
+                printed += scnprintf(bf + printed, size - printed, ", flowinfo: %lu", flowinfo);
+        if (sin6->sin6_scope_id != 0)
+                printed += scnprintf(bf + printed, size - printed, ", scope_id: %lu", sin6->sin6_scope_id);
+
+        return printed;
+}
+
+static size_t af_local__scnprintf(struct sockaddr *sa, char *bf, size_t size)
+{
+        struct sockaddr_un *sun = (struct sockaddr_un *)sa;
+        return scnprintf(bf, size, ", path: %s", sun->sun_path);
+}
+
+static size_t (*af_scnprintfs[])(struct sockaddr *sa, char *bf, size_t size) = {
+        [AF_LOCAL] = af_local__scnprintf,
+        [AF_INET]  = af_inet__scnprintf,
+        [AF_INET6] = af_inet6__scnprintf,
+};
+
+static size_t syscall_arg__scnprintf_augmented_sockaddr(struct syscall_arg *arg, char *bf, size_t size)
+{
+        struct sockaddr *sa = (struct sockaddr *)arg->augmented.args;
+        char family[32];
+        size_t printed;
+
+        strarray__scnprintf(&strarray__socket_families, family, sizeof(family), "%d", sa->sa_family);
+        printed = scnprintf(bf, size, "{ .family: %s", family);
+
+        if (sa->sa_family < ARRAY_SIZE(af_scnprintfs) && af_scnprintfs[sa->sa_family])
+                printed += af_scnprintfs[sa->sa_family](sa, bf + printed, size - printed);
+
+        return printed + scnprintf(bf + printed, size - printed, " }");
+}
+
+size_t syscall_arg__scnprintf_sockaddr(char *bf, size_t size, struct syscall_arg *arg)
+{
+        if (arg->augmented.args)
+                return syscall_arg__scnprintf_augmented_sockaddr(arg, bf, size);
+
+        return scnprintf(bf, size, "%#x", arg->val);
+}
diff --git a/tools/perf/trace/beauty/socket.c b/tools/perf/trace/beauty/socket.c
index 65227269384b..d971a2596417 100644
--- a/tools/perf/trace/beauty/socket.c
+++ b/tools/perf/trace/beauty/socket.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * trace/beauty/socket.c
  *
diff --git a/tools/perf/trace/beauty/socket_ipproto.sh b/tools/perf/trace/beauty/socket_ipproto.sh
index a3cc24633bec..de0f2f29017f 100755
--- a/tools/perf/trace/beauty/socket_ipproto.sh
+++ b/tools/perf/trace/beauty/socket_ipproto.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
 
diff --git a/tools/perf/trace/beauty/socket_type.c b/tools/perf/trace/beauty/socket_type.c
index bca26aef4a77..a63a9a332aa0 100644
--- a/tools/perf/trace/beauty/socket_type.c
+++ b/tools/perf/trace/beauty/socket_type.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <sys/types.h>
 #include <sys/socket.h>
 
diff --git a/tools/perf/trace/beauty/statx.c b/tools/perf/trace/beauty/statx.c
index 5643b692af4c..630f2760dd66 100644
--- a/tools/perf/trace/beauty/statx.c
+++ b/tools/perf/trace/beauty/statx.c
@@ -1,9 +1,8 @@
+// SPDX-License-Identifier: LGPL-2.1
 /*
  * 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"
diff --git a/tools/perf/trace/beauty/vhost_virtio_ioctl.sh b/tools/perf/trace/beauty/vhost_virtio_ioctl.sh
index 0f6a5197d0be..439773daaf77 100755
--- a/tools/perf/trace/beauty/vhost_virtio_ioctl.sh
+++ b/tools/perf/trace/beauty/vhost_virtio_ioctl.sh
@@ -1,4 +1,5 @@
 #!/bin/sh
+# SPDX-License-Identifier: LGPL-2.1
 
 [ $# -eq 1 ] && header_dir=$1 || header_dir=tools/include/uapi/linux/
 
diff --git a/tools/perf/trace/beauty/waitid_options.c b/tools/perf/trace/beauty/waitid_options.c
index 8465281a093d..42ff58ad613b 100644
--- a/tools/perf/trace/beauty/waitid_options.c
+++ b/tools/perf/trace/beauty/waitid_options.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: LGPL-2.1
 #include <sys/types.h>
 #include <sys/wait.h>
 
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
index 7efe15b9618d..ecd9f9ceda77 100644
--- a/tools/perf/util/Build
+++ b/tools/perf/util/Build
@@ -73,6 +73,7 @@ libperf-y += vdso.o
 libperf-y += counts.o
 libperf-y += stat.o
 libperf-y += stat-shadow.o
+libperf-y += stat-display.o
 libperf-y += record.o
 libperf-y += srcline.o
 libperf-y += data.o
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 28cd6a17491b..6936daf89ddd 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -139,6 +139,7 @@ static int arch__associate_ins_ops(struct arch* arch, const char *name, struct i
 #include "arch/x86/annotate/instructions.c"
 #include "arch/powerpc/annotate/instructions.c"
 #include "arch/s390/annotate/instructions.c"
+#include "arch/sparc/annotate/instructions.c"
 
 static struct arch architectures[] = {
         {
@@ -170,6 +171,13 @@ static struct arch architectures[] = {
                         .comment_char = '#',
                 },
         },
+        {
+                .name = "sparc",
+                .init = sparc__annotate_init,
+                .objdump = {
+                        .comment_char = '#',
+                },
+        },
 };
 
 static void ins__delete(struct ins_operands *ops)
diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
index db1511359c5e..72d5ba2479bf 100644
--- a/tools/perf/util/auxtrace.c
+++ b/tools/perf/util/auxtrace.c
@@ -906,9 +906,8 @@ out_free:
         return err;
 }
 
-int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused,
-                                      union perf_event *event,
-                                      struct perf_session *session)
+int perf_event__process_auxtrace_info(struct perf_session *session,
+                                      union perf_event *event)
 {
         enum auxtrace_type type = event->auxtrace_info.type;
 
@@ -932,9 +931,8 @@ int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused,
         }
 }
 
-s64 perf_event__process_auxtrace(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+s64 perf_event__process_auxtrace(struct perf_session *session,
+                                 union perf_event *event)
 {
         s64 err;
 
@@ -950,7 +948,7 @@ s64 perf_event__process_auxtrace(struct perf_tool *tool,
         if (!session->auxtrace || event->header.type != PERF_RECORD_AUXTRACE)
                 return -EINVAL;
 
-        err = session->auxtrace->process_auxtrace_event(session, event, tool);
+        err = session->auxtrace->process_auxtrace_event(session, event, session->tool);
         if (err < 0)
                 return err;
 
@@ -964,16 +962,23 @@ s64 perf_event__process_auxtrace(struct perf_tool *tool,
 #define PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ      64
 #define PERF_ITRACE_MAX_LAST_BRANCH_SZ          1024
 
-void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts)
+void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts,
+                                    bool no_sample)
 {
-        synth_opts->instructions = true;
         synth_opts->branches = true;
         synth_opts->transactions = true;
         synth_opts->ptwrites = true;
         synth_opts->pwr_events = true;
         synth_opts->errors = true;
-        synth_opts->period_type = PERF_ITRACE_DEFAULT_PERIOD_TYPE;
-        synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
+        if (no_sample) {
+                synth_opts->period_type = PERF_ITRACE_PERIOD_INSTRUCTIONS;
+                synth_opts->period = 1;
+                synth_opts->calls = true;
+        } else {
+                synth_opts->instructions = true;
+                synth_opts->period_type = PERF_ITRACE_DEFAULT_PERIOD_TYPE;
+                synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
+        }
         synth_opts->callchain_sz = PERF_ITRACE_DEFAULT_CALLCHAIN_SZ;
         synth_opts->last_branch_sz = PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ;
         synth_opts->initial_skip = 0;
@@ -1001,7 +1006,7 @@ int itrace_parse_synth_opts(const struct option *opt, const char *str,
         }
 
         if (!str) {
-                itrace_synth_opts__set_default(synth_opts);
+                itrace_synth_opts__set_default(synth_opts, false);
                 return 0;
         }
 
@@ -1185,9 +1190,8 @@ void events_stats__auxtrace_error_warn(const struct events_stats *stats)
         }
 }
 
-int perf_event__process_auxtrace_error(struct perf_tool *tool __maybe_unused,
-                                       union perf_event *event,
-                                       struct perf_session *session)
+int perf_event__process_auxtrace_error(struct perf_session *session,
+                                       union perf_event *event)
 {
         if (auxtrace__dont_decode(session))
                 return 0;
@@ -1196,11 +1200,12 @@ int perf_event__process_auxtrace_error(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
+static int __auxtrace_mmap__read(struct perf_mmap *map,
                                  struct auxtrace_record *itr,
                                  struct perf_tool *tool, process_auxtrace_t fn,
                                  bool snapshot, size_t snapshot_size)
 {
+        struct auxtrace_mmap *mm = &map->auxtrace_mmap;
         u64 head, old = mm->prev, offset, ref;
         unsigned char *data = mm->base;
         size_t size, head_off, old_off, len1, len2, padding;
@@ -1287,7 +1292,7 @@ static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
         ev.auxtrace.tid = mm->tid;
         ev.auxtrace.cpu = mm->cpu;
 
-        if (fn(tool, &ev, data1, len1, data2, len2))
+        if (fn(tool, map, &ev, data1, len1, data2, len2))
                 return -1;
 
         mm->prev = head;
@@ -1306,18 +1311,18 @@ static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
         return 1;
 }
 
-int auxtrace_mmap__read(struct auxtrace_mmap *mm, struct auxtrace_record *itr,
+int auxtrace_mmap__read(struct perf_mmap *map, struct auxtrace_record *itr,
                         struct perf_tool *tool, process_auxtrace_t fn)
 {
-        return __auxtrace_mmap__read(mm, itr, tool, fn, false, 0);
+        return __auxtrace_mmap__read(map, itr, tool, fn, false, 0);
 }
 
-int auxtrace_mmap__read_snapshot(struct auxtrace_mmap *mm,
+int auxtrace_mmap__read_snapshot(struct perf_mmap *map,
                                  struct auxtrace_record *itr,
                                  struct perf_tool *tool, process_auxtrace_t fn,
                                  size_t snapshot_size)
 {
-        return __auxtrace_mmap__read(mm, itr, tool, fn, true, snapshot_size);
+        return __auxtrace_mmap__read(map, itr, tool, fn, true, snapshot_size);
 }
 
 /**
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 71fc3bd74299..8e50f96d4b23 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -23,6 +23,7 @@
 #include <linux/list.h>
 #include <linux/perf_event.h>
 #include <linux/types.h>
+#include <asm/bitsperlong.h>
 
 #include "../perf.h"
 #include "event.h"
@@ -33,6 +34,7 @@ union perf_event;
 struct perf_session;
 struct perf_evlist;
 struct perf_tool;
+struct perf_mmap;
 struct option;
 struct record_opts;
 struct auxtrace_info_event;
@@ -56,6 +58,7 @@ enum itrace_period_type {
 /**
  * struct itrace_synth_opts - AUX area tracing synthesis options.
  * @set: indicates whether or not options have been set
+ * @default_no_sample: Default to no sampling.
  * @inject: indicates the event (not just the sample) must be fully synthesized
  *          because 'perf inject' will write it out
  * @instructions: whether to synthesize 'instructions' events
@@ -80,6 +83,7 @@ enum itrace_period_type {
  */
 struct itrace_synth_opts {
         bool                    set;
+        bool                    default_no_sample;
         bool                    inject;
         bool                    instructions;
         bool                    branches;
@@ -434,13 +438,14 @@ void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp,
                                    bool per_cpu);
 
 typedef int (*process_auxtrace_t)(struct perf_tool *tool,
+                                  struct perf_mmap *map,
                                   union perf_event *event, void *data1,
                                   size_t len1, void *data2, size_t len2);
 
-int auxtrace_mmap__read(struct auxtrace_mmap *mm, struct auxtrace_record *itr,
+int auxtrace_mmap__read(struct perf_mmap *map, struct auxtrace_record *itr,
                         struct perf_tool *tool, process_auxtrace_t fn);
 
-int auxtrace_mmap__read_snapshot(struct auxtrace_mmap *mm,
+int auxtrace_mmap__read_snapshot(struct perf_mmap *map,
                                  struct auxtrace_record *itr,
                                  struct perf_tool *tool, process_auxtrace_t fn,
                                  size_t snapshot_size);
@@ -517,18 +522,16 @@ int perf_event__synthesize_auxtrace_info(struct auxtrace_record *itr,
                                          struct perf_tool *tool,
                                          struct perf_session *session,
                                          perf_event__handler_t process);
-int perf_event__process_auxtrace_info(struct perf_tool *tool,
-                                      union perf_event *event,
-                                      struct perf_session *session);
-s64 perf_event__process_auxtrace(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session);
-int perf_event__process_auxtrace_error(struct perf_tool *tool,
-                                       union perf_event *event,
-                                       struct perf_session *session);
+int perf_event__process_auxtrace_info(struct perf_session *session,
+                                      union perf_event *event);
+s64 perf_event__process_auxtrace(struct perf_session *session,
+                                 union perf_event *event);
+int perf_event__process_auxtrace_error(struct perf_session *session,
+                                       union perf_event *event);
 int itrace_parse_synth_opts(const struct option *opt, const char *str,
                             int unset);
-void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts);
+void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts,
+                                    bool no_sample);
 
 size_t perf_event__fprintf_auxtrace_error(union perf_event *event, FILE *fp);
 void perf_session__auxtrace_error_inc(struct perf_session *session,
@@ -577,6 +580,23 @@ static inline void auxtrace__free(struct perf_session *session)
         return session->auxtrace->free(session);
 }
 
+#define ITRACE_HELP \
+"                               i:                      synthesize instructions events\n"               \
+"                               b:                      synthesize branches events\n"           \
+"                               c:                      synthesize branches events (calls only)\n"      \
+"                               r:                      synthesize branches events (returns only)\n" \
+"                               x:                      synthesize transactions events\n"               \
+"                               w:                      synthesize ptwrite events\n"            \
+"                               p:                      synthesize power events\n"                      \
+"                               e:                      synthesize error events\n"                      \
+"                               d:                      create a debug log\n"                   \
+"                               g[len]:                 synthesize a call chain (use with i or x)\n" \
+"                               l[len]:                 synthesize last branch entries (use with i or x)\n" \
+"                               sNUMBER:                skip initial number of events\n"                \
+"                               PERIOD[ns|us|ms|i|t]:   specify period to sample stream\n" \
+"                               concatenate multiple options. Default is ibxwpe or cewp\n"
+
+
 #else
 
 static inline struct auxtrace_record *
@@ -717,6 +737,8 @@ void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp,
                                    struct perf_evlist *evlist, int idx,
                                    bool per_cpu);
 
+#define ITRACE_HELP ""
+
 #endif
 
 #endif
diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c
index 47aac41349a2..f9ae1a993806 100644
--- a/tools/perf/util/bpf-loader.c
+++ b/tools/perf/util/bpf-loader.c
@@ -1615,7 +1615,7 @@ struct perf_evsel *bpf__setup_output_event(struct perf_evlist *evlist, const cha
 int bpf__setup_stdout(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel = bpf__setup_output_event(evlist, "__bpf_stdout__");
-        return IS_ERR(evsel) ? PTR_ERR(evsel) : 0;
+        return PTR_ERR_OR_ZERO(evsel);
 }
 
 #define ERRNO_OFFSET(e)         ((e) - __BPF_LOADER_ERRNO__START)
diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c
index 2ae640257fdb..73430b73570d 100644
--- a/tools/perf/util/cs-etm.c
+++ b/tools/perf/util/cs-etm.c
@@ -244,6 +244,27 @@ static void cs_etm__free(struct perf_session *session)
         zfree(&aux);
 }
 
+static u8 cs_etm__cpu_mode(struct cs_etm_queue *etmq, u64 address)
+{
+        struct machine *machine;
+
+        machine = etmq->etm->machine;
+
+        if (address >= etmq->etm->kernel_start) {
+                if (machine__is_host(machine))
+                        return PERF_RECORD_MISC_KERNEL;
+                else
+                        return PERF_RECORD_MISC_GUEST_KERNEL;
+        } else {
+                if (machine__is_host(machine))
+                        return PERF_RECORD_MISC_USER;
+                else if (perf_guest)
+                        return PERF_RECORD_MISC_GUEST_USER;
+                else
+                        return PERF_RECORD_MISC_HYPERVISOR;
+        }
+}
+
 static u32 cs_etm__mem_access(struct cs_etm_queue *etmq, u64 address,
                               size_t size, u8 *buffer)
 {
@@ -258,10 +279,7 @@ static u32 cs_etm__mem_access(struct cs_etm_queue *etmq, u64 address,
                 return -1;
 
         machine = etmq->etm->machine;
-        if (address >= etmq->etm->kernel_start)
-                cpumode = PERF_RECORD_MISC_KERNEL;
-        else
-                cpumode = PERF_RECORD_MISC_USER;
+        cpumode = cs_etm__cpu_mode(etmq, address);
 
         thread = etmq->thread;
         if (!thread) {
@@ -653,7 +671,7 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq,
         struct perf_sample sample = {.ip = 0,};
 
         event->sample.header.type = PERF_RECORD_SAMPLE;
-        event->sample.header.misc = PERF_RECORD_MISC_USER;
+        event->sample.header.misc = cs_etm__cpu_mode(etmq, addr);
         event->sample.header.size = sizeof(struct perf_event_header);
 
         sample.ip = addr;
@@ -665,7 +683,7 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq,
         sample.cpu = etmq->packet->cpu;
         sample.flags = 0;
         sample.insn_len = 1;
-        sample.cpumode = event->header.misc;
+        sample.cpumode = event->sample.header.misc;
 
         if (etm->synth_opts.last_branch) {
                 cs_etm__copy_last_branch_rb(etmq);
@@ -706,12 +724,15 @@ static int cs_etm__synth_branch_sample(struct cs_etm_queue *etmq)
                 u64                     nr;
                 struct branch_entry     entries;
         } dummy_bs;
+        u64 ip;
+
+        ip = cs_etm__last_executed_instr(etmq->prev_packet);
 
         event->sample.header.type = PERF_RECORD_SAMPLE;
-        event->sample.header.misc = PERF_RECORD_MISC_USER;
+        event->sample.header.misc = cs_etm__cpu_mode(etmq, ip);
         event->sample.header.size = sizeof(struct perf_event_header);
 
-        sample.ip = cs_etm__last_executed_instr(etmq->prev_packet);
+        sample.ip = ip;
         sample.pid = etmq->pid;
         sample.tid = etmq->tid;
         sample.addr = cs_etm__first_executed_instr(etmq->packet);
@@ -720,7 +741,7 @@ static int cs_etm__synth_branch_sample(struct cs_etm_queue *etmq)
         sample.period = 1;
         sample.cpu = etmq->packet->cpu;
         sample.flags = 0;
-        sample.cpumode = PERF_RECORD_MISC_USER;
+        sample.cpumode = event->sample.header.misc;
 
         /*
          * perf report cannot handle events without a branch stack
@@ -1432,7 +1453,8 @@ int cs_etm__process_auxtrace_info(union perf_event *event,
         if (session->itrace_synth_opts && session->itrace_synth_opts->set) {
                 etm->synth_opts = *session->itrace_synth_opts;
         } else {
-                itrace_synth_opts__set_default(&etm->synth_opts);
+                itrace_synth_opts__set_default(&etm->synth_opts,
+                                session->itrace_synth_opts->default_no_sample);
                 etm->synth_opts.callchain = false;
         }
 
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
index abd38abf1d91..2a36fab76994 100644
--- a/tools/perf/util/data-convert-bt.c
+++ b/tools/perf/util/data-convert-bt.c
@@ -182,20 +182,20 @@ err_put_field:
 }
 
 static struct bt_ctf_field_type*
-get_tracepoint_field_type(struct ctf_writer *cw, struct format_field *field)
+get_tracepoint_field_type(struct ctf_writer *cw, struct tep_format_field *field)
 {
         unsigned long flags = field->flags;
 
-        if (flags & FIELD_IS_STRING)
+        if (flags & TEP_FIELD_IS_STRING)
                 return cw->data.string;
 
-        if (!(flags & FIELD_IS_SIGNED)) {
+        if (!(flags & TEP_FIELD_IS_SIGNED)) {
                 /* unsigned long are mostly pointers */
-                if (flags & FIELD_IS_LONG || flags & FIELD_IS_POINTER)
+                if (flags & TEP_FIELD_IS_LONG || flags & TEP_FIELD_IS_POINTER)
                         return cw->data.u64_hex;
         }
 
-        if (flags & FIELD_IS_SIGNED) {
+        if (flags & TEP_FIELD_IS_SIGNED) {
                 if (field->size == 8)
                         return cw->data.s64;
                 else
@@ -287,7 +287,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                                       struct bt_ctf_event_class *event_class,
                                       struct bt_ctf_event *event,
                                       struct perf_sample *sample,
-                                      struct format_field *fmtf)
+                                      struct tep_format_field *fmtf)
 {
         struct bt_ctf_field_type *type;
         struct bt_ctf_field *array_field;
@@ -304,10 +304,10 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
         name = fmtf->alias;
         offset = fmtf->offset;
         len = fmtf->size;
-        if (flags & FIELD_IS_STRING)
-                flags &= ~FIELD_IS_ARRAY;
+        if (flags & TEP_FIELD_IS_STRING)
+                flags &= ~TEP_FIELD_IS_ARRAY;
 
-        if (flags & FIELD_IS_DYNAMIC) {
+        if (flags & TEP_FIELD_IS_DYNAMIC) {
                 unsigned long long tmp_val;
 
                 tmp_val = tep_read_number(fmtf->event->pevent,
@@ -317,7 +317,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                 offset &= 0xffff;
         }
 
-        if (flags & FIELD_IS_ARRAY) {
+        if (flags & TEP_FIELD_IS_ARRAY) {
 
                 type = bt_ctf_event_class_get_field_by_name(
                                 event_class, name);
@@ -338,7 +338,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
         type = get_tracepoint_field_type(cw, fmtf);
 
         for (i = 0; i < n_items; i++) {
-                if (flags & FIELD_IS_ARRAY)
+                if (flags & TEP_FIELD_IS_ARRAY)
                         field = bt_ctf_field_array_get_field(array_field, i);
                 else
                         field = bt_ctf_field_create(type);
@@ -348,7 +348,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                         return -1;
                 }
 
-                if (flags & FIELD_IS_STRING)
+                if (flags & TEP_FIELD_IS_STRING)
                         ret = string_set_value(field, data + offset + i * len);
                 else {
                         unsigned long long value_int;
@@ -357,7 +357,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                                         fmtf->event->pevent,
                                         data + offset + i * len, len);
 
-                        if (!(flags & FIELD_IS_SIGNED))
+                        if (!(flags & TEP_FIELD_IS_SIGNED))
                                 ret = bt_ctf_field_unsigned_integer_set_value(
                                                 field, value_int);
                         else
@@ -369,7 +369,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                         pr_err("failed to set file value %s\n", name);
                         goto err_put_field;
                 }
-                if (!(flags & FIELD_IS_ARRAY)) {
+                if (!(flags & TEP_FIELD_IS_ARRAY)) {
                         ret = bt_ctf_event_set_payload(event, name, field);
                         if (ret) {
                                 pr_err("failed to set payload %s\n", name);
@@ -378,7 +378,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                 }
                 bt_ctf_field_put(field);
         }
-        if (flags & FIELD_IS_ARRAY) {
+        if (flags & TEP_FIELD_IS_ARRAY) {
                 ret = bt_ctf_event_set_payload(event, name, array_field);
                 if (ret) {
                         pr_err("Failed add payload array %s\n", name);
@@ -396,10 +396,10 @@ err_put_field:
 static int add_tracepoint_fields_values(struct ctf_writer *cw,
                                         struct bt_ctf_event_class *event_class,
                                         struct bt_ctf_event *event,
-                                        struct format_field *fields,
+                                        struct tep_format_field *fields,
                                         struct perf_sample *sample)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         int ret;
 
         for (field = fields; field; field = field->next) {
@@ -417,8 +417,8 @@ static int add_tracepoint_values(struct ctf_writer *cw,
                                  struct perf_evsel *evsel,
                                  struct perf_sample *sample)
 {
-        struct format_field *common_fields = evsel->tp_format->format.common_fields;
-        struct format_field *fields        = evsel->tp_format->format.fields;
+        struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
+        struct tep_format_field *fields        = evsel->tp_format->format.fields;
         int ret;
 
         ret = add_tracepoint_fields_values(cw, event_class, event,
@@ -970,7 +970,7 @@ out:
 
 static int event_class_add_field(struct bt_ctf_event_class *event_class,
                 struct bt_ctf_field_type *type,
-                struct format_field *field)
+                struct tep_format_field *field)
 {
         struct bt_ctf_field_type *t = NULL;
         char *name;
@@ -1009,10 +1009,10 @@ static int event_class_add_field(struct bt_ctf_event_class *event_class,
 }
 
 static int add_tracepoint_fields_types(struct ctf_writer *cw,
-                                       struct format_field *fields,
+                                       struct tep_format_field *fields,
                                        struct bt_ctf_event_class *event_class)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         int ret;
 
         for (field = fields; field; field = field->next) {
@@ -1030,15 +1030,15 @@ static int add_tracepoint_fields_types(struct ctf_writer *cw,
                  * type and don't care that it is an array. What we don't
                  * support is an array of strings.
                  */
-                if (flags & FIELD_IS_STRING)
-                        flags &= ~FIELD_IS_ARRAY;
+                if (flags & TEP_FIELD_IS_STRING)
+                        flags &= ~TEP_FIELD_IS_ARRAY;
 
-                if (flags & FIELD_IS_ARRAY)
+                if (flags & TEP_FIELD_IS_ARRAY)
                         type = bt_ctf_field_type_array_create(type, field->arraylen);
 
                 ret = event_class_add_field(event_class, type, field);
 
-                if (flags & FIELD_IS_ARRAY)
+                if (flags & TEP_FIELD_IS_ARRAY)
                         bt_ctf_field_type_put(type);
 
                 if (ret) {
@@ -1055,8 +1055,8 @@ static int add_tracepoint_types(struct ctf_writer *cw,
                                 struct perf_evsel *evsel,
                                 struct bt_ctf_event_class *class)
 {
-        struct format_field *common_fields = evsel->tp_format->format.common_fields;
-        struct format_field *fields        = evsel->tp_format->format.fields;
+        struct tep_format_field *common_fields = evsel->tp_format->format.common_fields;
+        struct tep_format_field *fields        = evsel->tp_format->format.fields;
         int ret;
 
         ret = add_tracepoint_fields_types(cw, common_fields, class);
@@ -1578,7 +1578,7 @@ int bt_convert__perf2ctf(const char *input, const char *path,
 {
         struct perf_session *session;
         struct perf_data data = {
-                .file.path = input,
+                .file      = { .path = input, .fd = -1 },
                 .mode      = PERF_DATA_MODE_READ,
                 .force     = opts->force,
         };
diff --git a/tools/perf/util/db-export.c b/tools/perf/util/db-export.c
index 7123746edcf4..69fbb0a72d0c 100644
--- a/tools/perf/util/db-export.c
+++ b/tools/perf/util/db-export.c
@@ -463,6 +463,28 @@ int db_export__branch_types(struct db_export *dbe)
                 if (err)
                         break;
         }
+
+        /* Add trace begin / end variants */
+        for (i = 0; branch_types[i].name ; i++) {
+                const char *name = branch_types[i].name;
+                u32 type = branch_types[i].branch_type;
+                char buf[64];
+
+                if (type == PERF_IP_FLAG_BRANCH ||
+                    (type & (PERF_IP_FLAG_TRACE_BEGIN | PERF_IP_FLAG_TRACE_END)))
+                        continue;
+
+                snprintf(buf, sizeof(buf), "trace begin / %s", name);
+                err = db_export__branch_type(dbe, type | PERF_IP_FLAG_TRACE_BEGIN, buf);
+                if (err)
+                        break;
+
+                snprintf(buf, sizeof(buf), "%s / trace end", name);
+                err = db_export__branch_type(dbe, type | PERF_IP_FLAG_TRACE_END, buf);
+                if (err)
+                        break;
+        }
+
         return err;
 }
 
diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h
index 1f3ccc368530..d01b8355f4ca 100644
--- a/tools/perf/util/env.h
+++ b/tools/perf/util/env.h
@@ -63,6 +63,7 @@ struct perf_env {
         struct numa_node        *numa_nodes;
         struct memory_node      *memory_nodes;
         unsigned long long       memory_bsize;
+        u64                     clockid_res_ns;
 };
 
 extern struct perf_env perf_env;
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 0cd42150f712..e9c108a6b1c3 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -308,6 +308,7 @@ static int perf_event__synthesize_fork(struct perf_tool *tool,
         event->fork.pid  = tgid;
         event->fork.tid  = pid;
         event->fork.header.type = PERF_RECORD_FORK;
+        event->fork.header.misc = PERF_RECORD_MISC_FORK_EXEC;
 
         event->fork.header.size = (sizeof(event->fork) + machine->id_hdr_size);
 
@@ -1081,6 +1082,7 @@ void *cpu_map_data__alloc(struct cpu_map *map, size_t *size, u16 *type, int *max
         }
 
         *size += sizeof(struct cpu_map_data);
+        *size = PERF_ALIGN(*size, sizeof(u64));
         return zalloc(*size);
 }
 
@@ -1560,26 +1562,9 @@ struct map *thread__find_map(struct thread *thread, u8 cpumode, u64 addr,
 
                 return NULL;
         }
-try_again:
+
         al->map = map_groups__find(mg, al->addr);
-        if (al->map == NULL) {
-                /*
-                 * If this is outside of all known maps, and is a negative
-                 * address, try to look it up in the kernel dso, as it might be
-                 * a vsyscall or vdso (which executes in user-mode).
-                 *
-                 * XXX This is nasty, we should have a symbol list in the
-                 * "[vdso]" dso, but for now lets use the old trick of looking
-                 * in the whole kernel symbol list.
-                 */
-                if (cpumode == PERF_RECORD_MISC_USER && machine &&
-                    mg != &machine->kmaps &&
-                    machine__kernel_ip(machine, al->addr)) {
-                        mg = &machine->kmaps;
-                        load_map = true;
-                        goto try_again;
-                }
-        } else {
+        if (al->map != NULL) {
                 /*
                  * Kernel maps might be changed when loading symbols so loading
                  * must be done prior to using kernel maps.
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index be440df29615..e88e6f9b1463 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -358,7 +358,7 @@ void perf_evlist__disable(struct perf_evlist *evlist)
         struct perf_evsel *pos;
 
         evlist__for_each_entry(evlist, pos) {
-                if (!perf_evsel__is_group_leader(pos) || !pos->fd)
+                if (pos->disabled || !perf_evsel__is_group_leader(pos) || !pos->fd)
                         continue;
                 perf_evsel__disable(pos);
         }
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 1a61628a1c12..6d187059a373 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -232,6 +232,7 @@ void perf_evsel__init(struct perf_evsel *evsel,
         evsel->leader      = evsel;
         evsel->unit        = "";
         evsel->scale       = 1.0;
+        evsel->max_events  = ULONG_MAX;
         evsel->evlist      = NULL;
         evsel->bpf_fd      = -1;
         INIT_LIST_HEAD(&evsel->node);
@@ -793,6 +794,9 @@ static void apply_config_terms(struct perf_evsel *evsel,
                 case PERF_EVSEL__CONFIG_TERM_MAX_STACK:
                         max_stack = term->val.max_stack;
                         break;
+                case PERF_EVSEL__CONFIG_TERM_MAX_EVENTS:
+                        evsel->max_events = term->val.max_events;
+                        break;
                 case PERF_EVSEL__CONFIG_TERM_INHERIT:
                         /*
                          * attr->inherit should has already been set by
@@ -1089,6 +1093,9 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
                 attr->exclude_user   = 1;
         }
 
+        if (evsel->own_cpus)
+                evsel->attr.read_format |= PERF_FORMAT_ID;
+
         /*
          * Apply event specific term settings,
          * it overloads any global configuration.
@@ -1200,16 +1207,27 @@ int perf_evsel__append_addr_filter(struct perf_evsel *evsel, const char *filter)
 
 int perf_evsel__enable(struct perf_evsel *evsel)
 {
-        return perf_evsel__run_ioctl(evsel,
-                                     PERF_EVENT_IOC_ENABLE,
-                                     0);
+        int err = perf_evsel__run_ioctl(evsel, PERF_EVENT_IOC_ENABLE, 0);
+
+        if (!err)
+                evsel->disabled = false;
+
+        return err;
 }
 
 int perf_evsel__disable(struct perf_evsel *evsel)
 {
-        return perf_evsel__run_ioctl(evsel,
-                                     PERF_EVENT_IOC_DISABLE,
-                                     0);
+        int err = perf_evsel__run_ioctl(evsel, PERF_EVENT_IOC_DISABLE, 0);
+        /*
+         * We mark it disabled here so that tools that disable a event can
+         * ignore events after they disable it. I.e. the ring buffer may have
+         * already a few more events queued up before the kernel got the stop
+         * request.
+         */
+        if (!err)
+                evsel->disabled = true;
+
+        return err;
 }
 
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
@@ -2682,7 +2700,7 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
         return 0;
 }
 
-struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
+struct tep_format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
 {
         return tep_find_field(evsel->tp_format, name);
 }
@@ -2690,7 +2708,7 @@ struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *nam
 void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
                          const char *name)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
+        struct tep_format_field *field = perf_evsel__field(evsel, name);
         int offset;
 
         if (!field)
@@ -2698,7 +2716,7 @@ void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
 
         offset = field->offset;
 
-        if (field->flags & FIELD_IS_DYNAMIC) {
+        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                 offset = *(int *)(sample->raw_data + field->offset);
                 offset &= 0xffff;
         }
@@ -2706,7 +2724,7 @@ void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
         return sample->raw_data + offset;
 }
 
-u64 format_field__intval(struct format_field *field, struct perf_sample *sample,
+u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample,
                          bool needs_swap)
 {
         u64 value;
@@ -2748,7 +2766,7 @@ u64 format_field__intval(struct format_field *field, struct perf_sample *sample,
 u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                        const char *name)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
+        struct tep_format_field *field = perf_evsel__field(evsel, name);
 
         if (!field)
                 return 0;
@@ -2940,3 +2958,32 @@ struct perf_env *perf_evsel__env(struct perf_evsel *evsel)
                 return evsel->evlist->env;
         return NULL;
 }
+
+static int store_evsel_ids(struct perf_evsel *evsel, struct perf_evlist *evlist)
+{
+        int cpu, thread;
+
+        for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {
+                for (thread = 0; thread < xyarray__max_y(evsel->fd);
+                     thread++) {
+                        int fd = FD(evsel, cpu, thread);
+
+                        if (perf_evlist__id_add_fd(evlist, evsel,
+                                                   cpu, thread, fd) < 0)
+                                return -1;
+                }
+        }
+
+        return 0;
+}
+
+int perf_evsel__store_ids(struct perf_evsel *evsel, struct perf_evlist *evlist)
+{
+        struct cpu_map *cpus = evsel->cpus;
+        struct thread_map *threads = evsel->threads;
+
+        if (perf_evsel__alloc_id(evsel, cpus->nr, threads->nr))
+                return -ENOMEM;
+
+        return store_evsel_ids(evsel, evlist);
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 163c960614d3..3147ca76c6fc 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -46,6 +46,7 @@ enum term_type {
         PERF_EVSEL__CONFIG_TERM_STACK_USER,
         PERF_EVSEL__CONFIG_TERM_INHERIT,
         PERF_EVSEL__CONFIG_TERM_MAX_STACK,
+        PERF_EVSEL__CONFIG_TERM_MAX_EVENTS,
         PERF_EVSEL__CONFIG_TERM_OVERWRITE,
         PERF_EVSEL__CONFIG_TERM_DRV_CFG,
         PERF_EVSEL__CONFIG_TERM_BRANCH,
@@ -65,6 +66,7 @@ struct perf_evsel_config_term {
                 bool    inherit;
                 bool    overwrite;
                 char    *branch;
+                unsigned long max_events;
         } val;
         bool weak;
 };
@@ -99,10 +101,12 @@ struct perf_evsel {
         struct perf_counts      *prev_raw_counts;
         int                     idx;
         u32                     ids;
+        unsigned long           max_events;
+        unsigned long           nr_events_printed;
         char                    *name;
         double                  scale;
         const char              *unit;
-        struct event_format     *tp_format;
+        struct tep_event_format *tp_format;
         off_t                   id_offset;
         struct perf_stat_evsel  *stats;
         void                    *priv;
@@ -119,6 +123,7 @@ struct perf_evsel {
         bool                    snapshot;
         bool                    supported;
         bool                    needs_swap;
+        bool                    disabled;
         bool                    no_aux_samples;
         bool                    immediate;
         bool                    system_wide;
@@ -211,7 +216,7 @@ static inline struct perf_evsel *perf_evsel__newtp(const char *sys, const char *
 
 struct perf_evsel *perf_evsel__new_cycles(bool precise);
 
-struct event_format *event_format__new(const char *sys, const char *name);
+struct tep_event_format *event_format__new(const char *sys, const char *name);
 
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx);
@@ -296,11 +301,11 @@ static inline char *perf_evsel__strval(struct perf_evsel *evsel,
         return perf_evsel__rawptr(evsel, sample, name);
 }
 
-struct format_field;
+struct tep_format_field;
 
-u64 format_field__intval(struct format_field *field, struct perf_sample *sample, bool needs_swap);
+u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample, bool needs_swap);
 
-struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
+struct tep_format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
 
 #define perf_evsel__match(evsel, t, c)          \
         (evsel->attr.type == PERF_TYPE_##t &&   \
@@ -481,4 +486,5 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
 
 struct perf_env *perf_evsel__env(struct perf_evsel *evsel);
 
+int perf_evsel__store_ids(struct perf_evsel *evsel, struct perf_evlist *evlist);
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/evsel_fprintf.c b/tools/perf/util/evsel_fprintf.c
index 06dfb027879d..0d0a4c6f368b 100644
--- a/tools/perf/util/evsel_fprintf.c
+++ b/tools/perf/util/evsel_fprintf.c
@@ -73,7 +73,7 @@ int perf_evsel__fprintf(struct perf_evsel *evsel,
         }
 
         if (details->trace_fields) {
-                struct format_field *field;
+                struct tep_format_field *field;
 
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
                         printed += comma_fprintf(fp, &first, " (not a tracepoint)");
diff --git a/tools/perf/util/genelf.h b/tools/perf/util/genelf.h
index de322d51c7fe..b72440bf9a79 100644
--- a/tools/perf/util/genelf.h
+++ b/tools/perf/util/genelf.h
@@ -29,6 +29,12 @@ int jit_add_debug_info(Elf *e, uint64_t code_addr, void *debug, int nr_debug_ent
 #elif defined(__powerpc__)
 #define GEN_ELF_ARCH    EM_PPC
 #define GEN_ELF_CLASS   ELFCLASS32
+#elif defined(__sparc__) && defined(__arch64__)
+#define GEN_ELF_ARCH    EM_SPARCV9
+#define GEN_ELF_CLASS   ELFCLASS64
+#elif defined(__sparc__)
+#define GEN_ELF_ARCH    EM_SPARC
+#define GEN_ELF_CLASS   ELFCLASS32
 #else
 #error "unsupported architecture"
 #endif
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 3cadc252dd89..4fd45be95a43 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1034,6 +1034,13 @@ static int write_auxtrace(struct feat_fd *ff,
         return err;
 }
 
+static int write_clockid(struct feat_fd *ff,
+                         struct perf_evlist *evlist __maybe_unused)
+{
+        return do_write(ff, &ff->ph->env.clockid_res_ns,
+                        sizeof(ff->ph->env.clockid_res_ns));
+}
+
 static int cpu_cache_level__sort(const void *a, const void *b)
 {
         struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a;
@@ -1508,6 +1515,12 @@ static void print_cpu_topology(struct feat_fd *ff, FILE *fp)
                 fprintf(fp, "# Core ID and Socket ID information is not available\n");
 }
 
+static void print_clockid(struct feat_fd *ff, FILE *fp)
+{
+        fprintf(fp, "# clockid frequency: %"PRIu64" MHz\n",
+                ff->ph->env.clockid_res_ns * 1000);
+}
+
 static void free_event_desc(struct perf_evsel *events)
 {
         struct perf_evsel *evsel;
@@ -2531,6 +2544,15 @@ out:
         return ret;
 }
 
+static int process_clockid(struct feat_fd *ff,
+                           void *data __maybe_unused)
+{
+        if (do_read_u64(ff, &ff->ph->env.clockid_res_ns))
+                return -1;
+
+        return 0;
+}
+
 struct feature_ops {
         int (*write)(struct feat_fd *ff, struct perf_evlist *evlist);
         void (*print)(struct feat_fd *ff, FILE *fp);
@@ -2590,6 +2612,7 @@ static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
         FEAT_OPN(CACHE,         cache,          true),
         FEAT_OPR(SAMPLE_TIME,   sample_time,    false),
         FEAT_OPR(MEM_TOPOLOGY,  mem_topology,   true),
+        FEAT_OPR(CLOCKID,       clockid,        false)
 };
 
 struct header_print_data {
@@ -3206,7 +3229,7 @@ static int read_attr(int fd, struct perf_header *ph,
 static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
                                                 struct tep_handle *pevent)
 {
-        struct event_format *event;
+        struct tep_event_format *event;
         char bf[128];
 
         /* already prepared */
@@ -3448,10 +3471,10 @@ int perf_event__synthesize_features(struct perf_tool *tool,
         return ret;
 }
 
-int perf_event__process_feature(struct perf_tool *tool,
-                                union perf_event *event,
-                                struct perf_session *session __maybe_unused)
+int perf_event__process_feature(struct perf_session *session,
+                                union perf_event *event)
 {
+        struct perf_tool *tool = session->tool;
         struct feat_fd ff = { .fd = 0 };
         struct feature_event *fe = (struct feature_event *)event;
         int type = fe->header.type;
@@ -3637,13 +3660,13 @@ size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
 }
 
 int perf_event__synthesize_attrs(struct perf_tool *tool,
-                                   struct perf_session *session,
-                                   perf_event__handler_t process)
+                                 struct perf_evlist *evlist,
+                                 perf_event__handler_t process)
 {
         struct perf_evsel *evsel;
         int err = 0;
 
-        evlist__for_each_entry(session->evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
                                                   evsel->id, process);
                 if (err) {
@@ -3856,9 +3879,8 @@ int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
         return aligned_size;
 }
 
-int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
-                                     union perf_event *event,
-                                     struct perf_session *session)
+int perf_event__process_tracing_data(struct perf_session *session,
+                                     union perf_event *event)
 {
         ssize_t size_read, padding, size = event->tracing_data.size;
         int fd = perf_data__fd(session->data);
@@ -3924,9 +3946,8 @@ int perf_event__synthesize_build_id(struct perf_tool *tool,
         return err;
 }
 
-int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+int perf_event__process_build_id(struct perf_session *session,
+                                 union perf_event *event)
 {
         __event_process_build_id(&event->build_id,
                                  event->build_id.filename,
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 6d7fe44aadc0..0d553ddca0a3 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -38,6 +38,7 @@ enum {
         HEADER_CACHE,
         HEADER_SAMPLE_TIME,
         HEADER_MEM_TOPOLOGY,
+        HEADER_CLOCKID,
         HEADER_LAST_FEATURE,
         HEADER_FEAT_BITS        = 256,
 };
@@ -116,15 +117,14 @@ int perf_event__synthesize_extra_attr(struct perf_tool *tool,
                                       perf_event__handler_t process,
                                       bool is_pipe);
 
-int perf_event__process_feature(struct perf_tool *tool,
-                                union perf_event *event,
-                                struct perf_session *session);
+int perf_event__process_feature(struct perf_session *session,
+                                union perf_event *event);
 
 int perf_event__synthesize_attr(struct perf_tool *tool,
                                 struct perf_event_attr *attr, u32 ids, u64 *id,
                                 perf_event__handler_t process);
 int perf_event__synthesize_attrs(struct perf_tool *tool,
-                                 struct perf_session *session,
+                                 struct perf_evlist *evlist,
                                  perf_event__handler_t process);
 int perf_event__synthesize_event_update_unit(struct perf_tool *tool,
                                              struct perf_evsel *evsel,
@@ -148,17 +148,15 @@ size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp);
 int perf_event__synthesize_tracing_data(struct perf_tool *tool,
                                         int fd, struct perf_evlist *evlist,
                                         perf_event__handler_t process);
-int perf_event__process_tracing_data(struct perf_tool *tool,
-                                     union perf_event *event,
-                                     struct perf_session *session);
+int perf_event__process_tracing_data(struct perf_session *session,
+                                     union perf_event *event);
 
 int perf_event__synthesize_build_id(struct perf_tool *tool,
                                     struct dso *pos, u16 misc,
                                     perf_event__handler_t process,
                                     struct machine *machine);
-int perf_event__process_build_id(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session);
+int perf_event__process_build_id(struct perf_session *session,
+                                 union perf_event *event);
 bool is_perf_magic(u64 magic);
 
 #define NAME_ALIGN 64
diff --git a/tools/perf/util/intel-bts.c b/tools/perf/util/intel-bts.c
index 7f0c83b6332b..7b27d77306c2 100644
--- a/tools/perf/util/intel-bts.c
+++ b/tools/perf/util/intel-bts.c
@@ -269,6 +269,13 @@ static int intel_bts_do_fix_overlap(struct auxtrace_queue *queue,
         return 0;
 }
 
+static inline u8 intel_bts_cpumode(struct intel_bts *bts, uint64_t ip)
+{
+        return machine__kernel_ip(bts->machine, ip) ?
+               PERF_RECORD_MISC_KERNEL :
+               PERF_RECORD_MISC_USER;
+}
+
 static int intel_bts_synth_branch_sample(struct intel_bts_queue *btsq,
                                          struct branch *branch)
 {
@@ -281,12 +288,8 @@ static int intel_bts_synth_branch_sample(struct intel_bts_queue *btsq,
             bts->num_events++ <= bts->synth_opts.initial_skip)
                 return 0;
 
-        event.sample.header.type = PERF_RECORD_SAMPLE;
-        event.sample.header.misc = PERF_RECORD_MISC_USER;
-        event.sample.header.size = sizeof(struct perf_event_header);
-
-        sample.cpumode = PERF_RECORD_MISC_USER;
         sample.ip = le64_to_cpu(branch->from);
+        sample.cpumode = intel_bts_cpumode(bts, sample.ip);
         sample.pid = btsq->pid;
         sample.tid = btsq->tid;
         sample.addr = le64_to_cpu(branch->to);
@@ -298,6 +301,10 @@ static int intel_bts_synth_branch_sample(struct intel_bts_queue *btsq,
         sample.insn_len = btsq->intel_pt_insn.length;
         memcpy(sample.insn, btsq->intel_pt_insn.buf, INTEL_PT_INSN_BUF_SZ);
 
+        event.sample.header.type = PERF_RECORD_SAMPLE;
+        event.sample.header.misc = sample.cpumode;
+        event.sample.header.size = sizeof(struct perf_event_header);
+
         if (bts->synth_opts.inject) {
                 event.sample.header.size = bts->branches_event_size;
                 ret = perf_event__synthesize_sample(&event,
@@ -910,7 +917,8 @@ int intel_bts_process_auxtrace_info(union perf_event *event,
         if (session->itrace_synth_opts && session->itrace_synth_opts->set) {
                 bts->synth_opts = *session->itrace_synth_opts;
         } else {
-                itrace_synth_opts__set_default(&bts->synth_opts);
+                itrace_synth_opts__set_default(&bts->synth_opts,
+                                session->itrace_synth_opts->default_no_sample);
                 if (session->itrace_synth_opts)
                         bts->synth_opts.thread_stack =
                                 session->itrace_synth_opts->thread_stack;
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
index d404bed7003a..58f6a9ceb590 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
@@ -1165,7 +1165,7 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
                 decoder->pge = false;
                 decoder->continuous_period = false;
                 decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
-                decoder->state.to_ip = 0;
+                decoder->state.type |= INTEL_PT_TRACE_END;
                 return 0;
         }
         if (err == INTEL_PT_RETURN)
@@ -1179,9 +1179,13 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
                         decoder->continuous_period = false;
                         decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
                         decoder->state.from_ip = decoder->ip;
-                        decoder->state.to_ip = 0;
-                        if (decoder->packet.count != 0)
+                        if (decoder->packet.count == 0) {
+                                decoder->state.to_ip = 0;
+                        } else {
+                                decoder->state.to_ip = decoder->last_ip;
                                 decoder->ip = decoder->last_ip;
+                        }
+                        decoder->state.type |= INTEL_PT_TRACE_END;
                 } else {
                         decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
                         decoder->state.from_ip = decoder->ip;
@@ -1208,7 +1212,8 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
                         decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
                         decoder->ip = to_ip;
                         decoder->state.from_ip = decoder->ip;
-                        decoder->state.to_ip = 0;
+                        decoder->state.to_ip = to_ip;
+                        decoder->state.type |= INTEL_PT_TRACE_END;
                         return 0;
                 }
                 intel_pt_log_at("ERROR: Conditional branch when expecting indirect branch",
@@ -1640,14 +1645,15 @@ static int intel_pt_walk_fup_tip(struct intel_pt_decoder *decoder)
 
                 case INTEL_PT_TIP_PGD:
                         decoder->state.from_ip = decoder->ip;
-                        decoder->state.to_ip = 0;
-                        if (decoder->packet.count != 0) {
+                        if (decoder->packet.count == 0) {
+                                decoder->state.to_ip = 0;
+                        } else {
                                 intel_pt_set_ip(decoder);
-                                intel_pt_log("Omitting PGD ip " x64_fmt "\n",
-                                             decoder->ip);
+                                decoder->state.to_ip = decoder->ip;
                         }
                         decoder->pge = false;
                         decoder->continuous_period = false;
+                        decoder->state.type |= INTEL_PT_TRACE_END;
                         return 0;
 
                 case INTEL_PT_TIP_PGE:
@@ -1661,6 +1667,7 @@ static int intel_pt_walk_fup_tip(struct intel_pt_decoder *decoder)
                                 intel_pt_set_ip(decoder);
                                 decoder->state.to_ip = decoder->ip;
                         }
+                        decoder->state.type |= INTEL_PT_TRACE_BEGIN;
                         return 0;
 
                 case INTEL_PT_TIP:
@@ -1739,6 +1746,7 @@ next:
                         intel_pt_set_ip(decoder);
                         decoder->state.from_ip = 0;
                         decoder->state.to_ip = decoder->ip;
+                        decoder->state.type |= INTEL_PT_TRACE_BEGIN;
                         return 0;
                 }
 
@@ -2077,9 +2085,13 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                         decoder->pge = decoder->packet.type != INTEL_PT_TIP_PGD;
                         if (intel_pt_have_ip(decoder))
                                 intel_pt_set_ip(decoder);
-                        if (decoder->ip)
-                                return 0;
-                        break;
+                        if (!decoder->ip)
+                                break;
+                        if (decoder->packet.type == INTEL_PT_TIP_PGE)
+                                decoder->state.type |= INTEL_PT_TRACE_BEGIN;
+                        if (decoder->packet.type == INTEL_PT_TIP_PGD)
+                                decoder->state.type |= INTEL_PT_TRACE_END;
+                        return 0;
 
                 case INTEL_PT_FUP:
                         if (intel_pt_have_ip(decoder))
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
index 51c18d67f4ca..ed088d4726ba 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
@@ -37,6 +37,8 @@ enum intel_pt_sample_type {
         INTEL_PT_EX_STOP        = 1 << 6,
         INTEL_PT_PWR_EXIT       = 1 << 7,
         INTEL_PT_CBR_CHG        = 1 << 8,
+        INTEL_PT_TRACE_BEGIN    = 1 << 9,
+        INTEL_PT_TRACE_END      = 1 << 10,
 };
 
 enum intel_pt_period_type {
diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
index aec68908d604..86cc9a64e982 100644
--- a/tools/perf/util/intel-pt.c
+++ b/tools/perf/util/intel-pt.c
@@ -407,6 +407,13 @@ intel_pt_cache_lookup(struct dso *dso, struct machine *machine, u64 offset)
         return auxtrace_cache__lookup(dso->auxtrace_cache, offset);
 }
 
+static inline u8 intel_pt_cpumode(struct intel_pt *pt, uint64_t ip)
+{
+        return ip >= pt->kernel_start ?
+               PERF_RECORD_MISC_KERNEL :
+               PERF_RECORD_MISC_USER;
+}
+
 static int intel_pt_walk_next_insn(struct intel_pt_insn *intel_pt_insn,
                                    uint64_t *insn_cnt_ptr, uint64_t *ip,
                                    uint64_t to_ip, uint64_t max_insn_cnt,
@@ -429,10 +436,7 @@ static int intel_pt_walk_next_insn(struct intel_pt_insn *intel_pt_insn,
         if (to_ip && *ip == to_ip)
                 goto out_no_cache;
 
-        if (*ip >= ptq->pt->kernel_start)
-                cpumode = PERF_RECORD_MISC_KERNEL;
-        else
-                cpumode = PERF_RECORD_MISC_USER;
+        cpumode = intel_pt_cpumode(ptq->pt, *ip);
 
         thread = ptq->thread;
         if (!thread) {
@@ -759,7 +763,8 @@ static struct intel_pt_queue *intel_pt_alloc_queue(struct intel_pt *pt,
         if (pt->synth_opts.callchain) {
                 size_t sz = sizeof(struct ip_callchain);
 
-                sz += pt->synth_opts.callchain_sz * sizeof(u64);
+                /* Add 1 to callchain_sz for callchain context */
+                sz += (pt->synth_opts.callchain_sz + 1) * sizeof(u64);
                 ptq->chain = zalloc(sz);
                 if (!ptq->chain)
                         goto out_free;
@@ -908,6 +913,11 @@ static void intel_pt_sample_flags(struct intel_pt_queue *ptq)
                 ptq->insn_len = ptq->state->insn_len;
                 memcpy(ptq->insn, ptq->state->insn, INTEL_PT_INSN_BUF_SZ);
         }
+
+        if (ptq->state->type & INTEL_PT_TRACE_BEGIN)
+                ptq->flags |= PERF_IP_FLAG_TRACE_BEGIN;
+        if (ptq->state->type & INTEL_PT_TRACE_END)
+                ptq->flags |= PERF_IP_FLAG_TRACE_END;
 }
 
 static int intel_pt_setup_queue(struct intel_pt *pt,
@@ -1053,15 +1063,11 @@ static void intel_pt_prep_b_sample(struct intel_pt *pt,
                                    union perf_event *event,
                                    struct perf_sample *sample)
 {
-        event->sample.header.type = PERF_RECORD_SAMPLE;
-        event->sample.header.misc = PERF_RECORD_MISC_USER;
-        event->sample.header.size = sizeof(struct perf_event_header);
-
         if (!pt->timeless_decoding)
                 sample->time = tsc_to_perf_time(ptq->timestamp, &pt->tc);
 
-        sample->cpumode = PERF_RECORD_MISC_USER;
         sample->ip = ptq->state->from_ip;
+        sample->cpumode = intel_pt_cpumode(pt, sample->ip);
         sample->pid = ptq->pid;
         sample->tid = ptq->tid;
         sample->addr = ptq->state->to_ip;
@@ -1070,6 +1076,10 @@ static void intel_pt_prep_b_sample(struct intel_pt *pt,
         sample->flags = ptq->flags;
         sample->insn_len = ptq->insn_len;
         memcpy(sample->insn, ptq->insn, INTEL_PT_INSN_BUF_SZ);
+
+        event->sample.header.type = PERF_RECORD_SAMPLE;
+        event->sample.header.misc = sample->cpumode;
+        event->sample.header.size = sizeof(struct perf_event_header);
 }
 
 static int intel_pt_inject_event(union perf_event *event,
@@ -1155,7 +1165,8 @@ static void intel_pt_prep_sample(struct intel_pt *pt,
 
         if (pt->synth_opts.callchain) {
                 thread_stack__sample(ptq->thread, ptq->chain,
-                                     pt->synth_opts.callchain_sz, sample->ip);
+                                     pt->synth_opts.callchain_sz + 1,
+                                     sample->ip, pt->kernel_start);
                 sample->callchain = ptq->chain;
         }
 
@@ -2554,7 +2565,8 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
         if (session->itrace_synth_opts && session->itrace_synth_opts->set) {
                 pt->synth_opts = *session->itrace_synth_opts;
         } else {
-                itrace_synth_opts__set_default(&pt->synth_opts);
+                itrace_synth_opts__set_default(&pt->synth_opts,
+                                session->itrace_synth_opts->default_no_sample);
                 if (use_browser != -1) {
                         pt->synth_opts.branches = false;
                         pt->synth_opts.callchain = true;
diff --git a/tools/perf/util/llvm-utils.c b/tools/perf/util/llvm-utils.c
index 19262f98cd4e..5b0b60f00275 100644
--- a/tools/perf/util/llvm-utils.c
+++ b/tools/perf/util/llvm-utils.c
@@ -19,7 +19,7 @@
 #define CLANG_BPF_CMD_DEFAULT_TEMPLATE                          \
                 "$CLANG_EXEC -D__KERNEL__ -D__NR_CPUS__=$NR_CPUS "\
                 "-DLINUX_VERSION_CODE=$LINUX_VERSION_CODE "     \
-                "$CLANG_OPTIONS $KERNEL_INC_OPTIONS $PERF_BPF_INC_OPTIONS " \
+                "$CLANG_OPTIONS $PERF_BPF_INC_OPTIONS $KERNEL_INC_OPTIONS " \
                 "-Wno-unused-value -Wno-pointer-sign "          \
                 "-working-directory $WORKING_DIR "              \
                 "-c \"$CLANG_SOURCE\" -target bpf $CLANG_EMIT_LLVM -O2 -o - $LLVM_OPTIONS_PIPE"
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index c4acd2001db0..8f36ce813bc5 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -1708,6 +1708,7 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event
         struct thread *parent = machine__findnew_thread(machine,
                                                         event->fork.ppid,
                                                         event->fork.ptid);
+        bool do_maps_clone = true;
         int err = 0;
 
         if (dump_trace)
@@ -1736,9 +1737,25 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event
 
         thread = machine__findnew_thread(machine, event->fork.pid,
                                          event->fork.tid);
+        /*
+         * When synthesizing FORK events, we are trying to create thread
+         * objects for the already running tasks on the machine.
+         *
+         * Normally, for a kernel FORK event, we want to clone the parent's
+         * maps because that is what the kernel just did.
+         *
+         * But when synthesizing, this should not be done.  If we do, we end up
+         * with overlapping maps as we process the sythesized MMAP2 events that
+         * get delivered shortly thereafter.
+         *
+         * Use the FORK event misc flags in an internal way to signal this
+         * situation, so we can elide the map clone when appropriate.
+         */
+        if (event->fork.header.misc & PERF_RECORD_MISC_FORK_EXEC)
+                do_maps_clone = false;
 
         if (thread == NULL || parent == NULL ||
-            thread__fork(thread, parent, sample->time) < 0) {
+            thread__fork(thread, parent, sample->time, do_maps_clone) < 0) {
                 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
                 err = -1;
         }
@@ -2140,6 +2157,27 @@ static int resolve_lbr_callchain_sample(struct thread *thread,
         return 0;
 }
 
+static int find_prev_cpumode(struct ip_callchain *chain, struct thread *thread,
+                             struct callchain_cursor *cursor,
+                             struct symbol **parent,
+                             struct addr_location *root_al,
+                             u8 *cpumode, int ent)
+{
+        int err = 0;
+
+        while (--ent >= 0) {
+                u64 ip = chain->ips[ent];
+
+                if (ip >= PERF_CONTEXT_MAX) {
+                        err = add_callchain_ip(thread, cursor, parent,
+                                               root_al, cpumode, ip,
+                                               false, NULL, NULL, 0);
+                        break;
+                }
+        }
+        return err;
+}
+
 static int thread__resolve_callchain_sample(struct thread *thread,
                                             struct callchain_cursor *cursor,
                                             struct perf_evsel *evsel,
@@ -2246,6 +2284,12 @@ static int thread__resolve_callchain_sample(struct thread *thread,
         }
 
 check_calls:
+        if (callchain_param.order != ORDER_CALLEE) {
+                err = find_prev_cpumode(chain, thread, cursor, parent, root_al,
+                                        &cpumode, chain->nr - first_call);
+                if (err)
+                        return (err < 0) ? err : 0;
+        }
         for (i = first_call, nr_entries = 0;
              i < chain_nr && nr_entries < max_stack; i++) {
                 u64 ip;
@@ -2260,9 +2304,15 @@ check_calls:
                         continue;
 #endif
                 ip = chain->ips[j];
-
                 if (ip < PERF_CONTEXT_MAX)
                        ++nr_entries;
+                else if (callchain_param.order != ORDER_CALLEE) {
+                        err = find_prev_cpumode(chain, thread, cursor, parent,
+                                                root_al, &cpumode, j);
+                        if (err)
+                                return (err < 0) ? err : 0;
+                        continue;
+                }
 
                 err = add_callchain_ip(thread, cursor, parent,
                                        root_al, &cpumode, ip,
@@ -2286,7 +2336,8 @@ static int append_inlines(struct callchain_cursor *cursor,
         if (!symbol_conf.inline_name || !map || !sym)
                 return ret;
 
-        addr = map__rip_2objdump(map, ip);
+        addr = map__map_ip(map, ip);
+        addr = map__rip_2objdump(map, addr);
 
         inline_node = inlines__tree_find(&map->dso->inlined_nodes, addr);
         if (!inline_node) {
@@ -2312,7 +2363,7 @@ static int unwind_entry(struct unwind_entry *entry, void *arg)
 {
         struct callchain_cursor *cursor = arg;
         const char *srcline = NULL;
-        u64 addr;
+        u64 addr = entry->ip;
 
         if (symbol_conf.hide_unresolved && entry->sym == NULL)
                 return 0;
@@ -2324,7 +2375,8 @@ static int unwind_entry(struct unwind_entry *entry, void *arg)
          * Convert entry->ip from a virtual address to an offset in
          * its corresponding binary.
          */
-        addr = map__map_ip(entry->map, entry->ip);
+        if (entry->map)
+                addr = map__map_ip(entry->map, entry->ip);
 
         srcline = callchain_srcline(entry->map, entry->sym, addr);
         return callchain_cursor_append(cursor, entry->ip,
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 6a6929f208b4..354e54550d2b 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -320,12 +320,11 @@ int map__load(struct map *map)
                         build_id__sprintf(map->dso->build_id,
                                           sizeof(map->dso->build_id),
                                           sbuild_id);
-                        pr_warning("%s with build id %s not found",
-                                   name, sbuild_id);
+                        pr_debug("%s with build id %s not found", name, sbuild_id);
                 } else
-                        pr_warning("Failed to open %s", name);
+                        pr_debug("Failed to open %s", name);
 
-                pr_warning(", continuing without symbols\n");
+                pr_debug(", continuing without symbols\n");
                 return -1;
         } else if (nr == 0) {
 #ifdef HAVE_LIBELF_SUPPORT
@@ -334,12 +333,11 @@ int map__load(struct map *map)
 
                 if (len > sizeof(DSO__DELETED) &&
                     strcmp(name + real_len + 1, DSO__DELETED) == 0) {
-                        pr_warning("%.*s was updated (is prelink enabled?). "
+                        pr_debug("%.*s was updated (is prelink enabled?). "
                                 "Restart the long running apps that use it!\n",
                                    (int)real_len, name);
                 } else {
-                        pr_warning("no symbols found in %s, maybe install "
-                                   "a debug package?\n", name);
+                        pr_debug("no symbols found in %s, maybe install a debug package?\n", name);
                 }
 #endif
                 return -1;
@@ -712,8 +710,7 @@ static int maps__fixup_overlappings(struct maps *maps, struct map *map, FILE *fp
                 if (verbose >= 2) {
 
                         if (use_browser) {
-                                pr_warning("overlapping maps in %s "
-                                           "(disable tui for more info)\n",
+                                pr_debug("overlapping maps in %s (disable tui for more info)\n",
                                            map->dso->name);
                         } else {
                                 fputs("overlapping maps:\n", fp);
diff --git a/tools/perf/util/mmap.c b/tools/perf/util/mmap.c
index 215f69f41672..cdb95b3a1213 100644
--- a/tools/perf/util/mmap.c
+++ b/tools/perf/util/mmap.c
@@ -281,7 +281,7 @@ int perf_mmap__read_init(struct perf_mmap *map)
 }
 
 int perf_mmap__push(struct perf_mmap *md, void *to,
-                    int push(void *to, void *buf, size_t size))
+                    int push(struct perf_mmap *map, void *to, void *buf, size_t size))
 {
         u64 head = perf_mmap__read_head(md);
         unsigned char *data = md->base + page_size;
@@ -300,7 +300,7 @@ int perf_mmap__push(struct perf_mmap *md, void *to,
                 size = md->mask + 1 - (md->start & md->mask);
                 md->start += size;
 
-                if (push(to, buf, size) < 0) {
+                if (push(md, to, buf, size) < 0) {
                         rc = -1;
                         goto out;
                 }
@@ -310,7 +310,7 @@ int perf_mmap__push(struct perf_mmap *md, void *to,
         size = md->end - md->start;
         md->start += size;
 
-        if (push(to, buf, size) < 0) {
+        if (push(md, to, buf, size) < 0) {
                 rc = -1;
                 goto out;
         }
diff --git a/tools/perf/util/mmap.h b/tools/perf/util/mmap.h
index 05a6d47c7956..cc5e2d6d17a9 100644
--- a/tools/perf/util/mmap.h
+++ b/tools/perf/util/mmap.h
@@ -4,7 +4,7 @@
 #include <linux/compiler.h>
 #include <linux/refcount.h>
 #include <linux/types.h>
-#include <asm/barrier.h>
+#include <linux/ring_buffer.h>
 #include <stdbool.h>
 #include "auxtrace.h"
 #include "event.h"
@@ -71,21 +71,12 @@ void perf_mmap__consume(struct perf_mmap *map);
 
 static inline u64 perf_mmap__read_head(struct perf_mmap *mm)
 {
-        struct perf_event_mmap_page *pc = mm->base;
-        u64 head = READ_ONCE(pc->data_head);
-        rmb();
-        return head;
+        return ring_buffer_read_head(mm->base);
 }
 
 static inline void perf_mmap__write_tail(struct perf_mmap *md, u64 tail)
 {
-        struct perf_event_mmap_page *pc = md->base;
-
-        /*
-         * ensure all reads are done before we write the tail out.
-         */
-        mb();
-        pc->data_tail = tail;
+        ring_buffer_write_tail(md->base, tail);
 }
 
 union perf_event *perf_mmap__read_forward(struct perf_mmap *map);
@@ -93,7 +84,7 @@ union perf_event *perf_mmap__read_forward(struct perf_mmap *map);
 union perf_event *perf_mmap__read_event(struct perf_mmap *map);
 
 int perf_mmap__push(struct perf_mmap *md, void *to,
-                    int push(void *to, void *buf, size_t size));
+                    int push(struct perf_mmap *map, void *to, void *buf, size_t size));
 
 size_t perf_mmap__mmap_len(struct perf_mmap *map);
 
diff --git a/tools/perf/util/ordered-events.c b/tools/perf/util/ordered-events.c
index bad9e0296e9a..1904e7f6ec84 100644
--- a/tools/perf/util/ordered-events.c
+++ b/tools/perf/util/ordered-events.c
@@ -80,14 +80,20 @@ static union perf_event *dup_event(struct ordered_events *oe,
         return oe->copy_on_queue ? __dup_event(oe, event) : event;
 }
 
-static void free_dup_event(struct ordered_events *oe, union perf_event *event)
+static void __free_dup_event(struct ordered_events *oe, union perf_event *event)
 {
-        if (event && oe->copy_on_queue) {
+        if (event) {
                 oe->cur_alloc_size -= event->header.size;
                 free(event);
         }
 }
 
+static void free_dup_event(struct ordered_events *oe, union perf_event *event)
+{
+        if (oe->copy_on_queue)
+                __free_dup_event(oe, event);
+}
+
 #define MAX_SAMPLE_BUFFER       (64 * 1024 / sizeof(struct ordered_event))
 static struct ordered_event *alloc_event(struct ordered_events *oe,
                                          union perf_event *event)
@@ -95,21 +101,49 @@ static struct ordered_event *alloc_event(struct ordered_events *oe,
         struct list_head *cache = &oe->cache;
         struct ordered_event *new = NULL;
         union perf_event *new_event;
+        size_t size;
 
         new_event = dup_event(oe, event);
         if (!new_event)
                 return NULL;
 
+        /*
+         * We maintain the following scheme of buffers for ordered
+         * event allocation:
+         *
+         *   to_free list -> buffer1 (64K)
+         *                   buffer2 (64K)
+         *                   ...
+         *
+         * Each buffer keeps an array of ordered events objects:
+         *    buffer -> event[0]
+         *              event[1]
+         *              ...
+         *
+         * Each allocated ordered event is linked to one of
+         * following lists:
+         *   - time ordered list 'events'
+         *   - list of currently removed events 'cache'
+         *
+         * Allocation of the ordered event uses the following order
+         * to get the memory:
+         *   - use recently removed object from 'cache' list
+         *   - use available object in current allocation buffer
+         *   - allocate new buffer if the current buffer is full
+         *
+         * Removal of ordered event object moves it from events to
+         * the cache list.
+         */
+        size = sizeof(*oe->buffer) + MAX_SAMPLE_BUFFER * sizeof(*new);
+
         if (!list_empty(cache)) {
                 new = list_entry(cache->next, struct ordered_event, list);
                 list_del(&new->list);
         } else if (oe->buffer) {
-                new = oe->buffer + oe->buffer_idx;
+                new = &oe->buffer->event[oe->buffer_idx];
                 if (++oe->buffer_idx == MAX_SAMPLE_BUFFER)
                         oe->buffer = NULL;
-        } else if (oe->cur_alloc_size < oe->max_alloc_size) {
-                size_t size = MAX_SAMPLE_BUFFER * sizeof(*new);
-
+        } else if ((oe->cur_alloc_size + size) < oe->max_alloc_size) {
                 oe->buffer = malloc(size);
                 if (!oe->buffer) {
                         free_dup_event(oe, new_event);
@@ -122,11 +156,11 @@ static struct ordered_event *alloc_event(struct ordered_events *oe,
                 oe->cur_alloc_size += size;
                 list_add(&oe->buffer->list, &oe->to_free);
 
-                /* First entry is abused to maintain the to_free list. */
-                oe->buffer_idx = 2;
-                new = oe->buffer + 1;
+                oe->buffer_idx = 1;
+                new = &oe->buffer->event[0];
         } else {
                 pr("allocation limit reached %" PRIu64 "B\n", oe->max_alloc_size);
+                return NULL;
         }
 
         new->event = new_event;
@@ -300,15 +334,38 @@ void ordered_events__init(struct ordered_events *oe, ordered_events__deliver_t d
         oe->deliver        = deliver;
 }
 
+static void
+ordered_events_buffer__free(struct ordered_events_buffer *buffer,
+                            unsigned int max, struct ordered_events *oe)
+{
+        if (oe->copy_on_queue) {
+                unsigned int i;
+
+                for (i = 0; i < max; i++)
+                        __free_dup_event(oe, buffer->event[i].event);
+        }
+
+        free(buffer);
+}
+
 void ordered_events__free(struct ordered_events *oe)
 {
-        while (!list_empty(&oe->to_free)) {
-                struct ordered_event *event;
+        struct ordered_events_buffer *buffer, *tmp;
 
-                event = list_entry(oe->to_free.next, struct ordered_event, list);
-                list_del(&event->list);
-                free_dup_event(oe, event->event);
-                free(event);
+        if (list_empty(&oe->to_free))
+                return;
+
+        /*
+         * Current buffer might not have all the events allocated
+         * yet, we need to free only allocated ones ...
+         */
+        list_del(&oe->buffer->list);
+        ordered_events_buffer__free(oe->buffer, oe->buffer_idx, oe);
+
+        /* ... and continue with the rest */
+        list_for_each_entry_safe(buffer, tmp, &oe->to_free, list) {
+                list_del(&buffer->list);
+                ordered_events_buffer__free(buffer, MAX_SAMPLE_BUFFER, oe);
         }
 }
 
diff --git a/tools/perf/util/ordered-events.h b/tools/perf/util/ordered-events.h
index 8c7a2948593e..1338d5c345dc 100644
--- a/tools/perf/util/ordered-events.h
+++ b/tools/perf/util/ordered-events.h
@@ -25,23 +25,28 @@ struct ordered_events;
 typedef int (*ordered_events__deliver_t)(struct ordered_events *oe,
                                          struct ordered_event *event);
 
+struct ordered_events_buffer {
+        struct list_head        list;
+        struct ordered_event    event[0];
+};
+
 struct ordered_events {
-        u64                     last_flush;
-        u64                     next_flush;
-        u64                     max_timestamp;
-        u64                     max_alloc_size;
-        u64                     cur_alloc_size;
-        struct list_head        events;
-        struct list_head        cache;
-        struct list_head        to_free;
-        struct ordered_event    *buffer;
-        struct ordered_event    *last;
-        ordered_events__deliver_t deliver;
-        int                     buffer_idx;
-        unsigned int            nr_events;
-        enum oe_flush           last_flush_type;
-        u32                     nr_unordered_events;
-        bool                    copy_on_queue;
+        u64                              last_flush;
+        u64                              next_flush;
+        u64                              max_timestamp;
+        u64                              max_alloc_size;
+        u64                              cur_alloc_size;
+        struct list_head                 events;
+        struct list_head                 cache;
+        struct list_head                 to_free;
+        struct ordered_events_buffer    *buffer;
+        struct ordered_event            *last;
+        ordered_events__deliver_t        deliver;
+        int                              buffer_idx;
+        unsigned int                     nr_events;
+        enum oe_flush                    last_flush_type;
+        u32                              nr_unordered_events;
+        bool                             copy_on_queue;
 };
 
 int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index f8cd3e7c9186..59be3466d64d 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -926,6 +926,7 @@ static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
         [PARSE_EVENTS__TERM_TYPE_NOINHERIT]             = "no-inherit",
         [PARSE_EVENTS__TERM_TYPE_INHERIT]               = "inherit",
         [PARSE_EVENTS__TERM_TYPE_MAX_STACK]             = "max-stack",
+        [PARSE_EVENTS__TERM_TYPE_MAX_EVENTS]            = "nr",
         [PARSE_EVENTS__TERM_TYPE_OVERWRITE]             = "overwrite",
         [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE]           = "no-overwrite",
         [PARSE_EVENTS__TERM_TYPE_DRV_CFG]               = "driver-config",
@@ -1037,6 +1038,9 @@ do {									   \
         case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
                 CHECK_TYPE_VAL(NUM);
                 break;
+        case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
+                CHECK_TYPE_VAL(NUM);
+                break;
         default:
                 err->str = strdup("unknown term");
                 err->idx = term->err_term;
@@ -1084,6 +1088,7 @@ static int config_term_tracepoint(struct perf_event_attr *attr,
         case PARSE_EVENTS__TERM_TYPE_INHERIT:
         case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
         case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
+        case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
         case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
         case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
                 return config_term_common(attr, term, err);
@@ -1162,6 +1167,9 @@ do {								\
                 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
                         ADD_CONFIG_TERM(MAX_STACK, max_stack, term->val.num);
                         break;
+                case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
+                        ADD_CONFIG_TERM(MAX_EVENTS, max_events, term->val.num);
+                        break;
                 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
                         ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 1 : 0);
                         break;
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 4473dac27aee..5ed035cbcbb7 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -71,6 +71,7 @@ enum {
         PARSE_EVENTS__TERM_TYPE_NOINHERIT,
         PARSE_EVENTS__TERM_TYPE_INHERIT,
         PARSE_EVENTS__TERM_TYPE_MAX_STACK,
+        PARSE_EVENTS__TERM_TYPE_MAX_EVENTS,
         PARSE_EVENTS__TERM_TYPE_NOOVERWRITE,
         PARSE_EVENTS__TERM_TYPE_OVERWRITE,
         PARSE_EVENTS__TERM_TYPE_DRV_CFG,
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 5f761f3ed0f3..7805c71aaae2 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -269,6 +269,7 @@ time			{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_TIME); }
 call-graph              { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CALLGRAPH); }
 stack-size              { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_STACKSIZE); }
 max-stack               { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_STACK); }
+nr                      { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_EVENTS); }
 inherit                 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_INHERIT); }
 no-inherit              { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOINHERIT); }
 overwrite               { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_OVERWRITE); }
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index afd68524ffa9..7799788f662f 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -930,13 +930,14 @@ static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
 
 static __u64 pmu_format_max_value(const unsigned long *format)
 {
-        __u64 w = 0;
-        int fbit;
-
-        for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS)
-                w |= (1ULL << fbit);
+        int w;
 
-        return w;
+        w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
+        if (!w)
+                return 0;
+        if (w < 64)
+                return (1ULL << w) - 1;
+        return -1;
 }
 
 /*
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index f119eb628dbb..e86f8be89157 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1819,6 +1819,12 @@ int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
                         tp->offset = strtoul(fmt2_str, NULL, 10);
         }
 
+        if (tev->uprobes) {
+                fmt2_str = strchr(p, '(');
+                if (fmt2_str)
+                        tp->ref_ctr_offset = strtoul(fmt2_str + 1, NULL, 0);
+        }
+
         tev->nargs = argc - 2;
         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
         if (tev->args == NULL) {
@@ -2012,6 +2018,22 @@ static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
         return err;
 }
 
+static int
+synthesize_uprobe_trace_def(struct probe_trace_event *tev, struct strbuf *buf)
+{
+        struct probe_trace_point *tp = &tev->point;
+        int err;
+
+        err = strbuf_addf(buf, "%s:0x%lx", tp->module, tp->address);
+
+        if (err >= 0 && tp->ref_ctr_offset) {
+                if (!uprobe_ref_ctr_is_supported())
+                        return -1;
+                err = strbuf_addf(buf, "(0x%lx)", tp->ref_ctr_offset);
+        }
+        return err >= 0 ? 0 : -1;
+}
+
 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
 {
         struct probe_trace_point *tp = &tev->point;
@@ -2041,15 +2063,17 @@ char *synthesize_probe_trace_command(struct probe_trace_event *tev)
         }
 
         /* Use the tp->address for uprobes */
-        if (tev->uprobes)
-                err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address);
-        else if (!strncmp(tp->symbol, "0x", 2))
+        if (tev->uprobes) {
+                err = synthesize_uprobe_trace_def(tev, &buf);
+        } else if (!strncmp(tp->symbol, "0x", 2)) {
                 /* Absolute address. See try_to_find_absolute_address() */
                 err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
                                   tp->module ? ":" : "", tp->address);
-        else
+        } else {
                 err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
                                 tp->module ? ":" : "", tp->symbol, tp->offset);
+        }
+
         if (err)
                 goto error;
 
@@ -2633,6 +2657,13 @@ static void warn_uprobe_event_compat(struct probe_trace_event *tev)
 {
         int i;
         char *buf = synthesize_probe_trace_command(tev);
+        struct probe_trace_point *tp = &tev->point;
+
+        if (tp->ref_ctr_offset && !uprobe_ref_ctr_is_supported()) {
+                pr_warning("A semaphore is associated with %s:%s and "
+                           "seems your kernel doesn't support it.\n",
+                           tev->group, tev->event);
+        }
 
         /* Old uprobe event doesn't support memory dereference */
         if (!tev->uprobes || tev->nargs == 0 || !buf)
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 45b14f020558..15a98c3a2a2f 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -27,6 +27,7 @@ struct probe_trace_point {
         char            *symbol;        /* Base symbol */
         char            *module;        /* Module name */
         unsigned long   offset;         /* Offset from symbol */
+        unsigned long   ref_ctr_offset; /* SDT reference counter offset */
         unsigned long   address;        /* Actual address of the trace point */
         bool            retprobe;       /* Return probe flag */
 };
diff --git a/tools/perf/util/probe-file.c b/tools/perf/util/probe-file.c
index b76088fadf3d..aac7817d9e14 100644
--- a/tools/perf/util/probe-file.c
+++ b/tools/perf/util/probe-file.c
@@ -696,8 +696,16 @@ out_err:
 #ifdef HAVE_GELF_GETNOTE_SUPPORT
 static unsigned long long sdt_note__get_addr(struct sdt_note *note)
 {
-        return note->bit32 ? (unsigned long long)note->addr.a32[0]
-                 : (unsigned long long)note->addr.a64[0];
+        return note->bit32 ?
+                (unsigned long long)note->addr.a32[SDT_NOTE_IDX_LOC] :
+                (unsigned long long)note->addr.a64[SDT_NOTE_IDX_LOC];
+}
+
+static unsigned long long sdt_note__get_ref_ctr_offset(struct sdt_note *note)
+{
+        return note->bit32 ?
+                (unsigned long long)note->addr.a32[SDT_NOTE_IDX_REFCTR] :
+                (unsigned long long)note->addr.a64[SDT_NOTE_IDX_REFCTR];
 }
 
 static const char * const type_to_suffix[] = {
@@ -775,14 +783,21 @@ static char *synthesize_sdt_probe_command(struct sdt_note *note,
 {
         struct strbuf buf;
         char *ret = NULL, **args;
-        int i, args_count;
+        int i, args_count, err;
+        unsigned long long ref_ctr_offset;
 
         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)
+        err = strbuf_addf(&buf, "p:%s/%s %s:0x%llx",
+                        sdtgrp, note->name, pathname,
+                        sdt_note__get_addr(note));
+
+        ref_ctr_offset = sdt_note__get_ref_ctr_offset(note);
+        if (ref_ctr_offset && err >= 0)
+                err = strbuf_addf(&buf, "(0x%llx)", ref_ctr_offset);
+
+        if (err < 0)
                 goto error;
 
         if (!note->args)
@@ -998,6 +1013,7 @@ int probe_cache__show_all_caches(struct strfilter *filter)
 enum ftrace_readme {
         FTRACE_README_PROBE_TYPE_X = 0,
         FTRACE_README_KRETPROBE_OFFSET,
+        FTRACE_README_UPROBE_REF_CTR,
         FTRACE_README_END,
 };
 
@@ -1009,6 +1025,7 @@ static struct {
         [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): *"),
+        DEFINE_TYPE(FTRACE_README_UPROBE_REF_CTR, "*ref_ctr_offset*"),
 };
 
 static bool scan_ftrace_readme(enum ftrace_readme type)
@@ -1064,3 +1081,8 @@ bool kretprobe_offset_is_supported(void)
 {
         return scan_ftrace_readme(FTRACE_README_KRETPROBE_OFFSET);
 }
+
+bool uprobe_ref_ctr_is_supported(void)
+{
+        return scan_ftrace_readme(FTRACE_README_UPROBE_REF_CTR);
+}
diff --git a/tools/perf/util/probe-file.h b/tools/perf/util/probe-file.h
index 63f29b1d22c1..2a249182f2a6 100644
--- a/tools/perf/util/probe-file.h
+++ b/tools/perf/util/probe-file.h
@@ -69,6 +69,7 @@ struct probe_cache_entry *probe_cache__find_by_name(struct probe_cache *pcache,
 int probe_cache__show_all_caches(struct strfilter *filter);
 bool probe_type_is_available(enum probe_type type);
 bool kretprobe_offset_is_supported(void);
+bool uprobe_ref_ctr_is_supported(void);
 #else   /* ! HAVE_LIBELF_SUPPORT */
 static inline struct probe_cache *probe_cache__new(const char *tgt __maybe_unused, struct nsinfo *nsi __maybe_unused)
 {
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index ce501ba14b08..50150dfc0cdf 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -340,7 +340,7 @@ static bool is_tracepoint(struct pyrf_event *pevent)
 }
 
 static PyObject*
-tracepoint_field(struct pyrf_event *pe, struct format_field *field)
+tracepoint_field(struct pyrf_event *pe, struct tep_format_field *field)
 {
         struct tep_handle *pevent = field->event->pevent;
         void *data = pe->sample.raw_data;
@@ -348,28 +348,28 @@ tracepoint_field(struct pyrf_event *pe, struct format_field *field)
         unsigned long long val;
         unsigned int offset, len;
 
-        if (field->flags & FIELD_IS_ARRAY) {
+        if (field->flags & TEP_FIELD_IS_ARRAY) {
                 offset = field->offset;
                 len    = field->size;
-                if (field->flags & FIELD_IS_DYNAMIC) {
+                if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                         val     = tep_read_number(pevent, data + offset, len);
                         offset  = val;
                         len     = offset >> 16;
                         offset &= 0xffff;
                 }
-                if (field->flags & FIELD_IS_STRING &&
+                if (field->flags & TEP_FIELD_IS_STRING &&
                     is_printable_array(data + offset, len)) {
                         ret = _PyUnicode_FromString((char *)data + offset);
                 } else {
                         ret = PyByteArray_FromStringAndSize((const char *) data + offset, len);
-                        field->flags &= ~FIELD_IS_STRING;
+                        field->flags &= ~TEP_FIELD_IS_STRING;
                 }
         } else {
                 val = tep_read_number(pevent, data + field->offset,
                                       field->size);
-                if (field->flags & FIELD_IS_POINTER)
+                if (field->flags & TEP_FIELD_IS_POINTER)
                         ret = PyLong_FromUnsignedLong((unsigned long) val);
-                else if (field->flags & FIELD_IS_SIGNED)
+                else if (field->flags & TEP_FIELD_IS_SIGNED)
                         ret = PyLong_FromLong((long) val);
                 else
                         ret = PyLong_FromUnsignedLong((unsigned long) val);
@@ -383,10 +383,10 @@ get_tracepoint_field(struct pyrf_event *pevent, PyObject *attr_name)
 {
         const char *str = _PyUnicode_AsString(PyObject_Str(attr_name));
         struct perf_evsel *evsel = pevent->evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
 
         if (!evsel->tp_format) {
-                struct event_format *tp_format;
+                struct tep_event_format *tp_format;
 
                 tp_format = trace_event__tp_format_id(evsel->attr.config);
                 if (!tp_format)
@@ -1240,7 +1240,7 @@ static struct {
 static PyObject *pyrf__tracepoint(struct pyrf_evsel *pevsel,
                                   PyObject *args, PyObject *kwargs)
 {
-        struct event_format *tp_format;
+        struct tep_event_format *tp_format;
         static char *kwlist[] = { "sys", "name", NULL };
         char *sys  = NULL;
         char *name = NULL;
diff --git a/tools/perf/util/s390-cpumsf.c b/tools/perf/util/s390-cpumsf.c
index d2c78ffd9fee..a2eeebbfb25f 100644
--- a/tools/perf/util/s390-cpumsf.c
+++ b/tools/perf/util/s390-cpumsf.c
@@ -147,6 +147,9 @@
 #include <linux/bitops.h>
 #include <linux/log2.h>
 
+#include <sys/stat.h>
+#include <sys/types.h>
+
 #include "cpumap.h"
 #include "color.h"
 #include "evsel.h"
@@ -159,6 +162,7 @@
 #include "auxtrace.h"
 #include "s390-cpumsf.h"
 #include "s390-cpumsf-kernel.h"
+#include "config.h"
 
 struct s390_cpumsf {
         struct auxtrace         auxtrace;
@@ -170,6 +174,8 @@ struct s390_cpumsf {
         u32                     pmu_type;
         u16                     machine_type;
         bool                    data_queued;
+        bool                    use_logfile;
+        char                    *logdir;
 };
 
 struct s390_cpumsf_queue {
@@ -177,6 +183,7 @@ struct s390_cpumsf_queue {
         unsigned int            queue_nr;
         struct auxtrace_buffer  *buffer;
         int                     cpu;
+        FILE                    *logfile;
 };
 
 /* Display s390 CPU measurement facility basic-sampling data entry */
@@ -595,6 +602,12 @@ static int s390_cpumsf_run_decoder(struct s390_cpumsf_queue *sfq,
                         buffer->use_size = buffer->size;
                         buffer->use_data = buffer->data;
                 }
+                if (sfq->logfile) {     /* Write into log file */
+                        size_t rc = fwrite(buffer->data, buffer->size, 1,
+                                           sfq->logfile);
+                        if (rc != 1)
+                                pr_err("Failed to write auxiliary data\n");
+                }
         } else
                 buffer = sfq->buffer;
 
@@ -606,6 +619,13 @@ static int s390_cpumsf_run_decoder(struct s390_cpumsf_queue *sfq,
                         return -ENOMEM;
                 buffer->use_size = buffer->size;
                 buffer->use_data = buffer->data;
+
+                if (sfq->logfile) {     /* Write into log file */
+                        size_t rc = fwrite(buffer->data, buffer->size, 1,
+                                           sfq->logfile);
+                        if (rc != 1)
+                                pr_err("Failed to write auxiliary data\n");
+                }
         }
         pr_debug4("%s queue_nr:%d buffer:%" PRId64 " offset:%#" PRIx64 " size:%#zx rest:%#zx\n",
                   __func__, sfq->queue_nr, buffer->buffer_nr, buffer->offset,
@@ -640,6 +660,23 @@ s390_cpumsf_alloc_queue(struct s390_cpumsf *sf, unsigned int queue_nr)
         sfq->sf = sf;
         sfq->queue_nr = queue_nr;
         sfq->cpu = -1;
+        if (sf->use_logfile) {
+                char *name;
+                int rc;
+
+                rc = (sf->logdir)
+                        ? asprintf(&name, "%s/aux.smp.%02x",
+                                 sf->logdir, queue_nr)
+                        : asprintf(&name, "aux.smp.%02x", queue_nr);
+                if (rc > 0)
+                        sfq->logfile = fopen(name, "w");
+                if (sfq->logfile == NULL) {
+                        pr_err("Failed to open auxiliary log file %s,"
+                               "continue...\n", name);
+                        sf->use_logfile = false;
+                }
+                free(name);
+        }
         return sfq;
 }
 
@@ -850,8 +887,16 @@ static void s390_cpumsf_free_queues(struct perf_session *session)
         struct auxtrace_queues *queues = &sf->queues;
         unsigned int i;
 
-        for (i = 0; i < queues->nr_queues; i++)
+        for (i = 0; i < queues->nr_queues; i++) {
+                struct s390_cpumsf_queue *sfq = (struct s390_cpumsf_queue *)
+                                                queues->queue_array[i].priv;
+
+                if (sfq != NULL && sfq->logfile) {
+                        fclose(sfq->logfile);
+                        sfq->logfile = NULL;
+                }
                 zfree(&queues->queue_array[i].priv);
+        }
         auxtrace_queues__free(queues);
 }
 
@@ -864,6 +909,7 @@ static void s390_cpumsf_free(struct perf_session *session)
         auxtrace_heap__free(&sf->heap);
         s390_cpumsf_free_queues(session);
         session->auxtrace = NULL;
+        free(sf->logdir);
         free(sf);
 }
 
@@ -877,17 +923,55 @@ static int s390_cpumsf_get_type(const char *cpuid)
 
 /* Check itrace options set on perf report command.
  * Return true, if none are set or all options specified can be
- * handled on s390.
+ * handled on s390 (currently only option 'd' for logging.
  * Return false otherwise.
  */
 static bool check_auxtrace_itrace(struct itrace_synth_opts *itops)
 {
+        bool ison = false;
+
         if (!itops || !itops->set)
                 return true;
-        pr_err("No --itrace options supported\n");
+        ison = itops->inject || itops->instructions || itops->branches ||
+                itops->transactions || itops->ptwrites ||
+                itops->pwr_events || itops->errors ||
+                itops->dont_decode || itops->calls || itops->returns ||
+                itops->callchain || itops->thread_stack ||
+                itops->last_branch;
+        if (!ison)
+                return true;
+        pr_err("Unsupported --itrace options specified\n");
         return false;
 }
 
+/* Check for AUXTRACE dump directory if it is needed.
+ * On failure print an error message but continue.
+ * Return 0 on wrong keyword in config file and 1 otherwise.
+ */
+static int s390_cpumsf__config(const char *var, const char *value, void *cb)
+{
+        struct s390_cpumsf *sf = cb;
+        struct stat stbuf;
+        int rc;
+
+        if (strcmp(var, "auxtrace.dumpdir"))
+                return 0;
+        sf->logdir = strdup(value);
+        if (sf->logdir == NULL) {
+                pr_err("Failed to find auxtrace log directory %s,"
+                       " continue with current directory...\n", value);
+                return 1;
+        }
+        rc = stat(sf->logdir, &stbuf);
+        if (rc == -1 || !S_ISDIR(stbuf.st_mode)) {
+                pr_err("Missing auxtrace log directory %s,"
+                       " continue with current directory...\n", value);
+                free(sf->logdir);
+                sf->logdir = NULL;
+        }
+        return 1;
+}
+
 int s390_cpumsf_process_auxtrace_info(union perf_event *event,
                                       struct perf_session *session)
 {
@@ -906,6 +990,9 @@ int s390_cpumsf_process_auxtrace_info(union perf_event *event,
                 err = -EINVAL;
                 goto err_free;
         }
+        sf->use_logfile = session->itrace_synth_opts->log;
+        if (sf->use_logfile)
+                perf_config(s390_cpumsf__config, sf);
 
         err = auxtrace_queues__init(&sf->queues);
         if (err)
@@ -940,6 +1027,7 @@ err_free_queues:
         auxtrace_queues__free(&sf->queues);
         session->auxtrace = NULL;
 err_free:
+        free(sf->logdir);
         free(sf);
         return err;
 }
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 45484f0f7292..89cb887648f9 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -99,7 +99,7 @@ static void define_symbolic_value(const char *ev_name,
         LEAVE;
 }
 
-static void define_symbolic_values(struct print_flag_sym *field,
+static void define_symbolic_values(struct tep_print_flag_sym *field,
                                    const char *ev_name,
                                    const char *field_name)
 {
@@ -157,7 +157,7 @@ static void define_flag_value(const char *ev_name,
         LEAVE;
 }
 
-static void define_flag_values(struct print_flag_sym *field,
+static void define_flag_values(struct tep_print_flag_sym *field,
                                const char *ev_name,
                                const char *field_name)
 {
@@ -189,62 +189,62 @@ static void define_flag_field(const char *ev_name,
         LEAVE;
 }
 
-static void define_event_symbols(struct event_format *event,
+static void define_event_symbols(struct tep_event_format *event,
                                  const char *ev_name,
-                                 struct print_arg *args)
+                                 struct tep_print_arg *args)
 {
         if (args == NULL)
                 return;
 
         switch (args->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 break;
-        case PRINT_ATOM:
+        case TEP_PRINT_ATOM:
                 define_flag_value(ev_name, cur_field_name, "0",
                                   args->atom.atom);
                 zero_flag_atom = 0;
                 break;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 free(cur_field_name);
                 cur_field_name = strdup(args->field.name);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 define_event_symbols(event, ev_name, args->flags.field);
                 define_flag_field(ev_name, cur_field_name, args->flags.delim);
                 define_flag_values(args->flags.flags, ev_name, cur_field_name);
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 define_event_symbols(event, ev_name, args->symbol.field);
                 define_symbolic_field(ev_name, cur_field_name);
                 define_symbolic_values(args->symbol.symbols, ev_name,
                                        cur_field_name);
                 break;
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
                 define_event_symbols(event, ev_name, args->hex.field);
                 define_event_symbols(event, ev_name, args->hex.size);
                 break;
-        case PRINT_INT_ARRAY:
+        case TEP_PRINT_INT_ARRAY:
                 define_event_symbols(event, ev_name, args->int_array.field);
                 define_event_symbols(event, ev_name, args->int_array.count);
                 define_event_symbols(event, ev_name, args->int_array.el_size);
                 break;
-        case PRINT_BSTRING:
-        case PRINT_DYNAMIC_ARRAY:
-        case PRINT_DYNAMIC_ARRAY_LEN:
-        case PRINT_STRING:
-        case PRINT_BITMASK:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_DYNAMIC_ARRAY:
+        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
+        case TEP_PRINT_STRING:
+        case TEP_PRINT_BITMASK:
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 define_event_symbols(event, ev_name, args->typecast.item);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (strcmp(args->op.op, ":") == 0)
                         zero_flag_atom = 1;
                 define_event_symbols(event, ev_name, args->op.left);
                 define_event_symbols(event, ev_name, args->op.right);
                 break;
-        case PRINT_FUNC:
+        case TEP_PRINT_FUNC:
         default:
                 pr_err("Unsupported print arg type\n");
                 /* we should warn... */
@@ -338,8 +338,8 @@ static void perl_process_tracepoint(struct perf_sample *sample,
                                     struct addr_location *al)
 {
         struct thread *thread = al->thread;
-        struct event_format *event = evsel->tp_format;
-        struct format_field *field;
+        struct tep_event_format *event = evsel->tp_format;
+        struct tep_format_field *field;
         static char handler[256];
         unsigned long long val;
         unsigned long s, ns;
@@ -388,9 +388,9 @@ static void perl_process_tracepoint(struct perf_sample *sample,
         /* common fields other than pid can be accessed via xsub fns */
 
         for (field = event->format.fields; field; field = field->next) {
-                if (field->flags & FIELD_IS_STRING) {
+                if (field->flags & TEP_FIELD_IS_STRING) {
                         int offset;
-                        if (field->flags & FIELD_IS_DYNAMIC) {
+                        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                                 offset = *(int *)(data + field->offset);
                                 offset &= 0xffff;
                         } else
@@ -399,7 +399,7 @@ static void perl_process_tracepoint(struct perf_sample *sample,
                 } else { /* FIELD_IS_NUMERIC */
                         val = read_size(event, data + field->offset,
                                         field->size);
-                        if (field->flags & FIELD_IS_SIGNED) {
+                        if (field->flags & TEP_FIELD_IS_SIGNED) {
                                 XPUSHs(sv_2mortal(newSViv(val)));
                         } else {
                                 XPUSHs(sv_2mortal(newSVuv(val)));
@@ -537,8 +537,8 @@ static int perl_stop_script(void)
 
 static int perl_generate_script(struct tep_handle *pevent, const char *outfile)
 {
-        struct event_format *event = NULL;
-        struct format_field *f;
+        struct tep_event_format *event = NULL;
+        struct tep_format_field *f;
         char fname[PATH_MAX];
         int not_first, count;
         FILE *ofp;
@@ -646,11 +646,11 @@ sub print_backtrace\n\
                         count++;
 
                         fprintf(ofp, "%s=", f->name);
-                        if (f->flags & FIELD_IS_STRING ||
-                            f->flags & FIELD_IS_FLAG ||
-                            f->flags & FIELD_IS_SYMBOLIC)
+                        if (f->flags & TEP_FIELD_IS_STRING ||
+                            f->flags & TEP_FIELD_IS_FLAG ||
+                            f->flags & TEP_FIELD_IS_SYMBOLIC)
                                 fprintf(ofp, "%%s");
-                        else if (f->flags & FIELD_IS_SIGNED)
+                        else if (f->flags & TEP_FIELD_IS_SIGNED)
                                 fprintf(ofp, "%%d");
                         else
                                 fprintf(ofp, "%%u");
@@ -668,7 +668,7 @@ sub print_backtrace\n\
                         if (++count % 5 == 0)
                                 fprintf(ofp, "\n\t       ");
 
-                        if (f->flags & FIELD_IS_FLAG) {
+                        if (f->flags & TEP_FIELD_IS_FLAG) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t       ");
                                         count = 4;
@@ -678,7 +678,7 @@ sub print_backtrace\n\
                                         event->name);
                                 fprintf(ofp, "\"%s\", $%s)", f->name,
                                         f->name);
-                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                        } else if (f->flags & TEP_FIELD_IS_SYMBOLIC) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t       ");
                                         count = 4;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index dfc6093f118c..69aa93d4ee99 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -193,7 +193,7 @@ static void try_call_object(const char *handler_name, PyObject *args)
                 call_object(handler, args, handler_name);
 }
 
-static void define_value(enum print_arg_type field_type,
+static void define_value(enum tep_print_arg_type field_type,
                          const char *ev_name,
                          const char *field_name,
                          const char *field_value,
@@ -204,7 +204,7 @@ static void define_value(enum print_arg_type field_type,
         unsigned long long value;
         unsigned n = 0;
 
-        if (field_type == PRINT_SYMBOL)
+        if (field_type == TEP_PRINT_SYMBOL)
                 handler_name = "define_symbolic_value";
 
         t = PyTuple_New(4);
@@ -223,8 +223,8 @@ static void define_value(enum print_arg_type field_type,
         Py_DECREF(t);
 }
 
-static void define_values(enum print_arg_type field_type,
-                          struct print_flag_sym *field,
+static void define_values(enum tep_print_arg_type field_type,
+                          struct tep_print_flag_sym *field,
                           const char *ev_name,
                           const char *field_name)
 {
@@ -235,7 +235,7 @@ static void define_values(enum print_arg_type field_type,
                 define_values(field_type, field->next, ev_name, field_name);
 }
 
-static void define_field(enum print_arg_type field_type,
+static void define_field(enum tep_print_arg_type field_type,
                          const char *ev_name,
                          const char *field_name,
                          const char *delim)
@@ -244,10 +244,10 @@ static void define_field(enum print_arg_type field_type,
         PyObject *t;
         unsigned n = 0;
 
-        if (field_type == PRINT_SYMBOL)
+        if (field_type == TEP_PRINT_SYMBOL)
                 handler_name = "define_symbolic_field";
 
-        if (field_type == PRINT_FLAGS)
+        if (field_type == TEP_PRINT_FLAGS)
                 t = PyTuple_New(3);
         else
                 t = PyTuple_New(2);
@@ -256,7 +256,7 @@ static void define_field(enum print_arg_type field_type,
 
         PyTuple_SetItem(t, n++, _PyUnicode_FromString(ev_name));
         PyTuple_SetItem(t, n++, _PyUnicode_FromString(field_name));
-        if (field_type == PRINT_FLAGS)
+        if (field_type == TEP_PRINT_FLAGS)
                 PyTuple_SetItem(t, n++, _PyUnicode_FromString(delim));
 
         try_call_object(handler_name, t);
@@ -264,54 +264,54 @@ static void define_field(enum print_arg_type field_type,
         Py_DECREF(t);
 }
 
-static void define_event_symbols(struct event_format *event,
+static void define_event_symbols(struct tep_event_format *event,
                                  const char *ev_name,
-                                 struct print_arg *args)
+                                 struct tep_print_arg *args)
 {
         if (args == NULL)
                 return;
 
         switch (args->type) {
-        case PRINT_NULL:
+        case TEP_PRINT_NULL:
                 break;
-        case PRINT_ATOM:
-                define_value(PRINT_FLAGS, ev_name, cur_field_name, "0",
+        case TEP_PRINT_ATOM:
+                define_value(TEP_PRINT_FLAGS, ev_name, cur_field_name, "0",
                              args->atom.atom);
                 zero_flag_atom = 0;
                 break;
-        case PRINT_FIELD:
+        case TEP_PRINT_FIELD:
                 free(cur_field_name);
                 cur_field_name = strdup(args->field.name);
                 break;
-        case PRINT_FLAGS:
+        case TEP_PRINT_FLAGS:
                 define_event_symbols(event, ev_name, args->flags.field);
-                define_field(PRINT_FLAGS, ev_name, cur_field_name,
+                define_field(TEP_PRINT_FLAGS, ev_name, cur_field_name,
                              args->flags.delim);
-                define_values(PRINT_FLAGS, args->flags.flags, ev_name,
+                define_values(TEP_PRINT_FLAGS, args->flags.flags, ev_name,
                               cur_field_name);
                 break;
-        case PRINT_SYMBOL:
+        case TEP_PRINT_SYMBOL:
                 define_event_symbols(event, ev_name, args->symbol.field);
-                define_field(PRINT_SYMBOL, ev_name, cur_field_name, NULL);
-                define_values(PRINT_SYMBOL, args->symbol.symbols, ev_name,
+                define_field(TEP_PRINT_SYMBOL, ev_name, cur_field_name, NULL);
+                define_values(TEP_PRINT_SYMBOL, args->symbol.symbols, ev_name,
                               cur_field_name);
                 break;
-        case PRINT_HEX:
-        case PRINT_HEX_STR:
+        case TEP_PRINT_HEX:
+        case TEP_PRINT_HEX_STR:
                 define_event_symbols(event, ev_name, args->hex.field);
                 define_event_symbols(event, ev_name, args->hex.size);
                 break;
-        case PRINT_INT_ARRAY:
+        case TEP_PRINT_INT_ARRAY:
                 define_event_symbols(event, ev_name, args->int_array.field);
                 define_event_symbols(event, ev_name, args->int_array.count);
                 define_event_symbols(event, ev_name, args->int_array.el_size);
                 break;
-        case PRINT_STRING:
+        case TEP_PRINT_STRING:
                 break;
-        case PRINT_TYPE:
+        case TEP_PRINT_TYPE:
                 define_event_symbols(event, ev_name, args->typecast.item);
                 break;
-        case PRINT_OP:
+        case TEP_PRINT_OP:
                 if (strcmp(args->op.op, ":") == 0)
                         zero_flag_atom = 1;
                 define_event_symbols(event, ev_name, args->op.left);
@@ -319,11 +319,11 @@ static void define_event_symbols(struct event_format *event,
                 break;
         default:
                 /* gcc warns for these? */
-        case PRINT_BSTRING:
-        case PRINT_DYNAMIC_ARRAY:
-        case PRINT_DYNAMIC_ARRAY_LEN:
-        case PRINT_FUNC:
-        case PRINT_BITMASK:
+        case TEP_PRINT_BSTRING:
+        case TEP_PRINT_DYNAMIC_ARRAY:
+        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
+        case TEP_PRINT_FUNC:
+        case TEP_PRINT_BITMASK:
                 /* we should warn... */
                 return;
         }
@@ -332,10 +332,10 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static PyObject *get_field_numeric_entry(struct event_format *event,
-                struct format_field *field, void *data)
+static PyObject *get_field_numeric_entry(struct tep_event_format *event,
+                struct tep_format_field *field, void *data)
 {
-        bool is_array = field->flags & FIELD_IS_ARRAY;
+        bool is_array = field->flags & TEP_FIELD_IS_ARRAY;
         PyObject *obj = NULL, *list = NULL;
         unsigned long long val;
         unsigned int item_size, n_items, i;
@@ -353,7 +353,7 @@ static PyObject *get_field_numeric_entry(struct event_format *event,
 
                 val = read_size(event, data + field->offset + i * item_size,
                                 item_size);
-                if (field->flags & FIELD_IS_SIGNED) {
+                if (field->flags & TEP_FIELD_IS_SIGNED) {
                         if ((long long)val >= LONG_MIN &&
                                         (long long)val <= LONG_MAX)
                                 obj = _PyLong_FromLong(val);
@@ -790,11 +790,11 @@ static void python_process_tracepoint(struct perf_sample *sample,
                                       struct perf_evsel *evsel,
                                       struct addr_location *al)
 {
-        struct event_format *event = evsel->tp_format;
+        struct tep_event_format *event = evsel->tp_format;
         PyObject *handler, *context, *t, *obj = NULL, *callchain;
         PyObject *dict = NULL, *all_entries_dict = NULL;
         static char handler_name[256];
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long s, ns;
         unsigned n = 0;
         int pid;
@@ -867,22 +867,22 @@ static void python_process_tracepoint(struct perf_sample *sample,
                 unsigned int offset, len;
                 unsigned long long val;
 
-                if (field->flags & FIELD_IS_ARRAY) {
+                if (field->flags & TEP_FIELD_IS_ARRAY) {
                         offset = field->offset;
                         len    = field->size;
-                        if (field->flags & FIELD_IS_DYNAMIC) {
+                        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                                 val     = tep_read_number(scripting_context->pevent,
                                                           data + offset, len);
                                 offset  = val;
                                 len     = offset >> 16;
                                 offset &= 0xffff;
                         }
-                        if (field->flags & FIELD_IS_STRING &&
+                        if (field->flags & TEP_FIELD_IS_STRING &&
                             is_printable_array(data + offset, len)) {
                                 obj = _PyUnicode_FromString((char *) data + offset);
                         } else {
                                 obj = PyByteArray_FromStringAndSize((const char *) data + offset, len);
-                                field->flags &= ~FIELD_IS_STRING;
+                                field->flags &= ~TEP_FIELD_IS_STRING;
                         }
                 } else { /* FIELD_IS_NUMERIC */
                         obj = get_field_numeric_entry(event, field, data);
@@ -1590,8 +1590,8 @@ static int python_stop_script(void)
 
 static int python_generate_script(struct tep_handle *pevent, const char *outfile)
 {
-        struct event_format *event = NULL;
-        struct format_field *f;
+        struct tep_event_format *event = NULL;
+        struct tep_format_field *f;
         char fname[PATH_MAX];
         int not_first, count;
         FILE *ofp;
@@ -1686,12 +1686,12 @@ static int python_generate_script(struct tep_handle *pevent, const char *outfile
                         count++;
 
                         fprintf(ofp, "%s=", f->name);
-                        if (f->flags & FIELD_IS_STRING ||
-                            f->flags & FIELD_IS_FLAG ||
-                            f->flags & FIELD_IS_ARRAY ||
-                            f->flags & FIELD_IS_SYMBOLIC)
+                        if (f->flags & TEP_FIELD_IS_STRING ||
+                            f->flags & TEP_FIELD_IS_FLAG ||
+                            f->flags & TEP_FIELD_IS_ARRAY ||
+                            f->flags & TEP_FIELD_IS_SYMBOLIC)
                                 fprintf(ofp, "%%s");
-                        else if (f->flags & FIELD_IS_SIGNED)
+                        else if (f->flags & TEP_FIELD_IS_SIGNED)
                                 fprintf(ofp, "%%d");
                         else
                                 fprintf(ofp, "%%u");
@@ -1709,7 +1709,7 @@ static int python_generate_script(struct tep_handle *pevent, const char *outfile
                         if (++count % 5 == 0)
                                 fprintf(ofp, "\n\t\t");
 
-                        if (f->flags & FIELD_IS_FLAG) {
+                        if (f->flags & TEP_FIELD_IS_FLAG) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t\t");
                                         count = 4;
@@ -1719,7 +1719,7 @@ static int python_generate_script(struct tep_handle *pevent, const char *outfile
                                         event->name);
                                 fprintf(ofp, "\"%s\", %s)", f->name,
                                         f->name);
-                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                        } else if (f->flags & TEP_FIELD_IS_SYMBOLIC) {
                                 if ((count - 1) % 5 != 0) {
                                         fprintf(ofp, "\n\t\t");
                                         count = 4;
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 8b9369303561..7d2c8ce6cfad 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -199,12 +199,10 @@ void perf_session__delete(struct perf_session *session)
         free(session);
 }
 
-static int process_event_synth_tracing_data_stub(struct perf_tool *tool
+static int process_event_synth_tracing_data_stub(struct perf_session *session
                                                  __maybe_unused,
                                                  union perf_event *event
-                                                 __maybe_unused,
-                                                 struct perf_session *session
-                                                __maybe_unused)
+                                                 __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
@@ -277,10 +275,8 @@ static int skipn(int fd, off_t n)
         return 0;
 }
 
-static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
-                                       union perf_event *event,
-                                       struct perf_session *session
-                                       __maybe_unused)
+static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
+                                       union perf_event *event)
 {
         dump_printf(": unhandled!\n");
         if (perf_data__is_pipe(session->data))
@@ -288,9 +284,8 @@ static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
         return event->auxtrace.size;
 }
 
-static int process_event_op2_stub(struct perf_tool *tool __maybe_unused,
-                                  union perf_event *event __maybe_unused,
-                                  struct perf_session *session __maybe_unused)
+static int process_event_op2_stub(struct perf_session *session __maybe_unused,
+                                  union perf_event *event __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
@@ -298,9 +293,8 @@ static int process_event_op2_stub(struct perf_tool *tool __maybe_unused,
 
 
 static
-int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused,
-                                  union perf_event *event __maybe_unused,
-                                  struct perf_session *session __maybe_unused)
+int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
+                                  union perf_event *event __maybe_unused)
 {
         if (dump_trace)
                 perf_event__fprintf_thread_map(event, stdout);
@@ -310,9 +304,8 @@ int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused,
 }
 
 static
-int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused,
-                               union perf_event *event __maybe_unused,
-                               struct perf_session *session __maybe_unused)
+int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
+                               union perf_event *event __maybe_unused)
 {
         if (dump_trace)
                 perf_event__fprintf_cpu_map(event, stdout);
@@ -322,9 +315,8 @@ int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused,
 }
 
 static
-int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event __maybe_unused,
-                                   struct perf_session *session __maybe_unused)
+int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
+                                   union perf_event *event __maybe_unused)
 {
         if (dump_trace)
                 perf_event__fprintf_stat_config(event, stdout);
@@ -333,10 +325,8 @@ int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_stat_stub(struct perf_tool *tool __maybe_unused,
-                             union perf_event *event __maybe_unused,
-                             struct perf_session *perf_session
-                             __maybe_unused)
+static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
+                             union perf_event *event)
 {
         if (dump_trace)
                 perf_event__fprintf_stat(event, stdout);
@@ -345,10 +335,8 @@ static int process_stat_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_stat_round_stub(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event __maybe_unused,
-                                   struct perf_session *perf_session
-                                   __maybe_unused)
+static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
+                                   union perf_event *event)
 {
         if (dump_trace)
                 perf_event__fprintf_stat_round(event, stdout);
@@ -1374,37 +1362,37 @@ static s64 perf_session__process_user_event(struct perf_session *session,
         case PERF_RECORD_HEADER_TRACING_DATA:
                 /* setup for reading amidst mmap */
                 lseek(fd, file_offset, SEEK_SET);
-                return tool->tracing_data(tool, event, session);
+                return tool->tracing_data(session, event);
         case PERF_RECORD_HEADER_BUILD_ID:
-                return tool->build_id(tool, event, session);
+                return tool->build_id(session, event);
         case PERF_RECORD_FINISHED_ROUND:
                 return tool->finished_round(tool, event, oe);
         case PERF_RECORD_ID_INDEX:
-                return tool->id_index(tool, event, session);
+                return tool->id_index(session, event);
         case PERF_RECORD_AUXTRACE_INFO:
-                return tool->auxtrace_info(tool, event, session);
+                return tool->auxtrace_info(session, event);
         case PERF_RECORD_AUXTRACE:
                 /* setup for reading amidst mmap */
                 lseek(fd, file_offset + event->header.size, SEEK_SET);
-                return tool->auxtrace(tool, event, session);
+                return tool->auxtrace(session, event);
         case PERF_RECORD_AUXTRACE_ERROR:
                 perf_session__auxtrace_error_inc(session, event);
-                return tool->auxtrace_error(tool, event, session);
+                return tool->auxtrace_error(session, event);
         case PERF_RECORD_THREAD_MAP:
-                return tool->thread_map(tool, event, session);
+                return tool->thread_map(session, event);
         case PERF_RECORD_CPU_MAP:
-                return tool->cpu_map(tool, event, session);
+                return tool->cpu_map(session, event);
         case PERF_RECORD_STAT_CONFIG:
-                return tool->stat_config(tool, event, session);
+                return tool->stat_config(session, event);
         case PERF_RECORD_STAT:
-                return tool->stat(tool, event, session);
+                return tool->stat(session, event);
         case PERF_RECORD_STAT_ROUND:
-                return tool->stat_round(tool, event, session);
+                return tool->stat_round(session, event);
         case PERF_RECORD_TIME_CONV:
                 session->time_conv = event->time_conv;
-                return tool->time_conv(tool, event, session);
+                return tool->time_conv(session, event);
         case PERF_RECORD_HEADER_FEATURE:
-                return tool->feature(tool, event, session);
+                return tool->feature(session, event);
         default:
                 return -EINVAL;
         }
@@ -2133,9 +2121,8 @@ out:
         return err;
 }
 
-int perf_event__process_id_index(struct perf_tool *tool __maybe_unused,
-                                 union perf_event *event,
-                                 struct perf_session *session)
+int perf_event__process_id_index(struct perf_session *session,
+                                 union perf_event *event)
 {
         struct perf_evlist *evlist = session->evlist;
         struct id_index_event *ie = &event->id_index;
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index da40b4b380ca..d96eccd7d27f 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -120,9 +120,8 @@ int perf_session__deliver_synth_event(struct perf_session *session,
                                       union perf_event *event,
                                       struct perf_sample *sample);
 
-int perf_event__process_id_index(struct perf_tool *tool,
-                                 union perf_event *event,
-                                 struct perf_session *session);
+int perf_event__process_id_index(struct perf_session *session,
+                                 union perf_event *event);
 
 int perf_event__synthesize_id_index(struct perf_tool *tool,
                                     perf_event__handler_t process,
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 97efbcad076e..63f758c655d5 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -5,16 +5,18 @@ from subprocess import Popen, PIPE
 from re import sub
 
 def clang_has_option(option):
-    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if "unknown argument" in o] == [ ]
+    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if b"unknown argument" in o] == [ ]
 
 cc = getenv("CC")
 if cc == "clang":
-    from _sysconfigdata import build_time_vars
-    build_time_vars["CFLAGS"] = sub("-specs=[^ ]+", "", build_time_vars["CFLAGS"])
-    if not clang_has_option("-mcet"):
-        build_time_vars["CFLAGS"] = sub("-mcet", "", build_time_vars["CFLAGS"])
-    if not clang_has_option("-fcf-protection"):
-        build_time_vars["CFLAGS"] = sub("-fcf-protection", "", build_time_vars["CFLAGS"])
+    from distutils.sysconfig import get_config_vars
+    vars = get_config_vars()
+    for var in ('CFLAGS', 'OPT'):
+        vars[var] = sub("-specs=[^ ]+", "", vars[var])
+        if not clang_has_option("-mcet"):
+            vars[var] = sub("-mcet", "", vars[var])
+        if not clang_has_option("-fcf-protection"):
+            vars[var] = sub("-fcf-protection", "", vars[var])
 
 from distutils.core import setup, Extension
 
@@ -35,7 +37,7 @@ class install_lib(_install_lib):
 
 cflags = getenv('CFLAGS', '').split()
 # switch off several checks (need to be at the end of cflags list)
-cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter' ]
+cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter', '-Wno-redundant-decls' ]
 if cc != "clang":
     cflags += ['-Wno-cast-function-type' ]
 
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index b284276ec963..f96c005b3c41 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1884,7 +1884,7 @@ static int __sort_dimension__add_hpp_output(struct sort_dimension *sd,
 struct hpp_dynamic_entry {
         struct perf_hpp_fmt hpp;
         struct perf_evsel *evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned dynamic_len;
         bool raw_trace;
 };
@@ -1899,7 +1899,7 @@ static int hde_width(struct hpp_dynamic_entry *hde)
                 if (namelen > len)
                         len = namelen;
 
-                if (!(hde->field->flags & FIELD_IS_STRING)) {
+                if (!(hde->field->flags & TEP_FIELD_IS_STRING)) {
                         /* length for print hex numbers */
                         fieldlen = hde->field->size * 2 + 2;
                 }
@@ -1915,7 +1915,7 @@ static void update_dynamic_len(struct hpp_dynamic_entry *hde,
                                struct hist_entry *he)
 {
         char *str, *pos;
-        struct format_field *field = hde->field;
+        struct tep_format_field *field = hde->field;
         size_t namelen;
         bool last = false;
 
@@ -2000,7 +2000,7 @@ static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
         struct hpp_dynamic_entry *hde;
         size_t len = fmt->user_len;
         char *str, *pos;
-        struct format_field *field;
+        struct tep_format_field *field;
         size_t namelen;
         bool last = false;
         int ret;
@@ -2060,7 +2060,7 @@ static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
                                struct hist_entry *a, struct hist_entry *b)
 {
         struct hpp_dynamic_entry *hde;
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned offset, size;
 
         hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
@@ -2071,7 +2071,7 @@ static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
         }
 
         field = hde->field;
-        if (field->flags & FIELD_IS_DYNAMIC) {
+        if (field->flags & TEP_FIELD_IS_DYNAMIC) {
                 unsigned long long dyn;
 
                 tep_read_number_field(field, a->raw_data, &dyn);
@@ -2117,7 +2117,7 @@ static void hde_free(struct perf_hpp_fmt *fmt)
 }
 
 static struct hpp_dynamic_entry *
-__alloc_dynamic_entry(struct perf_evsel *evsel, struct format_field *field,
+__alloc_dynamic_entry(struct perf_evsel *evsel, struct tep_format_field *field,
                       int level)
 {
         struct hpp_dynamic_entry *hde;
@@ -2252,7 +2252,7 @@ static struct perf_evsel *find_evsel(struct perf_evlist *evlist, char *event_nam
 }
 
 static int __dynamic_dimension__add(struct perf_evsel *evsel,
-                                    struct format_field *field,
+                                    struct tep_format_field *field,
                                     bool raw_trace, int level)
 {
         struct hpp_dynamic_entry *hde;
@@ -2270,7 +2270,7 @@ static int __dynamic_dimension__add(struct perf_evsel *evsel,
 static int add_evsel_fields(struct perf_evsel *evsel, bool raw_trace, int level)
 {
         int ret;
-        struct format_field *field;
+        struct tep_format_field *field;
 
         field = evsel->tp_format->format.fields;
         while (field) {
@@ -2305,7 +2305,7 @@ static int add_all_matching_fields(struct perf_evlist *evlist,
 {
         int ret = -ESRCH;
         struct perf_evsel *evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
 
         evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
@@ -2327,7 +2327,7 @@ static int add_dynamic_entry(struct perf_evlist *evlist, const char *tok,
 {
         char *str, *event_name, *field_name, *opt_name;
         struct perf_evsel *evsel;
-        struct format_field *field;
+        struct tep_format_field *field;
         bool raw_trace = symbol_conf.raw_trace;
         int ret = 0;
 
diff --git a/tools/perf/util/srcline.c b/tools/perf/util/srcline.c
index 09d6746e6ec8..e767c4a9d4d2 100644
--- a/tools/perf/util/srcline.c
+++ b/tools/perf/util/srcline.c
@@ -85,6 +85,9 @@ static struct symbol *new_inline_sym(struct dso *dso,
         struct symbol *inline_sym;
         char *demangled = NULL;
 
+        if (!funcname)
+                funcname = "??";
+
         if (dso) {
                 demangled = dso__demangle_sym(dso, 0, funcname);
                 if (demangled)
diff --git a/tools/perf/util/stat-display.c b/tools/perf/util/stat-display.c
new file mode 100644
index 000000000000..e7b4c44ebb62
--- /dev/null
+++ b/tools/perf/util/stat-display.c
@@ -0,0 +1,1166 @@
+#include <stdio.h>
+#include <inttypes.h>
+#include <linux/time64.h>
+#include <math.h>
+#include "evlist.h"
+#include "evsel.h"
+#include "stat.h"
+#include "top.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "string2.h"
+#include "sane_ctype.h"
+#include "cgroup.h"
+#include <math.h>
+#include <api/fs/fs.h>
+
+#define CNTR_NOT_SUPPORTED      "<not supported>"
+#define CNTR_NOT_COUNTED        "<not counted>"
+
+static bool is_duration_time(struct perf_evsel *evsel)
+{
+        return !strcmp(evsel->name, "duration_time");
+}
+
+static void print_running(struct perf_stat_config *config,
+                          u64 run, u64 ena)
+{
+        if (config->csv_output) {
+                fprintf(config->output, "%s%" PRIu64 "%s%.2f",
+                                        config->csv_sep,
+                                        run,
+                                        config->csv_sep,
+                                        ena ? 100.0 * run / ena : 100.0);
+        } else if (run != ena) {
+                fprintf(config->output, "  (%.2f%%)", 100.0 * run / ena);
+        }
+}
+
+static void print_noise_pct(struct perf_stat_config *config,
+                            double total, double avg)
+{
+        double pct = rel_stddev_stats(total, avg);
+
+        if (config->csv_output)
+                fprintf(config->output, "%s%.2f%%", config->csv_sep, pct);
+        else if (pct)
+                fprintf(config->output, "  ( +-%6.2f%% )", pct);
+}
+
+static void print_noise(struct perf_stat_config *config,
+                        struct perf_evsel *evsel, double avg)
+{
+        struct perf_stat_evsel *ps;
+
+        if (config->run_count == 1)
+                return;
+
+        ps = evsel->stats;
+        print_noise_pct(config, stddev_stats(&ps->res_stats[0]), avg);
+}
+
+static void aggr_printout(struct perf_stat_config *config,
+                          struct perf_evsel *evsel, int id, int nr)
+{
+        switch (config->aggr_mode) {
+        case AGGR_CORE:
+                fprintf(config->output, "S%d-C%*d%s%*d%s",
+                        cpu_map__id_to_socket(id),
+                        config->csv_output ? 0 : -8,
+                        cpu_map__id_to_cpu(id),
+                        config->csv_sep,
+                        config->csv_output ? 0 : 4,
+                        nr,
+                        config->csv_sep);
+                break;
+        case AGGR_SOCKET:
+                fprintf(config->output, "S%*d%s%*d%s",
+                        config->csv_output ? 0 : -5,
+                        id,
+                        config->csv_sep,
+                        config->csv_output ? 0 : 4,
+                        nr,
+                        config->csv_sep);
+                        break;
+        case AGGR_NONE:
+                fprintf(config->output, "CPU%*d%s",
+                        config->csv_output ? 0 : -4,
+                        perf_evsel__cpus(evsel)->map[id], config->csv_sep);
+                break;
+        case AGGR_THREAD:
+                fprintf(config->output, "%*s-%*d%s",
+                        config->csv_output ? 0 : 16,
+                        thread_map__comm(evsel->threads, id),
+                        config->csv_output ? 0 : -8,
+                        thread_map__pid(evsel->threads, id),
+                        config->csv_sep);
+                break;
+        case AGGR_GLOBAL:
+        case AGGR_UNSET:
+        default:
+                break;
+        }
+}
+
+struct outstate {
+        FILE *fh;
+        bool newline;
+        const char *prefix;
+        int  nfields;
+        int  id, nr;
+        struct perf_evsel *evsel;
+};
+
+#define METRIC_LEN  35
+
+static void new_line_std(struct perf_stat_config *config __maybe_unused,
+                         void *ctx)
+{
+        struct outstate *os = ctx;
+
+        os->newline = true;
+}
+
+static void do_new_line_std(struct perf_stat_config *config,
+                            struct outstate *os)
+{
+        fputc('\n', os->fh);
+        fputs(os->prefix, os->fh);
+        aggr_printout(config, os->evsel, os->id, os->nr);
+        if (config->aggr_mode == AGGR_NONE)
+                fprintf(os->fh, "        ");
+        fprintf(os->fh, "                                                 ");
+}
+
+static void print_metric_std(struct perf_stat_config *config,
+                             void *ctx, const char *color, const char *fmt,
+                             const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        int n;
+        bool newline = os->newline;
+
+        os->newline = false;
+
+        if (unit == NULL || fmt == NULL) {
+                fprintf(out, "%-*s", METRIC_LEN, "");
+                return;
+        }
+
+        if (newline)
+                do_new_line_std(config, os);
+
+        n = fprintf(out, " # ");
+        if (color)
+                n += color_fprintf(out, color, fmt, val);
+        else
+                n += fprintf(out, fmt, val);
+        fprintf(out, " %-*s", METRIC_LEN - n - 1, unit);
+}
+
+static void new_line_csv(struct perf_stat_config *config, void *ctx)
+{
+        struct outstate *os = ctx;
+        int i;
+
+        fputc('\n', os->fh);
+        if (os->prefix)
+                fprintf(os->fh, "%s%s", os->prefix, config->csv_sep);
+        aggr_printout(config, os->evsel, os->id, os->nr);
+        for (i = 0; i < os->nfields; i++)
+                fputs(config->csv_sep, os->fh);
+}
+
+static void print_metric_csv(struct perf_stat_config *config __maybe_unused,
+                             void *ctx,
+                             const char *color __maybe_unused,
+                             const char *fmt, const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        char buf[64], *vals, *ends;
+
+        if (unit == NULL || fmt == NULL) {
+                fprintf(out, "%s%s", config->csv_sep, config->csv_sep);
+                return;
+        }
+        snprintf(buf, sizeof(buf), fmt, val);
+        ends = vals = ltrim(buf);
+        while (isdigit(*ends) || *ends == '.')
+                ends++;
+        *ends = 0;
+        while (isspace(*unit))
+                unit++;
+        fprintf(out, "%s%s%s%s", config->csv_sep, vals, config->csv_sep, unit);
+}
+
+/* Filter out some columns that don't work well in metrics only mode */
+
+static bool valid_only_metric(const char *unit)
+{
+        if (!unit)
+                return false;
+        if (strstr(unit, "/sec") ||
+            strstr(unit, "hz") ||
+            strstr(unit, "Hz") ||
+            strstr(unit, "CPUs utilized"))
+                return false;
+        return true;
+}
+
+static const char *fixunit(char *buf, struct perf_evsel *evsel,
+                           const char *unit)
+{
+        if (!strncmp(unit, "of all", 6)) {
+                snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel),
+                         unit);
+                return buf;
+        }
+        return unit;
+}
+
+static void print_metric_only(struct perf_stat_config *config,
+                              void *ctx, const char *color, const char *fmt,
+                              const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        char buf[1024], str[1024];
+        unsigned mlen = config->metric_only_len;
+
+        if (!valid_only_metric(unit))
+                return;
+        unit = fixunit(buf, os->evsel, unit);
+        if (mlen < strlen(unit))
+                mlen = strlen(unit) + 1;
+
+        if (color)
+                mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
+
+        color_snprintf(str, sizeof(str), color ?: "", fmt, val);
+        fprintf(out, "%*s ", mlen, str);
+}
+
+static void print_metric_only_csv(struct perf_stat_config *config __maybe_unused,
+                                  void *ctx, const char *color __maybe_unused,
+                                  const char *fmt,
+                                  const char *unit, double val)
+{
+        struct outstate *os = ctx;
+        FILE *out = os->fh;
+        char buf[64], *vals, *ends;
+        char tbuf[1024];
+
+        if (!valid_only_metric(unit))
+                return;
+        unit = fixunit(tbuf, os->evsel, unit);
+        snprintf(buf, sizeof buf, fmt, val);
+        ends = vals = ltrim(buf);
+        while (isdigit(*ends) || *ends == '.')
+                ends++;
+        *ends = 0;
+        fprintf(out, "%s%s", vals, config->csv_sep);
+}
+
+static void new_line_metric(struct perf_stat_config *config __maybe_unused,
+                            void *ctx __maybe_unused)
+{
+}
+
+static void print_metric_header(struct perf_stat_config *config,
+                                void *ctx, const char *color __maybe_unused,
+                                const char *fmt __maybe_unused,
+                                const char *unit, double val __maybe_unused)
+{
+        struct outstate *os = ctx;
+        char tbuf[1024];
+
+        if (!valid_only_metric(unit))
+                return;
+        unit = fixunit(tbuf, os->evsel, unit);
+        if (config->csv_output)
+                fprintf(os->fh, "%s%s", unit, config->csv_sep);
+        else
+                fprintf(os->fh, "%*s ", config->metric_only_len, unit);
+}
+
+static int first_shadow_cpu(struct perf_stat_config *config,
+                            struct perf_evsel *evsel, int id)
+{
+        struct perf_evlist *evlist = evsel->evlist;
+        int i;
+
+        if (!config->aggr_get_id)
+                return 0;
+
+        if (config->aggr_mode == AGGR_NONE)
+                return id;
+
+        if (config->aggr_mode == AGGR_GLOBAL)
+                return 0;
+
+        for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) {
+                int cpu2 = perf_evsel__cpus(evsel)->map[i];
+
+                if (config->aggr_get_id(config, evlist->cpus, cpu2) == id)
+                        return cpu2;
+        }
+        return 0;
+}
+
+static void abs_printout(struct perf_stat_config *config,
+                         int id, int nr, struct perf_evsel *evsel, double avg)
+{
+        FILE *output = config->output;
+        double sc =  evsel->scale;
+        const char *fmt;
+
+        if (config->csv_output) {
+                fmt = floor(sc) != sc ?  "%.2f%s" : "%.0f%s";
+        } else {
+                if (config->big_num)
+                        fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s";
+                else
+                        fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s";
+        }
+
+        aggr_printout(config, evsel, id, nr);
+
+        fprintf(output, fmt, avg, config->csv_sep);
+
+        if (evsel->unit)
+                fprintf(output, "%-*s%s",
+                        config->csv_output ? 0 : config->unit_width,
+                        evsel->unit, config->csv_sep);
+
+        fprintf(output, "%-*s", config->csv_output ? 0 : 25, perf_evsel__name(evsel));
+
+        if (evsel->cgrp)
+                fprintf(output, "%s%s", config->csv_sep, evsel->cgrp->name);
+}
+
+static bool is_mixed_hw_group(struct perf_evsel *counter)
+{
+        struct perf_evlist *evlist = counter->evlist;
+        u32 pmu_type = counter->attr.type;
+        struct perf_evsel *pos;
+
+        if (counter->nr_members < 2)
+                return false;
+
+        evlist__for_each_entry(evlist, pos) {
+                /* software events can be part of any hardware group */
+                if (pos->attr.type == PERF_TYPE_SOFTWARE)
+                        continue;
+                if (pmu_type == PERF_TYPE_SOFTWARE) {
+                        pmu_type = pos->attr.type;
+                        continue;
+                }
+                if (pmu_type != pos->attr.type)
+                        return true;
+        }
+
+        return false;
+}
+
+static void printout(struct perf_stat_config *config, int id, int nr,
+                     struct perf_evsel *counter, double uval,
+                     char *prefix, u64 run, u64 ena, double noise,
+                     struct runtime_stat *st)
+{
+        struct perf_stat_output_ctx out;
+        struct outstate os = {
+                .fh = config->output,
+                .prefix = prefix ? prefix : "",
+                .id = id,
+                .nr = nr,
+                .evsel = counter,
+        };
+        print_metric_t pm = print_metric_std;
+        new_line_t nl;
+
+        if (config->metric_only) {
+                nl = new_line_metric;
+                if (config->csv_output)
+                        pm = print_metric_only_csv;
+                else
+                        pm = print_metric_only;
+        } else
+                nl = new_line_std;
+
+        if (config->csv_output && !config->metric_only) {
+                static int aggr_fields[] = {
+                        [AGGR_GLOBAL] = 0,
+                        [AGGR_THREAD] = 1,
+                        [AGGR_NONE] = 1,
+                        [AGGR_SOCKET] = 2,
+                        [AGGR_CORE] = 2,
+                };
+
+                pm = print_metric_csv;
+                nl = new_line_csv;
+                os.nfields = 3;
+                os.nfields += aggr_fields[config->aggr_mode];
+                if (counter->cgrp)
+                        os.nfields++;
+        }
+        if (run == 0 || ena == 0 || counter->counts->scaled == -1) {
+                if (config->metric_only) {
+                        pm(config, &os, NULL, "", "", 0);
+                        return;
+                }
+                aggr_printout(config, counter, id, nr);
+
+                fprintf(config->output, "%*s%s",
+                        config->csv_output ? 0 : 18,
+                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
+                        config->csv_sep);
+
+                if (counter->supported) {
+                        config->print_free_counters_hint = 1;
+                        if (is_mixed_hw_group(counter))
+                                config->print_mixed_hw_group_error = 1;
+                }
+
+                fprintf(config->output, "%-*s%s",
+                        config->csv_output ? 0 : config->unit_width,
+                        counter->unit, config->csv_sep);
+
+                fprintf(config->output, "%*s",
+                        config->csv_output ? 0 : -25,
+                        perf_evsel__name(counter));
+
+                if (counter->cgrp)
+                        fprintf(config->output, "%s%s",
+                                config->csv_sep, counter->cgrp->name);
+
+                if (!config->csv_output)
+                        pm(config, &os, NULL, NULL, "", 0);
+                print_noise(config, counter, noise);
+                print_running(config, run, ena);
+                if (config->csv_output)
+                        pm(config, &os, NULL, NULL, "", 0);
+                return;
+        }
+
+        if (!config->metric_only)
+                abs_printout(config, id, nr, counter, uval);
+
+        out.print_metric = pm;
+        out.new_line = nl;
+        out.ctx = &os;
+        out.force_header = false;
+
+        if (config->csv_output && !config->metric_only) {
+                print_noise(config, counter, noise);
+                print_running(config, run, ena);
+        }
+
+        perf_stat__print_shadow_stats(config, counter, uval,
+                                first_shadow_cpu(config, counter, id),
+                                &out, &config->metric_events, st);
+        if (!config->csv_output && !config->metric_only) {
+                print_noise(config, counter, noise);
+                print_running(config, run, ena);
+        }
+}
+
+static void aggr_update_shadow(struct perf_stat_config *config,
+                               struct perf_evlist *evlist)
+{
+        int cpu, s2, id, s;
+        u64 val;
+        struct perf_evsel *counter;
+
+        for (s = 0; s < config->aggr_map->nr; s++) {
+                id = config->aggr_map->map[s];
+                evlist__for_each_entry(evlist, counter) {
+                        val = 0;
+                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                                s2 = config->aggr_get_id(config, evlist->cpus, cpu);
+                                if (s2 != id)
+                                        continue;
+                                val += perf_counts(counter->counts, cpu, 0)->val;
+                        }
+                        perf_stat__update_shadow_stats(counter, val,
+                                        first_shadow_cpu(config, counter, id),
+                                        &rt_stat);
+                }
+        }
+}
+
+static void uniquify_event_name(struct perf_evsel *counter)
+{
+        char *new_name;
+        char *config;
+
+        if (counter->uniquified_name ||
+            !counter->pmu_name || !strncmp(counter->name, counter->pmu_name,
+                                           strlen(counter->pmu_name)))
+                return;
+
+        config = strchr(counter->name, '/');
+        if (config) {
+                if (asprintf(&new_name,
+                             "%s%s", counter->pmu_name, config) > 0) {
+                        free(counter->name);
+                        counter->name = new_name;
+                }
+        } else {
+                if (asprintf(&new_name,
+                             "%s [%s]", counter->name, counter->pmu_name) > 0) {
+                        free(counter->name);
+                        counter->name = new_name;
+                }
+        }
+
+        counter->uniquified_name = true;
+}
+
+static void collect_all_aliases(struct perf_stat_config *config, struct perf_evsel *counter,
+                            void (*cb)(struct perf_stat_config *config, struct perf_evsel *counter, void *data,
+                                       bool first),
+                            void *data)
+{
+        struct perf_evlist *evlist = counter->evlist;
+        struct perf_evsel *alias;
+
+        alias = list_prepare_entry(counter, &(evlist->entries), node);
+        list_for_each_entry_continue (alias, &evlist->entries, node) {
+                if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
+                    alias->scale != counter->scale ||
+                    alias->cgrp != counter->cgrp ||
+                    strcmp(alias->unit, counter->unit) ||
+                    perf_evsel__is_clock(alias) != perf_evsel__is_clock(counter))
+                        break;
+                alias->merged_stat = true;
+                cb(config, alias, data, false);
+        }
+}
+
+static bool collect_data(struct perf_stat_config *config, struct perf_evsel *counter,
+                            void (*cb)(struct perf_stat_config *config, struct perf_evsel *counter, void *data,
+                                       bool first),
+                            void *data)
+{
+        if (counter->merged_stat)
+                return false;
+        cb(config, counter, data, true);
+        if (config->no_merge)
+                uniquify_event_name(counter);
+        else if (counter->auto_merge_stats)
+                collect_all_aliases(config, counter, cb, data);
+        return true;
+}
+
+struct aggr_data {
+        u64 ena, run, val;
+        int id;
+        int nr;
+        int cpu;
+};
+
+static void aggr_cb(struct perf_stat_config *config,
+                    struct perf_evsel *counter, void *data, bool first)
+{
+        struct aggr_data *ad = data;
+        int cpu, s2;
+
+        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                struct perf_counts_values *counts;
+
+                s2 = config->aggr_get_id(config, perf_evsel__cpus(counter), cpu);
+                if (s2 != ad->id)
+                        continue;
+                if (first)
+                        ad->nr++;
+                counts = perf_counts(counter->counts, cpu, 0);
+                /*
+                 * When any result is bad, make them all to give
+                 * consistent output in interval mode.
+                 */
+                if (counts->ena == 0 || counts->run == 0 ||
+                    counter->counts->scaled == -1) {
+                        ad->ena = 0;
+                        ad->run = 0;
+                        break;
+                }
+                ad->val += counts->val;
+                ad->ena += counts->ena;
+                ad->run += counts->run;
+        }
+}
+
+static void print_aggr(struct perf_stat_config *config,
+                       struct perf_evlist *evlist,
+                       char *prefix)
+{
+        bool metric_only = config->metric_only;
+        FILE *output = config->output;
+        struct perf_evsel *counter;
+        int s, id, nr;
+        double uval;
+        u64 ena, run, val;
+        bool first;
+
+        if (!(config->aggr_map || config->aggr_get_id))
+                return;
+
+        aggr_update_shadow(config, evlist);
+
+        /*
+         * With metric_only everything is on a single line.
+         * Without each counter has its own line.
+         */
+        for (s = 0; s < config->aggr_map->nr; s++) {
+                struct aggr_data ad;
+                if (prefix && metric_only)
+                        fprintf(output, "%s", prefix);
+
+                ad.id = id = config->aggr_map->map[s];
+                first = true;
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+
+                        ad.val = ad.ena = ad.run = 0;
+                        ad.nr = 0;
+                        if (!collect_data(config, counter, aggr_cb, &ad))
+                                continue;
+                        nr = ad.nr;
+                        ena = ad.ena;
+                        run = ad.run;
+                        val = ad.val;
+                        if (first && metric_only) {
+                                first = false;
+                                aggr_printout(config, counter, id, nr);
+                        }
+                        if (prefix && !metric_only)
+                                fprintf(output, "%s", prefix);
+
+                        uval = val * counter->scale;
+                        printout(config, id, nr, counter, uval, prefix,
+                                 run, ena, 1.0, &rt_stat);
+                        if (!metric_only)
+                                fputc('\n', output);
+                }
+                if (metric_only)
+                        fputc('\n', output);
+        }
+}
+
+static int cmp_val(const void *a, const void *b)
+{
+        return ((struct perf_aggr_thread_value *)b)->val -
+                ((struct perf_aggr_thread_value *)a)->val;
+}
+
+static struct perf_aggr_thread_value *sort_aggr_thread(
+                                        struct perf_evsel *counter,
+                                        int nthreads, int ncpus,
+                                        int *ret,
+                                        struct target *_target)
+{
+        int cpu, thread, i = 0;
+        double uval;
+        struct perf_aggr_thread_value *buf;
+
+        buf = calloc(nthreads, sizeof(struct perf_aggr_thread_value));
+        if (!buf)
+                return NULL;
+
+        for (thread = 0; thread < nthreads; thread++) {
+                u64 ena = 0, run = 0, val = 0;
+
+                for (cpu = 0; cpu < ncpus; cpu++) {
+                        val += perf_counts(counter->counts, cpu, thread)->val;
+                        ena += perf_counts(counter->counts, cpu, thread)->ena;
+                        run += perf_counts(counter->counts, cpu, thread)->run;
+                }
+
+                uval = val * counter->scale;
+
+                /*
+                 * Skip value 0 when enabling --per-thread globally,
+                 * otherwise too many 0 output.
+                 */
+                if (uval == 0.0 && target__has_per_thread(_target))
+                        continue;
+
+                buf[i].counter = counter;
+                buf[i].id = thread;
+                buf[i].uval = uval;
+                buf[i].val = val;
+                buf[i].run = run;
+                buf[i].ena = ena;
+                i++;
+        }
+
+        qsort(buf, i, sizeof(struct perf_aggr_thread_value), cmp_val);
+
+        if (ret)
+                *ret = i;
+
+        return buf;
+}
+
+static void print_aggr_thread(struct perf_stat_config *config,
+                              struct target *_target,
+                              struct perf_evsel *counter, char *prefix)
+{
+        FILE *output = config->output;
+        int nthreads = thread_map__nr(counter->threads);
+        int ncpus = cpu_map__nr(counter->cpus);
+        int thread, sorted_threads, id;
+        struct perf_aggr_thread_value *buf;
+
+        buf = sort_aggr_thread(counter, nthreads, ncpus, &sorted_threads, _target);
+        if (!buf) {
+                perror("cannot sort aggr thread");
+                return;
+        }
+
+        for (thread = 0; thread < sorted_threads; thread++) {
+                if (prefix)
+                        fprintf(output, "%s", prefix);
+
+                id = buf[thread].id;
+                if (config->stats)
+                        printout(config, id, 0, buf[thread].counter, buf[thread].uval,
+                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
+                                 &config->stats[id]);
+                else
+                        printout(config, id, 0, buf[thread].counter, buf[thread].uval,
+                                 prefix, buf[thread].run, buf[thread].ena, 1.0,
+                                 &rt_stat);
+                fputc('\n', output);
+        }
+
+        free(buf);
+}
+
+struct caggr_data {
+        double avg, avg_enabled, avg_running;
+};
+
+static void counter_aggr_cb(struct perf_stat_config *config __maybe_unused,
+                            struct perf_evsel *counter, void *data,
+                            bool first __maybe_unused)
+{
+        struct caggr_data *cd = data;
+        struct perf_stat_evsel *ps = counter->stats;
+
+        cd->avg += avg_stats(&ps->res_stats[0]);
+        cd->avg_enabled += avg_stats(&ps->res_stats[1]);
+        cd->avg_running += avg_stats(&ps->res_stats[2]);
+}
+
+/*
+ * Print out the results of a single counter:
+ * aggregated counts in system-wide mode
+ */
+static void print_counter_aggr(struct perf_stat_config *config,
+                               struct perf_evsel *counter, char *prefix)
+{
+        bool metric_only = config->metric_only;
+        FILE *output = config->output;
+        double uval;
+        struct caggr_data cd = { .avg = 0.0 };
+
+        if (!collect_data(config, counter, counter_aggr_cb, &cd))
+                return;
+
+        if (prefix && !metric_only)
+                fprintf(output, "%s", prefix);
+
+        uval = cd.avg * counter->scale;
+        printout(config, -1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
+                 cd.avg, &rt_stat);
+        if (!metric_only)
+                fprintf(output, "\n");
+}
+
+static void counter_cb(struct perf_stat_config *config __maybe_unused,
+                       struct perf_evsel *counter, void *data,
+                       bool first __maybe_unused)
+{
+        struct aggr_data *ad = data;
+
+        ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
+        ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
+        ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
+}
+
+/*
+ * Print out the results of a single counter:
+ * does not use aggregated count in system-wide
+ */
+static void print_counter(struct perf_stat_config *config,
+                          struct perf_evsel *counter, char *prefix)
+{
+        FILE *output = config->output;
+        u64 ena, run, val;
+        double uval;
+        int cpu;
+
+        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                struct aggr_data ad = { .cpu = cpu };
+
+                if (!collect_data(config, counter, counter_cb, &ad))
+                        return;
+                val = ad.val;
+                ena = ad.ena;
+                run = ad.run;
+
+                if (prefix)
+                        fprintf(output, "%s", prefix);
+
+                uval = val * counter->scale;
+                printout(config, cpu, 0, counter, uval, prefix, run, ena, 1.0,
+                         &rt_stat);
+
+                fputc('\n', output);
+        }
+}
+
+static void print_no_aggr_metric(struct perf_stat_config *config,
+                                 struct perf_evlist *evlist,
+                                 char *prefix)
+{
+        int cpu;
+        int nrcpus = 0;
+        struct perf_evsel *counter;
+        u64 ena, run, val;
+        double uval;
+
+        nrcpus = evlist->cpus->nr;
+        for (cpu = 0; cpu < nrcpus; cpu++) {
+                bool first = true;
+
+                if (prefix)
+                        fputs(prefix, config->output);
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+                        if (first) {
+                                aggr_printout(config, counter, cpu, 0);
+                                first = false;
+                        }
+                        val = perf_counts(counter->counts, cpu, 0)->val;
+                        ena = perf_counts(counter->counts, cpu, 0)->ena;
+                        run = perf_counts(counter->counts, cpu, 0)->run;
+
+                        uval = val * counter->scale;
+                        printout(config, cpu, 0, counter, uval, prefix, run, ena, 1.0,
+                                 &rt_stat);
+                }
+                fputc('\n', config->output);
+        }
+}
+
+static int aggr_header_lens[] = {
+        [AGGR_CORE] = 18,
+        [AGGR_SOCKET] = 12,
+        [AGGR_NONE] = 6,
+        [AGGR_THREAD] = 24,
+        [AGGR_GLOBAL] = 0,
+};
+
+static const char *aggr_header_csv[] = {
+        [AGGR_CORE]     =       "core,cpus,",
+        [AGGR_SOCKET]   =       "socket,cpus",
+        [AGGR_NONE]     =       "cpu,",
+        [AGGR_THREAD]   =       "comm-pid,",
+        [AGGR_GLOBAL]   =       ""
+};
+
+static void print_metric_headers(struct perf_stat_config *config,
+                                 struct perf_evlist *evlist,
+                                 const char *prefix, bool no_indent)
+{
+        struct perf_stat_output_ctx out;
+        struct perf_evsel *counter;
+        struct outstate os = {
+                .fh = config->output
+        };
+
+        if (prefix)
+                fprintf(config->output, "%s", prefix);
+
+        if (!config->csv_output && !no_indent)
+                fprintf(config->output, "%*s",
+                        aggr_header_lens[config->aggr_mode], "");
+        if (config->csv_output) {
+                if (config->interval)
+                        fputs("time,", config->output);
+                fputs(aggr_header_csv[config->aggr_mode], config->output);
+        }
+
+        /* Print metrics headers only */
+        evlist__for_each_entry(evlist, counter) {
+                if (is_duration_time(counter))
+                        continue;
+                os.evsel = counter;
+                out.ctx = &os;
+                out.print_metric = print_metric_header;
+                out.new_line = new_line_metric;
+                out.force_header = true;
+                os.evsel = counter;
+                perf_stat__print_shadow_stats(config, counter, 0,
+                                              0,
+                                              &out,
+                                              &config->metric_events,
+                                              &rt_stat);
+        }
+        fputc('\n', config->output);
+}
+
+static void print_interval(struct perf_stat_config *config,
+                           struct perf_evlist *evlist,
+                           char *prefix, struct timespec *ts)
+{
+        bool metric_only = config->metric_only;
+        unsigned int unit_width = config->unit_width;
+        FILE *output = config->output;
+        static int num_print_interval;
+
+        if (config->interval_clear)
+                puts(CONSOLE_CLEAR);
+
+        sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, config->csv_sep);
+
+        if ((num_print_interval == 0 && !config->csv_output) || config->interval_clear) {
+                switch (config->aggr_mode) {
+                case AGGR_SOCKET:
+                        fprintf(output, "#           time socket cpus");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_CORE:
+                        fprintf(output, "#           time core         cpus");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_NONE:
+                        fprintf(output, "#           time CPU    ");
+                        if (!metric_only)
+                                fprintf(output, "                counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_THREAD:
+                        fprintf(output, "#           time             comm-pid");
+                        if (!metric_only)
+                                fprintf(output, "                  counts %*s events\n", unit_width, "unit");
+                        break;
+                case AGGR_GLOBAL:
+                default:
+                        fprintf(output, "#           time");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
+                case AGGR_UNSET:
+                        break;
+                }
+        }
+
+        if ((num_print_interval == 0 || config->interval_clear) && metric_only)
+                print_metric_headers(config, evlist, " ", true);
+        if (++num_print_interval == 25)
+                num_print_interval = 0;
+}
+
+static void print_header(struct perf_stat_config *config,
+                         struct target *_target,
+                         int argc, const char **argv)
+{
+        FILE *output = config->output;
+        int i;
+
+        fflush(stdout);
+
+        if (!config->csv_output) {
+                fprintf(output, "\n");
+                fprintf(output, " Performance counter stats for ");
+                if (_target->system_wide)
+                        fprintf(output, "\'system wide");
+                else if (_target->cpu_list)
+                        fprintf(output, "\'CPU(s) %s", _target->cpu_list);
+                else if (!target__has_task(_target)) {
+                        fprintf(output, "\'%s", argv ? argv[0] : "pipe");
+                        for (i = 1; argv && (i < argc); i++)
+                                fprintf(output, " %s", argv[i]);
+                } else if (_target->pid)
+                        fprintf(output, "process id \'%s", _target->pid);
+                else
+                        fprintf(output, "thread id \'%s", _target->tid);
+
+                fprintf(output, "\'");
+                if (config->run_count > 1)
+                        fprintf(output, " (%d runs)", config->run_count);
+                fprintf(output, ":\n\n");
+        }
+}
+
+static int get_precision(double num)
+{
+        if (num > 1)
+                return 0;
+
+        return lround(ceil(-log10(num)));
+}
+
+static void print_table(struct perf_stat_config *config,
+                        FILE *output, int precision, double avg)
+{
+        char tmp[64];
+        int idx, indent = 0;
+
+        scnprintf(tmp, 64, " %17.*f", precision, avg);
+        while (tmp[indent] == ' ')
+                indent++;
+
+        fprintf(output, "%*s# Table of individual measurements:\n", indent, "");
+
+        for (idx = 0; idx < config->run_count; idx++) {
+                double run = (double) config->walltime_run[idx] / NSEC_PER_SEC;
+                int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);
+
+                fprintf(output, " %17.*f (%+.*f) ",
+                        precision, run, precision, run - avg);
+
+                for (h = 0; h < n; h++)
+                        fprintf(output, "#");
+
+                fprintf(output, "\n");
+        }
+
+        fprintf(output, "\n%*s# Final result:\n", indent, "");
+}
+
+static double timeval2double(struct timeval *t)
+{
+        return t->tv_sec + (double) t->tv_usec/USEC_PER_SEC;
+}
+
+static void print_footer(struct perf_stat_config *config)
+{
+        double avg = avg_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
+        FILE *output = config->output;
+        int n;
+
+        if (!config->null_run)
+                fprintf(output, "\n");
+
+        if (config->run_count == 1) {
+                fprintf(output, " %17.9f seconds time elapsed", avg);
+
+                if (config->ru_display) {
+                        double ru_utime = timeval2double(&config->ru_data.ru_utime);
+                        double ru_stime = timeval2double(&config->ru_data.ru_stime);
+
+                        fprintf(output, "\n\n");
+                        fprintf(output, " %17.9f seconds user\n", ru_utime);
+                        fprintf(output, " %17.9f seconds sys\n", ru_stime);
+                }
+        } else {
+                double sd = stddev_stats(config->walltime_nsecs_stats) / NSEC_PER_SEC;
+                /*
+                 * Display at most 2 more significant
+                 * digits than the stddev inaccuracy.
+                 */
+                int precision = get_precision(sd) + 2;
+
+                if (config->walltime_run_table)
+                        print_table(config, output, precision, avg);
+
+                fprintf(output, " %17.*f +- %.*f seconds time elapsed",
+                        precision, avg, precision, sd);
+
+                print_noise_pct(config, sd, avg);
+        }
+        fprintf(output, "\n\n");
+
+        if (config->print_free_counters_hint &&
+            sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
+            n > 0)
+                fprintf(output,
+"Some events weren't counted. Try disabling the NMI watchdog:\n"
+"       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
+"       perf stat ...\n"
+"       echo 1 > /proc/sys/kernel/nmi_watchdog\n");
+
+        if (config->print_mixed_hw_group_error)
+                fprintf(output,
+                        "The events in group usually have to be from "
+                        "the same PMU. Try reorganizing the group.\n");
+}
+
+void
+perf_evlist__print_counters(struct perf_evlist *evlist,
+                            struct perf_stat_config *config,
+                            struct target *_target,
+                            struct timespec *ts,
+                            int argc, const char **argv)
+{
+        bool metric_only = config->metric_only;
+        int interval = config->interval;
+        struct perf_evsel *counter;
+        char buf[64], *prefix = NULL;
+
+        if (interval)
+                print_interval(config, evlist, prefix = buf, ts);
+        else
+                print_header(config, _target, argc, argv);
+
+        if (metric_only) {
+                static int num_print_iv;
+
+                if (num_print_iv == 0 && !interval)
+                        print_metric_headers(config, evlist, prefix, false);
+                if (num_print_iv++ == 25)
+                        num_print_iv = 0;
+                if (config->aggr_mode == AGGR_GLOBAL && prefix)
+                        fprintf(config->output, "%s", prefix);
+        }
+
+        switch (config->aggr_mode) {
+        case AGGR_CORE:
+        case AGGR_SOCKET:
+                print_aggr(config, evlist, prefix);
+                break;
+        case AGGR_THREAD:
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+                        print_aggr_thread(config, _target, counter, prefix);
+                }
+                break;
+        case AGGR_GLOBAL:
+                evlist__for_each_entry(evlist, counter) {
+                        if (is_duration_time(counter))
+                                continue;
+                        print_counter_aggr(config, counter, prefix);
+                }
+                if (metric_only)
+                        fputc('\n', config->output);
+                break;
+        case AGGR_NONE:
+                if (metric_only)
+                        print_no_aggr_metric(config, evlist, prefix);
+                else {
+                        evlist__for_each_entry(evlist, counter) {
+                                if (is_duration_time(counter))
+                                        continue;
+                                print_counter(config, counter, prefix);
+                        }
+                }
+                break;
+        case AGGR_UNSET:
+        default:
+                break;
+        }
+
+        if (!interval && !config->csv_output)
+                print_footer(config);
+
+        fflush(config->output);
+}
diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index 99990f5f2512..8ad32763cfff 100644
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -410,7 +410,8 @@ static double runtime_stat_n(struct runtime_stat *st,
         return v->stats.n;
 }
 
-static void print_stalled_cycles_frontend(int cpu,
+static void print_stalled_cycles_frontend(struct perf_stat_config *config,
+                                          int cpu,
                                           struct perf_evsel *evsel, double avg,
                                           struct perf_stat_output_ctx *out,
                                           struct runtime_stat *st)
@@ -427,13 +428,14 @@ static void print_stalled_cycles_frontend(int cpu,
         color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio);
 
         if (ratio)
-                out->print_metric(out->ctx, color, "%7.2f%%", "frontend cycles idle",
+                out->print_metric(config, out->ctx, color, "%7.2f%%", "frontend cycles idle",
                                   ratio);
         else
-                out->print_metric(out->ctx, NULL, NULL, "frontend cycles idle", 0);
+                out->print_metric(config, out->ctx, NULL, NULL, "frontend cycles idle", 0);
 }
 
-static void print_stalled_cycles_backend(int cpu,
+static void print_stalled_cycles_backend(struct perf_stat_config *config,
+                                         int cpu,
                                          struct perf_evsel *evsel, double avg,
                                          struct perf_stat_output_ctx *out,
                                          struct runtime_stat *st)
@@ -449,10 +451,11 @@ static void print_stalled_cycles_backend(int cpu,
 
         color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio);
 
-        out->print_metric(out->ctx, color, "%7.2f%%", "backend cycles idle", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "backend cycles idle", ratio);
 }
 
-static void print_branch_misses(int cpu,
+static void print_branch_misses(struct perf_stat_config *config,
+                                int cpu,
                                 struct perf_evsel *evsel,
                                 double avg,
                                 struct perf_stat_output_ctx *out,
@@ -469,10 +472,11 @@ static void print_branch_misses(int cpu,
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all branches", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all branches", ratio);
 }
 
-static void print_l1_dcache_misses(int cpu,
+static void print_l1_dcache_misses(struct perf_stat_config *config,
+                                   int cpu,
                                    struct perf_evsel *evsel,
                                    double avg,
                                    struct perf_stat_output_ctx *out,
@@ -490,10 +494,11 @@ static void print_l1_dcache_misses(int cpu,
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
 
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all L1-dcache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all L1-dcache hits", ratio);
 }
 
-static void print_l1_icache_misses(int cpu,
+static void print_l1_icache_misses(struct perf_stat_config *config,
+                                   int cpu,
                                    struct perf_evsel *evsel,
                                    double avg,
                                    struct perf_stat_output_ctx *out,
@@ -510,10 +515,11 @@ static void print_l1_icache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all L1-icache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all L1-icache hits", ratio);
 }
 
-static void print_dtlb_cache_misses(int cpu,
+static void print_dtlb_cache_misses(struct perf_stat_config *config,
+                                    int cpu,
                                     struct perf_evsel *evsel,
                                     double avg,
                                     struct perf_stat_output_ctx *out,
@@ -529,10 +535,11 @@ static void print_dtlb_cache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all dTLB cache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all dTLB cache hits", ratio);
 }
 
-static void print_itlb_cache_misses(int cpu,
+static void print_itlb_cache_misses(struct perf_stat_config *config,
+                                    int cpu,
                                     struct perf_evsel *evsel,
                                     double avg,
                                     struct perf_stat_output_ctx *out,
@@ -548,10 +555,11 @@ static void print_itlb_cache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all iTLB cache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all iTLB cache hits", ratio);
 }
 
-static void print_ll_cache_misses(int cpu,
+static void print_ll_cache_misses(struct perf_stat_config *config,
+                                  int cpu,
                                   struct perf_evsel *evsel,
                                   double avg,
                                   struct perf_stat_output_ctx *out,
@@ -567,7 +575,7 @@ static void print_ll_cache_misses(int cpu,
                 ratio = avg / total * 100.0;
 
         color = get_ratio_color(GRC_CACHE_MISSES, ratio);
-        out->print_metric(out->ctx, color, "%7.2f%%", "of all LL-cache hits", ratio);
+        out->print_metric(config, out->ctx, color, "%7.2f%%", "of all LL-cache hits", ratio);
 }
 
 /*
@@ -674,7 +682,8 @@ static double td_be_bound(int ctx, int cpu, struct runtime_stat *st)
         return sanitize_val(1.0 - sum);
 }
 
-static void print_smi_cost(int cpu, struct perf_evsel *evsel,
+static void print_smi_cost(struct perf_stat_config *config,
+                           int cpu, struct perf_evsel *evsel,
                            struct perf_stat_output_ctx *out,
                            struct runtime_stat *st)
 {
@@ -694,11 +703,12 @@ static void print_smi_cost(int cpu, struct perf_evsel *evsel,
 
         if (cost > 10)
                 color = PERF_COLOR_RED;
-        out->print_metric(out->ctx, color, "%8.1f%%", "SMI cycles%", cost);
-        out->print_metric(out->ctx, NULL, "%4.0f", "SMI#", smi_num);
+        out->print_metric(config, out->ctx, color, "%8.1f%%", "SMI cycles%", cost);
+        out->print_metric(config, out->ctx, NULL, "%4.0f", "SMI#", smi_num);
 }
 
-static void generic_metric(const char *metric_expr,
+static void generic_metric(struct perf_stat_config *config,
+                           const char *metric_expr,
                            struct perf_evsel **metric_events,
                            char *name,
                            const char *metric_name,
@@ -737,20 +747,21 @@ static void generic_metric(const char *metric_expr,
                 const char *p = metric_expr;
 
                 if (expr__parse(&ratio, &pctx, &p) == 0)
-                        print_metric(ctxp, NULL, "%8.1f",
+                        print_metric(config, ctxp, NULL, "%8.1f",
                                 metric_name ?
                                 metric_name :
                                 out->force_header ?  name : "",
                                 ratio);
                 else
-                        print_metric(ctxp, NULL, NULL,
+                        print_metric(config, ctxp, NULL, NULL,
                                      out->force_header ?
                                      (metric_name ? metric_name : name) : "", 0);
         } else
-                print_metric(ctxp, NULL, NULL, "", 0);
+                print_metric(config, ctxp, NULL, NULL, "", 0);
 }
 
-void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
+void perf_stat__print_shadow_stats(struct perf_stat_config *config,
+                                   struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out,
                                    struct rblist *metric_events,
@@ -769,10 +780,10 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
 
                 if (total) {
                         ratio = avg / total;
-                        print_metric(ctxp, NULL, "%7.2f ",
+                        print_metric(config, ctxp, NULL, "%7.2f ",
                                         "insn per cycle", ratio);
                 } else {
-                        print_metric(ctxp, NULL, NULL, "insn per cycle", 0);
+                        print_metric(config, ctxp, NULL, NULL, "insn per cycle", 0);
                 }
 
                 total = runtime_stat_avg(st, STAT_STALLED_CYCLES_FRONT,
@@ -783,20 +794,20 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                                     ctx, cpu));
 
                 if (total && avg) {
-                        out->new_line(ctxp);
+                        out->new_line(config, ctxp);
                         ratio = total / avg;
-                        print_metric(ctxp, NULL, "%7.2f ",
+                        print_metric(config, ctxp, NULL, "%7.2f ",
                                         "stalled cycles per insn",
                                         ratio);
                 } else if (have_frontend_stalled) {
-                        print_metric(ctxp, NULL, NULL,
+                        print_metric(config, ctxp, NULL, NULL,
                                      "stalled cycles per insn", 0);
                 }
         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES)) {
                 if (runtime_stat_n(st, STAT_BRANCHES, ctx, cpu) != 0)
-                        print_branch_misses(cpu, evsel, avg, out, st);
+                        print_branch_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all branches", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all branches", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1D |
@@ -804,9 +815,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_L1_DCACHE, ctx, cpu) != 0)
-                        print_l1_dcache_misses(cpu, evsel, avg, out, st);
+                        print_l1_dcache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all L1-dcache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all L1-dcache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_L1I |
@@ -814,9 +825,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_L1_ICACHE, ctx, cpu) != 0)
-                        print_l1_icache_misses(cpu, evsel, avg, out, st);
+                        print_l1_icache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all L1-icache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all L1-icache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_DTLB |
@@ -824,9 +835,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_DTLB_CACHE, ctx, cpu) != 0)
-                        print_dtlb_cache_misses(cpu, evsel, avg, out, st);
+                        print_dtlb_cache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all dTLB cache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all dTLB cache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_ITLB |
@@ -834,9 +845,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_ITLB_CACHE, ctx, cpu) != 0)
-                        print_itlb_cache_misses(cpu, evsel, avg, out, st);
+                        print_itlb_cache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all iTLB cache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all iTLB cache hits", 0);
         } else if (
                 evsel->attr.type == PERF_TYPE_HW_CACHE &&
                 evsel->attr.config ==  ( PERF_COUNT_HW_CACHE_LL |
@@ -844,9 +855,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                          ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
 
                 if (runtime_stat_n(st, STAT_LL_CACHE, ctx, cpu) != 0)
-                        print_ll_cache_misses(cpu, evsel, avg, out, st);
+                        print_ll_cache_misses(config, cpu, evsel, avg, out, st);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all LL-cache hits", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all LL-cache hits", 0);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES)) {
                 total = runtime_stat_avg(st, STAT_CACHEREFS, ctx, cpu);
 
@@ -854,32 +865,32 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                         ratio = avg * 100 / total;
 
                 if (runtime_stat_n(st, STAT_CACHEREFS, ctx, cpu) != 0)
-                        print_metric(ctxp, NULL, "%8.3f %%",
+                        print_metric(config, ctxp, NULL, "%8.3f %%",
                                      "of all cache refs", ratio);
                 else
-                        print_metric(ctxp, NULL, NULL, "of all cache refs", 0);
+                        print_metric(config, ctxp, NULL, NULL, "of all cache refs", 0);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
-                print_stalled_cycles_frontend(cpu, evsel, avg, out, st);
+                print_stalled_cycles_frontend(config, cpu, evsel, avg, out, st);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
-                print_stalled_cycles_backend(cpu, evsel, avg, out, st);
+                print_stalled_cycles_backend(config, cpu, evsel, avg, out, st);
         } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
                 total = runtime_stat_avg(st, STAT_NSECS, 0, cpu);
 
                 if (total) {
                         ratio = avg / total;
-                        print_metric(ctxp, NULL, "%8.3f", "GHz", ratio);
+                        print_metric(config, ctxp, NULL, "%8.3f", "GHz", ratio);
                 } else {
-                        print_metric(ctxp, NULL, NULL, "Ghz", 0);
+                        print_metric(config, ctxp, NULL, NULL, "Ghz", 0);
                 }
         } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) {
                 total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
 
                 if (total)
-                        print_metric(ctxp, NULL,
+                        print_metric(config, ctxp, NULL,
                                         "%7.2f%%", "transactional cycles",
                                         100.0 * (avg / total));
                 else
-                        print_metric(ctxp, NULL, NULL, "transactional cycles",
+                        print_metric(config, ctxp, NULL, NULL, "transactional cycles",
                                      0);
         } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) {
                 total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
@@ -888,10 +899,10 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 if (total2 < avg)
                         total2 = avg;
                 if (total)
-                        print_metric(ctxp, NULL, "%7.2f%%", "aborted cycles",
+                        print_metric(config, ctxp, NULL, "%7.2f%%", "aborted cycles",
                                 100.0 * ((total2-avg) / total));
                 else
-                        print_metric(ctxp, NULL, NULL, "aborted cycles", 0);
+                        print_metric(config, ctxp, NULL, NULL, "aborted cycles", 0);
         } else if (perf_stat_evsel__is(evsel, TRANSACTION_START)) {
                 total = runtime_stat_avg(st, STAT_CYCLES_IN_TX,
                                          ctx, cpu);
@@ -900,10 +911,10 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                         ratio = total / avg;
 
                 if (runtime_stat_n(st, STAT_CYCLES_IN_TX, ctx, cpu) != 0)
-                        print_metric(ctxp, NULL, "%8.0f",
+                        print_metric(config, ctxp, NULL, "%8.0f",
                                      "cycles / transaction", ratio);
                 else
-                        print_metric(ctxp, NULL, NULL, "cycles / transaction",
+                        print_metric(config, ctxp, NULL, NULL, "cycles / transaction",
                                       0);
         } else if (perf_stat_evsel__is(evsel, ELISION_START)) {
                 total = runtime_stat_avg(st, STAT_CYCLES_IN_TX,
@@ -912,33 +923,33 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 if (avg)
                         ratio = total / avg;
 
-                print_metric(ctxp, NULL, "%8.0f", "cycles / elision", ratio);
+                print_metric(config, ctxp, NULL, "%8.0f", "cycles / elision", ratio);
         } else if (perf_evsel__is_clock(evsel)) {
                 if ((ratio = avg_stats(&walltime_nsecs_stats)) != 0)
-                        print_metric(ctxp, NULL, "%8.3f", "CPUs utilized",
+                        print_metric(config, ctxp, NULL, "%8.3f", "CPUs utilized",
                                      avg / (ratio * evsel->scale));
                 else
-                        print_metric(ctxp, NULL, NULL, "CPUs utilized", 0);
+                        print_metric(config, ctxp, NULL, NULL, "CPUs utilized", 0);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_FETCH_BUBBLES)) {
                 double fe_bound = td_fe_bound(ctx, cpu, st);
 
                 if (fe_bound > 0.2)
                         color = PERF_COLOR_RED;
-                print_metric(ctxp, color, "%8.1f%%", "frontend bound",
+                print_metric(config, ctxp, color, "%8.1f%%", "frontend bound",
                                 fe_bound * 100.);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_RETIRED)) {
                 double retiring = td_retiring(ctx, cpu, st);
 
                 if (retiring > 0.7)
                         color = PERF_COLOR_GREEN;
-                print_metric(ctxp, color, "%8.1f%%", "retiring",
+                print_metric(config, ctxp, color, "%8.1f%%", "retiring",
                                 retiring * 100.);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_RECOVERY_BUBBLES)) {
                 double bad_spec = td_bad_spec(ctx, cpu, st);
 
                 if (bad_spec > 0.1)
                         color = PERF_COLOR_RED;
-                print_metric(ctxp, color, "%8.1f%%", "bad speculation",
+                print_metric(config, ctxp, color, "%8.1f%%", "bad speculation",
                                 bad_spec * 100.);
         } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_ISSUED)) {
                 double be_bound = td_be_bound(ctx, cpu, st);
@@ -955,12 +966,12 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 if (be_bound > 0.2)
                         color = PERF_COLOR_RED;
                 if (td_total_slots(ctx, cpu, st) > 0)
-                        print_metric(ctxp, color, "%8.1f%%", name,
+                        print_metric(config, ctxp, color, "%8.1f%%", name,
                                         be_bound * 100.);
                 else
-                        print_metric(ctxp, NULL, NULL, name, 0);
+                        print_metric(config, ctxp, NULL, NULL, name, 0);
         } else if (evsel->metric_expr) {
-                generic_metric(evsel->metric_expr, evsel->metric_events, evsel->name,
+                generic_metric(config, evsel->metric_expr, evsel->metric_events, evsel->name,
                                 evsel->metric_name, avg, cpu, out, st);
         } else if (runtime_stat_n(st, STAT_NSECS, 0, cpu) != 0) {
                 char unit = 'M';
@@ -975,9 +986,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                         unit = 'K';
                 }
                 snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit);
-                print_metric(ctxp, NULL, "%8.3f", unit_buf, ratio);
+                print_metric(config, ctxp, NULL, "%8.3f", unit_buf, ratio);
         } else if (perf_stat_evsel__is(evsel, SMI_NUM)) {
-                print_smi_cost(cpu, evsel, out, st);
+                print_smi_cost(config, cpu, evsel, out, st);
         } else {
                 num = 0;
         }
@@ -987,12 +998,12 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
 
                 list_for_each_entry (mexp, &me->head, nd) {
                         if (num++ > 0)
-                                out->new_line(ctxp);
-                        generic_metric(mexp->metric_expr, mexp->metric_events,
+                                out->new_line(config, ctxp);
+                        generic_metric(config, mexp->metric_expr, mexp->metric_events,
                                         evsel->name, mexp->metric_name,
                                         avg, cpu, out, st);
                 }
         }
         if (num == 0)
-                print_metric(ctxp, NULL, NULL, NULL, 0);
+                print_metric(config, ctxp, NULL, NULL, NULL, 0);
 }
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index a0061e0b0fad..4d40515307b8 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -374,9 +374,8 @@ int perf_stat_process_counter(struct perf_stat_config *config,
         return 0;
 }
 
-int perf_event__process_stat_event(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event,
-                                   struct perf_session *session)
+int perf_event__process_stat_event(struct perf_session *session,
+                                   union perf_event *event)
 {
         struct perf_counts_values count;
         struct stat_event *st = &event->stat;
@@ -435,3 +434,98 @@ size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp)
 
         return ret;
 }
+
+int create_perf_stat_counter(struct perf_evsel *evsel,
+                             struct perf_stat_config *config,
+                             struct target *target)
+{
+        struct perf_event_attr *attr = &evsel->attr;
+        struct perf_evsel *leader = evsel->leader;
+
+        if (config->scale) {
+                attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
+                                    PERF_FORMAT_TOTAL_TIME_RUNNING;
+        }
+
+        /*
+         * The event is part of non trivial group, let's enable
+         * the group read (for leader) and ID retrieval for all
+         * members.
+         */
+        if (leader->nr_members > 1)
+                attr->read_format |= PERF_FORMAT_ID|PERF_FORMAT_GROUP;
+
+        attr->inherit = !config->no_inherit;
+
+        /*
+         * Some events get initialized with sample_(period/type) set,
+         * like tracepoints. Clear it up for counting.
+         */
+        attr->sample_period = 0;
+
+        if (config->identifier)
+                attr->sample_type = PERF_SAMPLE_IDENTIFIER;
+
+        /*
+         * Disabling all counters initially, they will be enabled
+         * either manually by us or by kernel via enable_on_exec
+         * set later.
+         */
+        if (perf_evsel__is_group_leader(evsel)) {
+                attr->disabled = 1;
+
+                /*
+                 * In case of initial_delay we enable tracee
+                 * events manually.
+                 */
+                if (target__none(target) && !config->initial_delay)
+                        attr->enable_on_exec = 1;
+        }
+
+        if (target__has_cpu(target) && !target__has_per_thread(target))
+                return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
+
+        return perf_evsel__open_per_thread(evsel, evsel->threads);
+}
+
+int perf_stat_synthesize_config(struct perf_stat_config *config,
+                                struct perf_tool *tool,
+                                struct perf_evlist *evlist,
+                                perf_event__handler_t process,
+                                bool attrs)
+{
+        int err;
+
+        if (attrs) {
+                err = perf_event__synthesize_attrs(tool, evlist, process);
+                if (err < 0) {
+                        pr_err("Couldn't synthesize attrs.\n");
+                        return err;
+                }
+        }
+
+        err = perf_event__synthesize_extra_attr(tool, evlist, process,
+                                                attrs);
+
+        err = perf_event__synthesize_thread_map2(tool, evlist->threads,
+                                                 process, NULL);
+        if (err < 0) {
+                pr_err("Couldn't synthesize thread map.\n");
+                return err;
+        }
+
+        err = perf_event__synthesize_cpu_map(tool, evlist->cpus,
+                                             process, NULL);
+        if (err < 0) {
+                pr_err("Couldn't synthesize thread map.\n");
+                return err;
+        }
+
+        err = perf_event__synthesize_stat_config(tool, config, process, NULL);
+        if (err < 0) {
+                pr_err("Couldn't synthesize config.\n");
+                return err;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
index 36efb986f7fc..2f9c9159a364 100644
--- a/tools/perf/util/stat.h
+++ b/tools/perf/util/stat.h
@@ -4,8 +4,14 @@
 
 #include <linux/types.h>
 #include <stdio.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
 #include "xyarray.h"
 #include "rblist.h"
+#include "perf.h"
+#include "event.h"
 
 struct stats {
         double n, mean, M2;
@@ -84,15 +90,42 @@ struct runtime_stat {
         struct rblist value_list;
 };
 
+typedef int (*aggr_get_id_t)(struct perf_stat_config *config,
+                             struct cpu_map *m, int cpu);
+
 struct perf_stat_config {
-        enum aggr_mode  aggr_mode;
-        bool            scale;
-        FILE            *output;
-        unsigned int    interval;
-        unsigned int    timeout;
-        int             times;
-        struct runtime_stat *stats;
-        int             stats_num;
+        enum aggr_mode           aggr_mode;
+        bool                     scale;
+        bool                     no_inherit;
+        bool                     identifier;
+        bool                     csv_output;
+        bool                     interval_clear;
+        bool                     metric_only;
+        bool                     null_run;
+        bool                     ru_display;
+        bool                     big_num;
+        bool                     no_merge;
+        bool                     walltime_run_table;
+        FILE                    *output;
+        unsigned int             interval;
+        unsigned int             timeout;
+        unsigned int             initial_delay;
+        unsigned int             unit_width;
+        unsigned int             metric_only_len;
+        int                      times;
+        int                      run_count;
+        int                      print_free_counters_hint;
+        int                      print_mixed_hw_group_error;
+        struct runtime_stat     *stats;
+        int                      stats_num;
+        const char              *csv_sep;
+        struct stats            *walltime_nsecs_stats;
+        struct rusage            ru_data;
+        struct cpu_map          *aggr_map;
+        aggr_get_id_t            aggr_get_id;
+        struct cpu_map          *cpus_aggr_map;
+        u64                     *walltime_run;
+        struct rblist            metric_events;
 };
 
 void update_stats(struct stats *stats, u64 val);
@@ -130,9 +163,10 @@ bool __perf_evsel_stat__is(struct perf_evsel *evsel,
 extern struct runtime_stat rt_stat;
 extern struct stats walltime_nsecs_stats;
 
-typedef void (*print_metric_t)(void *ctx, const char *color, const char *unit,
+typedef void (*print_metric_t)(struct perf_stat_config *config,
+                               void *ctx, const char *color, const char *unit,
                                const char *fmt, double val);
-typedef void (*new_line_t )(void *ctx);
+typedef void (*new_line_t)(struct perf_stat_config *config, void *ctx);
 
 void runtime_stat__init(struct runtime_stat *st);
 void runtime_stat__exit(struct runtime_stat *st);
@@ -148,7 +182,8 @@ struct perf_stat_output_ctx {
         bool force_header;
 };
 
-void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
+void perf_stat__print_shadow_stats(struct perf_stat_config *config,
+                                   struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out,
                                    struct rblist *metric_events,
@@ -164,11 +199,25 @@ int perf_stat_process_counter(struct perf_stat_config *config,
 struct perf_tool;
 union perf_event;
 struct perf_session;
-int perf_event__process_stat_event(struct perf_tool *tool,
-                                   union perf_event *event,
-                                   struct perf_session *session);
+int perf_event__process_stat_event(struct perf_session *session,
+                                   union perf_event *event);
 
 size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp);
+
+int create_perf_stat_counter(struct perf_evsel *evsel,
+                             struct perf_stat_config *config,
+                             struct target *target);
+int perf_stat_synthesize_config(struct perf_stat_config *config,
+                                struct perf_tool *tool,
+                                struct perf_evlist *evlist,
+                                perf_event__handler_t process,
+                                bool attrs);
+void
+perf_evlist__print_counters(struct perf_evlist *evlist,
+                            struct perf_stat_config *config,
+                            struct target *_target,
+                            struct timespec *ts,
+                            int argc, const char **argv);
 #endif
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 3d1cf5bf7f18..9005fbe0780e 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -98,19 +98,25 @@ static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap)
 
         va_copy(ap_saved, ap);
         len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
-        if (len < 0)
+        if (len < 0) {
+                va_end(ap_saved);
                 return len;
+        }
         if (len > strbuf_avail(sb)) {
                 ret = strbuf_grow(sb, len);
-                if (ret)
+                if (ret) {
+                        va_end(ap_saved);
                         return ret;
+                }
                 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved);
                 va_end(ap_saved);
                 if (len > strbuf_avail(sb)) {
                         pr_debug("this should not happen, your vsnprintf is broken");
+                        va_end(ap_saved);
                         return -EINVAL;
                 }
         }
+        va_end(ap_saved);
         return strbuf_setlen(sb, sb->len + len);
 }
 
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 29770ea61768..66a84d5846c8 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -324,7 +324,17 @@ int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss)
                         plt_entry_size = 16;
                         break;
 
-                default: /* FIXME: s390/alpha/mips/parisc/poperpc/sh/sparc/xtensa need to be checked */
+                case EM_SPARC:
+                        plt_header_size = 48;
+                        plt_entry_size = 12;
+                        break;
+
+                case EM_SPARCV9:
+                        plt_header_size = 128;
+                        plt_entry_size = 32;
+                        break;
+
+                default: /* FIXME: s390/alpha/mips/parisc/poperpc/sh/xtensa need to be checked */
                         plt_header_size = shdr_plt.sh_entsize;
                         plt_entry_size = shdr_plt.sh_entsize;
                         break;
@@ -1947,6 +1957,34 @@ void kcore_extract__delete(struct kcore_extract *kce)
 }
 
 #ifdef HAVE_GELF_GETNOTE_SUPPORT
+
+static void sdt_adjust_loc(struct sdt_note *tmp, GElf_Addr base_off)
+{
+        if (!base_off)
+                return;
+
+        if (tmp->bit32)
+                tmp->addr.a32[SDT_NOTE_IDX_LOC] =
+                        tmp->addr.a32[SDT_NOTE_IDX_LOC] + base_off -
+                        tmp->addr.a32[SDT_NOTE_IDX_BASE];
+        else
+                tmp->addr.a64[SDT_NOTE_IDX_LOC] =
+                        tmp->addr.a64[SDT_NOTE_IDX_LOC] + base_off -
+                        tmp->addr.a64[SDT_NOTE_IDX_BASE];
+}
+
+static void sdt_adjust_refctr(struct sdt_note *tmp, GElf_Addr base_addr,
+                              GElf_Addr base_off)
+{
+        if (!base_off)
+                return;
+
+        if (tmp->bit32 && tmp->addr.a32[SDT_NOTE_IDX_REFCTR])
+                tmp->addr.a32[SDT_NOTE_IDX_REFCTR] -= (base_addr - base_off);
+        else if (tmp->addr.a64[SDT_NOTE_IDX_REFCTR])
+                tmp->addr.a64[SDT_NOTE_IDX_REFCTR] -= (base_addr - base_off);
+}
+
 /**
  * populate_sdt_note : Parse raw data and identify SDT note
  * @elf: elf of the opened file
@@ -1964,7 +2002,6 @@ static int populate_sdt_note(Elf **elf, const char *data, size_t len,
         const char *provider, *name, *args;
         struct sdt_note *tmp = NULL;
         GElf_Ehdr ehdr;
-        GElf_Addr base_off = 0;
         GElf_Shdr shdr;
         int ret = -EINVAL;
 
@@ -2060,17 +2097,12 @@ static int populate_sdt_note(Elf **elf, const char *data, size_t len,
          * base address in the description of the SDT note. If its different,
          * then accordingly, adjust the note location.
          */
-        if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_BASE_SCN, NULL)) {
-                base_off = shdr.sh_offset;
-                if (base_off) {
-                        if (tmp->bit32)
-                                tmp->addr.a32[0] = tmp->addr.a32[0] + base_off -
-                                        tmp->addr.a32[1];
-                        else
-                                tmp->addr.a64[0] = tmp->addr.a64[0] + base_off -
-                                        tmp->addr.a64[1];
-                }
-        }
+        if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_BASE_SCN, NULL))
+                sdt_adjust_loc(tmp, shdr.sh_offset);
+
+        /* Adjust reference counter offset */
+        if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_PROBES_SCN, NULL))
+                sdt_adjust_refctr(tmp, shdr.sh_addr, shdr.sh_offset);
 
         list_add_tail(&tmp->note_list, sdt_notes);
         return 0;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index f25fae4b5743..d026d215bdc6 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -123,7 +123,8 @@ struct symbol_conf {
         const char      *vmlinux_name,
                         *kallsyms_name,
                         *source_prefix,
-                        *field_sep;
+                        *field_sep,
+                        *graph_function;
         const char      *default_guest_vmlinux_name,
                         *default_guest_kallsyms,
                         *default_guest_modules;
@@ -379,12 +380,19 @@ int get_sdt_note_list(struct list_head *head, const char *target);
 int cleanup_sdt_note_list(struct list_head *sdt_notes);
 int sdt_notes__get_count(struct list_head *start);
 
+#define SDT_PROBES_SCN ".probes"
 #define SDT_BASE_SCN ".stapsdt.base"
 #define SDT_NOTE_SCN  ".note.stapsdt"
 #define SDT_NOTE_TYPE 3
 #define SDT_NOTE_NAME "stapsdt"
 #define NR_ADDR 3
 
+enum {
+        SDT_NOTE_IDX_LOC = 0,
+        SDT_NOTE_IDX_BASE,
+        SDT_NOTE_IDX_REFCTR,
+};
+
 struct mem_info *mem_info__new(void);
 struct mem_info *mem_info__get(struct mem_info *mi);
 void   mem_info__put(struct mem_info *mi);
diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c
index dd17d6a38d3a..61a4286a74dc 100644
--- a/tools/perf/util/thread-stack.c
+++ b/tools/perf/util/thread-stack.c
@@ -36,6 +36,7 @@
  * @branch_count: the branch count when the entry was created
  * @cp: call path
  * @no_call: a 'call' was not seen
+ * @trace_end: a 'call' but trace ended
  */
 struct thread_stack_entry {
         u64 ret_addr;
@@ -44,6 +45,7 @@ struct thread_stack_entry {
         u64 branch_count;
         struct call_path *cp;
         bool no_call;
+        bool trace_end;
 };
 
 /**
@@ -112,7 +114,8 @@ static struct thread_stack *thread_stack__new(struct thread *thread,
         return ts;
 }
 
-static int thread_stack__push(struct thread_stack *ts, u64 ret_addr)
+static int thread_stack__push(struct thread_stack *ts, u64 ret_addr,
+                              bool trace_end)
 {
         int err = 0;
 
@@ -124,6 +127,7 @@ static int thread_stack__push(struct thread_stack *ts, u64 ret_addr)
                 }
         }
 
+        ts->stack[ts->cnt].trace_end = trace_end;
         ts->stack[ts->cnt++].ret_addr = ret_addr;
 
         return err;
@@ -150,6 +154,18 @@ static void thread_stack__pop(struct thread_stack *ts, u64 ret_addr)
         }
 }
 
+static void thread_stack__pop_trace_end(struct thread_stack *ts)
+{
+        size_t i;
+
+        for (i = ts->cnt; i; ) {
+                if (ts->stack[--i].trace_end)
+                        ts->cnt = i;
+                else
+                        return;
+        }
+}
+
 static bool thread_stack__in_kernel(struct thread_stack *ts)
 {
         if (!ts->cnt)
@@ -254,10 +270,19 @@ int thread_stack__event(struct thread *thread, u32 flags, u64 from_ip,
                 ret_addr = from_ip + insn_len;
                 if (ret_addr == to_ip)
                         return 0; /* Zero-length calls are excluded */
-                return thread_stack__push(thread->ts, ret_addr);
-        } else if (flags & PERF_IP_FLAG_RETURN) {
-                if (!from_ip)
-                        return 0;
+                return thread_stack__push(thread->ts, ret_addr,
+                                          flags & PERF_IP_FLAG_TRACE_END);
+        } else if (flags & PERF_IP_FLAG_TRACE_BEGIN) {
+                /*
+                 * If the caller did not change the trace number (which would
+                 * have flushed the stack) then try to make sense of the stack.
+                 * Possibly, tracing began after returning to the current
+                 * address, so try to pop that. Also, do not expect a call made
+                 * when the trace ended, to return, so pop that.
+                 */
+                thread_stack__pop(thread->ts, to_ip);
+                thread_stack__pop_trace_end(thread->ts);
+        } else if ((flags & PERF_IP_FLAG_RETURN) && from_ip) {
                 thread_stack__pop(thread->ts, to_ip);
         }
 
@@ -285,20 +310,46 @@ void thread_stack__free(struct thread *thread)
         }
 }
 
+static inline u64 callchain_context(u64 ip, u64 kernel_start)
+{
+        return ip < kernel_start ? PERF_CONTEXT_USER : PERF_CONTEXT_KERNEL;
+}
+
 void thread_stack__sample(struct thread *thread, struct ip_callchain *chain,
-                          size_t sz, u64 ip)
+                          size_t sz, u64 ip, u64 kernel_start)
 {
-        size_t i;
+        u64 context = callchain_context(ip, kernel_start);
+        u64 last_context;
+        size_t i, j;
 
-        if (!thread || !thread->ts)
-                chain->nr = 1;
-        else
-                chain->nr = min(sz, thread->ts->cnt + 1);
+        if (sz < 2) {
+                chain->nr = 0;
+                return;
+        }
+
+        chain->ips[0] = context;
+        chain->ips[1] = ip;
 
-        chain->ips[0] = ip;
+        if (!thread || !thread->ts) {
+                chain->nr = 2;
+                return;
+        }
+
+        last_context = context;
+
+        for (i = 2, j = 1; i < sz && j <= thread->ts->cnt; i++, j++) {
+                ip = thread->ts->stack[thread->ts->cnt - j].ret_addr;
+                context = callchain_context(ip, kernel_start);
+                if (context != last_context) {
+                        if (i >= sz - 1)
+                                break;
+                        chain->ips[i++] = context;
+                        last_context = context;
+                }
+                chain->ips[i] = ip;
+        }
 
-        for (i = 1; i < chain->nr; i++)
-                chain->ips[i] = thread->ts->stack[thread->ts->cnt - i].ret_addr;
+        chain->nr = i;
 }
 
 struct call_return_processor *
@@ -332,7 +383,7 @@ void call_return_processor__free(struct call_return_processor *crp)
 
 static int thread_stack__push_cp(struct thread_stack *ts, u64 ret_addr,
                                  u64 timestamp, u64 ref, struct call_path *cp,
-                                 bool no_call)
+                                 bool no_call, bool trace_end)
 {
         struct thread_stack_entry *tse;
         int err;
@@ -350,6 +401,7 @@ static int thread_stack__push_cp(struct thread_stack *ts, u64 ret_addr,
         tse->branch_count = ts->branch_count;
         tse->cp = cp;
         tse->no_call = no_call;
+        tse->trace_end = trace_end;
 
         return 0;
 }
@@ -423,7 +475,7 @@ static int thread_stack__bottom(struct thread *thread, struct thread_stack *ts,
                 return -ENOMEM;
 
         return thread_stack__push_cp(thread->ts, ip, sample->time, ref, cp,
-                                     true);
+                                     true, false);
 }
 
 static int thread_stack__no_call_return(struct thread *thread,
@@ -455,7 +507,7 @@ static int thread_stack__no_call_return(struct thread *thread,
                         if (!cp)
                                 return -ENOMEM;
                         return thread_stack__push_cp(ts, 0, sample->time, ref,
-                                                     cp, true);
+                                                     cp, true, false);
                 }
         } else if (thread_stack__in_kernel(ts) && sample->ip < ks) {
                 /* Return to userspace, so pop all kernel addresses */
@@ -480,7 +532,7 @@ static int thread_stack__no_call_return(struct thread *thread,
                 return -ENOMEM;
 
         err = thread_stack__push_cp(ts, sample->addr, sample->time, ref, cp,
-                                    true);
+                                    true, false);
         if (err)
                 return err;
 
@@ -500,7 +552,7 @@ static int thread_stack__trace_begin(struct thread *thread,
 
         /* Pop trace end */
         tse = &ts->stack[ts->cnt - 1];
-        if (tse->cp->sym == NULL && tse->cp->ip == 0) {
+        if (tse->trace_end) {
                 err = thread_stack__call_return(thread, ts, --ts->cnt,
                                                 timestamp, ref, false);
                 if (err)
@@ -529,7 +581,7 @@ static int thread_stack__trace_end(struct thread_stack *ts,
         ret_addr = sample->ip + sample->insn_len;
 
         return thread_stack__push_cp(ts, ret_addr, sample->time, ref, cp,
-                                     false);
+                                     false, true);
 }
 
 int thread_stack__process(struct thread *thread, struct comm *comm,
@@ -579,6 +631,7 @@ int thread_stack__process(struct thread *thread, struct comm *comm,
         ts->last_time = sample->time;
 
         if (sample->flags & PERF_IP_FLAG_CALL) {
+                bool trace_end = sample->flags & PERF_IP_FLAG_TRACE_END;
                 struct call_path_root *cpr = ts->crp->cpr;
                 struct call_path *cp;
                 u64 ret_addr;
@@ -596,7 +649,7 @@ int thread_stack__process(struct thread *thread, struct comm *comm,
                 if (!cp)
                         return -ENOMEM;
                 err = thread_stack__push_cp(ts, ret_addr, sample->time, ref,
-                                            cp, false);
+                                            cp, false, trace_end);
         } else if (sample->flags & PERF_IP_FLAG_RETURN) {
                 if (!sample->ip || !sample->addr)
                         return 0;
diff --git a/tools/perf/util/thread-stack.h b/tools/perf/util/thread-stack.h
index b7e41c4ebfdd..f97c00a8c251 100644
--- a/tools/perf/util/thread-stack.h
+++ b/tools/perf/util/thread-stack.h
@@ -84,7 +84,7 @@ int thread_stack__event(struct thread *thread, u32 flags, u64 from_ip,
                         u64 to_ip, u16 insn_len, u64 trace_nr);
 void thread_stack__set_trace_nr(struct thread *thread, u64 trace_nr);
 void thread_stack__sample(struct thread *thread, struct ip_callchain *chain,
-                          size_t sz, u64 ip);
+                          size_t sz, u64 ip, u64 kernel_start);
 int thread_stack__flush(struct thread *thread);
 void thread_stack__free(struct thread *thread);
 size_t thread_stack__depth(struct thread *thread);
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 2048d393ece6..3d9ed7d0e281 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -330,7 +330,8 @@ static int thread__prepare_access(struct thread *thread)
 }
 
 static int thread__clone_map_groups(struct thread *thread,
-                                    struct thread *parent)
+                                    struct thread *parent,
+                                    bool do_maps_clone)
 {
         /* This is new thread, we share map groups for process. */
         if (thread->pid_ == parent->pid_)
@@ -341,15 +342,11 @@ static int thread__clone_map_groups(struct thread *thread,
                          thread->pid_, thread->tid, parent->pid_, parent->tid);
                 return 0;
         }
-
         /* But this one is new process, copy maps. */
-        if (map_groups__clone(thread, parent->mg) < 0)
-                return -ENOMEM;
-
-        return 0;
+        return do_maps_clone ? map_groups__clone(thread, parent->mg) : 0;
 }
 
-int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
+int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone)
 {
         if (parent->comm_set) {
                 const char *comm = thread__comm_str(parent);
@@ -362,7 +359,7 @@ int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
         }
 
         thread->ppid = parent->tid;
-        return thread__clone_map_groups(thread, parent);
+        return thread__clone_map_groups(thread, parent, do_maps_clone);
 }
 
 void thread__find_cpumode_addr_location(struct thread *thread, u64 addr,
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 07606aa6998d..30e2b4c165fe 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -42,6 +42,8 @@ struct thread {
         void                            *addr_space;
         struct unwind_libunwind_ops     *unwind_libunwind_ops;
 #endif
+        bool                    filter;
+        int                     filter_entry_depth;
 };
 
 struct machine;
@@ -87,7 +89,7 @@ struct comm *thread__comm(const struct thread *thread);
 struct comm *thread__exec_comm(const struct thread *thread);
 const char *thread__comm_str(const struct thread *thread);
 int thread__insert_map(struct thread *thread, struct map *map);
-int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp);
+int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone);
 size_t thread__fprintf(struct thread *thread, FILE *fp);
 
 struct thread *thread__main_thread(struct machine *machine, struct thread *thread);
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index 183c91453522..56e4ca54020a 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -26,15 +26,12 @@ typedef int (*event_attr_op)(struct perf_tool *tool,
                              union perf_event *event,
                              struct perf_evlist **pevlist);
 
-typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
-                         struct perf_session *session);
+typedef int (*event_op2)(struct perf_session *session, union perf_event *event);
+typedef s64 (*event_op3)(struct perf_session *session, union perf_event *event);
 
 typedef int (*event_oe)(struct perf_tool *tool, union perf_event *event,
                         struct ordered_events *oe);
 
-typedef s64 (*event_op3)(struct perf_tool *tool, union perf_event *event,
-                         struct perf_session *session);
-
 enum show_feature_header {
         SHOW_FEAT_NO_HEADER = 0,
         SHOW_FEAT_HEADER,
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 7b0ca7cbb7de..8ad8e755127b 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -531,12 +531,14 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                          "/tmp/perf-XXXXXX");
                 if (!mkstemp(tdata->temp_file)) {
                         pr_debug("Can't make temp file");
+                        free(tdata);
                         return NULL;
                 }
 
                 temp_fd = open(tdata->temp_file, O_RDWR);
                 if (temp_fd < 0) {
                         pr_debug("Can't read '%s'", tdata->temp_file);
+                        free(tdata);
                         return NULL;
                 }
 
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index e76214f8d596..32e558a65af3 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -33,14 +33,15 @@ static int get_common_field(struct scripting_context *context,
                             int *offset, int *size, const char *type)
 {
         struct tep_handle *pevent = context->pevent;
-        struct event_format *event;
-        struct format_field *field;
+        struct tep_event_format *event;
+        struct tep_format_field *field;
 
         if (!*size) {
-                if (!pevent->events)
+
+                event = tep_get_first_event(pevent);
+                if (!event)
                         return 0;
 
-                event = pevent->events[0];
                 field = tep_find_common_field(event, type);
                 if (!field)
                         return 0;
@@ -94,9 +95,9 @@ int common_pc(struct scripting_context *context)
 }
 
 unsigned long long
-raw_field_value(struct event_format *event, const char *name, void *data)
+raw_field_value(struct tep_event_format *event, const char *name, void *data)
 {
-        struct format_field *field;
+        struct tep_format_field *field;
         unsigned long long val;
 
         field = tep_find_any_field(event, name);
@@ -108,12 +109,12 @@ raw_field_value(struct event_format *event, const char *name, void *data)
         return val;
 }
 
-unsigned long long read_size(struct event_format *event, void *ptr, int size)
+unsigned long long read_size(struct tep_event_format *event, void *ptr, int size)
 {
         return tep_read_number(event->pevent, ptr, size);
 }
 
-void event_format__fprintf(struct event_format *event,
+void event_format__fprintf(struct tep_event_format *event,
                            int cpu, void *data, int size, FILE *fp)
 {
         struct tep_record record;
@@ -130,7 +131,7 @@ void event_format__fprintf(struct event_format *event,
         trace_seq_destroy(&s);
 }
 
-void event_format__print(struct event_format *event,
+void event_format__print(struct tep_event_format *event,
                          int cpu, void *data, int size)
 {
         return event_format__fprintf(event, cpu, data, size, stdout);
@@ -158,6 +159,7 @@ void parse_ftrace_printk(struct tep_handle *pevent,
                 printk = strdup(fmt+1);
                 line = strtok_r(NULL, "\n", &next);
                 tep_register_print_string(pevent, printk, addr);
+                free(printk);
         }
 }
 
@@ -188,29 +190,33 @@ int parse_event_file(struct tep_handle *pevent,
         return tep_parse_event(pevent, buf, size, sys);
 }
 
-struct event_format *trace_find_next_event(struct tep_handle *pevent,
-                                           struct event_format *event)
+struct tep_event_format *trace_find_next_event(struct tep_handle *pevent,
+                                               struct tep_event_format *event)
 {
         static int idx;
+        int events_count;
+        struct tep_event_format *all_events;
 
-        if (!pevent || !pevent->events)
+        all_events = tep_get_first_event(pevent);
+        events_count = tep_get_events_count(pevent);
+        if (!pevent || !all_events || events_count < 1)
                 return NULL;
 
         if (!event) {
                 idx = 0;
-                return pevent->events[0];
+                return all_events;
         }
 
-        if (idx < pevent->nr_events && event == pevent->events[idx]) {
+        if (idx < events_count && event == (all_events + idx)) {
                 idx++;
-                if (idx == pevent->nr_events)
+                if (idx == events_count)
                         return NULL;
-                return pevent->events[idx];
+                return (all_events + idx);
         }
 
-        for (idx = 1; idx < pevent->nr_events; idx++) {
-                if (event == pevent->events[idx - 1])
-                        return pevent->events[idx];
+        for (idx = 1; idx < events_count; idx++) {
+                if (event == (all_events + (idx - 1)))
+                        return (all_events + idx);
         }
         return NULL;
 }
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 3dfc1db6b25b..76f12c705ef9 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -102,7 +102,7 @@ static unsigned int read4(struct tep_handle *pevent)
 
         if (do_read(&data, 4) < 0)
                 return 0;
-        return __data2host4(pevent, data);
+        return __tep_data2host4(pevent, data);
 }
 
 static unsigned long long read8(struct tep_handle *pevent)
@@ -111,7 +111,7 @@ static unsigned long long read8(struct tep_handle *pevent)
 
         if (do_read(&data, 8) < 0)
                 return 0;
-        return __data2host8(pevent, data);
+        return __tep_data2host8(pevent, data);
 }
 
 static char *read_string(void)
@@ -241,7 +241,7 @@ static int read_header_files(struct tep_handle *pevent)
                  * The commit field in the page is of type long,
                  * use that instead, since it represents the kernel.
                  */
-                tep_set_long_size(pevent, pevent->header_page_size_size);
+                tep_set_long_size(pevent, tep_get_header_page_size(pevent));
         }
         free(header_page);
 
@@ -297,10 +297,8 @@ static int read_event_file(struct tep_handle *pevent, char *sys,
         }
 
         ret = do_read(buf, size);
-        if (ret < 0) {
-                free(buf);
+        if (ret < 0)
                 goto out;
-        }
 
         ret = parse_event_file(pevent, buf, size, sys);
         if (ret < 0)
@@ -349,9 +347,12 @@ static int read_event_files(struct tep_handle *pevent)
                 for (x=0; x < count; x++) {
                         size = read8(pevent);
                         ret = read_event_file(pevent, sys, size);
-                        if (ret)
+                        if (ret) {
+                                free(sys);
                                 return ret;
+                        }
                 }
+                free(sys);
         }
         return 0;
 }
diff --git a/tools/perf/util/trace-event.c b/tools/perf/util/trace-event.c
index 58bb72f266f3..95664b2f771e 100644
--- a/tools/perf/util/trace-event.c
+++ b/tools/perf/util/trace-event.c
@@ -72,12 +72,12 @@ void trace_event__cleanup(struct trace_event *t)
 /*
  * Returns pointer with encoded error via <linux/err.h> interface.
  */
-static struct event_format*
+static struct tep_event_format*
 tp_format(const char *sys, const char *name)
 {
         char *tp_dir = get_events_file(sys);
         struct tep_handle *pevent = tevent.pevent;
-        struct event_format *event = NULL;
+        struct tep_event_format *event = NULL;
         char path[PATH_MAX];
         size_t size;
         char *data;
@@ -102,7 +102,7 @@ tp_format(const char *sys, const char *name)
 /*
  * Returns pointer with encoded error via <linux/err.h> interface.
  */
-struct event_format*
+struct tep_event_format*
 trace_event__tp_format(const char *sys, const char *name)
 {
         if (!tevent_initialized && trace_event__init2())
@@ -111,7 +111,7 @@ trace_event__tp_format(const char *sys, const char *name)
         return tp_format(sys, name);
 }
 
-struct event_format *trace_event__tp_format_id(int id)
+struct tep_event_format *trace_event__tp_format_id(int id)
 {
         if (!tevent_initialized && trace_event__init2())
                 return ERR_PTR(-ENOMEM);
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 40204ec3a7a2..f024d73bfc40 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -3,6 +3,7 @@
 #define _PERF_UTIL_TRACE_EVENT_H
 
 #include <traceevent/event-parse.h>
+#include <traceevent/trace-seq.h>
 #include "parse-events.h"
 
 struct machine;
@@ -10,28 +11,28 @@ struct perf_sample;
 union perf_event;
 struct perf_tool;
 struct thread;
-struct plugin_list;
+struct tep_plugin_list;
 
 struct trace_event {
         struct tep_handle       *pevent;
-        struct plugin_list      *plugin_list;
+        struct tep_plugin_list  *plugin_list;
 };
 
 int trace_event__init(struct trace_event *t);
 void trace_event__cleanup(struct trace_event *t);
 int trace_event__register_resolver(struct machine *machine,
                                    tep_func_resolver_t *func);
-struct event_format*
+struct tep_event_format*
 trace_event__tp_format(const char *sys, const char *name);
 
-struct event_format *trace_event__tp_format_id(int id);
+struct tep_event_format *trace_event__tp_format_id(int id);
 
 int bigendian(void);
 
-void event_format__fprintf(struct event_format *event,
+void event_format__fprintf(struct tep_event_format *event,
                            int cpu, void *data, int size, FILE *fp);
 
-void event_format__print(struct event_format *event,
+void event_format__print(struct tep_event_format *event,
                          int cpu, void *data, int size);
 
 int parse_ftrace_file(struct tep_handle *pevent, char *buf, unsigned long size);
@@ -39,7 +40,7 @@ int parse_event_file(struct tep_handle *pevent,
                      char *buf, unsigned long size, char *sys);
 
 unsigned long long
-raw_field_value(struct event_format *event, const char *name, void *data);
+raw_field_value(struct tep_event_format *event, const char *name, void *data);
 
 void parse_proc_kallsyms(struct tep_handle *pevent, char *file, unsigned int size);
 void parse_ftrace_printk(struct tep_handle *pevent, char *file, unsigned int size);
@@ -47,9 +48,9 @@ void parse_saved_cmdline(struct tep_handle *pevent, char *file, unsigned int siz
 
 ssize_t trace_report(int fd, struct trace_event *tevent, bool repipe);
 
-struct event_format *trace_find_next_event(struct tep_handle *pevent,
-                                           struct event_format *event);
-unsigned long long read_size(struct event_format *event, void *ptr, int size);
+struct tep_event_format *trace_find_next_event(struct tep_handle *pevent,
+                                               struct tep_event_format *event);
+unsigned long long read_size(struct tep_event_format *event, void *ptr, int size);
 unsigned long long eval_flag(const char *flag);
 
 int read_tracing_data(int fd, struct list_head *pattrs);
diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c
index 6f318b15950e..5eff9bfc5758 100644
--- a/tools/perf/util/unwind-libdw.c
+++ b/tools/perf/util/unwind-libdw.c
@@ -45,13 +45,13 @@ static int __report_module(struct addr_location *al, u64 ip,
                 Dwarf_Addr s;
 
                 dwfl_module_info(mod, NULL, &s, NULL, NULL, NULL, NULL, NULL);
-                if (s != al->map->start)
+                if (s != al->map->start - al->map->pgoff)
                         mod = 0;
         }
 
         if (!mod)
                 mod = dwfl_report_elf(ui->dwfl, dso->short_name,
-                                      (dso->symsrc_filename ? dso->symsrc_filename : dso->long_name), -1, al->map->start,
+                                      (dso->symsrc_filename ? dso->symsrc_filename : dso->long_name), -1, al->map->start - al->map->pgoff,
                                       false);
 
         return mod && dwfl_addrmodule(ui->dwfl, ip) == mod ? 0 : -1;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index eac5b858a371..093352e93d50 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -221,7 +221,7 @@ out:
         return err;
 }
 
-static int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
+int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
 {
         void *ptr;
         loff_t pgoff;
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index dc58254a2b69..14508ee7707a 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -6,6 +6,7 @@
 /* glibc 2.20 deprecates _BSD_SOURCE in favour of _DEFAULT_SOURCE */
 #define _DEFAULT_SOURCE 1
 
+#include <fcntl.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -35,6 +36,7 @@ bool lsdir_no_dot_filter(const char *name, struct dirent *d);
 int copyfile(const char *from, const char *to);
 int copyfile_mode(const char *from, const char *to, mode_t mode);
 int copyfile_ns(const char *from, const char *to, struct nsinfo *nsi);
+int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size);
 
 ssize_t readn(int fd, void *buf, size_t n);
 ssize_t writen(int fd, const void *buf, size_t n);