197 files changed, 5566 insertions, 2785 deletions

diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 40399c3d97d6..812f904193e8 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -1,6 +1,7 @@
 PERF-CFLAGS
 PERF-GUI-VARS
 PERF-VERSION-FILE
+FEATURE-DUMP
 perf
 perf-read-vdso32
 perf-read-vdsox32
diff --git a/tools/perf/Build b/tools/perf/Build
new file mode 100644
index 000000000000..b77370ef7005
--- /dev/null
+++ b/tools/perf/Build
@@ -0,0 +1,44 @@
+perf-y += builtin-bench.o
+perf-y += builtin-annotate.o
+perf-y += builtin-diff.o
+perf-y += builtin-evlist.o
+perf-y += builtin-help.o
+perf-y += builtin-sched.o
+perf-y += builtin-buildid-list.o
+perf-y += builtin-buildid-cache.o
+perf-y += builtin-list.o
+perf-y += builtin-record.o
+perf-y += builtin-report.o
+perf-y += builtin-stat.o
+perf-y += builtin-timechart.o
+perf-y += builtin-top.o
+perf-y += builtin-script.o
+perf-y += builtin-kmem.o
+perf-y += builtin-lock.o
+perf-y += builtin-kvm.o
+perf-y += builtin-inject.o
+perf-y += builtin-mem.o
+perf-y += builtin-data.o
+
+perf-$(CONFIG_AUDIT) += builtin-trace.o
+perf-$(CONFIG_LIBELF) += builtin-probe.o
+
+perf-y += bench/
+perf-y += tests/
+
+perf-y += perf.o
+
+paths += -DPERF_HTML_PATH="BUILD_STR($(htmldir_SQ))"
+paths += -DPERF_INFO_PATH="BUILD_STR($(infodir_SQ))"
+paths += -DPERF_MAN_PATH="BUILD_STR($(mandir_SQ))"
+
+CFLAGS_builtin-help.o      += $(paths)
+CFLAGS_builtin-timechart.o += $(paths)
+CFLAGS_perf.o              += -DPERF_HTML_PATH="BUILD_STR($(htmldir_SQ))" -include $(OUTPUT)PERF-VERSION-FILE
+
+libperf-y += util/
+libperf-y += arch/
+libperf-y += ui/
+libperf-y += scripts/
+
+gtk-y += ui/gtk/
diff --git a/tools/perf/Documentation/Build.txt b/tools/perf/Documentation/Build.txt
new file mode 100644
index 000000000000..f6fc6507ba55
--- /dev/null
+++ b/tools/perf/Documentation/Build.txt
@@ -0,0 +1,49 @@
+
+1) perf build
+=============
+The perf build process consists of several separated building blocks,
+which are linked together to form the perf binary:
+  - libperf library (static)
+  - perf builtin commands
+  - traceevent library (static)
+  - GTK ui library
+
+Several makefiles govern the perf build:
+
+  - Makefile
+    top level Makefile working as a wrapper that calls the main
+    Makefile.perf with a -j option to do parallel builds.
+
+  - Makefile.perf
+    main makefile that triggers build of all perf objects including
+    installation and documentation processing.
+
+  - tools/build/Makefile.build
+    main makefile of the build framework
+
+  - tools/build/Build.include
+    build framework generic definitions
+
+  - Build makefiles
+    makefiles that defines build objects
+
+Please refer to tools/build/Documentation/Build.txt for more
+information about build framework.
+
+
+2) perf build
+=============
+The Makefile.perf triggers the build framework for build objects:
+   perf, libperf, gtk
+
+resulting in following objects:
+  $ ls  *-in.o
+  gtk-in.o  libperf-in.o  perf-in.o
+
+Those objects are then used in final linking:
+  libperf-gtk.so <- gtk-in.o  libperf-in.o
+  perf           <- perf-in.o libperf-in.o
+
+
+NOTE this description is omitting other libraries involved, only
+     focusing on build framework outcomes
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
index 0294c57b1f5e..dd07b55f58d8 100644
--- a/tools/perf/Documentation/perf-buildid-cache.txt
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -12,9 +12,9 @@ SYNOPSIS
 
 DESCRIPTION
 -----------
-This command manages the build-id cache. It can add and remove files to/from
-the cache. In the future it should as well purge older entries, set upper
-limits for the space used by the cache, etc.
+This command manages the build-id cache. It can add, remove, update and purge
+files to/from the cache. In the future it should as well set upper limits for
+the space used by the cache, etc.
 
 OPTIONS
 -------
@@ -36,14 +36,24 @@ OPTIONS
         actually made.
 -r::
 --remove=::
-        Remove specified file from the cache.
+        Remove a cached binary which has same build-id of specified file
+        from the cache.
+-p::
+--purge=::
+        Purge all cached binaries including older caches which have specified
+        path from the cache.
 -M::
 --missing=::
         List missing build ids in the cache for the specified file.
 -u::
---update::
-        Update specified file of the cache. It can be used to update kallsyms
-        kernel dso to vmlinux in order to support annotation.
+--update=::
+        Update specified file of the cache. Note that this doesn't remove
+        older entires since those may be still needed for annotating old
+        (or remote) perf.data. Only if there is already a cache which has
+        exactly same build-id, that is replaced by new one. It can be used
+        to update kallsyms and kernel dso to vmlinux in order to support
+        annotation.
+
 -v::
 --verbose::
         Be more verbose.
diff --git a/tools/perf/Documentation/perf-data.txt b/tools/perf/Documentation/perf-data.txt
new file mode 100644
index 000000000000..be8fa1a0a97e
--- /dev/null
+++ b/tools/perf/Documentation/perf-data.txt
@@ -0,0 +1,40 @@
+perf-data(1)
+==============
+
+NAME
+----
+perf-data - Data file related processing
+
+SYNOPSIS
+--------
+[verse]
+'perf data' [<common options>] <command> [<options>]",
+
+DESCRIPTION
+-----------
+Data file related processing.
+
+COMMANDS
+--------
+convert::
+        Converts perf data file into another format (only CTF [1] format is support by now).
+        It's possible to set data-convert debug variable to get debug messages from conversion,
+        like:
+          perf --debug data-convert data convert ...
+
+OPTIONS for 'convert'
+---------------------
+--to-ctf::
+        Triggers the CTF conversion, specify the path of CTF data directory.
+
+-i::
+        Specify input perf data file path.
+
+-v::
+--verbose::
+        Be more verbose (show counter open errors, etc).
+
+SEE ALSO
+--------
+linkperf:perf[1]
+[1] Common Trace Format - http://www.efficios.com/ctf
diff --git a/tools/perf/Documentation/perf-diff.txt b/tools/perf/Documentation/perf-diff.txt
index e463caa3eb49..d1deb573877f 100644
--- a/tools/perf/Documentation/perf-diff.txt
+++ b/tools/perf/Documentation/perf-diff.txt
@@ -20,12 +20,20 @@ If no parameters are passed it will assume perf.data.old and perf.data.
 The differential profile is displayed only for events matching both
 specified perf.data files.
 
+If no parameters are passed the samples will be sorted by dso and symbol.
+As the perf.data files could come from different binaries, the symbols addresses
+could vary. So perf diff is based on the comparison of the files and
+symbols name.
+
 OPTIONS
 -------
 -D::
 --dump-raw-trace::
         Dump raw trace in ASCII.
 
+--kallsyms=<file>::
+        kallsyms pathname
+
 -m::
 --modules::
         Load module symbols. WARNING: use only with -k and LIVE kernel
diff --git a/tools/perf/Documentation/perf-kmem.txt b/tools/perf/Documentation/perf-kmem.txt
index 7c8fbbf3f61c..23219c65c16f 100644
--- a/tools/perf/Documentation/perf-kmem.txt
+++ b/tools/perf/Documentation/perf-kmem.txt
@@ -3,7 +3,7 @@ perf-kmem(1)
 
 NAME
 ----
-perf-kmem - Tool to trace/measure kernel memory(slab) properties
+perf-kmem - Tool to trace/measure kernel memory properties
 
 SYNOPSIS
 --------
@@ -25,6 +25,10 @@ OPTIONS
 --input=<file>::
         Select the input file (default: perf.data unless stdin is a fifo)
 
+-v::
+--verbose::
+        Be more verbose. (show symbol address, etc)
+
 --caller::
         Show per-callsite statistics
 
@@ -42,6 +46,12 @@ OPTIONS
 --raw-ip::
         Print raw ip instead of symbol
 
+--slab::
+        Analyze SLAB allocator events.
+
+--page::
+        Analyze page allocator events
+
 SEE ALSO
 --------
 linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index 3e2aec94f806..bada8933fdd4 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -26,6 +26,7 @@ counted. The following modifiers exist:
  u - user-space counting
  k - kernel counting
  h - hypervisor counting
+ I - non idle counting
  G - guest counting (in KVM guests)
  H - host counting (not in KVM guests)
  p - precise level
@@ -127,6 +128,12 @@ To limit the list use:
 One or more types can be used at the same time, listing the events for the
 types specified.
 
+Support raw format:
+
+. '--raw-dump', shows the raw-dump of all the events.
+. '--raw-dump [hw|sw|cache|tracepoint|pmu|event_glob]', shows the raw-dump of
+  a certain kind of events.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-top[1],
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index aaa869be3dc1..239609c09f83 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -47,6 +47,12 @@ OPTIONS
 -v::
 --verbose::
         Be more verbose (show parsed arguments, etc).
+        Can not use with -q.
+
+-q::
+--quiet::
+        Be quiet (do not show any messages including errors).
+        Can not use with -v.
 
 -a::
 --add=::
@@ -96,7 +102,7 @@ OPTIONS
         Dry run. With this option, --add and --del doesn't execute actual
         adding and removal operations.
 
---max-probes::
+--max-probes=NUM::
         Set the maximum number of probe points for an event. Default is 128.
 
 -x::
@@ -104,8 +110,13 @@ OPTIONS
         Specify path to the executable or shared library file for user
         space tracing. Can also be used with --funcs option.
 
+--demangle::
+        Demangle application symbols. --no-demangle is also available
+        for disabling demangling.
+
 --demangle-kernel::
-        Demangle kernel symbols.
+        Demangle kernel symbols. --no-demangle-kernel is also available
+        for disabling kernel demangling.
 
 In absence of -m/-x options, perf probe checks if the first argument after
 the options is an absolute path name. If its an absolute path, perf probe
@@ -137,6 +148,7 @@ Each probe argument follows below syntax.
  [NAME=]LOCALVAR|$retval|%REG|@SYMBOL[:TYPE]
 
 'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.)
+'$vars' special argument is also available for NAME, it is expanded to the local variables which can access at given probe point.
 'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.
 
 On x86 systems %REG is always the short form of the register: for example %AX. %RAX or %EAX is not valid.
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 31e977459c51..4847a793de65 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -55,6 +55,11 @@ OPTIONS
           If you want to profile write accesses in [0x1000~1008), just set
           'mem:0x1000/8:w'.
 
+        - a group of events surrounded by a pair of brace ("{event1,event2,...}").
+          Each event is separated by commas and the group should be quoted to
+          prevent the shell interpretation.  You also need to use --group on
+          "perf report" to view group events together.
+
 --filter=<filter>::
         Event filter.
 
@@ -62,9 +67,6 @@ OPTIONS
 --all-cpus::
         System-wide collection from all CPUs.
 
--l::
-        Scale counter values.
-
 -p::
 --pid=::
         Record events on existing process ID (comma separated list).
@@ -107,6 +109,10 @@ OPTIONS
         specification with appended unit character - B/K/M/G. The
         size is rounded up to have nearest pages power of two value.
 
+--group::
+        Put all events in a single event group.  This precedes the --event
+        option and remains only for backward compatibility.  See --event.
+
 -g::
         Enables call-graph (stack chain/backtrace) recording.
 
@@ -115,13 +121,19 @@ OPTIONS
         implies -g.
 
         Allows specifying "fp" (frame pointer) or "dwarf"
-        (DWARF's CFI - Call Frame Information) as the method to collect
+        (DWARF's CFI - Call Frame Information) or "lbr"
+        (Hardware Last Branch Record facility) as the method to collect
         the information used to show the call graphs.
 
         In some systems, where binaries are build with gcc
         --fomit-frame-pointer, using the "fp" method will produce bogus
         call graphs, using "dwarf", if available (perf tools linked to
         the libunwind library) should be used instead.
+        Using the "lbr" method doesn't require any compiler options. It
+        will produce call graphs from the hardware LBR registers. The
+        main limition is that it is only available on new Intel
+        platforms, such as Haswell. It can only get user call chain. It
+        doesn't work with branch stack sampling at the same time.
 
 -q::
 --quiet::
@@ -235,6 +247,16 @@ Capture machine state (registers) at interrupt, i.e., on counter overflows for
 each sample. List of captured registers depends on the architecture. This option
 is off by default.
 
+--running-time::
+Record running and enabled time for read events (:S)
+
+-k::
+--clockid::
+Sets the clock id to use for the various time fields in the perf_event_type
+records. See clock_gettime(). In particular CLOCK_MONOTONIC and
+CLOCK_MONOTONIC_RAW are supported, some events might also allow
+CLOCK_BOOTTIME, CLOCK_REALTIME and CLOCK_TAI.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index dd7cccdde498..4879cf638824 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -40,6 +40,11 @@ OPTIONS
         Only consider symbols in these comms. CSV that understands
         file://filename entries.  This option will affect the percentage of
         the overhead column.  See --percentage for more info.
+--pid=::
+        Only show events for given process ID (comma separated list).
+
+--tid=::
+        Only show events for given thread ID (comma separated list).
 -d::
 --dsos=::
         Only consider symbols in these dsos. CSV that understands
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index a21eec05bc42..79445750fcb3 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -193,6 +193,12 @@ OPTIONS
         Only display events for these comms. CSV that understands
         file://filename entries.
 
+--pid=::
+        Only show events for given process ID (comma separated list).
+
+--tid=::
+        Only show events for given thread ID (comma separated list).
+
 -I::
 --show-info::
         Display extended information about the perf.data file. This adds
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 7e1b1f2bb83c..ba03fd5d1a54 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -55,6 +55,9 @@ OPTIONS
 --uid=::
         Record events in threads owned by uid. Name or number.
 
+--filter-pids=::
+        Filter out events for these pids and for 'trace' itself (comma separated list).
+
 -v::
 --verbose=::
         Verbosity level.
@@ -115,6 +118,9 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
 --syscalls::
         Trace system calls. This options is enabled by default.
 
+--event::
+        Trace other events, see 'perf list' for a complete list.
+
 PAGEFAULTS
 ----------
 
diff --git a/tools/perf/Documentation/perf.txt b/tools/perf/Documentation/perf.txt
index 1e8e400b4493..2b131776363e 100644
--- a/tools/perf/Documentation/perf.txt
+++ b/tools/perf/Documentation/perf.txt
@@ -13,11 +13,16 @@ SYNOPSIS
 OPTIONS
 -------
 --debug::
-        Setup debug variable (just verbose for now) in value
+        Setup debug variable (see list below) in value
         range (0, 10). Use like:
           --debug verbose   # sets verbose = 1
           --debug verbose=2 # sets verbose = 2
 
+        List of debug variables allowed to set:
+          verbose          - general debug messages
+          ordered-events   - ordered events object debug messages
+          data-convert     - data convert command debug messages
+
 --buildid-dir::
         Setup buildid cache directory. It has higher priority than
         buildid.dir config file option.
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index fbbfdc39271d..11ccbb22ea2b 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -1,5 +1,6 @@
 tools/perf
 tools/scripts
+tools/build
 tools/lib/traceevent
 tools/lib/api
 tools/lib/symbol/kallsyms.c
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index cb2e5868c8e8..c699dc35eef9 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -24,8 +24,8 @@ unexport MAKEFLAGS
 # (To override it, run 'make JOBS=1' and similar.)
 #
 ifeq ($(JOBS),)
-  JOBS := $(shell grep -c ^processor /proc/cpuinfo 2>/dev/null)
-  ifeq ($(JOBS),)
+  JOBS := $(shell egrep -c '^processor|^CPU' /proc/cpuinfo 2>/dev/null)
+  ifeq ($(JOBS),0)
     JOBS := 1
   endif
 endif
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index aa6a50447c32..c43a20517591 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -68,7 +68,11 @@ include config/utilities.mak
 # for reading the x32 mode 32-bit compatibility VDSO in 64-bit mode
 #
 # Define NO_ZLIB if you do not want to support compressed kernel modules
-
+#
+# Define LIBBABELTRACE if you DO want libbabeltrace support
+# for CTF data format.
+#
+# Define NO_LZMA if you do not want to support compressed (xz) kernel modules
 
 ifeq ($(srctree),)
 srctree := $(patsubst %/,%,$(dir $(shell pwd)))
@@ -82,13 +86,29 @@ endif
 
 ifneq ($(OUTPUT),)
 #$(info Determined 'OUTPUT' to be $(OUTPUT))
+# Adding $(OUTPUT) as a directory to look for source files,
+# because use generated output files as sources dependency
+# for flex/bison parsers.
+VPATH += $(OUTPUT)
+export VPATH
 endif
 
+ifeq ($(V),1)
+  Q =
+else
+  Q = @
+endif
+
+# Do not use make's built-in rules
+# (this improves performance and avoids hard-to-debug behaviour);
+MAKEFLAGS += -r
+
 $(OUTPUT)PERF-VERSION-FILE: ../../.git/HEAD
-        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
-        @touch $(OUTPUT)PERF-VERSION-FILE
+        $(Q)$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
+        $(Q)touch $(OUTPUT)PERF-VERSION-FILE
 
 CC = $(CROSS_COMPILE)gcc
+LD = $(CROSS_COMPILE)ld
 AR = $(CROSS_COMPILE)ar
 PKG_CONFIG = $(CROSS_COMPILE)pkg-config
 
@@ -127,10 +147,6 @@ export prefix bindir sharedir sysconfdir DESTDIR
 SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 
 # Guard against environment variables
-BUILTIN_OBJS =
-LIB_H =
-LIB_OBJS =
-GTK_OBJS =
 PYRF_OBJS =
 SCRIPT_SH =
 
@@ -155,8 +171,8 @@ endif
 LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
 export LIBTRACEEVENT
 
-LIBAPIKFS = $(LIB_PATH)libapikfs.a
-export LIBAPIKFS
+LIBAPI = $(LIB_PATH)libapi.a
+export LIBAPI
 
 # python extension build directories
 PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
@@ -167,7 +183,7 @@ export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
 python-clean := $(call QUIET_CLEAN, python) $(RM) -r $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 
 PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
-PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBAPIKFS)
+PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBAPI)
 
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
         $(QUIET_GEN)CFLAGS='$(CFLAGS)' $(PYTHON_WORD) util/setup.py \
@@ -206,297 +222,9 @@ endif
 
 export PERL_PATH
 
-$(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
-        $(QUIET_FLEX)$(FLEX) -o $@ --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) util/parse-events.l
-
-$(OUTPUT)util/parse-events-bison.c: util/parse-events.y
-        $(QUIET_BISON)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $(OUTPUT)util/parse-events-bison.c -p parse_events_
-
-$(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
-        $(QUIET_FLEX)$(FLEX) -o $@ --header-file=$(OUTPUT)util/pmu-flex.h util/pmu.l
-
-$(OUTPUT)util/pmu-bison.c: util/pmu.y
-        $(QUIET_BISON)$(BISON) -v util/pmu.y -d -o $(OUTPUT)util/pmu-bison.c -p perf_pmu_
-
-$(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
-$(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
-
 LIB_FILE=$(OUTPUT)libperf.a
 
-LIB_H += ../lib/symbol/kallsyms.h
-LIB_H += ../../include/uapi/linux/perf_event.h
-LIB_H += ../../include/linux/rbtree.h
-LIB_H += ../../include/linux/list.h
-LIB_H += ../../include/uapi/linux/const.h
-LIB_H += ../include/linux/hash.h
-LIB_H += ../../include/linux/stringify.h
-LIB_H += util/include/linux/bitmap.h
-LIB_H += ../include/linux/bitops.h
-LIB_H += ../include/asm-generic/bitops/arch_hweight.h
-LIB_H += ../include/asm-generic/bitops/atomic.h
-LIB_H += ../include/asm-generic/bitops/const_hweight.h
-LIB_H += ../include/asm-generic/bitops/find.h
-LIB_H += ../include/asm-generic/bitops/fls64.h
-LIB_H += ../include/asm-generic/bitops/fls.h
-LIB_H += ../include/asm-generic/bitops/__ffs.h
-LIB_H += ../include/asm-generic/bitops/__fls.h
-LIB_H += ../include/asm-generic/bitops/hweight.h
-LIB_H += ../include/asm-generic/bitops.h
-LIB_H += ../include/linux/compiler.h
-LIB_H += ../include/linux/log2.h
-LIB_H += util/include/linux/const.h
-LIB_H += util/include/linux/ctype.h
-LIB_H += util/include/linux/kernel.h
-LIB_H += util/include/linux/list.h
-LIB_H += ../include/linux/export.h
-LIB_H += util/include/linux/poison.h
-LIB_H += util/include/linux/rbtree.h
-LIB_H += util/include/linux/rbtree_augmented.h
-LIB_H += util/include/linux/string.h
-LIB_H += ../include/linux/types.h
-LIB_H += util/include/linux/linkage.h
-LIB_H += util/include/asm/asm-offsets.h
-LIB_H += ../include/asm/bug.h
-LIB_H += util/include/asm/byteorder.h
-LIB_H += util/include/asm/swab.h
-LIB_H += util/include/asm/system.h
-LIB_H += util/include/asm/uaccess.h
-LIB_H += util/include/dwarf-regs.h
-LIB_H += util/include/asm/dwarf2.h
-LIB_H += util/include/asm/cpufeature.h
-LIB_H += util/include/asm/unistd_32.h
-LIB_H += util/include/asm/unistd_64.h
-LIB_H += perf.h
-LIB_H += util/annotate.h
-LIB_H += util/cache.h
-LIB_H += util/callchain.h
-LIB_H += util/build-id.h
-LIB_H += util/db-export.h
-LIB_H += util/debug.h
-LIB_H += util/pmu.h
-LIB_H += util/event.h
-LIB_H += util/evsel.h
-LIB_H += util/evlist.h
-LIB_H += util/exec_cmd.h
-LIB_H += util/find-vdso-map.c
-LIB_H += util/levenshtein.h
-LIB_H += util/machine.h
-LIB_H += util/map.h
-LIB_H += util/parse-options.h
-LIB_H += util/parse-events.h
-LIB_H += util/quote.h
-LIB_H += util/util.h
-LIB_H += util/xyarray.h
-LIB_H += util/header.h
-LIB_H += util/help.h
-LIB_H += util/session.h
-LIB_H += util/ordered-events.h
-LIB_H += util/strbuf.h
-LIB_H += util/strlist.h
-LIB_H += util/strfilter.h
-LIB_H += util/svghelper.h
-LIB_H += util/tool.h
-LIB_H += util/run-command.h
-LIB_H += util/sigchain.h
-LIB_H += util/dso.h
-LIB_H += util/symbol.h
-LIB_H += util/color.h
-LIB_H += util/values.h
-LIB_H += util/sort.h
-LIB_H += util/hist.h
-LIB_H += util/comm.h
-LIB_H += util/thread.h
-LIB_H += util/thread_map.h
-LIB_H += util/trace-event.h
-LIB_H += util/probe-finder.h
-LIB_H += util/dwarf-aux.h
-LIB_H += util/probe-event.h
-LIB_H += util/pstack.h
-LIB_H += util/cpumap.h
-LIB_H += util/top.h
-LIB_H += $(ARCH_INCLUDE)
-LIB_H += util/cgroup.h
-LIB_H += $(LIB_INCLUDE)traceevent/event-parse.h
-LIB_H += util/target.h
-LIB_H += util/rblist.h
-LIB_H += util/intlist.h
-LIB_H += util/perf_regs.h
-LIB_H += util/unwind.h
-LIB_H += util/vdso.h
-LIB_H += util/tsc.h
-LIB_H += ui/helpline.h
-LIB_H += ui/progress.h
-LIB_H += ui/util.h
-LIB_H += ui/ui.h
-LIB_H += util/data.h
-LIB_H += util/kvm-stat.h
-LIB_H += util/thread-stack.h
-
-LIB_OBJS += $(OUTPUT)util/abspath.o
-LIB_OBJS += $(OUTPUT)util/alias.o
-LIB_OBJS += $(OUTPUT)util/annotate.o
-LIB_OBJS += $(OUTPUT)util/build-id.o
-LIB_OBJS += $(OUTPUT)util/config.o
-LIB_OBJS += $(OUTPUT)util/ctype.o
-LIB_OBJS += $(OUTPUT)util/db-export.o
-LIB_OBJS += $(OUTPUT)util/pmu.o
-LIB_OBJS += $(OUTPUT)util/environment.o
-LIB_OBJS += $(OUTPUT)util/event.o
-LIB_OBJS += $(OUTPUT)util/evlist.o
-LIB_OBJS += $(OUTPUT)util/evsel.o
-LIB_OBJS += $(OUTPUT)util/exec_cmd.o
-LIB_OBJS += $(OUTPUT)util/find_next_bit.o
-LIB_OBJS += $(OUTPUT)util/help.o
-LIB_OBJS += $(OUTPUT)util/kallsyms.o
-LIB_OBJS += $(OUTPUT)util/levenshtein.o
-LIB_OBJS += $(OUTPUT)util/parse-options.o
-LIB_OBJS += $(OUTPUT)util/parse-events.o
-LIB_OBJS += $(OUTPUT)util/path.o
-LIB_OBJS += $(OUTPUT)util/rbtree.o
-LIB_OBJS += $(OUTPUT)util/bitmap.o
-LIB_OBJS += $(OUTPUT)util/hweight.o
-LIB_OBJS += $(OUTPUT)util/run-command.o
-LIB_OBJS += $(OUTPUT)util/quote.o
-LIB_OBJS += $(OUTPUT)util/strbuf.o
-LIB_OBJS += $(OUTPUT)util/string.o
-LIB_OBJS += $(OUTPUT)util/strlist.o
-LIB_OBJS += $(OUTPUT)util/strfilter.o
-LIB_OBJS += $(OUTPUT)util/top.o
-LIB_OBJS += $(OUTPUT)util/usage.o
-LIB_OBJS += $(OUTPUT)util/wrapper.o
-LIB_OBJS += $(OUTPUT)util/sigchain.o
-LIB_OBJS += $(OUTPUT)util/dso.o
-LIB_OBJS += $(OUTPUT)util/symbol.o
-LIB_OBJS += $(OUTPUT)util/symbol-elf.o
-LIB_OBJS += $(OUTPUT)util/color.o
-LIB_OBJS += $(OUTPUT)util/pager.o
-LIB_OBJS += $(OUTPUT)util/header.o
-LIB_OBJS += $(OUTPUT)util/callchain.o
-LIB_OBJS += $(OUTPUT)util/values.o
-LIB_OBJS += $(OUTPUT)util/debug.o
-LIB_OBJS += $(OUTPUT)util/machine.o
-LIB_OBJS += $(OUTPUT)util/map.o
-LIB_OBJS += $(OUTPUT)util/pstack.o
-LIB_OBJS += $(OUTPUT)util/session.o
-LIB_OBJS += $(OUTPUT)util/ordered-events.o
-LIB_OBJS += $(OUTPUT)util/comm.o
-LIB_OBJS += $(OUTPUT)util/thread.o
-LIB_OBJS += $(OUTPUT)util/thread_map.o
-LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
-LIB_OBJS += $(OUTPUT)util/parse-events-flex.o
-LIB_OBJS += $(OUTPUT)util/parse-events-bison.o
-LIB_OBJS += $(OUTPUT)util/pmu-flex.o
-LIB_OBJS += $(OUTPUT)util/pmu-bison.o
-LIB_OBJS += $(OUTPUT)util/trace-event-read.o
-LIB_OBJS += $(OUTPUT)util/trace-event-info.o
-LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
-LIB_OBJS += $(OUTPUT)util/trace-event.o
-LIB_OBJS += $(OUTPUT)util/svghelper.o
-LIB_OBJS += $(OUTPUT)util/sort.o
-LIB_OBJS += $(OUTPUT)util/hist.o
-LIB_OBJS += $(OUTPUT)util/probe-event.o
-LIB_OBJS += $(OUTPUT)util/util.o
-LIB_OBJS += $(OUTPUT)util/xyarray.o
-LIB_OBJS += $(OUTPUT)util/cpumap.o
-LIB_OBJS += $(OUTPUT)util/cgroup.o
-LIB_OBJS += $(OUTPUT)util/target.o
-LIB_OBJS += $(OUTPUT)util/rblist.o
-LIB_OBJS += $(OUTPUT)util/intlist.o
-LIB_OBJS += $(OUTPUT)util/vdso.o
-LIB_OBJS += $(OUTPUT)util/stat.o
-LIB_OBJS += $(OUTPUT)util/record.o
-LIB_OBJS += $(OUTPUT)util/srcline.o
-LIB_OBJS += $(OUTPUT)util/data.o
-LIB_OBJS += $(OUTPUT)util/tsc.o
-LIB_OBJS += $(OUTPUT)util/cloexec.o
-LIB_OBJS += $(OUTPUT)util/thread-stack.o
-
-LIB_OBJS += $(OUTPUT)ui/setup.o
-LIB_OBJS += $(OUTPUT)ui/helpline.o
-LIB_OBJS += $(OUTPUT)ui/progress.o
-LIB_OBJS += $(OUTPUT)ui/util.o
-LIB_OBJS += $(OUTPUT)ui/hist.o
-LIB_OBJS += $(OUTPUT)ui/stdio/hist.o
-
-LIB_OBJS += $(OUTPUT)arch/common.o
-
-LIB_OBJS += $(OUTPUT)tests/parse-events.o
-LIB_OBJS += $(OUTPUT)tests/dso-data.o
-LIB_OBJS += $(OUTPUT)tests/attr.o
-LIB_OBJS += $(OUTPUT)tests/vmlinux-kallsyms.o
-LIB_OBJS += $(OUTPUT)tests/open-syscall.o
-LIB_OBJS += $(OUTPUT)tests/open-syscall-all-cpus.o
-LIB_OBJS += $(OUTPUT)tests/open-syscall-tp-fields.o
-LIB_OBJS += $(OUTPUT)tests/mmap-basic.o
-LIB_OBJS += $(OUTPUT)tests/perf-record.o
-LIB_OBJS += $(OUTPUT)tests/rdpmc.o
-LIB_OBJS += $(OUTPUT)tests/evsel-roundtrip-name.o
-LIB_OBJS += $(OUTPUT)tests/evsel-tp-sched.o
-LIB_OBJS += $(OUTPUT)tests/fdarray.o
-LIB_OBJS += $(OUTPUT)tests/pmu.o
-LIB_OBJS += $(OUTPUT)tests/hists_common.o
-LIB_OBJS += $(OUTPUT)tests/hists_link.o
-LIB_OBJS += $(OUTPUT)tests/hists_filter.o
-LIB_OBJS += $(OUTPUT)tests/hists_output.o
-LIB_OBJS += $(OUTPUT)tests/hists_cumulate.o
-LIB_OBJS += $(OUTPUT)tests/python-use.o
-LIB_OBJS += $(OUTPUT)tests/bp_signal.o
-LIB_OBJS += $(OUTPUT)tests/bp_signal_overflow.o
-LIB_OBJS += $(OUTPUT)tests/task-exit.o
-LIB_OBJS += $(OUTPUT)tests/sw-clock.o
-ifeq ($(ARCH),x86)
-LIB_OBJS += $(OUTPUT)tests/perf-time-to-tsc.o
-endif
-LIB_OBJS += $(OUTPUT)tests/code-reading.o
-LIB_OBJS += $(OUTPUT)tests/sample-parsing.o
-LIB_OBJS += $(OUTPUT)tests/parse-no-sample-id-all.o
-ifndef NO_DWARF_UNWIND
-ifeq ($(ARCH),$(filter $(ARCH),x86 arm))
-LIB_OBJS += $(OUTPUT)tests/dwarf-unwind.o
-endif
-endif
-LIB_OBJS += $(OUTPUT)tests/mmap-thread-lookup.o
-LIB_OBJS += $(OUTPUT)tests/thread-mg-share.o
-LIB_OBJS += $(OUTPUT)tests/switch-tracking.o
-
-BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
-BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
-# Benchmark modules
-BUILTIN_OBJS += $(OUTPUT)bench/sched-messaging.o
-BUILTIN_OBJS += $(OUTPUT)bench/sched-pipe.o
-ifeq ($(ARCH), x86)
-ifeq ($(IS_64_BIT), 1)
-BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy-x86-64-asm.o
-BUILTIN_OBJS += $(OUTPUT)bench/mem-memset-x86-64-asm.o
-endif
-endif
-BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.o
-BUILTIN_OBJS += $(OUTPUT)bench/futex-hash.o
-BUILTIN_OBJS += $(OUTPUT)bench/futex-wake.o
-BUILTIN_OBJS += $(OUTPUT)bench/futex-requeue.o
-
-BUILTIN_OBJS += $(OUTPUT)builtin-diff.o
-BUILTIN_OBJS += $(OUTPUT)builtin-evlist.o
-BUILTIN_OBJS += $(OUTPUT)builtin-help.o
-BUILTIN_OBJS += $(OUTPUT)builtin-sched.o
-BUILTIN_OBJS += $(OUTPUT)builtin-buildid-list.o
-BUILTIN_OBJS += $(OUTPUT)builtin-buildid-cache.o
-BUILTIN_OBJS += $(OUTPUT)builtin-list.o
-BUILTIN_OBJS += $(OUTPUT)builtin-record.o
-BUILTIN_OBJS += $(OUTPUT)builtin-report.o
-BUILTIN_OBJS += $(OUTPUT)builtin-stat.o
-BUILTIN_OBJS += $(OUTPUT)builtin-timechart.o
-BUILTIN_OBJS += $(OUTPUT)builtin-top.o
-BUILTIN_OBJS += $(OUTPUT)builtin-script.o
-BUILTIN_OBJS += $(OUTPUT)builtin-probe.o
-BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o
-BUILTIN_OBJS += $(OUTPUT)builtin-lock.o
-BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
-BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
-BUILTIN_OBJS += $(OUTPUT)tests/builtin-test.o
-BUILTIN_OBJS += $(OUTPUT)builtin-mem.o
-
-PERFLIBS = $(LIB_FILE) $(LIBAPIKFS) $(LIBTRACEEVENT)
+PERFLIBS = $(LIB_FILE) $(LIBAPI) $(LIBTRACEEVENT)
 
 # We choose to avoid "if .. else if .. else .. endif endif"
 # because maintaining the nesting to match is a pain.  If
@@ -508,67 +236,9 @@ ifneq ($(OUTPUT),)
   CFLAGS += -I$(OUTPUT)
 endif
 
-ifdef NO_LIBELF
-# Remove ELF/DWARF dependent codes
-LIB_OBJS := $(filter-out $(OUTPUT)util/symbol-elf.o,$(LIB_OBJS))
-LIB_OBJS := $(filter-out $(OUTPUT)util/dwarf-aux.o,$(LIB_OBJS))
-LIB_OBJS := $(filter-out $(OUTPUT)util/probe-event.o,$(LIB_OBJS))
-LIB_OBJS := $(filter-out $(OUTPUT)util/probe-finder.o,$(LIB_OBJS))
-
-BUILTIN_OBJS := $(filter-out $(OUTPUT)builtin-probe.o,$(BUILTIN_OBJS))
-
-# Use minimal symbol handling
-LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
-
-else # NO_LIBELF
-ifndef NO_DWARF
-  LIB_OBJS += $(OUTPUT)util/probe-finder.o
-  LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
-endif # NO_DWARF
-endif # NO_LIBELF
-
-ifndef NO_LIBDW_DWARF_UNWIND
-  LIB_OBJS += $(OUTPUT)util/unwind-libdw.o
-  LIB_H += util/unwind-libdw.h
-endif
-
-ifndef NO_LIBUNWIND
-  LIB_OBJS += $(OUTPUT)util/unwind-libunwind.o
-endif
-LIB_OBJS += $(OUTPUT)tests/keep-tracking.o
-
-ifndef NO_LIBAUDIT
-  BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
-endif
-
-ifndef NO_SLANG
-  LIB_OBJS += $(OUTPUT)ui/browser.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/map.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/header.o
-  LIB_OBJS += $(OUTPUT)ui/tui/setup.o
-  LIB_OBJS += $(OUTPUT)ui/tui/util.o
-  LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
-  LIB_OBJS += $(OUTPUT)ui/tui/progress.o
-  LIB_H += ui/tui/tui.h
-  LIB_H += ui/browser.h
-  LIB_H += ui/browsers/map.h
-  LIB_H += ui/keysyms.h
-  LIB_H += ui/libslang.h
-endif
-
 ifndef NO_GTK2
   ALL_PROGRAMS += $(OUTPUT)libperf-gtk.so
-
-  GTK_OBJS += $(OUTPUT)ui/gtk/browser.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/hists.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/setup.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/util.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/helpline.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/progress.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/annotate.o
+  GTK_IN := $(OUTPUT)gtk-in.o
 
 install-gtk: $(OUTPUT)libperf-gtk.so
         $(call QUIET_INSTALL, 'GTK UI') \
@@ -576,31 +246,6 @@ install-gtk: $(OUTPUT)libperf-gtk.so
                 $(INSTALL) $(OUTPUT)libperf-gtk.so '$(DESTDIR_SQ)$(libdir_SQ)'
 endif
 
-ifndef NO_LIBPERL
-  LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
-  LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
-endif
-
-ifndef NO_LIBPYTHON
-  LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
-  LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
-endif
-
-ifeq ($(NO_PERF_REGS),0)
-  ifeq ($(ARCH),x86)
-    LIB_H += arch/x86/include/perf_regs.h
-  endif
-  LIB_OBJS += $(OUTPUT)util/perf_regs.o
-endif
-
-ifndef NO_LIBNUMA
-  BUILTIN_OBJS += $(OUTPUT)bench/numa.o
-endif
-
-ifndef NO_ZLIB
-  LIB_OBJS += $(OUTPUT)util/zlib.o
-endif
-
 ifdef ASCIIDOC8
   export ASCIIDOC8
 endif
@@ -616,39 +261,29 @@ SHELL = $(SHELL_PATH)
 all: shell_compatibility_test $(ALL_PROGRAMS) $(LANG_BINDINGS) $(OTHER_PROGRAMS)
 
 please_set_SHELL_PATH_to_a_more_modern_shell:
-        @$$(:)
+        $(Q)$$(:)
 
 shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
 
 strip: $(PROGRAMS) $(OUTPUT)perf
         $(STRIP) $(STRIP_OPTS) $(PROGRAMS) $(OUTPUT)perf
 
-$(OUTPUT)perf.o: perf.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -include $(OUTPUT)PERF-VERSION-FILE \
-                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                $(CFLAGS) -c $(filter %.c,$^) -o $@
+PERF_IN := $(OUTPUT)perf-in.o
 
-$(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
-        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OUTPUT)perf.o \
-               $(BUILTIN_OBJS) $(LIBS) -o $@
+export srctree OUTPUT RM CC LD AR CFLAGS V BISON FLEX
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
 
-$(GTK_OBJS): $(OUTPUT)%.o: %.c $(LIB_H)
-        $(QUIET_CC)$(CC) -o $@ -c -fPIC $(CFLAGS) $(GTK_CFLAGS) $<
+$(PERF_IN): $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h FORCE
+        $(Q)$(MAKE) $(build)=perf
 
-$(OUTPUT)libperf-gtk.so: $(GTK_OBJS) $(PERFLIBS)
-        $(QUIET_LINK)$(CC) -o $@ -shared $(LDFLAGS) $(filter %.o,$^) $(GTK_LIBS)
+$(OUTPUT)perf: $(PERFLIBS) $(PERF_IN)
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(PERF_IN) $(LIBS) -o $@
 
-$(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                '-DPERF_MAN_PATH="$(mandir_SQ)"' \
-                '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
+$(GTK_IN): FORCE
+        $(Q)$(MAKE) $(build)=gtk
 
-$(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                '-DPERF_MAN_PATH="$(mandir_SQ)"' \
-                '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
+$(OUTPUT)libperf-gtk.so: $(GTK_IN) $(PERFLIBS)
+        $(QUIET_LINK)$(CC) -o $@ -shared $(LDFLAGS) $(filter %.o,$^) $(GTK_LIBS)
 
 $(OUTPUT)common-cmds.h: util/generate-cmdlist.sh command-list.txt
 
@@ -659,8 +294,7 @@ $(SCRIPTS) : % : %.sh
         $(QUIET_GEN)$(INSTALL) '$@.sh' '$(OUTPUT)$@'
 
 # These can record PERF_VERSION
-$(OUTPUT)perf.o perf.spec \
-        $(SCRIPTS) \
+perf.spec $(SCRIPTS) \
         : $(OUTPUT)PERF-VERSION-FILE
 
 .SUFFIXES:
@@ -683,90 +317,33 @@ endif
 # These two need to be here so that when O= is not used they take precedence
 # over the general rule for .o
 
-$(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -w $<
-
-$(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
-
-$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
-$(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
-$(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -S $(CFLAGS) $<
-$(OUTPUT)%.o: %.S
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
-$(OUTPUT)%.s: %.S
-        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
-
-$(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                '-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
-                '-DPREFIX="$(prefix_SQ)"' \
-                $<
-
-$(OUTPUT)tests/attr.o: tests/attr.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                '-DBINDIR="$(bindir_SQ)"' -DPYTHON='"$(PYTHON_WORD)"' \
-                $<
-
-$(OUTPUT)tests/python-use.o: tests/python-use.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                -DPYTHONPATH='"$(OUTPUT)python"' \
-                -DPYTHON='"$(PYTHON_WORD)"' \
-                $<
-
-$(OUTPUT)tests/dwarf-unwind.o: tests/dwarf-unwind.c
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -fno-optimize-sibling-calls $<
+# get relative building directory (to $(OUTPUT))
+# and '.' if it's $(OUTPUT) itself
+__build-dir = $(subst $(OUTPUT),,$(dir $@))
+build-dir   = $(if $(__build-dir),$(__build-dir),.)
 
-$(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+single_dep: $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
 
-$(OUTPUT)ui/setup.o: ui/setup.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DLIBDIR='"$(libdir_SQ)"' $<
+$(OUTPUT)%.o: %.c single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
-$(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+$(OUTPUT)%.i: %.c single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
-$(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+$(OUTPUT)%.s: %.c single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
-$(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+$(OUTPUT)%-bison.o: %.c single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
-$(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+$(OUTPUT)%-flex.o: %.c single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
-$(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+$(OUTPUT)%.o: %.S single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
-$(OUTPUT)util/kallsyms.o: ../lib/symbol/kallsyms.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
-
-$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-
-$(OUTPUT)util/hweight.o: ../../lib/hweight.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-
-$(OUTPUT)util/find_next_bit.o: ../lib/util/find_next_bit.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-
-$(OUTPUT)util/parse-events.o: util/parse-events.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-redundant-decls $<
-
-$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default $<
-
-$(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default $<
-
-$(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
-
-$(OUTPUT)scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+$(OUTPUT)%.i: %.S single_dep FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
 
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
         $(QUIET_LINK)$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(filter %.o,$^) $(LIBS)
@@ -781,58 +358,34 @@ $(OUTPUT)perf-read-vdsox32: perf-read-vdso.c util/find-vdso-map.c
         $(QUIET_CC)$(CC) -mx32 $(filter -static,$(LDFLAGS)) -Wall -Werror -o $@ perf-read-vdso.c
 endif
 
-$(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
-$(patsubst perf-%,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
+$(patsubst perf-%,%.o,$(PROGRAMS)): $(wildcard */*.h)
 
-# we compile into subdirectories. if the target directory is not the source directory, they might not exists. So
-# we depend the various files onto their directories.
-DIRECTORY_DEPS = $(LIB_OBJS) $(BUILTIN_OBJS) $(GTK_OBJS)
-DIRECTORY_DEPS += $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
-# no need to add flex objects, because they depend on bison ones
-DIRECTORY_DEPS += $(OUTPUT)util/parse-events-bison.c
-DIRECTORY_DEPS += $(OUTPUT)util/pmu-bison.c
+LIBPERF_IN := $(OUTPUT)libperf-in.o
 
-OUTPUT_DIRECTORIES := $(sort $(dir $(DIRECTORY_DEPS)))
+$(LIBPERF_IN): FORCE
+        $(Q)$(MAKE) $(build)=libperf
 
-$(DIRECTORY_DEPS): | $(OUTPUT_DIRECTORIES)
-# In the second step, we make a rule to actually create these directories
-$(OUTPUT_DIRECTORIES):
-        $(QUIET_MKDIR)$(MKDIR) -p $@ 2>/dev/null
+$(LIB_FILE): $(LIBPERF_IN)
+        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIBPERF_IN) $(LIB_OBJS)
 
-$(LIB_FILE): $(LIB_OBJS)
-        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
-
-# libtraceevent.a
-TE_SOURCES = $(wildcard $(TRACE_EVENT_DIR)*.[ch])
-
-LIBTRACEEVENT_FLAGS  = $(QUIET_SUBDIR1) O=$(OUTPUT)
-LIBTRACEEVENT_FLAGS += CFLAGS="-g -Wall $(EXTRA_CFLAGS)"
 LIBTRACEEVENT_FLAGS += plugin_dir=$(plugindir_SQ)
 
-$(LIBTRACEEVENT): $(TE_SOURCES) $(OUTPUT)PERF-CFLAGS
-        $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) libtraceevent.a plugins
+$(LIBTRACEEVENT): FORCE
+        $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) O=$(OUTPUT) $(OUTPUT)libtraceevent.a plugins
 
 $(LIBTRACEEVENT)-clean:
         $(call QUIET_CLEAN, libtraceevent)
-        @$(MAKE) -C $(TRACE_EVENT_DIR) O=$(OUTPUT) clean >/dev/null
+        $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) O=$(OUTPUT) clean >/dev/null
 
 install-traceevent-plugins: $(LIBTRACEEVENT)
-        $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) install_plugins
+        $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) O=$(OUTPUT) install_plugins
 
-LIBAPIKFS_SOURCES = $(wildcard $(LIB_PATH)fs/*.[ch] $(LIB_PATH)fd/*.[ch])
-
-# if subdir is set, we've been called from above so target has been built
-# already
-$(LIBAPIKFS): $(LIBAPIKFS_SOURCES)
-ifeq ($(subdir),)
-        $(QUIET_SUBDIR0)$(LIB_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) libapikfs.a
-endif
+$(LIBAPI): FORCE
+        $(Q)$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) $(OUTPUT)libapi.a
 
-$(LIBAPIKFS)-clean:
-ifeq ($(subdir),)
-        $(call QUIET_CLEAN, libapikfs)
-        @$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) clean >/dev/null
-endif
+$(LIBAPI)-clean:
+        $(call QUIET_CLEAN, libapi)
+        $(Q)$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) clean >/dev/null
 
 help:
         @echo 'Perf make targets:'
@@ -888,17 +441,6 @@ cscope:
         $(QUIET_GEN)$(RM) cscope*; \
         $(FIND) $(TAG_FOLDERS) -name '*.[hcS]' -print | xargs cscope -b $(TAG_FILES)
 
-### Detect prefix changes
-TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):\
-             $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ):$(plugindir_SQ)
-
-$(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
-        @FLAGS='$(TRACK_CFLAGS)'; \
-            if test x"$$FLAGS" != x"`cat $(OUTPUT)PERF-CFLAGS 2>/dev/null`" ; then \
-                echo 1>&2 "  FLAGS:   * new build flags or prefix"; \
-                echo "$$FLAGS" >$(OUTPUT)PERF-CFLAGS; \
-            fi
-
 ### Testing rules
 
 # GNU make supports exporting all variables by "export" without parameters.
@@ -981,12 +523,14 @@ $(INSTALL_DOC_TARGETS):
 #
 config-clean:
         $(call QUIET_CLEAN, config)
-        @$(MAKE) -C config/feature-checks clean >/dev/null
+        $(Q)$(MAKE) -C $(srctree)/tools/build/feature/ clean >/dev/null
 
-clean: $(LIBTRACEEVENT)-clean $(LIBAPIKFS)-clean config-clean
-        $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(OUTPUT)perf.o $(LANG_BINDINGS) $(GTK_OBJS)
+clean: $(LIBTRACEEVENT)-clean $(LIBAPI)-clean config-clean
+        $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(LANG_BINDINGS)
+        $(Q)find . -name '*.o' -delete -o -name '\.*.cmd' -delete -o -name '\.*.d' -delete
+        $(Q)$(RM) .config-detected
         $(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf perf-read-vdso32 perf-read-vdsox32
-        $(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS $(OUTPUT)PERF-FEATURES $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex*
+        $(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)FEATURE-DUMP $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex*
         $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
         $(python-clean)
 
@@ -1000,7 +544,9 @@ else
     GIT-HEAD-PHONY =
 endif
 
+FORCE:
+
 .PHONY: all install clean config-clean strip install-gtk
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
-.PHONY: $(GIT-HEAD-PHONY) TAGS tags cscope .FORCE-PERF-CFLAGS
+.PHONY: $(GIT-HEAD-PHONY) TAGS tags cscope FORCE single_dep
 
diff --git a/tools/perf/arch/Build b/tools/perf/arch/Build
new file mode 100644
index 000000000000..109eb75cf7de
--- /dev/null
+++ b/tools/perf/arch/Build
@@ -0,0 +1,2 @@
+libperf-y += common.o
+libperf-y += $(ARCH)/
diff --git a/tools/perf/arch/arm/Build b/tools/perf/arch/arm/Build
new file mode 100644
index 000000000000..41bf61da476a
--- /dev/null
+++ b/tools/perf/arch/arm/Build
@@ -0,0 +1,2 @@
+libperf-y += util/
+libperf-$(CONFIG_DWARF_UNWIND) += tests/
diff --git a/tools/perf/arch/arm/Makefile b/tools/perf/arch/arm/Makefile
index 09d62153d384..7fbca175099e 100644
--- a/tools/perf/arch/arm/Makefile
+++ b/tools/perf/arch/arm/Makefile
@@ -1,14 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
-endif
-ifndef NO_LIBUNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libunwind.o
-endif
-ifndef NO_LIBDW_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libdw.o
-endif
-ifndef NO_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/regs_load.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/dwarf-unwind.o
 endif
diff --git a/tools/perf/arch/arm/tests/Build b/tools/perf/arch/arm/tests/Build
new file mode 100644
index 000000000000..b30eff9bcc83
--- /dev/null
+++ b/tools/perf/arch/arm/tests/Build
@@ -0,0 +1,2 @@
+libperf-y += regs_load.o
+libperf-y += dwarf-unwind.o
diff --git a/tools/perf/arch/arm/util/Build b/tools/perf/arch/arm/util/Build
new file mode 100644
index 000000000000..d22e3d07de3d
--- /dev/null
+++ b/tools/perf/arch/arm/util/Build
@@ -0,0 +1,4 @@
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
+
+libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
diff --git a/tools/perf/arch/arm64/Build b/tools/perf/arch/arm64/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/arm64/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/arm64/Makefile b/tools/perf/arch/arm64/Makefile
index 67e9b3d38e89..7fbca175099e 100644
--- a/tools/perf/arch/arm64/Makefile
+++ b/tools/perf/arch/arm64/Makefile
@@ -1,7 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
-endif
-ifndef NO_LIBUNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libunwind.o
 endif
diff --git a/tools/perf/arch/arm64/util/Build b/tools/perf/arch/arm64/util/Build
new file mode 100644
index 000000000000..e58123a8912b
--- /dev/null
+++ b/tools/perf/arch/arm64/util/Build
@@ -0,0 +1,2 @@
+libperf-$(CONFIG_DWARF)     += dwarf-regs.o
+libperf-$(CONFIG_LIBUNWIND) += unwind-libunwind.o
diff --git a/tools/perf/arch/powerpc/Build b/tools/perf/arch/powerpc/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/powerpc/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
index 6f7782bea5dd..7fbca175099e 100644
--- a/tools/perf/arch/powerpc/Makefile
+++ b/tools/perf/arch/powerpc/Makefile
@@ -1,6 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/skip-callchain-idx.o
 endif
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
diff --git a/tools/perf/arch/powerpc/util/Build b/tools/perf/arch/powerpc/util/Build
new file mode 100644
index 000000000000..0af6e9b3f728
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/Build
@@ -0,0 +1,4 @@
+libperf-y += header.o
+
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
+libperf-$(CONFIG_DWARF) += skip-callchain-idx.o
diff --git a/tools/perf/arch/s390/Build b/tools/perf/arch/s390/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/s390/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/s390/Makefile b/tools/perf/arch/s390/Makefile
index 798ac7379c5f..21322e0385b8 100644
--- a/tools/perf/arch/s390/Makefile
+++ b/tools/perf/arch/s390/Makefile
@@ -1,7 +1,4 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
 HAVE_KVM_STAT_SUPPORT := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/kvm-stat.o
diff --git a/tools/perf/arch/s390/util/Build b/tools/perf/arch/s390/util/Build
new file mode 100644
index 000000000000..8a61372bb47a
--- /dev/null
+++ b/tools/perf/arch/s390/util/Build
@@ -0,0 +1,4 @@
+libperf-y += header.o
+libperf-y += kvm-stat.o
+
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/sh/Build b/tools/perf/arch/sh/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/sh/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/sh/Makefile b/tools/perf/arch/sh/Makefile
index 15130b50dfe3..7fbca175099e 100644
--- a/tools/perf/arch/sh/Makefile
+++ b/tools/perf/arch/sh/Makefile
@@ -1,4 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
diff --git a/tools/perf/arch/sh/util/Build b/tools/perf/arch/sh/util/Build
new file mode 100644
index 000000000000..954e287bbb89
--- /dev/null
+++ b/tools/perf/arch/sh/util/Build
@@ -0,0 +1 @@
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/sparc/Build b/tools/perf/arch/sparc/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/sparc/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/sparc/Makefile b/tools/perf/arch/sparc/Makefile
index 15130b50dfe3..7fbca175099e 100644
--- a/tools/perf/arch/sparc/Makefile
+++ b/tools/perf/arch/sparc/Makefile
@@ -1,4 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
diff --git a/tools/perf/arch/sparc/util/Build b/tools/perf/arch/sparc/util/Build
new file mode 100644
index 000000000000..954e287bbb89
--- /dev/null
+++ b/tools/perf/arch/sparc/util/Build
@@ -0,0 +1 @@
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/x86/Build b/tools/perf/arch/x86/Build
new file mode 100644
index 000000000000..41bf61da476a
--- /dev/null
+++ b/tools/perf/arch/x86/Build
@@ -0,0 +1,2 @@
+libperf-y += util/
+libperf-$(CONFIG_DWARF_UNWIND) += tests/
diff --git a/tools/perf/arch/x86/Makefile b/tools/perf/arch/x86/Makefile
index 9b21881db52f..21322e0385b8 100644
--- a/tools/perf/arch/x86/Makefile
+++ b/tools/perf/arch/x86/Makefile
@@ -1,19 +1,4 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
-ifndef NO_LIBUNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libunwind.o
-endif
-ifndef NO_LIBDW_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libdw.o
-endif
-ifndef NO_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/regs_load.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/dwarf-unwind.o
-endif
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/tsc.o
-LIB_H += arch/$(ARCH)/util/tsc.h
 HAVE_KVM_STAT_SUPPORT := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/kvm-stat.o
diff --git a/tools/perf/arch/x86/tests/Build b/tools/perf/arch/x86/tests/Build
new file mode 100644
index 000000000000..b30eff9bcc83
--- /dev/null
+++ b/tools/perf/arch/x86/tests/Build
@@ -0,0 +1,2 @@
+libperf-y += regs_load.o
+libperf-y += dwarf-unwind.o
diff --git a/tools/perf/arch/x86/util/Build b/tools/perf/arch/x86/util/Build
new file mode 100644
index 000000000000..cfbccc4e3187
--- /dev/null
+++ b/tools/perf/arch/x86/util/Build
@@ -0,0 +1,8 @@
+libperf-y += header.o
+libperf-y += tsc.o
+libperf-y += kvm-stat.o
+
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
+
+libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
diff --git a/tools/perf/bench/Build b/tools/perf/bench/Build
new file mode 100644
index 000000000000..5ce98023d518
--- /dev/null
+++ b/tools/perf/bench/Build
@@ -0,0 +1,11 @@
+perf-y += sched-messaging.o
+perf-y += sched-pipe.o
+perf-y += mem-memcpy.o
+perf-y += futex-hash.o
+perf-y += futex-wake.o
+perf-y += futex-requeue.o
+
+perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o
+perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.o
+
+perf-$(CONFIG_NUMA) += numa.o
diff --git a/tools/perf/bench/mem-memcpy-x86-64-asm-def.h b/tools/perf/bench/mem-memcpy-x86-64-asm-def.h
index d66ab799b35f..8c0c1a2770c8 100644
--- a/tools/perf/bench/mem-memcpy-x86-64-asm-def.h
+++ b/tools/perf/bench/mem-memcpy-x86-64-asm-def.h
@@ -1,12 +1,12 @@
 
-MEMCPY_FN(__memcpy,
+MEMCPY_FN(memcpy_orig,
         "x86-64-unrolled",
         "unrolled memcpy() in arch/x86/lib/memcpy_64.S")
 
-MEMCPY_FN(memcpy_c,
+MEMCPY_FN(__memcpy,
         "x86-64-movsq",
         "movsq-based memcpy() in arch/x86/lib/memcpy_64.S")
 
-MEMCPY_FN(memcpy_c_e,
+MEMCPY_FN(memcpy_erms,
         "x86-64-movsb",
         "movsb-based memcpy() in arch/x86/lib/memcpy_64.S")
diff --git a/tools/perf/bench/mem-memcpy-x86-64-asm.S b/tools/perf/bench/mem-memcpy-x86-64-asm.S
index fcd9cf00600a..e4c2c30143b9 100644
--- a/tools/perf/bench/mem-memcpy-x86-64-asm.S
+++ b/tools/perf/bench/mem-memcpy-x86-64-asm.S
@@ -1,8 +1,6 @@
 #define memcpy MEMCPY /* don't hide glibc's memcpy() */
 #define altinstr_replacement text
 #define globl p2align 4; .globl
-#define Lmemcpy_c globl memcpy_c; memcpy_c
-#define Lmemcpy_c_e globl memcpy_c_e; memcpy_c_e
 #include "../../../arch/x86/lib/memcpy_64.S"
 /*
  * We need to provide note.GNU-stack section, saying that we want
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index db1d3a29d97f..d3dfb7936dcd 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -36,7 +36,7 @@ static const struct option options[] = {
                     "Specify length of memory to copy. "
                     "Available units: B, KB, MB, GB and TB (upper and lower)"),
         OPT_STRING('r', "routine", &routine, "default",
-                    "Specify routine to copy"),
+                    "Specify routine to copy, \"all\" runs all available routines"),
         OPT_INTEGER('i', "iterations", &iterations,
                     "repeat memcpy() invocation this number of times"),
         OPT_BOOLEAN('c', "cycle", &use_cycle,
@@ -135,55 +135,16 @@ struct bench_mem_info {
         const char *const *usage;
 };
 
-static int bench_mem_common(int argc, const char **argv,
-                     const char *prefix __maybe_unused,
-                     struct bench_mem_info *info)
+static void __bench_mem_routine(struct bench_mem_info *info, int r_idx, size_t len, double totallen)
 {
-        int i;
-        size_t len;
-        double totallen;
+        const struct routine *r = &info->routines[r_idx];
         double result_bps[2];
         u64 result_cycle[2];
 
-        argc = parse_options(argc, argv, options,
-                             info->usage, 0);
-
-        if (no_prefault && only_prefault) {
-                fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
-                return 1;
-        }
-
-        if (use_cycle)
-                init_cycle();
-
-        len = (size_t)perf_atoll((char *)length_str);
-        totallen = (double)len * iterations;
-
         result_cycle[0] = result_cycle[1] = 0ULL;
         result_bps[0] = result_bps[1] = 0.0;
 
-        if ((s64)len <= 0) {
-                fprintf(stderr, "Invalid length:%s\n", length_str);
-                return 1;
-        }
-
-        /* same to without specifying either of prefault and no-prefault */
-        if (only_prefault && no_prefault)
-                only_prefault = no_prefault = false;
-
-        for (i = 0; info->routines[i].name; i++) {
-                if (!strcmp(info->routines[i].name, routine))
-                        break;
-        }
-        if (!info->routines[i].name) {
-                printf("Unknown routine:%s\n", routine);
-                printf("Available routines...\n");
-                for (i = 0; info->routines[i].name; i++) {
-                        printf("\t%s ... %s\n",
-                               info->routines[i].name, info->routines[i].desc);
-                }
-                return 1;
-        }
+        printf("Routine %s (%s)\n", r->name, r->desc);
 
         if (bench_format == BENCH_FORMAT_DEFAULT)
                 printf("# Copying %s Bytes ...\n\n", length_str);
@@ -191,28 +152,17 @@ static int bench_mem_common(int argc, const char **argv,
         if (!only_prefault && !no_prefault) {
                 /* show both of results */
                 if (use_cycle) {
-                        result_cycle[0] =
-                                info->do_cycle(&info->routines[i], len, false);
-                        result_cycle[1] =
-                                info->do_cycle(&info->routines[i], len, true);
+                        result_cycle[0] = info->do_cycle(r, len, false);
+                        result_cycle[1] = info->do_cycle(r, len, true);
                 } else {
-                        result_bps[0] =
-                                info->do_gettimeofday(&info->routines[i],
-                                                len, false);
-                        result_bps[1] =
-                                info->do_gettimeofday(&info->routines[i],
-                                                len, true);
+                        result_bps[0]   = info->do_gettimeofday(r, len, false);
+                        result_bps[1]   = info->do_gettimeofday(r, len, true);
                 }
         } else {
-                if (use_cycle) {
-                        result_cycle[pf] =
-                                info->do_cycle(&info->routines[i],
-                                                len, only_prefault);
-                } else {
-                        result_bps[pf] =
-                                info->do_gettimeofday(&info->routines[i],
-                                                len, only_prefault);
-                }
+                if (use_cycle)
+                        result_cycle[pf] = info->do_cycle(r, len, only_prefault);
+                else
+                        result_bps[pf] = info->do_gettimeofday(r, len, only_prefault);
         }
 
         switch (bench_format) {
@@ -265,6 +215,60 @@ static int bench_mem_common(int argc, const char **argv,
                 die("unknown format: %d\n", bench_format);
                 break;
         }
+}
+
+static int bench_mem_common(int argc, const char **argv,
+                     const char *prefix __maybe_unused,
+                     struct bench_mem_info *info)
+{
+        int i;
+        size_t len;
+        double totallen;
+
+        argc = parse_options(argc, argv, options,
+                             info->usage, 0);
+
+        if (no_prefault && only_prefault) {
+                fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
+                return 1;
+        }
+
+        if (use_cycle)
+                init_cycle();
+
+        len = (size_t)perf_atoll((char *)length_str);
+        totallen = (double)len * iterations;
+
+        if ((s64)len <= 0) {
+                fprintf(stderr, "Invalid length:%s\n", length_str);
+                return 1;
+        }
+
+        /* same to without specifying either of prefault and no-prefault */
+        if (only_prefault && no_prefault)
+                only_prefault = no_prefault = false;
+
+        if (!strncmp(routine, "all", 3)) {
+                for (i = 0; info->routines[i].name; i++)
+                        __bench_mem_routine(info, i, len, totallen);
+                return 0;
+        }
+
+        for (i = 0; info->routines[i].name; i++) {
+                if (!strcmp(info->routines[i].name, routine))
+                        break;
+        }
+        if (!info->routines[i].name) {
+                printf("Unknown routine:%s\n", routine);
+                printf("Available routines...\n");
+                for (i = 0; info->routines[i].name; i++) {
+                        printf("\t%s ... %s\n",
+                               info->routines[i].name, info->routines[i].desc);
+                }
+                return 1;
+        }
+
+        __bench_mem_routine(info, i, len, totallen);
 
         return 0;
 }
diff --git a/tools/perf/bench/mem-memset-x86-64-asm-def.h b/tools/perf/bench/mem-memset-x86-64-asm-def.h
index a71dff97c1f5..f02d028771d9 100644
--- a/tools/perf/bench/mem-memset-x86-64-asm-def.h
+++ b/tools/perf/bench/mem-memset-x86-64-asm-def.h
@@ -1,12 +1,12 @@
 
-MEMSET_FN(__memset,
+MEMSET_FN(memset_orig,
         "x86-64-unrolled",
         "unrolled memset() in arch/x86/lib/memset_64.S")
 
-MEMSET_FN(memset_c,
+MEMSET_FN(__memset,
         "x86-64-stosq",
         "movsq-based memset() in arch/x86/lib/memset_64.S")
 
-MEMSET_FN(memset_c_e,
+MEMSET_FN(memset_erms,
         "x86-64-stosb",
         "movsb-based memset() in arch/x86/lib/memset_64.S")
diff --git a/tools/perf/bench/mem-memset-x86-64-asm.S b/tools/perf/bench/mem-memset-x86-64-asm.S
index 9e5af89ed13a..de278784c866 100644
--- a/tools/perf/bench/mem-memset-x86-64-asm.S
+++ b/tools/perf/bench/mem-memset-x86-64-asm.S
@@ -1,8 +1,6 @@
 #define memset MEMSET /* don't hide glibc's memset() */
 #define altinstr_replacement text
 #define globl p2align 4; .globl
-#define Lmemset_c globl memset_c; memset_c
-#define Lmemset_c_e globl memset_c_e; memset_c_e
 #include "../../../arch/x86/lib/memset_64.S"
 
 /*
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 747f86103599..71bf7451c0ca 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -208,7 +208,7 @@ static int __cmd_annotate(struct perf_annotate *ann)
                         goto out;
         }
 
-        ret = perf_session__process_events(session, &ann->tool);
+        ret = perf_session__process_events(session);
         if (ret)
                 goto out;
 
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index 50e6b66aea1f..d47a0cdc71c9 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -125,8 +125,7 @@ static int build_id_cache__kcore_existing(const char *from_dir, char *to_dir,
         return ret;
 }
 
-static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
-                                     bool force)
+static int build_id_cache__add_kcore(const char *filename, bool force)
 {
         char dir[32], sbuildid[BUILD_ID_SIZE * 2 + 1];
         char from_dir[PATH_MAX], to_dir[PATH_MAX];
@@ -143,7 +142,7 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
                 return -1;
 
         scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s",
-                  debugdir, sbuildid);
+                  buildid_dir, sbuildid);
 
         if (!force &&
             !build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
@@ -155,7 +154,7 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
                 return -1;
 
         scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s/%s",
-                  debugdir, sbuildid, dir);
+                  buildid_dir, sbuildid, dir);
 
         if (mkdir_p(to_dir, 0755))
                 return -1;
@@ -183,7 +182,7 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
         return 0;
 }
 
-static int build_id_cache__add_file(const char *filename, const char *debugdir)
+static int build_id_cache__add_file(const char *filename)
 {
         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
         u8 build_id[BUILD_ID_SIZE];
@@ -195,16 +194,14 @@ static int build_id_cache__add_file(const char *filename, const char *debugdir)
         }
 
         build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
-        err = build_id_cache__add_s(sbuild_id, debugdir, filename,
+        err = build_id_cache__add_s(sbuild_id, filename,
                                     false, false);
-        if (verbose)
-                pr_info("Adding %s %s: %s\n", sbuild_id, filename,
-                        err ? "FAIL" : "Ok");
+        pr_debug("Adding %s %s: %s\n", sbuild_id, filename,
+                 err ? "FAIL" : "Ok");
         return err;
 }
 
-static int build_id_cache__remove_file(const char *filename,
-                                       const char *debugdir)
+static int build_id_cache__remove_file(const char *filename)
 {
         u8 build_id[BUILD_ID_SIZE];
         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
@@ -217,10 +214,34 @@ static int build_id_cache__remove_file(const char *filename,
         }
 
         build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
-        err = build_id_cache__remove_s(sbuild_id, debugdir);
-        if (verbose)
-                pr_info("Removing %s %s: %s\n", sbuild_id, filename,
-                        err ? "FAIL" : "Ok");
+        err = build_id_cache__remove_s(sbuild_id);
+        pr_debug("Removing %s %s: %s\n", sbuild_id, filename,
+                 err ? "FAIL" : "Ok");
+
+        return err;
+}
+
+static int build_id_cache__purge_path(const char *pathname)
+{
+        struct strlist *list;
+        struct str_node *pos;
+        int err;
+
+        err = build_id_cache__list_build_ids(pathname, &list);
+        if (err)
+                goto out;
+
+        strlist__for_each(pos, list) {
+                err = build_id_cache__remove_s(pos->s);
+                pr_debug("Removing %s %s: %s\n", pos->s, pathname,
+                         err ? "FAIL" : "Ok");
+                if (err)
+                        break;
+        }
+        strlist__delete(list);
+
+out:
+        pr_debug("Purging %s: %s\n", pathname, err ? "FAIL" : "Ok");
 
         return err;
 }
@@ -252,13 +273,12 @@ static int build_id_cache__fprintf_missing(struct perf_session *session, FILE *f
         return 0;
 }
 
-static int build_id_cache__update_file(const char *filename,
-                                       const char *debugdir)
+static int build_id_cache__update_file(const char *filename)
 {
         u8 build_id[BUILD_ID_SIZE];
         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 
-        int err;
+        int err = 0;
 
         if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
                 pr_debug("Couldn't read a build-id in %s\n", filename);
@@ -266,14 +286,14 @@ static int build_id_cache__update_file(const char *filename,
         }
 
         build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
-        err = build_id_cache__remove_s(sbuild_id, debugdir);
-        if (!err) {
-                err = build_id_cache__add_s(sbuild_id, debugdir, filename,
-                                            false, false);
-        }
-        if (verbose)
-                pr_info("Updating %s %s: %s\n", sbuild_id, filename,
-                        err ? "FAIL" : "Ok");
+        if (build_id_cache__cached(sbuild_id))
+                err = build_id_cache__remove_s(sbuild_id);
+
+        if (!err)
+                err = build_id_cache__add_s(sbuild_id, filename, false, false);
+
+        pr_debug("Updating %s %s: %s\n", sbuild_id, filename,
+                 err ? "FAIL" : "Ok");
 
         return err;
 }
@@ -287,6 +307,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         bool force = false;
         char const *add_name_list_str = NULL,
                    *remove_name_list_str = NULL,
+                   *purge_name_list_str = NULL,
                    *missing_filename = NULL,
                    *update_name_list_str = NULL,
                    *kcore_filename = NULL;
@@ -304,6 +325,8 @@ int cmd_buildid_cache(int argc, const char **argv,
                    "file", "kcore file to add"),
         OPT_STRING('r', "remove", &remove_name_list_str, "file list",
                     "file(s) to remove"),
+        OPT_STRING('p', "purge", &purge_name_list_str, "path list",
+                    "path(s) to remove (remove old caches too)"),
         OPT_STRING('M', "missing", &missing_filename, "file",
                    "to find missing build ids in the cache"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
@@ -320,6 +343,11 @@ int cmd_buildid_cache(int argc, const char **argv,
         argc = parse_options(argc, argv, buildid_cache_options,
                              buildid_cache_usage, 0);
 
+        if (argc || (!add_name_list_str && !kcore_filename &&
+                     !remove_name_list_str && !purge_name_list_str &&
+                     !missing_filename && !update_name_list_str))
+                usage_with_options(buildid_cache_usage, buildid_cache_options);
+
         if (missing_filename) {
                 file.path = missing_filename;
                 file.force = force;
@@ -338,7 +366,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                 list = strlist__new(true, add_name_list_str);
                 if (list) {
                         strlist__for_each(pos, list)
-                                if (build_id_cache__add_file(pos->s, buildid_dir)) {
+                                if (build_id_cache__add_file(pos->s)) {
                                         if (errno == EEXIST) {
                                                 pr_debug("%s already in the cache\n",
                                                          pos->s);
@@ -356,7 +384,25 @@ int cmd_buildid_cache(int argc, const char **argv,
                 list = strlist__new(true, remove_name_list_str);
                 if (list) {
                         strlist__for_each(pos, list)
-                                if (build_id_cache__remove_file(pos->s, buildid_dir)) {
+                                if (build_id_cache__remove_file(pos->s)) {
+                                        if (errno == ENOENT) {
+                                                pr_debug("%s wasn't in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't remove %s: %s\n",
+                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
+                                }
+
+                        strlist__delete(list);
+                }
+        }
+
+        if (purge_name_list_str) {
+                list = strlist__new(true, purge_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__purge_path(pos->s)) {
                                         if (errno == ENOENT) {
                                                 pr_debug("%s wasn't in the cache\n",
                                                          pos->s);
@@ -377,7 +423,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                 list = strlist__new(true, update_name_list_str);
                 if (list) {
                         strlist__for_each(pos, list)
-                                if (build_id_cache__update_file(pos->s, buildid_dir)) {
+                                if (build_id_cache__update_file(pos->s)) {
                                         if (errno == ENOENT) {
                                                 pr_debug("%s wasn't in the cache\n",
                                                          pos->s);
@@ -391,8 +437,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                 }
         }
 
-        if (kcore_filename &&
-            build_id_cache__add_kcore(kcore_filename, buildid_dir, force))
+        if (kcore_filename && build_id_cache__add_kcore(kcore_filename, force))
                 pr_warning("Couldn't add %s\n", kcore_filename);
 
 out:
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index ed3873b3e238..feb420f74c2d 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -74,7 +74,7 @@ static int perf_session__list_build_ids(bool force, bool with_hits)
          * the record stream. Buildids are stored as RECORD_HEADER_BUILD_ID
          */
         if (with_hits || perf_data_file__is_pipe(&file))
-                perf_session__process_events(session, &build_id__mark_dso_hit_ops);
+                perf_session__process_events(session);
 
         perf_session__fprintf_dsos_buildid(session, stdout, dso__skip_buildid, with_hits);
         perf_session__delete(session);
diff --git a/tools/perf/builtin-data.c b/tools/perf/builtin-data.c
new file mode 100644
index 000000000000..d6525bc54d13
--- /dev/null
+++ b/tools/perf/builtin-data.c
@@ -0,0 +1,123 @@
+#include <linux/compiler.h>
+#include "builtin.h"
+#include "perf.h"
+#include "debug.h"
+#include "parse-options.h"
+#include "data-convert-bt.h"
+
+typedef int (*data_cmd_fn_t)(int argc, const char **argv, const char *prefix);
+
+struct data_cmd {
+        const char      *name;
+        const char      *summary;
+        data_cmd_fn_t   fn;
+};
+
+static struct data_cmd data_cmds[];
+
+#define for_each_cmd(cmd) \
+        for (cmd = data_cmds; cmd && cmd->name; cmd++)
+
+static const struct option data_options[] = {
+        OPT_END()
+};
+
+static const char * const data_subcommands[] = { "convert", NULL };
+
+static const char *data_usage[] = {
+        "perf data [<common options>] <command> [<options>]",
+        NULL
+};
+
+static void print_usage(void)
+{
+        struct data_cmd *cmd;
+
+        printf("Usage:\n");
+        printf("\t%s\n\n", data_usage[0]);
+        printf("\tAvailable commands:\n");
+
+        for_each_cmd(cmd) {
+                printf("\t %s\t- %s\n", cmd->name, cmd->summary);
+        }
+
+        printf("\n");
+}
+
+static const char * const data_convert_usage[] = {
+        "perf data convert [<options>]",
+        NULL
+};
+
+static int cmd_data_convert(int argc, const char **argv,
+                            const char *prefix __maybe_unused)
+{
+        const char *to_ctf     = NULL;
+        bool force = false;
+        const struct option options[] = {
+                OPT_INCR('v', "verbose", &verbose, "be more verbose"),
+                OPT_STRING('i', "input", &input_name, "file", "input file name"),
+#ifdef HAVE_LIBBABELTRACE_SUPPORT
+                OPT_STRING(0, "to-ctf", &to_ctf, NULL, "Convert to CTF format"),
+#endif
+                OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+                OPT_END()
+        };
+
+#ifndef HAVE_LIBBABELTRACE_SUPPORT
+        pr_err("No conversion support compiled in.\n");
+        return -1;
+#endif
+
+        argc = parse_options(argc, argv, options,
+                             data_convert_usage, 0);
+        if (argc) {
+                usage_with_options(data_convert_usage, options);
+                return -1;
+        }
+
+        if (to_ctf) {
+#ifdef HAVE_LIBBABELTRACE_SUPPORT
+                return bt_convert__perf2ctf(input_name, to_ctf, force);
+#else
+                pr_err("The libbabeltrace support is not compiled in.\n");
+                return -1;
+#endif
+        }
+
+        return 0;
+}
+
+static struct data_cmd data_cmds[] = {
+        { "convert", "converts data file between formats", cmd_data_convert },
+        { .name = NULL, },
+};
+
+int cmd_data(int argc, const char **argv, const char *prefix)
+{
+        struct data_cmd *cmd;
+        const char *cmdstr;
+
+        /* No command specified. */
+        if (argc < 2)
+                goto usage;
+
+        argc = parse_options_subcommand(argc, argv, data_options, data_subcommands, data_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+        if (argc < 1)
+                goto usage;
+
+        cmdstr = argv[0];
+
+        for_each_cmd(cmd) {
+                if (strcmp(cmd->name, cmdstr))
+                        continue;
+
+                return cmd->fn(argc, argv, prefix);
+        }
+
+        pr_err("Unknown command: %s\n", cmdstr);
+usage:
+        print_usage();
+        return -1;
+}
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 74aada554b12..df6307b4050a 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -747,7 +747,7 @@ static int __cmd_diff(void)
                         goto out_delete;
                 }
 
-                ret = perf_session__process_events(d->session, &tool);
+                ret = perf_session__process_events(d->session);
                 if (ret) {
                         pr_err("Failed to process %s\n", d->file.path);
                         goto out_delete;
@@ -791,6 +791,8 @@ static const struct option options[] = {
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
+                   "file", "kallsyms pathname"),
         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
@@ -802,7 +804,7 @@ static const struct option options[] = {
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
                    "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
                    " Please refer the man page for the complete list."),
-        OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
+        OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
                    "separator for columns, no spaces will be added between "
                    "columns '.' is reserved."),
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index 0f93f859b782..695ec5a50cf2 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -24,6 +24,7 @@ static int __cmd_evlist(const char *file_name, struct perf_attr_details *details
         struct perf_data_file file = {
                 .path = file_name,
                 .mode = PERF_DATA_MODE_READ,
+                .force = details->force,
         };
 
         session = perf_session__new(&file, 0, NULL);
@@ -47,6 +48,7 @@ int cmd_evlist(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show all event attr details"),
         OPT_BOOLEAN('g', "group", &details.event_group,
                     "Show event group information"),
+        OPT_BOOLEAN('f', "force", &details.force, "don't complain, do it"),
         OPT_END()
         };
         const char * const evlist_usage[] = {
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 25d20628212e..36486eade1ef 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -437,7 +437,18 @@ int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
                         HELP_FORMAT_INFO),
         OPT_END(),
         };
-        const char * const builtin_help_usage[] = {
+        const char * const builtin_help_subcommands[] = {
+                "buildid-cache", "buildid-list", "diff", "evlist", "help", "list",
+                "record", "report", "bench", "stat", "timechart", "top", "annotate",
+                "script", "sched", "kmem", "lock", "kvm", "test", "inject", "mem", "data",
+#ifdef HAVE_LIBELF_SUPPORT
+                "probe",
+#endif
+#ifdef HAVE_LIBAUDIT_SUPPORT
+                "trace",
+#endif
+        NULL };
+        const char *builtin_help_usage[] = {
                 "perf help [--all] [--man|--web|--info] [command]",
                 NULL
         };
@@ -448,8 +459,8 @@ int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
 
         perf_config(perf_help_config, &help_format);
 
-        argc = parse_options(argc, argv, builtin_help_options,
-                        builtin_help_usage, 0);
+        argc = parse_options_subcommand(argc, argv, builtin_help_options,
+                        builtin_help_subcommands, builtin_help_usage, 0);
 
         if (show_all) {
                 printf("\n usage: %s\n\n", perf_usage_string);
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index a13641e066f5..40a33d7334cc 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -53,6 +53,13 @@ static int perf_event__repipe_synth(struct perf_tool *tool,
         return 0;
 }
 
+static int perf_event__repipe_oe_synth(struct perf_tool *tool,
+                                       union perf_event *event,
+                                       struct ordered_events *oe __maybe_unused)
+{
+        return perf_event__repipe_synth(tool, event);
+}
+
 static int perf_event__repipe_op2_synth(struct perf_tool *tool,
                                         union perf_event *event,
                                         struct perf_session *session
@@ -359,8 +366,6 @@ static int __cmd_inject(struct perf_inject *inject)
         } else if (inject->sched_stat) {
                 struct perf_evsel *evsel;
 
-                inject->tool.ordered_events = true;
-
                 evlist__for_each(session->evlist, evsel) {
                         const char *name = perf_evsel__name(evsel);
 
@@ -379,7 +384,7 @@ static int __cmd_inject(struct perf_inject *inject)
         if (!file_out->is_pipe)
                 lseek(fd, session->header.data_offset, SEEK_SET);
 
-        ret = perf_session__process_events(session, &inject->tool);
+        ret = perf_session__process_events(session);
 
         if (!file_out->is_pipe) {
                 if (inject->build_ids)
@@ -408,7 +413,7 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                         .unthrottle     = perf_event__repipe,
                         .attr           = perf_event__repipe_attr,
                         .tracing_data   = perf_event__repipe_op2_synth,
-                        .finished_round = perf_event__repipe_op2_synth,
+                        .finished_round = perf_event__repipe_oe_synth,
                         .build_id       = perf_event__repipe_op2_synth,
                         .id_index       = perf_event__repipe_op2_synth,
                 },
@@ -438,6 +443,7 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                          "be more verbose (show build ids, etc)"),
                 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
                            "kallsyms pathname"),
+                OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
                 OPT_END()
         };
         const char * const inject_usage[] = {
@@ -458,6 +464,8 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                 return -1;
         }
 
+        inject.tool.ordered_events = inject.sched_stat;
+
         file.path = inject.input_name;
         inject.session = perf_session__new(&file, true, &inject.tool);
         if (inject.session == NULL)
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index f295141025bc..63ea01349b6e 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -20,6 +20,12 @@
 
 #include <linux/rbtree.h>
 #include <linux/string.h>
+#include <locale.h>
+
+static int      kmem_slab;
+static int      kmem_page;
+
+static long     kmem_page_size;
 
 struct alloc_stat;
 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
@@ -225,6 +231,244 @@ static int perf_evsel__process_free_event(struct perf_evsel *evsel,
         return 0;
 }
 
+static u64 total_page_alloc_bytes;
+static u64 total_page_free_bytes;
+static u64 total_page_nomatch_bytes;
+static u64 total_page_fail_bytes;
+static unsigned long nr_page_allocs;
+static unsigned long nr_page_frees;
+static unsigned long nr_page_fails;
+static unsigned long nr_page_nomatch;
+
+static bool use_pfn;
+
+#define MAX_MIGRATE_TYPES  6
+#define MAX_PAGE_ORDER     11
+
+static int order_stats[MAX_PAGE_ORDER][MAX_MIGRATE_TYPES];
+
+struct page_stat {
+        struct rb_node  node;
+        u64             page;
+        int             order;
+        unsigned        gfp_flags;
+        unsigned        migrate_type;
+        u64             alloc_bytes;
+        u64             free_bytes;
+        int             nr_alloc;
+        int             nr_free;
+};
+
+static struct rb_root page_tree;
+static struct rb_root page_alloc_tree;
+static struct rb_root page_alloc_sorted;
+
+static struct page_stat *search_page(unsigned long page, bool create)
+{
+        struct rb_node **node = &page_tree.rb_node;
+        struct rb_node *parent = NULL;
+        struct page_stat *data;
+
+        while (*node) {
+                s64 cmp;
+
+                parent = *node;
+                data = rb_entry(*node, struct page_stat, node);
+
+                cmp = data->page - page;
+                if (cmp < 0)
+                        node = &parent->rb_left;
+                else if (cmp > 0)
+                        node = &parent->rb_right;
+                else
+                        return data;
+        }
+
+        if (!create)
+                return NULL;
+
+        data = zalloc(sizeof(*data));
+        if (data != NULL) {
+                data->page = page;
+
+                rb_link_node(&data->node, parent, node);
+                rb_insert_color(&data->node, &page_tree);
+        }
+
+        return data;
+}
+
+static int page_stat_cmp(struct page_stat *a, struct page_stat *b)
+{
+        if (a->page > b->page)
+                return -1;
+        if (a->page < b->page)
+                return 1;
+        if (a->order > b->order)
+                return -1;
+        if (a->order < b->order)
+                return 1;
+        if (a->migrate_type > b->migrate_type)
+                return -1;
+        if (a->migrate_type < b->migrate_type)
+                return 1;
+        if (a->gfp_flags > b->gfp_flags)
+                return -1;
+        if (a->gfp_flags < b->gfp_flags)
+                return 1;
+        return 0;
+}
+
+static struct page_stat *search_page_alloc_stat(struct page_stat *stat, bool create)
+{
+        struct rb_node **node = &page_alloc_tree.rb_node;
+        struct rb_node *parent = NULL;
+        struct page_stat *data;
+
+        while (*node) {
+                s64 cmp;
+
+                parent = *node;
+                data = rb_entry(*node, struct page_stat, node);
+
+                cmp = page_stat_cmp(data, stat);
+                if (cmp < 0)
+                        node = &parent->rb_left;
+                else if (cmp > 0)
+                        node = &parent->rb_right;
+                else
+                        return data;
+        }
+
+        if (!create)
+                return NULL;
+
+        data = zalloc(sizeof(*data));
+        if (data != NULL) {
+                data->page = stat->page;
+                data->order = stat->order;
+                data->gfp_flags = stat->gfp_flags;
+                data->migrate_type = stat->migrate_type;
+
+                rb_link_node(&data->node, parent, node);
+                rb_insert_color(&data->node, &page_alloc_tree);
+        }
+
+        return data;
+}
+
+static bool valid_page(u64 pfn_or_page)
+{
+        if (use_pfn && pfn_or_page == -1UL)
+                return false;
+        if (!use_pfn && pfn_or_page == 0)
+                return false;
+        return true;
+}
+
+static int perf_evsel__process_page_alloc_event(struct perf_evsel *evsel,
+                                                struct perf_sample *sample)
+{
+        u64 page;
+        unsigned int order = perf_evsel__intval(evsel, sample, "order");
+        unsigned int gfp_flags = perf_evsel__intval(evsel, sample, "gfp_flags");
+        unsigned int migrate_type = perf_evsel__intval(evsel, sample,
+                                                       "migratetype");
+        u64 bytes = kmem_page_size << order;
+        struct page_stat *stat;
+        struct page_stat this = {
+                .order = order,
+                .gfp_flags = gfp_flags,
+                .migrate_type = migrate_type,
+        };
+
+        if (use_pfn)
+                page = perf_evsel__intval(evsel, sample, "pfn");
+        else
+                page = perf_evsel__intval(evsel, sample, "page");
+
+        nr_page_allocs++;
+        total_page_alloc_bytes += bytes;
+
+        if (!valid_page(page)) {
+                nr_page_fails++;
+                total_page_fail_bytes += bytes;
+
+                return 0;
+        }
+
+        /*
+         * This is to find the current page (with correct gfp flags and
+         * migrate type) at free event.
+         */
+        stat = search_page(page, true);
+        if (stat == NULL)
+                return -ENOMEM;
+
+        stat->order = order;
+        stat->gfp_flags = gfp_flags;
+        stat->migrate_type = migrate_type;
+
+        this.page = page;
+        stat = search_page_alloc_stat(&this, true);
+        if (stat == NULL)
+                return -ENOMEM;
+
+        stat->nr_alloc++;
+        stat->alloc_bytes += bytes;
+
+        order_stats[order][migrate_type]++;
+
+        return 0;
+}
+
+static int perf_evsel__process_page_free_event(struct perf_evsel *evsel,
+                                                struct perf_sample *sample)
+{
+        u64 page;
+        unsigned int order = perf_evsel__intval(evsel, sample, "order");
+        u64 bytes = kmem_page_size << order;
+        struct page_stat *stat;
+        struct page_stat this = {
+                .order = order,
+        };
+
+        if (use_pfn)
+                page = perf_evsel__intval(evsel, sample, "pfn");
+        else
+                page = perf_evsel__intval(evsel, sample, "page");
+
+        nr_page_frees++;
+        total_page_free_bytes += bytes;
+
+        stat = search_page(page, false);
+        if (stat == NULL) {
+                pr_debug2("missing free at page %"PRIx64" (order: %d)\n",
+                          page, order);
+
+                nr_page_nomatch++;
+                total_page_nomatch_bytes += bytes;
+
+                return 0;
+        }
+
+        this.page = page;
+        this.gfp_flags = stat->gfp_flags;
+        this.migrate_type = stat->migrate_type;
+
+        rb_erase(&stat->node, &page_tree);
+        free(stat);
+
+        stat = search_page_alloc_stat(&this, false);
+        if (stat == NULL)
+                return -ENOENT;
+
+        stat->nr_free++;
+        stat->free_bytes += bytes;
+
+        return 0;
+}
+
 typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
                                   struct perf_sample *sample);
 
@@ -269,16 +513,17 @@ static double fragmentation(unsigned long n_req, unsigned long n_alloc)
                 return 100.0 - (100.0 * n_req / n_alloc);
 }
 
-static void __print_result(struct rb_root *root, struct perf_session *session,
-                           int n_lines, int is_caller)
+static void __print_slab_result(struct rb_root *root,
+                                struct perf_session *session,
+                                int n_lines, int is_caller)
 {
         struct rb_node *next;
         struct machine *machine = &session->machines.host;
 
-        printf("%.102s\n", graph_dotted_line);
+        printf("%.105s\n", graph_dotted_line);
         printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
         printf(" Total_alloc/Per | Total_req/Per   | Hit      | Ping-pong | Frag\n");
-        printf("%.102s\n", graph_dotted_line);
+        printf("%.105s\n", graph_dotted_line);
 
         next = rb_first(root);
 
@@ -304,7 +549,7 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
                         snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr);
                 printf(" %-34s |", buf);
 
-                printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
+                printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %9lu | %6.3f%%\n",
                        (unsigned long long)data->bytes_alloc,
                        (unsigned long)data->bytes_alloc / data->hit,
                        (unsigned long long)data->bytes_req,
@@ -317,30 +562,137 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
         }
 
         if (n_lines == -1)
-                printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
+                printf(" ...                                | ...             | ...             | ...      | ...       | ...   \n");
 
-        printf("%.102s\n", graph_dotted_line);
+        printf("%.105s\n", graph_dotted_line);
 }
 
-static void print_summary(void)
+static const char * const migrate_type_str[] = {
+        "UNMOVABL",
+        "RECLAIM",
+        "MOVABLE",
+        "RESERVED",
+        "CMA/ISLT",
+        "UNKNOWN",
+};
+
+static void __print_page_result(struct rb_root *root,
+                                struct perf_session *session __maybe_unused,
+                                int n_lines)
 {
-        printf("\nSUMMARY\n=======\n");
-        printf("Total bytes requested: %lu\n", total_requested);
-        printf("Total bytes allocated: %lu\n", total_allocated);
-        printf("Total bytes wasted on internal fragmentation: %lu\n",
+        struct rb_node *next = rb_first(root);
+        const char *format;
+
+        printf("\n%.80s\n", graph_dotted_line);
+        printf(" %-16s | Total alloc (KB) | Hits      | Order | Mig.type | GFP flags\n",
+               use_pfn ? "PFN" : "Page");
+        printf("%.80s\n", graph_dotted_line);
+
+        if (use_pfn)
+                format = " %16llu | %'16llu | %'9d | %5d | %8s |  %08lx\n";
+        else
+                format = " %016llx | %'16llu | %'9d | %5d | %8s |  %08lx\n";
+
+        while (next && n_lines--) {
+                struct page_stat *data;
+
+                data = rb_entry(next, struct page_stat, node);
+
+                printf(format, (unsigned long long)data->page,
+                       (unsigned long long)data->alloc_bytes / 1024,
+                       data->nr_alloc, data->order,
+                       migrate_type_str[data->migrate_type],
+                       (unsigned long)data->gfp_flags);
+
+                next = rb_next(next);
+        }
+
+        if (n_lines == -1)
+                printf(" ...              | ...              | ...       | ...   | ...      | ...     \n");
+
+        printf("%.80s\n", graph_dotted_line);
+}
+
+static void print_slab_summary(void)
+{
+        printf("\nSUMMARY (SLAB allocator)");
+        printf("\n========================\n");
+        printf("Total bytes requested: %'lu\n", total_requested);
+        printf("Total bytes allocated: %'lu\n", total_allocated);
+        printf("Total bytes wasted on internal fragmentation: %'lu\n",
                total_allocated - total_requested);
         printf("Internal fragmentation: %f%%\n",
                fragmentation(total_requested, total_allocated));
-        printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
+        printf("Cross CPU allocations: %'lu/%'lu\n", nr_cross_allocs, nr_allocs);
 }
 
-static void print_result(struct perf_session *session)
+static void print_page_summary(void)
+{
+        int o, m;
+        u64 nr_alloc_freed = nr_page_frees - nr_page_nomatch;
+        u64 total_alloc_freed_bytes = total_page_free_bytes - total_page_nomatch_bytes;
+
+        printf("\nSUMMARY (page allocator)");
+        printf("\n========================\n");
+        printf("%-30s: %'16lu   [ %'16"PRIu64" KB ]\n", "Total allocation requests",
+               nr_page_allocs, total_page_alloc_bytes / 1024);
+        printf("%-30s: %'16lu   [ %'16"PRIu64" KB ]\n", "Total free requests",
+               nr_page_frees, total_page_free_bytes / 1024);
+        printf("\n");
+
+        printf("%-30s: %'16lu   [ %'16"PRIu64" KB ]\n", "Total alloc+freed requests",
+               nr_alloc_freed, (total_alloc_freed_bytes) / 1024);
+        printf("%-30s: %'16lu   [ %'16"PRIu64" KB ]\n", "Total alloc-only requests",
+               nr_page_allocs - nr_alloc_freed,
+               (total_page_alloc_bytes - total_alloc_freed_bytes) / 1024);
+        printf("%-30s: %'16lu   [ %'16"PRIu64" KB ]\n", "Total free-only requests",
+               nr_page_nomatch, total_page_nomatch_bytes / 1024);
+        printf("\n");
+
+        printf("%-30s: %'16lu   [ %'16"PRIu64" KB ]\n", "Total allocation failures",
+               nr_page_fails, total_page_fail_bytes / 1024);
+        printf("\n");
+
+        printf("%5s  %12s  %12s  %12s  %12s  %12s\n", "Order",  "Unmovable",
+               "Reclaimable", "Movable", "Reserved", "CMA/Isolated");
+        printf("%.5s  %.12s  %.12s  %.12s  %.12s  %.12s\n", graph_dotted_line,
+               graph_dotted_line, graph_dotted_line, graph_dotted_line,
+               graph_dotted_line, graph_dotted_line);
+
+        for (o = 0; o < MAX_PAGE_ORDER; o++) {
+                printf("%5d", o);
+                for (m = 0; m < MAX_MIGRATE_TYPES - 1; m++) {
+                        if (order_stats[o][m])
+                                printf("  %'12d", order_stats[o][m]);
+                        else
+                                printf("  %12c", '.');
+                }
+                printf("\n");
+        }
+}
+
+static void print_slab_result(struct perf_session *session)
 {
         if (caller_flag)
-                __print_result(&root_caller_sorted, session, caller_lines, 1);
+                __print_slab_result(&root_caller_sorted, session, caller_lines, 1);
         if (alloc_flag)
-                __print_result(&root_alloc_sorted, session, alloc_lines, 0);
-        print_summary();
+                __print_slab_result(&root_alloc_sorted, session, alloc_lines, 0);
+        print_slab_summary();
+}
+
+static void print_page_result(struct perf_session *session)
+{
+        if (alloc_flag)
+                __print_page_result(&page_alloc_sorted, session, alloc_lines);
+        print_page_summary();
+}
+
+static void print_result(struct perf_session *session)
+{
+        if (kmem_slab)
+                print_slab_result(session);
+        if (kmem_page)
+                print_page_result(session);
 }
 
 struct sort_dimension {
@@ -352,8 +704,8 @@ struct sort_dimension {
 static LIST_HEAD(caller_sort);
 static LIST_HEAD(alloc_sort);
 
-static void sort_insert(struct rb_root *root, struct alloc_stat *data,
-                        struct list_head *sort_list)
+static void sort_slab_insert(struct rb_root *root, struct alloc_stat *data,
+                             struct list_head *sort_list)
 {
         struct rb_node **new = &(root->rb_node);
         struct rb_node *parent = NULL;
@@ -382,8 +734,8 @@ static void sort_insert(struct rb_root *root, struct alloc_stat *data,
         rb_insert_color(&data->node, root);
 }
 
-static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
-                          struct list_head *sort_list)
+static void __sort_slab_result(struct rb_root *root, struct rb_root *root_sorted,
+                               struct list_head *sort_list)
 {
         struct rb_node *node;
         struct alloc_stat *data;
@@ -395,26 +747,79 @@ static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
 
                 rb_erase(node, root);
                 data = rb_entry(node, struct alloc_stat, node);
-                sort_insert(root_sorted, data, sort_list);
+                sort_slab_insert(root_sorted, data, sort_list);
+        }
+}
+
+static void sort_page_insert(struct rb_root *root, struct page_stat *data)
+{
+        struct rb_node **new = &root->rb_node;
+        struct rb_node *parent = NULL;
+
+        while (*new) {
+                struct page_stat *this;
+                int cmp = 0;
+
+                this = rb_entry(*new, struct page_stat, node);
+                parent = *new;
+
+                /* TODO: support more sort key */
+                cmp = data->alloc_bytes - this->alloc_bytes;
+
+                if (cmp > 0)
+                        new = &parent->rb_left;
+                else
+                        new = &parent->rb_right;
+        }
+
+        rb_link_node(&data->node, parent, new);
+        rb_insert_color(&data->node, root);
+}
+
+static void __sort_page_result(struct rb_root *root, struct rb_root *root_sorted)
+{
+        struct rb_node *node;
+        struct page_stat *data;
+
+        for (;;) {
+                node = rb_first(root);
+                if (!node)
+                        break;
+
+                rb_erase(node, root);
+                data = rb_entry(node, struct page_stat, node);
+                sort_page_insert(root_sorted, data);
         }
 }
 
 static void sort_result(void)
 {
-        __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
-        __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
+        if (kmem_slab) {
+                __sort_slab_result(&root_alloc_stat, &root_alloc_sorted,
+                                   &alloc_sort);
+                __sort_slab_result(&root_caller_stat, &root_caller_sorted,
+                                   &caller_sort);
+        }
+        if (kmem_page) {
+                __sort_page_result(&page_alloc_tree, &page_alloc_sorted);
+        }
 }
 
 static int __cmd_kmem(struct perf_session *session)
 {
         int err = -EINVAL;
+        struct perf_evsel *evsel;
         const struct perf_evsel_str_handler kmem_tracepoints[] = {
+                /* slab allocator */
                 { "kmem:kmalloc",               perf_evsel__process_alloc_event, },
                 { "kmem:kmem_cache_alloc",      perf_evsel__process_alloc_event, },
                 { "kmem:kmalloc_node",          perf_evsel__process_alloc_node_event, },
                 { "kmem:kmem_cache_alloc_node", perf_evsel__process_alloc_node_event, },
                 { "kmem:kfree",                 perf_evsel__process_free_event, },
                 { "kmem:kmem_cache_free",       perf_evsel__process_free_event, },
+                /* page allocator */
+                { "kmem:mm_page_alloc",         perf_evsel__process_page_alloc_event, },
+                { "kmem:mm_page_free",          perf_evsel__process_page_free_event, },
         };
 
         if (!perf_session__has_traces(session, "kmem record"))
@@ -425,10 +830,20 @@ static int __cmd_kmem(struct perf_session *session)
                 goto out;
         }
 
+        evlist__for_each(session->evlist, evsel) {
+                if (!strcmp(perf_evsel__name(evsel), "kmem:mm_page_alloc") &&
+                    perf_evsel__field(evsel, "pfn")) {
+                        use_pfn = true;
+                        break;
+                }
+        }
+
         setup_pager();
-        err = perf_session__process_events(session, &perf_kmem);
-        if (err != 0)
+        err = perf_session__process_events(session);
+        if (err != 0) {
+                pr_err("error during process events: %d\n", err);
                 goto out;
+        }
         sort_result();
         print_result(session);
 out:
@@ -559,6 +974,7 @@ static int setup_sorting(struct list_head *sort_list, const char *arg)
 {
         char *tok;
         char *str = strdup(arg);
+        char *pos = str;
 
         if (!str) {
                 pr_err("%s: strdup failed\n", __func__);
@@ -566,7 +982,7 @@ static int setup_sorting(struct list_head *sort_list, const char *arg)
         }
 
         while (true) {
-                tok = strsep(&str, ",");
+                tok = strsep(&pos, ",");
                 if (!tok)
                         break;
                 if (sort_dimension__add(tok, sort_list) < 0) {
@@ -610,6 +1026,22 @@ static int parse_alloc_opt(const struct option *opt __maybe_unused,
         return 0;
 }
 
+static int parse_slab_opt(const struct option *opt __maybe_unused,
+                          const char *arg __maybe_unused,
+                          int unset __maybe_unused)
+{
+        kmem_slab = (kmem_page + 1);
+        return 0;
+}
+
+static int parse_page_opt(const struct option *opt __maybe_unused,
+                          const char *arg __maybe_unused,
+                          int unset __maybe_unused)
+{
+        kmem_page = (kmem_slab + 1);
+        return 0;
+}
+
 static int parse_line_opt(const struct option *opt __maybe_unused,
                           const char *arg, int unset __maybe_unused)
 {
@@ -632,6 +1064,8 @@ static int __cmd_record(int argc, const char **argv)
 {
         const char * const record_args[] = {
         "record", "-a", "-R", "-c", "1",
+        };
+        const char * const slab_events[] = {
         "-e", "kmem:kmalloc",
         "-e", "kmem:kmalloc_node",
         "-e", "kmem:kfree",
@@ -639,10 +1073,19 @@ static int __cmd_record(int argc, const char **argv)
         "-e", "kmem:kmem_cache_alloc_node",
         "-e", "kmem:kmem_cache_free",
         };
+        const char * const page_events[] = {
+        "-e", "kmem:mm_page_alloc",
+        "-e", "kmem:mm_page_free",
+        };
         unsigned int rec_argc, i, j;
         const char **rec_argv;
 
         rec_argc = ARRAY_SIZE(record_args) + argc - 1;
+        if (kmem_slab)
+                rec_argc += ARRAY_SIZE(slab_events);
+        if (kmem_page)
+                rec_argc += ARRAY_SIZE(page_events);
+
         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 
         if (rec_argv == NULL)
@@ -651,6 +1094,15 @@ static int __cmd_record(int argc, const char **argv)
         for (i = 0; i < ARRAY_SIZE(record_args); i++)
                 rec_argv[i] = strdup(record_args[i]);
 
+        if (kmem_slab) {
+                for (j = 0; j < ARRAY_SIZE(slab_events); j++, i++)
+                        rec_argv[i] = strdup(slab_events[j]);
+        }
+        if (kmem_page) {
+                for (j = 0; j < ARRAY_SIZE(page_events); j++, i++)
+                        rec_argv[i] = strdup(page_events[j]);
+        }
+
         for (j = 1; j < (unsigned int)argc; j++, i++)
                 rec_argv[i] = argv[j];
 
@@ -660,8 +1112,13 @@ static int __cmd_record(int argc, const char **argv)
 int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         const char * const default_sort_order = "frag,hit,bytes";
+        struct perf_data_file file = {
+                .mode = PERF_DATA_MODE_READ,
+        };
         const struct option kmem_options[] = {
         OPT_STRING('i', "input", &input_name, "file", "input file name"),
+        OPT_INCR('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
         OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
                            "show per-callsite statistics", parse_caller_opt),
         OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
@@ -671,6 +1128,11 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
                      parse_sort_opt),
         OPT_CALLBACK('l', "line", NULL, "num", "show n lines", parse_line_opt),
         OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
+        OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
+        OPT_CALLBACK_NOOPT(0, "slab", NULL, NULL, "Analyze slab allocator",
+                           parse_slab_opt),
+        OPT_CALLBACK_NOOPT(0, "page", NULL, NULL, "Analyze page allocator",
+                           parse_page_opt),
         OPT_END()
         };
         const char *const kmem_subcommands[] = { "record", "stat", NULL };
@@ -679,10 +1141,6 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
                 NULL
         };
         struct perf_session *session;
-        struct perf_data_file file = {
-                .path = input_name,
-                .mode = PERF_DATA_MODE_READ,
-        };
         int ret = -1;
 
         argc = parse_options_subcommand(argc, argv, kmem_options,
@@ -691,18 +1149,36 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
         if (!argc)
                 usage_with_options(kmem_usage, kmem_options);
 
+        if (kmem_slab == 0 && kmem_page == 0)
+                kmem_slab = 1;  /* for backward compatibility */
+
         if (!strncmp(argv[0], "rec", 3)) {
                 symbol__init(NULL);
                 return __cmd_record(argc, argv);
         }
 
+        file.path = input_name;
+
         session = perf_session__new(&file, false, &perf_kmem);
         if (session == NULL)
                 return -1;
 
+        if (kmem_page) {
+                struct perf_evsel *evsel = perf_evlist__first(session->evlist);
+
+                if (evsel == NULL || evsel->tp_format == NULL) {
+                        pr_err("invalid event found.. aborting\n");
+                        return -1;
+                }
+
+                kmem_page_size = pevent_get_page_size(evsel->tp_format->pevent);
+        }
+
         symbol__init(&session->header.env);
 
         if (!strcmp(argv[0], "stat")) {
+                setlocale(LC_ALL, "");
+
                 if (cpu__setup_cpunode_map())
                         goto out_delete;
 
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 0894a817f67e..1f9338f6109c 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -18,6 +18,7 @@
 #include "util/stat.h"
 #include "util/top.h"
 #include "util/data.h"
+#include "util/ordered-events.h"
 
 #include <sys/prctl.h>
 #ifdef HAVE_TIMERFD_SUPPORT
@@ -730,9 +731,9 @@ static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,
                         return -1;
                 }
 
-                err = perf_session_queue_event(kvm->session, event, &kvm->tool, &sample, 0);
+                err = perf_session__queue_event(kvm->session, event, &sample, 0);
                 /*
-                 * FIXME: Here we can't consume the event, as perf_session_queue_event will
+                 * FIXME: Here we can't consume the event, as perf_session__queue_event will
                  *        point to it, and it'll get possibly overwritten by the kernel.
                  */
                 perf_evlist__mmap_consume(kvm->evlist, idx);
@@ -783,8 +784,10 @@ static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)
 
         /* flush queue after each round in which we processed events */
         if (ntotal) {
-                kvm->session->ordered_events.next_flush = flush_time;
-                err = kvm->tool.finished_round(&kvm->tool, NULL, kvm->session);
+                struct ordered_events *oe = &kvm->session->ordered_events;
+
+                oe->next_flush = flush_time;
+                err = ordered_events__flush(oe, OE_FLUSH__ROUND);
                 if (err) {
                         if (kvm->lost_events)
                                 pr_info("\nLost events: %" PRIu64 "\n\n",
@@ -1044,6 +1047,7 @@ static int read_events(struct perf_kvm_stat *kvm)
         struct perf_data_file file = {
                 .path = kvm->file_name,
                 .mode = PERF_DATA_MODE_READ,
+                .force = kvm->force,
         };
 
         kvm->tool = eops;
@@ -1066,7 +1070,7 @@ static int read_events(struct perf_kvm_stat *kvm)
         if (ret < 0)
                 return ret;
 
-        return perf_session__process_events(kvm->session, &kvm->tool);
+        return perf_session__process_events(kvm->session);
 }
 
 static int parse_target_str(struct perf_kvm_stat *kvm)
@@ -1201,6 +1205,7 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
                             " time (sort by avg time)"),
                 OPT_STRING('p', "pid", &kvm->opts.target.pid, "pid",
                            "analyze events only for given process id(s)"),
+                OPT_BOOLEAN('f', "force", &kvm->force, "don't complain, do it"),
                 OPT_END()
         };
 
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
index 198f3c3aff95..af5bd0514108 100644
--- a/tools/perf/builtin-list.c
+++ b/tools/perf/builtin-list.c
@@ -36,38 +36,36 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 
         setup_pager();
 
-        if (raw_dump) {
-                print_events(NULL, true);
-                return 0;
-        }
+        if (!raw_dump)
+                printf("\nList of pre-defined events (to be used in -e):\n\n");
 
         if (argc == 0) {
-                print_events(NULL, false);
+                print_events(NULL, raw_dump);
                 return 0;
         }
 
         for (i = 0; i < argc; ++i) {
-                if (i)
-                        putchar('\n');
-                if (strncmp(argv[i], "tracepoint", 10) == 0)
-                        print_tracepoint_events(NULL, NULL, false);
+                if (strcmp(argv[i], "tracepoint") == 0)
+                        print_tracepoint_events(NULL, NULL, raw_dump);
                 else if (strcmp(argv[i], "hw") == 0 ||
                          strcmp(argv[i], "hardware") == 0)
-                        print_events_type(PERF_TYPE_HARDWARE);
+                        print_symbol_events(NULL, PERF_TYPE_HARDWARE,
+                                        event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump);
                 else if (strcmp(argv[i], "sw") == 0 ||
                          strcmp(argv[i], "software") == 0)
-                        print_events_type(PERF_TYPE_SOFTWARE);
+                        print_symbol_events(NULL, PERF_TYPE_SOFTWARE,
+                                        event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
                 else if (strcmp(argv[i], "cache") == 0 ||
                          strcmp(argv[i], "hwcache") == 0)
-                        print_hwcache_events(NULL, false);
+                        print_hwcache_events(NULL, raw_dump);
                 else if (strcmp(argv[i], "pmu") == 0)
-                        print_pmu_events(NULL, false);
+                        print_pmu_events(NULL, raw_dump);
                 else {
                         char *sep = strchr(argv[i], ':'), *s;
                         int sep_idx;
 
                         if (sep == NULL) {
-                                print_events(argv[i], false);
+                                print_events(argv[i], raw_dump);
                                 continue;
                         }
                         sep_idx = sep - argv[i];
@@ -76,7 +74,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                                 return -1;
 
                         s[sep_idx] = '\0';
-                        print_tracepoint_events(s, s + sep_idx + 1, false);
+                        print_tracepoint_events(s, s + sep_idx + 1, raw_dump);
                         free(s);
                 }
         }
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index e7ec71589da6..d49c2ab85fc2 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -846,6 +846,8 @@ static const struct perf_evsel_str_handler lock_tracepoints[] = {
         { "lock:lock_release",   perf_evsel__process_lock_release,   }, /* CONFIG_LOCKDEP */
 };
 
+static bool force;
+
 static int __cmd_report(bool display_info)
 {
         int err = -EINVAL;
@@ -857,6 +859,7 @@ static int __cmd_report(bool display_info)
         struct perf_data_file file = {
                 .path = input_name,
                 .mode = PERF_DATA_MODE_READ,
+                .force = force,
         };
 
         session = perf_session__new(&file, false, &eops);
@@ -878,7 +881,7 @@ static int __cmd_report(bool display_info)
         if (select_key())
                 goto out_delete;
 
-        err = perf_session__process_events(session, &eops);
+        err = perf_session__process_events(session);
         if (err)
                 goto out_delete;
 
@@ -945,6 +948,7 @@ int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
                     "dump thread list in perf.data"),
         OPT_BOOLEAN('m', "map", &info_map,
                     "map of lock instances (address:name table)"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
         OPT_END()
         };
         const struct option lock_options[] = {
@@ -956,6 +960,7 @@ int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
         const struct option report_options[] = {
         OPT_STRING('k', "key", &sort_key, "acquired",
                     "key for sorting (acquired / contended / avg_wait / wait_total / wait_max / wait_min)"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
         /* TODO: type */
         OPT_END()
         };
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 9b5663950a4d..675216e08bfc 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -15,6 +15,7 @@ struct perf_mem {
         char const              *input_name;
         bool                    hide_unresolved;
         bool                    dump_raw;
+        bool                    force;
         int                     operation;
         const char              *cpu_list;
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
@@ -120,6 +121,7 @@ static int report_raw_events(struct perf_mem *mem)
         struct perf_data_file file = {
                 .path = input_name,
                 .mode = PERF_DATA_MODE_READ,
+                .force = mem->force,
         };
         int err = -EINVAL;
         int ret;
@@ -141,7 +143,7 @@ static int report_raw_events(struct perf_mem *mem)
 
         printf("# PID, TID, IP, ADDR, LOCAL WEIGHT, DSRC, SYMBOL\n");
 
-        err = perf_session__process_events(session, &mem->tool);
+        err = perf_session__process_events(session);
         if (err)
                 return err;
 
@@ -286,10 +288,11 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
                    "input file name"),
         OPT_STRING('C', "cpu", &mem.cpu_list, "cpu",
                    "list of cpus to profile"),
-        OPT_STRING('x', "field-separator", &symbol_conf.field_sep,
+        OPT_STRING_NOEMPTY('x', "field-separator", &symbol_conf.field_sep,
                    "separator",
                    "separator for columns, no spaces will be added"
                    " between columns '.' is reserved."),
+        OPT_BOOLEAN('f', "force", &mem.force, "don't complain, do it"),
         OPT_END()
         };
         const char *const mem_subcommands[] = { "record", "report", NULL };
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 921bb6942503..f7b1af67e9f6 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -56,6 +56,7 @@ static struct {
         bool mod_events;
         bool uprobes;
         bool quiet;
+        bool target_used;
         int nevents;
         struct perf_probe_event events[MAX_PROBES];
         struct strlist *dellist;
@@ -78,6 +79,12 @@ static int parse_probe_event(const char *str)
         }
 
         pev->uprobes = params.uprobes;
+        if (params.target) {
+                pev->target = strdup(params.target);
+                if (!pev->target)
+                        return -ENOMEM;
+                params.target_used = true;
+        }
 
         /* Parse a perf-probe command into event */
         ret = parse_perf_probe_command(str, pev);
@@ -102,6 +109,7 @@ static int set_target(const char *ptr)
                 params.target = strdup(ptr);
                 if (!params.target)
                         return -ENOMEM;
+                params.target_used = false;
 
                 found = 1;
                 buf = ptr + (strlen(ptr) - 3);
@@ -178,7 +186,7 @@ static int opt_set_target(const struct option *opt, const char *str,
         int ret = -ENOENT;
         char *tmp;
 
-        if  (str && !params.target) {
+        if  (str) {
                 if (!strcmp(opt->long_name, "exec"))
                         params.uprobes = true;
 #ifdef HAVE_DWARF_SUPPORT
@@ -200,7 +208,9 @@ static int opt_set_target(const struct option *opt, const char *str,
                         if (!tmp)
                                 return -ENOMEM;
                 }
+                free(params.target);
                 params.target = tmp;
+                params.target_used = false;
                 ret = 0;
         }
 
@@ -485,9 +495,14 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
         }
 
         if (params.nevents) {
+                /* Ensure the last given target is used */
+                if (params.target && !params.target_used) {
+                        pr_warning("  Error: -x/-m must follow the probe definitions.\n");
+                        usage_with_options(probe_usage, options);
+                }
+
                 ret = add_perf_probe_events(params.events, params.nevents,
                                             params.max_probe_points,
-                                            params.target,
                                             params.force_add);
                 if (ret < 0) {
                         pr_err_with_code("  Error: Failed to add events.", ret);
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 404ab3434052..c3efdfb630b5 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -70,8 +70,8 @@ static int process_synthesized_event(struct perf_tool *tool,
 static int record__mmap_read(struct record *rec, int idx)
 {
         struct perf_mmap *md = &rec->evlist->mmap[idx];
-        unsigned int head = perf_mmap__read_head(md);
-        unsigned int old = md->prev;
+        u64 head = perf_mmap__read_head(md);
+        u64 old = md->prev;
         unsigned char *data = md->base + page_size;
         unsigned long size;
         void *buf;
@@ -161,8 +161,9 @@ try_again:
                 }
         }
 
-        if (perf_evlist__apply_filters(evlist)) {
-                error("failed to set filter with %d (%s)\n", errno,
+        if (perf_evlist__apply_filters(evlist, &pos)) {
+                error("failed to set filter \"%s\" on event %s with %d (%s)\n",
+                        pos->filter, perf_evsel__name(pos), errno,
                         strerror_r(errno, msg, sizeof(msg)));
                 rc = -1;
                 goto out;
@@ -225,7 +226,7 @@ static int process_buildids(struct record *rec)
          */
         symbol_conf.ignore_vmlinux_buildid = true;
 
-        return perf_session__process_events(session, &rec->tool);
+        return perf_session__process_events(session);
 }
 
 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
@@ -343,7 +344,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         signal(SIGINT, sig_handler);
         signal(SIGTERM, sig_handler);
 
-        session = perf_session__new(file, false, NULL);
+        session = perf_session__new(file, false, tool);
         if (session == NULL) {
                 pr_err("Perf session creation failed.\n");
                 return -1;
@@ -658,7 +659,7 @@ error:
 
 static void callchain_debug(void)
 {
-        static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF" };
+        static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
 
         pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
 
@@ -710,6 +711,90 @@ static int perf_record_config(const char *var, const char *value, void *cb)
         return perf_default_config(var, value, cb);
 }
 
+struct clockid_map {
+        const char *name;
+        int clockid;
+};
+
+#define CLOCKID_MAP(n, c)       \
+        { .name = n, .clockid = (c), }
+
+#define CLOCKID_END     { .name = NULL, }
+
+
+/*
+ * Add the missing ones, we need to build on many distros...
+ */
+#ifndef CLOCK_MONOTONIC_RAW
+#define CLOCK_MONOTONIC_RAW 4
+#endif
+#ifndef CLOCK_BOOTTIME
+#define CLOCK_BOOTTIME 7
+#endif
+#ifndef CLOCK_TAI
+#define CLOCK_TAI 11
+#endif
+
+static const struct clockid_map clockids[] = {
+        /* available for all events, NMI safe */
+        CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
+        CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
+
+        /* available for some events */
+        CLOCKID_MAP("realtime", CLOCK_REALTIME),
+        CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
+        CLOCKID_MAP("tai", CLOCK_TAI),
+
+        /* available for the lazy */
+        CLOCKID_MAP("mono", CLOCK_MONOTONIC),
+        CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
+        CLOCKID_MAP("real", CLOCK_REALTIME),
+        CLOCKID_MAP("boot", CLOCK_BOOTTIME),
+
+        CLOCKID_END,
+};
+
+static int parse_clockid(const struct option *opt, const char *str, int unset)
+{
+        struct record_opts *opts = (struct record_opts *)opt->value;
+        const struct clockid_map *cm;
+        const char *ostr = str;
+
+        if (unset) {
+                opts->use_clockid = 0;
+                return 0;
+        }
+
+        /* no arg passed */
+        if (!str)
+                return 0;
+
+        /* no setting it twice */
+        if (opts->use_clockid)
+                return -1;
+
+        opts->use_clockid = true;
+
+        /* if its a number, we're done */
+        if (sscanf(str, "%d", &opts->clockid) == 1)
+                return 0;
+
+        /* allow a "CLOCK_" prefix to the name */
+        if (!strncasecmp(str, "CLOCK_", 6))
+                str += 6;
+
+        for (cm = clockids; cm->name; cm++) {
+                if (!strcasecmp(str, cm->name)) {
+                        opts->clockid = cm->clockid;
+                        return 0;
+                }
+        }
+
+        opts->use_clockid = false;
+        ui__warning("unknown clockid %s, check man page\n", ostr);
+        return -1;
+}
+
 static const char * const __record_usage[] = {
         "perf record [<options>] [<command>]",
         "perf record [<options>] -- <command> [<options>]",
@@ -751,9 +836,9 @@ static struct record record = {
 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
 
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
-const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf";
+const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf lbr";
 #else
-const char record_callchain_help[] = CALLCHAIN_HELP "fp";
+const char record_callchain_help[] = CALLCHAIN_HELP "fp lbr";
 #endif
 
 /*
@@ -839,6 +924,11 @@ struct option __record_options[] = {
                     "use per-thread mmaps"),
         OPT_BOOLEAN('I', "intr-regs", &record.opts.sample_intr_regs,
                     "Sample machine registers on interrupt"),
+        OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
+                    "Record running/enabled time of read (:S) events"),
+        OPT_CALLBACK('k', "clockid", &record.opts,
+        "clockid", "clockid to use for events, see clock_gettime()",
+        parse_clockid),
         OPT_END()
 };
 
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 2f91094e228b..476cdf7afcca 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -249,6 +249,8 @@ static int report__setup_sample_type(struct report *rep)
                 if ((sample_type & PERF_SAMPLE_REGS_USER) &&
                     (sample_type & PERF_SAMPLE_STACK_USER))
                         callchain_param.record_mode = CALLCHAIN_DWARF;
+                else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
+                        callchain_param.record_mode = CALLCHAIN_LBR;
                 else
                         callchain_param.record_mode = CALLCHAIN_FP;
         }
@@ -302,7 +304,7 @@ static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report
 
         if (rep->mem_mode) {
                 ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
-                ret += fprintf(fp, "\n# Sort order   : %s", sort_order);
+                ret += fprintf(fp, "\n# Sort order   : %s", sort_order ? : default_mem_sort_order);
         } else
                 ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
         return ret + fprintf(fp, "\n#\n");
@@ -345,7 +347,7 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
 static void report__warn_kptr_restrict(const struct report *rep)
 {
         struct map *kernel_map = rep->session->machines.host.vmlinux_maps[MAP__FUNCTION];
-        struct kmap *kernel_kmap = map__kmap(kernel_map);
+        struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;
 
         if (kernel_map == NULL ||
             (kernel_map->dso->hit &&
@@ -480,7 +482,7 @@ static int __cmd_report(struct report *rep)
         if (ret)
                 return ret;
 
-        ret = perf_session__process_events(session, &rep->tool);
+        ret = perf_session__process_events(session);
         if (ret)
                 return ret;
 
@@ -667,6 +669,10 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                    "only consider symbols in these dsos"),
         OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
                    "only consider symbols in these comms"),
+        OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
+                   "only consider symbols in these pids"),
+        OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
+                   "only consider symbols in these tids"),
         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
                    "only consider these symbols"),
         OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",
@@ -674,7 +680,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
                    "width[,width...]",
                    "don't try to adjust column width, use these fixed values"),
-        OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
+        OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
                    "separator for columns, no spaces will be added between "
                    "columns '.' is reserved."),
         OPT_BOOLEAN('U', "hide-unresolved", &report.hide_unresolved,
@@ -766,7 +772,7 @@ repeat:
          * 0/1 means the user chose a mode.
          */
         if (((branch_mode == -1 && has_br_stack) || branch_mode == 1) &&
-            branch_call_mode == -1) {
+            !branch_call_mode) {
                 sort__mode = SORT_MODE__BRANCH;
                 symbol_conf.cumulate_callchain = false;
         }
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 891c3930080e..5275bab70313 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -23,12 +23,13 @@
 #include <semaphore.h>
 #include <pthread.h>
 #include <math.h>
+#include <api/fs/fs.h>
 
 #define PR_SET_NAME             15               /* Set process name */
 #define MAX_CPUS                4096
 #define COMM_LEN                20
 #define SYM_LEN                 129
-#define MAX_PID                 65536
+#define MAX_PID                 1024000
 
 struct sched_atom;
 
@@ -124,7 +125,7 @@ struct perf_sched {
         struct perf_tool tool;
         const char       *sort_order;
         unsigned long    nr_tasks;
-        struct task_desc *pid_to_task[MAX_PID];
+        struct task_desc **pid_to_task;
         struct task_desc **tasks;
         const struct trace_sched_handler *tp_handler;
         pthread_mutex_t  start_work_mutex;
@@ -169,6 +170,7 @@ struct perf_sched {
         u64              cpu_last_switched[MAX_CPUS];
         struct rb_root   atom_root, sorted_atom_root;
         struct list_head sort_list, cmp_pid;
+        bool force;
 };
 
 static u64 get_nsecs(void)
@@ -326,8 +328,19 @@ static struct task_desc *register_pid(struct perf_sched *sched,
                                       unsigned long pid, const char *comm)
 {
         struct task_desc *task;
+        static int pid_max;
 
-        BUG_ON(pid >= MAX_PID);
+        if (sched->pid_to_task == NULL) {
+                if (sysctl__read_int("kernel/pid_max", &pid_max) < 0)
+                        pid_max = MAX_PID;
+                BUG_ON((sched->pid_to_task = calloc(pid_max, sizeof(struct task_desc *))) == NULL);
+        }
+        if (pid >= (unsigned long)pid_max) {
+                BUG_ON((sched->pid_to_task = realloc(sched->pid_to_task, (pid + 1) *
+                        sizeof(struct task_desc *))) == NULL);
+                while (pid >= (unsigned long)pid_max)
+                        sched->pid_to_task[pid_max++] = NULL;
+        }
 
         task = sched->pid_to_task[pid];
 
@@ -346,7 +359,7 @@ static struct task_desc *register_pid(struct perf_sched *sched,
 
         sched->pid_to_task[pid] = task;
         sched->nr_tasks++;
-        sched->tasks = realloc(sched->tasks, sched->nr_tasks * sizeof(struct task_task *));
+        sched->tasks = realloc(sched->tasks, sched->nr_tasks * sizeof(struct task_desc *));
         BUG_ON(!sched->tasks);
         sched->tasks[task->nr] = task;
 
@@ -425,24 +438,45 @@ static u64 get_cpu_usage_nsec_parent(void)
         return sum;
 }
 
-static int self_open_counters(void)
+static int self_open_counters(struct perf_sched *sched, unsigned long cur_task)
 {
         struct perf_event_attr attr;
-        char sbuf[STRERR_BUFSIZE];
+        char sbuf[STRERR_BUFSIZE], info[STRERR_BUFSIZE];
         int fd;
+        struct rlimit limit;
+        bool need_privilege = false;
 
         memset(&attr, 0, sizeof(attr));
 
         attr.type = PERF_TYPE_SOFTWARE;
         attr.config = PERF_COUNT_SW_TASK_CLOCK;
 
+force_again:
         fd = sys_perf_event_open(&attr, 0, -1, -1,
                                  perf_event_open_cloexec_flag());
 
-        if (fd < 0)
+        if (fd < 0) {
+                if (errno == EMFILE) {
+                        if (sched->force) {
+                                BUG_ON(getrlimit(RLIMIT_NOFILE, &limit) == -1);
+                                limit.rlim_cur += sched->nr_tasks - cur_task;
+                                if (limit.rlim_cur > limit.rlim_max) {
+                                        limit.rlim_max = limit.rlim_cur;
+                                        need_privilege = true;
+                                }
+                                if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
+                                        if (need_privilege && errno == EPERM)
+                                                strcpy(info, "Need privilege\n");
+                                } else
+                                        goto force_again;
+                        } else
+                                strcpy(info, "Have a try with -f option\n");
+                }
                 pr_err("Error: sys_perf_event_open() syscall returned "
-                       "with %d (%s)\n", fd,
-                       strerror_r(errno, sbuf, sizeof(sbuf)));
+                       "with %d (%s)\n%s", fd,
+                       strerror_r(errno, sbuf, sizeof(sbuf)), info);
+                exit(EXIT_FAILURE);
+        }
         return fd;
 }
 
@@ -460,6 +494,7 @@ static u64 get_cpu_usage_nsec_self(int fd)
 struct sched_thread_parms {
         struct task_desc  *task;
         struct perf_sched *sched;
+        int fd;
 };
 
 static void *thread_func(void *ctx)
@@ -470,13 +505,12 @@ static void *thread_func(void *ctx)
         u64 cpu_usage_0, cpu_usage_1;
         unsigned long i, ret;
         char comm2[22];
-        int fd;
+        int fd = parms->fd;
 
         zfree(&parms);
 
         sprintf(comm2, ":%s", this_task->comm);
         prctl(PR_SET_NAME, comm2);
-        fd = self_open_counters();
         if (fd < 0)
                 return NULL;
 again:
@@ -528,6 +562,7 @@ static void create_tasks(struct perf_sched *sched)
                 BUG_ON(parms == NULL);
                 parms->task = task = sched->tasks[i];
                 parms->sched = sched;
+                parms->fd = self_open_counters(sched, i);
                 sem_init(&task->sleep_sem, 0, 0);
                 sem_init(&task->ready_for_work, 0, 0);
                 sem_init(&task->work_done_sem, 0, 0);
@@ -572,13 +607,13 @@ static void wait_for_tasks(struct perf_sched *sched)
         cpu_usage_1 = get_cpu_usage_nsec_parent();
         if (!sched->runavg_cpu_usage)
                 sched->runavg_cpu_usage = sched->cpu_usage;
-        sched->runavg_cpu_usage = (sched->runavg_cpu_usage * 9 + sched->cpu_usage) / 10;
+        sched->runavg_cpu_usage = (sched->runavg_cpu_usage * (sched->replay_repeat - 1) + sched->cpu_usage) / sched->replay_repeat;
 
         sched->parent_cpu_usage = cpu_usage_1 - cpu_usage_0;
         if (!sched->runavg_parent_cpu_usage)
                 sched->runavg_parent_cpu_usage = sched->parent_cpu_usage;
-        sched->runavg_parent_cpu_usage = (sched->runavg_parent_cpu_usage * 9 +
-                                         sched->parent_cpu_usage)/10;
+        sched->runavg_parent_cpu_usage = (sched->runavg_parent_cpu_usage * (sched->replay_repeat - 1) +
+                                         sched->parent_cpu_usage)/sched->replay_repeat;
 
         ret = pthread_mutex_lock(&sched->start_work_mutex);
         BUG_ON(ret);
@@ -610,7 +645,7 @@ static void run_one_test(struct perf_sched *sched)
         sched->sum_fluct += fluct;
         if (!sched->run_avg)
                 sched->run_avg = delta;
-        sched->run_avg = (sched->run_avg * 9 + delta) / 10;
+        sched->run_avg = (sched->run_avg * (sched->replay_repeat - 1) + delta) / sched->replay_repeat;
 
         printf("#%-3ld: %0.3f, ", sched->nr_runs, (double)delta / 1000000.0);
 
@@ -831,7 +866,7 @@ static int thread_atoms_insert(struct perf_sched *sched, struct thread *thread)
                 return -1;
         }
 
-        atoms->thread = thread;
+        atoms->thread = thread__get(thread);
         INIT_LIST_HEAD(&atoms->work_list);
         __thread_latency_insert(&sched->atom_root, atoms, &sched->cmp_pid);
         return 0;
@@ -1439,8 +1474,7 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool __maybe_
         return err;
 }
 
-static int perf_sched__read_events(struct perf_sched *sched,
-                                   struct perf_session **psession)
+static int perf_sched__read_events(struct perf_sched *sched)
 {
         const struct perf_evsel_str_handler handlers[] = {
                 { "sched:sched_switch",       process_sched_switch_event, },
@@ -1453,7 +1487,9 @@ static int perf_sched__read_events(struct perf_sched *sched,
         struct perf_data_file file = {
                 .path = input_name,
                 .mode = PERF_DATA_MODE_READ,
+                .force = sched->force,
         };
+        int rc = -1;
 
         session = perf_session__new(&file, false, &sched->tool);
         if (session == NULL) {
@@ -1467,27 +1503,21 @@ static int perf_sched__read_events(struct perf_sched *sched,
                 goto out_delete;
 
         if (perf_session__has_traces(session, "record -R")) {
-                int err = perf_session__process_events(session, &sched->tool);
+                int err = perf_session__process_events(session);
                 if (err) {
                         pr_err("Failed to process events, error %d", err);
                         goto out_delete;
                 }
 
-                sched->nr_events      = session->stats.nr_events[0];
-                sched->nr_lost_events = session->stats.total_lost;
-                sched->nr_lost_chunks = session->stats.nr_events[PERF_RECORD_LOST];
+                sched->nr_events      = session->evlist->stats.nr_events[0];
+                sched->nr_lost_events = session->evlist->stats.total_lost;
+                sched->nr_lost_chunks = session->evlist->stats.nr_events[PERF_RECORD_LOST];
         }
 
-        if (psession)
-                *psession = session;
-        else
-                perf_session__delete(session);
-
-        return 0;
-
+        rc = 0;
 out_delete:
         perf_session__delete(session);
-        return -1;
+        return rc;
 }
 
 static void print_bad_events(struct perf_sched *sched)
@@ -1515,12 +1545,10 @@ static void print_bad_events(struct perf_sched *sched)
 static int perf_sched__lat(struct perf_sched *sched)
 {
         struct rb_node *next;
-        struct perf_session *session;
 
         setup_pager();
 
-        /* save session -- references to threads are held in work_list */
-        if (perf_sched__read_events(sched, &session))
+        if (perf_sched__read_events(sched))
                 return -1;
 
         perf_sched__sort_lat(sched);
@@ -1537,6 +1565,7 @@ static int perf_sched__lat(struct perf_sched *sched)
                 work_list = rb_entry(next, struct work_atoms, node);
                 output_lat_thread(sched, work_list);
                 next = rb_next(next);
+                thread__zput(work_list->thread);
         }
 
         printf(" -----------------------------------------------------------------------------------------------------------------\n");
@@ -1548,7 +1577,6 @@ static int perf_sched__lat(struct perf_sched *sched)
         print_bad_events(sched);
         printf("\n");
 
-        perf_session__delete(session);
         return 0;
 }
 
@@ -1557,7 +1585,7 @@ static int perf_sched__map(struct perf_sched *sched)
         sched->max_cpu = sysconf(_SC_NPROCESSORS_CONF);
 
         setup_pager();
-        if (perf_sched__read_events(sched, NULL))
+        if (perf_sched__read_events(sched))
                 return -1;
         print_bad_events(sched);
         return 0;
@@ -1572,7 +1600,7 @@ static int perf_sched__replay(struct perf_sched *sched)
 
         test_calibrations(sched);
 
-        if (perf_sched__read_events(sched, NULL))
+        if (perf_sched__read_events(sched))
                 return -1;
 
         printf("nr_run_events:        %ld\n", sched->nr_run_events);
@@ -1693,6 +1721,7 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
+        OPT_BOOLEAN('f', "force", &sched.force, "don't complain, do it"),
         OPT_END()
         };
         const struct option sched_options[] = {
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index ce304dfd962a..58f10b8e6ff2 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -446,9 +446,9 @@ static void print_sample_bts(union perf_event *event,
 }
 
 static void process_event(union perf_event *event, struct perf_sample *sample,
-                          struct perf_evsel *evsel, struct thread *thread,
-                          struct addr_location *al)
+                          struct perf_evsel *evsel, struct addr_location *al)
 {
+        struct thread *thread = al->thread;
         struct perf_event_attr *attr = &evsel->attr;
 
         if (output[attr->type].fields == 0)
@@ -549,14 +549,6 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                 struct machine *machine)
 {
         struct addr_location al;
-        struct thread *thread = machine__findnew_thread(machine, sample->pid,
-                                                        sample->tid);
-
-        if (thread == NULL) {
-                pr_debug("problem processing %d event, skipping it.\n",
-                         event->header.type);
-                return -1;
-        }
 
         if (debug_mode) {
                 if (sample->time < last_timestamp) {
@@ -581,7 +573,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
         if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
                 return 0;
 
-        scripting_ops->process_event(event, sample, evsel, thread, &al);
+        scripting_ops->process_event(event, sample, evsel, &al);
 
         return 0;
 }
@@ -800,7 +792,7 @@ static int __cmd_script(struct perf_script *script)
                 script->tool.mmap2 = process_mmap2_event;
         }
 
-        ret = perf_session__process_events(script->session, &script->tool);
+        ret = perf_session__process_events(script->session);
 
         if (debug_mode)
                 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
@@ -1523,6 +1515,9 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                         .ordering_requires_timestamps = true,
                 },
         };
+        struct perf_data_file file = {
+                .mode = PERF_DATA_MODE_READ,
+        };
         const struct option options[] = {
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
@@ -1550,7 +1545,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                     "When printing symbols do not display call chain"),
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                     "Look for files with symbols relative to this directory"),
-        OPT_CALLBACK('f', "fields", NULL, "str",
+        OPT_CALLBACK('F', "fields", NULL, "str",
                      "comma separated output fields prepend with 'type:'. "
                      "Valid types: hw,sw,trace,raw. "
                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
@@ -1562,6 +1557,10 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
         OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
                    "only display events for these comms"),
+        OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
+                   "only consider symbols in these pids"),
+        OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
+                   "only consider symbols in these tids"),
         OPT_BOOLEAN('I', "show-info", &show_full_info,
                     "display extended information from perf.data file"),
         OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
@@ -1570,9 +1569,11 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show the fork/comm/exit events"),
         OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
                     "Show the mmap events"),
+        OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
         OPT_END()
         };
-        const char * const script_usage[] = {
+        const char * const script_subcommands[] = { "record", "report", NULL };
+        const char *script_usage[] = {
                 "perf script [<options>]",
                 "perf script [<options>] record <script> [<record-options>] <command>",
                 "perf script [<options>] report <script> [script-args]",
@@ -1580,13 +1581,10 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                 "perf script [<options>] <top-script> [script-args]",
                 NULL
         };
-        struct perf_data_file file = {
-                .mode = PERF_DATA_MODE_READ,
-        };
 
         setup_scripting();
 
-        argc = parse_options(argc, argv, options, script_usage,
+        argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
 
         file.path = input_name;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index e598e4e98170..f7b8218785f6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -353,39 +353,40 @@ static struct perf_evsel *nth_evsel(int n)
  * more semantic information such as miss/hit ratios,
  * instruction rates, etc:
  */
-static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
+static void update_shadow_stats(struct perf_evsel *counter, u64 *count,
+                                int cpu)
 {
         if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
-                update_stats(&runtime_nsecs_stats[0], count[0]);
+                update_stats(&runtime_nsecs_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
-                update_stats(&runtime_cycles_stats[0], count[0]);
+                update_stats(&runtime_cycles_stats[cpu], count[0]);
         else if (transaction_run &&
                  perf_evsel__cmp(counter, nth_evsel(T_CYCLES_IN_TX)))
-                update_stats(&runtime_cycles_in_tx_stats[0], count[0]);
+                update_stats(&runtime_cycles_in_tx_stats[cpu], count[0]);
         else if (transaction_run &&
                  perf_evsel__cmp(counter, nth_evsel(T_TRANSACTION_START)))
-                update_stats(&runtime_transaction_stats[0], count[0]);
+                update_stats(&runtime_transaction_stats[cpu], count[0]);
         else if (transaction_run &&
                  perf_evsel__cmp(counter, nth_evsel(T_ELISION_START)))
-                update_stats(&runtime_elision_stats[0], count[0]);
+                update_stats(&runtime_elision_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
-                update_stats(&runtime_stalled_cycles_front_stats[0], count[0]);
+                update_stats(&runtime_stalled_cycles_front_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
-                update_stats(&runtime_stalled_cycles_back_stats[0], count[0]);
+                update_stats(&runtime_stalled_cycles_back_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
-                update_stats(&runtime_branches_stats[0], count[0]);
+                update_stats(&runtime_branches_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
-                update_stats(&runtime_cacherefs_stats[0], count[0]);
+                update_stats(&runtime_cacherefs_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
-                update_stats(&runtime_l1_dcache_stats[0], count[0]);
+                update_stats(&runtime_l1_dcache_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
-                update_stats(&runtime_l1_icache_stats[0], count[0]);
+                update_stats(&runtime_l1_icache_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
-                update_stats(&runtime_ll_cache_stats[0], count[0]);
+                update_stats(&runtime_ll_cache_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
-                update_stats(&runtime_dtlb_cache_stats[0], count[0]);
+                update_stats(&runtime_dtlb_cache_stats[cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
-                update_stats(&runtime_itlb_cache_stats[0], count[0]);
+                update_stats(&runtime_itlb_cache_stats[cpu], count[0]);
 }
 
 static void zero_per_pkg(struct perf_evsel *counter)
@@ -447,7 +448,8 @@ static int read_cb(struct perf_evsel *evsel, int cpu, int thread __maybe_unused,
                         perf_evsel__compute_deltas(evsel, cpu, count);
                 perf_counts_values__scale(count, scale, NULL);
                 evsel->counts->cpu[cpu] = *count;
-                update_shadow_stats(evsel, count->values);
+                if (aggr_mode == AGGR_NONE)
+                        update_shadow_stats(evsel, count->values, cpu);
                 break;
         case AGGR_GLOBAL:
                 aggr->val += count->val;
@@ -495,7 +497,7 @@ static int read_counter_aggr(struct perf_evsel *counter)
         /*
          * Save the full runtime - to allow normalization during printout:
          */
-        update_shadow_stats(counter, count);
+        update_shadow_stats(counter, count, 0);
 
         return 0;
 }
@@ -510,6 +512,9 @@ static int read_counter(struct perf_evsel *counter)
         int ncpus = perf_evsel__nr_cpus(counter);
         int cpu, thread;
 
+        if (!counter->supported)
+                return -ENOENT;
+
         if (counter->system_wide)
                 nthreads = 1;
 
@@ -679,8 +684,9 @@ static int __run_perf_stat(int argc, const char **argv)
                         unit_width = l;
         }
 
-        if (perf_evlist__apply_filters(evsel_list)) {
-                error("failed to set filter with %d (%s)\n", errno,
+        if (perf_evlist__apply_filters(evsel_list, &counter)) {
+                error("failed to set filter \"%s\" on event %s with %d (%s)\n",
+                        counter->filter, perf_evsel__name(counter), errno,
                         strerror_r(errno, msg, sizeof(msg)));
                 return -1;
         }
@@ -766,6 +772,19 @@ static int run_perf_stat(int argc, const char **argv)
         return ret;
 }
 
+static void print_running(u64 run, u64 ena)
+{
+        if (csv_output) {
+                fprintf(output, "%s%" PRIu64 "%s%.2f",
+                                        csv_sep,
+                                        run,
+                                        csv_sep,
+                                        ena ? 100.0 * run / ena : 100.0);
+        } else if (run != ena) {
+                fprintf(output, "  (%.2f%%)", 100.0 * run / ena);
+        }
+}
+
 static void print_noise_pct(double total, double avg)
 {
         double pct = rel_stddev_stats(total, avg);
@@ -1076,6 +1095,8 @@ static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
                 if (total) {
                         ratio = avg / total;
                         fprintf(output, " #   %5.2f  insns per cycle        ", ratio);
+                } else {
+                        fprintf(output, "                                   ");
                 }
                 total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
                 total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
@@ -1145,6 +1166,8 @@ static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
                 if (total) {
                         ratio = avg / total;
                         fprintf(output, " # %8.3f GHz                    ", ratio);
+                } else {
+                        fprintf(output, "                                   ");
                 }
         } else if (transaction_run &&
                    perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX))) {
@@ -1249,6 +1272,7 @@ static void print_aggr(char *prefix)
                                         fprintf(output, "%s%s",
                                                 csv_sep, counter->cgrp->name);
 
+                                print_running(run, ena);
                                 fputc('\n', output);
                                 continue;
                         }
@@ -1259,13 +1283,10 @@ static void print_aggr(char *prefix)
                         else
                                 abs_printout(id, nr, counter, uval);
 
-                        if (!csv_output) {
+                        if (!csv_output)
                                 print_noise(counter, 1.0);
 
-                                if (run != ena)
-                                        fprintf(output, "  (%.2f%%)",
-                                                100.0 * run / ena);
-                        }
+                        print_running(run, ena);
                         fputc('\n', output);
                 }
         }
@@ -1281,11 +1302,15 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
         double avg = avg_stats(&ps->res_stats[0]);
         int scaled = counter->counts->scaled;
         double uval;
+        double avg_enabled, avg_running;
+
+        avg_enabled = avg_stats(&ps->res_stats[1]);
+        avg_running = avg_stats(&ps->res_stats[2]);
 
         if (prefix)
                 fprintf(output, "%s", prefix);
 
-        if (scaled == -1) {
+        if (scaled == -1 || !counter->supported) {
                 fprintf(output, "%*s%s",
                         csv_output ? 0 : 18,
                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
@@ -1300,6 +1325,7 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
                 if (counter->cgrp)
                         fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
 
+                print_running(avg_running, avg_enabled);
                 fputc('\n', output);
                 return;
         }
@@ -1313,19 +1339,7 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
 
         print_noise(counter, avg);
 
-        if (csv_output) {
-                fputc('\n', output);
-                return;
-        }
-
-        if (scaled) {
-                double avg_enabled, avg_running;
-
-                avg_enabled = avg_stats(&ps->res_stats[1]);
-                avg_running = avg_stats(&ps->res_stats[2]);
-
-                fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
-        }
+        print_running(avg_running, avg_enabled);
         fprintf(output, "\n");
 }
 
@@ -1367,6 +1381,7 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
                                 fprintf(output, "%s%s",
                                         csv_sep, counter->cgrp->name);
 
+                        print_running(run, ena);
                         fputc('\n', output);
                         continue;
                 }
@@ -1378,13 +1393,10 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
                 else
                         abs_printout(cpu, 0, counter, uval);
 
-                if (!csv_output) {
+                if (!csv_output)
                         print_noise(counter, 1.0);
+                print_running(run, ena);
 
-                        if (run != ena)
-                                fprintf(output, "  (%.2f%%)",
-                                        100.0 * run / ena);
-                }
                 fputc('\n', output);
         }
 }
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index f3bb1a4bf060..e50fe1187b0b 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -67,6 +67,7 @@ struct timechart {
                                 skip_eagain;
         u64                     min_time,
                                 merge_dist;
+        bool                    force;
 };
 
 struct per_pidcomm;
@@ -1598,6 +1599,7 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
         struct perf_data_file file = {
                 .path = input_name,
                 .mode = PERF_DATA_MODE_READ,
+                .force = tchart->force,
         };
 
         struct perf_session *session = perf_session__new(&file, false,
@@ -1623,7 +1625,7 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
                 goto out_delete;
         }
 
-        ret = perf_session__process_events(session, &tchart->tool);
+        ret = perf_session__process_events(session);
         if (ret)
                 goto out_delete;
 
@@ -1956,9 +1958,11 @@ int cmd_timechart(int argc, const char **argv,
         OPT_CALLBACK(0, "io-merge-dist", &tchart.merge_dist, "time",
                      "merge events that are merge-dist us apart",
                      parse_time),
+        OPT_BOOLEAN('f', "force", &tchart.force, "don't complain, do it"),
         OPT_END()
         };
-        const char * const timechart_usage[] = {
+        const char * const timechart_subcommands[] = { "record", NULL };
+        const char *timechart_usage[] = {
                 "perf timechart [<options>] {record}",
                 NULL
         };
@@ -1976,8 +1980,8 @@ int cmd_timechart(int argc, const char **argv,
                 "perf timechart record [<options>]",
                 NULL
         };
-        argc = parse_options(argc, argv, timechart_options, timechart_usage,
-                        PARSE_OPT_STOP_AT_NON_OPTION);
+        argc = parse_options_subcommand(argc, argv, timechart_options, timechart_subcommands,
+                        timechart_usage, PARSE_OPT_STOP_AT_NON_OPTION);
 
         if (tchart.power_only && tchart.tasks_only) {
                 pr_err("-P and -T options cannot be used at the same time.\n");
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index c4c7eac69de4..1cb3436276d1 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -716,7 +716,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
 
         if (!machine) {
                 pr_err("%u unprocessable samples recorded.\r",
-                       top->session->stats.nr_unprocessable_samples++);
+                       top->session->evlist->stats.nr_unprocessable_samples++);
                 return;
         }
 
@@ -757,8 +757,10 @@ static void perf_event__process_sample(struct perf_tool *tool,
                     al.map == machine->vmlinux_maps[MAP__FUNCTION] &&
                     RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
                         if (symbol_conf.vmlinux_name) {
-                                ui__warning("The %s file can't be used.\n%s",
-                                            symbol_conf.vmlinux_name, msg);
+                                char serr[256];
+                                dso__strerror_load(al.map->dso, serr, sizeof(serr));
+                                ui__warning("The %s file can't be used: %s\n%s",
+                                            symbol_conf.vmlinux_name, serr, msg);
                         } else {
                                 ui__warning("A vmlinux file was not found.\n%s",
                                             msg);
@@ -856,7 +858,7 @@ static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
                         hists__inc_nr_events(evsel__hists(evsel), event->header.type);
                         machine__process_event(machine, event, &sample);
                 } else
-                        ++session->stats.nr_unknown_events;
+                        ++session->evlist->stats.nr_unknown_events;
 next_event:
                 perf_evlist__mmap_consume(top->evlist, idx);
         }
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 7e935f1083ec..e124741be187 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -52,7 +52,9 @@ struct tp_field {
 #define TP_UINT_FIELD(bits) \
 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
 { \
-        return *(u##bits *)(sample->raw_data + field->offset); \
+        u##bits value; \
+        memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
+        return value;  \
 }
 
 TP_UINT_FIELD(8);
@@ -63,7 +65,8 @@ TP_UINT_FIELD(64);
 #define TP_UINT_FIELD__SWAPPED(bits) \
 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
 { \
-        u##bits value = *(u##bits *)(sample->raw_data + field->offset); \
+        u##bits value; \
+        memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
         return bswap_##bits(value);\
 }
 
@@ -1132,6 +1135,8 @@ static struct syscall_fmt *syscall_fmt__find(const char *name)
 
 struct syscall {
         struct event_format *tp_format;
+        int                 nr_args;
+        struct format_field *args;
         const char          *name;
         bool                filtered;
         bool                is_exit;
@@ -1219,7 +1224,9 @@ struct trace {
                 struct syscall  *table;
         } syscalls;
         struct record_opts      opts;
+        struct perf_evlist      *evlist;
         struct machine          *host;
+        struct thread           *current;
         u64                     base_time;
         FILE                    *output;
         unsigned long           nr_events;
@@ -1227,6 +1234,10 @@ struct trace {
         const char              *last_vfs_getname;
         struct intlist          *tid_list;
         struct intlist          *pid_list;
+        struct {
+                size_t          nr;
+                pid_t           *entries;
+        }                       filter_pids;
         double                  duration_filter;
         double                  runtime_ms;
         struct {
@@ -1243,6 +1254,7 @@ struct trace {
         bool                    show_comm;
         bool                    show_tool_stats;
         bool                    trace_syscalls;
+        bool                    force;
         int                     trace_pgfaults;
 };
 
@@ -1433,14 +1445,14 @@ static int syscall__set_arg_fmts(struct syscall *sc)
         struct format_field *field;
         int idx = 0;
 
-        sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
+        sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
         if (sc->arg_scnprintf == NULL)
                 return -1;
 
         if (sc->fmt)
                 sc->arg_parm = sc->fmt->arg_parm;
 
-        for (field = sc->tp_format->format.fields->next; field; field = field->next) {
+        for (field = sc->args; field; field = field->next) {
                 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
                         sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
                 else if (field->flags & FIELD_IS_POINTER)
@@ -1506,18 +1518,37 @@ static int trace__read_syscall_info(struct trace *trace, int id)
         if (sc->tp_format == NULL)
                 return -1;
 
+        sc->args = sc->tp_format->format.fields;
+        sc->nr_args = sc->tp_format->format.nr_fields;
+        /* drop nr field - not relevant here; does not exist on older kernels */
+        if (sc->args && strcmp(sc->args->name, "nr") == 0) {
+                sc->args = sc->args->next;
+                --sc->nr_args;
+        }
+
         sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
 
         return syscall__set_arg_fmts(sc);
 }
 
+/*
+ * args is to be interpreted as a series of longs but we need to handle
+ * 8-byte unaligned accesses. args points to raw_data within the event
+ * and raw_data is guaranteed to be 8-byte unaligned because it is
+ * preceded by raw_size which is a u32. So we need to copy args to a temp
+ * variable to read it. Most notably this avoids extended load instructions
+ * on unaligned addresses
+ */
+
 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
-                                      unsigned long *args, struct trace *trace,
+                                      unsigned char *args, struct trace *trace,
                                       struct thread *thread)
 {
         size_t printed = 0;
+        unsigned char *p;
+        unsigned long val;
 
-        if (sc->tp_format != NULL) {
+        if (sc->args != NULL) {
                 struct format_field *field;
                 u8 bit = 1;
                 struct syscall_arg arg = {
@@ -1527,16 +1558,21 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                         .thread = thread,
                 };
 
-                for (field = sc->tp_format->format.fields->next; field;
+                for (field = sc->args; field;
                      field = field->next, ++arg.idx, bit <<= 1) {
                         if (arg.mask & bit)
                                 continue;
+
+                        /* special care for unaligned accesses */
+                        p = args + sizeof(unsigned long) * arg.idx;
+                        memcpy(&val, p, sizeof(val));
+
                         /*
                          * Suppress this argument if its value is zero and
                          * and we don't have a string associated in an
                          * strarray for it.
                          */
-                        if (args[arg.idx] == 0 &&
+                        if (val == 0 &&
                             !(sc->arg_scnprintf &&
                               sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
                               sc->arg_parm[arg.idx]))
@@ -1545,23 +1581,26 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                         printed += scnprintf(bf + printed, size - printed,
                                              "%s%s: ", printed ? ", " : "", field->name);
                         if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
-                                arg.val = args[arg.idx];
+                                arg.val = val;
                                 if (sc->arg_parm)
                                         arg.parm = sc->arg_parm[arg.idx];
                                 printed += sc->arg_scnprintf[arg.idx](bf + printed,
                                                                       size - printed, &arg);
                         } else {
                                 printed += scnprintf(bf + printed, size - printed,
-                                                     "%ld", args[arg.idx]);
+                                                     "%ld", val);
                         }
                 }
         } else {
                 int i = 0;
 
                 while (i < 6) {
+                        /* special care for unaligned accesses */
+                        p = args + sizeof(unsigned long) * i;
+                        memcpy(&val, p, sizeof(val));
                         printed += scnprintf(bf + printed, size - printed,
                                              "%sarg%d: %ld",
-                                             printed ? ", " : "", i, args[i]);
+                                             printed ? ", " : "", i, val);
                         ++i;
                 }
         }
@@ -1642,6 +1681,29 @@ static void thread__update_stats(struct thread_trace *ttrace,
         update_stats(stats, duration);
 }
 
+static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
+{
+        struct thread_trace *ttrace;
+        u64 duration;
+        size_t printed;
+
+        if (trace->current == NULL)
+                return 0;
+
+        ttrace = thread__priv(trace->current);
+
+        if (!ttrace->entry_pending)
+                return 0;
+
+        duration = sample->time - ttrace->entry_time;
+
+        printed  = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
+        printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
+        ttrace->entry_pending = false;
+
+        return printed;
+}
+
 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                             union perf_event *event __maybe_unused,
                             struct perf_sample *sample)
@@ -1673,6 +1735,9 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                         return -1;
         }
 
+        if (!trace->summary_only)
+                trace__printf_interrupted_entry(trace, sample);
+
         ttrace->entry_time = sample->time;
         msg = ttrace->entry_str;
         printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
@@ -1688,6 +1753,11 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
         } else
                 ttrace->entry_pending = true;
 
+        if (trace->current != thread) {
+                thread__put(trace->current);
+                trace->current = thread__get(thread);
+        }
+
         return 0;
 }
 
@@ -1805,6 +1875,28 @@ out_dump:
         return 0;
 }
 
+static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
+                                union perf_event *event __maybe_unused,
+                                struct perf_sample *sample)
+{
+        trace__printf_interrupted_entry(trace, sample);
+        trace__fprintf_tstamp(trace, sample->time, trace->output);
+
+        if (trace->trace_syscalls)
+                fprintf(trace->output, "(         ): ");
+
+        fprintf(trace->output, "%s:", evsel->name);
+
+        if (evsel->tp_format) {
+                event_format__fprintf(evsel->tp_format, sample->cpu,
+                                      sample->raw_data, sample->raw_size,
+                                      trace->output);
+        }
+
+        fprintf(trace->output, ")\n");
+        return 0;
+}
+
 static void print_location(FILE *f, struct perf_sample *sample,
                            struct addr_location *al,
                            bool print_dso, bool print_sym)
@@ -2037,10 +2129,39 @@ static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
         return 0;
 }
 
-static int trace__run(struct trace *trace, int argc, const char **argv)
+static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
 {
-        struct perf_evlist *evlist = perf_evlist__new();
+        const u32 type = event->header.type;
         struct perf_evsel *evsel;
+
+        if (!trace->full_time && trace->base_time == 0)
+                trace->base_time = sample->time;
+
+        if (type != PERF_RECORD_SAMPLE) {
+                trace__process_event(trace, trace->host, event, sample);
+                return;
+        }
+
+        evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
+        if (evsel == NULL) {
+                fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
+                return;
+        }
+
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
+            sample->raw_data == NULL) {
+                fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
+                       perf_evsel__name(evsel), sample->tid,
+                       sample->cpu, sample->raw_size);
+        } else {
+                tracepoint_handler handler = evsel->handler;
+                handler(trace, evsel, event, sample);
+        }
+}
+
+static int trace__run(struct trace *trace, int argc, const char **argv)
+{
+        struct perf_evlist *evlist = trace->evlist;
         int err = -1, i;
         unsigned long before;
         const bool forks = argc > 0;
@@ -2048,11 +2169,6 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
 
         trace->live = true;
 
-        if (evlist == NULL) {
-                fprintf(trace->output, "Not enough memory to run!\n");
-                goto out;
-        }
-
         if (trace->trace_syscalls &&
             perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
                                            trace__sys_exit))
@@ -2105,16 +2221,34 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
         if (err < 0)
                 goto out_error_open;
 
+        /*
+         * Better not use !target__has_task() here because we need to cover the
+         * case where no threads were specified in the command line, but a
+         * workload was, and in that case we will fill in the thread_map when
+         * we fork the workload in perf_evlist__prepare_workload.
+         */
+        if (trace->filter_pids.nr > 0)
+                err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
+        else if (evlist->threads->map[0] == -1)
+                err = perf_evlist__set_filter_pid(evlist, getpid());
+
+        if (err < 0) {
+                printf("err=%d,%s\n", -err, strerror(-err));
+                exit(1);
+        }
+
         err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
         if (err < 0)
                 goto out_error_mmap;
 
-        perf_evlist__enable(evlist);
-
         if (forks)
                 perf_evlist__start_workload(evlist);
+        else
+                perf_evlist__enable(evlist);
 
-        trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
+        trace->multiple_threads = evlist->threads->map[0] == -1 ||
+                                  evlist->threads->nr > 1 ||
+                                  perf_evlist__first(evlist)->attr.inherit;
 again:
         before = trace->nr_events;
 
@@ -2122,8 +2256,6 @@ again:
                 union perf_event *event;
 
                 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
-                        const u32 type = event->header.type;
-                        tracepoint_handler handler;
                         struct perf_sample sample;
 
                         ++trace->nr_events;
@@ -2134,30 +2266,7 @@ again:
                                 goto next_event;
                         }
 
-                        if (!trace->full_time && trace->base_time == 0)
-                                trace->base_time = sample.time;
-
-                        if (type != PERF_RECORD_SAMPLE) {
-                                trace__process_event(trace, trace->host, event, &sample);
-                                continue;
-                        }
-
-                        evsel = perf_evlist__id2evsel(evlist, sample.id);
-                        if (evsel == NULL) {
-                                fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
-                                goto next_event;
-                        }
-
-                        if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
-                            sample.raw_data == NULL) {
-                                fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
-                                       perf_evsel__name(evsel), sample.tid,
-                                       sample.cpu, sample.raw_size);
-                                goto next_event;
-                        }
-
-                        handler = evsel->handler;
-                        handler(trace, evsel, event, &sample);
+                        trace__handle_event(trace, event, &sample);
 next_event:
                         perf_evlist__mmap_consume(evlist, i);
 
@@ -2180,6 +2289,8 @@ next_event:
         }
 
 out_disable:
+        thread__zput(trace->current);
+
         perf_evlist__disable(evlist);
 
         if (!err) {
@@ -2197,7 +2308,7 @@ out_disable:
 
 out_delete_evlist:
         perf_evlist__delete(evlist);
-out:
+        trace->evlist = NULL;
         trace->live = false;
         return err;
 {
@@ -2235,6 +2346,7 @@ static int trace__replay(struct trace *trace)
         struct perf_data_file file = {
                 .path  = input_name,
                 .mode  = PERF_DATA_MODE_READ,
+                .force = trace->force,
         };
         struct perf_session *session;
         struct perf_evsel *evsel;
@@ -2309,7 +2421,7 @@ static int trace__replay(struct trace *trace)
 
         setup_pager();
 
-        err = perf_session__process_events(session, &trace->tool);
+        err = perf_session__process_events(session);
         if (err)
                 pr_err("Failed to process events, error %d", err);
 
@@ -2434,6 +2546,38 @@ static int trace__set_duration(const struct option *opt, const char *str,
         return 0;
 }
 
+static int trace__set_filter_pids(const struct option *opt, const char *str,
+                                  int unset __maybe_unused)
+{
+        int ret = -1;
+        size_t i;
+        struct trace *trace = opt->value;
+        /*
+         * FIXME: introduce a intarray class, plain parse csv and create a
+         * { int nr, int entries[] } struct...
+         */
+        struct intlist *list = intlist__new(str);
+
+        if (list == NULL)
+                return -1;
+
+        i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
+        trace->filter_pids.entries = calloc(i, sizeof(pid_t));
+
+        if (trace->filter_pids.entries == NULL)
+                goto out;
+
+        trace->filter_pids.entries[0] = getpid();
+
+        for (i = 1; i < trace->filter_pids.nr; ++i)
+                trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
+
+        intlist__delete(list);
+        ret = 0;
+out:
+        return ret;
+}
+
 static int trace__open_output(struct trace *trace, const char *filename)
 {
         struct stat st;
@@ -2468,9 +2612,17 @@ static int parse_pagefaults(const struct option *opt, const char *str,
         return 0;
 }
 
+static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
+{
+        struct perf_evsel *evsel;
+
+        evlist__for_each(evlist, evsel)
+                evsel->handler = handler;
+}
+
 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        const char * const trace_usage[] = {
+        const char *trace_usage[] = {
                 "perf trace [<options>] [<command>]",
                 "perf trace [<options>] -- <command> [<options>]",
                 "perf trace record [<options>] [<command>]",
@@ -2502,6 +2654,9 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
         const char *output_name = NULL;
         const char *ev_qualifier_str = NULL;
         const struct option trace_options[] = {
+        OPT_CALLBACK(0, "event", &trace.evlist, "event",
+                     "event selector. use 'perf list' to list available events",
+                     parse_events_option),
         OPT_BOOLEAN(0, "comm", &trace.show_comm,
                     "show the thread COMM next to its id"),
         OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
@@ -2513,6 +2668,8 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
                     "trace events on existing process id"),
         OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
                     "trace events on existing thread id"),
+        OPT_CALLBACK(0, "filter-pids", &trace, "float",
+                     "show only events with duration > N.M ms", trace__set_filter_pids),
         OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
                     "system-wide collection from all CPUs"),
         OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
@@ -2538,19 +2695,36 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
                      "Trace pagefaults", parse_pagefaults, "maj"),
         OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
+        OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
         OPT_END()
         };
+        const char * const trace_subcommands[] = { "record", NULL };
         int err;
         char bf[BUFSIZ];
 
-        argc = parse_options(argc, argv, trace_options, trace_usage,
-                             PARSE_OPT_STOP_AT_NON_OPTION);
+        signal(SIGSEGV, sighandler_dump_stack);
+        signal(SIGFPE, sighandler_dump_stack);
+
+        trace.evlist = perf_evlist__new();
+        if (trace.evlist == NULL)
+                return -ENOMEM;
+
+        if (trace.evlist == NULL) {
+                pr_err("Not enough memory to run!\n");
+                goto out;
+        }
+
+        argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
+                                 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
 
         if (trace.trace_pgfaults) {
                 trace.opts.sample_address = true;
                 trace.opts.sample_time = true;
         }
 
+        if (trace.evlist->nr_entries > 0)
+                evlist__set_evsel_handler(trace.evlist, trace__event_handler);
+
         if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
                 return trace__record(&trace, argc-1, &argv[1]);
 
@@ -2558,7 +2732,8 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
         if (trace.summary_only)
                 trace.summary = trace.summary_only;
 
-        if (!trace.trace_syscalls && !trace.trace_pgfaults) {
+        if (!trace.trace_syscalls && !trace.trace_pgfaults &&
+            trace.evlist->nr_entries == 0 /* Was --events used? */) {
                 pr_err("Please specify something to trace.\n");
                 return -1;
         }
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index b210d62907e4..3688ad29085f 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -37,6 +37,7 @@ extern int cmd_test(int argc, const char **argv, const char *prefix);
 extern int cmd_trace(int argc, const char **argv, const char *prefix);
 extern int cmd_inject(int argc, const char **argv, const char *prefix);
 extern int cmd_mem(int argc, const char **argv, const char *prefix);
+extern int cmd_data(int argc, const char **argv, const char *prefix);
 
 extern int find_scripts(char **scripts_array, char **scripts_path_array);
 #endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 0906fc401c52..00fcaf8a5b8d 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -7,6 +7,7 @@ perf-archive			mainporcelain common
 perf-bench                      mainporcelain common
 perf-buildid-cache              mainporcelain common
 perf-buildid-list               mainporcelain common
+perf-data                       mainporcelain common
 perf-diff                       mainporcelain common
 perf-evlist                     mainporcelain common
 perf-inject                     mainporcelain common
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index cc224080b525..59a98c643240 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -11,19 +11,26 @@ ifneq ($(obj-perf),)
 obj-perf := $(abspath $(obj-perf))/
 endif
 
-LIB_INCLUDE := $(srctree)/tools/lib/
+$(shell echo -n > .config-detected)
+detected     = $(shell echo "$(1)=y"       >> .config-detected)
+detected_var = $(shell echo "$(1)=$($(1))" >> .config-detected)
+
 CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)
 
 include $(src-perf)/config/Makefile.arch
 
+$(call detected_var,ARCH)
+
 NO_PERF_REGS := 1
 
 # Additional ARCH settings for x86
 ifeq ($(ARCH),x86)
+  $(call detected,CONFIG_X86)
   ifeq (${IS_64_BIT}, 1)
     CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT
     ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
     LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
+    $(call detected,CONFIG_X86_64)
   else
     LIBUNWIND_LIBS = -lunwind -lunwind-x86
   endif
@@ -40,6 +47,10 @@ ifeq ($(ARCH),arm64)
   LIBUNWIND_LIBS = -lunwind -lunwind-aarch64
 endif
 
+ifeq ($(NO_PERF_REGS),0)
+  $(call detected,CONFIG_PERF_REGS)
+endif
+
 # So far there's only x86 and arm libdw unwind support merged in perf.
 # Disable it on all other architectures in case libdw unwind
 # support is detected in system. Add supported architectures
@@ -84,6 +95,17 @@ ifndef NO_LIBELF
   FEATURE_CHECK_LDFLAGS-libdw-dwarf-unwind := $(LIBDW_LDFLAGS) -ldw
 endif
 
+ifdef LIBBABELTRACE
+  # for linking with debug library, run like:
+  # make DEBUG=1 LIBBABELTRACE_DIR=/opt/libbabeltrace/
+  ifdef LIBBABELTRACE_DIR
+    LIBBABELTRACE_CFLAGS  := -I$(LIBBABELTRACE_DIR)/include
+    LIBBABELTRACE_LDFLAGS := -L$(LIBBABELTRACE_DIR)/lib
+  endif
+  FEATURE_CHECK_CFLAGS-libbabeltrace := $(LIBBABELTRACE_CFLAGS)
+  FEATURE_CHECK_LDFLAGS-libbabeltrace := $(LIBBABELTRACE_LDFLAGS) -lbabeltrace-ctf
+endif
+
 # include ARCH specific config
 -include $(src-perf)/arch/$(ARCH)/Makefile
 
@@ -114,6 +136,8 @@ ifdef PARSER_DEBUG
   PARSER_DEBUG_BISON := -t
   PARSER_DEBUG_FLEX  := -d
   CFLAGS             += -DPARSER_DEBUG
+  $(call detected_var,PARSER_DEBUG_BISON)
+  $(call detected_var,PARSER_DEBUG_FLEX)
 endif
 
 ifndef NO_LIBPYTHON
@@ -152,121 +176,7 @@ LDFLAGS += -Wl,-z,noexecstack
 
 EXTLIBS = -lpthread -lrt -lm -ldl
 
-ifneq ($(OUTPUT),)
-  OUTPUT_FEATURES = $(OUTPUT)config/feature-checks/
-  $(shell mkdir -p $(OUTPUT_FEATURES))
-endif
-
-feature_check = $(eval $(feature_check_code))
-define feature_check_code
-  feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C config/feature-checks test-$1.bin >/dev/null 2>/dev/null && echo 1 || echo 0)
-endef
-
-feature_set = $(eval $(feature_set_code))
-define feature_set_code
-  feature-$(1) := 1
-endef
-
-#
-# Build the feature check binaries in parallel, ignore errors, ignore return value and suppress output:
-#
-
-#
-# Note that this is not a complete list of all feature tests, just
-# those that are typically built on a fully configured system.
-#
-# [ Feature tests not mentioned here have to be built explicitly in
-#   the rule that uses them - an example for that is the 'bionic'
-#   feature check. ]
-#
-CORE_FEATURE_TESTS =                    \
-        backtrace                       \
-        dwarf                           \
-        fortify-source                  \
-        sync-compare-and-swap           \
-        glibc                           \
-        gtk2                            \
-        gtk2-infobar                    \
-        libaudit                        \
-        libbfd                          \
-        libelf                          \
-        libelf-getphdrnum               \
-        libelf-mmap                     \
-        libnuma                         \
-        libperl                         \
-        libpython                       \
-        libpython-version               \
-        libslang                        \
-        libunwind                       \
-        pthread-attr-setaffinity-np     \
-        stackprotector-all              \
-        timerfd                         \
-        libdw-dwarf-unwind              \
-        zlib
-
-LIB_FEATURE_TESTS =                     \
-        dwarf                           \
-        glibc                           \
-        gtk2                            \
-        libaudit                        \
-        libbfd                          \
-        libelf                          \
-        libnuma                         \
-        libperl                         \
-        libpython                       \
-        libslang                        \
-        libunwind                       \
-        libdw-dwarf-unwind              \
-        zlib
-
-VF_FEATURE_TESTS =                      \
-        backtrace                       \
-        fortify-source                  \
-        sync-compare-and-swap           \
-        gtk2-infobar                    \
-        libelf-getphdrnum               \
-        libelf-mmap                     \
-        libpython-version               \
-        pthread-attr-setaffinity-np     \
-        stackprotector-all              \
-        timerfd                         \
-        libunwind-debug-frame           \
-        bionic                          \
-        liberty                         \
-        liberty-z                       \
-        cplus-demangle                  \
-        compile-32                      \
-        compile-x32
-
-# Set FEATURE_CHECK_(C|LD)FLAGS-all for all CORE_FEATURE_TESTS features.
-# If in the future we need per-feature checks/flags for features not
-# mentioned in this list we need to refactor this ;-).
-set_test_all_flags = $(eval $(set_test_all_flags_code))
-define set_test_all_flags_code
-  FEATURE_CHECK_CFLAGS-all  += $(FEATURE_CHECK_CFLAGS-$(1))
-  FEATURE_CHECK_LDFLAGS-all += $(FEATURE_CHECK_LDFLAGS-$(1))
-endef
-
-$(foreach feat,$(CORE_FEATURE_TESTS),$(call set_test_all_flags,$(feat)))
-
-#
-# Special fast-path for the 'all features are available' case:
-#
-$(call feature_check,all,$(MSG))
-
-#
-# Just in case the build freshly failed, make sure we print the
-# feature matrix:
-#
-ifeq ($(feature-all), 1)
-  #
-  # test-all.c passed - just set all the core feature flags to 1:
-  #
-  $(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_set,$(feat)))
-else
-  $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS)" LDFLAGS=$(LDFLAGS) -i -j -C config/feature-checks $(addsuffix .bin,$(CORE_FEATURE_TESTS)) >/dev/null 2>&1)
-  $(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_check,$(feat)))
-endif
+include $(srctree)/tools/build/Makefile.feature
 
 ifeq ($(feature-stackprotector-all), 1)
   CFLAGS += -fstack-protector-all
@@ -295,7 +205,7 @@ endif
 
 CFLAGS += -I$(src-perf)/util
 CFLAGS += -I$(src-perf)
-CFLAGS += -I$(LIB_INCLUDE)
+CFLAGS += -I$(srctree)/tools/lib/
 
 CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
 
@@ -361,6 +271,7 @@ endif # NO_LIBELF
 ifndef NO_LIBELF
   CFLAGS += -DHAVE_LIBELF_SUPPORT
   EXTLIBS += -lelf
+  $(call detected,CONFIG_LIBELF)
 
   ifeq ($(feature-libelf-mmap), 1)
     CFLAGS += -DHAVE_LIBELF_MMAP_SUPPORT
@@ -381,6 +292,7 @@ ifndef NO_LIBELF
       CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)
       LDFLAGS += $(LIBDW_LDFLAGS)
       EXTLIBS += -ldw
+      $(call detected,CONFIG_DWARF)
     endif # PERF_HAVE_DWARF_REGS
   endif # NO_DWARF
 endif # NO_LIBELF
@@ -408,9 +320,11 @@ ifdef NO_LIBUNWIND
     dwarf-post-unwind := 0
   else
     dwarf-post-unwind-text := libdw
+    $(call detected,CONFIG_LIBDW_DWARF_UNWIND)
   endif
 else
   dwarf-post-unwind-text := libunwind
+  $(call detected,CONFIG_LIBUNWIND)
   # Enable libunwind support by default.
   ifndef NO_LIBDW_DWARF_UNWIND
     NO_LIBDW_DWARF_UNWIND := 1
@@ -419,6 +333,7 @@ endif
 
 ifeq ($(dwarf-post-unwind),1)
   CFLAGS += -DHAVE_DWARF_UNWIND_SUPPORT
+  $(call detected,CONFIG_DWARF_UNWIND)
 else
   NO_DWARF_UNWIND := 1
 endif
@@ -447,6 +362,7 @@ ifndef NO_LIBAUDIT
   else
     CFLAGS += -DHAVE_LIBAUDIT_SUPPORT
     EXTLIBS += -laudit
+    $(call detected,CONFIG_AUDIT)
   endif
 endif
 
@@ -463,6 +379,7 @@ ifndef NO_SLANG
     CFLAGS += -I/usr/include/slang
     CFLAGS += -DHAVE_SLANG_SUPPORT
     EXTLIBS += -lslang
+    $(call detected,CONFIG_SLANG)
   endif
 endif
 
@@ -497,10 +414,11 @@ else
   ifneq ($(feature-libperl), 1)
     CFLAGS += -DNO_LIBPERL
     NO_LIBPERL := 1
-    msg := $(warning Missing perl devel files. Disabling perl scripting support, consider installing perl-ExtUtils-Embed);
+    msg := $(warning Missing perl devel files. Disabling perl scripting support, please install perl-ExtUtils-Embed/libperl-dev);
   else
     LDFLAGS += $(PERL_EMBED_LDFLAGS)
     EXTLIBS += $(PERL_EMBED_LIBADD)
+    $(call detected,CONFIG_LIBPERL)
   endif
 endif
 
@@ -513,22 +431,21 @@ endif
 disable-python = $(eval $(disable-python_code))
 define disable-python_code
   CFLAGS += -DNO_LIBPYTHON
-  $(if $(1),$(warning No $(1) was found))
-  $(warning Python support will not be built)
+  $(warning $1)
   NO_LIBPYTHON := 1
 endef
 
 ifdef NO_LIBPYTHON
-  $(call disable-python)
+  $(call disable-python,Python support disabled by user)
 else
 
   ifndef PYTHON
-    $(call disable-python,python interpreter)
+    $(call disable-python,No python interpreter was found: disables Python support - please install python-devel/python-dev)
   else
     PYTHON_WORD := $(call shell-wordify,$(PYTHON))
 
     ifndef PYTHON_CONFIG
-      $(call disable-python,python-config tool)
+      $(call disable-python,No 'python-config' tool was found: disables Python support - please install python-devel/python-dev)
     else
 
       PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
@@ -540,7 +457,7 @@ else
       FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
 
       ifneq ($(feature-libpython), 1)
-        $(call disable-python,Python.h (for Python 2.x))
+        $(call disable-python,No 'Python.h' (for Python 2.x support) was found: disables Python support - please install python-devel/python-dev)
       else
 
         ifneq ($(feature-libpython-version), 1)
@@ -560,6 +477,7 @@ else
           LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
           EXTLIBS += $(PYTHON_EMBED_LIBADD)
           LANG_BINDINGS += $(obj-perf)python/perf.so
+          $(call detected,CONFIG_LIBPYTHON)
         endif
       endif
     endif
@@ -600,7 +518,7 @@ else
             EXTLIBS += -liberty
             CFLAGS += -DHAVE_CPLUS_DEMANGLE_SUPPORT
           else
-            msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
+            msg := $(warning No bfd.h/libbfd found, please install binutils-dev[el]/zlib-static/libiberty-dev to gain symbol demangling)
             CFLAGS += -DNO_DEMANGLE
           endif
         endif
@@ -617,11 +535,23 @@ ifndef NO_ZLIB
   ifeq ($(feature-zlib), 1)
     CFLAGS += -DHAVE_ZLIB_SUPPORT
     EXTLIBS += -lz
+    $(call detected,CONFIG_ZLIB)
   else
     NO_ZLIB := 1
   endif
 endif
 
+ifndef NO_LZMA
+  ifeq ($(feature-lzma), 1)
+    CFLAGS += -DHAVE_LZMA_SUPPORT
+    EXTLIBS += -llzma
+    $(call detected,CONFIG_LZMA)
+  else
+    msg := $(warning No liblzma found, disables xz kernel module decompression, please install xz-devel/liblzma-dev);
+    NO_LZMA := 1
+  endif
+endif
+
 ifndef NO_BACKTRACE
   ifeq ($(feature-backtrace), 1)
     CFLAGS += -DHAVE_BACKTRACE_SUPPORT
@@ -635,6 +565,7 @@ ifndef NO_LIBNUMA
   else
     CFLAGS += -DHAVE_LIBNUMA_SUPPORT
     EXTLIBS += -lnuma
+    $(call detected,CONFIG_NUMA)
   endif
 endif
 
@@ -651,7 +582,7 @@ ifeq (${IS_64_BIT}, 1)
       NO_PERF_READ_VDSO32 := 1
     endif
   endif
-  ifneq (${IS_X86_64}, 1)
+  ifneq ($(ARCH), x86)
     NO_PERF_READ_VDSOX32 := 1
   endif
   ifndef NO_PERF_READ_VDSOX32
@@ -667,6 +598,18 @@ else
   NO_PERF_READ_VDSOX32 := 1
 endif
 
+ifdef LIBBABELTRACE
+  $(call feature_check,libbabeltrace)
+  ifeq ($(feature-libbabeltrace), 1)
+    CFLAGS += -DHAVE_LIBBABELTRACE_SUPPORT $(LIBBABELTRACE_CFLAGS)
+    LDFLAGS += $(LIBBABELTRACE_LDFLAGS)
+    EXTLIBS += -lbabeltrace-ctf
+    $(call detected,CONFIG_LIBBABELTRACE)
+  else
+    msg := $(warning No libbabeltrace found, disables 'perf data' CTF format support, please install libbabeltrace-dev[el]/libbabeltrace-ctf-dev);
+  endif
+endif
+
 # Among the variables below, these:
 #   perfexecdir
 #   template_dir
@@ -699,7 +642,7 @@ sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 ifndef lib
-ifeq ($(IS_X86_64),1)
+ifeq ($(ARCH)$(IS_64_BIT), x861)
 lib = lib64
 else
 lib = lib
@@ -735,83 +678,33 @@ plugindir=$(libdir)/traceevent/plugins
 plugindir_SQ= $(subst ','\'',$(plugindir))
 endif
 
-#
-# Print the result of the feature test:
-#
-feature_print_status = $(eval $(feature_print_status_code)) $(info $(MSG))
-
-define feature_print_status_code
-  ifeq ($(feature-$(1)), 1)
-    MSG = $(shell printf '...%30s: [ \033[32mon\033[m  ]' $(1))
-  else
-    MSG = $(shell printf '...%30s: [ \033[31mOFF\033[m ]' $(1))
-  endif
-endef
-
-feature_print_var = $(eval $(feature_print_var_code)) $(info $(MSG))
-define feature_print_var_code
+print_var = $(eval $(print_var_code)) $(info $(MSG))
+define print_var_code
     MSG = $(shell printf '...%30s: %s' $(1) $($(1)))
 endef
 
-feature_print_text = $(eval $(feature_print_text_code)) $(info $(MSG))
-define feature_print_text_code
-    MSG = $(shell printf '...%30s: %s' $(1) $(2))
-endef
-
-PERF_FEATURES := $(foreach feat,$(LIB_FEATURE_TESTS),feature-$(feat)($(feature-$(feat))))
-PERF_FEATURES_FILE := $(shell touch $(OUTPUT)PERF-FEATURES; cat $(OUTPUT)PERF-FEATURES)
-
-ifeq ($(dwarf-post-unwind),1)
-  PERF_FEATURES += dwarf-post-unwind($(dwarf-post-unwind-text))
-endif
-
-# The $(display_lib) controls the default detection message
-# output. It's set if:
-# - detected features differes from stored features from
-#   last build (in PERF-FEATURES file)
-# - one of the $(LIB_FEATURE_TESTS) is not detected
-# - VF is enabled
-
-ifneq ("$(PERF_FEATURES)","$(PERF_FEATURES_FILE)")
-  $(shell echo "$(PERF_FEATURES)" > $(OUTPUT)PERF-FEATURES)
-  display_lib := 1
-endif
-
-feature_check = $(eval $(feature_check_code))
-define feature_check_code
-  ifneq ($(feature-$(1)), 1)
-    display_lib := 1
-  endif
-endef
-
-$(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_check,$(feat)))
-
 ifeq ($(VF),1)
-  display_lib := 1
-  display_vf := 1
-endif
-
-ifeq ($(display_lib),1)
+  $(call print_var,prefix)
+  $(call print_var,bindir)
+  $(call print_var,libdir)
+  $(call print_var,sysconfdir)
+  $(call print_var,LIBUNWIND_DIR)
+  $(call print_var,LIBDW_DIR)
   $(info )
-  $(info Auto-detecting system features:)
-  $(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_print_status,$(feat),))
-
-  ifeq ($(dwarf-post-unwind),1)
-    $(call feature_print_text,"DWARF post unwind library", $(dwarf-post-unwind-text))
-  endif
-endif
-
-ifeq ($(display_vf),1)
-  $(foreach feat,$(VF_FEATURE_TESTS),$(call feature_print_status,$(feat),))
-  $(info )
-  $(call feature_print_var,prefix)
-  $(call feature_print_var,bindir)
-  $(call feature_print_var,libdir)
-  $(call feature_print_var,sysconfdir)
-  $(call feature_print_var,LIBUNWIND_DIR)
-  $(call feature_print_var,LIBDW_DIR)
 endif
 
-ifeq ($(display_lib),1)
-  $(info )
-endif
+$(call detected_var,bindir_SQ)
+$(call detected_var,PYTHON_WORD)
+ifneq ($(OUTPUT),)
+$(call detected_var,OUTPUT)
+endif
+$(call detected_var,htmldir_SQ)
+$(call detected_var,infodir_SQ)
+$(call detected_var,mandir_SQ)
+$(call detected_var,ETC_PERFCONFIG_SQ)
+$(call detected_var,prefix_SQ)
+$(call detected_var,perfexecdir_SQ)
+$(call detected_var,LIBDIR)
+$(call detected_var,GTK_CFLAGS)
+$(call detected_var,PERL_EMBED_CCOPTS)
+$(call detected_var,PYTHON_EMBED_CCOPTS)
diff --git a/tools/perf/config/Makefile.arch b/tools/perf/config/Makefile.arch
index ac8721ffa6c8..e11fbd6fae78 100644
--- a/tools/perf/config/Makefile.arch
+++ b/tools/perf/config/Makefile.arch
@@ -1,32 +1,15 @@
+ifndef ARCH
+ARCH := $(shell uname -m 2>/dev/null || echo not)
+endif
 
-uname_M := $(shell uname -m 2>/dev/null || echo not)
-
-RAW_ARCH := $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
-                                  -e s/arm.*/arm/ -e s/sa110/arm/ \
+ARCH := $(shell echo $(ARCH) | sed -e s/i.86/x86/ -e s/x86_64/x86/ \
+                                  -e s/sun4u/sparc/ -e s/sparc64/sparc/ \
+                                  -e /arm64/!s/arm.*/arm/ -e s/sa110/arm/ \
                                   -e s/s390x/s390/ -e s/parisc64/parisc/ \
                                   -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
                                   -e s/sh[234].*/sh/ -e s/aarch64.*/arm64/ \
                                   -e s/tile.*/tile/ )
 
-# Additional ARCH settings for x86
-ifeq ($(RAW_ARCH),i386)
-  ARCH ?= x86
-endif
-
-ifeq ($(RAW_ARCH),x86_64)
-  ARCH ?= x86
-
-  ifneq (, $(findstring m32,$(CFLAGS)))
-    RAW_ARCH := x86_32
-  endif
-endif
-
-ifeq ($(RAW_ARCH),sparc64)
-  ARCH ?= sparc
-endif
-
-ARCH ?= $(RAW_ARCH)
-
 LP64 := $(shell echo __LP64__ | ${CC} ${CFLAGS} -E -x c - | tail -n 1)
 ifeq ($(LP64), 1)
   IS_64_BIT := 1
diff --git a/tools/perf/config/feature-checks/.gitignore b/tools/perf/config/feature-checks/.gitignore
deleted file mode 100644
index 80f3da0c3515..000000000000
--- a/tools/perf/config/feature-checks/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*.d
-*.bin
diff --git a/tools/perf/config/feature-checks/Makefile b/tools/perf/config/feature-checks/Makefile
deleted file mode 100644
index b32ff3372514..000000000000
--- a/tools/perf/config/feature-checks/Makefile
+++ /dev/null
@@ -1,155 +0,0 @@
-
-FILES=                                  \
-        test-all.bin                    \
-        test-backtrace.bin              \
-        test-bionic.bin                 \
-        test-dwarf.bin                  \
-        test-fortify-source.bin         \
-        test-sync-compare-and-swap.bin  \
-        test-glibc.bin                  \
-        test-gtk2.bin                   \
-        test-gtk2-infobar.bin           \
-        test-hello.bin                  \
-        test-libaudit.bin               \
-        test-libbfd.bin                 \
-        test-liberty.bin                \
-        test-liberty-z.bin              \
-        test-cplus-demangle.bin         \
-        test-libelf.bin                 \
-        test-libelf-getphdrnum.bin      \
-        test-libelf-mmap.bin            \
-        test-libnuma.bin                \
-        test-libperl.bin                \
-        test-libpython.bin              \
-        test-libpython-version.bin      \
-        test-libslang.bin               \
-        test-libunwind.bin              \
-        test-libunwind-debug-frame.bin  \
-        test-pthread-attr-setaffinity-np.bin    \
-        test-stackprotector-all.bin     \
-        test-timerfd.bin                \
-        test-libdw-dwarf-unwind.bin     \
-        test-compile-32.bin             \
-        test-compile-x32.bin            \
-        test-zlib.bin
-
-CC := $(CROSS_COMPILE)gcc -MD
-PKG_CONFIG := $(CROSS_COMPILE)pkg-config
-
-all: $(FILES)
-
-BUILD = $(CC) $(CFLAGS) -o $(OUTPUT)$@ $(patsubst %.bin,%.c,$@) $(LDFLAGS)
-
-###############################
-
-test-all.bin:
-        $(BUILD) -Werror -fstack-protector-all -O2 -Werror -D_FORTIFY_SOURCE=2 -ldw -lelf -lnuma -lelf -laudit -I/usr/include/slang -lslang $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null) $(FLAGS_PERL_EMBED) $(FLAGS_PYTHON_EMBED) -DPACKAGE='"perf"' -lbfd -ldl -lz
-
-test-hello.bin:
-        $(BUILD)
-
-test-pthread-attr-setaffinity-np.bin:
-        $(BUILD) -D_GNU_SOURCE -Werror -lpthread
-
-test-stackprotector-all.bin:
-        $(BUILD) -Werror -fstack-protector-all
-
-test-fortify-source.bin:
-        $(BUILD) -O2 -Werror -D_FORTIFY_SOURCE=2
-
-test-bionic.bin:
-        $(BUILD)
-
-test-libelf.bin:
-        $(BUILD) -lelf
-
-test-glibc.bin:
-        $(BUILD)
-
-test-dwarf.bin:
-        $(BUILD) -ldw
-
-test-libelf-mmap.bin:
-        $(BUILD) -lelf
-
-test-libelf-getphdrnum.bin:
-        $(BUILD) -lelf
-
-test-libnuma.bin:
-        $(BUILD) -lnuma
-
-test-libunwind.bin:
-        $(BUILD) -lelf
-
-test-libunwind-debug-frame.bin:
-        $(BUILD) -lelf
-
-test-libaudit.bin:
-        $(BUILD) -laudit
-
-test-libslang.bin:
-        $(BUILD) -I/usr/include/slang -lslang
-
-test-gtk2.bin:
-        $(BUILD) $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null)
-
-test-gtk2-infobar.bin:
-        $(BUILD) $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null)
-
-grep-libs  = $(filter -l%,$(1))
-strip-libs = $(filter-out -l%,$(1))
-
-PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)
-PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))
-PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))
-PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
-FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
-
-test-libperl.bin:
-        $(BUILD) $(FLAGS_PERL_EMBED)
-
-test-libpython.bin:
-        $(BUILD)
-
-test-libpython-version.bin:
-        $(BUILD)
-
-test-libbfd.bin:
-        $(BUILD) -DPACKAGE='"perf"' -lbfd -lz -liberty -ldl
-
-test-liberty.bin:
-        $(CC) -o $(OUTPUT)$@ test-libbfd.c -DPACKAGE='"perf"' -lbfd -ldl -liberty
-
-test-liberty-z.bin:
-        $(CC) -o $(OUTPUT)$@ test-libbfd.c -DPACKAGE='"perf"' -lbfd -ldl -liberty -lz
-
-test-cplus-demangle.bin:
-        $(BUILD) -liberty
-
-test-backtrace.bin:
-        $(BUILD)
-
-test-timerfd.bin:
-        $(BUILD)
-
-test-libdw-dwarf-unwind.bin:
-        $(BUILD)
-
-test-sync-compare-and-swap.bin:
-        $(BUILD) -Werror
-
-test-compile-32.bin:
-        $(CC) -m32 -o $(OUTPUT)$@ test-compile.c
-
-test-compile-x32.bin:
-        $(CC) -mx32 -o $(OUTPUT)$@ test-compile.c
-
-test-zlib.bin:
-        $(BUILD) -lz
-
--include *.d
-
-###############################
-
-clean:
-        rm -f $(FILES) *.d
diff --git a/tools/perf/config/feature-checks/test-all.c b/tools/perf/config/feature-checks/test-all.c
deleted file mode 100644
index 6d4d09323922..000000000000
--- a/tools/perf/config/feature-checks/test-all.c
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * test-all.c: Try to build all the main testcases at once.
- *
- * A well-configured system will have all the prereqs installed, so we can speed
- * up auto-detection on such systems.
- */
-
-/*
- * Quirk: Python and Perl headers cannot be in arbitrary places, so keep
- * these 3 testcases at the top:
- */
-#define main main_test_libpython
-# include "test-libpython.c"
-#undef main
-
-#define main main_test_libpython_version
-# include "test-libpython-version.c"
-#undef main
-
-#define main main_test_libperl
-# include "test-libperl.c"
-#undef main
-
-#define main main_test_hello
-# include "test-hello.c"
-#undef main
-
-#define main main_test_libelf
-# include "test-libelf.c"
-#undef main
-
-#define main main_test_libelf_mmap
-# include "test-libelf-mmap.c"
-#undef main
-
-#define main main_test_glibc
-# include "test-glibc.c"
-#undef main
-
-#define main main_test_dwarf
-# include "test-dwarf.c"
-#undef main
-
-#define main main_test_libelf_getphdrnum
-# include "test-libelf-getphdrnum.c"
-#undef main
-
-#define main main_test_libunwind
-# include "test-libunwind.c"
-#undef main
-
-#define main main_test_libaudit
-# include "test-libaudit.c"
-#undef main
-
-#define main main_test_libslang
-# include "test-libslang.c"
-#undef main
-
-#define main main_test_gtk2
-# include "test-gtk2.c"
-#undef main
-
-#define main main_test_gtk2_infobar
-# include "test-gtk2-infobar.c"
-#undef main
-
-#define main main_test_libbfd
-# include "test-libbfd.c"
-#undef main
-
-#define main main_test_backtrace
-# include "test-backtrace.c"
-#undef main
-
-#define main main_test_libnuma
-# include "test-libnuma.c"
-#undef main
-
-#define main main_test_timerfd
-# include "test-timerfd.c"
-#undef main
-
-#define main main_test_stackprotector_all
-# include "test-stackprotector-all.c"
-#undef main
-
-#define main main_test_libdw_dwarf_unwind
-# include "test-libdw-dwarf-unwind.c"
-#undef main
-
-#define main main_test_sync_compare_and_swap
-# include "test-sync-compare-and-swap.c"
-#undef main
-
-#define main main_test_zlib
-# include "test-zlib.c"
-#undef main
-
-#define main main_test_pthread_attr_setaffinity_np
-# include "test-pthread_attr_setaffinity_np.c"
-#undef main
-
-int main(int argc, char *argv[])
-{
-        main_test_libpython();
-        main_test_libpython_version();
-        main_test_libperl();
-        main_test_hello();
-        main_test_libelf();
-        main_test_libelf_mmap();
-        main_test_glibc();
-        main_test_dwarf();
-        main_test_libelf_getphdrnum();
-        main_test_libunwind();
-        main_test_libaudit();
-        main_test_libslang();
-        main_test_gtk2(argc, argv);
-        main_test_gtk2_infobar(argc, argv);
-        main_test_libbfd();
-        main_test_backtrace();
-        main_test_libnuma();
-        main_test_timerfd();
-        main_test_stackprotector_all();
-        main_test_libdw_dwarf_unwind();
-        main_test_sync_compare_and_swap(argc, argv);
-        main_test_zlib();
-        main_test_pthread_attr_setaffinity_np();
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-backtrace.c b/tools/perf/config/feature-checks/test-backtrace.c
deleted file mode 100644
index 7124aa1dc8fb..000000000000
--- a/tools/perf/config/feature-checks/test-backtrace.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <execinfo.h>
-#include <stdio.h>
-
-int main(void)
-{
-        void *backtrace_fns[10];
-        size_t entries;
-
-        entries = backtrace(backtrace_fns, 10);
-        backtrace_symbols_fd(backtrace_fns, entries, 1);
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-bionic.c b/tools/perf/config/feature-checks/test-bionic.c
deleted file mode 100644
index eac24e9513eb..000000000000
--- a/tools/perf/config/feature-checks/test-bionic.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <android/api-level.h>
-
-int main(void)
-{
-        return __ANDROID_API__;
-}
diff --git a/tools/perf/config/feature-checks/test-compile.c b/tools/perf/config/feature-checks/test-compile.c
deleted file mode 100644
index 31dbf45bf99c..000000000000
--- a/tools/perf/config/feature-checks/test-compile.c
+++ /dev/null
@@ -1,4 +0,0 @@
-int main(void)
-{
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-cplus-demangle.c b/tools/perf/config/feature-checks/test-cplus-demangle.c
deleted file mode 100644
index 610c686e0009..000000000000
--- a/tools/perf/config/feature-checks/test-cplus-demangle.c
+++ /dev/null
@@ -1,14 +0,0 @@
-extern int printf(const char *format, ...);
-extern char *cplus_demangle(const char *, int);
-
-int main(void)
-{
-        char symbol[4096] = "FieldName__9ClassNameFd";
-        char *tmp;
-
-        tmp = cplus_demangle(symbol, 0);
-
-        printf("demangled symbol: {%s}\n", tmp);
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-dwarf.c b/tools/perf/config/feature-checks/test-dwarf.c
deleted file mode 100644
index 3fc1801ce4a9..000000000000
--- a/tools/perf/config/feature-checks/test-dwarf.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <dwarf.h>
-#include <elfutils/libdw.h>
-#include <elfutils/version.h>
-
-int main(void)
-{
-        Dwarf *dbg = dwarf_begin(0, DWARF_C_READ);
-
-        return (long)dbg;
-}
diff --git a/tools/perf/config/feature-checks/test-fortify-source.c b/tools/perf/config/feature-checks/test-fortify-source.c
deleted file mode 100644
index c9f398d87868..000000000000
--- a/tools/perf/config/feature-checks/test-fortify-source.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main(void)
-{
-        return puts("hi");
-}
diff --git a/tools/perf/config/feature-checks/test-glibc.c b/tools/perf/config/feature-checks/test-glibc.c
deleted file mode 100644
index b0820345cd98..000000000000
--- a/tools/perf/config/feature-checks/test-glibc.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <gnu/libc-version.h>
-
-int main(void)
-{
-        const char *version = gnu_get_libc_version();
-
-        return (long)version;
-}
diff --git a/tools/perf/config/feature-checks/test-gtk2-infobar.c b/tools/perf/config/feature-checks/test-gtk2-infobar.c
deleted file mode 100644
index 397b4646d066..000000000000
--- a/tools/perf/config/feature-checks/test-gtk2-infobar.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma GCC diagnostic ignored "-Wstrict-prototypes"
-#include <gtk/gtk.h>
-#pragma GCC diagnostic error "-Wstrict-prototypes"
-
-int main(int argc, char *argv[])
-{
-        gtk_init(&argc, &argv);
-        gtk_info_bar_new();
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-gtk2.c b/tools/perf/config/feature-checks/test-gtk2.c
deleted file mode 100644
index 6bd80e509439..000000000000
--- a/tools/perf/config/feature-checks/test-gtk2.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma GCC diagnostic ignored "-Wstrict-prototypes"
-#include <gtk/gtk.h>
-#pragma GCC diagnostic error "-Wstrict-prototypes"
-
-int main(int argc, char *argv[])
-{
-        gtk_init(&argc, &argv);
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-hello.c b/tools/perf/config/feature-checks/test-hello.c
deleted file mode 100644
index c9f398d87868..000000000000
--- a/tools/perf/config/feature-checks/test-hello.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main(void)
-{
-        return puts("hi");
-}
diff --git a/tools/perf/config/feature-checks/test-libaudit.c b/tools/perf/config/feature-checks/test-libaudit.c
deleted file mode 100644
index afc019f08641..000000000000
--- a/tools/perf/config/feature-checks/test-libaudit.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <libaudit.h>
-
-extern int printf(const char *format, ...);
-
-int main(void)
-{
-        printf("error message: %s\n", audit_errno_to_name(0));
-
-        return audit_open();
-}
diff --git a/tools/perf/config/feature-checks/test-libbfd.c b/tools/perf/config/feature-checks/test-libbfd.c
deleted file mode 100644
index 24059907e990..000000000000
--- a/tools/perf/config/feature-checks/test-libbfd.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <bfd.h>
-
-extern int printf(const char *format, ...);
-
-int main(void)
-{
-        char symbol[4096] = "FieldName__9ClassNameFd";
-        char *tmp;
-
-        tmp = bfd_demangle(0, symbol, 0);
-
-        printf("demangled symbol: {%s}\n", tmp);
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libdw-dwarf-unwind.c b/tools/perf/config/feature-checks/test-libdw-dwarf-unwind.c
deleted file mode 100644
index f676a3ff442a..000000000000
--- a/tools/perf/config/feature-checks/test-libdw-dwarf-unwind.c
+++ /dev/null
@@ -1,13 +0,0 @@
-
-#include <elfutils/libdwfl.h>
-
-int main(void)
-{
-        /*
-         * This function is guarded via: __nonnull_attribute__ (1, 2).
-         * Passing '1' as arguments value. This code is never executed,
-         * only compiled.
-         */
-        dwfl_thread_getframes((void *) 1, (void *) 1, NULL);
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libelf-getphdrnum.c b/tools/perf/config/feature-checks/test-libelf-getphdrnum.c
deleted file mode 100644
index d710459306c3..000000000000
--- a/tools/perf/config/feature-checks/test-libelf-getphdrnum.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <libelf.h>
-
-int main(void)
-{
-        size_t dst;
-
-        return elf_getphdrnum(0, &dst);
-}
diff --git a/tools/perf/config/feature-checks/test-libelf-mmap.c b/tools/perf/config/feature-checks/test-libelf-mmap.c
deleted file mode 100644
index 564427d7ef18..000000000000
--- a/tools/perf/config/feature-checks/test-libelf-mmap.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <libelf.h>
-
-int main(void)
-{
-        Elf *elf = elf_begin(0, ELF_C_READ_MMAP, 0);
-
-        return (long)elf;
-}
diff --git a/tools/perf/config/feature-checks/test-libelf.c b/tools/perf/config/feature-checks/test-libelf.c
deleted file mode 100644
index 08db322d8957..000000000000
--- a/tools/perf/config/feature-checks/test-libelf.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <libelf.h>
-
-int main(void)
-{
-        Elf *elf = elf_begin(0, ELF_C_READ, 0);
-
-        return (long)elf;
-}
diff --git a/tools/perf/config/feature-checks/test-libnuma.c b/tools/perf/config/feature-checks/test-libnuma.c
deleted file mode 100644
index 4763d9cd587d..000000000000
--- a/tools/perf/config/feature-checks/test-libnuma.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <numa.h>
-#include <numaif.h>
-
-int main(void)
-{
-        numa_available();
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libperl.c b/tools/perf/config/feature-checks/test-libperl.c
deleted file mode 100644
index 8871f6a0fdb4..000000000000
--- a/tools/perf/config/feature-checks/test-libperl.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <EXTERN.h>
-#include <perl.h>
-
-int main(void)
-{
-        perl_alloc();
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libpython-version.c b/tools/perf/config/feature-checks/test-libpython-version.c
deleted file mode 100644
index facea122d812..000000000000
--- a/tools/perf/config/feature-checks/test-libpython-version.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <Python.h>
-
-#if PY_VERSION_HEX >= 0x03000000
-        #error
-#endif
-
-int main(void)
-{
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libpython.c b/tools/perf/config/feature-checks/test-libpython.c
deleted file mode 100644
index b24b28ad6324..000000000000
--- a/tools/perf/config/feature-checks/test-libpython.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <Python.h>
-
-int main(void)
-{
-        Py_Initialize();
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libslang.c b/tools/perf/config/feature-checks/test-libslang.c
deleted file mode 100644
index 22ff22ed94d1..000000000000
--- a/tools/perf/config/feature-checks/test-libslang.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <slang.h>
-
-int main(void)
-{
-        return SLsmg_init_smg();
-}
diff --git a/tools/perf/config/feature-checks/test-libunwind-debug-frame.c b/tools/perf/config/feature-checks/test-libunwind-debug-frame.c
deleted file mode 100644
index 0ef8087a104a..000000000000
--- a/tools/perf/config/feature-checks/test-libunwind-debug-frame.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <libunwind.h>
-#include <stdlib.h>
-
-extern int
-UNW_OBJ(dwarf_find_debug_frame) (int found, unw_dyn_info_t *di_debug,
-                                 unw_word_t ip, unw_word_t segbase,
-                                 const char *obj_name, unw_word_t start,
-                                 unw_word_t end);
-
-#define dwarf_find_debug_frame UNW_OBJ(dwarf_find_debug_frame)
-
-int main(void)
-{
-        dwarf_find_debug_frame(0, NULL, 0, 0, NULL, 0, 0);
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-libunwind.c b/tools/perf/config/feature-checks/test-libunwind.c
deleted file mode 100644
index 43b9369bcab7..000000000000
--- a/tools/perf/config/feature-checks/test-libunwind.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <libunwind.h>
-#include <stdlib.h>
-
-extern int UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
-                                      unw_word_t ip,
-                                      unw_dyn_info_t *di,
-                                      unw_proc_info_t *pi,
-                                      int need_unwind_info, void *arg);
-
-
-#define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table)
-
-static unw_accessors_t accessors;
-
-int main(void)
-{
-        unw_addr_space_t addr_space;
-
-        addr_space = unw_create_addr_space(&accessors, 0);
-        if (addr_space)
-                return 0;
-
-        unw_init_remote(NULL, addr_space, NULL);
-        dwarf_search_unwind_table(addr_space, 0, NULL, NULL, 0, NULL);
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c b/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c
deleted file mode 100644
index 2b81b72eca23..000000000000
--- a/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <stdint.h>
-#include <pthread.h>
-
-int main(void)
-{
-        int ret = 0;
-        pthread_attr_t thread_attr;
-        cpu_set_t cs;
-
-        pthread_attr_init(&thread_attr);
-        /* don't care abt exact args, just the API itself in libpthread */
-        ret = pthread_attr_setaffinity_np(&thread_attr, sizeof(cs), &cs);
-
-        return ret;
-}
diff --git a/tools/perf/config/feature-checks/test-stackprotector-all.c b/tools/perf/config/feature-checks/test-stackprotector-all.c
deleted file mode 100644
index c9f398d87868..000000000000
--- a/tools/perf/config/feature-checks/test-stackprotector-all.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main(void)
-{
-        return puts("hi");
-}
diff --git a/tools/perf/config/feature-checks/test-sync-compare-and-swap.c b/tools/perf/config/feature-checks/test-sync-compare-and-swap.c
deleted file mode 100644
index c34d4ca4af56..000000000000
--- a/tools/perf/config/feature-checks/test-sync-compare-and-swap.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include <stdint.h>
-
-volatile uint64_t x;
-
-int main(int argc, char *argv[])
-{
-        uint64_t old, new = argc;
-
-        argv = argv;
-        do {
-                old = __sync_val_compare_and_swap(&x, 0, 0);
-        } while (!__sync_bool_compare_and_swap(&x, old, new));
-        return old == new;
-}
diff --git a/tools/perf/config/feature-checks/test-timerfd.c b/tools/perf/config/feature-checks/test-timerfd.c
deleted file mode 100644
index 8c5c083b4d3c..000000000000
--- a/tools/perf/config/feature-checks/test-timerfd.c
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- * test for timerfd functions used by perf-kvm-stat-live
- */
-#include <sys/timerfd.h>
-
-int main(void)
-{
-        struct itimerspec new_value;
-
-        int fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
-        if (fd < 0)
-                return 1;
-
-        if (timerfd_settime(fd, 0, &new_value, NULL) != 0)
-                return 1;
-
-        return 0;
-}
diff --git a/tools/perf/config/feature-checks/test-zlib.c b/tools/perf/config/feature-checks/test-zlib.c
deleted file mode 100644
index e111fff6240e..000000000000
--- a/tools/perf/config/feature-checks/test-zlib.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <zlib.h>
-
-int main(void)
-{
-        z_stream zs;
-
-        inflateInit(&zs);
-        return 0;
-}
diff --git a/tools/perf/config/utilities.mak b/tools/perf/config/utilities.mak
index 7076a62d0ff7..c16ce833079c 100644
--- a/tools/perf/config/utilities.mak
+++ b/tools/perf/config/utilities.mak
@@ -175,6 +175,5 @@ _ge-abspath = $(if $(is-executable),$(1))
 define get-executable-or-default
 $(if $($(1)),$(call _ge_attempt,$($(1)),$(1)),$(call _ge_attempt,$(2)))
 endef
-_ge_attempt = $(if $(get-executable),$(get-executable),$(_gea_warn)$(call _gea_err,$(2)))
-_gea_warn = $(warning The path '$(1)' is not executable.)
+_ge_attempt = $(if $(get-executable),$(get-executable),$(call _gea_err,$(2)))
 _gea_err  = $(if $(1),$(error Please set '$(1)' appropriately))
diff --git a/tools/perf/perf-completion.sh b/tools/perf/perf-completion.sh
index 33569847fdcc..3ba80b2359cc 100644
--- a/tools/perf/perf-completion.sh
+++ b/tools/perf/perf-completion.sh
@@ -47,8 +47,16 @@ __my_reassemble_comp_words_by_ref()
         done
 }
 
-type _get_comp_words_by_ref &>/dev/null ||
-_get_comp_words_by_ref()
+# Define preload_get_comp_words_by_ref="false", if the function
+# __perf_get_comp_words_by_ref() is required instead.
+preload_get_comp_words_by_ref="true"
+
+if [ $preload_get_comp_words_by_ref = "true" ]; then
+        type _get_comp_words_by_ref &>/dev/null ||
+        preload_get_comp_words_by_ref="false"
+fi
+[ $preload_get_comp_words_by_ref = "true" ] ||
+__perf_get_comp_words_by_ref()
 {
         local exclude cur_ words_ cword_
         if [ "$1" = "-n" ]; then
@@ -76,8 +84,16 @@ _get_comp_words_by_ref()
         done
 }
 
-type __ltrim_colon_completions &>/dev/null ||
-__ltrim_colon_completions()
+# Define preload__ltrim_colon_completions="false", if the function
+# __perf__ltrim_colon_completions() is required instead.
+preload__ltrim_colon_completions="true"
+
+if [ $preload__ltrim_colon_completions = "true" ]; then
+        type __ltrim_colon_completions &>/dev/null ||
+        preload__ltrim_colon_completions="false"
+fi
+[ $preload__ltrim_colon_completions = "true" ] ||
+__perf__ltrim_colon_completions()
 {
         if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
                 # Remove colon-word prefix from COMPREPLY items
@@ -97,7 +113,32 @@ __perfcomp ()
 __perfcomp_colon ()
 {
         __perfcomp "$1" "$2"
-        __ltrim_colon_completions $cur
+        if [ $preload__ltrim_colon_completions = "true" ]; then
+                __ltrim_colon_completions $cur
+        else
+                __perf__ltrim_colon_completions $cur
+        fi
+}
+
+__perf_prev_skip_opts ()
+{
+        local i cmd_ cmds_
+
+        let i=cword-1
+        cmds_=$($cmd $1 --list-cmds)
+        prev_skip_opts=()
+        while [ $i -ge 0 ]; do
+                if [[ ${words[i]} == $1 ]]; then
+                        return
+                fi
+                for cmd_ in $cmds_; do
+                        if [[ ${words[i]} == $cmd_ ]]; then
+                                prev_skip_opts=${words[i]}
+                                return
+                        fi
+                done
+                ((i--))
+        done
 }
 
 __perf_main ()
@@ -107,29 +148,36 @@ __perf_main ()
         cmd=${words[0]}
         COMPREPLY=()
 
+        # Skip options backward and find the last perf command
+        __perf_prev_skip_opts
         # List perf subcommands or long options
-        if [ $cword -eq 1 ]; then
+        if [ -z $prev_skip_opts ]; then
                 if [[ $cur == --* ]]; then
-                        __perfcomp '--help --version \
-                        --exec-path --html-path --paginate --no-pager \
-                        --perf-dir --work-tree --debugfs-dir' -- "$cur"
+                        cmds=$($cmd --list-opts)
                 else
                         cmds=$($cmd --list-cmds)
-                        __perfcomp "$cmds" "$cur"
                 fi
+                __perfcomp "$cmds" "$cur"
         # List possible events for -e option
-        elif [[ $prev == "-e" && "${words[1]}" == @(record|stat|top) ]]; then
+        elif [[ $prev == @("-e"|"--event") &&
+                $prev_skip_opts == @(record|stat|top) ]]; then
                 evts=$($cmd list --raw-dump)
                 __perfcomp_colon "$evts" "$cur"
-        # List subcommands for perf commands
-        elif [[ $prev == @(kvm|kmem|mem|lock|sched) ]]; then
-                subcmds=$($cmd $prev --list-cmds)
-                __perfcomp_colon "$subcmds" "$cur"
-        # List long option names
-        elif [[ $cur == --* ]];  then
-                subcmd=${words[1]}
-                opts=$($cmd $subcmd --list-opts)
-                __perfcomp "$opts" "$cur"
+        else
+                # List subcommands for perf commands
+                if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
+                        |data|help|script|test|timechart|trace) ]]; then
+                        subcmds=$($cmd $prev_skip_opts --list-cmds)
+                        __perfcomp_colon "$subcmds" "$cur"
+                fi
+                # List long option names
+                if [[ $cur == --* ]];  then
+                        subcmd=$prev_skip_opts
+                        __perf_prev_skip_opts $subcmd
+                        subcmd=$subcmd" "$prev_skip_opts
+                        opts=$($cmd $subcmd --list-opts)
+                        __perfcomp "$opts" "$cur"
+                fi
         fi
 }
 
@@ -198,7 +246,11 @@ type perf &>/dev/null &&
 _perf()
 {
         local cur words cword prev
-        _get_comp_words_by_ref -n =: cur words cword prev
+        if [ $preload_get_comp_words_by_ref = "true" ]; then
+                _get_comp_words_by_ref -n =: cur words cword prev
+        else
+                __perf_get_comp_words_by_ref -n =: cur words cword prev
+        fi
         __perf_main
 } &&
 
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 3700a7faca6c..b857fcbd00cf 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -13,6 +13,7 @@
 #include "util/quote.h"
 #include "util/run-command.h"
 #include "util/parse-events.h"
+#include "util/parse-options.h"
 #include "util/debug.h"
 #include <api/fs/debugfs.h>
 #include <pthread.h>
@@ -62,6 +63,7 @@ static struct cmd_struct commands[] = {
 #endif
         { "inject",     cmd_inject,     0 },
         { "mem",        cmd_mem,        0 },
+        { "data",       cmd_data,       0 },
 };
 
 struct pager_config {
@@ -124,6 +126,23 @@ static void commit_pager_choice(void)
         }
 }
 
+struct option options[] = {
+        OPT_ARGUMENT("help", "help"),
+        OPT_ARGUMENT("version", "version"),
+        OPT_ARGUMENT("exec-path", "exec-path"),
+        OPT_ARGUMENT("html-path", "html-path"),
+        OPT_ARGUMENT("paginate", "paginate"),
+        OPT_ARGUMENT("no-pager", "no-pager"),
+        OPT_ARGUMENT("perf-dir", "perf-dir"),
+        OPT_ARGUMENT("work-tree", "work-tree"),
+        OPT_ARGUMENT("debugfs-dir", "debugfs-dir"),
+        OPT_ARGUMENT("buildid-dir", "buildid-dir"),
+        OPT_ARGUMENT("list-cmds", "list-cmds"),
+        OPT_ARGUMENT("list-opts", "list-opts"),
+        OPT_ARGUMENT("debug", "debug"),
+        OPT_END()
+};
+
 static int handle_options(const char ***argv, int *argc, int *envchanged)
 {
         int handled = 0;
@@ -222,6 +241,16 @@ static int handle_options(const char ***argv, int *argc, int *envchanged)
                                 struct cmd_struct *p = commands+i;
                                 printf("%s ", p->cmd);
                         }
+                        putchar('\n');
+                        exit(0);
+                } else if (!strcmp(cmd, "--list-opts")) {
+                        unsigned int i;
+
+                        for (i = 0; i < ARRAY_SIZE(options)-1; i++) {
+                                struct option *p = options+i;
+                                printf("--%s ", p->long_name);
+                        }
+                        putchar('\n');
                         exit(0);
                 } else if (!strcmp(cmd, "--debug")) {
                         if (*argc < 2) {
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 1dabb8553499..e14bb637255c 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -29,7 +29,7 @@ static inline unsigned long long rdclock(void)
         return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
 }
 
-#define MAX_NR_CPUS                     256
+#define MAX_NR_CPUS                     1024
 
 extern const char *input_name;
 extern bool perf_host, perf_guest;
@@ -53,6 +53,7 @@ struct record_opts {
         bool         sample_time;
         bool         period;
         bool         sample_intr_regs;
+        bool         running_time;
         unsigned int freq;
         unsigned int mmap_pages;
         unsigned int user_freq;
@@ -61,6 +62,8 @@ struct record_opts {
         u64          user_interval;
         bool         sample_transaction;
         unsigned     initial_delay;
+        bool         use_clockid;
+        clockid_t    clockid;
 };
 
 struct option;
diff --git a/tools/perf/scripts/Build b/tools/perf/scripts/Build
new file mode 100644
index 000000000000..41efd7e368b3
--- /dev/null
+++ b/tools/perf/scripts/Build
@@ -0,0 +1,2 @@
+libperf-$(CONFIG_LIBPERL)   += perl/Perf-Trace-Util/
+libperf-$(CONFIG_LIBPYTHON) += python/Perf-Trace-Util/
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Build b/tools/perf/scripts/perl/Perf-Trace-Util/Build
new file mode 100644
index 000000000000..928e110179cb
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Build
@@ -0,0 +1,3 @@
+libperf-y += Context.o
+
+CFLAGS_Context.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/Build b/tools/perf/scripts/python/Perf-Trace-Util/Build
new file mode 100644
index 000000000000..aefc15c9444a
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/Build
@@ -0,0 +1,3 @@
+libperf-y += Context.o
+
+CFLAGS_Context.o += $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
new file mode 100644
index 000000000000..6a8801b32017
--- /dev/null
+++ b/tools/perf/tests/Build
@@ -0,0 +1,43 @@
+perf-y += builtin-test.o
+perf-y += parse-events.o
+perf-y += dso-data.o
+perf-y += attr.o
+perf-y += vmlinux-kallsyms.o
+perf-y += open-syscall.o
+perf-y += open-syscall-all-cpus.o
+perf-y += open-syscall-tp-fields.o
+perf-y += mmap-basic.o
+perf-y += perf-record.o
+perf-y += rdpmc.o
+perf-y += evsel-roundtrip-name.o
+perf-y += evsel-tp-sched.o
+perf-y += fdarray.o
+perf-y += pmu.o
+perf-y += hists_common.o
+perf-y += hists_link.o
+perf-y += hists_filter.o
+perf-y += hists_output.o
+perf-y += hists_cumulate.o
+perf-y += python-use.o
+perf-y += bp_signal.o
+perf-y += bp_signal_overflow.o
+perf-y += task-exit.o
+perf-y += sw-clock.o
+perf-y += mmap-thread-lookup.o
+perf-y += thread-mg-share.o
+perf-y += switch-tracking.o
+perf-y += keep-tracking.o
+perf-y += code-reading.o
+perf-y += sample-parsing.o
+perf-y += parse-no-sample-id-all.o
+perf-y += kmod-path.o
+
+perf-$(CONFIG_X86) += perf-time-to-tsc.o
+
+ifeq ($(ARCH),$(filter $(ARCH),x86 arm))
+perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
+endif
+
+CFLAGS_attr.o         += -DBINDIR="BUILD_STR($(bindir_SQ))" -DPYTHON="BUILD_STR($(PYTHON_WORD))"
+CFLAGS_python-use.o   += -DPYTHONPATH="BUILD_STR($(OUTPUT)python)" -DPYTHON="BUILD_STR($(PYTHON_WORD))"
+CFLAGS_dwarf-unwind.o += -fno-optimize-sibling-calls
diff --git a/tools/perf/tests/attr/base-record b/tools/perf/tests/attr/base-record
index d3095dafed36..7e6d74946e04 100644
--- a/tools/perf/tests/attr/base-record
+++ b/tools/perf/tests/attr/base-record
@@ -5,7 +5,7 @@ group_fd=-1
 flags=0|8
 cpu=*
 type=0|1
-size=104
+size=112
 config=0
 sample_period=4000
 sample_type=263
diff --git a/tools/perf/tests/attr/base-stat b/tools/perf/tests/attr/base-stat
index 872ed7e24c7c..f4cf148f14cb 100644
--- a/tools/perf/tests/attr/base-stat
+++ b/tools/perf/tests/attr/base-stat
@@ -5,7 +5,7 @@ group_fd=-1
 flags=0|8
 cpu=*
 type=0
-size=104
+size=112
 config=0
 sample_period=0
 sample_type=0
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 4b7d9ab0f049..4f4098167112 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -167,6 +167,10 @@ static struct test {
                 .func = test__fdarray__add,
         },
         {
+                .desc = "Test kmod_path__parse function",
+                .func = test__kmod_path__parse,
+        },
+        {
                 .func = NULL,
         },
 };
@@ -291,7 +295,7 @@ static int perf_test__list(int argc, const char **argv)
 
 int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        const char * const test_usage[] = {
+        const char *test_usage[] = {
         "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
         NULL,
         };
@@ -302,13 +306,14 @@ int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
                     "be more verbose (show symbol address, etc)"),
         OPT_END()
         };
+        const char * const test_subcommands[] = { "list", NULL };
         struct intlist *skiplist = NULL;
         int ret = hists__init();
 
         if (ret < 0)
                 return ret;
 
-        argc = parse_options(argc, argv, test_options, test_usage, 0);
+        argc = parse_options_subcommand(argc, argv, test_options, test_subcommands, test_usage, 0);
         if (argc >= 1 && !strcmp(argv[0], "list"))
                 return perf_test__list(argc, argv);
 
diff --git a/tools/perf/tests/dso-data.c b/tools/perf/tests/dso-data.c
index caaf37f079b1..513e5febbe5a 100644
--- a/tools/perf/tests/dso-data.c
+++ b/tools/perf/tests/dso-data.c
@@ -112,6 +112,9 @@ int test__dso_data(void)
 
         dso = dso__new((const char *)file);
 
+        TEST_ASSERT_VAL("Failed to access to dso",
+                        dso__data_fd(dso, &machine) >= 0);
+
         /* Basic 10 bytes tests. */
         for (i = 0; i < ARRAY_SIZE(offsets); i++) {
                 struct test_data_offset *data = &offsets[i];
@@ -243,8 +246,8 @@ int test__dso_data_cache(void)
         limit = nr * 4;
         TEST_ASSERT_VAL("failed to set file limit", !set_fd_limit(limit));
 
-        /* and this is now our dso open FDs limit + 1 extra */
-        dso_cnt = limit / 2 + 1;
+        /* and this is now our dso open FDs limit */
+        dso_cnt = limit / 2;
         TEST_ASSERT_VAL("failed to create dsos\n",
                 !dsos__create(dso_cnt, TEST_FILE_SIZE));
 
@@ -252,13 +255,13 @@ int test__dso_data_cache(void)
                 struct dso *dso = dsos[i];
 
                 /*
-                 * Open dsos via dso__data_fd or dso__data_read_offset.
-                 * Both opens the data file and keep it open.
+                 * Open dsos via dso__data_fd(), it opens the data
+                 * file and keep it open (unless open file limit).
                  */
+                fd = dso__data_fd(dso, &machine);
+                TEST_ASSERT_VAL("failed to get fd", fd > 0);
+
                 if (i % 2) {
-                        fd = dso__data_fd(dso, &machine);
-                        TEST_ASSERT_VAL("failed to get fd", fd > 0);
-                } else {
                         #define BUFSIZE 10
                         u8 buf[BUFSIZE];
                         ssize_t n;
@@ -268,7 +271,10 @@ int test__dso_data_cache(void)
                 }
         }
 
-        /* open +1 dso over the allowed limit */
+        /* verify the first one is already open */
+        TEST_ASSERT_VAL("dsos[0] is not open", dsos[0]->data.fd != -1);
+
+        /* open +1 dso to reach the allowed limit */
         fd = dso__data_fd(dsos[i], &machine);
         TEST_ASSERT_VAL("failed to get fd", fd > 0);
 
diff --git a/tools/perf/tests/kmod-path.c b/tools/perf/tests/kmod-path.c
new file mode 100644
index 000000000000..e8d7cbb9320c
--- /dev/null
+++ b/tools/perf/tests/kmod-path.c
@@ -0,0 +1,73 @@
+#include <stdbool.h>
+#include "tests.h"
+#include "dso.h"
+#include "debug.h"
+
+static int test(const char *path, bool alloc_name, bool alloc_ext,
+                bool kmod, bool comp, const char *name, const char *ext)
+{
+        struct kmod_path m;
+
+        memset(&m, 0x0, sizeof(m));
+
+        TEST_ASSERT_VAL("kmod_path__parse",
+                        !__kmod_path__parse(&m, path, alloc_name, alloc_ext));
+
+        pr_debug("%s - alloc name %d, alloc ext %d, kmod %d, comp %d, name '%s', ext '%s'\n",
+                 path, alloc_name, alloc_ext, m.kmod, m.comp, m.name, m.ext);
+
+        TEST_ASSERT_VAL("wrong kmod", m.kmod == kmod);
+        TEST_ASSERT_VAL("wrong comp", m.comp == comp);
+
+        if (ext)
+                TEST_ASSERT_VAL("wrong ext", m.ext && !strcmp(ext, m.ext));
+        else
+                TEST_ASSERT_VAL("wrong ext", !m.ext);
+
+        if (name)
+                TEST_ASSERT_VAL("wrong name", m.name && !strcmp(name, m.name));
+        else
+                TEST_ASSERT_VAL("wrong name", !m.name);
+
+        free(m.name);
+        free(m.ext);
+        return 0;
+}
+
+#define T(path, an, ae, k, c, n, e) \
+        TEST_ASSERT_VAL("failed", !test(path, an, ae, k, c, n, e))
+
+int test__kmod_path__parse(void)
+{
+        /* path                alloc_name  alloc_ext   kmod  comp   name     ext */
+        T("/xxxx/xxxx/x-x.ko", true      , true      , true, false, "[x_x]", NULL);
+        T("/xxxx/xxxx/x-x.ko", false     , true      , true, false, NULL   , NULL);
+        T("/xxxx/xxxx/x-x.ko", true      , false     , true, false, "[x_x]", NULL);
+        T("/xxxx/xxxx/x-x.ko", false     , false     , true, false, NULL   , NULL);
+
+        /* path                alloc_name  alloc_ext   kmod  comp  name   ext */
+        T("/xxxx/xxxx/x.ko.gz", true     , true      , true, true, "[x]", "gz");
+        T("/xxxx/xxxx/x.ko.gz", false    , true      , true, true, NULL , "gz");
+        T("/xxxx/xxxx/x.ko.gz", true     , false     , true, true, "[x]", NULL);
+        T("/xxxx/xxxx/x.ko.gz", false    , false     , true, true, NULL , NULL);
+
+        /* path              alloc_name  alloc_ext  kmod   comp  name    ext */
+        T("/xxxx/xxxx/x.gz", true      , true     , false, true, "x.gz" ,"gz");
+        T("/xxxx/xxxx/x.gz", false     , true     , false, true, NULL   ,"gz");
+        T("/xxxx/xxxx/x.gz", true      , false    , false, true, "x.gz" , NULL);
+        T("/xxxx/xxxx/x.gz", false     , false    , false, true, NULL   , NULL);
+
+        /* path   alloc_name  alloc_ext  kmod   comp  name     ext */
+        T("x.gz", true      , true     , false, true, "x.gz", "gz");
+        T("x.gz", false     , true     , false, true, NULL  , "gz");
+        T("x.gz", true      , false    , false, true, "x.gz", NULL);
+        T("x.gz", false     , false    , false, true, NULL  , NULL);
+
+        /* path      alloc_name  alloc_ext  kmod  comp  name  ext */
+        T("x.ko.gz", true      , true     , true, true, "[x]", "gz");
+        T("x.ko.gz", false     , true     , true, true, NULL , "gz");
+        T("x.ko.gz", true      , false    , true, true, "[x]", NULL);
+        T("x.ko.gz", false     , false    , true, true, NULL , NULL);
+
+        return 0;
+}
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
index 75709d2b17b4..bff85324f799 100644
--- a/tools/perf/tests/make
+++ b/tools/perf/tests/make
@@ -5,7 +5,7 @@ include config/Makefile.arch
 
 # FIXME looks like x86 is the only arch running tests ;-)
 # we need some IS_(32/64) flag to make this generic
-ifeq ($(IS_X86_64),1)
+ifeq ($(ARCH)$(IS_64_BIT), x861)
 lib = lib64
 else
 lib = lib
diff --git a/tools/perf/tests/open-syscall-all-cpus.c b/tools/perf/tests/open-syscall-all-cpus.c
index 8fa82d1700c7..3ec885c48f8f 100644
--- a/tools/perf/tests/open-syscall-all-cpus.c
+++ b/tools/perf/tests/open-syscall-all-cpus.c
@@ -29,7 +29,12 @@ int test__open_syscall_event_on_all_cpus(void)
 
         evsel = perf_evsel__newtp("syscalls", "sys_enter_open");
         if (evsel == NULL) {
-                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                if (tracefs_configured())
+                        pr_debug("is tracefs mounted on /sys/kernel/tracing?\n");
+                else if (debugfs_configured())
+                        pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                else
+                        pr_debug("Neither tracefs or debugfs is enabled in this kernel\n");
                 goto out_thread_map_delete;
         }
 
diff --git a/tools/perf/tests/open-syscall.c b/tools/perf/tests/open-syscall.c
index a33b2daae40f..07aa319bf334 100644
--- a/tools/perf/tests/open-syscall.c
+++ b/tools/perf/tests/open-syscall.c
@@ -18,7 +18,12 @@ int test__open_syscall_event(void)
 
         evsel = perf_evsel__newtp("syscalls", "sys_enter_open");
         if (evsel == NULL) {
-                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                if (tracefs_configured())
+                        pr_debug("is tracefs mounted on /sys/kernel/tracing?\n");
+                else if (debugfs_configured())
+                        pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                else
+                        pr_debug("Neither tracefs or debugfs is enabled in this kernel\n");
                 goto out_thread_map_delete;
         }
 
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 1cdab0ce00e2..3de744961739 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -3,6 +3,7 @@
 #include "evsel.h"
 #include "evlist.h"
 #include <api/fs/fs.h>
+#include <api/fs/tracefs.h>
 #include <api/fs/debugfs.h>
 #include "tests.h"
 #include "debug.h"
@@ -294,6 +295,36 @@ static int test__checkevent_genhw_modifier(struct perf_evlist *evlist)
         return test__checkevent_genhw(evlist);
 }
 
+static int test__checkevent_exclude_idle_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+
+        TEST_ASSERT_VAL("wrong exclude idle", evsel->attr.exclude_idle);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
+static int test__checkevent_exclude_idle_modifier_1(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+
+        TEST_ASSERT_VAL("wrong exclude idle", evsel->attr.exclude_idle);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
 static int test__checkevent_breakpoint_modifier(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel = perf_evlist__first(evlist);
@@ -1192,11 +1223,19 @@ static int count_tracepoints(void)
 {
         char events_path[PATH_MAX];
         struct dirent *events_ent;
+        const char *mountpoint;
         DIR *events_dir;
         int cnt = 0;
 
-        scnprintf(events_path, PATH_MAX, "%s/tracing/events",
-                  debugfs_find_mountpoint());
+        mountpoint = tracefs_find_mountpoint();
+        if (mountpoint) {
+                scnprintf(events_path, PATH_MAX, "%s/events",
+                          mountpoint);
+        } else {
+                mountpoint = debugfs_find_mountpoint();
+                scnprintf(events_path, PATH_MAX, "%s/tracing/events",
+                          mountpoint);
+        }
 
         events_dir = opendir(events_path);
 
@@ -1485,6 +1524,16 @@ static struct evlist_test test__events[] = {
                 .id    = 100,
         },
 #endif
+        {
+                .name  = "instructions:I",
+                .check = test__checkevent_exclude_idle_modifier,
+                .id    = 45,
+        },
+        {
+                .name  = "instructions:kIG",
+                .check = test__checkevent_exclude_idle_modifier_1,
+                .id    = 46,
+        },
 };
 
 static struct evlist_test test__events_pmu[] = {
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 00e776a87a9c..52758a33f64c 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -51,6 +51,7 @@ int test__hists_cumulate(void);
 int test__switch_tracking(void);
 int test__fdarray__filter(void);
 int test__fdarray__add(void);
+int test__kmod_path__parse(void);
 
 #if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/ui/Build b/tools/perf/ui/Build
new file mode 100644
index 000000000000..0a73538c0441
--- /dev/null
+++ b/tools/perf/ui/Build
@@ -0,0 +1,14 @@
+libperf-y += setup.o
+libperf-y += helpline.o
+libperf-y += progress.o
+libperf-y += util.o
+libperf-y += hist.o
+libperf-y += stdio/hist.o
+
+CFLAGS_setup.o += -DLIBDIR="BUILD_STR($(LIBDIR))"
+
+libperf-$(CONFIG_SLANG) += browser.o
+libperf-$(CONFIG_SLANG) += browsers/
+libperf-$(CONFIG_SLANG) += tui/
+
+CFLAGS_browser.o += -DENABLE_SLFUTURE_CONST
diff --git a/tools/perf/ui/browsers/Build b/tools/perf/ui/browsers/Build
new file mode 100644
index 000000000000..de223f5bed58
--- /dev/null
+++ b/tools/perf/ui/browsers/Build
@@ -0,0 +1,10 @@
+libperf-y += annotate.o
+libperf-y += hists.o
+libperf-y += map.o
+libperf-y += scripts.o
+libperf-y += header.o
+
+CFLAGS_annotate.o += -DENABLE_SLFUTURE_CONST
+CFLAGS_hists.o    += -DENABLE_SLFUTURE_CONST
+CFLAGS_map.o      += -DENABLE_SLFUTURE_CONST
+CFLAGS_scripts.o  += -DENABLE_SLFUTURE_CONST
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index 9d32e3c0cfee..e5250eb2dd57 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -829,10 +829,16 @@ out:
         return key;
 }
 
+int map_symbol__tui_annotate(struct map_symbol *ms, struct perf_evsel *evsel,
+                             struct hist_browser_timer *hbt)
+{
+        return symbol__tui_annotate(ms->sym, ms->map, evsel, hbt);
+}
+
 int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
                              struct hist_browser_timer *hbt)
 {
-        return symbol__tui_annotate(he->ms.sym, he->ms.map, evsel, hbt);
+        return map_symbol__tui_annotate(&he->ms, evsel, hbt);
 }
 
 static void annotate_browser__mark_jump_targets(struct annotate_browser *browser,
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 788506eef567..995b7a8596b1 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -48,6 +48,24 @@ static bool hist_browser__has_filter(struct hist_browser *hb)
         return hists__has_filter(hb->hists) || hb->min_pcnt;
 }
 
+static int hist_browser__get_folding(struct hist_browser *browser)
+{
+        struct rb_node *nd;
+        struct hists *hists = browser->hists;
+        int unfolded_rows = 0;
+
+        for (nd = rb_first(&hists->entries);
+             (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
+             nd = rb_next(nd)) {
+                struct hist_entry *he =
+                        rb_entry(nd, struct hist_entry, rb_node);
+
+                if (he->ms.unfolded)
+                        unfolded_rows += he->nr_rows;
+        }
+        return unfolded_rows;
+}
+
 static u32 hist_browser__nr_entries(struct hist_browser *hb)
 {
         u32 nr_entries;
@@ -57,6 +75,7 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb)
         else
                 nr_entries = hb->hists->nr_entries;
 
+        hb->nr_callchain_rows = hist_browser__get_folding(hb);
         return nr_entries + hb->nr_callchain_rows;
 }
 
@@ -492,6 +511,7 @@ static void hist_browser__show_callchain_entry(struct hist_browser *browser,
 {
         int color, width;
         char folded_sign = callchain_list__folded(chain);
+        bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;
 
         color = HE_COLORSET_NORMAL;
         width = browser->b.width - (offset + 2);
@@ -504,7 +524,8 @@ static void hist_browser__show_callchain_entry(struct hist_browser *browser,
         ui_browser__set_color(&browser->b, color);
         hist_browser__gotorc(browser, row, 0);
         slsmg_write_nstring(" ", offset);
-        slsmg_printf("%c ", folded_sign);
+        slsmg_printf("%c", folded_sign);
+        ui_browser__write_graph(&browser->b, show_annotated ? SLSMG_RARROW_CHAR : ' ');
         slsmg_write_nstring(str, width);
 }
 
@@ -1467,7 +1488,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
 
         while (1) {
-                const struct thread *thread = NULL;
+                struct thread *thread = NULL;
                 const struct dso *dso = NULL;
                 int choice = 0,
                     annotate = -2, zoom_dso = -2, zoom_thread = -2,
@@ -1593,28 +1614,30 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                 if (!sort__has_sym)
                         goto add_exit_option;
 
+                if (browser->selection == NULL)
+                        goto skip_annotation;
+
                 if (sort__mode == SORT_MODE__BRANCH) {
                         bi = browser->he_selection->branch_info;
-                        if (browser->selection != NULL &&
-                            bi &&
-                            bi->from.sym != NULL &&
+
+                        if (bi == NULL)
+                                goto skip_annotation;
+
+                        if (bi->from.sym != NULL &&
                             !bi->from.map->dso->annotate_warned &&
-                                asprintf(&options[nr_options], "Annotate %s",
-                                         bi->from.sym->name) > 0)
+                            asprintf(&options[nr_options], "Annotate %s", bi->from.sym->name) > 0) {
                                 annotate_f = nr_options++;
+                        }
 
-                        if (browser->selection != NULL &&
-                            bi &&
-                            bi->to.sym != NULL &&
+                        if (bi->to.sym != NULL &&
                             !bi->to.map->dso->annotate_warned &&
                             (bi->to.sym != bi->from.sym ||
                              bi->to.map->dso != bi->from.map->dso) &&
-                                asprintf(&options[nr_options], "Annotate %s",
-                                         bi->to.sym->name) > 0)
+                            asprintf(&options[nr_options], "Annotate %s", bi->to.sym->name) > 0) {
                                 annotate_t = nr_options++;
+                        }
                 } else {
-                        if (browser->selection != NULL &&
-                            browser->selection->sym != NULL &&
+                        if (browser->selection->sym != NULL &&
                             !browser->selection->map->dso->annotate_warned) {
                                 struct annotation *notes;
 
@@ -1622,11 +1645,12 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 
                                 if (notes->src &&
                                     asprintf(&options[nr_options], "Annotate %s",
-                                                 browser->selection->sym->name) > 0)
+                                                 browser->selection->sym->name) > 0) {
                                         annotate = nr_options++;
+                                }
                         }
                 }
-
+skip_annotation:
                 if (thread != NULL &&
                     asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
                              (browser->hists->thread_filter ? "out of" : "into"),
@@ -1682,6 +1706,7 @@ retry_popup_menu:
                 if (choice == annotate || choice == annotate_t || choice == annotate_f) {
                         struct hist_entry *he;
                         struct annotation *notes;
+                        struct map_symbol ms;
                         int err;
 do_annotate:
                         if (!objdump_path && perf_session_env__lookup_objdump(env))
@@ -1691,30 +1716,21 @@ do_annotate:
                         if (he == NULL)
                                 continue;
 
-                        /*
-                         * we stash the branch_info symbol + map into the
-                         * the ms so we don't have to rewrite all the annotation
-                         * code to use branch_info.
-                         * in branch mode, the ms struct is not used
-                         */
                         if (choice == annotate_f) {
-                                he->ms.sym = he->branch_info->from.sym;
-                                he->ms.map = he->branch_info->from.map;
-                        }  else if (choice == annotate_t) {
-                                he->ms.sym = he->branch_info->to.sym;
-                                he->ms.map = he->branch_info->to.map;
+                                ms.map = he->branch_info->from.map;
+                                ms.sym = he->branch_info->from.sym;
+                        } else if (choice == annotate_t) {
+                                ms.map = he->branch_info->to.map;
+                                ms.sym = he->branch_info->to.sym;
+                        } else {
+                                ms = *browser->selection;
                         }
 
-                        notes = symbol__annotation(he->ms.sym);
+                        notes = symbol__annotation(ms.sym);
                         if (!notes->src)
                                 continue;
 
-                        /*
-                         * Don't let this be freed, say, by hists__decay_entry.
-                         */
-                        he->used = true;
-                        err = hist_entry__tui_annotate(he, evsel, hbt);
-                        he->used = false;
+                        err = map_symbol__tui_annotate(&ms, evsel, hbt);
                         /*
                          * offer option to annotate the other branch source or target
                          * (if they exists) when returning from annotate
@@ -1754,13 +1770,13 @@ zoom_thread:
                                 pstack__remove(fstack, &browser->hists->thread_filter);
 zoom_out_thread:
                                 ui_helpline__pop();
-                                browser->hists->thread_filter = NULL;
+                                thread__zput(browser->hists->thread_filter);
                                 perf_hpp__set_elide(HISTC_THREAD, false);
                         } else {
                                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
                                                    thread->comm_set ? thread__comm_str(thread) : "",
                                                    thread->tid);
-                                browser->hists->thread_filter = thread;
+                                browser->hists->thread_filter = thread__get(thread);
                                 perf_hpp__set_elide(HISTC_THREAD, false);
                                 pstack__push(fstack, &browser->hists->thread_filter);
                         }
diff --git a/tools/perf/ui/gtk/Build b/tools/perf/ui/gtk/Build
new file mode 100644
index 000000000000..ec22e899a224
--- /dev/null
+++ b/tools/perf/ui/gtk/Build
@@ -0,0 +1,9 @@
+CFLAGS_gtk += -fPIC $(GTK_CFLAGS)
+
+gtk-y += browser.o
+gtk-y += hists.o
+gtk-y += setup.o
+gtk-y += util.o
+gtk-y += helpline.o
+gtk-y += progress.o
+gtk-y += annotate.o
diff --git a/tools/perf/ui/tui/Build b/tools/perf/ui/tui/Build
new file mode 100644
index 000000000000..9e4c6ca41a9f
--- /dev/null
+++ b/tools/perf/ui/tui/Build
@@ -0,0 +1,4 @@
+libperf-y += setup.o
+libperf-y += util.o
+libperf-y += helpline.o
+libperf-y += progress.o
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
new file mode 100644
index 000000000000..797490a40075
--- /dev/null
+++ b/tools/perf/util/Build
@@ -0,0 +1,145 @@
+libperf-y += abspath.o
+libperf-y += alias.o
+libperf-y += annotate.o
+libperf-y += build-id.o
+libperf-y += config.o
+libperf-y += ctype.o
+libperf-y += db-export.o
+libperf-y += environment.o
+libperf-y += event.o
+libperf-y += evlist.o
+libperf-y += evsel.o
+libperf-y += exec_cmd.o
+libperf-y += find_next_bit.o
+libperf-y += help.o
+libperf-y += kallsyms.o
+libperf-y += levenshtein.o
+libperf-y += parse-options.o
+libperf-y += parse-events.o
+libperf-y += path.o
+libperf-y += rbtree.o
+libperf-y += bitmap.o
+libperf-y += hweight.o
+libperf-y += run-command.o
+libperf-y += quote.o
+libperf-y += strbuf.o
+libperf-y += string.o
+libperf-y += strlist.o
+libperf-y += strfilter.o
+libperf-y += top.o
+libperf-y += usage.o
+libperf-y += wrapper.o
+libperf-y += sigchain.o
+libperf-y += dso.o
+libperf-y += symbol.o
+libperf-y += color.o
+libperf-y += pager.o
+libperf-y += header.o
+libperf-y += callchain.o
+libperf-y += values.o
+libperf-y += debug.o
+libperf-y += machine.o
+libperf-y += map.o
+libperf-y += pstack.o
+libperf-y += session.o
+libperf-y += ordered-events.o
+libperf-y += comm.o
+libperf-y += thread.o
+libperf-y += thread_map.o
+libperf-y += trace-event-parse.o
+libperf-y += parse-events-flex.o
+libperf-y += parse-events-bison.o
+libperf-y += pmu.o
+libperf-y += pmu-flex.o
+libperf-y += pmu-bison.o
+libperf-y += trace-event-read.o
+libperf-y += trace-event-info.o
+libperf-y += trace-event-scripting.o
+libperf-y += trace-event.o
+libperf-y += svghelper.o
+libperf-y += sort.o
+libperf-y += hist.o
+libperf-y += util.o
+libperf-y += xyarray.o
+libperf-y += cpumap.o
+libperf-y += cgroup.o
+libperf-y += target.o
+libperf-y += rblist.o
+libperf-y += intlist.o
+libperf-y += vdso.o
+libperf-y += stat.o
+libperf-y += record.o
+libperf-y += srcline.o
+libperf-y += data.o
+libperf-$(CONFIG_X86) += tsc.o
+libperf-y += cloexec.o
+libperf-y += thread-stack.o
+
+libperf-$(CONFIG_LIBELF) += symbol-elf.o
+libperf-$(CONFIG_LIBELF) += probe-event.o
+
+ifndef CONFIG_LIBELF
+libperf-y += symbol-minimal.o
+endif
+
+libperf-$(CONFIG_DWARF) += probe-finder.o
+libperf-$(CONFIG_DWARF) += dwarf-aux.o
+
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
+libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+
+libperf-$(CONFIG_LIBBABELTRACE) += data-convert-bt.o
+
+libperf-y += scripting-engines/
+
+libperf-$(CONFIG_PERF_REGS) += perf_regs.o
+libperf-$(CONFIG_ZLIB) += zlib.o
+libperf-$(CONFIG_LZMA) += lzma.o
+
+CFLAGS_config.o   += -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_exec_cmd.o += -DPERF_EXEC_PATH="BUILD_STR($(perfexecdir_SQ))" -DPREFIX="BUILD_STR($(prefix_SQ))"
+
+$(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
+        $(call rule_mkdir)
+        @$(call echo-cmd,flex)$(FLEX) -o $@ --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) util/parse-events.l
+
+$(OUTPUT)util/parse-events-bison.c: util/parse-events.y
+        $(call rule_mkdir)
+        @$(call echo-cmd,bison)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $@ -p parse_events_
+
+$(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
+        $(call rule_mkdir)
+        @$(call echo-cmd,flex)$(FLEX) -o $@ --header-file=$(OUTPUT)util/pmu-flex.h util/pmu.l
+
+$(OUTPUT)util/pmu-bison.c: util/pmu.y
+        $(call rule_mkdir)
+        @$(call echo-cmd,bison)$(BISON) -v util/pmu.y -d -o $@ -p perf_pmu_
+
+CFLAGS_parse-events-flex.o  += -w
+CFLAGS_pmu-flex.o           += -w
+CFLAGS_parse-events-bison.o += -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w
+CFLAGS_pmu-bison.o          += -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w
+
+$(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
+$(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
+
+CFLAGS_find_next_bit.o += -Wno-unused-parameter -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_rbtree.o        += -Wno-unused-parameter -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_hweight.o       += -Wno-unused-parameter -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_parse-events.o  += -Wno-redundant-decls
+
+$(OUTPUT)util/kallsyms.o: ../lib/symbol/kallsyms.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+
+$(OUTPUT)util/find_next_bit.o: ../lib/util/find_next_bit.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+
+$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+
+$(OUTPUT)util/hweight.o: ../../lib/hweight.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 61bf9128e1f2..7f5bdfc9bc87 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -30,6 +30,8 @@ static int disasm_line__parse(char *line, char **namep, char **rawp);
 
 static void ins__delete(struct ins_operands *ops)
 {
+        if (ops == NULL)
+                return;
         zfree(&ops->source.raw);
         zfree(&ops->source.name);
         zfree(&ops->target.raw);
@@ -1008,6 +1010,32 @@ fallback:
                         }
                         filename = symfs_filename;
                 }
+        } else if (dso__needs_decompress(dso)) {
+                char tmp[PATH_MAX];
+                struct kmod_path m;
+                int fd;
+                bool ret;
+
+                if (kmod_path__parse_ext(&m, symfs_filename))
+                        goto out_free_filename;
+
+                snprintf(tmp, PATH_MAX, "/tmp/perf-kmod-XXXXXX");
+
+                fd = mkstemp(tmp);
+                if (fd < 0) {
+                        free(m.ext);
+                        goto out_free_filename;
+                }
+
+                ret = decompress_to_file(m.ext, symfs_filename, fd);
+
+                free(m.ext);
+                close(fd);
+
+                if (!ret)
+                        goto out_free_filename;
+
+                strcpy(symfs_filename, tmp);
         }
 
         snprintf(command, sizeof(command),
@@ -1027,7 +1055,7 @@ fallback:
 
         file = popen(command, "r");
         if (!file)
-                goto out_free_filename;
+                goto out_remove_tmp;
 
         while (!feof(file))
                 if (symbol__parse_objdump_line(sym, map, file, privsize,
@@ -1042,6 +1070,10 @@ fallback:
                 delete_last_nop(sym);
 
         pclose(file);
+
+out_remove_tmp:
+        if (dso__needs_decompress(dso))
+                unlink(symfs_filename);
 out_free_filename:
         if (delete_extract)
                 kcore_extract__delete(&kce);
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 0c72680a977f..61867dff5d5a 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -59,11 +59,8 @@ static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
         dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
                     event->fork.ppid, event->fork.ptid);
 
-        if (thread) {
-                rb_erase(&thread->rb_node, &machine->threads);
-                machine->last_match = NULL;
-                thread__delete(thread);
-        }
+        if (thread)
+                machine__remove_thread(machine, thread);
 
         return 0;
 }
@@ -93,6 +90,35 @@ int build_id__sprintf(const u8 *build_id, int len, char *bf)
         return raw - build_id;
 }
 
+/* asnprintf consolidates asprintf and snprintf */
+static int asnprintf(char **strp, size_t size, const char *fmt, ...)
+{
+        va_list ap;
+        int ret;
+
+        if (!strp)
+                return -EINVAL;
+
+        va_start(ap, fmt);
+        if (*strp)
+                ret = vsnprintf(*strp, size, fmt, ap);
+        else
+                ret = vasprintf(strp, fmt, ap);
+        va_end(ap);
+
+        return ret;
+}
+
+static char *build_id__filename(const char *sbuild_id, char *bf, size_t size)
+{
+        char *tmp = bf;
+        int ret = asnprintf(&bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
+                            sbuild_id, sbuild_id + 2);
+        if (ret < 0 || (tmp && size < (unsigned int)ret))
+                return NULL;
+        return bf;
+}
+
 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size)
 {
         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
@@ -101,14 +127,7 @@ char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size)
                 return NULL;
 
         build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex);
-        if (bf == NULL) {
-                if (asprintf(&bf, "%s/.build-id/%.2s/%s", buildid_dir,
-                             build_id_hex, build_id_hex + 2) < 0)
-                        return NULL;
-        } else
-                snprintf(bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
-                         build_id_hex, build_id_hex + 2);
-        return bf;
+        return build_id__filename(build_id_hex, bf, size);
 }
 
 #define dsos__for_each_with_build_id(pos, head) \
@@ -259,52 +278,113 @@ void disable_buildid_cache(void)
         no_buildid_cache = true;
 }
 
-int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
-                          const char *name, bool is_kallsyms, bool is_vdso)
+static char *build_id_cache__dirname_from_path(const char *name,
+                                               bool is_kallsyms, bool is_vdso)
 {
-        const size_t size = PATH_MAX;
-        char *realname, *filename = zalloc(size),
-             *linkname = zalloc(size), *targetname;
-        int len, err = -1;
+        char *realname = (char *)name, *filename;
         bool slash = is_kallsyms || is_vdso;
 
-        if (is_kallsyms) {
-                if (symbol_conf.kptr_restrict) {
-                        pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
-                        err = 0;
-                        goto out_free;
-                }
-                realname = (char *) name;
-        } else
+        if (!slash) {
                 realname = realpath(name, NULL);
+                if (!realname)
+                        return NULL;
+        }
 
-        if (realname == NULL || filename == NULL || linkname == NULL)
+        if (asprintf(&filename, "%s%s%s", buildid_dir, slash ? "/" : "",
+                     is_vdso ? DSO__NAME_VDSO : realname) < 0)
+                filename = NULL;
+
+        if (!slash)
+                free(realname);
+
+        return filename;
+}
+
+int build_id_cache__list_build_ids(const char *pathname,
+                                   struct strlist **result)
+{
+        struct strlist *list;
+        char *dir_name;
+        DIR *dir;
+        struct dirent *d;
+        int ret = 0;
+
+        list = strlist__new(true, NULL);
+        dir_name = build_id_cache__dirname_from_path(pathname, false, false);
+        if (!list || !dir_name) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* List up all dirents */
+        dir = opendir(dir_name);
+        if (!dir) {
+                ret = -errno;
+                goto out;
+        }
+
+        while ((d = readdir(dir)) != NULL) {
+                if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
+                        continue;
+                strlist__add(list, d->d_name);
+        }
+        closedir(dir);
+
+out:
+        free(dir_name);
+        if (ret)
+                strlist__delete(list);
+        else
+                *result = list;
+
+        return ret;
+}
+
+int build_id_cache__add_s(const char *sbuild_id, const char *name,
+                          bool is_kallsyms, bool is_vdso)
+{
+        const size_t size = PATH_MAX;
+        char *realname = NULL, *filename = NULL, *dir_name = NULL,
+             *linkname = zalloc(size), *targetname, *tmp;
+        int err = -1;
+
+        if (!is_kallsyms) {
+                realname = realpath(name, NULL);
+                if (!realname)
+                        goto out_free;
+        }
+
+        dir_name = build_id_cache__dirname_from_path(name, is_kallsyms, is_vdso);
+        if (!dir_name)
                 goto out_free;
 
-        len = scnprintf(filename, size, "%s%s%s",
-                       debugdir, slash ? "/" : "",
-                       is_vdso ? DSO__NAME_VDSO : realname);
-        if (mkdir_p(filename, 0755))
+        if (mkdir_p(dir_name, 0755))
                 goto out_free;
 
-        snprintf(filename + len, size - len, "/%s", sbuild_id);
+        if (asprintf(&filename, "%s/%s", dir_name, sbuild_id) < 0) {
+                filename = NULL;
+                goto out_free;
+        }
 
         if (access(filename, F_OK)) {
                 if (is_kallsyms) {
                          if (copyfile("/proc/kallsyms", filename))
                                 goto out_free;
-                } else if (link(realname, filename) && copyfile(name, filename))
+                } else if (link(realname, filename) && errno != EEXIST &&
+                                copyfile(name, filename))
                         goto out_free;
         }
 
-        len = scnprintf(linkname, size, "%s/.build-id/%.2s",
-                       debugdir, sbuild_id);
+        if (!build_id__filename(sbuild_id, linkname, size))
+                goto out_free;
+        tmp = strrchr(linkname, '/');
+        *tmp = '\0';
 
         if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
                 goto out_free;
 
-        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
-        targetname = filename + strlen(debugdir) - 5;
+        *tmp = '/';
+        targetname = filename + strlen(buildid_dir) - 5;
         memcpy(targetname, "../..", 5);
 
         if (symlink(targetname, linkname) == 0)
@@ -313,34 +393,46 @@ out_free:
         if (!is_kallsyms)
                 free(realname);
         free(filename);
+        free(dir_name);
         free(linkname);
         return err;
 }
 
 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
-                                 const char *name, const char *debugdir,
-                                 bool is_kallsyms, bool is_vdso)
+                                 const char *name, bool is_kallsyms,
+                                 bool is_vdso)
 {
         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 
         build_id__sprintf(build_id, build_id_size, sbuild_id);
 
-        return build_id_cache__add_s(sbuild_id, debugdir, name,
-                                     is_kallsyms, is_vdso);
+        return build_id_cache__add_s(sbuild_id, name, is_kallsyms, is_vdso);
+}
+
+bool build_id_cache__cached(const char *sbuild_id)
+{
+        bool ret = false;
+        char *filename = build_id__filename(sbuild_id, NULL, 0);
+
+        if (filename && !access(filename, F_OK))
+                ret = true;
+        free(filename);
+
+        return ret;
 }
 
-int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
+int build_id_cache__remove_s(const char *sbuild_id)
 {
         const size_t size = PATH_MAX;
         char *filename = zalloc(size),
-             *linkname = zalloc(size);
+             *linkname = zalloc(size), *tmp;
         int err = -1;
 
         if (filename == NULL || linkname == NULL)
                 goto out_free;
 
-        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
-                 debugdir, sbuild_id, sbuild_id + 2);
+        if (!build_id__filename(sbuild_id, linkname, size))
+                goto out_free;
 
         if (access(linkname, F_OK))
                 goto out_free;
@@ -354,8 +446,8 @@ int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
         /*
          * Since the link is relative, we must make it absolute:
          */
-        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
-                 debugdir, sbuild_id, filename);
+        tmp = strrchr(linkname, '/') + 1;
+        snprintf(tmp, size - (tmp - linkname), "%s", filename);
 
         if (unlink(linkname))
                 goto out_free;
@@ -367,8 +459,7 @@ out_free:
         return err;
 }
 
-static int dso__cache_build_id(struct dso *dso, struct machine *machine,
-                               const char *debugdir)
+static int dso__cache_build_id(struct dso *dso, struct machine *machine)
 {
         bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
         bool is_vdso = dso__is_vdso(dso);
@@ -381,28 +472,26 @@ static int dso__cache_build_id(struct dso *dso, struct machine *machine,
                 name = nm;
         }
         return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name,
-                                     debugdir, is_kallsyms, is_vdso);
+                                     is_kallsyms, is_vdso);
 }
 
 static int __dsos__cache_build_ids(struct list_head *head,
-                                   struct machine *machine, const char *debugdir)
+                                   struct machine *machine)
 {
         struct dso *pos;
         int err = 0;
 
         dsos__for_each_with_build_id(pos, head)
-                if (dso__cache_build_id(pos, machine, debugdir))
+                if (dso__cache_build_id(pos, machine))
                         err = -1;
 
         return err;
 }
 
-static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
+static int machine__cache_build_ids(struct machine *machine)
 {
-        int ret = __dsos__cache_build_ids(&machine->kernel_dsos.head, machine,
-                                          debugdir);
-        ret |= __dsos__cache_build_ids(&machine->user_dsos.head, machine,
-                                       debugdir);
+        int ret = __dsos__cache_build_ids(&machine->kernel_dsos.head, machine);
+        ret |= __dsos__cache_build_ids(&machine->user_dsos.head, machine);
         return ret;
 }
 
@@ -417,11 +506,11 @@ int perf_session__cache_build_ids(struct perf_session *session)
         if (mkdir(buildid_dir, 0755) != 0 && errno != EEXIST)
                 return -1;
 
-        ret = machine__cache_build_ids(&session->machines.host, buildid_dir);
+        ret = machine__cache_build_ids(&session->machines.host);
 
         for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                ret |= machine__cache_build_ids(pos, buildid_dir);
+                ret |= machine__cache_build_ids(pos);
         }
         return ret ? -1 : 0;
 }
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 8236319514d5..85011222cc14 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -4,6 +4,7 @@
 #define BUILD_ID_SIZE 20
 
 #include "tool.h"
+#include "strlist.h"
 #include <linux/types.h>
 
 extern struct perf_tool build_id__mark_dso_hit_ops;
@@ -22,9 +23,12 @@ bool perf_session__read_build_ids(struct perf_session *session, bool with_hits);
 int perf_session__write_buildid_table(struct perf_session *session, int fd);
 int perf_session__cache_build_ids(struct perf_session *session);
 
-int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+int build_id_cache__list_build_ids(const char *pathname,
+                                   struct strlist **result);
+bool build_id_cache__cached(const char *sbuild_id);
+int build_id_cache__add_s(const char *sbuild_id,
                           const char *name, bool is_kallsyms, bool is_vdso);
-int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
+int build_id_cache__remove_s(const char *sbuild_id);
 void disable_buildid_cache(void);
 
 #endif
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index d04d770d90f6..fbcca21d66ab 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -17,6 +17,7 @@
 #define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
 #define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
+#define PERF_TRACEFS_ENVIRONMENT "PERF_TRACEFS_DIR"
 
 typedef int (*config_fn_t)(const char *, const char *, void *);
 extern int perf_default_config(const char *, const char *, void *);
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 14e7a123d43b..9f643ee77001 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -97,6 +97,14 @@ int parse_callchain_record_opt(const char *arg)
                                 callchain_param.dump_size = size;
                         }
 #endif /* HAVE_DWARF_UNWIND_SUPPORT */
+                } else if (!strncmp(name, "lbr", sizeof("lbr"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                callchain_param.record_mode = CALLCHAIN_LBR;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                        "needed for --call-graph lbr\n");
+                        break;
                 } else {
                         pr_err("callchain: Unknown --call-graph option "
                                "value: %s\n", arg);
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index c0ec1acc38e4..6033a0a212ca 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -11,6 +11,7 @@ enum perf_call_graph_mode {
         CALLCHAIN_NONE,
         CALLCHAIN_FP,
         CALLCHAIN_DWARF,
+        CALLCHAIN_LBR,
         CALLCHAIN_MAX
 };
 
diff --git a/tools/perf/util/cloexec.c b/tools/perf/util/cloexec.c
index 6da965bdbc2c..85b523885f9d 100644
--- a/tools/perf/util/cloexec.c
+++ b/tools/perf/util/cloexec.c
@@ -7,6 +7,12 @@
 
 static unsigned long flag = PERF_FLAG_FD_CLOEXEC;
 
+int __weak sched_getcpu(void)
+{
+        errno = ENOSYS;
+        return -1;
+}
+
 static int perf_flag_probe(void)
 {
         /* use 'safest' configuration as used in perf_evsel__fallback() */
diff --git a/tools/perf/util/cloexec.h b/tools/perf/util/cloexec.h
index 94a5a7d829d5..68888c29b04a 100644
--- a/tools/perf/util/cloexec.h
+++ b/tools/perf/util/cloexec.h
@@ -3,4 +3,10 @@
 
 unsigned long perf_event_open_cloexec_flag(void);
 
+#ifdef __GLIBC_PREREQ
+#if !__GLIBC_PREREQ(2, 6)
+extern int sched_getcpu(void) __THROW;
+#endif
+#endif
+
 #endif /* __PERF_CLOEXEC_H */
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
new file mode 100644
index 000000000000..dd17c9a32fbc
--- /dev/null
+++ b/tools/perf/util/data-convert-bt.c
@@ -0,0 +1,857 @@
+/*
+ * CTF writing support via babeltrace.
+ *
+ * Copyright (C) 2014, Jiri Olsa <jolsa@redhat.com>
+ * Copyright (C) 2014, Sebastian Andrzej Siewior <bigeasy@linutronix.de>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
+ */
+
+#include <linux/compiler.h>
+#include <babeltrace/ctf-writer/writer.h>
+#include <babeltrace/ctf-writer/clock.h>
+#include <babeltrace/ctf-writer/stream.h>
+#include <babeltrace/ctf-writer/event.h>
+#include <babeltrace/ctf-writer/event-types.h>
+#include <babeltrace/ctf-writer/event-fields.h>
+#include <babeltrace/ctf/events.h>
+#include <traceevent/event-parse.h>
+#include "asm/bug.h"
+#include "data-convert-bt.h"
+#include "session.h"
+#include "util.h"
+#include "debug.h"
+#include "tool.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "machine.h"
+
+#define pr_N(n, fmt, ...) \
+        eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
+
+#define pr(fmt, ...)  pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__)
+
+#define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__)
+
+struct evsel_priv {
+        struct bt_ctf_event_class *event_class;
+};
+
+struct ctf_writer {
+        /* writer primitives */
+        struct bt_ctf_writer            *writer;
+        struct bt_ctf_stream            *stream;
+        struct bt_ctf_stream_class      *stream_class;
+        struct bt_ctf_clock             *clock;
+
+        /* data types */
+        union {
+                struct {
+                        struct bt_ctf_field_type        *s64;
+                        struct bt_ctf_field_type        *u64;
+                        struct bt_ctf_field_type        *s32;
+                        struct bt_ctf_field_type        *u32;
+                        struct bt_ctf_field_type        *string;
+                        struct bt_ctf_field_type        *u64_hex;
+                };
+                struct bt_ctf_field_type *array[6];
+        } data;
+};
+
+struct convert {
+        struct perf_tool        tool;
+        struct ctf_writer       writer;
+
+        u64                     events_size;
+        u64                     events_count;
+};
+
+static int value_set(struct bt_ctf_field_type *type,
+                     struct bt_ctf_event *event,
+                     const char *name, u64 val)
+{
+        struct bt_ctf_field *field;
+        bool sign = bt_ctf_field_type_integer_get_signed(type);
+        int ret;
+
+        field = bt_ctf_field_create(type);
+        if (!field) {
+                pr_err("failed to create a field %s\n", name);
+                return -1;
+        }
+
+        if (sign) {
+                ret = bt_ctf_field_signed_integer_set_value(field, val);
+                if (ret) {
+                        pr_err("failed to set field value %s\n", name);
+                        goto err;
+                }
+        } else {
+                ret = bt_ctf_field_unsigned_integer_set_value(field, val);
+                if (ret) {
+                        pr_err("failed to set field value %s\n", name);
+                        goto err;
+                }
+        }
+
+        ret = bt_ctf_event_set_payload(event, name, field);
+        if (ret) {
+                pr_err("failed to set payload %s\n", name);
+                goto err;
+        }
+
+        pr2("  SET [%s = %" PRIu64 "]\n", name, val);
+
+err:
+        bt_ctf_field_put(field);
+        return ret;
+}
+
+#define __FUNC_VALUE_SET(_name, _val_type)                              \
+static __maybe_unused int value_set_##_name(struct ctf_writer *cw,      \
+                             struct bt_ctf_event *event,                \
+                             const char *name,                          \
+                             _val_type val)                             \
+{                                                                       \
+        struct bt_ctf_field_type *type = cw->data._name;                \
+        return value_set(type, event, name, (u64) val);                 \
+}
+
+#define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name)
+
+FUNC_VALUE_SET(s32)
+FUNC_VALUE_SET(u32)
+FUNC_VALUE_SET(s64)
+FUNC_VALUE_SET(u64)
+__FUNC_VALUE_SET(u64_hex, u64)
+
+static struct bt_ctf_field_type*
+get_tracepoint_field_type(struct ctf_writer *cw, struct format_field *field)
+{
+        unsigned long flags = field->flags;
+
+        if (flags & FIELD_IS_STRING)
+                return cw->data.string;
+
+        if (!(flags & FIELD_IS_SIGNED)) {
+                /* unsigned long are mostly pointers */
+                if (flags & FIELD_IS_LONG || flags & FIELD_IS_POINTER)
+                        return cw->data.u64_hex;
+        }
+
+        if (flags & FIELD_IS_SIGNED) {
+                if (field->size == 8)
+                        return cw->data.s64;
+                else
+                        return cw->data.s32;
+        }
+
+        if (field->size == 8)
+                return cw->data.u64;
+        else
+                return cw->data.u32;
+}
+
+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 bt_ctf_field_type *type;
+        struct bt_ctf_field *array_field;
+        struct bt_ctf_field *field;
+        const char *name = fmtf->name;
+        void *data = sample->raw_data;
+        unsigned long long value_int;
+        unsigned long flags = fmtf->flags;
+        unsigned int n_items;
+        unsigned int i;
+        unsigned int offset;
+        unsigned int len;
+        int ret;
+
+        offset = fmtf->offset;
+        len = fmtf->size;
+        if (flags & FIELD_IS_STRING)
+                flags &= ~FIELD_IS_ARRAY;
+
+        if (flags & FIELD_IS_DYNAMIC) {
+                unsigned long long tmp_val;
+
+                tmp_val = pevent_read_number(fmtf->event->pevent,
+                                data + offset, len);
+                offset = tmp_val;
+                len = offset >> 16;
+                offset &= 0xffff;
+        }
+
+        if (flags & FIELD_IS_ARRAY) {
+
+                type = bt_ctf_event_class_get_field_by_name(
+                                event_class, name);
+                array_field = bt_ctf_field_create(type);
+                bt_ctf_field_type_put(type);
+                if (!array_field) {
+                        pr_err("Failed to create array type %s\n", name);
+                        return -1;
+                }
+
+                len = fmtf->size / fmtf->arraylen;
+                n_items = fmtf->arraylen;
+        } else {
+                n_items = 1;
+                array_field = NULL;
+        }
+
+        type = get_tracepoint_field_type(cw, fmtf);
+
+        for (i = 0; i < n_items; i++) {
+                if (!(flags & FIELD_IS_STRING))
+                        value_int = pevent_read_number(
+                                        fmtf->event->pevent,
+                                        data + offset + i * len, len);
+
+                if (flags & FIELD_IS_ARRAY)
+                        field = bt_ctf_field_array_get_field(array_field, i);
+                else
+                        field = bt_ctf_field_create(type);
+
+                if (!field) {
+                        pr_err("failed to create a field %s\n", name);
+                        return -1;
+                }
+
+                if (flags & FIELD_IS_STRING)
+                        ret = bt_ctf_field_string_set_value(field,
+                                        data + offset + i * len);
+                else if (!(flags & FIELD_IS_SIGNED))
+                        ret = bt_ctf_field_unsigned_integer_set_value(
+                                        field, value_int);
+                else
+                        ret = bt_ctf_field_signed_integer_set_value(
+                                        field, value_int);
+                if (ret) {
+                        pr_err("failed to set file value %s\n", name);
+                        goto err_put_field;
+                }
+                if (!(flags & FIELD_IS_ARRAY)) {
+                        ret = bt_ctf_event_set_payload(event, name, field);
+                        if (ret) {
+                                pr_err("failed to set payload %s\n", name);
+                                goto err_put_field;
+                        }
+                }
+                bt_ctf_field_put(field);
+        }
+        if (flags & FIELD_IS_ARRAY) {
+                ret = bt_ctf_event_set_payload(event, name, array_field);
+                if (ret) {
+                        pr_err("Failed add payload array %s\n", name);
+                        return -1;
+                }
+                bt_ctf_field_put(array_field);
+        }
+        return 0;
+
+err_put_field:
+        bt_ctf_field_put(field);
+        return -1;
+}
+
+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 perf_sample *sample)
+{
+        struct format_field *field;
+        int ret;
+
+        for (field = fields; field; field = field->next) {
+                ret = add_tracepoint_field_value(cw, event_class, event, sample,
+                                field);
+                if (ret)
+                        return -1;
+        }
+        return 0;
+}
+
+static int add_tracepoint_values(struct ctf_writer *cw,
+                                 struct bt_ctf_event_class *event_class,
+                                 struct bt_ctf_event *event,
+                                 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;
+        int ret;
+
+        ret = add_tracepoint_fields_values(cw, event_class, event,
+                                           common_fields, sample);
+        if (!ret)
+                ret = add_tracepoint_fields_values(cw, event_class, event,
+                                                   fields, sample);
+
+        return ret;
+}
+
+static int add_generic_values(struct ctf_writer *cw,
+                              struct bt_ctf_event *event,
+                              struct perf_evsel *evsel,
+                              struct perf_sample *sample)
+{
+        u64 type = evsel->attr.sample_type;
+        int ret;
+
+        /*
+         * missing:
+         *   PERF_SAMPLE_TIME         - not needed as we have it in
+         *                              ctf event header
+         *   PERF_SAMPLE_READ         - TODO
+         *   PERF_SAMPLE_CALLCHAIN    - TODO
+         *   PERF_SAMPLE_RAW          - tracepoint fields are handled separately
+         *   PERF_SAMPLE_BRANCH_STACK - TODO
+         *   PERF_SAMPLE_REGS_USER    - TODO
+         *   PERF_SAMPLE_STACK_USER   - TODO
+         */
+
+        if (type & PERF_SAMPLE_IP) {
+                ret = value_set_u64_hex(cw, event, "perf_ip", sample->ip);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_TID) {
+                ret = value_set_s32(cw, event, "perf_tid", sample->tid);
+                if (ret)
+                        return -1;
+
+                ret = value_set_s32(cw, event, "perf_pid", sample->pid);
+                if (ret)
+                        return -1;
+        }
+
+        if ((type & PERF_SAMPLE_ID) ||
+            (type & PERF_SAMPLE_IDENTIFIER)) {
+                ret = value_set_u64(cw, event, "perf_id", sample->id);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_STREAM_ID) {
+                ret = value_set_u64(cw, event, "perf_stream_id", sample->stream_id);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_CPU) {
+                ret = value_set_u32(cw, event, "perf_cpu", sample->cpu);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_PERIOD) {
+                ret = value_set_u64(cw, event, "perf_period", sample->period);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_WEIGHT) {
+                ret = value_set_u64(cw, event, "perf_weight", sample->weight);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_DATA_SRC) {
+                ret = value_set_u64(cw, event, "perf_data_src",
+                                sample->data_src);
+                if (ret)
+                        return -1;
+        }
+
+        if (type & PERF_SAMPLE_TRANSACTION) {
+                ret = value_set_u64(cw, event, "perf_transaction",
+                                sample->transaction);
+                if (ret)
+                        return -1;
+        }
+
+        return 0;
+}
+
+static int process_sample_event(struct perf_tool *tool,
+                                union perf_event *_event __maybe_unused,
+                                struct perf_sample *sample,
+                                struct perf_evsel *evsel,
+                                struct machine *machine __maybe_unused)
+{
+        struct convert *c = container_of(tool, struct convert, tool);
+        struct evsel_priv *priv = evsel->priv;
+        struct ctf_writer *cw = &c->writer;
+        struct bt_ctf_event_class *event_class;
+        struct bt_ctf_event *event;
+        int ret;
+
+        if (WARN_ONCE(!priv, "Failed to setup all events.\n"))
+                return 0;
+
+        event_class = priv->event_class;
+
+        /* update stats */
+        c->events_count++;
+        c->events_size += _event->header.size;
+
+        pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count);
+
+        event = bt_ctf_event_create(event_class);
+        if (!event) {
+                pr_err("Failed to create an CTF event\n");
+                return -1;
+        }
+
+        bt_ctf_clock_set_time(cw->clock, sample->time);
+
+        ret = add_generic_values(cw, event, evsel, sample);
+        if (ret)
+                return -1;
+
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
+                ret = add_tracepoint_values(cw, event_class, event,
+                                            evsel, sample);
+                if (ret)
+                        return -1;
+        }
+
+        bt_ctf_stream_append_event(cw->stream, event);
+        bt_ctf_event_put(event);
+        return 0;
+}
+
+static int add_tracepoint_fields_types(struct ctf_writer *cw,
+                                       struct format_field *fields,
+                                       struct bt_ctf_event_class *event_class)
+{
+        struct format_field *field;
+        int ret;
+
+        for (field = fields; field; field = field->next) {
+                struct bt_ctf_field_type *type;
+                unsigned long flags = field->flags;
+
+                pr2("  field '%s'\n", field->name);
+
+                type = get_tracepoint_field_type(cw, field);
+                if (!type)
+                        return -1;
+
+                /*
+                 * A string is an array of chars. For this we use the string
+                 * 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 & FIELD_IS_ARRAY)
+                        type = bt_ctf_field_type_array_create(type, field->arraylen);
+
+                ret = bt_ctf_event_class_add_field(event_class, type,
+                                field->name);
+
+                if (flags & FIELD_IS_ARRAY)
+                        bt_ctf_field_type_put(type);
+
+                if (ret) {
+                        pr_err("Failed to add field '%s\n", field->name);
+                        return -1;
+                }
+        }
+
+        return 0;
+}
+
+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;
+        int ret;
+
+        ret = add_tracepoint_fields_types(cw, common_fields, class);
+        if (!ret)
+                ret = add_tracepoint_fields_types(cw, fields, class);
+
+        return ret;
+}
+
+static int add_generic_types(struct ctf_writer *cw, struct perf_evsel *evsel,
+                             struct bt_ctf_event_class *event_class)
+{
+        u64 type = evsel->attr.sample_type;
+
+        /*
+         * missing:
+         *   PERF_SAMPLE_TIME         - not needed as we have it in
+         *                              ctf event header
+         *   PERF_SAMPLE_READ         - TODO
+         *   PERF_SAMPLE_CALLCHAIN    - TODO
+         *   PERF_SAMPLE_RAW          - tracepoint fields are handled separately
+         *   PERF_SAMPLE_BRANCH_STACK - TODO
+         *   PERF_SAMPLE_REGS_USER    - TODO
+         *   PERF_SAMPLE_STACK_USER   - TODO
+         */
+
+#define ADD_FIELD(cl, t, n)                                             \
+        do {                                                            \
+                pr2("  field '%s'\n", n);                               \
+                if (bt_ctf_event_class_add_field(cl, t, n)) {           \
+                        pr_err("Failed to add field '%s;\n", n);        \
+                        return -1;                                      \
+                }                                                       \
+        } while (0)
+
+        if (type & PERF_SAMPLE_IP)
+                ADD_FIELD(event_class, cw->data.u64_hex, "perf_ip");
+
+        if (type & PERF_SAMPLE_TID) {
+                ADD_FIELD(event_class, cw->data.s32, "perf_tid");
+                ADD_FIELD(event_class, cw->data.s32, "perf_pid");
+        }
+
+        if ((type & PERF_SAMPLE_ID) ||
+            (type & PERF_SAMPLE_IDENTIFIER))
+                ADD_FIELD(event_class, cw->data.u64, "perf_id");
+
+        if (type & PERF_SAMPLE_STREAM_ID)
+                ADD_FIELD(event_class, cw->data.u64, "perf_stream_id");
+
+        if (type & PERF_SAMPLE_CPU)
+                ADD_FIELD(event_class, cw->data.u32, "perf_cpu");
+
+        if (type & PERF_SAMPLE_PERIOD)
+                ADD_FIELD(event_class, cw->data.u64, "perf_period");
+
+        if (type & PERF_SAMPLE_WEIGHT)
+                ADD_FIELD(event_class, cw->data.u64, "perf_weight");
+
+        if (type & PERF_SAMPLE_DATA_SRC)
+                ADD_FIELD(event_class, cw->data.u64, "perf_data_src");
+
+        if (type & PERF_SAMPLE_TRANSACTION)
+                ADD_FIELD(event_class, cw->data.u64, "perf_transaction");
+
+#undef ADD_FIELD
+        return 0;
+}
+
+static int add_event(struct ctf_writer *cw, struct perf_evsel *evsel)
+{
+        struct bt_ctf_event_class *event_class;
+        struct evsel_priv *priv;
+        const char *name = perf_evsel__name(evsel);
+        int ret;
+
+        pr("Adding event '%s' (type %d)\n", name, evsel->attr.type);
+
+        event_class = bt_ctf_event_class_create(name);
+        if (!event_class)
+                return -1;
+
+        ret = add_generic_types(cw, evsel, event_class);
+        if (ret)
+                goto err;
+
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
+                ret = add_tracepoint_types(cw, evsel, event_class);
+                if (ret)
+                        goto err;
+        }
+
+        ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);
+        if (ret) {
+                pr("Failed to add event class into stream.\n");
+                goto err;
+        }
+
+        priv = malloc(sizeof(*priv));
+        if (!priv)
+                goto err;
+
+        priv->event_class = event_class;
+        evsel->priv       = priv;
+        return 0;
+
+err:
+        bt_ctf_event_class_put(event_class);
+        pr_err("Failed to add event '%s'.\n", name);
+        return -1;
+}
+
+static int setup_events(struct ctf_writer *cw, struct perf_session *session)
+{
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_evsel *evsel;
+        int ret;
+
+        evlist__for_each(evlist, evsel) {
+                ret = add_event(cw, evsel);
+                if (ret)
+                        return ret;
+        }
+        return 0;
+}
+
+static int ctf_writer__setup_env(struct ctf_writer *cw,
+                                 struct perf_session *session)
+{
+        struct perf_header *header = &session->header;
+        struct bt_ctf_writer *writer = cw->writer;
+
+#define ADD(__n, __v)                                                   \
+do {                                                                    \
+        if (bt_ctf_writer_add_environment_field(writer, __n, __v))      \
+                return -1;                                              \
+} while (0)
+
+        ADD("host",    header->env.hostname);
+        ADD("sysname", "Linux");
+        ADD("release", header->env.os_release);
+        ADD("version", header->env.version);
+        ADD("machine", header->env.arch);
+        ADD("domain", "kernel");
+        ADD("tracer_name", "perf");
+
+#undef ADD
+        return 0;
+}
+
+static int ctf_writer__setup_clock(struct ctf_writer *cw)
+{
+        struct bt_ctf_clock *clock = cw->clock;
+
+        bt_ctf_clock_set_description(clock, "perf clock");
+
+#define SET(__n, __v)                           \
+do {                                            \
+        if (bt_ctf_clock_set_##__n(clock, __v)) \
+                return -1;                      \
+} while (0)
+
+        SET(frequency,   1000000000);
+        SET(offset_s,    0);
+        SET(offset,      0);
+        SET(precision,   10);
+        SET(is_absolute, 0);
+
+#undef SET
+        return 0;
+}
+
+static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex)
+{
+        struct bt_ctf_field_type *type;
+
+        type = bt_ctf_field_type_integer_create(size);
+        if (!type)
+                return NULL;
+
+        if (sign &&
+            bt_ctf_field_type_integer_set_signed(type, 1))
+                goto err;
+
+        if (hex &&
+            bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL))
+                goto err;
+
+        pr2("Created type: INTEGER %d-bit %ssigned %s\n",
+            size, sign ? "un" : "", hex ? "hex" : "");
+        return type;
+
+err:
+        bt_ctf_field_type_put(type);
+        return NULL;
+}
+
+static void ctf_writer__cleanup_data(struct ctf_writer *cw)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(cw->data.array); i++)
+                bt_ctf_field_type_put(cw->data.array[i]);
+}
+
+static int ctf_writer__init_data(struct ctf_writer *cw)
+{
+#define CREATE_INT_TYPE(type, size, sign, hex)          \
+do {                                                    \
+        (type) = create_int_type(size, sign, hex);      \
+        if (!(type))                                    \
+                goto err;                               \
+} while (0)
+
+        CREATE_INT_TYPE(cw->data.s64, 64, true,  false);
+        CREATE_INT_TYPE(cw->data.u64, 64, false, false);
+        CREATE_INT_TYPE(cw->data.s32, 32, true,  false);
+        CREATE_INT_TYPE(cw->data.u32, 32, false, false);
+        CREATE_INT_TYPE(cw->data.u64_hex, 64, false, true);
+
+        cw->data.string  = bt_ctf_field_type_string_create();
+        if (cw->data.string)
+                return 0;
+
+err:
+        ctf_writer__cleanup_data(cw);
+        pr_err("Failed to create data types.\n");
+        return -1;
+}
+
+static void ctf_writer__cleanup(struct ctf_writer *cw)
+{
+        ctf_writer__cleanup_data(cw);
+
+        bt_ctf_clock_put(cw->clock);
+        bt_ctf_stream_put(cw->stream);
+        bt_ctf_stream_class_put(cw->stream_class);
+        bt_ctf_writer_put(cw->writer);
+
+        /* and NULL all the pointers */
+        memset(cw, 0, sizeof(*cw));
+}
+
+static int ctf_writer__init(struct ctf_writer *cw, const char *path)
+{
+        struct bt_ctf_writer            *writer;
+        struct bt_ctf_stream_class      *stream_class;
+        struct bt_ctf_stream            *stream;
+        struct bt_ctf_clock             *clock;
+
+        /* CTF writer */
+        writer = bt_ctf_writer_create(path);
+        if (!writer)
+                goto err;
+
+        cw->writer = writer;
+
+        /* CTF clock */
+        clock = bt_ctf_clock_create("perf_clock");
+        if (!clock) {
+                pr("Failed to create CTF clock.\n");
+                goto err_cleanup;
+        }
+
+        cw->clock = clock;
+
+        if (ctf_writer__setup_clock(cw)) {
+                pr("Failed to setup CTF clock.\n");
+                goto err_cleanup;
+        }
+
+        /* CTF stream class */
+        stream_class = bt_ctf_stream_class_create("perf_stream");
+        if (!stream_class) {
+                pr("Failed to create CTF stream class.\n");
+                goto err_cleanup;
+        }
+
+        cw->stream_class = stream_class;
+
+        /* CTF clock stream setup */
+        if (bt_ctf_stream_class_set_clock(stream_class, clock)) {
+                pr("Failed to assign CTF clock to stream class.\n");
+                goto err_cleanup;
+        }
+
+        if (ctf_writer__init_data(cw))
+                goto err_cleanup;
+
+        /* CTF stream instance */
+        stream = bt_ctf_writer_create_stream(writer, stream_class);
+        if (!stream) {
+                pr("Failed to create CTF stream.\n");
+                goto err_cleanup;
+        }
+
+        cw->stream = stream;
+
+        /* CTF clock writer setup */
+        if (bt_ctf_writer_add_clock(writer, clock)) {
+                pr("Failed to assign CTF clock to writer.\n");
+                goto err_cleanup;
+        }
+
+        return 0;
+
+err_cleanup:
+        ctf_writer__cleanup(cw);
+err:
+        pr_err("Failed to setup CTF writer.\n");
+        return -1;
+}
+
+int bt_convert__perf2ctf(const char *input, const char *path, bool force)
+{
+        struct perf_session *session;
+        struct perf_data_file file = {
+                .path = input,
+                .mode = PERF_DATA_MODE_READ,
+                .force = force,
+        };
+        struct convert c = {
+                .tool = {
+                        .sample          = process_sample_event,
+                        .mmap            = perf_event__process_mmap,
+                        .mmap2           = perf_event__process_mmap2,
+                        .comm            = perf_event__process_comm,
+                        .exit            = perf_event__process_exit,
+                        .fork            = perf_event__process_fork,
+                        .lost            = perf_event__process_lost,
+                        .tracing_data    = perf_event__process_tracing_data,
+                        .build_id        = perf_event__process_build_id,
+                        .ordered_events  = true,
+                        .ordering_requires_timestamps = true,
+                },
+        };
+        struct ctf_writer *cw = &c.writer;
+        int err = -1;
+
+        /* CTF writer */
+        if (ctf_writer__init(cw, path))
+                return -1;
+
+        /* perf.data session */
+        session = perf_session__new(&file, 0, &c.tool);
+        if (!session)
+                goto free_writer;
+
+        /* CTF writer env/clock setup  */
+        if (ctf_writer__setup_env(cw, session))
+                goto free_session;
+
+        /* CTF events setup */
+        if (setup_events(cw, session))
+                goto free_session;
+
+        err = perf_session__process_events(session);
+        if (!err)
+                err = bt_ctf_stream_flush(cw->stream);
+
+        fprintf(stderr,
+                "[ perf data convert: Converted '%s' into CTF data '%s' ]\n",
+                file.path, path);
+
+        fprintf(stderr,
+                "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples) ]\n",
+                (double) c.events_size / 1024.0 / 1024.0,
+                c.events_count);
+
+        /* its all good */
+free_session:
+        perf_session__delete(session);
+
+free_writer:
+        ctf_writer__cleanup(cw);
+        return err;
+}
diff --git a/tools/perf/util/data-convert-bt.h b/tools/perf/util/data-convert-bt.h
new file mode 100644
index 000000000000..4c204342a9d8
--- /dev/null
+++ b/tools/perf/util/data-convert-bt.h
@@ -0,0 +1,8 @@
+#ifndef __DATA_CONVERT_BT_H
+#define __DATA_CONVERT_BT_H
+#ifdef HAVE_LIBBABELTRACE_SUPPORT
+
+int bt_convert__perf2ctf(const char *input_name, const char *to_ctf, bool force);
+
+#endif /* HAVE_LIBBABELTRACE_SUPPORT */
+#endif /* __DATA_CONVERT_BT_H */
diff --git a/tools/perf/util/db-export.c b/tools/perf/util/db-export.c
index c81dae399763..bb39a3ffc70b 100644
--- a/tools/perf/util/db-export.c
+++ b/tools/perf/util/db-export.c
@@ -282,13 +282,13 @@ int db_export__branch_type(struct db_export *dbe, u32 branch_type,
 
 int db_export__sample(struct db_export *dbe, union perf_event *event,
                       struct perf_sample *sample, struct perf_evsel *evsel,
-                      struct thread *thread, struct addr_location *al)
+                      struct addr_location *al)
 {
+        struct thread* thread = al->thread;
         struct export_sample es = {
                 .event = event,
                 .sample = sample,
                 .evsel = evsel,
-                .thread = thread,
                 .al = al,
         };
         struct thread *main_thread;
diff --git a/tools/perf/util/db-export.h b/tools/perf/util/db-export.h
index adbd22d66798..25e22fd76aca 100644
--- a/tools/perf/util/db-export.h
+++ b/tools/perf/util/db-export.h
@@ -34,7 +34,6 @@ struct export_sample {
         union perf_event        *event;
         struct perf_sample      *sample;
         struct perf_evsel       *evsel;
-        struct thread           *thread;
         struct addr_location    *al;
         u64                     db_id;
         u64                     comm_db_id;
@@ -97,7 +96,7 @@ int db_export__branch_type(struct db_export *dbe, u32 branch_type,
                            const char *name);
 int db_export__sample(struct db_export *dbe, union perf_event *event,
                       struct perf_sample *sample, struct perf_evsel *evsel,
-                      struct thread *thread, struct addr_location *al);
+                      struct addr_location *al);
 
 int db_export__branch_types(struct db_export *dbe);
 
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index ad60b2f20258..2da5581ec74d 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -20,6 +20,7 @@ int verbose;
 bool dump_trace = false, quiet = false;
 int debug_ordered_events;
 static int redirect_to_stderr;
+int debug_data_convert;
 
 static int _eprintf(int level, int var, const char *fmt, va_list args)
 {
@@ -147,6 +148,7 @@ static struct debug_variable {
         { .name = "verbose",            .ptr = &verbose },
         { .name = "ordered-events",     .ptr = &debug_ordered_events},
         { .name = "stderr",             .ptr = &redirect_to_stderr},
+        { .name = "data-convert",       .ptr = &debug_data_convert },
         { .name = NULL, }
 };
 
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index be264d6f3b30..caac2fdc6105 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -12,6 +12,7 @@
 extern int verbose;
 extern bool quiet, dump_trace;
 extern int debug_ordered_events;
+extern int debug_data_convert;
 
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index c2f7d3b90966..fc0ddd5792a9 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -45,13 +45,13 @@ int dso__read_binary_type_filename(const struct dso *dso,
         case DSO_BINARY_TYPE__DEBUGLINK: {
                 char *debuglink;
 
-                strncpy(filename, dso->long_name, size);
-                debuglink = filename + dso->long_name_len;
+                len = __symbol__join_symfs(filename, size, dso->long_name);
+                debuglink = filename + len;
                 while (debuglink != filename && *debuglink != '/')
                         debuglink--;
                 if (*debuglink == '/')
                         debuglink++;
-                ret = filename__read_debuglink(dso->long_name, debuglink,
+                ret = filename__read_debuglink(filename, debuglink,
                                                size - (debuglink - filename));
                 }
                 break;
@@ -148,6 +148,9 @@ static const struct {
 #ifdef HAVE_ZLIB_SUPPORT
         { "gz", gzip_decompress_to_file },
 #endif
+#ifdef HAVE_LZMA_SUPPORT
+        { "xz", lzma_decompress_to_file },
+#endif
         { NULL, NULL },
 };
 
@@ -162,32 +165,14 @@ bool is_supported_compression(const char *ext)
         return false;
 }
 
-bool is_kmodule_extension(const char *ext)
-{
-        if (strncmp(ext, "ko", 2))
-                return false;
-
-        if (ext[2] == '\0' || (ext[2] == '.' && is_supported_compression(ext+3)))
-                return true;
-
-        return false;
-}
-
-bool is_kernel_module(const char *pathname, bool *compressed)
+bool is_kernel_module(const char *pathname)
 {
-        const char *ext = strrchr(pathname, '.');
+        struct kmod_path m;
 
-        if (ext == NULL)
-                return false;
-
-        if (is_supported_compression(ext + 1)) {
-                if (compressed)
-                        *compressed = true;
-                ext -= 3;
-        } else if (compressed)
-                *compressed = false;
+        if (kmod_path__parse(&m, pathname))
+                return NULL;
 
-        return is_kmodule_extension(ext + 1);
+        return m.kmod;
 }
 
 bool decompress_to_file(const char *ext, const char *filename, int output_fd)
@@ -209,6 +194,72 @@ bool dso__needs_decompress(struct dso *dso)
 }
 
 /*
+ * Parses kernel module specified in @path and updates
+ * @m argument like:
+ *
+ *    @comp - true if @path contains supported compression suffix,
+ *            false otherwise
+ *    @kmod - true if @path contains '.ko' suffix in right position,
+ *            false otherwise
+ *    @name - if (@alloc_name && @kmod) is true, it contains strdup-ed base name
+ *            of the kernel module without suffixes, otherwise strudup-ed
+ *            base name of @path
+ *    @ext  - if (@alloc_ext && @comp) is true, it contains strdup-ed string
+ *            the compression suffix
+ *
+ * Returns 0 if there's no strdup error, -ENOMEM otherwise.
+ */
+int __kmod_path__parse(struct kmod_path *m, const char *path,
+                       bool alloc_name, bool alloc_ext)
+{
+        const char *name = strrchr(path, '/');
+        const char *ext  = strrchr(path, '.');
+
+        memset(m, 0x0, sizeof(*m));
+        name = name ? name + 1 : path;
+
+        /* No extension, just return name. */
+        if (ext == NULL) {
+                if (alloc_name) {
+                        m->name = strdup(name);
+                        return m->name ? 0 : -ENOMEM;
+                }
+                return 0;
+        }
+
+        if (is_supported_compression(ext + 1)) {
+                m->comp = true;
+                ext -= 3;
+        }
+
+        /* Check .ko extension only if there's enough name left. */
+        if (ext > name)
+                m->kmod = !strncmp(ext, ".ko", 3);
+
+        if (alloc_name) {
+                if (m->kmod) {
+                        if (asprintf(&m->name, "[%.*s]", (int) (ext - name), name) == -1)
+                                return -ENOMEM;
+                } else {
+                        if (asprintf(&m->name, "%s", name) == -1)
+                                return -ENOMEM;
+                }
+
+                strxfrchar(m->name, '-', '_');
+        }
+
+        if (alloc_ext && m->comp) {
+                m->ext = strdup(ext + 4);
+                if (!m->ext) {
+                        free((void *) m->name);
+                        return -ENOMEM;
+                }
+        }
+
+        return 0;
+}
+
+/*
  * Global list of open DSOs and the counter.
  */
 static LIST_HEAD(dso__data_open);
@@ -240,7 +291,7 @@ static int do_open(char *name)
                 if (fd >= 0)
                         return fd;
 
-                pr_debug("dso open failed, mmap: %s\n",
+                pr_debug("dso open failed: %s\n",
                          strerror_r(errno, sbuf, sizeof(sbuf)));
                 if (!dso__data_open_cnt || errno != EMFILE)
                         break;
@@ -1002,21 +1053,24 @@ struct dso *dsos__find(const struct dsos *dsos, const char *name,
         return dso__find_by_longname(&dsos->root, name);
 }
 
-struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
+struct dso *dsos__addnew(struct dsos *dsos, const char *name)
 {
-        struct dso *dso = dsos__find(dsos, name, false);
+        struct dso *dso = dso__new(name);
 
-        if (!dso) {
-                dso = dso__new(name);
-                if (dso != NULL) {
-                        dsos__add(dsos, dso);
-                        dso__set_basename(dso);
-                }
+        if (dso != NULL) {
+                dsos__add(dsos, dso);
+                dso__set_basename(dso);
         }
-
         return dso;
 }
 
+struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
+{
+        struct dso *dso = dsos__find(dsos, name, false);
+
+        return dso ? dso : dsos__addnew(dsos, name);
+}
+
 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
                                bool (skip)(struct dso *dso, int parm), int parm)
 {
@@ -1083,3 +1137,36 @@ enum dso_type dso__type(struct dso *dso, struct machine *machine)
 
         return dso__type_fd(fd);
 }
+
+int dso__strerror_load(struct dso *dso, char *buf, size_t buflen)
+{
+        int idx, errnum = dso->load_errno;
+        /*
+         * This must have a same ordering as the enum dso_load_errno.
+         */
+        static const char *dso_load__error_str[] = {
+        "Internal tools/perf/ library error",
+        "Invalid ELF file",
+        "Can not read build id",
+        "Mismatching build id",
+        "Decompression failure",
+        };
+
+        BUG_ON(buflen == 0);
+
+        if (errnum >= 0) {
+                const char *err = strerror_r(errnum, buf, buflen);
+
+                if (err != buf)
+                        scnprintf(buf, buflen, "%s", err);
+
+                return 0;
+        }
+
+        if (errnum <  __DSO_LOAD_ERRNO__START || errnum >= __DSO_LOAD_ERRNO__END)
+                return -1;
+
+        idx = errnum - __DSO_LOAD_ERRNO__START;
+        scnprintf(buf, buflen, "%s", dso_load__error_str[idx]);
+        return 0;
+}
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index ced92841ff97..e0901b4ed8de 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -60,6 +60,31 @@ enum dso_type {
         DSO__TYPE_X32BIT,
 };
 
+enum dso_load_errno {
+        DSO_LOAD_ERRNO__SUCCESS         = 0,
+
+        /*
+         * Choose an arbitrary negative big number not to clash with standard
+         * errno since SUS requires the errno has distinct positive values.
+         * See 'Issue 6' in the link below.
+         *
+         * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
+         */
+        __DSO_LOAD_ERRNO__START         = -10000,
+
+        DSO_LOAD_ERRNO__INTERNAL_ERROR  = __DSO_LOAD_ERRNO__START,
+
+        /* for symsrc__init() */
+        DSO_LOAD_ERRNO__INVALID_ELF,
+        DSO_LOAD_ERRNO__CANNOT_READ_BUILDID,
+        DSO_LOAD_ERRNO__MISMATCHING_BUILDID,
+
+        /* for decompress_kmodule */
+        DSO_LOAD_ERRNO__DECOMPRESSION_FAILURE,
+
+        __DSO_LOAD_ERRNO__END,
+};
+
 #define DSO__SWAP(dso, type, val)                       \
 ({                                                      \
         type ____r = val;                               \
@@ -113,6 +138,7 @@ struct dso {
         enum dso_swap_type      needs_swap;
         enum dso_binary_type    symtab_type;
         enum dso_binary_type    binary_type;
+        enum dso_load_errno     load_errno;
         u8               adjust_symbols:1;
         u8               has_build_id:1;
         u8               has_srcline:1;
@@ -139,7 +165,8 @@ struct dso {
                 u32              status_seen;
                 size_t           file_size;
                 struct list_head open_entry;
-                u64              frame_offset;
+                u64              debug_frame_offset;
+                u64              eh_frame_hdr_offset;
         } data;
 
         union { /* Tool specific area */
@@ -189,11 +216,24 @@ char dso__symtab_origin(const struct dso *dso);
 int dso__read_binary_type_filename(const struct dso *dso, enum dso_binary_type type,
                                    char *root_dir, char *filename, size_t size);
 bool is_supported_compression(const char *ext);
-bool is_kmodule_extension(const char *ext);
-bool is_kernel_module(const char *pathname, bool *compressed);
+bool is_kernel_module(const char *pathname);
 bool decompress_to_file(const char *ext, const char *filename, int output_fd);
 bool dso__needs_decompress(struct dso *dso);
 
+struct kmod_path {
+        char *name;
+        char *ext;
+        bool  comp;
+        bool  kmod;
+};
+
+int __kmod_path__parse(struct kmod_path *m, const char *path,
+                     bool alloc_name, bool alloc_ext);
+
+#define kmod_path__parse(__m, __p)      __kmod_path__parse(__m, __p, false, false)
+#define kmod_path__parse_name(__m, __p) __kmod_path__parse(__m, __p, true , false)
+#define kmod_path__parse_ext(__m, __p)  __kmod_path__parse(__m, __p, false, true)
+
 /*
  * The dso__data_* external interface provides following functions:
  *   dso__data_fd
@@ -249,6 +289,7 @@ struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
                                 const char *short_name, int dso_type);
 
 void dsos__add(struct dsos *dsos, struct dso *dso);
+struct dso *dsos__addnew(struct dsos *dsos, const char *name);
 struct dso *dsos__find(const struct dsos *dsos, const char *name,
                        bool cmp_short);
 struct dso *__dsos__findnew(struct dsos *dsos, const char *name);
@@ -279,4 +320,6 @@ void dso__free_a2l(struct dso *dso);
 
 enum dso_type dso__type(struct dso *dso, struct machine *machine);
 
+int dso__strerror_load(struct dso *dso, char *buf, size_t buflen);
+
 #endif /* __PERF_DSO */
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index cc66c4049e09..c34e024020c7 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -278,6 +278,21 @@ bool die_is_func_def(Dwarf_Die *dw_die)
 }
 
 /**
+ * die_is_func_instance - Ensure that this DIE is an instance of a subprogram
+ * @dw_die: a DIE
+ *
+ * Ensure that this DIE is an instance (which has an entry address).
+ * This returns true if @dw_die is a function instance. If not, you need to
+ * call die_walk_instances() to find actual instances.
+ **/
+bool die_is_func_instance(Dwarf_Die *dw_die)
+{
+        Dwarf_Addr tmp;
+
+        /* Actually gcc optimizes non-inline as like as inlined */
+        return !dwarf_func_inline(dw_die) && dwarf_entrypc(dw_die, &tmp) == 0;
+}
+/**
  * die_get_data_member_location - Get the data-member offset
  * @mb_die: a DIE of a member of a data structure
  * @offs: The offset of the member in the data structure
@@ -786,10 +801,16 @@ static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
 {
         const char *name = data;
 
-        if ((dwarf_tag(die_mem) == DW_TAG_member) &&
-            die_compare_name(die_mem, name))
-                return DIE_FIND_CB_END;
-
+        if (dwarf_tag(die_mem) == DW_TAG_member) {
+                if (die_compare_name(die_mem, name))
+                        return DIE_FIND_CB_END;
+                else if (!dwarf_diename(die_mem)) {     /* Unnamed structure */
+                        Dwarf_Die type_die, tmp_die;
+                        if (die_get_type(die_mem, &type_die) &&
+                            die_find_member(&type_die, name, &tmp_die))
+                                return DIE_FIND_CB_END;
+                }
+        }
         return DIE_FIND_CB_SIBLING;
 }
 
diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
index b4fe90c6cb2d..af7dbcd5f929 100644
--- a/tools/perf/util/dwarf-aux.h
+++ b/tools/perf/util/dwarf-aux.h
@@ -41,6 +41,9 @@ extern int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
 /* Ensure that this DIE is a subprogram and definition (not declaration) */
 extern bool die_is_func_def(Dwarf_Die *dw_die);
 
+/* Ensure that this DIE is an instance of a subprogram */
+extern bool die_is_func_instance(Dwarf_Die *dw_die);
+
 /* Compare diename and tname */
 extern bool die_compare_name(Dwarf_Die *dw_die, const char *tname);
 
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 6c6d044e959a..ff866c4d2e2f 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -49,72 +49,103 @@ static struct perf_sample synth_sample = {
         .period    = 1,
 };
 
-static pid_t perf_event__get_comm_tgid(pid_t pid, char *comm, size_t len)
+/*
+ * Assumes that the first 4095 bytes of /proc/pid/stat contains
+ * the comm, tgid and ppid.
+ */
+static int perf_event__get_comm_ids(pid_t pid, char *comm, size_t len,
+                                    pid_t *tgid, pid_t *ppid)
 {
         char filename[PATH_MAX];
-        char bf[BUFSIZ];
-        FILE *fp;
-        size_t size = 0;
-        pid_t tgid = -1;
+        char bf[4096];
+        int fd;
+        size_t size = 0, n;
+        char *nl, *name, *tgids, *ppids;
+
+        *tgid = -1;
+        *ppid = -1;
 
         snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
 
-        fp = fopen(filename, "r");
-        if (fp == NULL) {
+        fd = open(filename, O_RDONLY);
+        if (fd < 0) {
                 pr_debug("couldn't open %s\n", filename);
-                return 0;
+                return -1;
         }
 
-        while (!comm[0] || (tgid < 0)) {
-                if (fgets(bf, sizeof(bf), fp) == NULL) {
-                        pr_warning("couldn't get COMM and pgid, malformed %s\n",
-                                   filename);
-                        break;
-                }
+        n = read(fd, bf, sizeof(bf) - 1);
+        close(fd);
+        if (n <= 0) {
+                pr_warning("Couldn't get COMM, tigd and ppid for pid %d\n",
+                           pid);
+                return -1;
+        }
+        bf[n] = '\0';
 
-                if (memcmp(bf, "Name:", 5) == 0) {
-                        char *name = bf + 5;
-                        while (*name && isspace(*name))
-                                ++name;
-                        size = strlen(name) - 1;
-                        if (size >= len)
-                                size = len - 1;
-                        memcpy(comm, name, size);
-                        comm[size] = '\0';
-
-                } else if (memcmp(bf, "Tgid:", 5) == 0) {
-                        char *tgids = bf + 5;
-                        while (*tgids && isspace(*tgids))
-                                ++tgids;
-                        tgid = atoi(tgids);
-                }
+        name = strstr(bf, "Name:");
+        tgids = strstr(bf, "Tgid:");
+        ppids = strstr(bf, "PPid:");
+
+        if (name) {
+                name += 5;  /* strlen("Name:") */
+
+                while (*name && isspace(*name))
+                        ++name;
+
+                nl = strchr(name, '\n');
+                if (nl)
+                        *nl = '\0';
+
+                size = strlen(name);
+                if (size >= len)
+                        size = len - 1;
+                memcpy(comm, name, size);
+                comm[size] = '\0';
+        } else {
+                pr_debug("Name: string not found for pid %d\n", pid);
         }
 
-        fclose(fp);
+        if (tgids) {
+                tgids += 5;  /* strlen("Tgid:") */
+                *tgid = atoi(tgids);
+        } else {
+                pr_debug("Tgid: string not found for pid %d\n", pid);
+        }
 
-        return tgid;
+        if (ppids) {
+                ppids += 5;  /* strlen("PPid:") */
+                *ppid = atoi(ppids);
+        } else {
+                pr_debug("PPid: string not found for pid %d\n", pid);
+        }
+
+        return 0;
 }
 
-static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
-                                         union perf_event *event, pid_t pid,
-                                         perf_event__handler_t process,
-                                         struct machine *machine)
+static int perf_event__prepare_comm(union perf_event *event, pid_t pid,
+                                    struct machine *machine,
+                                    pid_t *tgid, pid_t *ppid)
 {
         size_t size;
-        pid_t tgid;
+
+        *ppid = -1;
 
         memset(&event->comm, 0, sizeof(event->comm));
 
-        if (machine__is_host(machine))
-                tgid = perf_event__get_comm_tgid(pid, event->comm.comm,
-                                                 sizeof(event->comm.comm));
-        else
-                tgid = machine->pid;
+        if (machine__is_host(machine)) {
+                if (perf_event__get_comm_ids(pid, event->comm.comm,
+                                             sizeof(event->comm.comm),
+                                             tgid, ppid) != 0) {
+                        return -1;
+                }
+        } else {
+                *tgid = machine->pid;
+        }
 
-        if (tgid < 0)
-                goto out;
+        if (*tgid < 0)
+                return -1;
 
-        event->comm.pid = tgid;
+        event->comm.pid = *tgid;
         event->comm.header.type = PERF_RECORD_COMM;
 
         size = strlen(event->comm.comm) + 1;
@@ -125,23 +156,45 @@ static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
                                 machine->id_hdr_size);
         event->comm.tid = pid;
 
+        return 0;
+}
+
+static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
+                                         union perf_event *event, pid_t pid,
+                                         perf_event__handler_t process,
+                                         struct machine *machine)
+{
+        pid_t tgid, ppid;
+
+        if (perf_event__prepare_comm(event, pid, machine, &tgid, &ppid) != 0)
+                return -1;
+
         if (process(tool, event, &synth_sample, machine) != 0)
                 return -1;
 
-out:
         return tgid;
 }
 
 static int perf_event__synthesize_fork(struct perf_tool *tool,
-                                       union perf_event *event, pid_t pid,
-                                       pid_t tgid, perf_event__handler_t process,
+                                       union perf_event *event,
+                                       pid_t pid, pid_t tgid, pid_t ppid,
+                                       perf_event__handler_t process,
                                        struct machine *machine)
 {
         memset(&event->fork, 0, sizeof(event->fork) + machine->id_hdr_size);
 
-        /* this is really a clone event but we use fork to synthesize it */
-        event->fork.ppid = tgid;
-        event->fork.ptid = tgid;
+        /*
+         * for main thread set parent to ppid from status file. For other
+         * threads set parent pid to main thread. ie., assume main thread
+         * spawns all threads in a process
+        */
+        if (tgid == pid) {
+                event->fork.ppid = ppid;
+                event->fork.ptid = ppid;
+        } else {
+                event->fork.ppid = tgid;
+                event->fork.ptid = tgid;
+        }
         event->fork.pid  = tgid;
         event->fork.tid  = pid;
         event->fork.header.type = PERF_RECORD_FORK;
@@ -333,7 +386,8 @@ static int __event__synthesize_thread(union perf_event *comm_event,
         char filename[PATH_MAX];
         DIR *tasks;
         struct dirent dirent, *next;
-        pid_t tgid;
+        pid_t tgid, ppid;
+        int rc = 0;
 
         /* special case: only send one comm event using passed in pid */
         if (!full) {
@@ -361,34 +415,38 @@ static int __event__synthesize_thread(union perf_event *comm_event,
 
         while (!readdir_r(tasks, &dirent, &next) && next) {
                 char *end;
-                int rc = 0;
                 pid_t _pid;
 
                 _pid = strtol(dirent.d_name, &end, 10);
                 if (*end)
                         continue;
 
-                tgid = perf_event__synthesize_comm(tool, comm_event, _pid,
-                                                   process, machine);
-                if (tgid == -1)
-                        return -1;
+                rc = -1;
+                if (perf_event__prepare_comm(comm_event, _pid, machine,
+                                             &tgid, &ppid) != 0)
+                        break;
 
+                if (perf_event__synthesize_fork(tool, fork_event, _pid, tgid,
+                                                ppid, process, machine) < 0)
+                        break;
+                /*
+                 * Send the prepared comm event
+                 */
+                if (process(tool, comm_event, &synth_sample, machine) != 0)
+                        break;
+
+                rc = 0;
                 if (_pid == pid) {
                         /* process the parent's maps too */
                         rc = perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
                                                 process, machine, mmap_data);
-                } else {
-                        /* only fork the tid's map, to save time */
-                        rc = perf_event__synthesize_fork(tool, fork_event, _pid, tgid,
-                                                 process, machine);
+                        if (rc)
+                                break;
                 }
-
-                if (rc)
-                        return rc;
         }
 
         closedir(tasks);
-        return 0;
+        return rc;
 }
 
 int perf_event__synthesize_thread_map(struct perf_tool *tool,
@@ -615,7 +673,7 @@ size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
         else
                 s = "";
 
-        return fprintf(fp, "%s: %s:%d\n", s, event->comm.comm, event->comm.tid);
+        return fprintf(fp, "%s: %s:%d/%d\n", s, event->comm.comm, event->comm.pid, event->comm.tid);
 }
 
 int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index c4ffe2bd0738..09b9e8d3fcf7 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -242,7 +242,6 @@ struct events_stats {
         u32 nr_invalid_chains;
         u32 nr_unknown_id;
         u32 nr_unprocessable_samples;
-        u32 nr_unordered_events;
 };
 
 struct attr_event {
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 28b8ce86bf12..080be93eea96 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -7,7 +7,6 @@
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "util.h"
-#include <api/fs/debugfs.h>
 #include <api/fs/fs.h>
 #include <poll.h>
 #include "cpumap.h"
@@ -635,8 +634,8 @@ static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 {
         struct perf_mmap *md = &evlist->mmap[idx];
-        unsigned int head = perf_mmap__read_head(md);
-        unsigned int old = md->prev;
+        u64 head = perf_mmap__read_head(md);
+        u64 old = md->prev;
         unsigned char *data = md->base + page_size;
         union perf_event *event = NULL;
 
@@ -696,7 +695,7 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 
 static bool perf_mmap__empty(struct perf_mmap *md)
 {
-        return perf_mmap__read_head(md) != md->prev;
+        return perf_mmap__read_head(md) == md->prev;
 }
 
 static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx)
@@ -717,7 +716,7 @@ void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
         struct perf_mmap *md = &evlist->mmap[idx];
 
         if (!evlist->overwrite) {
-                unsigned int old = md->prev;
+                u64 old = md->prev;
 
                 perf_mmap__write_tail(md, old);
         }
@@ -1051,7 +1050,7 @@ out_delete_threads:
         return -1;
 }
 
-int perf_evlist__apply_filters(struct perf_evlist *evlist)
+int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel)
 {
         struct perf_evsel *evsel;
         int err = 0;
@@ -1063,8 +1062,10 @@ int perf_evlist__apply_filters(struct perf_evlist *evlist)
                         continue;
 
                 err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
-                if (err)
+                if (err) {
+                        *err_evsel = evsel;
                         break;
+                }
         }
 
         return err;
@@ -1086,6 +1087,38 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
         return err;
 }
 
+int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids)
+{
+        char *filter;
+        int ret = -1;
+        size_t i;
+
+        for (i = 0; i < npids; ++i) {
+                if (i == 0) {
+                        if (asprintf(&filter, "common_pid != %d", pids[i]) < 0)
+                                return -1;
+                } else {
+                        char *tmp;
+
+                        if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0)
+                                goto out_free;
+
+                        free(filter);
+                        filter = tmp;
+                }
+        }
+
+        ret = perf_evlist__set_filter(evlist, filter);
+out_free:
+        free(filter);
+        return ret;
+}
+
+int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid)
+{
+        return perf_evlist__set_filter_pids(evlist, 1, &pid);
+}
+
 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
 {
         struct perf_evsel *pos;
@@ -1329,7 +1362,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *tar
                  * writing exactly one byte, in workload.cork_fd, usually via
                  * perf_evlist__start_workload().
                  *
-                 * For cancelling the workload without actuallin running it,
+                 * For cancelling the workload without actually running it,
                  * the parent will just close workload.cork_fd, without writing
                  * anything, i.e. read will return zero and we just exit()
                  * here.
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index e99a67632831..b5cce95d644e 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -27,7 +27,7 @@ struct perf_mmap {
         void             *base;
         int              mask;
         int              refcnt;
-        unsigned int     prev;
+        u64              prev;
         char             event_copy[PERF_SAMPLE_MAX_SIZE] __attribute__((aligned(8)));
 };
 
@@ -51,6 +51,7 @@ struct perf_evlist {
         struct thread_map *threads;
         struct cpu_map    *cpus;
         struct perf_evsel *selected;
+        struct events_stats stats;
 };
 
 struct perf_evsel_str_handler {
@@ -77,6 +78,8 @@ int perf_evlist__add_newtp(struct perf_evlist *evlist,
                            const char *sys, const char *name, void *handler);
 
 int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter);
+int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid);
+int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids);
 
 struct perf_evsel *
 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id);
@@ -149,7 +152,7 @@ static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
 }
 
 int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target);
-int perf_evlist__apply_filters(struct perf_evlist *evlist);
+int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel);
 
 void __perf_evlist__set_leader(struct list_head *list);
 void perf_evlist__set_leader(struct perf_evlist *evlist);
@@ -186,16 +189,15 @@ size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp);
 int perf_evlist__strerror_open(struct perf_evlist *evlist, int err, char *buf, size_t size);
 int perf_evlist__strerror_mmap(struct perf_evlist *evlist, int err, char *buf, size_t size);
 
-static inline unsigned int perf_mmap__read_head(struct perf_mmap *mm)
+static inline u64 perf_mmap__read_head(struct perf_mmap *mm)
 {
         struct perf_event_mmap_page *pc = mm->base;
-        int head = ACCESS_ONCE(pc->data_head);
+        u64 head = ACCESS_ONCE(pc->data_head);
         rmb();
         return head;
 }
 
-static inline void perf_mmap__write_tail(struct perf_mmap *md,
-                                         unsigned long tail)
+static inline void perf_mmap__write_tail(struct perf_mmap *md, u64 tail)
 {
         struct perf_event_mmap_page *pc = md->base;
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index ea51a90e20a0..33e3fd8c2e68 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -32,8 +32,12 @@ static struct {
         bool exclude_guest;
         bool mmap2;
         bool cloexec;
+        bool clockid;
+        bool clockid_wrong;
 } perf_missing_features;
 
+static clockid_t clockid;
+
 static int perf_evsel__no_extra_init(struct perf_evsel *evsel __maybe_unused)
 {
         return 0;
@@ -537,13 +541,30 @@ int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size)
 }
 
 static void
-perf_evsel__config_callgraph(struct perf_evsel *evsel)
+perf_evsel__config_callgraph(struct perf_evsel *evsel,
+                             struct record_opts *opts)
 {
         bool function = perf_evsel__is_function_event(evsel);
         struct perf_event_attr *attr = &evsel->attr;
 
         perf_evsel__set_sample_bit(evsel, CALLCHAIN);
 
+        if (callchain_param.record_mode == CALLCHAIN_LBR) {
+                if (!opts->branch_stack) {
+                        if (attr->exclude_user) {
+                                pr_warning("LBR callstack option is only available "
+                                           "to get user callchain information. "
+                                           "Falling back to framepointers.\n");
+                        } else {
+                                perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
+                                attr->branch_sample_type = PERF_SAMPLE_BRANCH_USER |
+                                                        PERF_SAMPLE_BRANCH_CALL_STACK;
+                        }
+                } else
+                         pr_warning("Cannot use LBR callstack with branch stack. "
+                                    "Falling back to framepointers.\n");
+        }
+
         if (callchain_param.record_mode == CALLCHAIN_DWARF) {
                 if (!function) {
                         perf_evsel__set_sample_bit(evsel, REGS_USER);
@@ -667,7 +688,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
                 evsel->attr.exclude_callchain_user = 1;
 
         if (callchain_param.enabled && !evsel->no_aux_samples)
-                perf_evsel__config_callgraph(evsel);
+                perf_evsel__config_callgraph(evsel, opts);
 
         if (opts->sample_intr_regs) {
                 attr->sample_regs_intr = PERF_REGS_MASK;
@@ -717,6 +738,12 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
         if (opts->sample_transaction)
                 perf_evsel__set_sample_bit(evsel, TRANSACTION);
 
+        if (opts->running_time) {
+                evsel->attr.read_format |=
+                        PERF_FORMAT_TOTAL_TIME_ENABLED |
+                        PERF_FORMAT_TOTAL_TIME_RUNNING;
+        }
+
         /*
          * XXX see the function comment above
          *
@@ -738,6 +765,12 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
                 attr->disabled = 0;
                 attr->enable_on_exec = 0;
         }
+
+        clockid = opts->clockid;
+        if (opts->use_clockid) {
+                attr->use_clockid = 1;
+                attr->clockid = opts->clockid;
+        }
 }
 
 static int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
@@ -978,67 +1011,126 @@ static int get_group_fd(struct perf_evsel *evsel, int cpu, int thread)
         return fd;
 }
 
-#define __PRINT_ATTR(fmt, cast, field)  \
-        fprintf(fp, "  %-19s "fmt"\n", #field, cast attr->field)
-
-#define PRINT_ATTR_U32(field)  __PRINT_ATTR("%u" , , field)
-#define PRINT_ATTR_X32(field)  __PRINT_ATTR("%#x", , field)
-#define PRINT_ATTR_U64(field)  __PRINT_ATTR("%" PRIu64, (uint64_t), field)
-#define PRINT_ATTR_X64(field)  __PRINT_ATTR("%#"PRIx64, (uint64_t), field)
-
-#define PRINT_ATTR2N(name1, field1, name2, field2)      \
-        fprintf(fp, "  %-19s %u    %-19s %u\n",         \
-        name1, attr->field1, name2, attr->field2)
-
-#define PRINT_ATTR2(field1, field2) \
-        PRINT_ATTR2N(#field1, field1, #field2, field2)
-
-static size_t perf_event_attr__fprintf(struct perf_event_attr *attr, FILE *fp)
-{
-        size_t ret = 0;
-
-        ret += fprintf(fp, "%.60s\n", graph_dotted_line);
-        ret += fprintf(fp, "perf_event_attr:\n");
-
-        ret += PRINT_ATTR_U32(type);
-        ret += PRINT_ATTR_U32(size);
-        ret += PRINT_ATTR_X64(config);
-        ret += PRINT_ATTR_U64(sample_period);
-        ret += PRINT_ATTR_U64(sample_freq);
-        ret += PRINT_ATTR_X64(sample_type);
-        ret += PRINT_ATTR_X64(read_format);
-
-        ret += PRINT_ATTR2(disabled, inherit);
-        ret += PRINT_ATTR2(pinned, exclusive);
-        ret += PRINT_ATTR2(exclude_user, exclude_kernel);
-        ret += PRINT_ATTR2(exclude_hv, exclude_idle);
-        ret += PRINT_ATTR2(mmap, comm);
-        ret += PRINT_ATTR2(mmap2, comm_exec);
-        ret += PRINT_ATTR2(freq, inherit_stat);
-        ret += PRINT_ATTR2(enable_on_exec, task);
-        ret += PRINT_ATTR2(watermark, precise_ip);
-        ret += PRINT_ATTR2(mmap_data, sample_id_all);
-        ret += PRINT_ATTR2(exclude_host, exclude_guest);
-        ret += PRINT_ATTR2N("excl.callchain_kern", exclude_callchain_kernel,
-                            "excl.callchain_user", exclude_callchain_user);
-
-        ret += PRINT_ATTR_U32(wakeup_events);
-        ret += PRINT_ATTR_U32(wakeup_watermark);
-        ret += PRINT_ATTR_X32(bp_type);
-        ret += PRINT_ATTR_X64(bp_addr);
-        ret += PRINT_ATTR_X64(config1);
-        ret += PRINT_ATTR_U64(bp_len);
-        ret += PRINT_ATTR_X64(config2);
-        ret += PRINT_ATTR_X64(branch_sample_type);
-        ret += PRINT_ATTR_X64(sample_regs_user);
-        ret += PRINT_ATTR_U32(sample_stack_user);
-        ret += PRINT_ATTR_X64(sample_regs_intr);
-
-        ret += fprintf(fp, "%.60s\n", graph_dotted_line);
+struct bit_names {
+        int bit;
+        const char *name;
+};
+
+static void __p_bits(char *buf, size_t size, u64 value, struct bit_names *bits)
+{
+        bool first_bit = true;
+        int i = 0;
+
+        do {
+                if (value & bits[i].bit) {
+                        buf += scnprintf(buf, size, "%s%s", first_bit ? "" : "|", bits[i].name);
+                        first_bit = false;
+                }
+        } while (bits[++i].name != NULL);
+}
+
+static void __p_sample_type(char *buf, size_t size, u64 value)
+{
+#define bit_name(n) { PERF_SAMPLE_##n, #n }
+        struct bit_names bits[] = {
+                bit_name(IP), bit_name(TID), bit_name(TIME), bit_name(ADDR),
+                bit_name(READ), bit_name(CALLCHAIN), bit_name(ID), bit_name(CPU),
+                bit_name(PERIOD), bit_name(STREAM_ID), bit_name(RAW),
+                bit_name(BRANCH_STACK), bit_name(REGS_USER), bit_name(STACK_USER),
+                bit_name(IDENTIFIER), bit_name(REGS_INTR),
+                { .name = NULL, }
+        };
+#undef bit_name
+        __p_bits(buf, size, value, bits);
+}
+
+static void __p_read_format(char *buf, size_t size, u64 value)
+{
+#define bit_name(n) { PERF_FORMAT_##n, #n }
+        struct bit_names bits[] = {
+                bit_name(TOTAL_TIME_ENABLED), bit_name(TOTAL_TIME_RUNNING),
+                bit_name(ID), bit_name(GROUP),
+                { .name = NULL, }
+        };
+#undef bit_name
+        __p_bits(buf, size, value, bits);
+}
+
+#define BUF_SIZE                1024
+
+#define p_hex(val)              snprintf(buf, BUF_SIZE, "%"PRIx64, (uint64_t)(val))
+#define p_unsigned(val)         snprintf(buf, BUF_SIZE, "%"PRIu64, (uint64_t)(val))
+#define p_signed(val)           snprintf(buf, BUF_SIZE, "%"PRId64, (int64_t)(val))
+#define p_sample_type(val)      __p_sample_type(buf, BUF_SIZE, val)
+#define p_read_format(val)      __p_read_format(buf, BUF_SIZE, val)
+
+#define PRINT_ATTRn(_n, _f, _p)                         \
+do {                                                    \
+        if (attr->_f) {                                 \
+                _p(attr->_f);                           \
+                ret += attr__fprintf(fp, _n, buf, priv);\
+        }                                               \
+} while (0)
+
+#define PRINT_ATTRf(_f, _p)     PRINT_ATTRn(#_f, _f, _p)
+
+int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
+                             attr__fprintf_f attr__fprintf, void *priv)
+{
+        char buf[BUF_SIZE];
+        int ret = 0;
+
+        PRINT_ATTRf(type, p_unsigned);
+        PRINT_ATTRf(size, p_unsigned);
+        PRINT_ATTRf(config, p_hex);
+        PRINT_ATTRn("{ sample_period, sample_freq }", sample_period, p_unsigned);
+        PRINT_ATTRf(sample_type, p_sample_type);
+        PRINT_ATTRf(read_format, p_read_format);
+
+        PRINT_ATTRf(disabled, p_unsigned);
+        PRINT_ATTRf(inherit, p_unsigned);
+        PRINT_ATTRf(pinned, p_unsigned);
+        PRINT_ATTRf(exclusive, p_unsigned);
+        PRINT_ATTRf(exclude_user, p_unsigned);
+        PRINT_ATTRf(exclude_kernel, p_unsigned);
+        PRINT_ATTRf(exclude_hv, p_unsigned);
+        PRINT_ATTRf(exclude_idle, p_unsigned);
+        PRINT_ATTRf(mmap, p_unsigned);
+        PRINT_ATTRf(comm, p_unsigned);
+        PRINT_ATTRf(freq, p_unsigned);
+        PRINT_ATTRf(inherit_stat, p_unsigned);
+        PRINT_ATTRf(enable_on_exec, p_unsigned);
+        PRINT_ATTRf(task, p_unsigned);
+        PRINT_ATTRf(watermark, p_unsigned);
+        PRINT_ATTRf(precise_ip, p_unsigned);
+        PRINT_ATTRf(mmap_data, p_unsigned);
+        PRINT_ATTRf(sample_id_all, p_unsigned);
+        PRINT_ATTRf(exclude_host, p_unsigned);
+        PRINT_ATTRf(exclude_guest, p_unsigned);
+        PRINT_ATTRf(exclude_callchain_kernel, p_unsigned);
+        PRINT_ATTRf(exclude_callchain_user, p_unsigned);
+        PRINT_ATTRf(mmap2, p_unsigned);
+        PRINT_ATTRf(comm_exec, p_unsigned);
+        PRINT_ATTRf(use_clockid, p_unsigned);
+
+        PRINT_ATTRn("{ wakeup_events, wakeup_watermark }", wakeup_events, p_unsigned);
+        PRINT_ATTRf(bp_type, p_unsigned);
+        PRINT_ATTRn("{ bp_addr, config1 }", bp_addr, p_hex);
+        PRINT_ATTRn("{ bp_len, config2 }", bp_len, p_hex);
+        PRINT_ATTRf(sample_regs_user, p_hex);
+        PRINT_ATTRf(sample_stack_user, p_unsigned);
+        PRINT_ATTRf(clockid, p_signed);
+        PRINT_ATTRf(sample_regs_intr, p_hex);
 
         return ret;
 }
 
+static int __open_attr__fprintf(FILE *fp, const char *name, const char *val,
+                                void *priv __attribute__((unused)))
+{
+        return fprintf(fp, "  %-32s %s\n", name, val);
+}
+
 static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                               struct thread_map *threads)
 {
@@ -1062,6 +1154,12 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         }
 
 fallback_missing_features:
+        if (perf_missing_features.clockid_wrong)
+                evsel->attr.clockid = CLOCK_MONOTONIC; /* should always work */
+        if (perf_missing_features.clockid) {
+                evsel->attr.use_clockid = 0;
+                evsel->attr.clockid = 0;
+        }
         if (perf_missing_features.cloexec)
                 flags &= ~(unsigned long)PERF_FLAG_FD_CLOEXEC;
         if (perf_missing_features.mmap2)
@@ -1072,8 +1170,12 @@ retry_sample_id:
         if (perf_missing_features.sample_id_all)
                 evsel->attr.sample_id_all = 0;
 
-        if (verbose >= 2)
-                perf_event_attr__fprintf(&evsel->attr, stderr);
+        if (verbose >= 2) {
+                fprintf(stderr, "%.60s\n", graph_dotted_line);
+                fprintf(stderr, "perf_event_attr:\n");
+                perf_event_attr__fprintf(stderr, &evsel->attr, __open_attr__fprintf, NULL);
+                fprintf(stderr, "%.60s\n", graph_dotted_line);
+        }
 
         for (cpu = 0; cpu < cpus->nr; cpu++) {
 
@@ -1099,6 +1201,17 @@ retry_open:
                                 goto try_fallback;
                         }
                         set_rlimit = NO_CHANGE;
+
+                        /*
+                         * If we succeeded but had to kill clockid, fail and
+                         * have perf_evsel__open_strerror() print us a nice
+                         * error.
+                         */
+                        if (perf_missing_features.clockid ||
+                            perf_missing_features.clockid_wrong) {
+                                err = -EINVAL;
+                                goto out_close;
+                        }
                 }
         }
 
@@ -1132,7 +1245,17 @@ try_fallback:
         if (err != -EINVAL || cpu > 0 || thread > 0)
                 goto out_close;
 
-        if (!perf_missing_features.cloexec && (flags & PERF_FLAG_FD_CLOEXEC)) {
+        /*
+         * Must probe features in the order they were added to the
+         * perf_event_attr interface.
+         */
+        if (!perf_missing_features.clockid_wrong && evsel->attr.use_clockid) {
+                perf_missing_features.clockid_wrong = true;
+                goto fallback_missing_features;
+        } else if (!perf_missing_features.clockid && evsel->attr.use_clockid) {
+                perf_missing_features.clockid = true;
+                goto fallback_missing_features;
+        } else if (!perf_missing_features.cloexec && (flags & PERF_FLAG_FD_CLOEXEC)) {
                 perf_missing_features.cloexec = true;
                 goto fallback_missing_features;
         } else if (!perf_missing_features.mmap2 && evsel->attr.mmap2) {
@@ -1892,7 +2015,7 @@ u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                 value = *(u32 *)ptr;
                 break;
         case 8:
-                value = *(u64 *)ptr;
+                memcpy(&value, ptr, sizeof(u64));
                 break;
         default:
                 return 0;
@@ -1933,62 +2056,9 @@ static int comma_fprintf(FILE *fp, bool *first, const char *fmt, ...)
         return ret;
 }
 
-static int __if_fprintf(FILE *fp, bool *first, const char *field, u64 value)
-{
-        if (value == 0)
-                return 0;
-
-        return comma_fprintf(fp, first, " %s: %" PRIu64, field, value);
-}
-
-#define if_print(field) printed += __if_fprintf(fp, &first, #field, evsel->attr.field)
-
-struct bit_names {
-        int bit;
-        const char *name;
-};
-
-static int bits__fprintf(FILE *fp, const char *field, u64 value,
-                         struct bit_names *bits, bool *first)
-{
-        int i = 0, printed = comma_fprintf(fp, first, " %s: ", field);
-        bool first_bit = true;
-
-        do {
-                if (value & bits[i].bit) {
-                        printed += fprintf(fp, "%s%s", first_bit ? "" : "|", bits[i].name);
-                        first_bit = false;
-                }
-        } while (bits[++i].name != NULL);
-
-        return printed;
-}
-
-static int sample_type__fprintf(FILE *fp, bool *first, u64 value)
-{
-#define bit_name(n) { PERF_SAMPLE_##n, #n }
-        struct bit_names bits[] = {
-                bit_name(IP), bit_name(TID), bit_name(TIME), bit_name(ADDR),
-                bit_name(READ), bit_name(CALLCHAIN), bit_name(ID), bit_name(CPU),
-                bit_name(PERIOD), bit_name(STREAM_ID), bit_name(RAW),
-                bit_name(BRANCH_STACK), bit_name(REGS_USER), bit_name(STACK_USER),
-                bit_name(IDENTIFIER), bit_name(REGS_INTR),
-                { .name = NULL, }
-        };
-#undef bit_name
-        return bits__fprintf(fp, "sample_type", value, bits, first);
-}
-
-static int read_format__fprintf(FILE *fp, bool *first, u64 value)
+static int __print_attr__fprintf(FILE *fp, const char *name, const char *val, void *priv)
 {
-#define bit_name(n) { PERF_FORMAT_##n, #n }
-        struct bit_names bits[] = {
-                bit_name(TOTAL_TIME_ENABLED), bit_name(TOTAL_TIME_RUNNING),
-                bit_name(ID), bit_name(GROUP),
-                { .name = NULL, }
-        };
-#undef bit_name
-        return bits__fprintf(fp, "read_format", value, bits, first);
+        return comma_fprintf(fp, (bool *)priv, " %s: %s", name, val);
 }
 
 int perf_evsel__fprintf(struct perf_evsel *evsel,
@@ -2017,47 +2087,13 @@ int perf_evsel__fprintf(struct perf_evsel *evsel,
 
         printed += fprintf(fp, "%s", perf_evsel__name(evsel));
 
-        if (details->verbose || details->freq) {
+        if (details->verbose) {
+                printed += perf_event_attr__fprintf(fp, &evsel->attr,
+                                                    __print_attr__fprintf, &first);
+        } else if (details->freq) {
                 printed += comma_fprintf(fp, &first, " sample_freq=%" PRIu64,
                                          (u64)evsel->attr.sample_freq);
         }
-
-        if (details->verbose) {
-                if_print(type);
-                if_print(config);
-                if_print(config1);
-                if_print(config2);
-                if_print(size);
-                printed += sample_type__fprintf(fp, &first, evsel->attr.sample_type);
-                if (evsel->attr.read_format)
-                        printed += read_format__fprintf(fp, &first, evsel->attr.read_format);
-                if_print(disabled);
-                if_print(inherit);
-                if_print(pinned);
-                if_print(exclusive);
-                if_print(exclude_user);
-                if_print(exclude_kernel);
-                if_print(exclude_hv);
-                if_print(exclude_idle);
-                if_print(mmap);
-                if_print(mmap2);
-                if_print(comm);
-                if_print(comm_exec);
-                if_print(freq);
-                if_print(inherit_stat);
-                if_print(enable_on_exec);
-                if_print(task);
-                if_print(watermark);
-                if_print(precise_ip);
-                if_print(mmap_data);
-                if_print(sample_id_all);
-                if_print(exclude_host);
-                if_print(exclude_guest);
-                if_print(__reserved_1);
-                if_print(wakeup_events);
-                if_print(bp_type);
-                if_print(branch_sample_type);
-        }
 out:
         fputc('\n', fp);
         return ++printed;
@@ -2135,6 +2171,12 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
         "The PMU counters are busy/taken by another profiler.\n"
         "We found oprofile daemon running, please stop it and try again.");
                 break;
+        case EINVAL:
+                if (perf_missing_features.clockid)
+                        return scnprintf(msg, size, "clockid feature not supported.");
+                if (perf_missing_features.clockid_wrong)
+                        return scnprintf(msg, size, "wrong clockid (%d).", clockid);
+                break;
         default:
                 break;
         }
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 38622747d130..e486151b0308 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -335,6 +335,7 @@ struct perf_attr_details {
         bool freq;
         bool verbose;
         bool event_group;
+        bool force;
 };
 
 int perf_evsel__fprintf(struct perf_evsel *evsel,
@@ -355,4 +356,14 @@ for ((_evsel) = list_entry((_leader)->node.next, struct perf_evsel, node); 	\
      (_evsel) && (_evsel)->leader == (_leader);                                 \
      (_evsel) = list_entry((_evsel)->node.next, struct perf_evsel, node))
 
+static inline bool has_branch_callstack(struct perf_evsel *evsel)
+{
+        return evsel->attr.branch_sample_type & PERF_SAMPLE_BRANCH_CALL_STACK;
+}
+
+typedef int (*attr__fprintf_f)(FILE *, const char *, const char *, void *);
+
+int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
+                             attr__fprintf_f attr__fprintf, void *priv);
+
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 1f407f7352a7..918fd8ae2d80 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1055,6 +1055,12 @@ error:
         goto out;
 }
 
+static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
+                                void *priv __attribute__((unused)))
+{
+        return fprintf(fp, ", %s = %s", name, val);
+}
+
 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
 {
         struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
@@ -1069,26 +1075,6 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
         for (evsel = events; evsel->attr.size; evsel++) {
                 fprintf(fp, "# event : name = %s, ", evsel->name);
 
-                fprintf(fp, "type = %d, config = 0x%"PRIx64
-                            ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
-                                evsel->attr.type,
-                                (u64)evsel->attr.config,
-                                (u64)evsel->attr.config1,
-                                (u64)evsel->attr.config2);
-
-                fprintf(fp, ", excl_usr = %d, excl_kern = %d",
-                                evsel->attr.exclude_user,
-                                evsel->attr.exclude_kernel);
-
-                fprintf(fp, ", excl_host = %d, excl_guest = %d",
-                                evsel->attr.exclude_host,
-                                evsel->attr.exclude_guest);
-
-                fprintf(fp, ", precise_ip = %d", evsel->attr.precise_ip);
-
-                fprintf(fp, ", attr_mmap2 = %d", evsel->attr.mmap2);
-                fprintf(fp, ", attr_mmap  = %d", evsel->attr.mmap);
-                fprintf(fp, ", attr_mmap_data = %d", evsel->attr.mmap_data);
                 if (evsel->ids) {
                         fprintf(fp, ", id = {");
                         for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
@@ -1099,6 +1085,8 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
                         fprintf(fp, " }");
                 }
 
+                perf_event_attr__fprintf(fp, &evsel->attr, __desc_attr__fprintf, NULL);
+
                 fputc('\n', fp);
         }
 
@@ -1266,7 +1254,7 @@ static int __event_process_build_id(struct build_id_event *bev,
 
                 dso__set_build_id(dso, &bev->build_id);
 
-                if (!is_kernel_module(filename, NULL))
+                if (!is_kernel_module(filename))
                         dso->kernel = dso_type;
 
                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
@@ -2516,8 +2504,11 @@ int perf_session__read_header(struct perf_session *session)
                 if (read_attr(fd, header, &f_attr) < 0)
                         goto out_errno;
 
-                if (header->needs_swap)
+                if (header->needs_swap) {
+                        f_attr.ids.size   = bswap_64(f_attr.ids.size);
+                        f_attr.ids.offset = bswap_64(f_attr.ids.offset);
                         perf_event__attr_swap(&f_attr.attr);
+                }
 
                 tmp = lseek(fd, 0, SEEK_CUR);
                 evsel = perf_evsel__new(&f_attr.attr);
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 70b48a65064c..cc22b9158b93 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -263,15 +263,9 @@ void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
         while (next) {
                 n = rb_entry(next, struct hist_entry, rb_node);
                 next = rb_next(&n->rb_node);
-                /*
-                 * We may be annotating this, for instance, so keep it here in
-                 * case some it gets new samples, we'll eventually free it when
-                 * the user stops browsing and it agains gets fully decayed.
-                 */
                 if (((zap_user && n->level == '.') ||
                      (zap_kernel && n->level != '.') ||
-                     hists__decay_entry(hists, n)) &&
-                    !n->used) {
+                     hists__decay_entry(hists, n))) {
                         hists__delete_entry(hists, n);
                 }
         }
@@ -355,6 +349,7 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template,
                         callchain_init(he->callchain);
 
                 INIT_LIST_HEAD(&he->pairs.node);
+                thread__get(he->thread);
         }
 
         return he;
@@ -941,6 +936,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
 
 void hist_entry__delete(struct hist_entry *he)
 {
+        thread__zput(he->thread);
         zfree(&he->branch_info);
         zfree(&he->mem_info);
         zfree(&he->stat_acc);
@@ -1169,6 +1165,7 @@ static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h
         /* force fold unfiltered entry for simplicity */
         h->ms.unfolded = false;
         h->row_offset = 0;
+        h->nr_rows = 0;
 
         hists->stats.nr_non_filtered_samples += h->stat.nr_events;
 
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 2b690d028907..9f31b89a527a 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -60,7 +60,7 @@ struct hists {
         struct rb_root          entries_collapsed;
         u64                     nr_entries;
         u64                     nr_non_filtered_entries;
-        const struct thread     *thread_filter;
+        struct thread           *thread_filter;
         const struct dso        *dso_filter;
         const char              *uid_filter_str;
         const char              *symbol_filter_str;
@@ -303,6 +303,9 @@ struct hist_browser_timer {
 
 #ifdef HAVE_SLANG_SUPPORT
 #include "../ui/keysyms.h"
+int map_symbol__tui_annotate(struct map_symbol *ms, struct perf_evsel *evsel,
+                             struct hist_browser_timer *hbt);
+
 int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
                              struct hist_browser_timer *hbt);
 
@@ -321,6 +324,12 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
 {
         return 0;
 }
+static inline int map_symbol__tui_annotate(struct map_symbol *ms __maybe_unused,
+                                           struct perf_evsel *evsel __maybe_unused,
+                                           struct hist_browser_timer *hbt __maybe_unused)
+{
+        return 0;
+}
 
 static inline int hist_entry__tui_annotate(struct hist_entry *he __maybe_unused,
                                            struct perf_evsel *evsel __maybe_unused,
diff --git a/tools/perf/util/include/asm/alternative-asm.h b/tools/perf/util/include/asm/alternative-asm.h
index 6789d788d494..3a3a0f16456a 100644
--- a/tools/perf/util/include/asm/alternative-asm.h
+++ b/tools/perf/util/include/asm/alternative-asm.h
@@ -4,5 +4,6 @@
 /* Just disable it so we can build arch/x86/lib/memcpy_64.S for perf bench: */
 
 #define altinstruction_entry #
+#define ALTERNATIVE_2 #
 
 #endif
diff --git a/tools/perf/util/kvm-stat.h b/tools/perf/util/kvm-stat.h
index cf1d7913783b..ae825d4ec110 100644
--- a/tools/perf/util/kvm-stat.h
+++ b/tools/perf/util/kvm-stat.h
@@ -99,6 +99,7 @@ struct perf_kvm_stat {
         int timerfd;
         unsigned int display_time;
         bool live;
+        bool force;
 };
 
 struct kvm_reg_events_ops {
diff --git a/tools/perf/util/lzma.c b/tools/perf/util/lzma.c
new file mode 100644
index 000000000000..95a1acb61245
--- /dev/null
+++ b/tools/perf/util/lzma.c
@@ -0,0 +1,95 @@
+#include <lzma.h>
+#include <stdio.h>
+#include <linux/compiler.h>
+#include "util.h"
+#include "debug.h"
+
+#define BUFSIZE 8192
+
+static const char *lzma_strerror(lzma_ret ret)
+{
+        switch ((int) ret) {
+        case LZMA_MEM_ERROR:
+                return "Memory allocation failed";
+        case LZMA_OPTIONS_ERROR:
+                return "Unsupported decompressor flags";
+        case LZMA_FORMAT_ERROR:
+                return "The input is not in the .xz format";
+        case LZMA_DATA_ERROR:
+                return "Compressed file is corrupt";
+        case LZMA_BUF_ERROR:
+                return "Compressed file is truncated or otherwise corrupt";
+        default:
+                return "Unknown error, possibly a bug";
+        }
+}
+
+int lzma_decompress_to_file(const char *input, int output_fd)
+{
+        lzma_action action = LZMA_RUN;
+        lzma_stream strm   = LZMA_STREAM_INIT;
+        lzma_ret ret;
+
+        u8 buf_in[BUFSIZE];
+        u8 buf_out[BUFSIZE];
+        FILE *infile;
+
+        infile = fopen(input, "rb");
+        if (!infile) {
+                pr_err("lzma: fopen failed on %s: '%s'\n",
+                       input, strerror(errno));
+                return -1;
+        }
+
+        ret = lzma_stream_decoder(&strm, UINT64_MAX, LZMA_CONCATENATED);
+        if (ret != LZMA_OK) {
+                pr_err("lzma: lzma_stream_decoder failed %s (%d)\n",
+                        lzma_strerror(ret), ret);
+                return -1;
+        }
+
+        strm.next_in   = NULL;
+        strm.avail_in  = 0;
+        strm.next_out  = buf_out;
+        strm.avail_out = sizeof(buf_out);
+
+        while (1) {
+                if (strm.avail_in == 0 && !feof(infile)) {
+                        strm.next_in  = buf_in;
+                        strm.avail_in = fread(buf_in, 1, sizeof(buf_in), infile);
+
+                        if (ferror(infile)) {
+                                pr_err("lzma: read error: %s\n", strerror(errno));
+                                return -1;
+                        }
+
+                        if (feof(infile))
+                                action = LZMA_FINISH;
+                }
+
+                ret = lzma_code(&strm, action);
+
+                if (strm.avail_out == 0 || ret == LZMA_STREAM_END) {
+                        ssize_t write_size = sizeof(buf_out) - strm.avail_out;
+
+                        if (writen(output_fd, buf_out, write_size) != write_size) {
+                                pr_err("lzma: write error: %s\n", strerror(errno));
+                                return -1;
+                        }
+
+                        strm.next_out  = buf_out;
+                        strm.avail_out = sizeof(buf_out);
+                }
+
+                if (ret != LZMA_OK) {
+                        if (ret == LZMA_STREAM_END)
+                                return 0;
+
+                        pr_err("lzma: failed %s\n", lzma_strerror(ret));
+                        return -1;
+                }
+        }
+
+        fclose(infile);
+        return 0;
+}
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 1bca3a9f2b16..527e032e24f6 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -89,16 +89,6 @@ static void dsos__delete(struct dsos *dsos)
         }
 }
 
-void machine__delete_dead_threads(struct machine *machine)
-{
-        struct thread *n, *t;
-
-        list_for_each_entry_safe(t, n, &machine->dead_threads, node) {
-                list_del(&t->node);
-                thread__delete(t);
-        }
-}
-
 void machine__delete_threads(struct machine *machine)
 {
         struct rb_node *nd = rb_first(&machine->threads);
@@ -106,9 +96,8 @@ void machine__delete_threads(struct machine *machine)
         while (nd) {
                 struct thread *t = rb_entry(nd, struct thread, rb_node);
 
-                rb_erase(&t->rb_node, &machine->threads);
                 nd = rb_next(nd);
-                thread__delete(t);
+                machine__remove_thread(machine, t);
         }
 }
 
@@ -361,9 +350,13 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
          * the full rbtree:
          */
         th = machine->last_match;
-        if (th && th->tid == tid) {
-                machine__update_thread_pid(machine, th, pid);
-                return th;
+        if (th != NULL) {
+                if (th->tid == tid) {
+                        machine__update_thread_pid(machine, th, pid);
+                        return th;
+                }
+
+                thread__zput(machine->last_match);
         }
 
         while (*p != NULL) {
@@ -371,7 +364,7 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
                 th = rb_entry(parent, struct thread, rb_node);
 
                 if (th->tid == tid) {
-                        machine->last_match = th;
+                        machine->last_match = thread__get(th);
                         machine__update_thread_pid(machine, th, pid);
                         return th;
                 }
@@ -403,8 +396,11 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
                         thread__delete(th);
                         return NULL;
                 }
-
-                machine->last_match = th;
+                /*
+                 * It is now in the rbtree, get a ref
+                 */
+                thread__get(th);
+                machine->last_match = thread__get(th);
         }
 
         return th;
@@ -462,30 +458,61 @@ int machine__process_lost_event(struct machine *machine __maybe_unused,
         return 0;
 }
 
+static struct dso*
+machine__module_dso(struct machine *machine, struct kmod_path *m,
+                    const char *filename)
+{
+        struct dso *dso;
+
+        dso = dsos__find(&machine->kernel_dsos, m->name, true);
+        if (!dso) {
+                dso = dsos__addnew(&machine->kernel_dsos, m->name);
+                if (dso == NULL)
+                        return NULL;
+
+                if (machine__is_host(machine))
+                        dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
+                else
+                        dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
+
+                /* _KMODULE_COMP should be next to _KMODULE */
+                if (m->kmod && m->comp)
+                        dso->symtab_type++;
+
+                dso__set_short_name(dso, strdup(m->name), true);
+                dso__set_long_name(dso, strdup(filename), true);
+        }
+
+        return dso;
+}
+
 struct map *machine__new_module(struct machine *machine, u64 start,
                                 const char *filename)
 {
-        struct map *map;
-        struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
-        bool compressed;
+        struct map *map = NULL;
+        struct dso *dso;
+        struct kmod_path m;
 
-        if (dso == NULL)
+        if (kmod_path__parse_name(&m, filename))
                 return NULL;
 
-        map = map__new2(start, dso, MAP__FUNCTION);
-        if (map == NULL)
-                return NULL;
+        map = map_groups__find_by_name(&machine->kmaps, MAP__FUNCTION,
+                                       m.name);
+        if (map)
+                goto out;
 
-        if (machine__is_host(machine))
-                dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
-        else
-                dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
+        dso = machine__module_dso(machine, &m, filename);
+        if (dso == NULL)
+                goto out;
 
-        /* _KMODULE_COMP should be next to _KMODULE */
-        if (is_kernel_module(filename, &compressed) && compressed)
-                dso->symtab_type++;
+        map = map__new2(start, dso, MAP__FUNCTION);
+        if (map == NULL)
+                goto out;
 
         map_groups__insert(&machine->kmaps, map);
+
+out:
+        free(m.name);
         return map;
 }
 
@@ -650,6 +677,9 @@ int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
                         machine->vmlinux_maps[type]->unmap_ip =
                                 identity__map_ip;
                 kmap = map__kmap(machine->vmlinux_maps[type]);
+                if (!kmap)
+                        return -1;
+
                 kmap->kmaps = &machine->kmaps;
                 map_groups__insert(&machine->kmaps,
                                    machine->vmlinux_maps[type]);
@@ -671,7 +701,7 @@ void machine__destroy_kernel_maps(struct machine *machine)
                 kmap = map__kmap(machine->vmlinux_maps[type]);
                 map_groups__remove(&machine->kmaps,
                                    machine->vmlinux_maps[type]);
-                if (kmap->ref_reloc_sym) {
+                if (kmap && kmap->ref_reloc_sym) {
                         /*
                          * ref_reloc_sym is shared among all maps, so free just
                          * on one of them.
@@ -827,6 +857,39 @@ static char *get_kernel_version(const char *root_dir)
         return strdup(name);
 }
 
+static bool is_kmod_dso(struct dso *dso)
+{
+        return dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
+               dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE;
+}
+
+static int map_groups__set_module_path(struct map_groups *mg, const char *path,
+                                       struct kmod_path *m)
+{
+        struct map *map;
+        char *long_name;
+
+        map = map_groups__find_by_name(mg, MAP__FUNCTION, m->name);
+        if (map == NULL)
+                return 0;
+
+        long_name = strdup(path);
+        if (long_name == NULL)
+                return -ENOMEM;
+
+        dso__set_long_name(map->dso, long_name, true);
+        dso__kernel_module_get_build_id(map->dso, "");
+
+        /*
+         * Full name could reveal us kmod compression, so
+         * we need to update the symtab_type if needed.
+         */
+        if (m->comp && is_kmod_dso(map->dso))
+                map->dso->symtab_type++;
+
+        return 0;
+}
+
 static int map_groups__set_modules_path_dir(struct map_groups *mg,
                                 const char *dir_name, int depth)
 {
@@ -865,35 +928,19 @@ static int map_groups__set_modules_path_dir(struct map_groups *mg,
                         if (ret < 0)
                                 goto out;
                 } else {
-                        char *dot = strrchr(dent->d_name, '.'),
-                             dso_name[PATH_MAX];
-                        struct map *map;
-                        char *long_name;
+                        struct kmod_path m;
 
-                        if (dot == NULL)
-                                continue;
-
-                        /* On some system, modules are compressed like .ko.gz */
-                        if (is_supported_compression(dot + 1) &&
-                            is_kmodule_extension(dot - 2))
-                                dot -= 3;
+                        ret = kmod_path__parse_name(&m, dent->d_name);
+                        if (ret)
+                                goto out;
 
-                        snprintf(dso_name, sizeof(dso_name), "[%.*s]",
-                                 (int)(dot - dent->d_name), dent->d_name);
+                        if (m.kmod)
+                                ret = map_groups__set_module_path(mg, path, &m);
 
-                        strxfrchar(dso_name, '-', '_');
-                        map = map_groups__find_by_name(mg, MAP__FUNCTION,
-                                                       dso_name);
-                        if (map == NULL)
-                                continue;
+                        free(m.name);
 
-                        long_name = strdup(path);
-                        if (long_name == NULL) {
-                                ret = -1;
+                        if (ret)
                                 goto out;
-                        }
-                        dso__set_long_name(map->dso, long_name, true);
-                        dso__kernel_module_get_build_id(map->dso, "");
                 }
         }
 
@@ -1046,40 +1093,11 @@ static int machine__process_kernel_mmap_event(struct machine *machine,
                                 strlen(kmmap_prefix) - 1) == 0;
         if (event->mmap.filename[0] == '/' ||
             (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
-
-                char short_module_name[1024];
-                char *name, *dot;
-
-                if (event->mmap.filename[0] == '/') {
-                        name = strrchr(event->mmap.filename, '/');
-                        if (name == NULL)
-                                goto out_problem;
-
-                        ++name; /* skip / */
-                        dot = strrchr(name, '.');
-                        if (dot == NULL)
-                                goto out_problem;
-                        /* On some system, modules are compressed like .ko.gz */
-                        if (is_supported_compression(dot + 1))
-                                dot -= 3;
-                        if (!is_kmodule_extension(dot + 1))
-                                goto out_problem;
-                        snprintf(short_module_name, sizeof(short_module_name),
-                                        "[%.*s]", (int)(dot - name), name);
-                        strxfrchar(short_module_name, '-', '_');
-                } else
-                        strcpy(short_module_name, event->mmap.filename);
-
                 map = machine__new_module(machine, event->mmap.start,
                                           event->mmap.filename);
                 if (map == NULL)
                         goto out_problem;
 
-                name = strdup(short_module_name);
-                if (name == NULL)
-                        goto out_problem;
-
-                dso__set_short_name(map->dso, name, true);
                 map->end = map->start + event->mmap.len;
         } else if (is_kernel_mmap) {
                 const char *symbol_name = (event->mmap.filename +
@@ -1092,7 +1110,7 @@ static int machine__process_kernel_mmap_event(struct machine *machine,
                 struct dso *dso;
 
                 list_for_each_entry(dso, &machine->kernel_dsos.head, node) {
-                        if (is_kernel_module(dso->long_name, NULL))
+                        if (is_kernel_module(dso->long_name))
                                 continue;
 
                         kernel = dso;
@@ -1236,15 +1254,19 @@ out_problem:
         return 0;
 }
 
-static void machine__remove_thread(struct machine *machine, struct thread *th)
+void machine__remove_thread(struct machine *machine, struct thread *th)
 {
-        machine->last_match = NULL;
+        if (machine->last_match == th)
+                thread__zput(machine->last_match);
+
         rb_erase(&th->rb_node, &machine->threads);
         /*
-         * We may have references to this thread, for instance in some hist_entry
-         * instances, so just move them to a separate list.
+         * Move it first to the dead_threads list, then drop the reference,
+         * if this is the last reference, then the thread__delete destructor
+         * will be called and we will remove it from the dead_threads list.
          */
         list_add_tail(&th->node, &machine->dead_threads);
+        thread__put(th);
 }
 
 int machine__process_fork_event(struct machine *machine, union perf_event *event,
@@ -1387,29 +1409,27 @@ struct mem_info *sample__resolve_mem(struct perf_sample *sample,
 static int add_callchain_ip(struct thread *thread,
                             struct symbol **parent,
                             struct addr_location *root_al,
-                            bool branch_history,
+                            u8 *cpumode,
                             u64 ip)
 {
         struct addr_location al;
 
         al.filtered = 0;
         al.sym = NULL;
-        if (branch_history)
+        if (!cpumode) {
                 thread__find_cpumode_addr_location(thread, MAP__FUNCTION,
                                                    ip, &al);
-        else {
-                u8 cpumode = PERF_RECORD_MISC_USER;
-
+        } else {
                 if (ip >= PERF_CONTEXT_MAX) {
                         switch (ip) {
                         case PERF_CONTEXT_HV:
-                                cpumode = PERF_RECORD_MISC_HYPERVISOR;
+                                *cpumode = PERF_RECORD_MISC_HYPERVISOR;
                                 break;
                         case PERF_CONTEXT_KERNEL:
-                                cpumode = PERF_RECORD_MISC_KERNEL;
+                                *cpumode = PERF_RECORD_MISC_KERNEL;
                                 break;
                         case PERF_CONTEXT_USER:
-                                cpumode = PERF_RECORD_MISC_USER;
+                                *cpumode = PERF_RECORD_MISC_USER;
                                 break;
                         default:
                                 pr_debug("invalid callchain context: "
@@ -1423,8 +1443,8 @@ static int add_callchain_ip(struct thread *thread,
                         }
                         return 0;
                 }
-                thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
-                                   ip, &al);
+                thread__find_addr_location(thread, *cpumode, MAP__FUNCTION,
+                                           ip, &al);
         }
 
         if (al.sym != NULL) {
@@ -1502,18 +1522,102 @@ static int remove_loops(struct branch_entry *l, int nr)
         return nr;
 }
 
-static int thread__resolve_callchain_sample(struct thread *thread,
-                                             struct ip_callchain *chain,
-                                             struct branch_stack *branch,
-                                             struct symbol **parent,
-                                             struct addr_location *root_al,
-                                             int max_stack)
+/*
+ * Recolve LBR callstack chain sample
+ * Return:
+ * 1 on success get LBR callchain information
+ * 0 no available LBR callchain information, should try fp
+ * negative error code on other errors.
+ */
+static int resolve_lbr_callchain_sample(struct thread *thread,
+                                        struct perf_sample *sample,
+                                        struct symbol **parent,
+                                        struct addr_location *root_al,
+                                        int max_stack)
 {
+        struct ip_callchain *chain = sample->callchain;
         int chain_nr = min(max_stack, (int)chain->nr);
+        u8 cpumode = PERF_RECORD_MISC_USER;
+        int i, j, err;
+        u64 ip;
+
+        for (i = 0; i < chain_nr; i++) {
+                if (chain->ips[i] == PERF_CONTEXT_USER)
+                        break;
+        }
+
+        /* LBR only affects the user callchain */
+        if (i != chain_nr) {
+                struct branch_stack *lbr_stack = sample->branch_stack;
+                int lbr_nr = lbr_stack->nr;
+                /*
+                 * LBR callstack can only get user call chain.
+                 * The mix_chain_nr is kernel call chain
+                 * number plus LBR user call chain number.
+                 * i is kernel call chain number,
+                 * 1 is PERF_CONTEXT_USER,
+                 * lbr_nr + 1 is the user call chain number.
+                 * For details, please refer to the comments
+                 * in callchain__printf
+                 */
+                int mix_chain_nr = i + 1 + lbr_nr + 1;
+
+                if (mix_chain_nr > PERF_MAX_STACK_DEPTH + PERF_MAX_BRANCH_DEPTH) {
+                        pr_warning("corrupted callchain. skipping...\n");
+                        return 0;
+                }
+
+                for (j = 0; j < mix_chain_nr; j++) {
+                        if (callchain_param.order == ORDER_CALLEE) {
+                                if (j < i + 1)
+                                        ip = chain->ips[j];
+                                else if (j > i + 1)
+                                        ip = lbr_stack->entries[j - i - 2].from;
+                                else
+                                        ip = lbr_stack->entries[0].to;
+                        } else {
+                                if (j < lbr_nr)
+                                        ip = lbr_stack->entries[lbr_nr - j - 1].from;
+                                else if (j > lbr_nr)
+                                        ip = chain->ips[i + 1 - (j - lbr_nr)];
+                                else
+                                        ip = lbr_stack->entries[0].to;
+                        }
+
+                        err = add_callchain_ip(thread, parent, root_al, &cpumode, ip);
+                        if (err)
+                                return (err < 0) ? err : 0;
+                }
+                return 1;
+        }
+
+        return 0;
+}
+
+static int thread__resolve_callchain_sample(struct thread *thread,
+                                            struct perf_evsel *evsel,
+                                            struct perf_sample *sample,
+                                            struct symbol **parent,
+                                            struct addr_location *root_al,
+                                            int max_stack)
+{
+        struct branch_stack *branch = sample->branch_stack;
+        struct ip_callchain *chain = sample->callchain;
+        int chain_nr = min(max_stack, (int)chain->nr);
+        u8 cpumode = PERF_RECORD_MISC_USER;
         int i, j, err;
         int skip_idx = -1;
         int first_call = 0;
 
+        callchain_cursor_reset(&callchain_cursor);
+
+        if (has_branch_callstack(evsel)) {
+                err = resolve_lbr_callchain_sample(thread, sample, parent,
+                                                   root_al, max_stack);
+                if (err)
+                        return (err < 0) ? err : 0;
+        }
+
         /*
          * Based on DWARF debug information, some architectures skip
          * a callchain entry saved by the kernel.
@@ -1521,8 +1625,6 @@ static int thread__resolve_callchain_sample(struct thread *thread,
         if (chain->nr < PERF_MAX_STACK_DEPTH)
                 skip_idx = arch_skip_callchain_idx(thread, chain);
 
-        callchain_cursor_reset(&callchain_cursor);
-
         /*
          * Add branches to call stack for easier browsing. This gives
          * more context for a sample than just the callers.
@@ -1568,10 +1670,10 @@ static int thread__resolve_callchain_sample(struct thread *thread,
 
                 for (i = 0; i < nr; i++) {
                         err = add_callchain_ip(thread, parent, root_al,
-                                               true, be[i].to);
+                                               NULL, be[i].to);
                         if (!err)
                                 err = add_callchain_ip(thread, parent, root_al,
-                                                       true, be[i].from);
+                                                       NULL, be[i].from);
                         if (err == -EINVAL)
                                 break;
                         if (err)
@@ -1600,7 +1702,7 @@ check_calls:
 #endif
                 ip = chain->ips[j];
 
-                err = add_callchain_ip(thread, parent, root_al, false, ip);
+                err = add_callchain_ip(thread, parent, root_al, &cpumode, ip);
 
                 if (err)
                         return (err < 0) ? err : 0;
@@ -1623,9 +1725,9 @@ int thread__resolve_callchain(struct thread *thread,
                               struct addr_location *root_al,
                               int max_stack)
 {
-        int ret = thread__resolve_callchain_sample(thread, sample->callchain,
-                                                   sample->branch_stack,
-                                                   parent, root_al, max_stack);
+        int ret = thread__resolve_callchain_sample(thread, evsel,
+                                                   sample, parent,
+                                                   root_al, max_stack);
         if (ret)
                 return ret;
 
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index e8b7779a0a3f..6d64cedb9d1e 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -118,9 +118,9 @@ void machines__set_comm_exec(struct machines *machines, bool comm_exec);
 struct machine *machine__new_host(void);
 int machine__init(struct machine *machine, const char *root_dir, pid_t pid);
 void machine__exit(struct machine *machine);
-void machine__delete_dead_threads(struct machine *machine);
 void machine__delete_threads(struct machine *machine);
 void machine__delete(struct machine *machine);
+void machine__remove_thread(struct machine *machine, struct thread *th);
 
 struct branch_info *sample__resolve_bstack(struct perf_sample *sample,
                                            struct addr_location *al);
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 62ca9f2607d5..a14f08f41686 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -778,3 +778,23 @@ struct map *maps__next(struct map *map)
                 return rb_entry(next, struct map, rb_node);
         return NULL;
 }
+
+struct kmap *map__kmap(struct map *map)
+{
+        if (!map->dso || !map->dso->kernel) {
+                pr_err("Internal error: map__kmap with a non-kernel map\n");
+                return NULL;
+        }
+        return (struct kmap *)(map + 1);
+}
+
+struct map_groups *map__kmaps(struct map *map)
+{
+        struct kmap *kmap = map__kmap(map);
+
+        if (!kmap || !kmap->kmaps) {
+                pr_err("Internal error: map__kmaps with a non-kernel map\n");
+                return NULL;
+        }
+        return kmap->kmaps;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 0e42438b1e59..ec19c59ca38e 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -76,10 +76,8 @@ static inline struct map_groups *map_groups__get(struct map_groups *mg)
 
 void map_groups__put(struct map_groups *mg);
 
-static inline struct kmap *map__kmap(struct map *map)
-{
-        return (struct kmap *)(map + 1);
-}
+struct kmap *map__kmap(struct map *map);
+struct map_groups *map__kmaps(struct map *map);
 
 static inline u64 map__map_ip(struct map *map, u64 ip)
 {
diff --git a/tools/perf/util/ordered-events.c b/tools/perf/util/ordered-events.c
index fd4be94125fb..52be201b9b25 100644
--- a/tools/perf/util/ordered-events.c
+++ b/tools/perf/util/ordered-events.c
@@ -2,7 +2,6 @@
 #include <linux/compiler.h>
 #include <linux/string.h>
 #include "ordered-events.h"
-#include "evlist.h"
 #include "session.h"
 #include "asm/bug.h"
 #include "debug.h"
@@ -131,8 +130,8 @@ static struct ordered_event *alloc_event(struct ordered_events *oe,
         return new;
 }
 
-struct ordered_event *
-ordered_events__new(struct ordered_events *oe, u64 timestamp,
+static struct ordered_event *
+ordered_events__new_event(struct ordered_events *oe, u64 timestamp,
                     union perf_event *event)
 {
         struct ordered_event *new;
@@ -153,20 +152,47 @@ void ordered_events__delete(struct ordered_events *oe, struct ordered_event *eve
         free_dup_event(oe, event->event);
 }
 
-static int __ordered_events__flush(struct perf_session *s,
-                                   struct perf_tool *tool)
+int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
+                          struct perf_sample *sample, u64 file_offset)
+{
+        u64 timestamp = sample->time;
+        struct ordered_event *oevent;
+
+        if (!timestamp || timestamp == ~0ULL)
+                return -ETIME;
+
+        if (timestamp < oe->last_flush) {
+                pr_oe_time(timestamp,      "out of order event\n");
+                pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
+                           oe->last_flush_type);
+
+                oe->nr_unordered_events++;
+        }
+
+        oevent = ordered_events__new_event(oe, timestamp, event);
+        if (!oevent) {
+                ordered_events__flush(oe, OE_FLUSH__HALF);
+                oevent = ordered_events__new_event(oe, timestamp, event);
+        }
+
+        if (!oevent)
+                return -ENOMEM;
+
+        oevent->file_offset = file_offset;
+        return 0;
+}
+
+static int __ordered_events__flush(struct ordered_events *oe)
 {
-        struct ordered_events *oe = &s->ordered_events;
         struct list_head *head = &oe->events;
         struct ordered_event *tmp, *iter;
-        struct perf_sample sample;
         u64 limit = oe->next_flush;
         u64 last_ts = oe->last ? oe->last->timestamp : 0ULL;
         bool show_progress = limit == ULLONG_MAX;
         struct ui_progress prog;
         int ret;
 
-        if (!tool->ordered_events || !limit)
+        if (!limit)
                 return 0;
 
         if (show_progress)
@@ -178,16 +204,9 @@ static int __ordered_events__flush(struct perf_session *s,
 
                 if (iter->timestamp > limit)
                         break;
-
-                ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
+                ret = oe->deliver(oe, iter);
                 if (ret)
-                        pr_err("Can't parse sample, err = %d\n", ret);
-                else {
-                        ret = perf_session__deliver_event(s, iter->event, &sample, tool,
-                                                          iter->file_offset);
-                        if (ret)
-                                return ret;
-                }
+                        return ret;
 
                 ordered_events__delete(oe, iter);
                 oe->last_flush = iter->timestamp;
@@ -204,10 +223,8 @@ static int __ordered_events__flush(struct perf_session *s,
         return 0;
 }
 
-int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
-                          enum oe_flush how)
+int ordered_events__flush(struct ordered_events *oe, enum oe_flush how)
 {
-        struct ordered_events *oe = &s->ordered_events;
         static const char * const str[] = {
                 "NONE",
                 "FINAL",
@@ -216,6 +233,9 @@ int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
         };
         int err;
 
+        if (oe->nr_events == 0)
+                return 0;
+
         switch (how) {
         case OE_FLUSH__FINAL:
                 oe->next_flush = ULLONG_MAX;
@@ -248,7 +268,7 @@ int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
                    str[how], oe->nr_events);
         pr_oe_time(oe->max_timestamp, "max_timestamp\n");
 
-        err = __ordered_events__flush(s, tool);
+        err = __ordered_events__flush(oe);
 
         if (!err) {
                 if (how == OE_FLUSH__ROUND)
@@ -264,13 +284,14 @@ int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
         return err;
 }
 
-void ordered_events__init(struct ordered_events *oe)
+void ordered_events__init(struct ordered_events *oe, ordered_events__deliver_t deliver)
 {
         INIT_LIST_HEAD(&oe->events);
         INIT_LIST_HEAD(&oe->cache);
         INIT_LIST_HEAD(&oe->to_free);
         oe->max_alloc_size = (u64) -1;
         oe->cur_alloc_size = 0;
+        oe->deliver        = deliver;
 }
 
 void ordered_events__free(struct ordered_events *oe)
diff --git a/tools/perf/util/ordered-events.h b/tools/perf/util/ordered-events.h
index 7b8f9b011f38..f403991e3bfd 100644
--- a/tools/perf/util/ordered-events.h
+++ b/tools/perf/util/ordered-events.h
@@ -2,9 +2,8 @@
 #define __ORDERED_EVENTS_H
 
 #include <linux/types.h>
-#include "tool.h"
 
-struct perf_session;
+struct perf_sample;
 
 struct ordered_event {
         u64                     timestamp;
@@ -20,6 +19,11 @@ enum oe_flush {
         OE_FLUSH__HALF,
 };
 
+struct ordered_events;
+
+typedef int (*ordered_events__deliver_t)(struct ordered_events *oe,
+                                         struct ordered_event *event);
+
 struct ordered_events {
         u64                     last_flush;
         u64                     next_flush;
@@ -31,18 +35,19 @@ struct ordered_events {
         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;
 };
 
-struct ordered_event *ordered_events__new(struct ordered_events *oe, u64 timestamp,
-                                          union perf_event *event);
+int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
+                          struct perf_sample *sample, u64 file_offset);
 void ordered_events__delete(struct ordered_events *oe, struct ordered_event *event);
-int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
-                          enum oe_flush how);
-void ordered_events__init(struct ordered_events *oe);
+int ordered_events__flush(struct ordered_events *oe, enum oe_flush how);
+void ordered_events__init(struct ordered_events *oe, ordered_events__deliver_t deliver);
 void ordered_events__free(struct ordered_events *oe);
 
 static inline
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 7f8ec6ce2823..be0655388b38 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -20,11 +20,6 @@
 
 #define MAX_NAME_LEN 100
 
-struct event_symbol {
-        const char      *symbol;
-        const char      *alias;
-};
-
 #ifdef PARSER_DEBUG
 extern int parse_events_debug;
 #endif
@@ -39,7 +34,7 @@ static struct perf_pmu_event_symbol *perf_pmu_events_list;
  */
 static int perf_pmu_events_list_num;
 
-static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
+struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
         [PERF_COUNT_HW_CPU_CYCLES] = {
                 .symbol = "cpu-cycles",
                 .alias  = "cycles",
@@ -82,7 +77,7 @@ static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
         },
 };
 
-static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
+struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
         [PERF_COUNT_SW_CPU_CLOCK] = {
                 .symbol = "cpu-clock",
                 .alias  = "",
@@ -175,9 +170,6 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (debugfs_valid_mountpoint(tracing_events_path))
-                return NULL;
-
         sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
                 return NULL;
@@ -473,12 +465,6 @@ static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 int parse_events_add_tracepoint(struct list_head *list, int *idx,
                                 char *sys, char *event)
 {
-        int ret;
-
-        ret = debugfs_valid_mountpoint(tracing_events_path);
-        if (ret)
-                return ret;
-
         if (strpbrk(sys, "*?"))
                 return add_tracepoint_multi_sys(list, idx, sys, event);
         else
@@ -723,6 +709,7 @@ struct event_modifier {
         int eh;
         int eH;
         int eG;
+        int eI;
         int precise;
         int exclude_GH;
         int sample_read;
@@ -737,6 +724,7 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
         int eh = evsel ? evsel->attr.exclude_hv : 0;
         int eH = evsel ? evsel->attr.exclude_host : 0;
         int eG = evsel ? evsel->attr.exclude_guest : 0;
+        int eI = evsel ? evsel->attr.exclude_idle : 0;
         int precise = evsel ? evsel->attr.precise_ip : 0;
         int sample_read = 0;
         int pinned = evsel ? evsel->attr.pinned : 0;
@@ -767,6 +755,8 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
                         if (!exclude_GH)
                                 exclude_GH = eG = eH = 1;
                         eH = 0;
+                } else if (*str == 'I') {
+                        eI = 1;
                 } else if (*str == 'p') {
                         precise++;
                         /* use of precise requires exclude_guest */
@@ -800,6 +790,7 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
         mod->eh = eh;
         mod->eH = eH;
         mod->eG = eG;
+        mod->eI = eI;
         mod->precise = precise;
         mod->exclude_GH = exclude_GH;
         mod->sample_read = sample_read;
@@ -817,7 +808,7 @@ static int check_modifier(char *str)
         char *p = str;
 
         /* The sizeof includes 0 byte as well. */
-        if (strlen(str) > (sizeof("ukhGHpppSD") - 1))
+        if (strlen(str) > (sizeof("ukhGHpppSDI") - 1))
                 return -1;
 
         while (*p) {
@@ -853,6 +844,7 @@ int parse_events__modifier_event(struct list_head *list, char *str, bool add)
                 evsel->attr.precise_ip     = mod.precise;
                 evsel->attr.exclude_host   = mod.eH;
                 evsel->attr.exclude_guest  = mod.eG;
+                evsel->attr.exclude_idle   = mod.eI;
                 evsel->exclude_GH          = mod.exclude_GH;
                 evsel->sample_read         = mod.sample_read;
 
@@ -1098,6 +1090,14 @@ static const char * const event_type_descriptors[] = {
         "Hardware breakpoint",
 };
 
+static int cmp_string(const void *a, const void *b)
+{
+        const char * const *as = a;
+        const char * const *bs = b;
+
+        return strcmp(*as, *bs);
+}
+
 /*
  * Print the events from <debugfs_mount_point>/tracing/events
  */
@@ -1109,18 +1109,21 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
-        char sbuf[STRERR_BUFSIZE];
-
-        if (debugfs_valid_mountpoint(tracing_events_path)) {
-                printf("  [ Tracepoints not available: %s ]\n",
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
-                return;
-        }
+        char **evt_list = NULL;
+        unsigned int evt_i = 0, evt_num = 0;
+        bool evt_num_known = false;
 
+restart:
         sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
                 return;
 
+        if (evt_num_known) {
+                evt_list = zalloc(sizeof(char *) * evt_num);
+                if (!evt_list)
+                        goto out_close_sys_dir;
+        }
+
         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
                 if (subsys_glob != NULL &&
                     !strglobmatch(sys_dirent.d_name, subsys_glob))
@@ -1137,19 +1140,56 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                             !strglobmatch(evt_dirent.d_name, event_glob))
                                 continue;
 
-                        if (name_only) {
-                                printf("%s:%s ", sys_dirent.d_name, evt_dirent.d_name);
+                        if (!evt_num_known) {
+                                evt_num++;
                                 continue;
                         }
 
                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                  sys_dirent.d_name, evt_dirent.d_name);
-                        printf("  %-50s [%s]\n", evt_path,
-                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
+
+                        evt_list[evt_i] = strdup(evt_path);
+                        if (evt_list[evt_i] == NULL)
+                                goto out_close_evt_dir;
+                        evt_i++;
                 }
                 closedir(evt_dir);
         }
         closedir(sys_dir);
+
+        if (!evt_num_known) {
+                evt_num_known = true;
+                goto restart;
+        }
+        qsort(evt_list, evt_num, sizeof(char *), cmp_string);
+        evt_i = 0;
+        while (evt_i < evt_num) {
+                if (name_only) {
+                        printf("%s ", evt_list[evt_i++]);
+                        continue;
+                }
+                printf("  %-50s [%s]\n", evt_list[evt_i++],
+                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
+        }
+        if (evt_num)
+                printf("\n");
+
+out_free:
+        evt_num = evt_i;
+        for (evt_i = 0; evt_i < evt_num; evt_i++)
+                zfree(&evt_list[evt_i]);
+        zfree(&evt_list);
+        return;
+
+out_close_evt_dir:
+        closedir(evt_dir);
+out_close_sys_dir:
+        closedir(sys_dir);
+
+        printf("FATAL: not enough memory to print %s\n",
+                        event_type_descriptors[PERF_TYPE_TRACEPOINT]);
+        if (evt_list)
+                goto out_free;
 }
 
 /*
@@ -1163,9 +1203,6 @@ int is_valid_tracepoint(const char *event_string)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (debugfs_valid_mountpoint(tracing_events_path))
-                return 0;
-
         sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
                 return 0;
@@ -1233,38 +1270,19 @@ static bool is_event_supported(u8 type, unsigned config)
         return ret;
 }
 
-static void __print_events_type(u8 type, struct event_symbol *syms,
-                                unsigned max)
-{
-        char name[64];
-        unsigned i;
-
-        for (i = 0; i < max ; i++, syms++) {
-                if (!is_event_supported(type, i))
-                        continue;
-
-                if (strlen(syms->alias))
-                        snprintf(name, sizeof(name),  "%s OR %s",
-                                 syms->symbol, syms->alias);
-                else
-                        snprintf(name, sizeof(name), "%s", syms->symbol);
-
-                printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
-        }
-}
-
-void print_events_type(u8 type)
-{
-        if (type == PERF_TYPE_SOFTWARE)
-                __print_events_type(type, event_symbols_sw, PERF_COUNT_SW_MAX);
-        else
-                __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX);
-}
-
 int print_hwcache_events(const char *event_glob, bool name_only)
 {
-        unsigned int type, op, i, printed = 0;
+        unsigned int type, op, i, evt_i = 0, evt_num = 0;
         char name[64];
+        char **evt_list = NULL;
+        bool evt_num_known = false;
+
+restart:
+        if (evt_num_known) {
+                evt_list = zalloc(sizeof(char *) * evt_num);
+                if (!evt_list)
+                        goto out_enomem;
+        }
 
         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
@@ -1282,27 +1300,66 @@ int print_hwcache_events(const char *event_glob, bool name_only)
                                                         type | (op << 8) | (i << 16)))
                                         continue;
 
-                                if (name_only)
-                                        printf("%s ", name);
-                                else
-                                        printf("  %-50s [%s]\n", name,
-                                               event_type_descriptors[PERF_TYPE_HW_CACHE]);
-                                ++printed;
+                                if (!evt_num_known) {
+                                        evt_num++;
+                                        continue;
+                                }
+
+                                evt_list[evt_i] = strdup(name);
+                                if (evt_list[evt_i] == NULL)
+                                        goto out_enomem;
+                                evt_i++;
                         }
                 }
         }
 
-        if (printed)
+        if (!evt_num_known) {
+                evt_num_known = true;
+                goto restart;
+        }
+        qsort(evt_list, evt_num, sizeof(char *), cmp_string);
+        evt_i = 0;
+        while (evt_i < evt_num) {
+                if (name_only) {
+                        printf("%s ", evt_list[evt_i++]);
+                        continue;
+                }
+                printf("  %-50s [%s]\n", evt_list[evt_i++],
+                                event_type_descriptors[PERF_TYPE_HW_CACHE]);
+        }
+        if (evt_num)
                 printf("\n");
-        return printed;
+
+out_free:
+        evt_num = evt_i;
+        for (evt_i = 0; evt_i < evt_num; evt_i++)
+                zfree(&evt_list[evt_i]);
+        zfree(&evt_list);
+        return evt_num;
+
+out_enomem:
+        printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]);
+        if (evt_list)
+                goto out_free;
+        return evt_num;
 }
 
-static void print_symbol_events(const char *event_glob, unsigned type,
+void print_symbol_events(const char *event_glob, unsigned type,
                                 struct event_symbol *syms, unsigned max,
                                 bool name_only)
 {
-        unsigned i, printed = 0;
+        unsigned int i, evt_i = 0, evt_num = 0;
         char name[MAX_NAME_LEN];
+        char **evt_list = NULL;
+        bool evt_num_known = false;
+
+restart:
+        if (evt_num_known) {
+                evt_list = zalloc(sizeof(char *) * evt_num);
+                if (!evt_list)
+                        goto out_enomem;
+                syms -= max;
+        }
 
         for (i = 0; i < max; i++, syms++) {
 
@@ -1314,23 +1371,49 @@ static void print_symbol_events(const char *event_glob, unsigned type,
                 if (!is_event_supported(type, i))
                         continue;
 
-                if (name_only) {
-                        printf("%s ", syms->symbol);
+                if (!evt_num_known) {
+                        evt_num++;
                         continue;
                 }
 
-                if (strlen(syms->alias))
+                if (!name_only && strlen(syms->alias))
                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
                 else
                         strncpy(name, syms->symbol, MAX_NAME_LEN);
 
-                printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
-
-                printed++;
+                evt_list[evt_i] = strdup(name);
+                if (evt_list[evt_i] == NULL)
+                        goto out_enomem;
+                evt_i++;
         }
 
-        if (printed)
+        if (!evt_num_known) {
+                evt_num_known = true;
+                goto restart;
+        }
+        qsort(evt_list, evt_num, sizeof(char *), cmp_string);
+        evt_i = 0;
+        while (evt_i < evt_num) {
+                if (name_only) {
+                        printf("%s ", evt_list[evt_i++]);
+                        continue;
+                }
+                printf("  %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]);
+        }
+        if (evt_num)
                 printf("\n");
+
+out_free:
+        evt_num = evt_i;
+        for (evt_i = 0; evt_i < evt_num; evt_i++)
+                zfree(&evt_list[evt_i]);
+        zfree(&evt_list);
+        return;
+
+out_enomem:
+        printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]);
+        if (evt_list)
+                goto out_free;
 }
 
 /*
@@ -1338,11 +1421,6 @@ static void print_symbol_events(const char *event_glob, unsigned type,
  */
 void print_events(const char *event_glob, bool name_only)
 {
-        if (!name_only) {
-                printf("\n");
-                printf("List of pre-defined events (to be used in -e):\n");
-        }
-
         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
                             event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
 
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index ff6e1fa4111e..52a2dda4f954 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -116,12 +116,21 @@ void parse_events_update_lists(struct list_head *list_event,
 void parse_events_error(void *data, void *scanner, char const *msg);
 
 void print_events(const char *event_glob, bool name_only);
-void print_events_type(u8 type);
+
+struct event_symbol {
+        const char      *symbol;
+        const char      *alias;
+};
+extern struct event_symbol event_symbols_hw[];
+extern struct event_symbol event_symbols_sw[];
+void print_symbol_events(const char *event_glob, unsigned type,
+                                struct event_symbol *syms, unsigned max,
+                                bool name_only);
 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                              bool name_only);
 int print_hwcache_events(const char *event_glob, bool name_only);
 extern int is_valid_tracepoint(const char *event_string);
 
-extern int valid_debugfs_mount(const char *debugfs);
+int valid_event_mount(const char *eventfs);
 
 #endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 94eacb6c1ef7..8895cf3132ab 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -101,7 +101,7 @@ num_raw_hex	[a-fA-F0-9]+
 name            [a-zA-Z_*?][a-zA-Z0-9_*?]*
 name_minus      [a-zA-Z_*?][a-zA-Z0-9\-_*?]*
 /* If you add a modifier you need to update check_modifier() */
-modifier_event  [ukhpGHSD]+
+modifier_event  [ukhpGHSDI]+
 modifier_bp     [rwx]{1,3}
 
 %%
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index 4a015f77e2b5..01626be2a8eb 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -37,6 +37,7 @@ static int get_value(struct parse_opt_ctx_t *p,
 {
         const char *s, *arg = NULL;
         const int unset = flags & OPT_UNSET;
+        int err;
 
         if (unset && p->opt)
                 return opterror(opt, "takes no value", flags);
@@ -114,13 +115,29 @@ static int get_value(struct parse_opt_ctx_t *p,
                 return 0;
 
         case OPTION_STRING:
+                err = 0;
                 if (unset)
                         *(const char **)opt->value = NULL;
                 else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
                         *(const char **)opt->value = (const char *)opt->defval;
                 else
-                        return get_arg(p, opt, flags, (const char **)opt->value);
-                return 0;
+                        err = get_arg(p, opt, flags, (const char **)opt->value);
+
+                /* PARSE_OPT_NOEMPTY: Allow NULL but disallow empty string. */
+                if (opt->flags & PARSE_OPT_NOEMPTY) {
+                        const char *val = *(const char **)opt->value;
+
+                        if (!val)
+                                return err;
+
+                        /* Similar to unset if we are given an empty string. */
+                        if (val[0] == '\0') {
+                                *(const char **)opt->value = NULL;
+                                return 0;
+                        }
+                }
+
+                return err;
 
         case OPTION_CALLBACK:
                 if (unset)
@@ -505,13 +522,18 @@ int parse_options_subcommand(int argc, const char **argv, const struct option *o
                 break;
         case PARSE_OPT_LIST_OPTS:
                 while (options->type != OPTION_END) {
-                        printf("--%s ", options->long_name);
+                        if (options->long_name)
+                                printf("--%s ", options->long_name);
                         options++;
                 }
+                putchar('\n');
                 exit(130);
         case PARSE_OPT_LIST_SUBCMDS:
-                for (int i = 0; subcommands[i]; i++)
-                        printf("%s ", subcommands[i]);
+                if (subcommands) {
+                        for (int i = 0; subcommands[i]; i++)
+                                printf("%s ", subcommands[i]);
+                }
+                putchar('\n');
                 exit(130);
         default: /* PARSE_OPT_UNKNOWN */
                 if (ctx.argv[0][1] == '-') {
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 97b153fb4999..59561fd86278 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -40,6 +40,7 @@ enum parse_opt_option_flags {
         PARSE_OPT_LASTARG_DEFAULT = 16,
         PARSE_OPT_DISABLED = 32,
         PARSE_OPT_EXCLUSIVE = 64,
+        PARSE_OPT_NOEMPTY  = 128,
 };
 
 struct option;
@@ -122,6 +123,7 @@ struct option {
 #define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = check_vtype(v, long *), .help = (h) }
 #define OPT_U64(s, l, v, h)         { .type = OPTION_U64, .short_name = (s), .long_name = (l), .value = check_vtype(v, u64 *), .help = (h) }
 #define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h) }
+#define OPT_STRING_NOEMPTY(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h), .flags = PARSE_OPT_NOEMPTY}
 #define OPT_DATE(s, l, v, h) \
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
 #define OPT_CALLBACK(s, l, v, a, h, f) \
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 919937eb0be2..d8bb616ff57c 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -41,6 +41,7 @@
 #include "symbol.h"
 #include "thread.h"
 #include <api/fs/debugfs.h>
+#include <api/fs/tracefs.h>
 #include "trace-event.h"        /* For __maybe_unused */
 #include "probe-event.h"
 #include "probe-finder.h"
@@ -79,6 +80,7 @@ static int init_symbol_maps(bool user_only)
         int ret;
 
         symbol_conf.sort_by_name = true;
+        symbol_conf.allow_aliases = true;
         ret = symbol__init(NULL);
         if (ret < 0) {
                 pr_debug("Failed to init symbol map.\n");
@@ -133,6 +135,8 @@ static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
                 return NULL;
 
         kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
+        if (!kmap)
+                return NULL;
         return kmap->ref_reloc_sym;
 }
 
@@ -150,7 +154,7 @@ static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
                 sym = __find_kernel_function_by_name(name, &map);
                 if (sym)
                         return map->unmap_ip(map, sym->start) -
-                                (reloc) ? 0 : map->reloc;
+                                ((reloc) ? 0 : map->reloc);
         }
         return 0;
 }
@@ -177,6 +181,25 @@ static struct map *kernel_get_module_map(const char *module)
         return NULL;
 }
 
+static struct map *get_target_map(const char *target, bool user)
+{
+        /* Init maps of given executable or kernel */
+        if (user)
+                return dso__new_map(target);
+        else
+                return kernel_get_module_map(target);
+}
+
+static void put_target_map(struct map *map, bool user)
+{
+        if (map && user) {
+                /* Only the user map needs to be released */
+                dso__delete(map->dso);
+                map__delete(map);
+        }
+}
+
+
 static struct dso *kernel_get_module_dso(const char *module)
 {
         struct dso *dso;
@@ -248,6 +271,13 @@ out:
         return ret;
 }
 
+static void clear_perf_probe_point(struct perf_probe_point *pp)
+{
+        free(pp->file);
+        free(pp->function);
+        free(pp->lazy_line);
+}
+
 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 {
         int i;
@@ -257,6 +287,104 @@ static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 }
 
 #ifdef HAVE_DWARF_SUPPORT
+/*
+ * Some binaries like glibc have special symbols which are on the symbol
+ * table, but not in the debuginfo. If we can find the address of the
+ * symbol from map, we can translate the address back to the probe point.
+ */
+static int find_alternative_probe_point(struct debuginfo *dinfo,
+                                        struct perf_probe_point *pp,
+                                        struct perf_probe_point *result,
+                                        const char *target, bool uprobes)
+{
+        struct map *map = NULL;
+        struct symbol *sym;
+        u64 address = 0;
+        int ret = -ENOENT;
+
+        /* This can work only for function-name based one */
+        if (!pp->function || pp->file)
+                return -ENOTSUP;
+
+        map = get_target_map(target, uprobes);
+        if (!map)
+                return -EINVAL;
+
+        /* Find the address of given function */
+        map__for_each_symbol_by_name(map, pp->function, sym) {
+                if (uprobes)
+                        address = sym->start;
+                else
+                        address = map->unmap_ip(map, sym->start);
+                break;
+        }
+        if (!address) {
+                ret = -ENOENT;
+                goto out;
+        }
+        pr_debug("Symbol %s address found : %" PRIx64 "\n",
+                        pp->function, address);
+
+        ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
+                                          result);
+        if (ret <= 0)
+                ret = (!ret) ? -ENOENT : ret;
+        else {
+                result->offset += pp->offset;
+                result->line += pp->line;
+                result->retprobe = pp->retprobe;
+                ret = 0;
+        }
+
+out:
+        put_target_map(map, uprobes);
+        return ret;
+
+}
+
+static int get_alternative_probe_event(struct debuginfo *dinfo,
+                                       struct perf_probe_event *pev,
+                                       struct perf_probe_point *tmp,
+                                       const char *target)
+{
+        int ret;
+
+        memcpy(tmp, &pev->point, sizeof(*tmp));
+        memset(&pev->point, 0, sizeof(pev->point));
+        ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
+                                           target, pev->uprobes);
+        if (ret < 0)
+                memcpy(&pev->point, tmp, sizeof(*tmp));
+
+        return ret;
+}
+
+static int get_alternative_line_range(struct debuginfo *dinfo,
+                                      struct line_range *lr,
+                                      const char *target, bool user)
+{
+        struct perf_probe_point pp = { .function = lr->function,
+                                       .file = lr->file,
+                                       .line = lr->start };
+        struct perf_probe_point result;
+        int ret, len = 0;
+
+        memset(&result, 0, sizeof(result));
+
+        if (lr->end != INT_MAX)
+                len = lr->end - lr->start;
+        ret = find_alternative_probe_point(dinfo, &pp, &result,
+                                           target, user);
+        if (!ret) {
+                lr->function = result.function;
+                lr->file = result.file;
+                lr->start = result.line;
+                if (lr->end != INT_MAX)
+                        lr->end = lr->start + len;
+                clear_perf_probe_point(&pp);
+        }
+        return ret;
+}
 
 /* Open new debuginfo of given module */
 static struct debuginfo *open_debuginfo(const char *module, bool silent)
@@ -465,6 +593,7 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
                                           int max_tevs, const char *target)
 {
         bool need_dwarf = perf_probe_event_need_dwarf(pev);
+        struct perf_probe_point tmp;
         struct debuginfo *dinfo;
         int ntevs, ret = 0;
 
@@ -481,6 +610,20 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
         /* Searching trace events corresponding to a probe event */
         ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
 
+        if (ntevs == 0) {  /* Not found, retry with an alternative */
+                ret = get_alternative_probe_event(dinfo, pev, &tmp, target);
+                if (!ret) {
+                        ntevs = debuginfo__find_trace_events(dinfo, pev,
+                                                             tevs, max_tevs);
+                        /*
+                         * Write back to the original probe_event for
+                         * setting appropriate (user given) event name
+                         */
+                        clear_perf_probe_point(&pev->point);
+                        memcpy(&pev->point, &tmp, sizeof(tmp));
+                }
+        }
+
         debuginfo__delete(dinfo);
 
         if (ntevs > 0) {        /* Succeeded to find trace events */
@@ -495,11 +638,9 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
         }
 
         if (ntevs == 0) {       /* No error but failed to find probe point. */
-                pr_warning("Probe point '%s' not found in debuginfo.\n",
+                pr_warning("Probe point '%s' not found.\n",
                            synthesize_perf_probe_point(&pev->point));
-                if (need_dwarf)
-                        return -ENOENT;
-                return 0;
+                return -ENOENT;
         }
         /* Error path : ntevs < 0 */
         pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
@@ -514,63 +655,6 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
         return ntevs;
 }
 
-/*
- * Find a src file from a DWARF tag path. Prepend optional source path prefix
- * and chop off leading directories that do not exist. Result is passed back as
- * a newly allocated path on success.
- * Return 0 if file was found and readable, -errno otherwise.
- */
-static int get_real_path(const char *raw_path, const char *comp_dir,
-                         char **new_path)
-{
-        const char *prefix = symbol_conf.source_prefix;
-
-        if (!prefix) {
-                if (raw_path[0] != '/' && comp_dir)
-                        /* If not an absolute path, try to use comp_dir */
-                        prefix = comp_dir;
-                else {
-                        if (access(raw_path, R_OK) == 0) {
-                                *new_path = strdup(raw_path);
-                                return 0;
-                        } else
-                                return -errno;
-                }
-        }
-
-        *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
-        if (!*new_path)
-                return -ENOMEM;
-
-        for (;;) {
-                sprintf(*new_path, "%s/%s", prefix, raw_path);
-
-                if (access(*new_path, R_OK) == 0)
-                        return 0;
-
-                if (!symbol_conf.source_prefix)
-                        /* In case of searching comp_dir, don't retry */
-                        return -errno;
-
-                switch (errno) {
-                case ENAMETOOLONG:
-                case ENOENT:
-                case EROFS:
-                case EFAULT:
-                        raw_path = strchr(++raw_path, '/');
-                        if (!raw_path) {
-                                zfree(new_path);
-                                return -ENOENT;
-                        }
-                        continue;
-
-                default:
-                        zfree(new_path);
-                        return -errno;
-                }
-        }
-}
-
 #define LINEBUF_SIZE 256
 #define NR_ADDITIONAL_LINES 2
 
@@ -622,7 +706,8 @@ static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
  * Show line-range always requires debuginfo to find source file and
  * line number.
  */
-static int __show_line_range(struct line_range *lr, const char *module)
+static int __show_line_range(struct line_range *lr, const char *module,
+                             bool user)
 {
         int l = 1;
         struct int_node *ln;
@@ -638,6 +723,11 @@ static int __show_line_range(struct line_range *lr, const char *module)
                 return -ENOENT;
 
         ret = debuginfo__find_line_range(dinfo, lr);
+        if (!ret) {     /* Not found, retry with an alternative */
+                ret = get_alternative_line_range(dinfo, lr, module, user);
+                if (!ret)
+                        ret = debuginfo__find_line_range(dinfo, lr);
+        }
         debuginfo__delete(dinfo);
         if (ret == 0 || ret == -ENOENT) {
                 pr_warning("Specified source line is not found.\n");
@@ -650,7 +740,11 @@ static int __show_line_range(struct line_range *lr, const char *module)
         /* Convert source file path */
         tmp = lr->path;
         ret = get_real_path(tmp, lr->comp_dir, &lr->path);
-        free(tmp);      /* Free old path */
+
+        /* Free old path when new path is assigned */
+        if (tmp != lr->path)
+                free(tmp);
+
         if (ret < 0) {
                 pr_warning("Failed to find source file path.\n");
                 return ret;
@@ -707,7 +801,7 @@ int show_line_range(struct line_range *lr, const char *module, bool user)
         ret = init_symbol_maps(user);
         if (ret < 0)
                 return ret;
-        ret = __show_line_range(lr, module);
+        ret = __show_line_range(lr, module, user);
         exit_symbol_maps();
 
         return ret;
@@ -716,12 +810,13 @@ int show_line_range(struct line_range *lr, const char *module, bool user)
 static int show_available_vars_at(struct debuginfo *dinfo,
                                   struct perf_probe_event *pev,
                                   int max_vls, struct strfilter *_filter,
-                                  bool externs)
+                                  bool externs, const char *target)
 {
         char *buf;
         int ret, i, nvars;
         struct str_node *node;
         struct variable_list *vls = NULL, *vl;
+        struct perf_probe_point tmp;
         const char *var;
 
         buf = synthesize_perf_probe_point(&pev->point);
@@ -731,6 +826,15 @@ static int show_available_vars_at(struct debuginfo *dinfo,
 
         ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
                                                 max_vls, externs);
+        if (!ret) {  /* Not found, retry with an alternative */
+                ret = get_alternative_probe_event(dinfo, pev, &tmp, target);
+                if (!ret) {
+                        ret = debuginfo__find_available_vars_at(dinfo, pev,
+                                                &vls, max_vls, externs);
+                        /* Release the old probe_point */
+                        clear_perf_probe_point(&tmp);
+                }
+        }
         if (ret <= 0) {
                 if (ret == 0 || ret == -ENOENT) {
                         pr_err("Failed to find the address of %s\n", buf);
@@ -793,7 +897,7 @@ int show_available_vars(struct perf_probe_event *pevs, int npevs,
 
         for (i = 0; i < npevs && ret >= 0; i++)
                 ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
-                                             externs);
+                                             externs, module);
 
         debuginfo__delete(dinfo);
 out:
@@ -1739,15 +1843,13 @@ static int convert_to_perf_probe_event(struct probe_trace_event *tev,
 
 void clear_perf_probe_event(struct perf_probe_event *pev)
 {
-        struct perf_probe_point *pp = &pev->point;
         struct perf_probe_arg_field *field, *next;
         int i;
 
         free(pev->event);
         free(pev->group);
-        free(pp->file);
-        free(pp->function);
-        free(pp->lazy_line);
+        free(pev->target);
+        clear_perf_probe_point(&pev->point);
 
         for (i = 0; i < pev->nargs; i++) {
                 free(pev->args[i].name);
@@ -1805,7 +1907,7 @@ static void print_open_warning(int err, bool is_kprobe)
                            " - please rebuild kernel with %s.\n",
                            is_kprobe ? 'k' : 'u', config);
         } else if (err == -ENOTSUP)
-                pr_warning("Debugfs is not mounted.\n");
+                pr_warning("Tracefs or debugfs is not mounted.\n");
         else
                 pr_warning("Failed to open %cprobe_events: %s\n",
                            is_kprobe ? 'k' : 'u',
@@ -1816,7 +1918,7 @@ static void print_both_open_warning(int kerr, int uerr)
 {
         /* Both kprobes and uprobes are disabled, warn it. */
         if (kerr == -ENOTSUP && uerr == -ENOTSUP)
-                pr_warning("Debugfs is not mounted.\n");
+                pr_warning("Tracefs or debugfs is not mounted.\n");
         else if (kerr == -ENOENT && uerr == -ENOENT)
                 pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
                            "or/and CONFIG_UPROBE_EVENTS.\n");
@@ -1833,13 +1935,20 @@ static int open_probe_events(const char *trace_file, bool readwrite)
 {
         char buf[PATH_MAX];
         const char *__debugfs;
+        const char *tracing_dir = "";
         int ret;
 
-        __debugfs = debugfs_find_mountpoint();
-        if (__debugfs == NULL)
-                return -ENOTSUP;
+        __debugfs = tracefs_find_mountpoint();
+        if (__debugfs == NULL) {
+                tracing_dir = "tracing/";
+
+                __debugfs = debugfs_find_mountpoint();
+                if (__debugfs == NULL)
+                        return -ENOTSUP;
+        }
 
-        ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
+        ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
+                         __debugfs, tracing_dir, trace_file);
         if (ret >= 0) {
                 pr_debug("Opening %s write=%d\n", buf, readwrite);
                 if (readwrite && !probe_event_dry_run)
@@ -1855,12 +1964,12 @@ static int open_probe_events(const char *trace_file, bool readwrite)
 
 static int open_kprobe_events(bool readwrite)
 {
-        return open_probe_events("tracing/kprobe_events", readwrite);
+        return open_probe_events("kprobe_events", readwrite);
 }
 
 static int open_uprobe_events(bool readwrite)
 {
-        return open_probe_events("tracing/uprobe_events", readwrite);
+        return open_probe_events("uprobe_events", readwrite);
 }
 
 /* Get raw string list of current kprobe_events  or uprobe_events */
@@ -1895,6 +2004,95 @@ static struct strlist *get_probe_trace_command_rawlist(int fd)
         return sl;
 }
 
+struct kprobe_blacklist_node {
+        struct list_head list;
+        unsigned long start;
+        unsigned long end;
+        char *symbol;
+};
+
+static void kprobe_blacklist__delete(struct list_head *blacklist)
+{
+        struct kprobe_blacklist_node *node;
+
+        while (!list_empty(blacklist)) {
+                node = list_first_entry(blacklist,
+                                        struct kprobe_blacklist_node, list);
+                list_del(&node->list);
+                free(node->symbol);
+                free(node);
+        }
+}
+
+static int kprobe_blacklist__load(struct list_head *blacklist)
+{
+        struct kprobe_blacklist_node *node;
+        const char *__debugfs = debugfs_find_mountpoint();
+        char buf[PATH_MAX], *p;
+        FILE *fp;
+        int ret;
+
+        if (__debugfs == NULL)
+                return -ENOTSUP;
+
+        ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
+        if (ret < 0)
+                return ret;
+
+        fp = fopen(buf, "r");
+        if (!fp)
+                return -errno;
+
+        ret = 0;
+        while (fgets(buf, PATH_MAX, fp)) {
+                node = zalloc(sizeof(*node));
+                if (!node) {
+                        ret = -ENOMEM;
+                        break;
+                }
+                INIT_LIST_HEAD(&node->list);
+                list_add_tail(&node->list, blacklist);
+                if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
+                        ret = -EINVAL;
+                        break;
+                }
+                p = strchr(buf, '\t');
+                if (p) {
+                        p++;
+                        if (p[strlen(p) - 1] == '\n')
+                                p[strlen(p) - 1] = '\0';
+                } else
+                        p = (char *)"unknown";
+                node->symbol = strdup(p);
+                if (!node->symbol) {
+                        ret = -ENOMEM;
+                        break;
+                }
+                pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
+                          node->start, node->end, node->symbol);
+                ret++;
+        }
+        if (ret < 0)
+                kprobe_blacklist__delete(blacklist);
+        fclose(fp);
+
+        return ret;
+}
+
+static struct kprobe_blacklist_node *
+kprobe_blacklist__find_by_address(struct list_head *blacklist,
+                                  unsigned long address)
+{
+        struct kprobe_blacklist_node *node;
+
+        list_for_each_entry(node, blacklist, list) {
+                if (node->start <= address && address <= node->end)
+                        return node;
+        }
+
+        return NULL;
+}
+
 /* Show an event */
 static int show_perf_probe_event(struct perf_probe_event *pev,
                                  const char *module)
@@ -2100,6 +2298,27 @@ static int get_new_event_name(char *buf, size_t len, const char *base,
         return ret;
 }
 
+/* Warn if the current kernel's uprobe implementation is old */
+static void warn_uprobe_event_compat(struct probe_trace_event *tev)
+{
+        int i;
+        char *buf = synthesize_probe_trace_command(tev);
+
+        /* Old uprobe event doesn't support memory dereference */
+        if (!tev->uprobes || tev->nargs == 0 || !buf)
+                goto out;
+
+        for (i = 0; i < tev->nargs; i++)
+                if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
+                        pr_warning("Please upgrade your kernel to at least "
+                                   "3.14 to have access to feature %s\n",
+                                   tev->args[i].value);
+                        break;
+                }
+out:
+        free(buf);
+}
+
 static int __add_probe_trace_events(struct perf_probe_event *pev,
                                      struct probe_trace_event *tevs,
                                      int ntevs, bool allow_suffix)
@@ -2109,6 +2328,8 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
         char buf[64];
         const char *event, *group;
         struct strlist *namelist;
+        LIST_HEAD(blacklist);
+        struct kprobe_blacklist_node *node;
 
         if (pev->uprobes)
                 fd = open_uprobe_events(true);
@@ -2126,11 +2347,25 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
                 pr_debug("Failed to get current event list.\n");
                 return -EIO;
         }
+        /* Get kprobe blacklist if exists */
+        if (!pev->uprobes) {
+                ret = kprobe_blacklist__load(&blacklist);
+                if (ret < 0)
+                        pr_debug("No kprobe blacklist support, ignored\n");
+        }
 
         ret = 0;
         pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
         for (i = 0; i < ntevs; i++) {
                 tev = &tevs[i];
+                /* Ensure that the address is NOT blacklisted */
+                node = kprobe_blacklist__find_by_address(&blacklist,
+                                                         tev->point.address);
+                if (node) {
+                        pr_warning("Warning: Skipped probing on blacklisted function: %s\n", node->symbol);
+                        continue;
+                }
+
                 if (pev->event)
                         event = pev->event;
                 else
@@ -2180,14 +2415,18 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
                  */
                 allow_suffix = true;
         }
+        if (ret == -EINVAL && pev->uprobes)
+                warn_uprobe_event_compat(tev);
 
-        if (ret >= 0) {
+        /* Note that it is possible to skip all events because of blacklist */
+        if (ret >= 0 && tev->event) {
                 /* Show how to use the event. */
                 pr_info("\nYou can now use it in all perf tools, such as:\n\n");
                 pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
                          tev->event);
         }
 
+        kprobe_blacklist__delete(&blacklist);
         strlist__delete(namelist);
         close(fd);
         return ret;
@@ -2199,8 +2438,7 @@ static int find_probe_functions(struct map *map, char *name)
         struct symbol *sym;
 
         map__for_each_symbol_by_name(map, name, sym) {
-                if (sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL)
-                        found++;
+                found++;
         }
 
         return found;
@@ -2218,7 +2456,6 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
                                             int max_tevs, const char *target)
 {
         struct map *map = NULL;
-        struct kmap *kmap = NULL;
         struct ref_reloc_sym *reloc_sym = NULL;
         struct symbol *sym;
         struct probe_trace_event *tev;
@@ -2227,11 +2464,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
         int num_matched_functions;
         int ret, i;
 
-        /* Init maps of given executable or kernel */
-        if (pev->uprobes)
-                map = dso__new_map(target);
-        else
-                map = kernel_get_module_map(target);
+        map = get_target_map(target, pev->uprobes);
         if (!map) {
                 ret = -EINVAL;
                 goto out;
@@ -2255,8 +2488,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
         }
 
         if (!pev->uprobes && !pp->retprobe) {
-                kmap = map__kmap(map);
-                reloc_sym = kmap->ref_reloc_sym;
+                reloc_sym = kernel_get_ref_reloc_sym();
                 if (!reloc_sym) {
                         pr_warning("Relocated base symbol is not found!\n");
                         ret = -EINVAL;
@@ -2324,11 +2556,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
         }
 
 out:
-        if (map && pev->uprobes) {
-                /* Only when using uprobe(exec) map needs to be released */
-                dso__delete(map->dso);
-                map__delete(map);
-        }
+        put_target_map(map, pev->uprobes);
         return ret;
 
 nomem_out:
@@ -2369,7 +2597,7 @@ struct __event_package {
 };
 
 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
-                          int max_tevs, const char *target, bool force_add)
+                          int max_tevs, bool force_add)
 {
         int i, j, ret;
         struct __event_package *pkgs;
@@ -2393,7 +2621,7 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
                 ret  = convert_to_probe_trace_events(pkgs[i].pev,
                                                      &pkgs[i].tevs,
                                                      max_tevs,
-                                                     target);
+                                                     pkgs[i].pev->target);
                 if (ret < 0)
                         goto end;
                 pkgs[i].ntevs = ret;
@@ -2568,8 +2796,7 @@ static struct strfilter *available_func_filter;
 static int filter_available_functions(struct map *map __maybe_unused,
                                       struct symbol *sym)
 {
-        if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
-            strfilter__compare(available_func_filter, sym->name))
+        if (strfilter__compare(available_func_filter, sym->name))
                 return 0;
         return 1;
 }
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index e01e9943139f..d6b783447be9 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -73,7 +73,8 @@ struct perf_probe_event {
         char                    *group; /* Group name */
         struct perf_probe_point point;  /* Probe point */
         int                     nargs;  /* Number of arguments */
-        bool                    uprobes;
+        bool                    uprobes;        /* Uprobe event flag */
+        char                    *target;        /* Target binary */
         struct perf_probe_arg   *args;  /* Arguments */
 };
 
@@ -124,8 +125,7 @@ extern int line_range__init(struct line_range *lr);
 extern const char *kernel_get_module_path(const char *module);
 
 extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
-                                 int max_probe_points, const char *module,
-                                 bool force_add);
+                                 int max_probe_points, bool force_add);
 extern int del_perf_probe_events(struct strlist *dellist);
 extern int show_perf_probe_events(void);
 extern int show_line_range(struct line_range *lr, const char *module,
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index b5247d777f0e..b5bf9d5efeaf 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -456,11 +456,12 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
                         return -EINVAL;
                 }
                 if (field->name[0] == '[') {
-                        pr_err("Semantic error: %s is not a pointor"
+                        pr_err("Semantic error: %s is not a pointer"
                                " nor array.\n", varname);
                         return -EINVAL;
                 }
-                if (field->ref) {
+                /* While prcessing unnamed field, we don't care about this */
+                if (field->ref && dwarf_diename(vr_die)) {
                         pr_err("Semantic error: %s must be referred by '.'\n",
                                field->name);
                         return -EINVAL;
@@ -491,6 +492,11 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
         }
         ref->offset += (long)offs;
 
+        /* If this member is unnamed, we need to reuse this field */
+        if (!dwarf_diename(die_mem))
+                return convert_variable_fields(die_mem, varname, field,
+                                                &ref, die_mem);
+
 next:
         /* Converting next field */
         if (field->next)
@@ -849,11 +855,22 @@ static int probe_point_lazy_walker(const char *fname, int lineno,
 static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
         int ret = 0;
+        char *fpath;
 
         if (intlist__empty(pf->lcache)) {
+                const char *comp_dir;
+
+                comp_dir = cu_get_comp_dir(&pf->cu_die);
+                ret = get_real_path(pf->fname, comp_dir, &fpath);
+                if (ret < 0) {
+                        pr_warning("Failed to find source file path.\n");
+                        return ret;
+                }
+
                 /* Matching lazy line pattern */
-                ret = find_lazy_match_lines(pf->lcache, pf->fname,
+                ret = find_lazy_match_lines(pf->lcache, fpath,
                                             pf->pev->point.lazy_line);
+                free(fpath);
                 if (ret <= 0)
                         return ret;
         }
@@ -915,17 +932,13 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
                 dwarf_decl_line(sp_die, &pf->lno);
                 pf->lno += pp->line;
                 param->retval = find_probe_point_by_line(pf);
-        } else if (!dwarf_func_inline(sp_die)) {
+        } else if (die_is_func_instance(sp_die)) {
+                /* Instances always have the entry address */
+                dwarf_entrypc(sp_die, &pf->addr);
                 /* Real function */
                 if (pp->lazy_line)
                         param->retval = find_probe_point_lazy(sp_die, pf);
                 else {
-                        if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
-                                pr_warning("Failed to get entry address of "
-                                           "%s.\n", dwarf_diename(sp_die));
-                                param->retval = -ENOENT;
-                                return DWARF_CB_ABORT;
-                        }
                         pf->addr += pp->offset;
                         /* TODO: Check the address in this function */
                         param->retval = call_probe_finder(sp_die, pf);
@@ -1053,7 +1066,7 @@ static int debuginfo__find_probes(struct debuginfo *dbg,
                         if (pp->function)
                                 ret = find_probe_point_by_func(pf);
                         else if (pp->lazy_line)
-                                ret = find_probe_point_lazy(NULL, pf);
+                                ret = find_probe_point_lazy(&pf->cu_die, pf);
                         else {
                                 pf->lno = pp->line;
                                 ret = find_probe_point_by_line(pf);
@@ -1349,11 +1362,8 @@ int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
         const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
         int baseline = 0, lineno = 0, ret = 0;
 
-        /* Adjust address with bias */
-        addr += dbg->bias;
-
         /* Find cu die */
-        if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr - dbg->bias, &cudie)) {
+        if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) {
                 pr_warning("Failed to find debug information for address %lx\n",
                            addr);
                 ret = -EINVAL;
@@ -1536,7 +1546,7 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
                 pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
                 lr->start = lf->lno_s;
                 lr->end = lf->lno_e;
-                if (dwarf_func_inline(sp_die))
+                if (!die_is_func_instance(sp_die))
                         param->retval = die_walk_instances(sp_die,
                                                 line_range_inline_cb, lf);
                 else
@@ -1623,3 +1633,61 @@ found:
         return (ret < 0) ? ret : lf.found;
 }
 
+/*
+ * Find a src file from a DWARF tag path. Prepend optional source path prefix
+ * and chop off leading directories that do not exist. Result is passed back as
+ * a newly allocated path on success.
+ * Return 0 if file was found and readable, -errno otherwise.
+ */
+int get_real_path(const char *raw_path, const char *comp_dir,
+                         char **new_path)
+{
+        const char *prefix = symbol_conf.source_prefix;
+
+        if (!prefix) {
+                if (raw_path[0] != '/' && comp_dir)
+                        /* If not an absolute path, try to use comp_dir */
+                        prefix = comp_dir;
+                else {
+                        if (access(raw_path, R_OK) == 0) {
+                                *new_path = strdup(raw_path);
+                                return *new_path ? 0 : -ENOMEM;
+                        } else
+                                return -errno;
+                }
+        }
+
+        *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
+        if (!*new_path)
+                return -ENOMEM;
+
+        for (;;) {
+                sprintf(*new_path, "%s/%s", prefix, raw_path);
+
+                if (access(*new_path, R_OK) == 0)
+                        return 0;
+
+                if (!symbol_conf.source_prefix) {
+                        /* In case of searching comp_dir, don't retry */
+                        zfree(new_path);
+                        return -errno;
+                }
+
+                switch (errno) {
+                case ENAMETOOLONG:
+                case ENOENT:
+                case EROFS:
+                case EFAULT:
+                        raw_path = strchr(++raw_path, '/');
+                        if (!raw_path) {
+                                zfree(new_path);
+                                return -ENOENT;
+                        }
+                        continue;
+
+                default:
+                        zfree(new_path);
+                        return -errno;
+                }
+        }
+}
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 92590b2c7e1c..ebf8c8c81453 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -55,6 +55,10 @@ extern int debuginfo__find_available_vars_at(struct debuginfo *dbg,
                                              struct variable_list **vls,
                                              int max_points, bool externs);
 
+/* Find a src file from a DWARF tag path */
+int get_real_path(const char *raw_path, const char *comp_dir,
+                         char **new_path);
+
 struct probe_finder {
         struct perf_probe_event *pev;           /* Target probe event */
 
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index 6c6a6953fa93..4d28624a1eca 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -17,6 +17,5 @@ util/xyarray.c
 util/cgroup.c
 util/rblist.c
 util/strlist.c
-../lib/api/fs/fs.c
 util/trace-event.c
 ../../lib/rbtree.c
diff --git a/tools/perf/util/scripting-engines/Build b/tools/perf/util/scripting-engines/Build
new file mode 100644
index 000000000000..6516e220c247
--- /dev/null
+++ b/tools/perf/util/scripting-engines/Build
@@ -0,0 +1,6 @@
+libperf-$(CONFIG_LIBPERL)   += trace-event-perl.o
+libperf-$(CONFIG_LIBPYTHON) += trace-event-python.o
+
+CFLAGS_trace-event-perl.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default
+
+CFLAGS_trace-event-python.o += $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 22ebc46226e7..430b5d27828e 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -214,6 +214,11 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->hex.field);
                 define_event_symbols(event, ev_name, args->hex.size);
                 break;
+        case 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_STRING:
@@ -355,10 +360,9 @@ static void perl_process_event_generic(union perf_event *event,
 static void perl_process_event(union perf_event *event,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
-                               struct thread *thread,
-                               struct addr_location *al __maybe_unused)
+                               struct addr_location *al)
 {
-        perl_process_tracepoint(sample, evsel, thread);
+        perl_process_tracepoint(sample, evsel, al->thread);
         perl_process_event_generic(event, sample, evsel);
 }
 
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 0c815a40a6e8..5544b8cdd1ee 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -231,6 +231,11 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->hex.field);
                 define_event_symbols(event, ev_name, args->hex.size);
                 break;
+        case 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:
                 break;
         case PRINT_TYPE:
@@ -376,7 +381,6 @@ exit:
 
 static void python_process_tracepoint(struct perf_sample *sample,
                                       struct perf_evsel *evsel,
-                                      struct thread *thread,
                                       struct addr_location *al)
 {
         struct event_format *event = evsel->tp_format;
@@ -390,7 +394,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
         int cpu = sample->cpu;
         void *data = sample->raw_data;
         unsigned long long nsecs = sample->time;
-        const char *comm = thread__comm_str(thread);
+        const char *comm = thread__comm_str(al->thread);
 
         t = PyTuple_New(MAX_FIELDS);
         if (!t)
@@ -675,7 +679,7 @@ static int python_export_sample(struct db_export *dbe,
         tuple_set_u64(t, 0, es->db_id);
         tuple_set_u64(t, 1, es->evsel->db_id);
         tuple_set_u64(t, 2, es->al->machine->db_id);
-        tuple_set_u64(t, 3, es->thread->db_id);
+        tuple_set_u64(t, 3, es->al->thread->db_id);
         tuple_set_u64(t, 4, es->comm_db_id);
         tuple_set_u64(t, 5, es->dso_db_id);
         tuple_set_u64(t, 6, es->sym_db_id);
@@ -761,7 +765,6 @@ static int python_process_call_return(struct call_return *cr, void *data)
 
 static void python_process_general_event(struct perf_sample *sample,
                                          struct perf_evsel *evsel,
-                                         struct thread *thread,
                                          struct addr_location *al)
 {
         PyObject *handler, *t, *dict, *callchain, *dict_sample;
@@ -811,7 +814,7 @@ static void python_process_general_event(struct perf_sample *sample,
         pydict_set_item_string_decref(dict, "raw_buf", PyString_FromStringAndSize(
                         (const char *)sample->raw_data, sample->raw_size));
         pydict_set_item_string_decref(dict, "comm",
-                        PyString_FromString(thread__comm_str(thread)));
+                        PyString_FromString(thread__comm_str(al->thread)));
         if (al->map) {
                 pydict_set_item_string_decref(dict, "dso",
                         PyString_FromString(al->map->dso->name));
@@ -838,22 +841,20 @@ exit:
 static void python_process_event(union perf_event *event,
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel,
-                                 struct thread *thread,
                                  struct addr_location *al)
 {
         struct tables *tables = &tables_global;
 
         switch (evsel->attr.type) {
         case PERF_TYPE_TRACEPOINT:
-                python_process_tracepoint(sample, evsel, thread, al);
+                python_process_tracepoint(sample, evsel, al);
                 break;
         /* Reserve for future process_hw/sw/raw APIs */
         default:
                 if (tables->db_export_mode)
-                        db_export__sample(&tables->dbe, event, sample, evsel,
-                                          thread, al);
+                        db_export__sample(&tables->dbe, event, sample, evsel, al);
                 else
-                        python_process_general_event(sample, evsel, thread, al);
+                        python_process_general_event(sample, evsel, al);
         }
 }
 
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 0baf75f12b7c..0c74012575ac 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -16,6 +16,12 @@
 #include "perf_regs.h"
 #include "asm/bug.h"
 
+static int machines__deliver_event(struct machines *machines,
+                                   struct perf_evlist *evlist,
+                                   union perf_event *event,
+                                   struct perf_sample *sample,
+                                   struct perf_tool *tool, u64 file_offset);
+
 static int perf_session__open(struct perf_session *session)
 {
         struct perf_data_file *file = session->file;
@@ -86,6 +92,23 @@ static void perf_session__set_comm_exec(struct perf_session *session)
         machines__set_comm_exec(&session->machines, comm_exec);
 }
 
+static int ordered_events__deliver_event(struct ordered_events *oe,
+                                         struct ordered_event *event)
+{
+        struct perf_sample sample;
+        struct perf_session *session = container_of(oe, struct perf_session,
+                                                    ordered_events);
+        int ret = perf_evlist__parse_sample(session->evlist, event->event, &sample);
+
+        if (ret) {
+                pr_err("Can't parse sample, err = %d\n", ret);
+                return ret;
+        }
+
+        return machines__deliver_event(&session->machines, session->evlist, event->event,
+                                       &sample, session->tool, event->file_offset);
+}
+
 struct perf_session *perf_session__new(struct perf_data_file *file,
                                        bool repipe, struct perf_tool *tool)
 {
@@ -95,8 +118,9 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                 goto out;
 
         session->repipe = repipe;
-        ordered_events__init(&session->ordered_events);
+        session->tool   = tool;
         machines__init(&session->machines);
+        ordered_events__init(&session->ordered_events, ordered_events__deliver_event);
 
         if (file) {
                 if (perf_data_file__open(file))
@@ -138,11 +162,6 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
         return NULL;
 }
 
-static void perf_session__delete_dead_threads(struct perf_session *session)
-{
-        machine__delete_dead_threads(&session->machines.host);
-}
-
 static void perf_session__delete_threads(struct perf_session *session)
 {
         machine__delete_threads(&session->machines.host);
@@ -167,7 +186,6 @@ static void perf_session_env__delete(struct perf_session_env *env)
 void perf_session__delete(struct perf_session *session)
 {
         perf_session__destroy_kernel_maps(session);
-        perf_session__delete_dead_threads(session);
         perf_session__delete_threads(session);
         perf_session_env__delete(&session->header.env);
         machines__exit(&session->machines);
@@ -215,10 +233,17 @@ static int process_event_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
+static int process_build_id_stub(struct perf_tool *tool __maybe_unused,
+                                 union perf_event *event __maybe_unused,
+                                 struct perf_session *session __maybe_unused)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
 static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
                                        union perf_event *event __maybe_unused,
-                                       struct perf_session *perf_session
-                                       __maybe_unused)
+                                       struct ordered_events *oe __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
@@ -226,7 +251,7 @@ static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
 
 static int process_finished_round(struct perf_tool *tool,
                                   union perf_event *event,
-                                  struct perf_session *session);
+                                  struct ordered_events *oe);
 
 static int process_id_index_stub(struct perf_tool *tool __maybe_unused,
                                  union perf_event *event __maybe_unused,
@@ -264,7 +289,7 @@ void perf_tool__fill_defaults(struct perf_tool *tool)
         if (tool->tracing_data == NULL)
                 tool->tracing_data = process_event_synth_tracing_data_stub;
         if (tool->build_id == NULL)
-                tool->build_id = process_finished_round_stub;
+                tool->build_id = process_build_id_stub;
         if (tool->finished_round == NULL) {
                 if (tool->ordered_events)
                         tool->finished_round = process_finished_round;
@@ -514,54 +539,80 @@ static perf_event__swap_op perf_event__swap_ops[] = {
  *      Flush every events below timestamp 7
  *      etc...
  */
-static int process_finished_round(struct perf_tool *tool,
+static int process_finished_round(struct perf_tool *tool __maybe_unused,
                                   union perf_event *event __maybe_unused,
-                                  struct perf_session *session)
+                                  struct ordered_events *oe)
 {
-        return ordered_events__flush(session, tool, OE_FLUSH__ROUND);
+        return ordered_events__flush(oe, OE_FLUSH__ROUND);
 }
 
-int perf_session_queue_event(struct perf_session *s, union perf_event *event,
-                             struct perf_tool *tool, struct perf_sample *sample,
-                             u64 file_offset)
+int perf_session__queue_event(struct perf_session *s, union perf_event *event,
+                              struct perf_sample *sample, u64 file_offset)
 {
-        struct ordered_events *oe = &s->ordered_events;
-        u64 timestamp = sample->time;
-        struct ordered_event *new;
-
-        if (!timestamp || timestamp == ~0ULL)
-                return -ETIME;
+        return ordered_events__queue(&s->ordered_events, event, sample, file_offset);
+}
 
-        if (timestamp < oe->last_flush) {
-                pr_oe_time(timestamp,      "out of order event\n");
-                pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
-                           oe->last_flush_type);
+static void callchain__lbr_callstack_printf(struct perf_sample *sample)
+{
+        struct ip_callchain *callchain = sample->callchain;
+        struct branch_stack *lbr_stack = sample->branch_stack;
+        u64 kernel_callchain_nr = callchain->nr;
+        unsigned int i;
 
-                s->stats.nr_unordered_events++;
+        for (i = 0; i < kernel_callchain_nr; i++) {
+                if (callchain->ips[i] == PERF_CONTEXT_USER)
+                        break;
         }
 
-        new = ordered_events__new(oe, timestamp, event);
-        if (!new) {
-                ordered_events__flush(s, tool, OE_FLUSH__HALF);
-                new = ordered_events__new(oe, timestamp, event);
-        }
+        if ((i != kernel_callchain_nr) && lbr_stack->nr) {
+                u64 total_nr;
+                /*
+                 * LBR callstack can only get user call chain,
+                 * i is kernel call chain number,
+                 * 1 is PERF_CONTEXT_USER.
+                 *
+                 * The user call chain is stored in LBR registers.
+                 * LBR are pair registers. The caller is stored
+                 * in "from" register, while the callee is stored
+                 * in "to" register.
+                 * For example, there is a call stack
+                 * "A"->"B"->"C"->"D".
+                 * The LBR registers will recorde like
+                 * "C"->"D", "B"->"C", "A"->"B".
+                 * So only the first "to" register and all "from"
+                 * registers are needed to construct the whole stack.
+                 */
+                total_nr = i + 1 + lbr_stack->nr + 1;
+                kernel_callchain_nr = i + 1;
 
-        if (!new)
-                return -ENOMEM;
+                printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);
 
-        new->file_offset = file_offset;
-        return 0;
+                for (i = 0; i < kernel_callchain_nr; i++)
+                        printf("..... %2d: %016" PRIx64 "\n",
+                               i, callchain->ips[i]);
+
+                printf("..... %2d: %016" PRIx64 "\n",
+                       (int)(kernel_callchain_nr), lbr_stack->entries[0].to);
+                for (i = 0; i < lbr_stack->nr; i++)
+                        printf("..... %2d: %016" PRIx64 "\n",
+                               (int)(i + kernel_callchain_nr + 1), lbr_stack->entries[i].from);
+        }
 }
 
-static void callchain__printf(struct perf_sample *sample)
+static void callchain__printf(struct perf_evsel *evsel,
+                              struct perf_sample *sample)
 {
         unsigned int i;
+        struct ip_callchain *callchain = sample->callchain;
+
+        if (has_branch_callstack(evsel))
+                callchain__lbr_callstack_printf(sample);
 
-        printf("... chain: nr:%" PRIu64 "\n", sample->callchain->nr);
+        printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
 
-        for (i = 0; i < sample->callchain->nr; i++)
+        for (i = 0; i < callchain->nr; i++)
                 printf("..... %2d: %016" PRIx64 "\n",
-                       i, sample->callchain->ips[i]);
+                       i, callchain->ips[i]);
 }
 
 static void branch_stack__printf(struct perf_sample *sample)
@@ -636,14 +687,14 @@ static void stack_user__printf(struct stack_dump *dump)
                dump->size, dump->offset);
 }
 
-static void perf_session__print_tstamp(struct perf_session *session,
+static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
                                        union perf_event *event,
                                        struct perf_sample *sample)
 {
-        u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
+        u64 sample_type = __perf_evlist__combined_sample_type(evlist);
 
         if (event->header.type != PERF_RECORD_SAMPLE &&
-            !perf_evlist__sample_id_all(session->evlist)) {
+            !perf_evlist__sample_id_all(evlist)) {
                 fputs("-1 -1 ", stdout);
                 return;
         }
@@ -685,7 +736,7 @@ static void sample_read__printf(struct perf_sample *sample, u64 read_format)
                         sample->read.one.id, sample->read.one.value);
 }
 
-static void dump_event(struct perf_session *session, union perf_event *event,
+static void dump_event(struct perf_evlist *evlist, union perf_event *event,
                        u64 file_offset, struct perf_sample *sample)
 {
         if (!dump_trace)
@@ -697,7 +748,7 @@ static void dump_event(struct perf_session *session, union perf_event *event,
         trace_event(event);
 
         if (sample)
-                perf_session__print_tstamp(session, event, sample);
+                perf_evlist__print_tstamp(evlist, event, sample);
 
         printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
                event->header.size, perf_event__name(event->header.type));
@@ -718,9 +769,9 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
         sample_type = evsel->attr.sample_type;
 
         if (sample_type & PERF_SAMPLE_CALLCHAIN)
-                callchain__printf(sample);
+                callchain__printf(evsel, sample);
 
-        if (sample_type & PERF_SAMPLE_BRANCH_STACK)
+        if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !has_branch_callstack(evsel))
                 branch_stack__printf(sample);
 
         if (sample_type & PERF_SAMPLE_REGS_USER)
@@ -745,8 +796,7 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
                 sample_read__printf(sample, evsel->attr.read_format);
 }
 
-static struct machine *
-        perf_session__find_machine_for_cpumode(struct perf_session *session,
+static struct machine *machines__find_for_cpumode(struct machines *machines,
                                                union perf_event *event,
                                                struct perf_sample *sample)
 {
@@ -764,26 +814,24 @@ static struct machine *
                 else
                         pid = sample->pid;
 
-                machine = perf_session__find_machine(session, pid);
+                machine = machines__find(machines, pid);
                 if (!machine)
-                        machine = perf_session__findnew_machine(session,
-                                                DEFAULT_GUEST_KERNEL_ID);
+                        machine = machines__find(machines, DEFAULT_GUEST_KERNEL_ID);
                 return machine;
         }
 
-        return &session->machines.host;
+        return &machines->host;
 }
 
-static int deliver_sample_value(struct perf_session *session,
+static int deliver_sample_value(struct perf_evlist *evlist,
                                 struct perf_tool *tool,
                                 union perf_event *event,
                                 struct perf_sample *sample,
                                 struct sample_read_value *v,
                                 struct machine *machine)
 {
-        struct perf_sample_id *sid;
+        struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
 
-        sid = perf_evlist__id2sid(session->evlist, v->id);
         if (sid) {
                 sample->id     = v->id;
                 sample->period = v->value - sid->period;
@@ -791,14 +839,14 @@ static int deliver_sample_value(struct perf_session *session,
         }
 
         if (!sid || sid->evsel == NULL) {
-                ++session->stats.nr_unknown_id;
+                ++evlist->stats.nr_unknown_id;
                 return 0;
         }
 
         return tool->sample(tool, event, sample, sid->evsel, machine);
 }
 
-static int deliver_sample_group(struct perf_session *session,
+static int deliver_sample_group(struct perf_evlist *evlist,
                                 struct perf_tool *tool,
                                 union  perf_event *event,
                                 struct perf_sample *sample,
@@ -808,7 +856,7 @@ static int deliver_sample_group(struct perf_session *session,
         u64 i;
 
         for (i = 0; i < sample->read.group.nr; i++) {
-                ret = deliver_sample_value(session, tool, event, sample,
+                ret = deliver_sample_value(evlist, tool, event, sample,
                                            &sample->read.group.values[i],
                                            machine);
                 if (ret)
@@ -819,7 +867,7 @@ static int deliver_sample_group(struct perf_session *session,
 }
 
 static int
-perf_session__deliver_sample(struct perf_session *session,
+ perf_evlist__deliver_sample(struct perf_evlist *evlist,
                              struct perf_tool *tool,
                              union  perf_event *event,
                              struct perf_sample *sample,
@@ -836,41 +884,40 @@ perf_session__deliver_sample(struct perf_session *session,
 
         /* For PERF_SAMPLE_READ we have either single or group mode. */
         if (read_format & PERF_FORMAT_GROUP)
-                return deliver_sample_group(session, tool, event, sample,
+                return deliver_sample_group(evlist, tool, event, sample,
                                             machine);
         else
-                return deliver_sample_value(session, tool, event, sample,
+                return deliver_sample_value(evlist, tool, event, sample,
                                             &sample->read.one, machine);
 }
 
-int perf_session__deliver_event(struct perf_session *session,
-                                union perf_event *event,
-                                struct perf_sample *sample,
-                                struct perf_tool *tool, u64 file_offset)
+static int machines__deliver_event(struct machines *machines,
+                                   struct perf_evlist *evlist,
+                                   union perf_event *event,
+                                   struct perf_sample *sample,
+                                   struct perf_tool *tool, u64 file_offset)
 {
         struct perf_evsel *evsel;
         struct machine *machine;
 
-        dump_event(session, event, file_offset, sample);
+        dump_event(evlist, event, file_offset, sample);
 
-        evsel = perf_evlist__id2evsel(session->evlist, sample->id);
+        evsel = perf_evlist__id2evsel(evlist, sample->id);
 
-        machine = perf_session__find_machine_for_cpumode(session, event,
-                                                         sample);
+        machine = machines__find_for_cpumode(machines, event, sample);
 
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
                 dump_sample(evsel, event, sample);
                 if (evsel == NULL) {
-                        ++session->stats.nr_unknown_id;
+                        ++evlist->stats.nr_unknown_id;
                         return 0;
                 }
                 if (machine == NULL) {
-                        ++session->stats.nr_unprocessable_samples;
+                        ++evlist->stats.nr_unprocessable_samples;
                         return 0;
                 }
-                return perf_session__deliver_sample(session, tool, event,
-                                                    sample, evsel, machine);
+                return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
         case PERF_RECORD_MMAP:
                 return tool->mmap(tool, event, sample, machine);
         case PERF_RECORD_MMAP2:
@@ -883,7 +930,7 @@ int perf_session__deliver_event(struct perf_session *session,
                 return tool->exit(tool, event, sample, machine);
         case PERF_RECORD_LOST:
                 if (tool->lost == perf_event__process_lost)
-                        session->stats.total_lost += event->lost.lost;
+                        evlist->stats.total_lost += event->lost.lost;
                 return tool->lost(tool, event, sample, machine);
         case PERF_RECORD_READ:
                 return tool->read(tool, event, sample, evsel, machine);
@@ -892,20 +939,21 @@ int perf_session__deliver_event(struct perf_session *session,
         case PERF_RECORD_UNTHROTTLE:
                 return tool->unthrottle(tool, event, sample, machine);
         default:
-                ++session->stats.nr_unknown_events;
+                ++evlist->stats.nr_unknown_events;
                 return -1;
         }
 }
 
 static s64 perf_session__process_user_event(struct perf_session *session,
                                             union perf_event *event,
-                                            struct perf_tool *tool,
                                             u64 file_offset)
 {
+        struct ordered_events *oe = &session->ordered_events;
+        struct perf_tool *tool = session->tool;
         int fd = perf_data_file__fd(session->file);
         int err;
 
-        dump_event(session, event, file_offset, NULL);
+        dump_event(session->evlist, event, file_offset, NULL);
 
         /* These events are processed right away */
         switch (event->header.type) {
@@ -929,7 +977,7 @@ static s64 perf_session__process_user_event(struct perf_session *session,
         case PERF_RECORD_HEADER_BUILD_ID:
                 return tool->build_id(tool, event, session);
         case PERF_RECORD_FINISHED_ROUND:
-                return tool->finished_round(tool, event, session);
+                return tool->finished_round(tool, event, oe);
         case PERF_RECORD_ID_INDEX:
                 return tool->id_index(tool, event, session);
         default:
@@ -939,15 +987,17 @@ static s64 perf_session__process_user_event(struct perf_session *session,
 
 int perf_session__deliver_synth_event(struct perf_session *session,
                                       union perf_event *event,
-                                      struct perf_sample *sample,
-                                      struct perf_tool *tool)
+                                      struct perf_sample *sample)
 {
-        events_stats__inc(&session->stats, event->header.type);
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_tool *tool = session->tool;
+
+        events_stats__inc(&evlist->stats, event->header.type);
 
         if (event->header.type >= PERF_RECORD_USER_TYPE_START)
-                return perf_session__process_user_event(session, event, tool, 0);
+                return perf_session__process_user_event(session, event, 0);
 
-        return perf_session__deliver_event(session, event, sample, tool, 0);
+        return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
 }
 
 static void event_swap(union perf_event *event, bool sample_id_all)
@@ -1015,40 +1065,39 @@ out_parse_sample:
 }
 
 static s64 perf_session__process_event(struct perf_session *session,
-                                       union perf_event *event,
-                                       struct perf_tool *tool,
-                                       u64 file_offset)
+                                       union perf_event *event, u64 file_offset)
 {
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_tool *tool = session->tool;
         struct perf_sample sample;
         int ret;
 
         if (session->header.needs_swap)
-                event_swap(event, perf_evlist__sample_id_all(session->evlist));
+                event_swap(event, perf_evlist__sample_id_all(evlist));
 
         if (event->header.type >= PERF_RECORD_HEADER_MAX)
                 return -EINVAL;
 
-        events_stats__inc(&session->stats, event->header.type);
+        events_stats__inc(&evlist->stats, event->header.type);
 
         if (event->header.type >= PERF_RECORD_USER_TYPE_START)
-                return perf_session__process_user_event(session, event, tool, file_offset);
+                return perf_session__process_user_event(session, event, file_offset);
 
         /*
          * For all kernel events we get the sample data
          */
-        ret = perf_evlist__parse_sample(session->evlist, event, &sample);
+        ret = perf_evlist__parse_sample(evlist, event, &sample);
         if (ret)
                 return ret;
 
         if (tool->ordered_events) {
-                ret = perf_session_queue_event(session, event, tool, &sample,
-                                               file_offset);
+                ret = perf_session__queue_event(session, event, &sample, file_offset);
                 if (ret != -ETIME)
                         return ret;
         }
 
-        return perf_session__deliver_event(session, event, &sample, tool,
-                                           file_offset);
+        return machines__deliver_event(&session->machines, evlist, event,
+                                       &sample, tool, file_offset);
 }
 
 void perf_event_header__bswap(struct perf_event_header *hdr)
@@ -1076,54 +1125,57 @@ static struct thread *perf_session__register_idle_thread(struct perf_session *se
         return thread;
 }
 
-static void perf_session__warn_about_errors(const struct perf_session *session,
-                                            const struct perf_tool *tool)
+static void perf_session__warn_about_errors(const struct perf_session *session)
 {
-        if (tool->lost == perf_event__process_lost &&
-            session->stats.nr_events[PERF_RECORD_LOST] != 0) {
+        const struct events_stats *stats = &session->evlist->stats;
+        const struct ordered_events *oe = &session->ordered_events;
+
+        if (session->tool->lost == perf_event__process_lost &&
+            stats->nr_events[PERF_RECORD_LOST] != 0) {
                 ui__warning("Processed %d events and lost %d chunks!\n\n"
                             "Check IO/CPU overload!\n\n",
-                            session->stats.nr_events[0],
-                            session->stats.nr_events[PERF_RECORD_LOST]);
+                            stats->nr_events[0],
+                            stats->nr_events[PERF_RECORD_LOST]);
         }
 
-        if (session->stats.nr_unknown_events != 0) {
+        if (stats->nr_unknown_events != 0) {
                 ui__warning("Found %u unknown events!\n\n"
                             "Is this an older tool processing a perf.data "
                             "file generated by a more recent tool?\n\n"
                             "If that is not the case, consider "
                             "reporting to linux-kernel@vger.kernel.org.\n\n",
-                            session->stats.nr_unknown_events);
+                            stats->nr_unknown_events);
         }
 
-        if (session->stats.nr_unknown_id != 0) {
+        if (stats->nr_unknown_id != 0) {
                 ui__warning("%u samples with id not present in the header\n",
-                            session->stats.nr_unknown_id);
+                            stats->nr_unknown_id);
         }
 
-        if (session->stats.nr_invalid_chains != 0) {
-                ui__warning("Found invalid callchains!\n\n"
-                            "%u out of %u events were discarded for this reason.\n\n"
-                            "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
-                            session->stats.nr_invalid_chains,
-                            session->stats.nr_events[PERF_RECORD_SAMPLE]);
-        }
+        if (stats->nr_invalid_chains != 0) {
+                ui__warning("Found invalid callchains!\n\n"
+                            "%u out of %u events were discarded for this reason.\n\n"
+                            "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
+                            stats->nr_invalid_chains,
+                            stats->nr_events[PERF_RECORD_SAMPLE]);
+        }
 
-        if (session->stats.nr_unprocessable_samples != 0) {
+        if (stats->nr_unprocessable_samples != 0) {
                 ui__warning("%u unprocessable samples recorded.\n"
                             "Do you have a KVM guest running and not using 'perf kvm'?\n",
-                            session->stats.nr_unprocessable_samples);
+                            stats->nr_unprocessable_samples);
         }
 
-        if (session->stats.nr_unordered_events != 0)
-                ui__warning("%u out of order events recorded.\n", session->stats.nr_unordered_events);
+        if (oe->nr_unordered_events != 0)
+                ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
 }
 
 volatile int session_done;
 
-static int __perf_session__process_pipe_events(struct perf_session *session,
-                                               struct perf_tool *tool)
+static int __perf_session__process_pipe_events(struct perf_session *session)
 {
+        struct ordered_events *oe = &session->ordered_events;
+        struct perf_tool *tool = session->tool;
         int fd = perf_data_file__fd(session->file);
         union perf_event *event;
         uint32_t size, cur_size = 0;
@@ -1187,7 +1239,7 @@ more:
                 }
         }
 
-        if ((skip = perf_session__process_event(session, event, tool, head)) < 0) {
+        if ((skip = perf_session__process_event(session, event, head)) < 0) {
                 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                        head, event->header.size, event->header.type);
                 err = -EINVAL;
@@ -1203,10 +1255,10 @@ more:
                 goto more;
 done:
         /* do the final flush for ordered samples */
-        err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
+        err = ordered_events__flush(oe, OE_FLUSH__FINAL);
 out_err:
         free(buf);
-        perf_session__warn_about_errors(session, tool);
+        perf_session__warn_about_errors(session);
         ordered_events__free(&session->ordered_events);
         return err;
 }
@@ -1253,8 +1305,10 @@ fetch_mmaped_event(struct perf_session *session,
 
 static int __perf_session__process_events(struct perf_session *session,
                                           u64 data_offset, u64 data_size,
-                                          u64 file_size, struct perf_tool *tool)
+                                          u64 file_size)
 {
+        struct ordered_events *oe = &session->ordered_events;
+        struct perf_tool *tool = session->tool;
         int fd = perf_data_file__fd(session->file);
         u64 head, page_offset, file_offset, file_pos, size;
         int err, mmap_prot, mmap_flags, map_idx = 0;
@@ -1323,8 +1377,7 @@ more:
         size = event->header.size;
 
         if (size < sizeof(struct perf_event_header) ||
-            (skip = perf_session__process_event(session, event, tool, file_pos))
-                                                                        < 0) {
+            (skip = perf_session__process_event(session, event, file_pos)) < 0) {
                 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                        file_offset + head, event->header.size,
                        event->header.type);
@@ -1348,17 +1401,16 @@ more:
 
 out:
         /* do the final flush for ordered samples */
-        err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
+        err = ordered_events__flush(oe, OE_FLUSH__FINAL);
 out_err:
         ui_progress__finish();
-        perf_session__warn_about_errors(session, tool);
+        perf_session__warn_about_errors(session);
         ordered_events__free(&session->ordered_events);
         session->one_mmap = false;
         return err;
 }
 
-int perf_session__process_events(struct perf_session *session,
-                                 struct perf_tool *tool)
+int perf_session__process_events(struct perf_session *session)
 {
         u64 size = perf_data_file__size(session->file);
         int err;
@@ -1369,10 +1421,9 @@ int perf_session__process_events(struct perf_session *session,
         if (!perf_data_file__is_pipe(session->file))
                 err = __perf_session__process_events(session,
                                                      session->header.data_offset,
-                                                     session->header.data_size,
-                                                     size, tool);
+                                                     session->header.data_size, size);
         else
-                err = __perf_session__process_pipe_events(session, tool);
+                err = __perf_session__process_pipe_events(session);
 
         return err;
 }
@@ -1415,6 +1466,9 @@ int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
 
         for (i = 0; i < MAP__NR_TYPES; ++i) {
                 struct kmap *kmap = map__kmap(maps[i]);
+
+                if (!kmap)
+                        continue;
                 kmap->ref_reloc_sym = ref;
         }
 
@@ -1436,7 +1490,7 @@ size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
 {
         size_t ret = fprintf(fp, "Aggregated stats:\n");
 
-        ret += events_stats__fprintf(&session->stats, fp);
+        ret += events_stats__fprintf(&session->evlist->stats, fp);
         return ret;
 }
 
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 6d663dc76404..d5fa7b7916ef 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -20,13 +20,13 @@ struct perf_session {
         struct machines         machines;
         struct perf_evlist      *evlist;
         struct trace_event      tevent;
-        struct events_stats     stats;
         bool                    repipe;
         bool                    one_mmap;
         void                    *one_mmap_addr;
         u64                     one_mmap_offset;
         struct ordered_events   ordered_events;
         struct perf_data_file   *file;
+        struct perf_tool        *tool;
 };
 
 #define PRINT_IP_OPT_IP         (1<<0)
@@ -49,20 +49,13 @@ int perf_session__peek_event(struct perf_session *session, off_t file_offset,
                              union perf_event **event_ptr,
                              struct perf_sample *sample);
 
-int perf_session__process_events(struct perf_session *session,
-                                 struct perf_tool *tool);
+int perf_session__process_events(struct perf_session *session);
 
-int perf_session_queue_event(struct perf_session *s, union perf_event *event,
-                             struct perf_tool *tool, struct perf_sample *sample,
-                             u64 file_offset);
+int perf_session__queue_event(struct perf_session *s, union perf_event *event,
+                              struct perf_sample *sample, u64 file_offset);
 
 void perf_tool__fill_defaults(struct perf_tool *tool);
 
-int perf_session__deliver_event(struct perf_session *session,
-                                union perf_event *event,
-                                struct perf_sample *sample,
-                                struct perf_tool *tool, u64 file_offset);
-
 int perf_session__resolve_callchain(struct perf_session *session,
                                     struct perf_evsel *evsel,
                                     struct thread *thread,
@@ -126,8 +119,7 @@ extern volatile int session_done;
 
 int perf_session__deliver_synth_event(struct perf_session *session,
                                       union perf_event *event,
-                                      struct perf_sample *sample,
-                                      struct perf_tool *tool);
+                                      struct perf_sample *sample);
 
 int perf_event__process_id_index(struct perf_tool *tool,
                                  union perf_event *event,
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index d0aee4b9dfd4..1833103768cb 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -25,7 +25,7 @@ cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter'
 build_lib = getenv('PYTHON_EXTBUILD_LIB')
 build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 libtraceevent = getenv('LIBTRACEEVENT')
-libapikfs = getenv('LIBAPIKFS')
+libapikfs = getenv('LIBAPI')
 
 ext_sources = [f.strip() for f in file('util/python-ext-sources')
                                 if len(f.strip()) > 0 and f[0] != '#']
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 7a39c1ed8d37..4593f36ecc4c 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1463,6 +1463,15 @@ int sort_dimension__add(const char *tok)
                         sort__has_parent = 1;
                 } else if (sd->entry == &sort_sym) {
                         sort__has_sym = 1;
+                        /*
+                         * perf diff displays the performance difference amongst
+                         * two or more perf.data files. Those files could come
+                         * from different binaries. So we should not compare
+                         * their ips, but the name of symbol.
+                         */
+                        if (sort__mode == SORT_MODE__DIFF)
+                                sd->entry->se_collapse = sort__sym_sort;
+
                 } else if (sd->entry == &sort_dso) {
                         sort__has_dso = 1;
                 }
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index c03e4ff8beff..846036a921dc 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -44,6 +44,7 @@ extern struct sort_entry sort_dso_to;
 extern struct sort_entry sort_sym_from;
 extern struct sort_entry sort_sym_to;
 extern enum sort_type sort__first_dimension;
+extern const char default_mem_sort_order[];
 
 struct he_stat {
         u64                     period;
@@ -102,7 +103,6 @@ struct hist_entry {
 
         bool                    init_have_children;
         char                    level;
-        bool                    used;
         u8                      filtered;
         char                    *srcline;
         struct symbol           *parent;
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 33b7a2aef713..a7ab6063e038 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -74,6 +74,10 @@ static inline uint8_t elf_sym__type(const GElf_Sym *sym)
         return GELF_ST_TYPE(sym->st_info);
 }
 
+#ifndef STT_GNU_IFUNC
+#define STT_GNU_IFUNC 10
+#endif
+
 static inline int elf_sym__is_function(const GElf_Sym *sym)
 {
         return (elf_sym__type(sym) == STT_FUNC ||
@@ -575,32 +579,37 @@ static int dso__swap_init(struct dso *dso, unsigned char eidata)
 static int decompress_kmodule(struct dso *dso, const char *name,
                               enum dso_binary_type type)
 {
-        int fd;
-        const char *ext = strrchr(name, '.');
+        int fd = -1;
         char tmpbuf[] = "/tmp/perf-kmod-XXXXXX";
+        struct kmod_path m;
 
         if (type != DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP &&
             type != DSO_BINARY_TYPE__GUEST_KMODULE_COMP &&
             type != DSO_BINARY_TYPE__BUILD_ID_CACHE)
                 return -1;
 
-        if (!ext || !is_supported_compression(ext + 1)) {
-                ext = strrchr(dso->name, '.');
-                if (!ext || !is_supported_compression(ext + 1))
-                        return -1;
-        }
+        if (type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
+                name = dso->long_name;
 
-        fd = mkstemp(tmpbuf);
-        if (fd < 0)
+        if (kmod_path__parse_ext(&m, name) || !m.comp)
                 return -1;
 
-        if (!decompress_to_file(ext + 1, name, fd)) {
+        fd = mkstemp(tmpbuf);
+        if (fd < 0) {
+                dso->load_errno = errno;
+                goto out;
+        }
+
+        if (!decompress_to_file(m.ext, name, fd)) {
+                dso->load_errno = DSO_LOAD_ERRNO__DECOMPRESSION_FAILURE;
                 close(fd);
                 fd = -1;
         }
 
         unlink(tmpbuf);
 
+out:
+        free(m.ext);
         return fd;
 }
 
@@ -629,37 +638,49 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
         Elf *elf;
         int fd;
 
-        if (dso__needs_decompress(dso))
+        if (dso__needs_decompress(dso)) {
                 fd = decompress_kmodule(dso, name, type);
-        else
+                if (fd < 0)
+                        return -1;
+        } else {
                 fd = open(name, O_RDONLY);
-
-        if (fd < 0)
-                return -1;
+                if (fd < 0) {
+                        dso->load_errno = errno;
+                        return -1;
+                }
+        }
 
         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
                 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
+                dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
                 goto out_close;
         }
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
+                dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
                 pr_debug("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
-        if (dso__swap_init(dso, ehdr.e_ident[EI_DATA]))
+        if (dso__swap_init(dso, ehdr.e_ident[EI_DATA])) {
+                dso->load_errno = DSO_LOAD_ERRNO__INTERNAL_ERROR;
                 goto out_elf_end;
+        }
 
         /* Always reject images with a mismatched build-id: */
         if (dso->has_build_id) {
                 u8 build_id[BUILD_ID_SIZE];
 
-                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
+                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0) {
+                        dso->load_errno = DSO_LOAD_ERRNO__CANNOT_READ_BUILDID;
                         goto out_elf_end;
+                }
 
-                if (!dso__build_id_equal(dso, build_id))
+                if (!dso__build_id_equal(dso, build_id)) {
+                        dso->load_errno = DSO_LOAD_ERRNO__MISMATCHING_BUILDID;
                         goto out_elf_end;
+                }
         }
 
         ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
@@ -695,8 +716,10 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
         }
 
         ss->name   = strdup(name);
-        if (!ss->name)
+        if (!ss->name) {
+                dso->load_errno = errno;
                 goto out_elf_end;
+        }
 
         ss->elf    = elf;
         ss->fd     = fd;
@@ -753,6 +776,7 @@ int dso__load_sym(struct dso *dso, struct map *map,
                   symbol_filter_t filter, int kmodule)
 {
         struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
+        struct map_groups *kmaps = kmap ? map__kmaps(map) : NULL;
         struct map *curr_map = map;
         struct dso *curr_dso = dso;
         Elf_Data *symstrs, *secstrs;
@@ -768,6 +792,9 @@ int dso__load_sym(struct dso *dso, struct map *map,
         int nr = 0;
         bool remap_kernel = false, adjust_kernel_syms = false;
 
+        if (kmap && !kmaps)
+                return -1;
+
         dso->symtab_type = syms_ss->type;
         dso->is_64_bit = syms_ss->is_64_bit;
         dso->rel = syms_ss->ehdr.e_type == ET_REL;
@@ -864,10 +891,9 @@ int dso__load_sym(struct dso *dso, struct map *map,
                 /* Reject ARM ELF "mapping symbols": these aren't unique and
                  * don't identify functions, so will confuse the profile
                  * output: */
-                if (ehdr.e_machine == EM_ARM) {
-                        if (!strcmp(elf_name, "$a") ||
-                            !strcmp(elf_name, "$d") ||
-                            !strcmp(elf_name, "$t"))
+                if (ehdr.e_machine == EM_ARM || ehdr.e_machine == EM_AARCH64) {
+                        if (elf_name[0] == '$' && strchr("adtx", elf_name[1])
+                            && (elf_name[2] == '\0' || elf_name[2] == '.'))
                                 continue;
                 }
 
@@ -936,8 +962,10 @@ int dso__load_sym(struct dso *dso, struct map *map,
                                         map->map_ip = map__map_ip;
                                         map->unmap_ip = map__unmap_ip;
                                         /* Ensure maps are correctly ordered */
-                                        map_groups__remove(kmap->kmaps, map);
-                                        map_groups__insert(kmap->kmaps, map);
+                                        if (kmaps) {
+                                                map_groups__remove(kmaps, map);
+                                                map_groups__insert(kmaps, map);
+                                        }
                                 }
 
                                 /*
@@ -961,7 +989,7 @@ int dso__load_sym(struct dso *dso, struct map *map,
                         snprintf(dso_name, sizeof(dso_name),
                                  "%s%s", dso->short_name, section_name);
 
-                        curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
+                        curr_map = map_groups__find_by_name(kmaps, map->type, dso_name);
                         if (curr_map == NULL) {
                                 u64 start = sym.st_value;
 
@@ -991,7 +1019,7 @@ int dso__load_sym(struct dso *dso, struct map *map,
                                         curr_map->unmap_ip = identity__map_ip;
                                 }
                                 curr_dso->symtab_type = dso->symtab_type;
-                                map_groups__insert(kmap->kmaps, curr_map);
+                                map_groups__insert(kmaps, curr_map);
                                 /*
                                  * The new DSO should go to the kernel DSOS
                                  */
@@ -1045,14 +1073,15 @@ new_symbol:
          * For misannotated, zeroed, ASM function sizes.
          */
         if (nr > 0) {
-                symbols__fixup_duplicate(&dso->symbols[map->type]);
+                if (!symbol_conf.allow_aliases)
+                        symbols__fixup_duplicate(&dso->symbols[map->type]);
                 symbols__fixup_end(&dso->symbols[map->type]);
                 if (kmap) {
                         /*
                          * We need to fixup this here too because we create new
                          * maps here, for things like vsyscall sections.
                          */
-                        __map_groups__fixup_end(kmap->kmaps, map->type);
+                        __map_groups__fixup_end(kmaps, map->type);
                 }
         }
         err = nr;
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index d7efb03b3f9a..fd8477cacf88 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -246,13 +246,12 @@ out:
         return ret;
 }
 
-int symsrc__init(struct symsrc *ss, struct dso *dso __maybe_unused,
-                 const char *name,
+int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
                  enum dso_binary_type type)
 {
         int fd = open(name, O_RDONLY);
         if (fd < 0)
-                return -1;
+                goto out_errno;
 
         ss->name = strdup(name);
         if (!ss->name)
@@ -264,6 +263,8 @@ int symsrc__init(struct symsrc *ss, struct dso *dso __maybe_unused,
         return 0;
 out_close:
         close(fd);
+out_errno:
+        dso->load_errno = errno;
         return -1;
 }
 
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index a69066865a55..201f6c4ca738 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -15,6 +15,7 @@
 #include "machine.h"
 #include "symbol.h"
 #include "strlist.h"
+#include "intlist.h"
 #include "header.h"
 
 #include <elf.h>
@@ -629,13 +630,16 @@ static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
                                          symbol_filter_t filter)
 {
-        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct map_groups *kmaps = map__kmaps(map);
         struct map *curr_map;
         struct symbol *pos;
         int count = 0, moved = 0;
         struct rb_root *root = &dso->symbols[map->type];
         struct rb_node *next = rb_first(root);
 
+        if (!kmaps)
+                return -1;
+
         while (next) {
                 char *module;
 
@@ -681,8 +685,8 @@ static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
 static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
                                symbol_filter_t filter)
 {
-        struct map_groups *kmaps = map__kmap(map)->kmaps;
-        struct machine *machine = kmaps->machine;
+        struct map_groups *kmaps = map__kmaps(map);
+        struct machine *machine;
         struct map *curr_map = map;
         struct symbol *pos;
         int count = 0, moved = 0;
@@ -690,6 +694,11 @@ static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
         struct rb_node *next = rb_first(root);
         int kernel_range = 0;
 
+        if (!kmaps)
+                return -1;
+
+        machine = kmaps->machine;
+
         while (next) {
                 char *module;
 
@@ -1024,9 +1033,12 @@ static bool filename_from_kallsyms_filename(char *filename,
 static int validate_kcore_modules(const char *kallsyms_filename,
                                   struct map *map)
 {
-        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct map_groups *kmaps = map__kmaps(map);
         char modules_filename[PATH_MAX];
 
+        if (!kmaps)
+                return -EINVAL;
+
         if (!filename_from_kallsyms_filename(modules_filename, "modules",
                                              kallsyms_filename))
                 return -EINVAL;
@@ -1042,6 +1054,9 @@ static int validate_kcore_addresses(const char *kallsyms_filename,
 {
         struct kmap *kmap = map__kmap(map);
 
+        if (!kmap)
+                return -EINVAL;
+
         if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) {
                 u64 start;
 
@@ -1080,8 +1095,8 @@ static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
 static int dso__load_kcore(struct dso *dso, struct map *map,
                            const char *kallsyms_filename)
 {
-        struct map_groups *kmaps = map__kmap(map)->kmaps;
-        struct machine *machine = kmaps->machine;
+        struct map_groups *kmaps = map__kmaps(map);
+        struct machine *machine;
         struct kcore_mapfn_data md;
         struct map *old_map, *new_map, *replacement_map = NULL;
         bool is_64_bit;
@@ -1089,6 +1104,11 @@ static int dso__load_kcore(struct dso *dso, struct map *map,
         char kcore_filename[PATH_MAX];
         struct symbol *sym;
 
+        if (!kmaps)
+                return -EINVAL;
+
+        machine = kmaps->machine;
+
         /* This function requires that the map is the kernel map */
         if (map != machine->vmlinux_maps[map->type])
                 return -EINVAL;
@@ -1201,6 +1221,9 @@ static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
         struct kmap *kmap = map__kmap(map);
         u64 addr;
 
+        if (!kmap)
+                return -1;
+
         if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name)
                 return 0;
 
@@ -1859,6 +1882,20 @@ int setup_list(struct strlist **list, const char *list_str,
         return 0;
 }
 
+int setup_intlist(struct intlist **list, const char *list_str,
+                  const char *list_name)
+{
+        if (list_str == NULL)
+                return 0;
+
+        *list = intlist__new(list_str);
+        if (!*list) {
+                pr_err("problems parsing %s list\n", list_name);
+                return -1;
+        }
+        return 0;
+}
+
 static bool symbol__read_kptr_restrict(void)
 {
         bool value = false;
@@ -1909,9 +1946,17 @@ int symbol__init(struct perf_session_env *env)
                        symbol_conf.comm_list_str, "comm") < 0)
                 goto out_free_dso_list;
 
+        if (setup_intlist(&symbol_conf.pid_list,
+                       symbol_conf.pid_list_str, "pid") < 0)
+                goto out_free_comm_list;
+
+        if (setup_intlist(&symbol_conf.tid_list,
+                       symbol_conf.tid_list_str, "tid") < 0)
+                goto out_free_pid_list;
+
         if (setup_list(&symbol_conf.sym_list,
                        symbol_conf.sym_list_str, "symbol") < 0)
-                goto out_free_comm_list;
+                goto out_free_tid_list;
 
         /*
          * A path to symbols of "/" is identical to ""
@@ -1930,6 +1975,10 @@ int symbol__init(struct perf_session_env *env)
         symbol_conf.initialized = true;
         return 0;
 
+out_free_tid_list:
+        intlist__delete(symbol_conf.tid_list);
+out_free_pid_list:
+        intlist__delete(symbol_conf.pid_list);
 out_free_comm_list:
         strlist__delete(symbol_conf.comm_list);
 out_free_dso_list:
@@ -1944,6 +1993,8 @@ void symbol__exit(void)
         strlist__delete(symbol_conf.sym_list);
         strlist__delete(symbol_conf.dso_list);
         strlist__delete(symbol_conf.comm_list);
+        intlist__delete(symbol_conf.tid_list);
+        intlist__delete(symbol_conf.pid_list);
         vmlinux_path__exit();
         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
         symbol_conf.initialized = false;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 1650dcb3a67b..09561500164a 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -78,6 +78,7 @@ static inline size_t symbol__size(const struct symbol *sym)
 }
 
 struct strlist;
+struct intlist;
 
 struct symbol_conf {
         unsigned short  priv_size;
@@ -87,6 +88,7 @@ struct symbol_conf {
                         ignore_vmlinux_buildid,
                         show_kernel_path,
                         use_modules,
+                        allow_aliases,
                         sort_by_name,
                         show_nr_samples,
                         show_total_period,
@@ -114,6 +116,8 @@ struct symbol_conf {
         const char      *guestmount;
         const char      *dso_list_str,
                         *comm_list_str,
+                        *pid_list_str,
+                        *tid_list_str,
                         *sym_list_str,
                         *col_width_list_str;
        struct strlist   *dso_list,
@@ -123,6 +127,8 @@ struct symbol_conf {
                         *dso_to_list,
                         *sym_from_list,
                         *sym_to_list;
+        struct intlist  *pid_list,
+                        *tid_list;
         const char      *symfs;
 };
 
@@ -294,5 +300,7 @@ int compare_proc_modules(const char *from, const char *to);
 
 int setup_list(struct strlist **list, const char *list_str,
                const char *list_name);
+int setup_intlist(struct intlist **list, const char *list_str,
+                  const char *list_name);
 
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/target.c b/tools/perf/util/target.c
index e74c5963dc7a..a53603b27e52 100644
--- a/tools/perf/util/target.c
+++ b/tools/perf/util/target.c
@@ -123,11 +123,8 @@ int target__strerror(struct target *target, int errnum,
         if (errnum >= 0) {
                 const char *err = strerror_r(errnum, buf, buflen);
 
-                if (err != buf) {
-                        size_t len = strlen(err);
-                        memcpy(buf, err, min(buflen - 1, len));
-                        *(buf + min(buflen - 1, len)) = '\0';
-                }
+                if (err != buf)
+                        scnprintf(buf, buflen, "%s", err);
 
                 return 0;
         }
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 9ebc8b1f9be5..1c8fbc9588c5 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -82,6 +82,20 @@ void thread__delete(struct thread *thread)
         free(thread);
 }
 
+struct thread *thread__get(struct thread *thread)
+{
+        ++thread->refcnt;
+        return thread;
+}
+
+void thread__put(struct thread *thread)
+{
+        if (thread && --thread->refcnt == 0) {
+                list_del_init(&thread->node);
+                thread__delete(thread);
+        }
+}
+
 struct comm *thread__comm(const struct thread *thread)
 {
         if (list_empty(&thread->comm_list))
@@ -192,7 +206,6 @@ int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
                 err = thread__set_comm(thread, comm, timestamp);
                 if (err)
                         return err;
-                thread->comm_set = true;
         }
 
         thread->ppid = parent->tid;
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 160fd066a7d1..9b8a54dc34a8 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -7,6 +7,7 @@
 #include <sys/types.h>
 #include "symbol.h"
 #include <strlist.h>
+#include <intlist.h>
 
 struct thread_stack;
 
@@ -20,6 +21,7 @@ struct thread {
         pid_t                   tid;
         pid_t                   ppid;
         int                     cpu;
+        int                     refcnt;
         char                    shortname[3];
         bool                    comm_set;
         bool                    dead; /* if set thread has exited */
@@ -37,6 +39,18 @@ struct comm;
 struct thread *thread__new(pid_t pid, pid_t tid);
 int thread__init_map_groups(struct thread *thread, struct machine *machine);
 void thread__delete(struct thread *thread);
+
+struct thread *thread__get(struct thread *thread);
+void thread__put(struct thread *thread);
+
+static inline void __thread__zput(struct thread **thread)
+{
+        thread__put(*thread);
+        *thread = NULL;
+}
+
+#define thread__zput(thread) __thread__zput(&thread)
+
 static inline void thread__exited(struct thread *thread)
 {
         thread->dead = true;
@@ -87,6 +101,16 @@ static inline bool thread__is_filtered(struct thread *thread)
                 return true;
         }
 
+        if (symbol_conf.pid_list &&
+            !intlist__has_entry(symbol_conf.pid_list, thread->pid_)) {
+                return true;
+        }
+
+        if (symbol_conf.tid_list &&
+            !intlist__has_entry(symbol_conf.tid_list, thread->tid)) {
+                return true;
+        }
+
         return false;
 }
 
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index bb2708bbfaca..51d9e56c0f84 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -10,6 +10,7 @@ struct perf_evsel;
 struct perf_sample;
 struct perf_tool;
 struct machine;
+struct ordered_events;
 
 typedef int (*event_sample)(struct perf_tool *tool, union perf_event *event,
                             struct perf_sample *sample,
@@ -25,6 +26,9 @@ typedef int (*event_attr_op)(struct perf_tool *tool,
 typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
                          struct perf_session *session);
 
+typedef int (*event_oe)(struct perf_tool *tool, union perf_event *event,
+                        struct ordered_events *oe);
+
 struct perf_tool {
         event_sample    sample,
                         read;
@@ -38,8 +42,8 @@ struct perf_tool {
                         unthrottle;
         event_attr_op   attr;
         event_op2       tracing_data;
-        event_op2       finished_round,
-                        build_id,
+        event_oe        finished_round;
+        event_op2       build_id,
                         id_index;
         bool            ordered_events;
         bool            ordering_requires_timestamps;
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index c36636fd825b..25d6c737be3e 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -112,8 +112,8 @@ unsigned long long read_size(struct event_format *event, void *ptr, int size)
         return pevent_read_number(event->pevent, ptr, size);
 }
 
-void event_format__print(struct event_format *event,
-                         int cpu, void *data, int size)
+void event_format__fprintf(struct event_format *event,
+                           int cpu, void *data, int size, FILE *fp)
 {
         struct pevent_record record;
         struct trace_seq s;
@@ -125,10 +125,16 @@ void event_format__print(struct event_format *event,
 
         trace_seq_init(&s);
         pevent_event_info(&s, event, &record);
-        trace_seq_do_printf(&s);
+        trace_seq_do_fprintf(&s, fp);
         trace_seq_destroy(&s);
 }
 
+void event_format__print(struct event_format *event,
+                         int cpu, void *data, int size)
+{
+        return event_format__fprintf(event, cpu, data, size, stdout);
+}
+
 void parse_proc_kallsyms(struct pevent *pevent,
                          char *file, unsigned int size __maybe_unused)
 {
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index 5c9bdd1591a9..9df61059a85d 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -43,7 +43,6 @@ static int stop_script_unsupported(void)
 static void process_event_unsupported(union perf_event *event __maybe_unused,
                                       struct perf_sample *sample __maybe_unused,
                                       struct perf_evsel *evsel __maybe_unused,
-                                      struct thread *thread __maybe_unused,
                                       struct addr_location *al __maybe_unused)
 {
 }
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 52aaa19e1eb1..d5168f0be4ec 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -23,6 +23,9 @@ trace_event__tp_format(const char *sys, const char *name);
 
 int bigendian(void);
 
+void event_format__fprintf(struct event_format *event,
+                           int cpu, void *data, int size, FILE *fp);
+
 void event_format__print(struct event_format *event,
                          int cpu, void *data, int size);
 
@@ -69,8 +72,7 @@ struct scripting_ops {
         void (*process_event) (union perf_event *event,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
-                               struct thread *thread,
-                                   struct addr_location *al);
+                               struct addr_location *al);
         int (*generate_script) (struct pevent *pevent, const char *outfile);
 };
 
diff --git a/tools/perf/util/unwind-libunwind.c b/tools/perf/util/unwind-libunwind.c
index e3c40a520a25..7b09a443a280 100644
--- a/tools/perf/util/unwind-libunwind.c
+++ b/tools/perf/util/unwind-libunwind.c
@@ -266,7 +266,7 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
                                      u64 *fde_count)
 {
         int ret = -EINVAL, fd;
-        u64 offset = dso->data.frame_offset;
+        u64 offset = dso->data.eh_frame_hdr_offset;
 
         if (offset == 0) {
                 fd = dso__data_fd(dso, machine);
@@ -275,7 +275,7 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
 
                 /* Check the .eh_frame section for unwinding info */
                 offset = elf_section_offset(fd, ".eh_frame_hdr");
-                dso->data.frame_offset = offset;
+                dso->data.eh_frame_hdr_offset = offset;
         }
 
         if (offset)
@@ -291,7 +291,7 @@ static int read_unwind_spec_debug_frame(struct dso *dso,
                                         struct machine *machine, u64 *offset)
 {
         int fd;
-        u64 ofs = dso->data.frame_offset;
+        u64 ofs = dso->data.debug_frame_offset;
 
         if (ofs == 0) {
                 fd = dso__data_fd(dso, machine);
@@ -300,7 +300,7 @@ static int read_unwind_spec_debug_frame(struct dso *dso,
 
                 /* Check the .debug_frame section for unwinding info */
                 ofs = elf_section_offset(fd, ".debug_frame");
-                dso->data.frame_offset = ofs;
+                dso->data.debug_frame_offset = ofs;
         }
 
         *offset = ofs;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index b86744f29eef..4ee6d0d4c993 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -269,6 +269,13 @@ void dump_stack(void)
 void dump_stack(void) {}
 #endif
 
+void sighandler_dump_stack(int sig)
+{
+        psignal(sig, "perf");
+        dump_stack();
+        exit(sig);
+}
+
 void get_term_dimensions(struct winsize *ws)
 {
         char *s = getenv("LINES");
@@ -303,13 +310,26 @@ void set_term_quiet_input(struct termios *old)
         tcsetattr(0, TCSANOW, &tc);
 }
 
-static void set_tracing_events_path(const char *mountpoint)
+static void set_tracing_events_path(const char *tracing, const char *mountpoint)
 {
-        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
-                 mountpoint, "tracing/events");
+        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s%s",
+                 mountpoint, tracing, "events");
 }
 
-const char *perf_debugfs_mount(const char *mountpoint)
+static const char *__perf_tracefs_mount(const char *mountpoint)
+{
+        const char *mnt;
+
+        mnt = tracefs_mount(mountpoint);
+        if (!mnt)
+                return NULL;
+
+        set_tracing_events_path("", mnt);
+
+        return mnt;
+}
+
+static const char *__perf_debugfs_mount(const char *mountpoint)
 {
         const char *mnt;
 
@@ -317,7 +337,20 @@ const char *perf_debugfs_mount(const char *mountpoint)
         if (!mnt)
                 return NULL;
 
-        set_tracing_events_path(mnt);
+        set_tracing_events_path("tracing/", mnt);
+
+        return mnt;
+}
+
+const char *perf_debugfs_mount(const char *mountpoint)
+{
+        const char *mnt;
+
+        mnt = __perf_tracefs_mount(mountpoint);
+        if (mnt)
+                return mnt;
+
+        mnt = __perf_debugfs_mount(mountpoint);
 
         return mnt;
 }
@@ -325,12 +358,19 @@ const char *perf_debugfs_mount(const char *mountpoint)
 void perf_debugfs_set_path(const char *mntpt)
 {
         snprintf(debugfs_mountpoint, strlen(debugfs_mountpoint), "%s", mntpt);
-        set_tracing_events_path(mntpt);
+        set_tracing_events_path("tracing/", mntpt);
+}
+
+static const char *find_tracefs(void)
+{
+        const char *path = __perf_tracefs_mount(NULL);
+
+        return path;
 }
 
 static const char *find_debugfs(void)
 {
-        const char *path = perf_debugfs_mount(NULL);
+        const char *path = __perf_debugfs_mount(NULL);
 
         if (!path)
                 fprintf(stderr, "Your kernel does not support the debugfs filesystem");
@@ -344,6 +384,7 @@ static const char *find_debugfs(void)
  */
 const char *find_tracing_dir(void)
 {
+        const char *tracing_dir = "";
         static char *tracing;
         static int tracing_found;
         const char *debugfs;
@@ -351,11 +392,15 @@ const char *find_tracing_dir(void)
         if (tracing_found)
                 return tracing;
 
-        debugfs = find_debugfs();
-        if (!debugfs)
-                return NULL;
+        debugfs = find_tracefs();
+        if (!debugfs) {
+                tracing_dir = "/tracing";
+                debugfs = find_debugfs();
+                if (!debugfs)
+                        return NULL;
+        }
 
-        if (asprintf(&tracing, "%s/tracing", debugfs) < 0)
+        if (asprintf(&tracing, "%s%s", debugfs, tracing_dir) < 0)
                 return NULL;
 
         tracing_found = 1;
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 027a5153495c..1ff23e04ad27 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -75,6 +75,7 @@
 #include <linux/types.h>
 #include <sys/ttydefaults.h>
 #include <api/fs/debugfs.h>
+#include <api/fs/tracefs.h>
 #include <termios.h>
 #include <linux/bitops.h>
 #include <termios.h>
@@ -276,6 +277,7 @@ char *ltrim(char *s);
 char *rtrim(char *s);
 
 void dump_stack(void);
+void sighandler_dump_stack(int sig);
 
 extern unsigned int page_size;
 extern int cacheline_size;
@@ -327,4 +329,8 @@ bool find_process(const char *name);
 int gzip_decompress_to_file(const char *input, int output_fd);
 #endif
 
+#ifdef HAVE_LZMA_SUPPORT
+int lzma_decompress_to_file(const char *input, int output_fd);
+#endif
+
 #endif /* GIT_COMPAT_UTIL_H */