169 files changed, 11173 insertions, 4871 deletions

diff --git a/tools/perf/Documentation/Makefile b/tools/perf/Documentation/Makefile
index ef6d22e879eb..eb30044a922a 100644
--- a/tools/perf/Documentation/Makefile
+++ b/tools/perf/Documentation/Makefile
@@ -222,10 +222,14 @@ install-pdf: pdf
 #install-html: html
 #       '$(SHELL_PATH_SQ)' ./install-webdoc.sh $(DESTDIR)$(htmldir)
 
+ifneq ($(MAKECMDGOALS),clean)
+ifneq ($(MAKECMDGOALS),tags)
 $(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
         $(QUIET_SUBDIR0)../ $(QUIET_SUBDIR1) $(OUTPUT)PERF-VERSION-FILE
 
 -include $(OUTPUT)PERF-VERSION-FILE
+endif
+endif
 
 #
 # Determine "include::" file references in asciidoc files.
diff --git a/tools/perf/Documentation/perf-annotate.txt b/tools/perf/Documentation/perf-annotate.txt
index c8ffd9fd5c6a..e9cd39a92dc2 100644
--- a/tools/perf/Documentation/perf-annotate.txt
+++ b/tools/perf/Documentation/perf-annotate.txt
@@ -61,11 +61,13 @@ OPTIONS
 
 --stdio:: Use the stdio interface.
 
---tui:: Use the TUI interface Use of --tui requires a tty, if one is not
+--tui:: Use the TUI interface. Use of --tui requires a tty, if one is not
         present, as when piping to other commands, the stdio interface is
         used. This interfaces starts by centering on the line with more
         samples, TAB/UNTAB cycles through the lines with more samples.
 
+--gtk:: Use the GTK interface.
+
 -C::
 --cpu:: Only report samples for the list of CPUs provided. Multiple CPUs can
         be provided as a comma-separated list with no space: 0,1. Ranges of
@@ -88,6 +90,12 @@ OPTIONS
 --objdump=<path>::
         Path to objdump binary.
 
+--skip-missing::
+        Skip symbols that cannot be annotated.
+
+--group::
+        Show event group information together
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-archive.txt b/tools/perf/Documentation/perf-archive.txt
index fae174dc7d01..5032a142853e 100644
--- a/tools/perf/Documentation/perf-archive.txt
+++ b/tools/perf/Documentation/perf-archive.txt
@@ -13,7 +13,7 @@ SYNOPSIS
 DESCRIPTION
 -----------
 This command runs runs perf-buildid-list --with-hits, and collects the files
-with the buildids found so that analisys of perf.data contents can be possible
+with the buildids found so that analysis of perf.data contents can be possible
 on another machine.
 
 
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
index c1057701a7dc..e9a8349a7172 100644
--- a/tools/perf/Documentation/perf-buildid-cache.txt
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -24,6 +24,13 @@ OPTIONS
 -r::
 --remove=::
         Remove specified file 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.
 -v::
 --verbose::
         Be more verbose.
diff --git a/tools/perf/Documentation/perf-diff.txt b/tools/perf/Documentation/perf-diff.txt
index 194f37d635df..5b3123d5721f 100644
--- a/tools/perf/Documentation/perf-diff.txt
+++ b/tools/perf/Documentation/perf-diff.txt
@@ -22,10 +22,6 @@ specified perf.data files.
 
 OPTIONS
 -------
--M::
---displacement::
-        Show position displacement relative to baseline.
-
 -D::
 --dump-raw-trace::
         Dump raw trace in ASCII.
diff --git a/tools/perf/Documentation/perf-evlist.txt b/tools/perf/Documentation/perf-evlist.txt
index 15217345c2fa..1ceb3700ffbb 100644
--- a/tools/perf/Documentation/perf-evlist.txt
+++ b/tools/perf/Documentation/perf-evlist.txt
@@ -28,6 +28,10 @@ OPTIONS
 --verbose=::
         Show all fields.
 
+-g::
+--group::
+        Show event group information.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-list[1],
diff --git a/tools/perf/Documentation/perf-mem.txt b/tools/perf/Documentation/perf-mem.txt
new file mode 100644
index 000000000000..888d51137fbe
--- /dev/null
+++ b/tools/perf/Documentation/perf-mem.txt
@@ -0,0 +1,48 @@
+perf-mem(1)
+===========
+
+NAME
+----
+perf-mem - Profile memory accesses
+
+SYNOPSIS
+--------
+[verse]
+'perf mem' [<options>] (record [<command>] | report)
+
+DESCRIPTION
+-----------
+"perf mem -t <TYPE> record" runs a command and gathers memory operation data
+from it, into perf.data. Perf record options are accepted and are passed through.
+
+"perf mem -t <TYPE> report" displays the result. It invokes perf report with the
+right set of options to display a memory access profile.
+
+OPTIONS
+-------
+<command>...::
+        Any command you can specify in a shell.
+
+-t::
+--type=::
+        Select the memory operation type: load or store (default: load)
+
+-D::
+--dump-raw-samples=::
+        Dump the raw decoded samples on the screen in a format that is easy to parse with
+        one sample per line.
+
+-x::
+--field-separator::
+        Specify the field separator used when dump raw samples (-D option). By default,
+        The separator is the space character.
+
+-C::
+--cpu-list::
+        Restrict dump of raw samples to those provided via this option. Note that the same
+        option can be passed in record mode. It will be interpreted the same way as perf
+        record.
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 938e8904f64d..d4da111ef53d 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -182,6 +182,12 @@ is enabled for all the sampling events. The sampled branch type is the same for
 The various filters must be specified as a comma separated list: --branch-filter any_ret,u,k
 Note that this feature may not be available on all processors.
 
+-W::
+--weight::
+Enable weightened sampling. An additional weight is recorded per sample and can be
+displayed with the weight and local_weight sort keys.  This currently works for TSX
+abort events and some memory events in precise mode on modern Intel CPUs.
+
 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 f4d91bebd59d..66dab7410c1d 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -57,11 +57,44 @@ OPTIONS
 
 -s::
 --sort=::
-        Sort by key(s): pid, comm, dso, symbol, parent, srcline.
+        Sort histogram entries by given key(s) - multiple keys can be specified
+        in CSV format.  Following sort keys are available:
+        pid, comm, dso, symbol, parent, cpu, srcline, weight, local_weight.
+
+        Each key has following meaning:
+
+        - comm: command (name) of the task which can be read via /proc/<pid>/comm
+        - pid: command and tid of the task
+        - dso: name of library or module executed at the time of sample
+        - symbol: name of function executed at the time of sample
+        - parent: name of function matched to the parent regex filter. Unmatched
+        entries are displayed as "[other]".
+        - cpu: cpu number the task ran at the time of sample
+        - srcline: filename and line number executed at the time of sample.  The
+        DWARF debuggin info must be provided.
+
+        By default, comm, dso and symbol keys are used.
+        (i.e. --sort comm,dso,symbol)
+
+        If --branch-stack option is used, following sort keys are also
+        available:
+        dso_from, dso_to, symbol_from, symbol_to, mispredict.
+
+        - dso_from: name of library or module branched from
+        - dso_to: name of library or module branched to
+        - symbol_from: name of function branched from
+        - symbol_to: name of function branched to
+        - mispredict: "N" for predicted branch, "Y" for mispredicted branch
+
+        And default sort keys are changed to comm, dso_from, symbol_from, dso_to
+        and symbol_to, see '--branch-stack'.
 
 -p::
 --parent=<regex>::
-        regex filter to identify parent, see: '--sort parent'
+        A regex filter to identify parent. The parent is a caller of this
+        function and searched through the callchain, thus it requires callchain
+        information recorded. The pattern is in the exteneded regex format and
+        defaults to "\^sys_|^do_page_fault", see '--sort parent'.
 
 -x::
 --exclude-other::
@@ -74,7 +107,6 @@ OPTIONS
 
 -t::
 --field-separator=::
-
         Use a special separator character and don't pad with spaces, replacing
         all occurrences of this separator in symbol names (and other output)
         with a '.' character, that thus it's the only non valid separator.
@@ -171,6 +203,17 @@ OPTIONS
 --objdump=<path>::
         Path to objdump binary.
 
+--group::
+        Show event group information together.
+
+--demangle::
+        Demangle symbol names to human readable form. It's enabled by default,
+        disable with --no-demangle.
+
+--percent-limit::
+        Do not show entries which have an overhead under that percent.
+        (Default: 0).
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-annotate[1]
diff --git a/tools/perf/Documentation/perf-script-python.txt b/tools/perf/Documentation/perf-script-python.txt
index a4027f221a53..9f1f054b8432 100644
--- a/tools/perf/Documentation/perf-script-python.txt
+++ b/tools/perf/Documentation/perf-script-python.txt
@@ -336,7 +336,6 @@ scripts listed by the 'perf script -l' command e.g.:
 ----
 root@tropicana:~# perf script -l
 List of available trace scripts:
-  workqueue-stats                      workqueue stats (ins/exe/create/destroy)
   wakeup-latency                       system-wide min/max/avg wakeup latency
   rw-by-file <comm>                    r/w activity for a program, by file
   rw-by-pid                            system-wide r/w activity
@@ -402,7 +401,6 @@ should show a new entry for your script:
 ----
 root@tropicana:~# perf script -l
 List of available trace scripts:
-  workqueue-stats                      workqueue stats (ins/exe/create/destroy)
   wakeup-latency                       system-wide min/max/avg wakeup latency
   rw-by-file <comm>                    r/w activity for a program, by file
   rw-by-pid                            system-wide r/w activity
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index cf0c3107e06e..2fe87fb558f0 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -52,7 +52,7 @@ OPTIONS
 
 -r::
 --repeat=<n>::
-        repeat command and print average + stddev (max: 100)
+        repeat command and print average + stddev (max: 100). 0 means forever.
 
 -B::
 --big-num::
@@ -114,6 +114,23 @@ with it.  --append may be used here.  Examples:
 
 perf stat --repeat 10 --null --sync --pre 'make -s O=defconfig-build/clean' -- make -s -j64 O=defconfig-build/ bzImage
 
+-I msecs::
+--interval-print msecs::
+        Print count deltas every N milliseconds (minimum: 100ms)
+        example: perf stat -I 1000 -e cycles -a sleep 5
+
+--per-socket::
+Aggregate counts per processor socket for system-wide mode measurements.  This
+is a useful mode to detect imbalance between sockets.  To enable this mode,
+use --per-socket in addition to -a. (system-wide).  The output includes the
+socket number and the number of online processors on that socket. This is
+useful to gauge the amount of aggregation.
+
+--per-core::
+Aggregate counts per physical processor for system-wide mode measurements.  This
+is a useful mode to detect imbalance between physical cores.  To enable this mode,
+use --per-core in addition to -a. (system-wide).  The output includes the
+core number and the number of online logical processors on that physical processor.
 
 EXAMPLES
 --------
diff --git a/tools/perf/Documentation/perf-test.txt b/tools/perf/Documentation/perf-test.txt
index b24ac40fcd58..d1d3e5121f89 100644
--- a/tools/perf/Documentation/perf-test.txt
+++ b/tools/perf/Documentation/perf-test.txt
@@ -23,6 +23,10 @@ from 'perf test list'.
 
 OPTIONS
 -------
+-s::
+--skip::
+        Tests to skip (comma separater numeric list).
+
 -v::
 --verbose::
         Be more verbose.
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 5b80d84d6b4a..7fdd1909e376 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -60,7 +60,7 @@ Default is to monitor all CPUS.
 
 -i::
 --inherit::
-        Child tasks inherit counters, only makes sens with -p option.
+        Child tasks do not inherit counters.
 
 -k <path>::
 --vmlinux=<path>::
@@ -112,7 +112,7 @@ Default is to monitor all CPUS.
 
 -s::
 --sort::
-        Sort by key(s): pid, comm, dso, symbol, parent, srcline.
+        Sort by key(s): pid, comm, dso, symbol, parent, srcline, weight, local_weight.
 
 -n::
 --show-nr-samples::
@@ -155,6 +155,10 @@ Default is to monitor all CPUS.
 
         Default: fractal,0.5,callee.
 
+--percent-limit::
+        Do not show entries which have an overhead under that percent.
+        (Default: 0).
+
 INTERACTIVE PROMPTING KEYS
 --------------------------
 
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index 39d41068484f..025de796067c 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -1,6 +1,7 @@
 tools/perf
 tools/scripts
 tools/lib/traceevent
+tools/lib/lk
 include/linux/const.h
 include/linux/perf_event.h
 include/linux/rbtree.h
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 8ab05e543ef4..203cb0eecff2 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -35,7 +35,9 @@ include config/utilities.mak
 #
 # Define WERROR=0 to disable treating any warnings as errors.
 #
-# Define NO_NEWT if you do not want TUI support.
+# Define NO_NEWT if you do not want TUI support. (deprecated)
+#
+# Define NO_SLANG if you do not want TUI support.
 #
 # Define NO_GTK2 if you do not want GTK+ GUI support.
 #
@@ -47,165 +49,65 @@ include config/utilities.mak
 # backtrace post unwind.
 #
 # Define NO_BACKTRACE if you do not want stack backtrace debug feature
+#
+# Define NO_LIBNUMA if you do not want numa perf benchmark
+#
+# Define NO_LIBAUDIT if you do not want libaudit support
+#
+# Define NO_LIBBIONIC if you do not want bionic support
 
-$(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
-        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
--include $(OUTPUT)PERF-VERSION-FILE
-
-uname_M := $(shell uname -m 2>/dev/null || echo not)
-
-ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
-                                  -e 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/ )
-NO_PERF_REGS := 1
-
-CC = $(CROSS_COMPILE)gcc
-AR = $(CROSS_COMPILE)ar
-
-# Additional ARCH settings for x86
-ifeq ($(ARCH),i386)
-        override ARCH := x86
-        NO_PERF_REGS := 0
-        LIBUNWIND_LIBS = -lunwind -lunwind-x86
-endif
-ifeq ($(ARCH),x86_64)
-        override ARCH := x86
-        IS_X86_64 := 0
-        ifeq (, $(findstring m32,$(EXTRA_CFLAGS)))
-                IS_X86_64 := $(shell echo __x86_64__ | ${CC} -E -x c - | tail -n 1)
-        endif
-        ifeq (${IS_X86_64}, 1)
-                RAW_ARCH := x86_64
-                ARCH_CFLAGS := -DARCH_X86_64
-                ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
-        endif
-        NO_PERF_REGS := 0
-        LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
-endif
-
-# Treat warnings as errors unless directed not to
-ifneq ($(WERROR),0)
-        CFLAGS_WERROR := -Werror
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
 endif
 
-ifeq ("$(origin DEBUG)", "command line")
-  PERF_DEBUG = $(DEBUG)
-endif
-ifndef PERF_DEBUG
-  CFLAGS_OPTIMIZE = -O6 -D_FORTIFY_SOURCE=2
+ifneq ($(objtree),)
+#$(info Determined 'objtree' to be $(objtree))
 endif
 
-ifdef PARSER_DEBUG
-        PARSER_DEBUG_BISON  := -t
-        PARSER_DEBUG_FLEX   := -d
-        PARSER_DEBUG_CFLAGS := -DPARSER_DEBUG
+ifneq ($(OUTPUT),)
+#$(info Determined 'OUTPUT' to be $(OUTPUT))
 endif
 
-CFLAGS = -fno-omit-frame-pointer -ggdb3 -funwind-tables -Wall -Wextra -std=gnu99 $(CFLAGS_WERROR) $(CFLAGS_OPTIMIZE) $(EXTRA_WARNINGS) $(EXTRA_CFLAGS) $(PARSER_DEBUG_CFLAGS)
-EXTLIBS = -lpthread -lrt -lelf -lm
-ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
-ALL_LDFLAGS = $(LDFLAGS)
-STRIP ?= strip
-
-# Among the variables below, these:
-#   perfexecdir
-#   template_dir
-#   mandir
-#   infodir
-#   htmldir
-#   ETC_PERFCONFIG (but not sysconfdir)
-# can be specified as a relative path some/where/else;
-# this is interpreted as relative to $(prefix) and "perf" at
-# runtime figures out where they are based on the path to the executable.
-# This can help installing the suite in a relocatable way.
-
-# Make the path relative to DESTDIR, not to prefix
-ifndef DESTDIR
-prefix = $(HOME)
-endif
-bindir_relative = bin
-bindir = $(prefix)/$(bindir_relative)
-mandir = share/man
-infodir = share/info
-perfexecdir = libexec/perf-core
-sharedir = $(prefix)/share
-template_dir = share/perf-core/templates
-htmldir = share/doc/perf-doc
-ifeq ($(prefix),/usr)
-sysconfdir = /etc
-ETC_PERFCONFIG = $(sysconfdir)/perfconfig
-else
-sysconfdir = $(prefix)/etc
-ETC_PERFCONFIG = etc/perfconfig
-endif
-lib = lib
+$(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
+        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
 
-export prefix bindir sharedir sysconfdir
+CC = $(CROSS_COMPILE)gcc
+AR = $(CROSS_COMPILE)ar
 
-RM = rm -f
-MKDIR = mkdir
-FIND = find
+RM      = rm -f
+MKDIR   = mkdir
+FIND    = find
 INSTALL = install
+FLEX    = flex
+BISON   = bison
+STRIP   = strip
 
-# sparse is architecture-neutral, which means that we need to tell it
-# explicitly what architecture to check for. Fix this up for yours..
-SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
-
--include config/feature-tests.mak
+LK_DIR          = $(srctree)/tools/lib/lk/
+TRACE_EVENT_DIR = $(srctree)/tools/lib/traceevent/
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -fstack-protector-all,-fstack-protector-all),y)
-        CFLAGS := $(CFLAGS) -fstack-protector-all
-endif
+# include config/Makefile by default and rule out
+# non-config cases
+config := 1
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wstack-protector,-Wstack-protector),y)
-       CFLAGS := $(CFLAGS) -Wstack-protector
-endif
+NON_CONFIG_TARGETS := clean TAGS tags cscope help
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wvolatile-register-var,-Wvolatile-register-var),y)
-       CFLAGS := $(CFLAGS) -Wvolatile-register-var
+ifdef MAKECMDGOALS
+ifeq ($(filter-out $(NON_CONFIG_TARGETS),$(MAKECMDGOALS)),)
+  config := 0
 endif
-
-### --- END CONFIGURATION SECTION ---
-
-ifeq ($(srctree),)
-srctree := $(patsubst %/,%,$(dir $(shell pwd)))
-srctree := $(patsubst %/,%,$(dir $(srctree)))
-#$(info Determined 'srctree' to be $(srctree))
 endif
 
-ifneq ($(objtree),)
-#$(info Determined 'objtree' to be $(objtree))
+ifeq ($(config),1)
+include config/Makefile
 endif
 
-ifneq ($(OUTPUT),)
-#$(info Determined 'OUTPUT' to be $(OUTPUT))
-endif
+export prefix bindir sharedir sysconfdir
 
-BASIC_CFLAGS = \
-        -Iutil/include \
-        -Iarch/$(ARCH)/include \
-        $(if $(objtree),-I$(objtree)/arch/$(ARCH)/include/generated/uapi) \
-        -I$(srctree)/arch/$(ARCH)/include/uapi \
-        -I$(srctree)/arch/$(ARCH)/include \
-        $(if $(objtree),-I$(objtree)/include/generated/uapi) \
-        -I$(srctree)/include/uapi \
-        -I$(srctree)/include \
-        -I$(OUTPUT)util \
-        -Iutil \
-        -I. \
-        -I$(TRACE_EVENT_DIR) \
-        -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
-
-BASIC_LDFLAGS =
-
-ifeq ($(call try-cc,$(SOURCE_BIONIC),$(CFLAGS),bionic),y)
-        BIONIC := 1
-        EXTLIBS := $(filter-out -lrt,$(EXTLIBS))
-        EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))
-        BASIC_CFLAGS += -I.
-endif
+# sparse is architecture-neutral, which means that we need to tell it
+# explicitly what architecture to check for. Fix this up for yours..
+SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 
 # Guard against environment variables
 BUILTIN_OBJS =
@@ -219,24 +121,38 @@ SCRIPT_SH += perf-archive.sh
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
 
-TRACE_EVENT_DIR = ../lib/traceevent/
+LK_PATH=$(LK_DIR)
 
 ifneq ($(OUTPUT),)
-        TE_PATH=$(OUTPUT)
+  TE_PATH=$(OUTPUT)
+ifneq ($(subdir),)
+  LK_PATH=$(OUTPUT)$(LK_DIR)
 else
-        TE_PATH=$(TRACE_EVENT_DIR)
+  LK_PATH=$(OUTPUT)
+endif
+else
+  TE_PATH=$(TRACE_EVENT_DIR)
 endif
 
 LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
-TE_LIB := -L$(TE_PATH) -ltraceevent
+export LIBTRACEEVENT
 
-PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
-PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py
+LIBLK = $(LK_PATH)liblk.a
+export LIBLK
 
-export LIBTRACEEVENT
+# python extension build directories
+PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
+PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
+PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
+export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
+
+python-clean := rm -rf $(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) $(LIBLK)
 
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
-        $(QUIET_GEN)CFLAGS='$(BASIC_CFLAGS)' $(PYTHON_WORD) util/setup.py \
+        $(QUIET_GEN)CFLAGS='$(CFLAGS)' $(PYTHON_WORD) util/setup.py \
           --quiet build_ext; \
         mkdir -p $(OUTPUT)python && \
         cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
@@ -251,8 +167,6 @@ SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
 #
 PROGRAMS += $(OUTPUT)perf
 
-LANG_BINDINGS =
-
 # what 'all' will build and 'install' will install, in perfexecdir
 ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
 
@@ -261,28 +175,25 @@ OTHER_PROGRAMS = $(OUTPUT)perf
 
 # Set paths to tools early so that they can be used for version tests.
 ifndef SHELL_PATH
-        SHELL_PATH = /bin/sh
+  SHELL_PATH = /bin/sh
 endif
 ifndef PERL_PATH
-        PERL_PATH = /usr/bin/perl
+  PERL_PATH = /usr/bin/perl
 endif
 
 export PERL_PATH
 
-FLEX = flex
-BISON= bison
-
 $(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
         $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) -t util/parse-events.l > $(OUTPUT)util/parse-events-flex.c
 
 $(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
+        $(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) --header-file=$(OUTPUT)util/pmu-flex.h -t util/pmu.l > $(OUTPUT)util/pmu-flex.c
 
 $(OUTPUT)util/pmu-bison.c: util/pmu.y
-        $(QUIET_BISON)$(BISON) -v util/pmu.y -d -o $(OUTPUT)util/pmu-bison.c
+        $(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
@@ -329,7 +240,6 @@ LIB_H += util/cache.h
 LIB_H += util/callchain.h
 LIB_H += util/build-id.h
 LIB_H += util/debug.h
-LIB_H += util/debugfs.h
 LIB_H += util/sysfs.h
 LIB_H += util/pmu.h
 LIB_H += util/event.h
@@ -378,8 +288,11 @@ LIB_H += util/rblist.h
 LIB_H += util/intlist.h
 LIB_H += util/perf_regs.h
 LIB_H += util/unwind.h
-LIB_H += ui/helpline.h
 LIB_H += util/vdso.h
+LIB_H += ui/helpline.h
+LIB_H += ui/progress.h
+LIB_H += ui/util.h
+LIB_H += ui/ui.h
 
 LIB_OBJS += $(OUTPUT)util/abspath.o
 LIB_OBJS += $(OUTPUT)util/alias.o
@@ -387,7 +300,6 @@ 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/debugfs.o
 LIB_OBJS += $(OUTPUT)util/sysfs.o
 LIB_OBJS += $(OUTPUT)util/pmu.o
 LIB_OBJS += $(OUTPUT)util/environment.o
@@ -453,6 +365,7 @@ LIB_OBJS += $(OUTPUT)util/stat.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
 
@@ -471,7 +384,12 @@ 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/pmu.o
-LIB_OBJS += $(OUTPUT)tests/util.o
+LIB_OBJS += $(OUTPUT)tests/hists_link.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
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
@@ -504,78 +422,18 @@ 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) $(LIBTRACEEVENT)
-
-#
-# Platform specific tweaks
-#
+PERFLIBS = $(LIB_FILE) $(LIBLK) $(LIBTRACEEVENT)
 
 # We choose to avoid "if .. else if .. else .. endif endif"
 # because maintaining the nesting to match is a pain.  If
 # we had "elif" things would have been much nicer...
 
--include config.mak.autogen
--include config.mak
-
-ifdef NO_LIBELF
-        NO_DWARF := 1
-        NO_DEMANGLE := 1
-        NO_LIBUNWIND := 1
-else
-FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF),libelf),y)
-        FLAGS_GLIBC=$(ALL_CFLAGS) $(ALL_LDFLAGS)
-        ifeq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC),glibc),y)
-                LIBC_SUPPORT := 1
-        endif
-        ifeq ($(BIONIC),1)
-                LIBC_SUPPORT := 1
-        endif
-        ifeq ($(LIBC_SUPPORT),1)
-                msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);
-
-                NO_LIBELF := 1
-                NO_DWARF := 1
-                NO_DEMANGLE := 1
-        else
-                msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
-        endif
-else
-        # for linking with debug library, run like:
-        # make DEBUG=1 LIBDW_DIR=/opt/libdw/
-        ifdef LIBDW_DIR
-                LIBDW_CFLAGS  := -I$(LIBDW_DIR)/include
-                LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib
-        endif
-
-        FLAGS_DWARF=$(ALL_CFLAGS) $(LIBDW_CFLAGS) -ldw -lelf $(LIBDW_LDFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-        ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF),libdw),y)
-                msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
-                NO_DWARF := 1
-        endif # Dwarf support
-endif # SOURCE_LIBELF
-endif # NO_LIBELF
-
-ifndef NO_LIBUNWIND
-# for linking with debug library, run like:
-# make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/
-ifdef LIBUNWIND_DIR
-        LIBUNWIND_CFLAGS  := -I$(LIBUNWIND_DIR)/include
-        LIBUNWIND_LDFLAGS := -L$(LIBUNWIND_DIR)/lib
-endif
-
-FLAGS_UNWIND=$(LIBUNWIND_CFLAGS) $(ALL_CFLAGS) $(LIBUNWIND_LDFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(LIBUNWIND_LIBS)
-ifneq ($(call try-cc,$(SOURCE_LIBUNWIND),$(FLAGS_UNWIND),libunwind),y)
-        msg := $(warning No libunwind found, disabling post unwind support. Please install libunwind-dev[el] >= 0.99);
-        NO_LIBUNWIND := 1
-endif # Libunwind support
-endif # NO_LIBUNWIND
-
 -include arch/$(ARCH)/Makefile
 
 ifneq ($(OUTPUT),)
-        BASIC_CFLAGS += -I$(OUTPUT)
+  CFLAGS += -I$(OUTPUT)
 endif
 
 ifdef NO_LIBELF
@@ -593,282 +451,74 @@ BUILTIN_OBJS := $(filter-out $(OUTPUT)builtin-probe.o,$(BUILTIN_OBJS))
 LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
 
 else # NO_LIBELF
-BASIC_CFLAGS += -DLIBELF_SUPPORT
-
-FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
-        BASIC_CFLAGS += -DLIBELF_MMAP
-endif
-
 ifndef NO_DWARF
-ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
-        msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
-else
-        BASIC_CFLAGS := -DDWARF_SUPPORT $(LIBDW_CFLAGS) $(BASIC_CFLAGS)
-        BASIC_LDFLAGS := $(LIBDW_LDFLAGS) $(BASIC_LDFLAGS)
-        EXTLIBS += -lelf -ldw
-        LIB_OBJS += $(OUTPUT)util/probe-finder.o
-        LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
-endif # PERF_HAVE_DWARF_REGS
+  LIB_OBJS += $(OUTPUT)util/probe-finder.o
+  LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
 endif # NO_DWARF
 endif # NO_LIBELF
 
 ifndef NO_LIBUNWIND
-        BASIC_CFLAGS += -DLIBUNWIND_SUPPORT
-        EXTLIBS += $(LIBUNWIND_LIBS)
-        BASIC_CFLAGS := $(LIBUNWIND_CFLAGS) $(BASIC_CFLAGS)
-        BASIC_LDFLAGS := $(LIBUNWIND_LDFLAGS) $(BASIC_LDFLAGS)
-        LIB_OBJS += $(OUTPUT)util/unwind.o
+  LIB_OBJS += $(OUTPUT)util/unwind.o
 endif
 
 ifndef NO_LIBAUDIT
-        FLAGS_LIBAUDIT = $(ALL_CFLAGS) $(ALL_LDFLAGS) -laudit
-        ifneq ($(call try-cc,$(SOURCE_LIBAUDIT),$(FLAGS_LIBAUDIT),libaudit),y)
-                msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);
-        else
-                BASIC_CFLAGS += -DLIBAUDIT_SUPPORT
-                BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
-                EXTLIBS += -laudit
-        endif
+  BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
 endif
 
-ifndef NO_NEWT
-        FLAGS_NEWT=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lnewt
-        ifneq ($(call try-cc,$(SOURCE_NEWT),$(FLAGS_NEWT),libnewt),y)
-                msg := $(warning newt not found, disables TUI support. Please install newt-devel or libnewt-dev);
-        else
-                # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
-                BASIC_CFLAGS += -I/usr/include/slang
-                BASIC_CFLAGS += -DNEWT_SUPPORT
-                EXTLIBS += -lnewt -lslang
-                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/util.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/browser.h
-                LIB_H += ui/browsers/map.h
-                LIB_H += ui/keysyms.h
-                LIB_H += ui/libslang.h
-                LIB_H += ui/progress.h
-                LIB_H += ui/util.h
-                LIB_H += ui/ui.h
-        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/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/browser.h
+  LIB_H += ui/browsers/map.h
+  LIB_H += ui/keysyms.h
+  LIB_H += ui/libslang.h
 endif
 
 ifndef NO_GTK2
-        FLAGS_GTK2=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(shell pkg-config --libs --cflags gtk+-2.0 2>/dev/null)
-        ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2),gtk2),y)
-                msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
-        else
-                ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2),-DHAVE_GTK_INFO_BAR),y)
-                        BASIC_CFLAGS += -DHAVE_GTK_INFO_BAR
-                endif
-                BASIC_CFLAGS += -DGTK2_SUPPORT
-                BASIC_CFLAGS += $(shell pkg-config --cflags gtk+-2.0 2>/dev/null)
-                EXTLIBS += $(shell pkg-config --libs gtk+-2.0 2>/dev/null)
-                LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/util.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/helpline.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/progress.o
-                # Make sure that it'd be included only once.
-                ifeq ($(findstring -DNEWT_SUPPORT,$(BASIC_CFLAGS)),)
-                        LIB_OBJS += $(OUTPUT)ui/util.o
-                endif
-        endif
-endif
-
-ifdef NO_LIBPERL
-        BASIC_CFLAGS += -DNO_LIBPERL
-else
-       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)
-
-        ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED),perl),y)
-                BASIC_CFLAGS += -DNO_LIBPERL
-        else
-               ALL_LDFLAGS += $(PERL_EMBED_LDFLAGS)
-               EXTLIBS += $(PERL_EMBED_LIBADD)
-                LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
-                LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
-        endif
+  LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/hists.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/util.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/helpline.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/progress.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/annotate.o
 endif
 
-disable-python = $(eval $(disable-python_code))
-define disable-python_code
-  BASIC_CFLAGS += -DNO_LIBPYTHON
-  $(if $(1),$(warning No $(1) was found))
-  $(warning Python support won't be built)
-endef
-
-override PYTHON := \
-  $(call get-executable-or-default,PYTHON,python)
-
-ifndef PYTHON
-  $(call disable-python,python interpreter)
-  python-clean :=
-else
-
-  PYTHON_WORD := $(call shell-wordify,$(PYTHON))
-
-  # python extension build directories
-  PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
-  PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
-  PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
-  export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
-
-  python-clean := rm -rf $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
-
-  ifdef NO_LIBPYTHON
-    $(call disable-python)
-  else
-
-    override PYTHON_CONFIG := \
-      $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
-
-    ifndef PYTHON_CONFIG
-      $(call disable-python,python-config tool)
-    else
-
-      PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
-
-      PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
-      PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
-      PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
-      PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
-      FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
-
-      ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED),python),y)
-        $(call disable-python,Python.h (for Python 2.x))
-      else
-
-        ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED),python version),y)
-          $(warning Python 3 is not yet supported; please set)
-          $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
-          $(warning If you also have Python 2 installed, then)
-          $(warning try something like:)
-          $(warning $(and ,))
-          $(warning $(and ,)  make PYTHON=python2)
-          $(warning $(and ,))
-          $(warning Otherwise, disable Python support entirely:)
-          $(warning $(and ,))
-          $(warning $(and ,)  make NO_LIBPYTHON=1)
-          $(warning $(and ,))
-          $(error   $(and ,))
-        else
-          ALL_LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
-          EXTLIBS += $(PYTHON_EMBED_LIBADD)
-          LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
-          LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
-          LANG_BINDINGS += $(OUTPUT)python/perf.so
-        endif
-
-      endif
-    endif
-  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
 
-ifdef NO_DEMANGLE
-        BASIC_CFLAGS += -DNO_DEMANGLE
-else
-        ifdef HAVE_CPLUS_DEMANGLE
-                EXTLIBS += -liberty
-                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
-        else
-                FLAGS_BFD=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -DPACKAGE='perf' -lbfd
-                has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD),libbfd)
-                ifeq ($(has_bfd),y)
-                        EXTLIBS += -lbfd
-                else
-                        FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
-                        has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY),liberty)
-                        ifeq ($(has_bfd_iberty),y)
-                                EXTLIBS += -lbfd -liberty
-                        else
-                                FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
-                                has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z),libz)
-                                ifeq ($(has_bfd_iberty_z),y)
-                                        EXTLIBS += -lbfd -liberty -lz
-                                else
-                                        FLAGS_CPLUS_DEMANGLE=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -liberty
-                                        has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE),demangle)
-                                        ifeq ($(has_cplus_demangle),y)
-                                                EXTLIBS += -liberty
-                                                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
-                                        else
-                                                msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
-                                                BASIC_CFLAGS += -DNO_DEMANGLE
-                                        endif
-                                endif
-                        endif
-                endif
-        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
-        BASIC_CFLAGS += -DHAVE_PERF_REGS
-endif
-
-ifndef NO_STRLCPY
-        ifeq ($(call try-cc,$(SOURCE_STRLCPY),,-DHAVE_STRLCPY),y)
-                BASIC_CFLAGS += -DHAVE_STRLCPY
-        endif
-endif
-
-ifndef NO_ON_EXIT
-        ifeq ($(call try-cc,$(SOURCE_ON_EXIT),,-DHAVE_ON_EXIT),y)
-                BASIC_CFLAGS += -DHAVE_ON_EXIT
-        endif
+  ifeq ($(ARCH),x86)
+    LIB_H += arch/x86/include/perf_regs.h
+  endif
 endif
 
-ifndef NO_BACKTRACE
-       ifeq ($(call try-cc,$(SOURCE_BACKTRACE),,-DBACKTRACE_SUPPORT),y)
-               BASIC_CFLAGS += -DBACKTRACE_SUPPORT
-       endif
+ifndef NO_LIBNUMA
+  BUILTIN_OBJS += $(OUTPUT)bench/numa.o
 endif
 
 ifdef ASCIIDOC8
-        export ASCIIDOC8
+  export ASCIIDOC8
 endif
 
-# Shell quote (do not use $(call) to accommodate ancient setups);
-
-ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
-
-DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
-bindir_SQ = $(subst ','\'',$(bindir))
-bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
-mandir_SQ = $(subst ','\'',$(mandir))
-infodir_SQ = $(subst ','\'',$(infodir))
-perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
-template_dir_SQ = $(subst ','\'',$(template_dir))
-htmldir_SQ = $(subst ','\'',$(htmldir))
-prefix_SQ = $(subst ','\'',$(prefix))
-sysconfdir_SQ = $(subst ','\'',$(sysconfdir))
-
-SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
-
 LIBS = -Wl,--whole-archive $(PERFLIBS) -Wl,--no-whole-archive -Wl,--start-group $(EXTLIBS) -Wl,--end-group
 
-ALL_CFLAGS += $(BASIC_CFLAGS)
-ALL_CFLAGS += $(ARCH_CFLAGS)
-ALL_LDFLAGS += $(BASIC_LDFLAGS)
-
 export INSTALL SHELL_PATH
 
-
 ### Build rules
 
 SHELL = $(SHELL_PATH)
@@ -884,22 +534,22 @@ 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) -DPERF_VERSION='"$(PERF_VERSION)"' \
+        $(QUIET_CC)$(CC) -include $(OUTPUT)PERF-VERSION-FILE \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                $(ALL_CFLAGS) -c $(filter %.c,$^) -o $@
+                $(CFLAGS) -c $(filter %.c,$^) -o $@
 
 $(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(OUTPUT)perf.o \
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OUTPUT)perf.o \
                $(BUILTIN_OBJS) $(LIBS) -o $@
 
 $(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
                 '-DPERF_MAN_PATH="$(mandir_SQ)"' \
                 '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 
 $(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
                 '-DPERF_MAN_PATH="$(mandir_SQ)"' \
                 '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
@@ -924,71 +574,77 @@ $(OUTPUT)perf.o perf.spec \
 # over the general rule for .o
 
 $(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(ALL_CFLAGS) -w $<
+        $(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/ $(ALL_CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
+        $(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 $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -E $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 $(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -S $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -S $(CFLAGS) $<
 $(OUTPUT)%.o: %.S
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.s: %.S
-        $(QUIET_CC)$(CC) -o $@ -E $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 
 $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_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 $(ALL_CFLAGS) \
-                '-DBINDIR="$(bindir_SQ)"' \
+        $(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)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
 $(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+        $(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 $(ALL_CFLAGS) -Wno-redundant-decls $<
+        $(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 $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 
 $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 
 $(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+        $(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 $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
+        $(QUIET_LINK)$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(filter %.o,$^) $(LIBS)
 
 $(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
 $(patsubst perf-%,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
@@ -1011,6 +667,18 @@ $(LIBTRACEEVENT):
 $(LIBTRACEEVENT)-clean:
         $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) clean
 
+# if subdir is set, we've been called from above so target has been built
+# already
+$(LIBLK):
+ifeq ($(subdir),)
+        $(QUIET_SUBDIR0)$(LK_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) liblk.a
+endif
+
+$(LIBLK)-clean:
+ifeq ($(subdir),)
+        $(QUIET_SUBDIR0)$(LK_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) clean
+endif
+
 help:
         @echo 'Perf make targets:'
         @echo '  doc            - make *all* documentation (see below)'
@@ -1063,7 +731,7 @@ cscope:
         $(FIND) . -name '*.[hcS]' -print | xargs cscope -b
 
 ### Detect prefix changes
-TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
+TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):\
              $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
 
 $(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
@@ -1084,7 +752,7 @@ check: $(OUTPUT)common-cmds.h
         then \
                 for i in *.c */*.c; \
                 do \
-                        sparse $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
+                        sparse $(CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
                 done; \
         else \
                 exit 1; \
@@ -1092,14 +760,7 @@ check: $(OUTPUT)common-cmds.h
 
 ### Installation rules
 
-ifneq ($(filter /%,$(firstword $(perfexecdir))),)
-perfexec_instdir = $(perfexecdir)
-else
-perfexec_instdir = $(prefix)/$(perfexecdir)
-endif
-perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
-
-install: all try-install-man
+install-bin: all
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
         $(INSTALL) $(OUTPUT)perf '$(DESTDIR_SQ)$(bindir_SQ)'
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
@@ -1120,6 +781,8 @@ install: all try-install-man
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
         $(INSTALL) tests/attr/* '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
 
+install: install-bin try-install-man
+
 install-python_ext:
         $(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
 
@@ -1129,7 +792,7 @@ $(INSTALL_DOC_TARGETS):
 
 ### Cleaning rules
 
-clean: $(LIBTRACEEVENT)-clean
+clean: $(LIBTRACEEVENT)-clean $(LIBLK)-clean
         $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf.o $(LANG_BINDINGS)
         $(RM) $(ALL_PROGRAMS) perf
         $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
@@ -1139,6 +802,6 @@ clean: $(LIBTRACEEVENT)-clean
         $(RM) $(OUTPUT)util/*-flex*
         $(python-clean)
 
-.PHONY: all install clean strip $(LIBTRACEEVENT)
+.PHONY: all install clean strip $(LIBTRACEEVENT) $(LIBLK)
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
 .PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
diff --git a/tools/perf/arch/arm/util/dwarf-regs.c b/tools/perf/arch/arm/util/dwarf-regs.c
index e8d5c551c69c..33ec5b339da8 100644
--- a/tools/perf/arch/arm/util/dwarf-regs.c
+++ b/tools/perf/arch/arm/util/dwarf-regs.c
@@ -8,10 +8,7 @@
  * published by the Free Software Foundation.
  */
 
-#include <stdlib.h>
-#ifndef __UCLIBC__
-#include <libio.h>
-#endif
+#include <stddef.h>
 #include <dwarf-regs.h>
 
 struct pt_regs_dwarfnum {
diff --git a/tools/perf/arch/common.c b/tools/perf/arch/common.c
index 3e975cb6232e..aacef07ebf31 100644
--- a/tools/perf/arch/common.c
+++ b/tools/perf/arch/common.c
@@ -155,6 +155,7 @@ static int perf_session_env__lookup_binutils_path(struct perf_session_env *env,
                 if (lookup_path(buf))
                         goto out;
                 free(buf);
+                buf = NULL;
         }
 
         if (!strcmp(arch, "arm"))
diff --git a/tools/perf/arch/powerpc/util/dwarf-regs.c b/tools/perf/arch/powerpc/util/dwarf-regs.c
index 7cdd61d0e27c..733151cdf46e 100644
--- a/tools/perf/arch/powerpc/util/dwarf-regs.c
+++ b/tools/perf/arch/powerpc/util/dwarf-regs.c
@@ -9,10 +9,7 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <stdlib.h>
-#ifndef __UCLIBC__
-#include <libio.h>
-#endif
+#include <stddef.h>
 #include <dwarf-regs.h>
 
 
diff --git a/tools/perf/arch/s390/util/dwarf-regs.c b/tools/perf/arch/s390/util/dwarf-regs.c
index e19653e025fa..0469df02ee62 100644
--- a/tools/perf/arch/s390/util/dwarf-regs.c
+++ b/tools/perf/arch/s390/util/dwarf-regs.c
@@ -6,7 +6,7 @@
  *
  */
 
-#include <libio.h>
+#include <stddef.h>
 #include <dwarf-regs.h>
 
 #define NUM_GPRS 16
diff --git a/tools/perf/arch/sh/util/dwarf-regs.c b/tools/perf/arch/sh/util/dwarf-regs.c
index a11edb007a6c..0d0897f57a10 100644
--- a/tools/perf/arch/sh/util/dwarf-regs.c
+++ b/tools/perf/arch/sh/util/dwarf-regs.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <libio.h>
+#include <stddef.h>
 #include <dwarf-regs.h>
 
 /*
diff --git a/tools/perf/arch/sparc/util/dwarf-regs.c b/tools/perf/arch/sparc/util/dwarf-regs.c
index 0ab88483720c..92eda412fed3 100644
--- a/tools/perf/arch/sparc/util/dwarf-regs.c
+++ b/tools/perf/arch/sparc/util/dwarf-regs.c
@@ -9,7 +9,7 @@
  * 2 of the License, or (at your option) any later version.
  */
 
-#include <libio.h>
+#include <stddef.h>
 #include <dwarf-regs.h>
 
 #define SPARC_MAX_REGS  96
diff --git a/tools/perf/arch/x86/util/dwarf-regs.c b/tools/perf/arch/x86/util/dwarf-regs.c
index a794d3081928..be22dd463232 100644
--- a/tools/perf/arch/x86/util/dwarf-regs.c
+++ b/tools/perf/arch/x86/util/dwarf-regs.c
@@ -20,7 +20,7 @@
  *
  */
 
-#include <libio.h>
+#include <stddef.h>
 #include <dwarf-regs.h>
 
 /*
diff --git a/tools/perf/bench/bench.h b/tools/perf/bench/bench.h
index 8f89998eeaf4..0fdc85269c4d 100644
--- a/tools/perf/bench/bench.h
+++ b/tools/perf/bench/bench.h
@@ -1,6 +1,31 @@
 #ifndef BENCH_H
 #define BENCH_H
 
+/*
+ * The madvise transparent hugepage constants were added in glibc
+ * 2.13. For compatibility with older versions of glibc, define these
+ * tokens if they are not already defined.
+ *
+ * PA-RISC uses different madvise values from other architectures and
+ * needs to be special-cased.
+ */
+#ifdef __hppa__
+# ifndef MADV_HUGEPAGE
+#  define MADV_HUGEPAGE         67
+# endif
+# ifndef MADV_NOHUGEPAGE
+#  define MADV_NOHUGEPAGE       68
+# endif
+#else
+# ifndef MADV_HUGEPAGE
+#  define MADV_HUGEPAGE         14
+# endif
+# ifndef MADV_NOHUGEPAGE
+#  define MADV_NOHUGEPAGE       15
+# endif
+#endif
+
+extern int bench_numa(int argc, const char **argv, const char *prefix);
 extern int bench_sched_messaging(int argc, const char **argv, const char *prefix);
 extern int bench_sched_pipe(int argc, const char **argv, const char *prefix);
 extern int bench_mem_memcpy(int argc, const char **argv,
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
new file mode 100644
index 000000000000..30d1c3225b46
--- /dev/null
+++ b/tools/perf/bench/numa.c
@@ -0,0 +1,1731 @@
+/*
+ * numa.c
+ *
+ * numa: Simulate NUMA-sensitive workload and measure their NUMA performance
+ */
+
+#include "../perf.h"
+#include "../builtin.h"
+#include "../util/util.h"
+#include "../util/parse-options.h"
+
+#include "bench.h"
+
+#include <errno.h>
+#include <sched.h>
+#include <stdio.h>
+#include <assert.h>
+#include <malloc.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/prctl.h>
+#include <sys/types.h>
+
+#include <numa.h>
+#include <numaif.h>
+
+/*
+ * Regular printout to the terminal, supressed if -q is specified:
+ */
+#define tprintf(x...) do { if (g && g->p.show_details >= 0) printf(x); } while (0)
+
+/*
+ * Debug printf:
+ */
+#define dprintf(x...) do { if (g && g->p.show_details >= 1) printf(x); } while (0)
+
+struct thread_data {
+        int                     curr_cpu;
+        cpu_set_t               bind_cpumask;
+        int                     bind_node;
+        u8                      *process_data;
+        int                     process_nr;
+        int                     thread_nr;
+        int                     task_nr;
+        unsigned int            loops_done;
+        u64                     val;
+        u64                     runtime_ns;
+        pthread_mutex_t         *process_lock;
+};
+
+/* Parameters set by options: */
+
+struct params {
+        /* Startup synchronization: */
+        bool                    serialize_startup;
+
+        /* Task hierarchy: */
+        int                     nr_proc;
+        int                     nr_threads;
+
+        /* Working set sizes: */
+        const char              *mb_global_str;
+        const char              *mb_proc_str;
+        const char              *mb_proc_locked_str;
+        const char              *mb_thread_str;
+
+        double                  mb_global;
+        double                  mb_proc;
+        double                  mb_proc_locked;
+        double                  mb_thread;
+
+        /* Access patterns to the working set: */
+        bool                    data_reads;
+        bool                    data_writes;
+        bool                    data_backwards;
+        bool                    data_zero_memset;
+        bool                    data_rand_walk;
+        u32                     nr_loops;
+        u32                     nr_secs;
+        u32                     sleep_usecs;
+
+        /* Working set initialization: */
+        bool                    init_zero;
+        bool                    init_random;
+        bool                    init_cpu0;
+
+        /* Misc options: */
+        int                     show_details;
+        int                     run_all;
+        int                     thp;
+
+        long                    bytes_global;
+        long                    bytes_process;
+        long                    bytes_process_locked;
+        long                    bytes_thread;
+
+        int                     nr_tasks;
+        bool                    show_quiet;
+
+        bool                    show_convergence;
+        bool                    measure_convergence;
+
+        int                     perturb_secs;
+        int                     nr_cpus;
+        int                     nr_nodes;
+
+        /* Affinity options -C and -N: */
+        char                    *cpu_list_str;
+        char                    *node_list_str;
+};
+
+
+/* Global, read-writable area, accessible to all processes and threads: */
+
+struct global_info {
+        u8                      *data;
+
+        pthread_mutex_t         startup_mutex;
+        int                     nr_tasks_started;
+
+        pthread_mutex_t         startup_done_mutex;
+
+        pthread_mutex_t         start_work_mutex;
+        int                     nr_tasks_working;
+
+        pthread_mutex_t         stop_work_mutex;
+        u64                     bytes_done;
+
+        struct thread_data      *threads;
+
+        /* Convergence latency measurement: */
+        bool                    all_converged;
+        bool                    stop_work;
+
+        int                     print_once;
+
+        struct params           p;
+};
+
+static struct global_info       *g = NULL;
+
+static int parse_cpus_opt(const struct option *opt, const char *arg, int unset);
+static int parse_nodes_opt(const struct option *opt, const char *arg, int unset);
+
+struct params p0;
+
+static const struct option options[] = {
+        OPT_INTEGER('p', "nr_proc"      , &p0.nr_proc,          "number of processes"),
+        OPT_INTEGER('t', "nr_threads"   , &p0.nr_threads,       "number of threads per process"),
+
+        OPT_STRING('G', "mb_global"     , &p0.mb_global_str,    "MB", "global  memory (MBs)"),
+        OPT_STRING('P', "mb_proc"       , &p0.mb_proc_str,      "MB", "process memory (MBs)"),
+        OPT_STRING('L', "mb_proc_locked", &p0.mb_proc_locked_str,"MB", "process serialized/locked memory access (MBs), <= process_memory"),
+        OPT_STRING('T', "mb_thread"     , &p0.mb_thread_str,    "MB", "thread  memory (MBs)"),
+
+        OPT_UINTEGER('l', "nr_loops"    , &p0.nr_loops,         "max number of loops to run"),
+        OPT_UINTEGER('s', "nr_secs"     , &p0.nr_secs,          "max number of seconds to run"),
+        OPT_UINTEGER('u', "usleep"      , &p0.sleep_usecs,      "usecs to sleep per loop iteration"),
+
+        OPT_BOOLEAN('R', "data_reads"   , &p0.data_reads,       "access the data via writes (can be mixed with -W)"),
+        OPT_BOOLEAN('W', "data_writes"  , &p0.data_writes,      "access the data via writes (can be mixed with -R)"),
+        OPT_BOOLEAN('B', "data_backwards", &p0.data_backwards,  "access the data backwards as well"),
+        OPT_BOOLEAN('Z', "data_zero_memset", &p0.data_zero_memset,"access the data via glibc bzero only"),
+        OPT_BOOLEAN('r', "data_rand_walk", &p0.data_rand_walk,  "access the data with random (32bit LFSR) walk"),
+
+
+        OPT_BOOLEAN('z', "init_zero"    , &p0.init_zero,        "bzero the initial allocations"),
+        OPT_BOOLEAN('I', "init_random"  , &p0.init_random,      "randomize the contents of the initial allocations"),
+        OPT_BOOLEAN('0', "init_cpu0"    , &p0.init_cpu0,        "do the initial allocations on CPU#0"),
+        OPT_INTEGER('x', "perturb_secs", &p0.perturb_secs,      "perturb thread 0/0 every X secs, to test convergence stability"),
+
+        OPT_INCR   ('d', "show_details" , &p0.show_details,     "Show details"),
+        OPT_INCR   ('a', "all"          , &p0.run_all,          "Run all tests in the suite"),
+        OPT_INTEGER('H', "thp"          , &p0.thp,              "MADV_NOHUGEPAGE < 0 < MADV_HUGEPAGE"),
+        OPT_BOOLEAN('c', "show_convergence", &p0.show_convergence, "show convergence details"),
+        OPT_BOOLEAN('m', "measure_convergence", &p0.measure_convergence, "measure convergence latency"),
+        OPT_BOOLEAN('q', "quiet"        , &p0.show_quiet,       "bzero the initial allocations"),
+        OPT_BOOLEAN('S', "serialize-startup", &p0.serialize_startup,"serialize thread startup"),
+
+        /* Special option string parsing callbacks: */
+        OPT_CALLBACK('C', "cpus", NULL, "cpu[,cpu2,...cpuN]",
+                        "bind the first N tasks to these specific cpus (the rest is unbound)",
+                        parse_cpus_opt),
+        OPT_CALLBACK('M', "memnodes", NULL, "node[,node2,...nodeN]",
+                        "bind the first N tasks to these specific memory nodes (the rest is unbound)",
+                        parse_nodes_opt),
+        OPT_END()
+};
+
+static const char * const bench_numa_usage[] = {
+        "perf bench numa <options>",
+        NULL
+};
+
+static const char * const numa_usage[] = {
+        "perf bench numa mem [<options>]",
+        NULL
+};
+
+static cpu_set_t bind_to_cpu(int target_cpu)
+{
+        cpu_set_t orig_mask, mask;
+        int ret;
+
+        ret = sched_getaffinity(0, sizeof(orig_mask), &orig_mask);
+        BUG_ON(ret);
+
+        CPU_ZERO(&mask);
+
+        if (target_cpu == -1) {
+                int cpu;
+
+                for (cpu = 0; cpu < g->p.nr_cpus; cpu++)
+                        CPU_SET(cpu, &mask);
+        } else {
+                BUG_ON(target_cpu < 0 || target_cpu >= g->p.nr_cpus);
+                CPU_SET(target_cpu, &mask);
+        }
+
+        ret = sched_setaffinity(0, sizeof(mask), &mask);
+        BUG_ON(ret);
+
+        return orig_mask;
+}
+
+static cpu_set_t bind_to_node(int target_node)
+{
+        int cpus_per_node = g->p.nr_cpus/g->p.nr_nodes;
+        cpu_set_t orig_mask, mask;
+        int cpu;
+        int ret;
+
+        BUG_ON(cpus_per_node*g->p.nr_nodes != g->p.nr_cpus);
+        BUG_ON(!cpus_per_node);
+
+        ret = sched_getaffinity(0, sizeof(orig_mask), &orig_mask);
+        BUG_ON(ret);
+
+        CPU_ZERO(&mask);
+
+        if (target_node == -1) {
+                for (cpu = 0; cpu < g->p.nr_cpus; cpu++)
+                        CPU_SET(cpu, &mask);
+        } else {
+                int cpu_start = (target_node + 0) * cpus_per_node;
+                int cpu_stop  = (target_node + 1) * cpus_per_node;
+
+                BUG_ON(cpu_stop > g->p.nr_cpus);
+
+                for (cpu = cpu_start; cpu < cpu_stop; cpu++)
+                        CPU_SET(cpu, &mask);
+        }
+
+        ret = sched_setaffinity(0, sizeof(mask), &mask);
+        BUG_ON(ret);
+
+        return orig_mask;
+}
+
+static void bind_to_cpumask(cpu_set_t mask)
+{
+        int ret;
+
+        ret = sched_setaffinity(0, sizeof(mask), &mask);
+        BUG_ON(ret);
+}
+
+static void mempol_restore(void)
+{
+        int ret;
+
+        ret = set_mempolicy(MPOL_DEFAULT, NULL, g->p.nr_nodes-1);
+
+        BUG_ON(ret);
+}
+
+static void bind_to_memnode(int node)
+{
+        unsigned long nodemask;
+        int ret;
+
+        if (node == -1)
+                return;
+
+        BUG_ON(g->p.nr_nodes > (int)sizeof(nodemask));
+        nodemask = 1L << node;
+
+        ret = set_mempolicy(MPOL_BIND, &nodemask, sizeof(nodemask)*8);
+        dprintf("binding to node %d, mask: %016lx => %d\n", node, nodemask, ret);
+
+        BUG_ON(ret);
+}
+
+#define HPSIZE (2*1024*1024)
+
+#define set_taskname(fmt...)                            \
+do {                                                    \
+        char name[20];                                  \
+                                                        \
+        snprintf(name, 20, fmt);                        \
+        prctl(PR_SET_NAME, name);                       \
+} while (0)
+
+static u8 *alloc_data(ssize_t bytes0, int map_flags,
+                      int init_zero, int init_cpu0, int thp, int init_random)
+{
+        cpu_set_t orig_mask;
+        ssize_t bytes;
+        u8 *buf;
+        int ret;
+
+        if (!bytes0)
+                return NULL;
+
+        /* Allocate and initialize all memory on CPU#0: */
+        if (init_cpu0) {
+                orig_mask = bind_to_node(0);
+                bind_to_memnode(0);
+        }
+
+        bytes = bytes0 + HPSIZE;
+
+        buf = (void *)mmap(0, bytes, PROT_READ|PROT_WRITE, MAP_ANON|map_flags, -1, 0);
+        BUG_ON(buf == (void *)-1);
+
+        if (map_flags == MAP_PRIVATE) {
+                if (thp > 0) {
+                        ret = madvise(buf, bytes, MADV_HUGEPAGE);
+                        if (ret && !g->print_once) {
+                                g->print_once = 1;
+                                printf("WARNING: Could not enable THP - do: 'echo madvise > /sys/kernel/mm/transparent_hugepage/enabled'\n");
+                        }
+                }
+                if (thp < 0) {
+                        ret = madvise(buf, bytes, MADV_NOHUGEPAGE);
+                        if (ret && !g->print_once) {
+                                g->print_once = 1;
+                                printf("WARNING: Could not disable THP: run a CONFIG_TRANSPARENT_HUGEPAGE kernel?\n");
+                        }
+                }
+        }
+
+        if (init_zero) {
+                bzero(buf, bytes);
+        } else {
+                /* Initialize random contents, different in each word: */
+                if (init_random) {
+                        u64 *wbuf = (void *)buf;
+                        long off = rand();
+                        long i;
+
+                        for (i = 0; i < bytes/8; i++)
+                                wbuf[i] = i + off;
+                }
+        }
+
+        /* Align to 2MB boundary: */
+        buf = (void *)(((unsigned long)buf + HPSIZE-1) & ~(HPSIZE-1));
+
+        /* Restore affinity: */
+        if (init_cpu0) {
+                bind_to_cpumask(orig_mask);
+                mempol_restore();
+        }
+
+        return buf;
+}
+
+static void free_data(void *data, ssize_t bytes)
+{
+        int ret;
+
+        if (!data)
+                return;
+
+        ret = munmap(data, bytes);
+        BUG_ON(ret);
+}
+
+/*
+ * Create a shared memory buffer that can be shared between processes, zeroed:
+ */
+static void * zalloc_shared_data(ssize_t bytes)
+{
+        return alloc_data(bytes, MAP_SHARED, 1, g->p.init_cpu0,  g->p.thp, g->p.init_random);
+}
+
+/*
+ * Create a shared memory buffer that can be shared between processes:
+ */
+static void * setup_shared_data(ssize_t bytes)
+{
+        return alloc_data(bytes, MAP_SHARED, 0, g->p.init_cpu0,  g->p.thp, g->p.init_random);
+}
+
+/*
+ * Allocate process-local memory - this will either be shared between
+ * threads of this process, or only be accessed by this thread:
+ */
+static void * setup_private_data(ssize_t bytes)
+{
+        return alloc_data(bytes, MAP_PRIVATE, 0, g->p.init_cpu0,  g->p.thp, g->p.init_random);
+}
+
+/*
+ * Return a process-shared (global) mutex:
+ */
+static void init_global_mutex(pthread_mutex_t *mutex)
+{
+        pthread_mutexattr_t attr;
+
+        pthread_mutexattr_init(&attr);
+        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
+        pthread_mutex_init(mutex, &attr);
+}
+
+static int parse_cpu_list(const char *arg)
+{
+        p0.cpu_list_str = strdup(arg);
+
+        dprintf("got CPU list: {%s}\n", p0.cpu_list_str);
+
+        return 0;
+}
+
+static void parse_setup_cpu_list(void)
+{
+        struct thread_data *td;
+        char *str0, *str;
+        int t;
+
+        if (!g->p.cpu_list_str)
+                return;
+
+        dprintf("g->p.nr_tasks: %d\n", g->p.nr_tasks);
+
+        str0 = str = strdup(g->p.cpu_list_str);
+        t = 0;
+
+        BUG_ON(!str);
+
+        tprintf("# binding tasks to CPUs:\n");
+        tprintf("#  ");
+
+        while (true) {
+                int bind_cpu, bind_cpu_0, bind_cpu_1;
+                char *tok, *tok_end, *tok_step, *tok_len, *tok_mul;
+                int bind_len;
+                int step;
+                int mul;
+
+                tok = strsep(&str, ",");
+                if (!tok)
+                        break;
+
+                tok_end = strstr(tok, "-");
+
+                dprintf("\ntoken: {%s}, end: {%s}\n", tok, tok_end);
+                if (!tok_end) {
+                        /* Single CPU specified: */
+                        bind_cpu_0 = bind_cpu_1 = atol(tok);
+                } else {
+                        /* CPU range specified (for example: "5-11"): */
+                        bind_cpu_0 = atol(tok);
+                        bind_cpu_1 = atol(tok_end + 1);
+                }
+
+                step = 1;
+                tok_step = strstr(tok, "#");
+                if (tok_step) {
+                        step = atol(tok_step + 1);
+                        BUG_ON(step <= 0 || step >= g->p.nr_cpus);
+                }
+
+                /*
+                 * Mask length.
+                 * Eg: "--cpus 8_4-16#4" means: '--cpus 8_4,12_4,16_4',
+                 * where the _4 means the next 4 CPUs are allowed.
+                 */
+                bind_len = 1;
+                tok_len = strstr(tok, "_");
+                if (tok_len) {
+                        bind_len = atol(tok_len + 1);
+                        BUG_ON(bind_len <= 0 || bind_len > g->p.nr_cpus);
+                }
+
+                /* Multiplicator shortcut, "0x8" is a shortcut for: "0,0,0,0,0,0,0,0" */
+                mul = 1;
+                tok_mul = strstr(tok, "x");
+                if (tok_mul) {
+                        mul = atol(tok_mul + 1);
+                        BUG_ON(mul <= 0);
+                }
+
+                dprintf("CPUs: %d_%d-%d#%dx%d\n", bind_cpu_0, bind_len, bind_cpu_1, step, mul);
+
+                BUG_ON(bind_cpu_0 < 0 || bind_cpu_0 >= g->p.nr_cpus);
+                BUG_ON(bind_cpu_1 < 0 || bind_cpu_1 >= g->p.nr_cpus);
+                BUG_ON(bind_cpu_0 > bind_cpu_1);
+
+                for (bind_cpu = bind_cpu_0; bind_cpu <= bind_cpu_1; bind_cpu += step) {
+                        int i;
+
+                        for (i = 0; i < mul; i++) {
+                                int cpu;
+
+                                if (t >= g->p.nr_tasks) {
+                                        printf("\n# NOTE: ignoring bind CPUs starting at CPU#%d\n #", bind_cpu);
+                                        goto out;
+                                }
+                                td = g->threads + t;
+
+                                if (t)
+                                        tprintf(",");
+                                if (bind_len > 1) {
+                                        tprintf("%2d/%d", bind_cpu, bind_len);
+                                } else {
+                                        tprintf("%2d", bind_cpu);
+                                }
+
+                                CPU_ZERO(&td->bind_cpumask);
+                                for (cpu = bind_cpu; cpu < bind_cpu+bind_len; cpu++) {
+                                        BUG_ON(cpu < 0 || cpu >= g->p.nr_cpus);
+                                        CPU_SET(cpu, &td->bind_cpumask);
+                                }
+                                t++;
+                        }
+                }
+        }
+out:
+
+        tprintf("\n");
+
+        if (t < g->p.nr_tasks)
+                printf("# NOTE: %d tasks bound, %d tasks unbound\n", t, g->p.nr_tasks - t);
+
+        free(str0);
+}
+
+static int parse_cpus_opt(const struct option *opt __maybe_unused,
+                          const char *arg, int unset __maybe_unused)
+{
+        if (!arg)
+                return -1;
+
+        return parse_cpu_list(arg);
+}
+
+static int parse_node_list(const char *arg)
+{
+        p0.node_list_str = strdup(arg);
+
+        dprintf("got NODE list: {%s}\n", p0.node_list_str);
+
+        return 0;
+}
+
+static void parse_setup_node_list(void)
+{
+        struct thread_data *td;
+        char *str0, *str;
+        int t;
+
+        if (!g->p.node_list_str)
+                return;
+
+        dprintf("g->p.nr_tasks: %d\n", g->p.nr_tasks);
+
+        str0 = str = strdup(g->p.node_list_str);
+        t = 0;
+
+        BUG_ON(!str);
+
+        tprintf("# binding tasks to NODEs:\n");
+        tprintf("# ");
+
+        while (true) {
+                int bind_node, bind_node_0, bind_node_1;
+                char *tok, *tok_end, *tok_step, *tok_mul;
+                int step;
+                int mul;
+
+                tok = strsep(&str, ",");
+                if (!tok)
+                        break;
+
+                tok_end = strstr(tok, "-");
+
+                dprintf("\ntoken: {%s}, end: {%s}\n", tok, tok_end);
+                if (!tok_end) {
+                        /* Single NODE specified: */
+                        bind_node_0 = bind_node_1 = atol(tok);
+                } else {
+                        /* NODE range specified (for example: "5-11"): */
+                        bind_node_0 = atol(tok);
+                        bind_node_1 = atol(tok_end + 1);
+                }
+
+                step = 1;
+                tok_step = strstr(tok, "#");
+                if (tok_step) {
+                        step = atol(tok_step + 1);
+                        BUG_ON(step <= 0 || step >= g->p.nr_nodes);
+                }
+
+                /* Multiplicator shortcut, "0x8" is a shortcut for: "0,0,0,0,0,0,0,0" */
+                mul = 1;
+                tok_mul = strstr(tok, "x");
+                if (tok_mul) {
+                        mul = atol(tok_mul + 1);
+                        BUG_ON(mul <= 0);
+                }
+
+                dprintf("NODEs: %d-%d #%d\n", bind_node_0, bind_node_1, step);
+
+                BUG_ON(bind_node_0 < 0 || bind_node_0 >= g->p.nr_nodes);
+                BUG_ON(bind_node_1 < 0 || bind_node_1 >= g->p.nr_nodes);
+                BUG_ON(bind_node_0 > bind_node_1);
+
+                for (bind_node = bind_node_0; bind_node <= bind_node_1; bind_node += step) {
+                        int i;
+
+                        for (i = 0; i < mul; i++) {
+                                if (t >= g->p.nr_tasks) {
+                                        printf("\n# NOTE: ignoring bind NODEs starting at NODE#%d\n", bind_node);
+                                        goto out;
+                                }
+                                td = g->threads + t;
+
+                                if (!t)
+                                        tprintf(" %2d", bind_node);
+                                else
+                                        tprintf(",%2d", bind_node);
+
+                                td->bind_node = bind_node;
+                                t++;
+                        }
+                }
+        }
+out:
+
+        tprintf("\n");
+
+        if (t < g->p.nr_tasks)
+                printf("# NOTE: %d tasks mem-bound, %d tasks unbound\n", t, g->p.nr_tasks - t);
+
+        free(str0);
+}
+
+static int parse_nodes_opt(const struct option *opt __maybe_unused,
+                          const char *arg, int unset __maybe_unused)
+{
+        if (!arg)
+                return -1;
+
+        return parse_node_list(arg);
+
+        return 0;
+}
+
+#define BIT(x) (1ul << x)
+
+static inline uint32_t lfsr_32(uint32_t lfsr)
+{
+        const uint32_t taps = BIT(1) | BIT(5) | BIT(6) | BIT(31);
+        return (lfsr>>1) ^ ((0x0u - (lfsr & 0x1u)) & taps);
+}
+
+/*
+ * Make sure there's real data dependency to RAM (when read
+ * accesses are enabled), so the compiler, the CPU and the
+ * kernel (KSM, zero page, etc.) cannot optimize away RAM
+ * accesses:
+ */
+static inline u64 access_data(u64 *data __attribute__((unused)), u64 val)
+{
+        if (g->p.data_reads)
+                val += *data;
+        if (g->p.data_writes)
+                *data = val + 1;
+        return val;
+}
+
+/*
+ * The worker process does two types of work, a forwards going
+ * loop and a backwards going loop.
+ *
+ * We do this so that on multiprocessor systems we do not create
+ * a 'train' of processing, with highly synchronized processes,
+ * skewing the whole benchmark.
+ */
+static u64 do_work(u8 *__data, long bytes, int nr, int nr_max, int loop, u64 val)
+{
+        long words = bytes/sizeof(u64);
+        u64 *data = (void *)__data;
+        long chunk_0, chunk_1;
+        u64 *d0, *d, *d1;
+        long off;
+        long i;
+
+        BUG_ON(!data && words);
+        BUG_ON(data && !words);
+
+        if (!data)
+                return val;
+
+        /* Very simple memset() work variant: */
+        if (g->p.data_zero_memset && !g->p.data_rand_walk) {
+                bzero(data, bytes);
+                return val;
+        }
+
+        /* Spread out by PID/TID nr and by loop nr: */
+        chunk_0 = words/nr_max;
+        chunk_1 = words/g->p.nr_loops;
+        off = nr*chunk_0 + loop*chunk_1;
+
+        while (off >= words)
+                off -= words;
+
+        if (g->p.data_rand_walk) {
+                u32 lfsr = nr + loop + val;
+                int j;
+
+                for (i = 0; i < words/1024; i++) {
+                        long start, end;
+
+                        lfsr = lfsr_32(lfsr);
+
+                        start = lfsr % words;
+                        end = min(start + 1024, words-1);
+
+                        if (g->p.data_zero_memset) {
+                                bzero(data + start, (end-start) * sizeof(u64));
+                        } else {
+                                for (j = start; j < end; j++)
+                                        val = access_data(data + j, val);
+                        }
+                }
+        } else if (!g->p.data_backwards || (nr + loop) & 1) {
+
+                d0 = data + off;
+                d  = data + off + 1;
+                d1 = data + words;
+
+                /* Process data forwards: */
+                for (;;) {
+                        if (unlikely(d >= d1))
+                                d = data;
+                        if (unlikely(d == d0))
+                                break;
+
+                        val = access_data(d, val);
+
+                        d++;
+                }
+        } else {
+                /* Process data backwards: */
+
+                d0 = data + off;
+                d  = data + off - 1;
+                d1 = data + words;
+
+                /* Process data forwards: */
+                for (;;) {
+                        if (unlikely(d < data))
+                                d = data + words-1;
+                        if (unlikely(d == d0))
+                                break;
+
+                        val = access_data(d, val);
+
+                        d--;
+                }
+        }
+
+        return val;
+}
+
+static void update_curr_cpu(int task_nr, unsigned long bytes_worked)
+{
+        unsigned int cpu;
+
+        cpu = sched_getcpu();
+
+        g->threads[task_nr].curr_cpu = cpu;
+        prctl(0, bytes_worked);
+}
+
+#define MAX_NR_NODES    64
+
+/*
+ * Count the number of nodes a process's threads
+ * are spread out on.
+ *
+ * A count of 1 means that the process is compressed
+ * to a single node. A count of g->p.nr_nodes means it's
+ * spread out on the whole system.
+ */
+static int count_process_nodes(int process_nr)
+{
+        char node_present[MAX_NR_NODES] = { 0, };
+        int nodes;
+        int n, t;
+
+        for (t = 0; t < g->p.nr_threads; t++) {
+                struct thread_data *td;
+                int task_nr;
+                int node;
+
+                task_nr = process_nr*g->p.nr_threads + t;
+                td = g->threads + task_nr;
+
+                node = numa_node_of_cpu(td->curr_cpu);
+                node_present[node] = 1;
+        }
+
+        nodes = 0;
+
+        for (n = 0; n < MAX_NR_NODES; n++)
+                nodes += node_present[n];
+
+        return nodes;
+}
+
+/*
+ * Count the number of distinct process-threads a node contains.
+ *
+ * A count of 1 means that the node contains only a single
+ * process. If all nodes on the system contain at most one
+ * process then we are well-converged.
+ */
+static int count_node_processes(int node)
+{
+        int processes = 0;
+        int t, p;
+
+        for (p = 0; p < g->p.nr_proc; p++) {
+                for (t = 0; t < g->p.nr_threads; t++) {
+                        struct thread_data *td;
+                        int task_nr;
+                        int n;
+
+                        task_nr = p*g->p.nr_threads + t;
+                        td = g->threads + task_nr;
+
+                        n = numa_node_of_cpu(td->curr_cpu);
+                        if (n == node) {
+                                processes++;
+                                break;
+                        }
+                }
+        }
+
+        return processes;
+}
+
+static void calc_convergence_compression(int *strong)
+{
+        unsigned int nodes_min, nodes_max;
+        int p;
+
+        nodes_min = -1;
+        nodes_max =  0;
+
+        for (p = 0; p < g->p.nr_proc; p++) {
+                unsigned int nodes = count_process_nodes(p);
+
+                nodes_min = min(nodes, nodes_min);
+                nodes_max = max(nodes, nodes_max);
+        }
+
+        /* Strong convergence: all threads compress on a single node: */
+        if (nodes_min == 1 && nodes_max == 1) {
+                *strong = 1;
+        } else {
+                *strong = 0;
+                tprintf(" {%d-%d}", nodes_min, nodes_max);
+        }
+}
+
+static void calc_convergence(double runtime_ns_max, double *convergence)
+{
+        unsigned int loops_done_min, loops_done_max;
+        int process_groups;
+        int nodes[MAX_NR_NODES];
+        int distance;
+        int nr_min;
+        int nr_max;
+        int strong;
+        int sum;
+        int nr;
+        int node;
+        int cpu;
+        int t;
+
+        if (!g->p.show_convergence && !g->p.measure_convergence)
+                return;
+
+        for (node = 0; node < g->p.nr_nodes; node++)
+                nodes[node] = 0;
+
+        loops_done_min = -1;
+        loops_done_max = 0;
+
+        for (t = 0; t < g->p.nr_tasks; t++) {
+                struct thread_data *td = g->threads + t;
+                unsigned int loops_done;
+
+                cpu = td->curr_cpu;
+
+                /* Not all threads have written it yet: */
+                if (cpu < 0)
+                        continue;
+
+                node = numa_node_of_cpu(cpu);
+
+                nodes[node]++;
+
+                loops_done = td->loops_done;
+                loops_done_min = min(loops_done, loops_done_min);
+                loops_done_max = max(loops_done, loops_done_max);
+        }
+
+        nr_max = 0;
+        nr_min = g->p.nr_tasks;
+        sum = 0;
+
+        for (node = 0; node < g->p.nr_nodes; node++) {
+                nr = nodes[node];
+                nr_min = min(nr, nr_min);
+                nr_max = max(nr, nr_max);
+                sum += nr;
+        }
+        BUG_ON(nr_min > nr_max);
+
+        BUG_ON(sum > g->p.nr_tasks);
+
+        if (0 && (sum < g->p.nr_tasks))
+                return;
+
+        /*
+         * Count the number of distinct process groups present
+         * on nodes - when we are converged this will decrease
+         * to g->p.nr_proc:
+         */
+        process_groups = 0;
+
+        for (node = 0; node < g->p.nr_nodes; node++) {
+                int processes = count_node_processes(node);
+
+                nr = nodes[node];
+                tprintf(" %2d/%-2d", nr, processes);
+
+                process_groups += processes;
+        }
+
+        distance = nr_max - nr_min;
+
+        tprintf(" [%2d/%-2d]", distance, process_groups);
+
+        tprintf(" l:%3d-%-3d (%3d)",
+                loops_done_min, loops_done_max, loops_done_max-loops_done_min);
+
+        if (loops_done_min && loops_done_max) {
+                double skew = 1.0 - (double)loops_done_min/loops_done_max;
+
+                tprintf(" [%4.1f%%]", skew * 100.0);
+        }
+
+        calc_convergence_compression(&strong);
+
+        if (strong && process_groups == g->p.nr_proc) {
+                if (!*convergence) {
+                        *convergence = runtime_ns_max;
+                        tprintf(" (%6.1fs converged)\n", *convergence/1e9);
+                        if (g->p.measure_convergence) {
+                                g->all_converged = true;
+                                g->stop_work = true;
+                        }
+                }
+        } else {
+                if (*convergence) {
+                        tprintf(" (%6.1fs de-converged)", runtime_ns_max/1e9);
+                        *convergence = 0;
+                }
+                tprintf("\n");
+        }
+}
+
+static void show_summary(double runtime_ns_max, int l, double *convergence)
+{
+        tprintf("\r #  %5.1f%%  [%.1f mins]",
+                (double)(l+1)/g->p.nr_loops*100.0, runtime_ns_max/1e9 / 60.0);
+
+        calc_convergence(runtime_ns_max, convergence);
+
+        if (g->p.show_details >= 0)
+                fflush(stdout);
+}
+
+static void *worker_thread(void *__tdata)
+{
+        struct thread_data *td = __tdata;
+        struct timeval start0, start, stop, diff;
+        int process_nr = td->process_nr;
+        int thread_nr = td->thread_nr;
+        unsigned long last_perturbance;
+        int task_nr = td->task_nr;
+        int details = g->p.show_details;
+        int first_task, last_task;
+        double convergence = 0;
+        u64 val = td->val;
+        double runtime_ns_max;
+        u8 *global_data;
+        u8 *process_data;
+        u8 *thread_data;
+        u64 bytes_done;
+        long work_done;
+        u32 l;
+
+        bind_to_cpumask(td->bind_cpumask);
+        bind_to_memnode(td->bind_node);
+
+        set_taskname("thread %d/%d", process_nr, thread_nr);
+
+        global_data = g->data;
+        process_data = td->process_data;
+        thread_data = setup_private_data(g->p.bytes_thread);
+
+        bytes_done = 0;
+
+        last_task = 0;
+        if (process_nr == g->p.nr_proc-1 && thread_nr == g->p.nr_threads-1)
+                last_task = 1;
+
+        first_task = 0;
+        if (process_nr == 0 && thread_nr == 0)
+                first_task = 1;
+
+        if (details >= 2) {
+                printf("#  thread %2d / %2d global mem: %p, process mem: %p, thread mem: %p\n",
+                        process_nr, thread_nr, global_data, process_data, thread_data);
+        }
+
+        if (g->p.serialize_startup) {
+                pthread_mutex_lock(&g->startup_mutex);
+                g->nr_tasks_started++;
+                pthread_mutex_unlock(&g->startup_mutex);
+
+                /* Here we will wait for the main process to start us all at once: */
+                pthread_mutex_lock(&g->start_work_mutex);
+                g->nr_tasks_working++;
+
+                /* Last one wake the main process: */
+                if (g->nr_tasks_working == g->p.nr_tasks)
+                        pthread_mutex_unlock(&g->startup_done_mutex);
+
+                pthread_mutex_unlock(&g->start_work_mutex);
+        }
+
+        gettimeofday(&start0, NULL);
+
+        start = stop = start0;
+        last_perturbance = start.tv_sec;
+
+        for (l = 0; l < g->p.nr_loops; l++) {
+                start = stop;
+
+                if (g->stop_work)
+                        break;
+
+                val += do_work(global_data,  g->p.bytes_global,  process_nr, g->p.nr_proc,      l, val);
+                val += do_work(process_data, g->p.bytes_process, thread_nr,  g->p.nr_threads,   l, val);
+                val += do_work(thread_data,  g->p.bytes_thread,  0,          1,         l, val);
+
+                if (g->p.sleep_usecs) {
+                        pthread_mutex_lock(td->process_lock);
+                        usleep(g->p.sleep_usecs);
+                        pthread_mutex_unlock(td->process_lock);
+                }
+                /*
+                 * Amount of work to be done under a process-global lock:
+                 */
+                if (g->p.bytes_process_locked) {
+                        pthread_mutex_lock(td->process_lock);
+                        val += do_work(process_data, g->p.bytes_process_locked, thread_nr,  g->p.nr_threads,    l, val);
+                        pthread_mutex_unlock(td->process_lock);
+                }
+
+                work_done = g->p.bytes_global + g->p.bytes_process +
+                            g->p.bytes_process_locked + g->p.bytes_thread;
+
+                update_curr_cpu(task_nr, work_done);
+                bytes_done += work_done;
+
+                if (details < 0 && !g->p.perturb_secs && !g->p.measure_convergence && !g->p.nr_secs)
+                        continue;
+
+                td->loops_done = l;
+
+                gettimeofday(&stop, NULL);
+
+                /* Check whether our max runtime timed out: */
+                if (g->p.nr_secs) {
+                        timersub(&stop, &start0, &diff);
+                        if (diff.tv_sec >= g->p.nr_secs) {
+                                g->stop_work = true;
+                                break;
+                        }
+                }
+
+                /* Update the summary at most once per second: */
+                if (start.tv_sec == stop.tv_sec)
+                        continue;
+
+                /*
+                 * Perturb the first task's equilibrium every g->p.perturb_secs seconds,
+                 * by migrating to CPU#0:
+                 */
+                if (first_task && g->p.perturb_secs && (int)(stop.tv_sec - last_perturbance) >= g->p.perturb_secs) {
+                        cpu_set_t orig_mask;
+                        int target_cpu;
+                        int this_cpu;
+
+                        last_perturbance = stop.tv_sec;
+
+                        /*
+                         * Depending on where we are running, move into
+                         * the other half of the system, to create some
+                         * real disturbance:
+                         */
+                        this_cpu = g->threads[task_nr].curr_cpu;
+                        if (this_cpu < g->p.nr_cpus/2)
+                                target_cpu = g->p.nr_cpus-1;
+                        else
+                                target_cpu = 0;
+
+                        orig_mask = bind_to_cpu(target_cpu);
+
+                        /* Here we are running on the target CPU already */
+                        if (details >= 1)
+                                printf(" (injecting perturbalance, moved to CPU#%d)\n", target_cpu);
+
+                        bind_to_cpumask(orig_mask);
+                }
+
+                if (details >= 3) {
+                        timersub(&stop, &start, &diff);
+                        runtime_ns_max = diff.tv_sec * 1000000000;
+                        runtime_ns_max += diff.tv_usec * 1000;
+
+                        if (details >= 0) {
+                                printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016lx]\n",
+                                        process_nr, thread_nr, runtime_ns_max / bytes_done, val);
+                        }
+                        fflush(stdout);
+                }
+                if (!last_task)
+                        continue;
+
+                timersub(&stop, &start0, &diff);
+                runtime_ns_max = diff.tv_sec * 1000000000ULL;
+                runtime_ns_max += diff.tv_usec * 1000ULL;
+
+                show_summary(runtime_ns_max, l, &convergence);
+        }
+
+        gettimeofday(&stop, NULL);
+        timersub(&stop, &start0, &diff);
+        td->runtime_ns = diff.tv_sec * 1000000000ULL;
+        td->runtime_ns += diff.tv_usec * 1000ULL;
+
+        free_data(thread_data, g->p.bytes_thread);
+
+        pthread_mutex_lock(&g->stop_work_mutex);
+        g->bytes_done += bytes_done;
+        pthread_mutex_unlock(&g->stop_work_mutex);
+
+        return NULL;
+}
+
+/*
+ * A worker process starts a couple of threads:
+ */
+static void worker_process(int process_nr)
+{
+        pthread_mutex_t process_lock;
+        struct thread_data *td;
+        pthread_t *pthreads;
+        u8 *process_data;
+        int task_nr;
+        int ret;
+        int t;
+
+        pthread_mutex_init(&process_lock, NULL);
+        set_taskname("process %d", process_nr);
+
+        /*
+         * Pick up the memory policy and the CPU binding of our first thread,
+         * so that we initialize memory accordingly:
+         */
+        task_nr = process_nr*g->p.nr_threads;
+        td = g->threads + task_nr;
+
+        bind_to_memnode(td->bind_node);
+        bind_to_cpumask(td->bind_cpumask);
+
+        pthreads = zalloc(g->p.nr_threads * sizeof(pthread_t));
+        process_data = setup_private_data(g->p.bytes_process);
+
+        if (g->p.show_details >= 3) {
+                printf(" # process %2d global mem: %p, process mem: %p\n",
+                        process_nr, g->data, process_data);
+        }
+
+        for (t = 0; t < g->p.nr_threads; t++) {
+                task_nr = process_nr*g->p.nr_threads + t;
+                td = g->threads + task_nr;
+
+                td->process_data = process_data;
+                td->process_nr   = process_nr;
+                td->thread_nr    = t;
+                td->task_nr      = task_nr;
+                td->val          = rand();
+                td->curr_cpu     = -1;
+                td->process_lock = &process_lock;
+
+                ret = pthread_create(pthreads + t, NULL, worker_thread, td);
+                BUG_ON(ret);
+        }
+
+        for (t = 0; t < g->p.nr_threads; t++) {
+                ret = pthread_join(pthreads[t], NULL);
+                BUG_ON(ret);
+        }
+
+        free_data(process_data, g->p.bytes_process);
+        free(pthreads);
+}
+
+static void print_summary(void)
+{
+        if (g->p.show_details < 0)
+                return;
+
+        printf("\n ###\n");
+        printf(" # %d %s will execute (on %d nodes, %d CPUs):\n",
+                g->p.nr_tasks, g->p.nr_tasks == 1 ? "task" : "tasks", g->p.nr_nodes, g->p.nr_cpus);
+        printf(" #      %5dx %5ldMB global  shared mem operations\n",
+                        g->p.nr_loops, g->p.bytes_global/1024/1024);
+        printf(" #      %5dx %5ldMB process shared mem operations\n",
+                        g->p.nr_loops, g->p.bytes_process/1024/1024);
+        printf(" #      %5dx %5ldMB thread  local  mem operations\n",
+                        g->p.nr_loops, g->p.bytes_thread/1024/1024);
+
+        printf(" ###\n");
+
+        printf("\n ###\n"); fflush(stdout);
+}
+
+static void init_thread_data(void)
+{
+        ssize_t size = sizeof(*g->threads)*g->p.nr_tasks;
+        int t;
+
+        g->threads = zalloc_shared_data(size);
+
+        for (t = 0; t < g->p.nr_tasks; t++) {
+                struct thread_data *td = g->threads + t;
+                int cpu;
+
+                /* Allow all nodes by default: */
+                td->bind_node = -1;
+
+                /* Allow all CPUs by default: */
+                CPU_ZERO(&td->bind_cpumask);
+                for (cpu = 0; cpu < g->p.nr_cpus; cpu++)
+                        CPU_SET(cpu, &td->bind_cpumask);
+        }
+}
+
+static void deinit_thread_data(void)
+{
+        ssize_t size = sizeof(*g->threads)*g->p.nr_tasks;
+
+        free_data(g->threads, size);
+}
+
+static int init(void)
+{
+        g = (void *)alloc_data(sizeof(*g), MAP_SHARED, 1, 0, 0 /* THP */, 0);
+
+        /* Copy over options: */
+        g->p = p0;
+
+        g->p.nr_cpus = numa_num_configured_cpus();
+
+        g->p.nr_nodes = numa_max_node() + 1;
+
+        /* char array in count_process_nodes(): */
+        BUG_ON(g->p.nr_nodes > MAX_NR_NODES || g->p.nr_nodes < 0);
+
+        if (g->p.show_quiet && !g->p.show_details)
+                g->p.show_details = -1;
+
+        /* Some memory should be specified: */
+        if (!g->p.mb_global_str && !g->p.mb_proc_str && !g->p.mb_thread_str)
+                return -1;
+
+        if (g->p.mb_global_str) {
+                g->p.mb_global = atof(g->p.mb_global_str);
+                BUG_ON(g->p.mb_global < 0);
+        }
+
+        if (g->p.mb_proc_str) {
+                g->p.mb_proc = atof(g->p.mb_proc_str);
+                BUG_ON(g->p.mb_proc < 0);
+        }
+
+        if (g->p.mb_proc_locked_str) {
+                g->p.mb_proc_locked = atof(g->p.mb_proc_locked_str);
+                BUG_ON(g->p.mb_proc_locked < 0);
+                BUG_ON(g->p.mb_proc_locked > g->p.mb_proc);
+        }
+
+        if (g->p.mb_thread_str) {
+                g->p.mb_thread = atof(g->p.mb_thread_str);
+                BUG_ON(g->p.mb_thread < 0);
+        }
+
+        BUG_ON(g->p.nr_threads <= 0);
+        BUG_ON(g->p.nr_proc <= 0);
+
+        g->p.nr_tasks = g->p.nr_proc*g->p.nr_threads;
+
+        g->p.bytes_global               = g->p.mb_global        *1024L*1024L;
+        g->p.bytes_process              = g->p.mb_proc          *1024L*1024L;
+        g->p.bytes_process_locked       = g->p.mb_proc_locked   *1024L*1024L;
+        g->p.bytes_thread               = g->p.mb_thread        *1024L*1024L;
+
+        g->data = setup_shared_data(g->p.bytes_global);
+
+        /* Startup serialization: */
+        init_global_mutex(&g->start_work_mutex);
+        init_global_mutex(&g->startup_mutex);
+        init_global_mutex(&g->startup_done_mutex);
+        init_global_mutex(&g->stop_work_mutex);
+
+        init_thread_data();
+
+        tprintf("#\n");
+        parse_setup_cpu_list();
+        parse_setup_node_list();
+        tprintf("#\n");
+
+        print_summary();
+
+        return 0;
+}
+
+static void deinit(void)
+{
+        free_data(g->data, g->p.bytes_global);
+        g->data = NULL;
+
+        deinit_thread_data();
+
+        free_data(g, sizeof(*g));
+        g = NULL;
+}
+
+/*
+ * Print a short or long result, depending on the verbosity setting:
+ */
+static void print_res(const char *name, double val,
+                      const char *txt_unit, const char *txt_short, const char *txt_long)
+{
+        if (!name)
+                name = "main,";
+
+        if (g->p.show_quiet)
+                printf(" %-30s %15.3f, %-15s %s\n", name, val, txt_unit, txt_short);
+        else
+                printf(" %14.3f %s\n", val, txt_long);
+}
+
+static int __bench_numa(const char *name)
+{
+        struct timeval start, stop, diff;
+        u64 runtime_ns_min, runtime_ns_sum;
+        pid_t *pids, pid, wpid;
+        double delta_runtime;
+        double runtime_avg;
+        double runtime_sec_max;
+        double runtime_sec_min;
+        int wait_stat;
+        double bytes;
+        int i, t;
+
+        if (init())
+                return -1;
+
+        pids = zalloc(g->p.nr_proc * sizeof(*pids));
+        pid = -1;
+
+        /* All threads try to acquire it, this way we can wait for them to start up: */
+        pthread_mutex_lock(&g->start_work_mutex);
+
+        if (g->p.serialize_startup) {
+                tprintf(" #\n");
+                tprintf(" # Startup synchronization: ..."); fflush(stdout);
+        }
+
+        gettimeofday(&start, NULL);
+
+        for (i = 0; i < g->p.nr_proc; i++) {
+                pid = fork();
+                dprintf(" # process %2d: PID %d\n", i, pid);
+
+                BUG_ON(pid < 0);
+                if (!pid) {
+                        /* Child process: */
+                        worker_process(i);
+
+                        exit(0);
+                }
+                pids[i] = pid;
+
+        }
+        /* Wait for all the threads to start up: */
+        while (g->nr_tasks_started != g->p.nr_tasks)
+                usleep(1000);
+
+        BUG_ON(g->nr_tasks_started != g->p.nr_tasks);
+
+        if (g->p.serialize_startup) {
+                double startup_sec;
+
+                pthread_mutex_lock(&g->startup_done_mutex);
+
+                /* This will start all threads: */
+                pthread_mutex_unlock(&g->start_work_mutex);
+
+                /* This mutex is locked - the last started thread will wake us: */
+                pthread_mutex_lock(&g->startup_done_mutex);
+
+                gettimeofday(&stop, NULL);
+
+                timersub(&stop, &start, &diff);
+
+                startup_sec = diff.tv_sec * 1000000000.0;
+                startup_sec += diff.tv_usec * 1000.0;
+                startup_sec /= 1e9;
+
+                tprintf(" threads initialized in %.6f seconds.\n", startup_sec);
+                tprintf(" #\n");
+
+                start = stop;
+                pthread_mutex_unlock(&g->startup_done_mutex);
+        } else {
+                gettimeofday(&start, NULL);
+        }
+
+        /* Parent process: */
+
+
+        for (i = 0; i < g->p.nr_proc; i++) {
+                wpid = waitpid(pids[i], &wait_stat, 0);
+                BUG_ON(wpid < 0);
+                BUG_ON(!WIFEXITED(wait_stat));
+
+        }
+
+        runtime_ns_sum = 0;
+        runtime_ns_min = -1LL;
+
+        for (t = 0; t < g->p.nr_tasks; t++) {
+                u64 thread_runtime_ns = g->threads[t].runtime_ns;
+
+                runtime_ns_sum += thread_runtime_ns;
+                runtime_ns_min = min(thread_runtime_ns, runtime_ns_min);
+        }
+
+        gettimeofday(&stop, NULL);
+        timersub(&stop, &start, &diff);
+
+        BUG_ON(bench_format != BENCH_FORMAT_DEFAULT);
+
+        tprintf("\n ###\n");
+        tprintf("\n");
+
+        runtime_sec_max = diff.tv_sec * 1000000000.0;
+        runtime_sec_max += diff.tv_usec * 1000.0;
+        runtime_sec_max /= 1e9;
+
+        runtime_sec_min = runtime_ns_min/1e9;
+
+        bytes = g->bytes_done;
+        runtime_avg = (double)runtime_ns_sum / g->p.nr_tasks / 1e9;
+
+        if (g->p.measure_convergence) {
+                print_res(name, runtime_sec_max,
+                        "secs,", "NUMA-convergence-latency", "secs latency to NUMA-converge");
+        }
+
+        print_res(name, runtime_sec_max,
+                "secs,", "runtime-max/thread",  "secs slowest (max) thread-runtime");
+
+        print_res(name, runtime_sec_min,
+                "secs,", "runtime-min/thread",  "secs fastest (min) thread-runtime");
+
+        print_res(name, runtime_avg,
+                "secs,", "runtime-avg/thread",  "secs average thread-runtime");
+
+        delta_runtime = (runtime_sec_max - runtime_sec_min)/2.0;
+        print_res(name, delta_runtime / runtime_sec_max * 100.0,
+                "%,", "spread-runtime/thread",  "% difference between max/avg runtime");
+
+        print_res(name, bytes / g->p.nr_tasks / 1e9,
+                "GB,", "data/thread",           "GB data processed, per thread");
+
+        print_res(name, bytes / 1e9,
+                "GB,", "data-total",            "GB data processed, total");
+
+        print_res(name, runtime_sec_max * 1e9 / (bytes / g->p.nr_tasks),
+                "nsecs,", "runtime/byte/thread","nsecs/byte/thread runtime");
+
+        print_res(name, bytes / g->p.nr_tasks / 1e9 / runtime_sec_max,
+                "GB/sec,", "thread-speed",      "GB/sec/thread speed");
+
+        print_res(name, bytes / runtime_sec_max / 1e9,
+                "GB/sec,", "total-speed",       "GB/sec total speed");
+
+        free(pids);
+
+        deinit();
+
+        return 0;
+}
+
+#define MAX_ARGS 50
+
+static int command_size(const char **argv)
+{
+        int size = 0;
+
+        while (*argv) {
+                size++;
+                argv++;
+        }
+
+        BUG_ON(size >= MAX_ARGS);
+
+        return size;
+}
+
+static void init_params(struct params *p, const char *name, int argc, const char **argv)
+{
+        int i;
+
+        printf("\n # Running %s \"perf bench numa", name);
+
+        for (i = 0; i < argc; i++)
+                printf(" %s", argv[i]);
+
+        printf("\"\n");
+
+        memset(p, 0, sizeof(*p));
+
+        /* Initialize nonzero defaults: */
+
+        p->serialize_startup            = 1;
+        p->data_reads                   = true;
+        p->data_writes                  = true;
+        p->data_backwards               = true;
+        p->data_rand_walk               = true;
+        p->nr_loops                     = -1;
+        p->init_random                  = true;
+}
+
+static int run_bench_numa(const char *name, const char **argv)
+{
+        int argc = command_size(argv);
+
+        init_params(&p0, name, argc, argv);
+        argc = parse_options(argc, argv, options, bench_numa_usage, 0);
+        if (argc)
+                goto err;
+
+        if (__bench_numa(name))
+                goto err;
+
+        return 0;
+
+err:
+        usage_with_options(numa_usage, options);
+        return -1;
+}
+
+#define OPT_BW_RAM              "-s",  "20", "-zZq",    "--thp", " 1", "--no-data_rand_walk"
+#define OPT_BW_RAM_NOTHP        OPT_BW_RAM,             "--thp", "-1"
+
+#define OPT_CONV                "-s", "100", "-zZ0qcm", "--thp", " 1"
+#define OPT_CONV_NOTHP          OPT_CONV,               "--thp", "-1"
+
+#define OPT_BW                  "-s",  "20", "-zZ0q",   "--thp", " 1"
+#define OPT_BW_NOTHP            OPT_BW,                 "--thp", "-1"
+
+/*
+ * The built-in test-suite executed by "perf bench numa -a".
+ *
+ * (A minimum of 4 nodes and 16 GB of RAM is recommended.)
+ */
+static const char *tests[][MAX_ARGS] = {
+   /* Basic single-stream NUMA bandwidth measurements: */
+   { "RAM-bw-local,",     "mem",  "-p",  "1",  "-t",  "1", "-P", "1024",
+                          "-C" ,   "0", "-M",   "0", OPT_BW_RAM },
+   { "RAM-bw-local-NOTHP,",
+                          "mem",  "-p",  "1",  "-t",  "1", "-P", "1024",
+                          "-C" ,   "0", "-M",   "0", OPT_BW_RAM_NOTHP },
+   { "RAM-bw-remote,",    "mem",  "-p",  "1",  "-t",  "1", "-P", "1024",
+                          "-C" ,   "0", "-M",   "1", OPT_BW_RAM },
+
+   /* 2-stream NUMA bandwidth measurements: */
+   { "RAM-bw-local-2x,",  "mem",  "-p",  "2",  "-t",  "1", "-P", "1024",
+                           "-C", "0,2", "-M", "0x2", OPT_BW_RAM },
+   { "RAM-bw-remote-2x,", "mem",  "-p",  "2",  "-t",  "1", "-P", "1024",
+                           "-C", "0,2", "-M", "1x2", OPT_BW_RAM },
+
+   /* Cross-stream NUMA bandwidth measurement: */
+   { "RAM-bw-cross,",     "mem",  "-p",  "2",  "-t",  "1", "-P", "1024",
+                           "-C", "0,8", "-M", "1,0", OPT_BW_RAM },
+
+   /* Convergence latency measurements: */
+   { " 1x3-convergence,", "mem",  "-p",  "1", "-t",  "3", "-P",  "512", OPT_CONV },
+   { " 1x4-convergence,", "mem",  "-p",  "1", "-t",  "4", "-P",  "512", OPT_CONV },
+   { " 1x6-convergence,", "mem",  "-p",  "1", "-t",  "6", "-P", "1020", OPT_CONV },
+   { " 2x3-convergence,", "mem",  "-p",  "3", "-t",  "3", "-P", "1020", OPT_CONV },
+   { " 3x3-convergence,", "mem",  "-p",  "3", "-t",  "3", "-P", "1020", OPT_CONV },
+   { " 4x4-convergence,", "mem",  "-p",  "4", "-t",  "4", "-P",  "512", OPT_CONV },
+   { " 4x4-convergence-NOTHP,",
+                          "mem",  "-p",  "4", "-t",  "4", "-P",  "512", OPT_CONV_NOTHP },
+   { " 4x6-convergence,", "mem",  "-p",  "4", "-t",  "6", "-P", "1020", OPT_CONV },
+   { " 4x8-convergence,", "mem",  "-p",  "4", "-t",  "8", "-P",  "512", OPT_CONV },
+   { " 8x4-convergence,", "mem",  "-p",  "8", "-t",  "4", "-P",  "512", OPT_CONV },
+   { " 8x4-convergence-NOTHP,",
+                          "mem",  "-p",  "8", "-t",  "4", "-P",  "512", OPT_CONV_NOTHP },
+   { " 3x1-convergence,", "mem",  "-p",  "3", "-t",  "1", "-P",  "512", OPT_CONV },
+   { " 4x1-convergence,", "mem",  "-p",  "4", "-t",  "1", "-P",  "512", OPT_CONV },
+   { " 8x1-convergence,", "mem",  "-p",  "8", "-t",  "1", "-P",  "512", OPT_CONV },
+   { "16x1-convergence,", "mem",  "-p", "16", "-t",  "1", "-P",  "256", OPT_CONV },
+   { "32x1-convergence,", "mem",  "-p", "32", "-t",  "1", "-P",  "128", OPT_CONV },
+
+   /* Various NUMA process/thread layout bandwidth measurements: */
+   { " 2x1-bw-process,",  "mem",  "-p",  "2", "-t",  "1", "-P", "1024", OPT_BW },
+   { " 3x1-bw-process,",  "mem",  "-p",  "3", "-t",  "1", "-P", "1024", OPT_BW },
+   { " 4x1-bw-process,",  "mem",  "-p",  "4", "-t",  "1", "-P", "1024", OPT_BW },
+   { " 8x1-bw-process,",  "mem",  "-p",  "8", "-t",  "1", "-P", " 512", OPT_BW },
+   { " 8x1-bw-process-NOTHP,",
+                          "mem",  "-p",  "8", "-t",  "1", "-P", " 512", OPT_BW_NOTHP },
+   { "16x1-bw-process,",  "mem",  "-p", "16", "-t",  "1", "-P",  "256", OPT_BW },
+
+   { " 4x1-bw-thread,",   "mem",  "-p",  "1", "-t",  "4", "-T",  "256", OPT_BW },
+   { " 8x1-bw-thread,",   "mem",  "-p",  "1", "-t",  "8", "-T",  "256", OPT_BW },
+   { "16x1-bw-thread,",   "mem",  "-p",  "1", "-t", "16", "-T",  "128", OPT_BW },
+   { "32x1-bw-thread,",   "mem",  "-p",  "1", "-t", "32", "-T",   "64", OPT_BW },
+
+   { " 2x3-bw-thread,",   "mem",  "-p",  "2", "-t",  "3", "-P",  "512", OPT_BW },
+   { " 4x4-bw-thread,",   "mem",  "-p",  "4", "-t",  "4", "-P",  "512", OPT_BW },
+   { " 4x6-bw-thread,",   "mem",  "-p",  "4", "-t",  "6", "-P",  "512", OPT_BW },
+   { " 4x8-bw-thread,",   "mem",  "-p",  "4", "-t",  "8", "-P",  "512", OPT_BW },
+   { " 4x8-bw-thread-NOTHP,",
+                          "mem",  "-p",  "4", "-t",  "8", "-P",  "512", OPT_BW_NOTHP },
+   { " 3x3-bw-thread,",   "mem",  "-p",  "3", "-t",  "3", "-P",  "512", OPT_BW },
+   { " 5x5-bw-thread,",   "mem",  "-p",  "5", "-t",  "5", "-P",  "512", OPT_BW },
+
+   { "2x16-bw-thread,",   "mem",  "-p",  "2", "-t", "16", "-P",  "512", OPT_BW },
+   { "1x32-bw-thread,",   "mem",  "-p",  "1", "-t", "32", "-P", "2048", OPT_BW },
+
+   { "numa02-bw,",        "mem",  "-p",  "1", "-t", "32", "-T",   "32", OPT_BW },
+   { "numa02-bw-NOTHP,",  "mem",  "-p",  "1", "-t", "32", "-T",   "32", OPT_BW_NOTHP },
+   { "numa01-bw-thread,", "mem",  "-p",  "2", "-t", "16", "-T",  "192", OPT_BW },
+   { "numa01-bw-thread-NOTHP,",
+                          "mem",  "-p",  "2", "-t", "16", "-T",  "192", OPT_BW_NOTHP },
+};
+
+static int bench_all(void)
+{
+        int nr = ARRAY_SIZE(tests);
+        int ret;
+        int i;
+
+        ret = system("echo ' #'; echo ' # Running test on: '$(uname -a); echo ' #'");
+        BUG_ON(ret < 0);
+
+        for (i = 0; i < nr; i++) {
+                if (run_bench_numa(tests[i][0], tests[i] + 1))
+                        return -1;
+        }
+
+        printf("\n");
+
+        return 0;
+}
+
+int bench_numa(int argc, const char **argv, const char *prefix __maybe_unused)
+{
+        init_params(&p0, "main,", argc, argv);
+        argc = parse_options(argc, argv, options, bench_numa_usage, 0);
+        if (argc)
+                goto err;
+
+        if (p0.run_all)
+                return bench_all();
+
+        if (__bench_numa(NULL))
+                goto err;
+
+        return 0;
+
+err:
+        usage_with_options(numa_usage, options);
+        return -1;
+}
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index dc870cf31b79..db491e9a812b 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -34,9 +34,10 @@
 
 struct perf_annotate {
         struct perf_tool tool;
-        bool       force, use_tui, use_stdio;
+        bool       force, use_tui, use_stdio, use_gtk;
         bool       full_paths;
         bool       print_line;
+        bool       skip_missing;
         const char *sym_hist_filter;
         const char *cpu_list;
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
@@ -62,7 +63,7 @@ static int perf_evsel__add_sample(struct perf_evsel *evsel,
                 return 0;
         }
 
-        he = __hists__add_entry(&evsel->hists, al, NULL, 1);
+        he = __hists__add_entry(&evsel->hists, al, NULL, 1, 1);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -108,14 +109,16 @@ static int process_sample_event(struct perf_tool *tool,
         return 0;
 }
 
-static int hist_entry__tty_annotate(struct hist_entry *he, int evidx,
+static int hist_entry__tty_annotate(struct hist_entry *he,
+                                    struct perf_evsel *evsel,
                                     struct perf_annotate *ann)
 {
-        return symbol__tty_annotate(he->ms.sym, he->ms.map, evidx,
+        return symbol__tty_annotate(he->ms.sym, he->ms.map, evsel,
                                     ann->print_line, ann->full_paths, 0, 0);
 }
 
-static void hists__find_annotations(struct hists *self, int evidx,
+static void hists__find_annotations(struct hists *self,
+                                    struct perf_evsel *evsel,
                                     struct perf_annotate *ann)
 {
         struct rb_node *nd = rb_first(&self->entries), *next;
@@ -138,9 +141,22 @@ find_next:
                         continue;
                 }
 
-                if (use_browser > 0) {
-                        key = hist_entry__tui_annotate(he, evidx, NULL);
+                if (use_browser == 2) {
+                        int ret;
+
+                        ret = hist_entry__gtk_annotate(he, evsel, NULL);
+                        if (!ret || !ann->skip_missing)
+                                return;
+
+                        /* skip missing symbols */
+                        nd = rb_next(nd);
+                } else if (use_browser == 1) {
+                        key = hist_entry__tui_annotate(he, evsel, NULL);
                         switch (key) {
+                        case -1:
+                                if (!ann->skip_missing)
+                                        return;
+                                /* fall through */
                         case K_RIGHT:
                                 next = rb_next(nd);
                                 break;
@@ -154,7 +170,7 @@ find_next:
                         if (next != NULL)
                                 nd = next;
                 } else {
-                        hist_entry__tty_annotate(he, evidx, ann);
+                        hist_entry__tty_annotate(he, evsel, ann);
                         nd = rb_next(nd);
                         /*
                          * Since we have a hist_entry per IP for the same
@@ -216,7 +232,12 @@ static int __cmd_annotate(struct perf_annotate *ann)
                         total_nr_samples += nr_samples;
                         hists__collapse_resort(hists);
                         hists__output_resort(hists);
-                        hists__find_annotations(hists, pos->idx, ann);
+
+                        if (symbol_conf.event_group &&
+                            !perf_evsel__is_group_leader(pos))
+                                continue;
+
+                        hists__find_annotations(hists, pos, ann);
                 }
         }
 
@@ -224,6 +245,10 @@ static int __cmd_annotate(struct perf_annotate *ann)
                 ui__error("The %s file has no samples!\n", session->filename);
                 goto out_delete;
         }
+
+        if (use_browser == 2)
+                perf_gtk__show_annotations();
+
 out_delete:
         /*
          * Speed up the exit process, for large files this can
@@ -270,6 +295,7 @@ int cmd_annotate(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(0, "gtk", &annotate.use_gtk, "Use the GTK interface"),
         OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"),
         OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"),
         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
@@ -280,6 +306,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                     "print matching source lines (may be slow)"),
         OPT_BOOLEAN('P', "full-paths", &annotate.full_paths,
                     "Don't shorten the displayed pathnames"),
+        OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing,
+                    "Skip symbols that cannot be annotated"),
         OPT_STRING('C', "cpu", &annotate.cpu_list, "cpu", "list of cpus to profile"),
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                    "Look for files with symbols relative to this directory"),
@@ -291,6 +319,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
         OPT_STRING(0, "objdump", &objdump_path, "path",
                    "objdump binary to use for disassembly and annotations"),
+        OPT_BOOLEAN(0, "group", &symbol_conf.event_group,
+                    "Show event group information together"),
         OPT_END()
         };
 
@@ -300,6 +330,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                 use_browser = 0;
         else if (annotate.use_tui)
                 use_browser = 1;
+        else if (annotate.use_gtk)
+                use_browser = 2;
 
         setup_browser(true);
 
@@ -309,7 +341,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
         if (symbol__init() < 0)
                 return -1;
 
-        setup_sorting(annotate_usage, options);
+        if (setup_sorting() < 0)
+                usage_with_options(annotate_usage, options);
 
         if (argc) {
                 /*
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index cae9a5fd2ecf..77298bf892b8 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -35,6 +35,18 @@ struct bench_suite {
 /* sentinel: easy for help */
 #define suite_all { "all", "Test all benchmark suites", NULL }
 
+#ifdef LIBNUMA_SUPPORT
+static struct bench_suite numa_suites[] = {
+        { "mem",
+          "Benchmark for NUMA workloads",
+          bench_numa },
+        suite_all,
+        { NULL,
+          NULL,
+          NULL                  }
+};
+#endif
+
 static struct bench_suite sched_suites[] = {
         { "messaging",
           "Benchmark for scheduler and IPC mechanisms",
@@ -68,6 +80,11 @@ struct bench_subsys {
 };
 
 static struct bench_subsys subsystems[] = {
+#ifdef LIBNUMA_SUPPORT
+        { "numa",
+          "NUMA scheduling and MM behavior",
+          numa_suites },
+#endif
         { "sched",
           "scheduler and IPC mechanism",
           sched_suites },
@@ -159,6 +176,7 @@ static void all_suite(struct bench_subsys *subsys)	  /* FROM HERE */
                 printf("# Running %s/%s benchmark...\n",
                        subsys->name,
                        suites[i].name);
+                fflush(stdout);
 
                 argv[1] = suites[i].name;
                 suites[i].fn(1, argv, NULL);
@@ -225,6 +243,7 @@ int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused)
                                 printf("# Running %s/%s benchmark...\n",
                                        subsystems[i].name,
                                        subsystems[i].suites[j].name);
+                        fflush(stdout);
                         status = subsystems[i].suites[j].fn(argc - 1,
                                                             argv + 1, prefix);
                         goto end;
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index fae8b250b2ca..c96c8fa38243 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -14,6 +14,7 @@
 #include "util/parse-options.h"
 #include "util/strlist.h"
 #include "util/build-id.h"
+#include "util/session.h"
 #include "util/symbol.h"
 
 static int build_id_cache__add_file(const char *filename, const char *debugdir)
@@ -58,19 +59,89 @@ static int build_id_cache__remove_file(const char *filename,
         return err;
 }
 
+static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused)
+{
+        char filename[PATH_MAX];
+        u8 build_id[BUILD_ID_SIZE];
+
+        if (dso__build_id_filename(dso, filename, sizeof(filename)) &&
+            filename__read_build_id(filename, build_id,
+                                    sizeof(build_id)) != sizeof(build_id)) {
+                if (errno == ENOENT)
+                        return false;
+
+                pr_warning("Problems with %s file, consider removing it from the cache\n", 
+                           filename);
+        } else if (memcmp(dso->build_id, build_id, sizeof(dso->build_id))) {
+                pr_warning("Problems with %s file, consider removing it from the cache\n", 
+                           filename);
+        }
+
+        return true;
+}
+
+static int build_id_cache__fprintf_missing(const char *filename, bool force, FILE *fp)
+{
+        struct perf_session *session = perf_session__new(filename, O_RDONLY,
+                                                         force, false, NULL);
+        if (session == NULL)
+                return -1;
+
+        perf_session__fprintf_dsos_buildid(session, fp, dso__missing_buildid_cache, 0);
+        perf_session__delete(session);
+
+        return 0;
+}
+
+static int build_id_cache__update_file(const char *filename,
+                                       const char *debugdir)
+{
+        u8 build_id[BUILD_ID_SIZE];
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        int err;
+
+        if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
+                pr_debug("Couldn't read a build-id in %s\n", filename);
+                return -1;
+        }
+
+        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");
+
+        return err;
+}
+
 int cmd_buildid_cache(int argc, const char **argv,
                       const char *prefix __maybe_unused)
 {
         struct strlist *list;
         struct str_node *pos;
+        int ret = 0;
+        bool force = false;
         char debugdir[PATH_MAX];
         char const *add_name_list_str = NULL,
-                   *remove_name_list_str = NULL;
+                   *remove_name_list_str = NULL,
+                   *missing_filename = NULL,
+                   *update_name_list_str = NULL;
+
         const struct option buildid_cache_options[] = {
         OPT_STRING('a', "add", &add_name_list_str,
                    "file list", "file(s) to add"),
         OPT_STRING('r', "remove", &remove_name_list_str, "file list",
                     "file(s) to remove"),
+        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"),
+        OPT_STRING('u', "update", &update_name_list_str, "file list",
+                    "file(s) to update"),
         OPT_INCR('v', "verbose", &verbose, "be more verbose"),
         OPT_END()
         };
@@ -125,5 +196,26 @@ int cmd_buildid_cache(int argc, const char **argv,
                 }
         }
 
-        return 0;
+        if (missing_filename)
+                ret = build_id_cache__fprintf_missing(missing_filename, force, stdout);
+
+        if (update_name_list_str) {
+                list = strlist__new(true, update_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__update_file(pos->s, debugdir)) {
+                                        if (errno == ENOENT) {
+                                                pr_debug("%s wasn't in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't update %s: %s\n",
+                                                   pos->s, strerror(errno));
+                                }
+
+                        strlist__delete(list);
+                }
+        }
+
+        return ret;
 }
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index a82d99fec83e..e74366a13218 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -44,23 +44,26 @@ static int filename__fprintf_build_id(const char *name, FILE *fp)
         return fprintf(fp, "%s\n", sbuild_id);
 }
 
+static bool dso__skip_buildid(struct dso *dso, int with_hits)
+{
+        return with_hits && !dso->hit;
+}
+
 static int perf_session__list_build_ids(bool force, bool with_hits)
 {
         struct perf_session *session;
 
         symbol__elf_init();
-
-        session = perf_session__new(input_name, O_RDONLY, force, false,
-                                    &build_id__mark_dso_hit_ops);
-        if (session == NULL)
-                return -1;
-
         /*
          * See if this is an ELF file first:
          */
-        if (filename__fprintf_build_id(session->filename, stdout))
+        if (filename__fprintf_build_id(input_name, stdout))
                 goto out;
 
+        session = perf_session__new(input_name, O_RDONLY, force, false,
+                                    &build_id__mark_dso_hit_ops);
+        if (session == NULL)
+                return -1;
         /*
          * in pipe-mode, the only way to get the buildids is to parse
          * the record stream. Buildids are stored as RECORD_HEADER_BUILD_ID
@@ -68,9 +71,9 @@ static int perf_session__list_build_ids(bool force, bool with_hits)
         if (with_hits || session->fd_pipe)
                 perf_session__process_events(session, &build_id__mark_dso_hit_ops);
 
-        perf_session__fprintf_dsos_buildid(session, stdout, with_hits);
-out:
+        perf_session__fprintf_dsos_buildid(session, stdout, dso__skip_buildid, with_hits);
         perf_session__delete(session);
+out:
         return 0;
 }
 
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 93b852f8a5d5..da8f8eb383a0 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -23,7 +23,6 @@ static char const *input_old = "perf.data.old",
                   *input_new = "perf.data";
 static char       diff__default_sort_order[] = "dso,symbol";
 static bool  force;
-static bool show_displacement;
 static bool show_period;
 static bool show_formula;
 static bool show_baseline_only;
@@ -146,58 +145,47 @@ static int setup_compute(const struct option *opt, const char *str,
         return -EINVAL;
 }
 
-static double get_period_percent(struct hist_entry *he, u64 period)
+double perf_diff__period_percent(struct hist_entry *he, u64 period)
 {
         u64 total = he->hists->stats.total_period;
         return (period * 100.0) / total;
 }
 
-double perf_diff__compute_delta(struct hist_entry *he)
+double perf_diff__compute_delta(struct hist_entry *he, struct hist_entry *pair)
 {
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        double new_percent = get_period_percent(he, he->stat.period);
-        double old_percent = pair ? get_period_percent(pair, pair->stat.period) : 0.0;
+        double new_percent = perf_diff__period_percent(he, he->stat.period);
+        double old_percent = perf_diff__period_percent(pair, pair->stat.period);
 
         he->diff.period_ratio_delta = new_percent - old_percent;
         he->diff.computed = true;
         return he->diff.period_ratio_delta;
 }
 
-double perf_diff__compute_ratio(struct hist_entry *he)
+double perf_diff__compute_ratio(struct hist_entry *he, struct hist_entry *pair)
 {
-        struct hist_entry *pair = hist_entry__next_pair(he);
         double new_period = he->stat.period;
-        double old_period = pair ? pair->stat.period : 0;
+        double old_period = pair->stat.period;
 
         he->diff.computed = true;
-        he->diff.period_ratio = pair ? (new_period / old_period) : 0;
+        he->diff.period_ratio = new_period / old_period;
         return he->diff.period_ratio;
 }
 
-s64 perf_diff__compute_wdiff(struct hist_entry *he)
+s64 perf_diff__compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
 {
-        struct hist_entry *pair = hist_entry__next_pair(he);
         u64 new_period = he->stat.period;
-        u64 old_period = pair ? pair->stat.period : 0;
+        u64 old_period = pair->stat.period;
 
         he->diff.computed = true;
-
-        if (!pair)
-                he->diff.wdiff = 0;
-        else
-                he->diff.wdiff = new_period * compute_wdiff_w2 -
-                                 old_period * compute_wdiff_w1;
+        he->diff.wdiff = new_period * compute_wdiff_w2 -
+                         old_period * compute_wdiff_w1;
 
         return he->diff.wdiff;
 }
 
-static int formula_delta(struct hist_entry *he, char *buf, size_t size)
+static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
+                         char *buf, size_t size)
 {
-        struct hist_entry *pair = hist_entry__next_pair(he);
-
-        if (!pair)
-                return -1;
-
         return scnprintf(buf, size,
                          "(%" PRIu64 " * 100 / %" PRIu64 ") - "
                          "(%" PRIu64 " * 100 / %" PRIu64 ")",
@@ -205,41 +193,36 @@ static int formula_delta(struct hist_entry *he, char *buf, size_t size)
                           pair->stat.period, pair->hists->stats.total_period);
 }
 
-static int formula_ratio(struct hist_entry *he, char *buf, size_t size)
+static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
+                         char *buf, size_t size)
 {
-        struct hist_entry *pair = hist_entry__next_pair(he);
         double new_period = he->stat.period;
-        double old_period = pair ? pair->stat.period : 0;
-
-        if (!pair)
-                return -1;
+        double old_period = pair->stat.period;
 
         return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
 }
 
-static int formula_wdiff(struct hist_entry *he, char *buf, size_t size)
+static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
+                         char *buf, size_t size)
 {
-        struct hist_entry *pair = hist_entry__next_pair(he);
         u64 new_period = he->stat.period;
-        u64 old_period = pair ? pair->stat.period : 0;
-
-        if (!pair)
-                return -1;
+        u64 old_period = pair->stat.period;
 
         return scnprintf(buf, size,
                   "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
                   new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
 }
 
-int perf_diff__formula(char *buf, size_t size, struct hist_entry *he)
+int perf_diff__formula(struct hist_entry *he, struct hist_entry *pair,
+                       char *buf, size_t size)
 {
         switch (compute) {
         case COMPUTE_DELTA:
-                return formula_delta(he, buf, size);
+                return formula_delta(he, pair, buf, size);
         case COMPUTE_RATIO:
-                return formula_ratio(he, buf, size);
+                return formula_ratio(he, pair, buf, size);
         case COMPUTE_WEIGHTED_DIFF:
-                return formula_wdiff(he, buf, size);
+                return formula_wdiff(he, pair, buf, size);
         default:
                 BUG_ON(1);
         }
@@ -248,9 +231,10 @@ int perf_diff__formula(char *buf, size_t size, struct hist_entry *he)
 }
 
 static int hists__add_entry(struct hists *self,
-                            struct addr_location *al, u64 period)
+                            struct addr_location *al, u64 period,
+                            u64 weight)
 {
-        if (__hists__add_entry(self, al, NULL, period) != NULL)
+        if (__hists__add_entry(self, al, NULL, period, weight) != NULL)
                 return 0;
         return -ENOMEM;
 }
@@ -272,7 +256,7 @@ static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
         if (al.filtered)
                 return 0;
 
-        if (hists__add_entry(&evsel->hists, &al, sample->period)) {
+        if (hists__add_entry(&evsel->hists, &al, sample->period, sample->weight)) {
                 pr_warning("problem incrementing symbol period, skipping event\n");
                 return -1;
         }
@@ -292,48 +276,6 @@ static struct perf_tool tool = {
         .ordering_requires_timestamps = true,
 };
 
-static void insert_hist_entry_by_name(struct rb_root *root,
-                                      struct hist_entry *he)
-{
-        struct rb_node **p = &root->rb_node;
-        struct rb_node *parent = NULL;
-        struct hist_entry *iter;
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
-                if (hist_entry__cmp(he, iter) < 0)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, root);
-}
-
-static void hists__name_resort(struct hists *self, bool sort)
-{
-        unsigned long position = 1;
-        struct rb_root tmp = RB_ROOT;
-        struct rb_node *next = rb_first(&self->entries);
-
-        while (next != NULL) {
-                struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);
-
-                next = rb_next(&n->rb_node);
-                n->position = position++;
-
-                if (sort) {
-                        rb_erase(&n->rb_node, &self->entries);
-                        insert_hist_entry_by_name(&tmp, n);
-                }
-        }
-
-        if (sort)
-                self->entries = tmp;
-}
-
 static struct perf_evsel *evsel_match(struct perf_evsel *evsel,
                                       struct perf_evlist *evlist)
 {
@@ -346,34 +288,34 @@ static struct perf_evsel *evsel_match(struct perf_evsel *evsel,
         return NULL;
 }
 
-static void perf_evlist__resort_hists(struct perf_evlist *evlist, bool name)
+static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 struct hists *hists = &evsel->hists;
 
-                hists__output_resort(hists);
-
-                /*
-                 * The hists__name_resort only sets possition
-                 * if name is false.
-                 */
-                if (name || ((!name) && show_displacement))
-                        hists__name_resort(hists, name);
+                hists__collapse_resort(hists);
         }
 }
 
 static void hists__baseline_only(struct hists *hists)
 {
-        struct rb_node *next = rb_first(&hists->entries);
+        struct rb_root *root;
+        struct rb_node *next;
+
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
 
+        next = rb_first(root);
         while (next != NULL) {
-                struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
+                struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
 
-                next = rb_next(&he->rb_node);
+                next = rb_next(&he->rb_node_in);
                 if (!hist_entry__next_pair(he)) {
-                        rb_erase(&he->rb_node, &hists->entries);
+                        rb_erase(&he->rb_node_in, root);
                         hist_entry__free(he);
                 }
         }
@@ -381,22 +323,32 @@ static void hists__baseline_only(struct hists *hists)
 
 static void hists__precompute(struct hists *hists)
 {
-        struct rb_node *next = rb_first(&hists->entries);
+        struct rb_root *root;
+        struct rb_node *next;
+
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
 
+        next = rb_first(root);
         while (next != NULL) {
-                struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
+                struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
+                struct hist_entry *pair = hist_entry__next_pair(he);
 
-                next = rb_next(&he->rb_node);
+                next = rb_next(&he->rb_node_in);
+                if (!pair)
+                        continue;
 
                 switch (compute) {
                 case COMPUTE_DELTA:
-                        perf_diff__compute_delta(he);
+                        perf_diff__compute_delta(he, pair);
                         break;
                 case COMPUTE_RATIO:
-                        perf_diff__compute_ratio(he);
+                        perf_diff__compute_ratio(he, pair);
                         break;
                 case COMPUTE_WEIGHTED_DIFF:
-                        perf_diff__compute_wdiff(he);
+                        perf_diff__compute_wdiff(he, pair);
                         break;
                 default:
                         BUG_ON(1);
@@ -470,19 +422,30 @@ static void insert_hist_entry_by_compute(struct rb_root *root,
 
 static void hists__compute_resort(struct hists *hists)
 {
-        struct rb_root tmp = RB_ROOT;
-        struct rb_node *next = rb_first(&hists->entries);
+        struct rb_root *root;
+        struct rb_node *next;
+
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
+
+        hists->entries = RB_ROOT;
+        next = rb_first(root);
+
+        hists->nr_entries = 0;
+        hists->stats.total_period = 0;
+        hists__reset_col_len(hists);
 
         while (next != NULL) {
-                struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
+                struct hist_entry *he;
 
-                next = rb_next(&he->rb_node);
+                he = rb_entry(next, struct hist_entry, rb_node_in);
+                next = rb_next(&he->rb_node_in);
 
-                rb_erase(&he->rb_node, &hists->entries);
-                insert_hist_entry_by_compute(&tmp, he, compute);
+                insert_hist_entry_by_compute(&hists->entries, he, compute);
+                hists__inc_nr_entries(hists, he);
         }
-
-        hists->entries = tmp;
 }
 
 static void hists__process(struct hists *old, struct hists *new)
@@ -497,9 +460,11 @@ static void hists__process(struct hists *old, struct hists *new)
         if (sort_compute) {
                 hists__precompute(new);
                 hists__compute_resort(new);
+        } else {
+                hists__output_resort(new);
         }
 
-        hists__fprintf(new, true, 0, 0, stdout);
+        hists__fprintf(new, true, 0, 0, 0, stdout);
 }
 
 static int __cmd_diff(void)
@@ -528,8 +493,8 @@ static int __cmd_diff(void)
         evlist_old = older->evlist;
         evlist_new = newer->evlist;
 
-        perf_evlist__resort_hists(evlist_old, true);
-        perf_evlist__resort_hists(evlist_new, false);
+        perf_evlist__collapse_resort(evlist_old);
+        perf_evlist__collapse_resort(evlist_new);
 
         list_for_each_entry(evsel, &evlist_new->entries, node) {
                 struct perf_evsel *evsel_old;
@@ -562,8 +527,6 @@ static const char * const diff_usage[] = {
 static const struct option options[] = {
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
-        OPT_BOOLEAN('M', "displacement", &show_displacement,
-                    "Show position displacement relative to baseline"),
         OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
                     "Show only items with match in baseline"),
         OPT_CALLBACK('c', "compute", &compute,
@@ -597,40 +560,32 @@ static const struct option options[] = {
 
 static void ui_init(void)
 {
-        perf_hpp__init();
-
-        /* No overhead column. */
-        perf_hpp__column_enable(PERF_HPP__OVERHEAD, false);
-
         /*
-         * Display baseline/delta/ratio/displacement/
+         * Display baseline/delta/ratio
          * formula/periods columns.
          */
-        perf_hpp__column_enable(PERF_HPP__BASELINE, true);
+        perf_hpp__column_enable(PERF_HPP__BASELINE);
 
         switch (compute) {
         case COMPUTE_DELTA:
-                perf_hpp__column_enable(PERF_HPP__DELTA, true);
+                perf_hpp__column_enable(PERF_HPP__DELTA);
                 break;
         case COMPUTE_RATIO:
-                perf_hpp__column_enable(PERF_HPP__RATIO, true);
+                perf_hpp__column_enable(PERF_HPP__RATIO);
                 break;
         case COMPUTE_WEIGHTED_DIFF:
-                perf_hpp__column_enable(PERF_HPP__WEIGHTED_DIFF, true);
+                perf_hpp__column_enable(PERF_HPP__WEIGHTED_DIFF);
                 break;
         default:
                 BUG_ON(1);
         };
 
-        if (show_displacement)
-                perf_hpp__column_enable(PERF_HPP__DISPL, true);
-
         if (show_formula)
-                perf_hpp__column_enable(PERF_HPP__FORMULA, true);
+                perf_hpp__column_enable(PERF_HPP__FORMULA);
 
         if (show_period) {
-                perf_hpp__column_enable(PERF_HPP__PERIOD, true);
-                perf_hpp__column_enable(PERF_HPP__PERIOD_BASELINE, true);
+                perf_hpp__column_enable(PERF_HPP__PERIOD);
+                perf_hpp__column_enable(PERF_HPP__PERIOD_BASELINE);
         }
 }
 
@@ -658,12 +613,12 @@ int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
 
         ui_init();
 
-        setup_sorting(diff_usage, options);
+        if (setup_sorting() < 0)
+                usage_with_options(diff_usage, options);
+
         setup_pager();
 
-        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);
-        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);
-        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);
+        sort__setup_elide(NULL);
 
         return __cmd_diff();
 }
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index c20f1dcfb7e2..05bd9dfe875c 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -15,39 +15,6 @@
 #include "util/parse-options.h"
 #include "util/session.h"
 
-struct perf_attr_details {
-        bool freq;
-        bool verbose;
-};
-
-static int comma_printf(bool *first, const char *fmt, ...)
-{
-        va_list args;
-        int ret = 0;
-
-        if (!*first) {
-                ret += printf(",");
-        } else {
-                ret += printf(":");
-                *first = false;
-        }
-
-        va_start(args, fmt);
-        ret += vprintf(fmt, args);
-        va_end(args);
-        return ret;
-}
-
-static int __if_print(bool *first, const char *field, u64 value)
-{
-        if (value == 0)
-                return 0;
-
-        return comma_printf(first, " %s: %" PRIu64, field, value);
-}
-
-#define if_print(field) __if_print(&first, #field, pos->attr.field)
-
 static int __cmd_evlist(const char *file_name, struct perf_attr_details *details)
 {
         struct perf_session *session;
@@ -57,52 +24,8 @@ static int __cmd_evlist(const char *file_name, struct perf_attr_details *details
         if (session == NULL)
                 return -ENOMEM;
 
-        list_for_each_entry(pos, &session->evlist->entries, node) {
-                bool first = true;
-
-                printf("%s", perf_evsel__name(pos));
-
-                if (details->verbose || details->freq) {
-                        comma_printf(&first, " sample_freq=%" PRIu64,
-                                     (u64)pos->attr.sample_freq);
-                }
-
-                if (details->verbose) {
-                        if_print(type);
-                        if_print(config);
-                        if_print(config1);
-                        if_print(config2);
-                        if_print(size);
-                        if_print(sample_type);
-                        if_print(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(comm);
-                        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);
-                }
-
-                putchar('\n');
-        }
+        list_for_each_entry(pos, &session->evlist->entries, node)
+                perf_evsel__fprintf(pos, details, stdout);
 
         perf_session__delete(session);
         return 0;
@@ -116,6 +39,8 @@ int cmd_evlist(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_BOOLEAN('F', "freq", &details.freq, "Show the sample frequency"),
         OPT_BOOLEAN('v', "verbose", &details.verbose,
                     "Show all event attr details"),
+        OPT_BOOLEAN('g', "group", &details.event_group,
+                    "Show event group information"),
         OPT_END()
         };
         const char * const evlist_usage[] = {
@@ -127,5 +52,10 @@ int cmd_evlist(int argc, const char **argv, const char *prefix __maybe_unused)
         if (argc)
                 usage_with_options(evlist_usage, options);
 
+        if (details.event_group && (details.verbose || details.freq)) {
+                pr_err("--group option is not compatible with other options\n");
+                usage_with_options(evlist_usage, options);
+        }
+
         return __cmd_evlist(input_name, &details);
 }
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 0b4b796167be..46878daca5cc 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -17,6 +17,7 @@
 #include "util/debug.h"
 
 #include <linux/rbtree.h>
+#include <linux/string.h>
 
 struct alloc_stat;
 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
@@ -340,7 +341,7 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
                            int n_lines, int is_caller)
 {
         struct rb_node *next;
-        struct machine *machine;
+        struct machine *machine = &session->machines.host;
 
         printf("%.102s\n", graph_dotted_line);
         printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
@@ -349,11 +350,6 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
 
         next = rb_first(root);
 
-        machine = perf_session__find_host_machine(session);
-        if (!machine) {
-                pr_err("__print_result: couldn't find kernel information\n");
-                return;
-        }
         while (next && n_lines--) {
                 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
                                                    node);
@@ -614,8 +610,7 @@ static struct sort_dimension *avail_sorts[] = {
         &pingpong_sort_dimension,
 };
 
-#define NUM_AVAIL_SORTS \
-        (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
+#define NUM_AVAIL_SORTS ((int)ARRAY_SIZE(avail_sorts))
 
 static int sort_dimension__add(const char *tok, struct list_head *list)
 {
@@ -624,12 +619,11 @@ static int sort_dimension__add(const char *tok, struct list_head *list)
 
         for (i = 0; i < NUM_AVAIL_SORTS; i++) {
                 if (!strcmp(avail_sorts[i]->name, tok)) {
-                        sort = malloc(sizeof(*sort));
+                        sort = memdup(avail_sorts[i], sizeof(*avail_sorts[i]));
                         if (!sort) {
-                                pr_err("%s: malloc failed\n", __func__);
+                                pr_err("%s: memdup failed\n", __func__);
                                 return -1;
                         }
-                        memcpy(sort, avail_sorts[i], sizeof(*sort));
                         list_add_tail(&sort->list, list);
                         return 0;
                 }
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index ca3f80ebc100..24b78aecc928 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -12,7 +12,7 @@
 #include "util/parse-options.h"
 #include "util/trace-event.h"
 #include "util/debug.h"
-#include "util/debugfs.h"
+#include <lk/debugfs.h>
 #include "util/tool.h"
 #include "util/stat.h"
 
@@ -328,6 +328,7 @@ static int kvm_events_hash_fn(u64 key)
 static bool kvm_event_expand(struct kvm_event *event, int vcpu_id)
 {
         int old_max_vcpu = event->max_vcpu;
+        void *prev;
 
         if (vcpu_id < event->max_vcpu)
                 return true;
@@ -335,9 +336,11 @@ static bool kvm_event_expand(struct kvm_event *event, int vcpu_id)
         while (event->max_vcpu <= vcpu_id)
                 event->max_vcpu += DEFAULT_VCPU_NUM;
 
+        prev = event->vcpu;
         event->vcpu = realloc(event->vcpu,
                               event->max_vcpu * sizeof(*event->vcpu));
         if (!event->vcpu) {
+                free(prev);
                 pr_err("Not enough memory\n");
                 return false;
         }
@@ -973,8 +976,7 @@ __cmd_buildid_list(const char *file_name, int argc, const char **argv)
 
 int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        const char *file_name;
-
+        const char *file_name = NULL;
         const struct option kvm_options[] = {
                 OPT_STRING('i', "input", &file_name, "file",
                            "Input file name"),
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
new file mode 100644
index 000000000000..a8ff6d264e50
--- /dev/null
+++ b/tools/perf/builtin-mem.c
@@ -0,0 +1,242 @@
+#include "builtin.h"
+#include "perf.h"
+
+#include "util/parse-options.h"
+#include "util/trace-event.h"
+#include "util/tool.h"
+#include "util/session.h"
+
+#define MEM_OPERATION_LOAD      "load"
+#define MEM_OPERATION_STORE     "store"
+
+static const char       *mem_operation          = MEM_OPERATION_LOAD;
+
+struct perf_mem {
+        struct perf_tool        tool;
+        char const              *input_name;
+        symbol_filter_t         annotate_init;
+        bool                    hide_unresolved;
+        bool                    dump_raw;
+        const char              *cpu_list;
+        DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
+};
+
+static const char * const mem_usage[] = {
+        "perf mem [<options>] {record <command> |report}",
+        NULL
+};
+
+static int __cmd_record(int argc, const char **argv)
+{
+        int rec_argc, i = 0, j;
+        const char **rec_argv;
+        char event[64];
+        int ret;
+
+        rec_argc = argc + 4;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+        if (!rec_argv)
+                return -1;
+
+        rec_argv[i++] = strdup("record");
+        if (!strcmp(mem_operation, MEM_OPERATION_LOAD))
+                rec_argv[i++] = strdup("-W");
+        rec_argv[i++] = strdup("-d");
+        rec_argv[i++] = strdup("-e");
+
+        if (strcmp(mem_operation, MEM_OPERATION_LOAD))
+                sprintf(event, "cpu/mem-stores/pp");
+        else
+                sprintf(event, "cpu/mem-loads/pp");
+
+        rec_argv[i++] = strdup(event);
+        for (j = 1; j < argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        ret = cmd_record(i, rec_argv, NULL);
+        free(rec_argv);
+        return ret;
+}
+
+static int
+dump_raw_samples(struct perf_tool *tool,
+                 union perf_event *event,
+                 struct perf_sample *sample,
+                 struct perf_evsel *evsel __maybe_unused,
+                 struct machine *machine)
+{
+        struct perf_mem *mem = container_of(tool, struct perf_mem, tool);
+        struct addr_location al;
+        const char *fmt;
+
+        if (perf_event__preprocess_sample(event, machine, &al, sample,
+                                mem->annotate_init) < 0) {
+                fprintf(stderr, "problem processing %d event, skipping it.\n",
+                                event->header.type);
+                return -1;
+        }
+
+        if (al.filtered || (mem->hide_unresolved && al.sym == NULL))
+                return 0;
+
+        if (al.map != NULL)
+                al.map->dso->hit = 1;
+
+        if (symbol_conf.field_sep) {
+                fmt = "%d%s%d%s0x%"PRIx64"%s0x%"PRIx64"%s%"PRIu64
+                      "%s0x%"PRIx64"%s%s:%s\n";
+        } else {
+                fmt = "%5d%s%5d%s0x%016"PRIx64"%s0x016%"PRIx64
+                      "%s%5"PRIu64"%s0x%06"PRIx64"%s%s:%s\n";
+                symbol_conf.field_sep = " ";
+        }
+
+        printf(fmt,
+                sample->pid,
+                symbol_conf.field_sep,
+                sample->tid,
+                symbol_conf.field_sep,
+                event->ip.ip,
+                symbol_conf.field_sep,
+                sample->addr,
+                symbol_conf.field_sep,
+                sample->weight,
+                symbol_conf.field_sep,
+                sample->data_src,
+                symbol_conf.field_sep,
+                al.map ? (al.map->dso ? al.map->dso->long_name : "???") : "???",
+                al.sym ? al.sym->name : "???");
+
+        return 0;
+}
+
+static int process_sample_event(struct perf_tool *tool,
+                                union perf_event *event,
+                                struct perf_sample *sample,
+                                struct perf_evsel *evsel,
+                                struct machine *machine)
+{
+        return dump_raw_samples(tool, event, sample, evsel, machine);
+}
+
+static int report_raw_events(struct perf_mem *mem)
+{
+        int err = -EINVAL;
+        int ret;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY,
+                                                         0, false, &mem->tool);
+
+        if (session == NULL)
+                return -ENOMEM;
+
+        if (mem->cpu_list) {
+                ret = perf_session__cpu_bitmap(session, mem->cpu_list,
+                                               mem->cpu_bitmap);
+                if (ret)
+                        goto out_delete;
+        }
+
+        if (symbol__init() < 0)
+                return -1;
+
+        printf("# PID, TID, IP, ADDR, LOCAL WEIGHT, DSRC, SYMBOL\n");
+
+        err = perf_session__process_events(session, &mem->tool);
+        if (err)
+                return err;
+
+        return 0;
+
+out_delete:
+        perf_session__delete(session);
+        return err;
+}
+
+static int report_events(int argc, const char **argv, struct perf_mem *mem)
+{
+        const char **rep_argv;
+        int ret, i = 0, j, rep_argc;
+
+        if (mem->dump_raw)
+                return report_raw_events(mem);
+
+        rep_argc = argc + 3;
+        rep_argv = calloc(rep_argc + 1, sizeof(char *));
+        if (!rep_argv)
+                return -1;
+
+        rep_argv[i++] = strdup("report");
+        rep_argv[i++] = strdup("--mem-mode");
+        rep_argv[i++] = strdup("-n"); /* display number of samples */
+
+        /*
+         * there is no weight (cost) associated with stores, so don't print
+         * the column
+         */
+        if (strcmp(mem_operation, MEM_OPERATION_LOAD))
+                rep_argv[i++] = strdup("--sort=mem,sym,dso,symbol_daddr,"
+                                       "dso_daddr,tlb,locked");
+
+        for (j = 1; j < argc; j++, i++)
+                rep_argv[i] = argv[j];
+
+        ret = cmd_report(i, rep_argv, NULL);
+        free(rep_argv);
+        return ret;
+}
+
+int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
+{
+        struct stat st;
+        struct perf_mem mem = {
+                .tool = {
+                        .sample         = process_sample_event,
+                        .mmap           = perf_event__process_mmap,
+                        .comm           = perf_event__process_comm,
+                        .lost           = perf_event__process_lost,
+                        .fork           = perf_event__process_fork,
+                        .build_id       = perf_event__process_build_id,
+                        .ordered_samples = true,
+                },
+                .input_name              = "perf.data",
+        };
+        const struct option mem_options[] = {
+        OPT_STRING('t', "type", &mem_operation,
+                   "type", "memory operations(load/store)"),
+        OPT_BOOLEAN('D', "dump-raw-samples", &mem.dump_raw,
+                    "dump raw samples in ASCII"),
+        OPT_BOOLEAN('U', "hide-unresolved", &mem.hide_unresolved,
+                    "Only display entries resolved to a symbol"),
+        OPT_STRING('i', "input", &input_name, "file",
+                   "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,
+                   "separator",
+                   "separator for columns, no spaces will be added"
+                   " between columns '.' is reserved."),
+        OPT_END()
+        };
+
+        argc = parse_options(argc, argv, mem_options, mem_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+
+        if (!argc || !(strncmp(argv[0], "rec", 3) || mem_operation))
+                usage_with_options(mem_usage, mem_options);
+
+        if (!mem.input_name || !strlen(mem.input_name)) {
+                if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
+                        mem.input_name = "-";
+                else
+                        mem.input_name = "perf.data";
+        }
+
+        if (!strncmp(argv[0], "rec", 3))
+                return __cmd_record(argc, argv);
+        else if (!strncmp(argv[0], "rep", 3))
+                return report_events(argc, argv, &mem);
+        else
+                usage_with_options(mem_usage, mem_options);
+
+        return 0;
+}
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index de38a034b129..e8a66f9a6715 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -37,7 +37,7 @@
 #include "util/strfilter.h"
 #include "util/symbol.h"
 #include "util/debug.h"
-#include "util/debugfs.h"
+#include <lk/debugfs.h>
 #include "util/parse-options.h"
 #include "util/probe-finder.h"
 #include "util/probe-event.h"
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index f3151d3c70ce..fff985cf3852 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -5,8 +5,6 @@
  * (or a CPU, or a PID) into the perf.data output file - for
  * later analysis via perf report.
  */
-#define _FILE_OFFSET_BITS 64
-
 #include "builtin.h"
 
 #include "perf.h"
@@ -200,7 +198,6 @@ static void perf_record__sig_exit(int exit_status __maybe_unused, void *arg)
                 return;
 
         signal(signr, SIG_DFL);
-        kill(getpid(), signr);
 }
 
 static bool perf_evlist__equal(struct perf_evlist *evlist,
@@ -224,130 +221,28 @@ static bool perf_evlist__equal(struct perf_evlist *evlist,
 
 static int perf_record__open(struct perf_record *rec)
 {
+        char msg[512];
         struct perf_evsel *pos;
         struct perf_evlist *evlist = rec->evlist;
         struct perf_session *session = rec->session;
         struct perf_record_opts *opts = &rec->opts;
         int rc = 0;
 
-        /*
-         * Set the evsel leader links before we configure attributes,
-         * since some might depend on this info.
-         */
-        if (opts->group)
-                perf_evlist__set_leader(evlist);
-
-        perf_evlist__config_attrs(evlist, opts);
+        perf_evlist__config(evlist, opts);
 
         list_for_each_entry(pos, &evlist->entries, node) {
-                struct perf_event_attr *attr = &pos->attr;
-                /*
-                 * Check if parse_single_tracepoint_event has already asked for
-                 * PERF_SAMPLE_TIME.
-                 *
-                 * XXX this is kludgy but short term fix for problems introduced by
-                 * eac23d1c that broke 'perf script' by having different sample_types
-                 * when using multiple tracepoint events when we use a perf binary
-                 * that tries to use sample_id_all on an older kernel.
-                 *
-                 * We need to move counter creation to perf_session, support
-                 * different sample_types, etc.
-                 */
-                bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
-
-fallback_missing_features:
-                if (opts->exclude_guest_missing)
-                        attr->exclude_guest = attr->exclude_host = 0;
-retry_sample_id:
-                attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
 try_again:
                 if (perf_evsel__open(pos, evlist->cpus, evlist->threads) < 0) {
-                        int err = errno;
-
-                        if (err == EPERM || err == EACCES) {
-                                ui__error_paranoid();
-                                rc = -err;
-                                goto out;
-                        } else if (err ==  ENODEV && opts->target.cpu_list) {
-                                pr_err("No such device - did you specify"
-                                       " an out-of-range profile CPU?\n");
-                                rc = -err;
-                                goto out;
-                        } else if (err == EINVAL) {
-                                if (!opts->exclude_guest_missing &&
-                                    (attr->exclude_guest || attr->exclude_host)) {
-                                        pr_debug("Old kernel, cannot exclude "
-                                                 "guest or host samples.\n");
-                                        opts->exclude_guest_missing = true;
-                                        goto fallback_missing_features;
-                                } else if (!opts->sample_id_all_missing) {
-                                        /*
-                                         * Old kernel, no attr->sample_id_type_all field
-                                         */
-                                        opts->sample_id_all_missing = true;
-                                        if (!opts->sample_time && !opts->raw_samples && !time_needed)
-                                                attr->sample_type &= ~PERF_SAMPLE_TIME;
-
-                                        goto retry_sample_id;
-                                }
-                        }
-
-                        /*
-                         * If it's cycles then fall back to hrtimer
-                         * based cpu-clock-tick sw counter, which
-                         * is always available even if no PMU support.
-                         *
-                         * PPC returns ENXIO until 2.6.37 (behavior changed
-                         * with commit b0a873e).
-                         */
-                        if ((err == ENOENT || err == ENXIO)
-                                        && attr->type == PERF_TYPE_HARDWARE
-                                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
-
+                        if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
                                 if (verbose)
-                                        ui__warning("The cycles event is not supported, "
-                                                    "trying to fall back to cpu-clock-ticks\n");
-                                attr->type = PERF_TYPE_SOFTWARE;
-                                attr->config = PERF_COUNT_SW_CPU_CLOCK;
-                                if (pos->name) {
-                                        free(pos->name);
-                                        pos->name = NULL;
-                                }
+                                        ui__warning("%s\n", msg);
                                 goto try_again;
                         }
 
-                        if (err == ENOENT) {
-                                ui__error("The %s event is not supported.\n",
-                                          perf_evsel__name(pos));
-                                rc = -err;
-                                goto out;
-                        } else if ((err == EOPNOTSUPP) && (attr->precise_ip)) {
-                                ui__error("\'precise\' request may not be supported. "
-                                          "Try removing 'p' modifier\n");
-                                rc = -err;
-                                goto out;
-                        }
-
-                        printf("\n");
-                        error("sys_perf_event_open() syscall returned with %d "
-                              "(%s) for event %s. /bin/dmesg may provide "
-                              "additional information.\n",
-                              err, strerror(err), perf_evsel__name(pos));
-
-#if defined(__i386__) || defined(__x86_64__)
-                        if (attr->type == PERF_TYPE_HARDWARE &&
-                            err == EOPNOTSUPP) {
-                                pr_err("No hardware sampling interrupt available."
-                                       " No APIC? If so then you can boot the kernel"
-                                       " with the \"lapic\" boot parameter to"
-                                       " force-enable it.\n");
-                                rc = -err;
-                                goto out;
-                        }
-#endif
-
-                        pr_err("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
-                        rc = -err;
+                        rc = -errno;
+                        perf_evsel__open_strerror(pos, &opts->target,
+                                                  errno, msg, sizeof(msg));
+                        ui__error("%s\n", msg);
                         goto out;
                 }
         }
@@ -430,10 +325,6 @@ static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 {
         int err;
         struct perf_tool *tool = data;
-
-        if (machine__is_host(machine))
-                return;
-
         /*
          *As for guest kernel when processing subcommand record&report,
          *we arrange module mmap prior to guest kernel mmap and trigger
@@ -512,6 +403,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
         signal(SIGUSR1, sig_handler);
+        signal(SIGTERM, sig_handler);
 
         if (!output_name) {
                 if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
@@ -580,7 +472,9 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         }
 
         if (forks) {
-                err = perf_evlist__prepare_workload(evsel_list, opts, argv);
+                err = perf_evlist__prepare_workload(evsel_list, &opts->target,
+                                                    argv, opts->pipe_output,
+                                                    true);
                 if (err < 0) {
                         pr_err("Couldn't run the workload!\n");
                         goto out_delete_session;
@@ -592,6 +486,9 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                 goto out_delete_session;
         }
 
+        if (!evsel_list->nr_groups)
+                perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
+
         /*
          * perf_session__delete(session) will be called at perf_record__exit()
          */
@@ -618,12 +515,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 
         rec->post_processing_offset = lseek(output, 0, SEEK_CUR);
 
-        machine = perf_session__find_host_machine(session);
-        if (!machine) {
-                pr_err("Couldn't find native kernel information.\n");
-                err = -1;
-                goto out_delete_session;
-        }
+        machine = &session->machines.host;
 
         if (opts->pipe_output) {
                 err = perf_event__synthesize_attrs(tool, session,
@@ -676,17 +568,20 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
                        "Check /proc/modules permission or run as root.\n");
 
-        if (perf_guest)
-                perf_session__process_machines(session, tool,
-                                               perf_event__synthesize_guest_os);
+        if (perf_guest) {
+                machines__process_guests(&session->machines,
+                                         perf_event__synthesize_guest_os, tool);
+        }
 
-        if (!opts->target.system_wide)
+        if (perf_target__has_task(&opts->target))
                 err = perf_event__synthesize_thread_map(tool, evsel_list->threads,
                                                   process_synthesized_event,
                                                   machine);
-        else
+        else if (perf_target__has_cpu(&opts->target))
                 err = perf_event__synthesize_threads(tool, process_synthesized_event,
                                                machine);
+        else /* command specified */
+                err = 0;
 
         if (err != 0)
                 goto out_delete_session;
@@ -875,11 +770,10 @@ static int get_stack_size(char *str, unsigned long *_size)
 }
 #endif /* LIBUNWIND_SUPPORT */
 
-static int
-parse_callchain_opt(const struct option *opt __maybe_unused, const char *arg,
-                    int unset)
+int record_parse_callchain_opt(const struct option *opt,
+                               const char *arg, int unset)
 {
-        struct perf_record *rec = (struct perf_record *)opt->value;
+        struct perf_record_opts *opts = opt->value;
         char *tok, *name, *saveptr = NULL;
         char *buf;
         int ret = -1;
@@ -905,7 +799,7 @@ parse_callchain_opt(const struct option *opt __maybe_unused, const char *arg,
                 /* Framepointer style */
                 if (!strncmp(name, "fp", sizeof("fp"))) {
                         if (!strtok_r(NULL, ",", &saveptr)) {
-                                rec->opts.call_graph = CALLCHAIN_FP;
+                                opts->call_graph = CALLCHAIN_FP;
                                 ret = 0;
                         } else
                                 pr_err("callchain: No more arguments "
@@ -918,20 +812,20 @@ parse_callchain_opt(const struct option *opt __maybe_unused, const char *arg,
                         const unsigned long default_stack_dump_size = 8192;
 
                         ret = 0;
-                        rec->opts.call_graph = CALLCHAIN_DWARF;
-                        rec->opts.stack_dump_size = default_stack_dump_size;
+                        opts->call_graph = CALLCHAIN_DWARF;
+                        opts->stack_dump_size = default_stack_dump_size;
 
                         tok = strtok_r(NULL, ",", &saveptr);
                         if (tok) {
                                 unsigned long size = 0;
 
                                 ret = get_stack_size(tok, &size);
-                                rec->opts.stack_dump_size = size;
+                                opts->stack_dump_size = size;
                         }
 
                         if (!ret)
                                 pr_debug("callchain: stack dump size %d\n",
-                                         rec->opts.stack_dump_size);
+                                         opts->stack_dump_size);
 #endif /* LIBUNWIND_SUPPORT */
                 } else {
                         pr_err("callchain: Unknown -g option "
@@ -944,7 +838,7 @@ parse_callchain_opt(const struct option *opt __maybe_unused, const char *arg,
         free(buf);
 
         if (!ret)
-                pr_debug("callchain: type %d\n", rec->opts.call_graph);
+                pr_debug("callchain: type %d\n", opts->call_graph);
 
         return ret;
 }
@@ -982,9 +876,9 @@ static struct perf_record record = {
 #define CALLCHAIN_HELP "do call-graph (stack chain/backtrace) recording: "
 
 #ifdef LIBUNWIND_SUPPORT
-static const char callchain_help[] = CALLCHAIN_HELP "[fp] dwarf";
+const char record_callchain_help[] = CALLCHAIN_HELP "[fp] dwarf";
 #else
-static const char callchain_help[] = CALLCHAIN_HELP "[fp]";
+const char record_callchain_help[] = CALLCHAIN_HELP "[fp]";
 #endif
 
 /*
@@ -1028,9 +922,9 @@ const struct option record_options[] = {
                      "number of mmap data pages"),
         OPT_BOOLEAN(0, "group", &record.opts.group,
                     "put the counters into a counter group"),
-        OPT_CALLBACK_DEFAULT('g', "call-graph", &record, "mode[,dump_size]",
-                             callchain_help, &parse_callchain_opt,
-                             "fp"),
+        OPT_CALLBACK_DEFAULT('g', "call-graph", &record.opts,
+                             "mode[,dump_size]", record_callchain_help,
+                             &record_parse_callchain_opt, "fp"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
@@ -1059,6 +953,8 @@ const struct option record_options[] = {
         OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
                      "branch filter mask", "branch stack filter modes",
                      parse_branch_stack),
+        OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
+                    "sample by weight (on special events only)"),
         OPT_END()
 };
 
@@ -1070,7 +966,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
         struct perf_record *rec = &record;
         char errbuf[BUFSIZ];
 
-        evsel_list = perf_evlist__new(NULL, NULL);
+        evsel_list = perf_evlist__new();
         if (evsel_list == NULL)
                 return -ENOMEM;
 
@@ -1132,7 +1028,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
                 ui__error("%s", errbuf);
 
                 err = -saved_errno;
-                goto out_free_fd;
+                goto out_symbol_exit;
         }
 
         err = -ENOMEM;
@@ -1163,6 +1059,9 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
         }
 
         err = __cmd_record(&record, argc, argv);
+
+        perf_evlist__munmap(evsel_list);
+        perf_evlist__close(evsel_list);
 out_free_fd:
         perf_evlist__delete_maps(evsel_list);
 out_symbol_exit:
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index fc251005dd3d..ca98d34cd58b 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -8,11 +8,11 @@
 #include "builtin.h"
 
 #include "util/util.h"
+#include "util/cache.h"
 
 #include "util/annotate.h"
 #include "util/color.h"
 #include <linux/list.h>
-#include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
 #include "util/callchain.h"
@@ -46,14 +46,124 @@ struct perf_report {
         bool                    show_full_info;
         bool                    show_threads;
         bool                    inverted_callchain;
+        bool                    mem_mode;
         struct perf_read_values show_threads_values;
         const char              *pretty_printing_style;
         symbol_filter_t         annotate_init;
         const char              *cpu_list;
         const char              *symbol_filter_str;
+        float                   min_percent;
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 };
 
+static int perf_report_config(const char *var, const char *value, void *cb)
+{
+        if (!strcmp(var, "report.group")) {
+                symbol_conf.event_group = perf_config_bool(var, value);
+                return 0;
+        }
+        if (!strcmp(var, "report.percent-limit")) {
+                struct perf_report *rep = cb;
+                rep->min_percent = strtof(value, NULL);
+                return 0;
+        }
+
+        return perf_default_config(var, value, cb);
+}
+
+static int perf_report__add_mem_hist_entry(struct perf_tool *tool,
+                                           struct addr_location *al,
+                                           struct perf_sample *sample,
+                                           struct perf_evsel *evsel,
+                                           struct machine *machine,
+                                           union perf_event *event)
+{
+        struct perf_report *rep = container_of(tool, struct perf_report, tool);
+        struct symbol *parent = NULL;
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        int err = 0;
+        struct hist_entry *he;
+        struct mem_info *mi, *mx;
+        uint64_t cost;
+
+        if ((sort__has_parent || symbol_conf.use_callchain) &&
+            sample->callchain) {
+                err = machine__resolve_callchain(machine, evsel, al->thread,
+                                                 sample, &parent);
+                if (err)
+                        return err;
+        }
+
+        mi = machine__resolve_mem(machine, al->thread, sample, cpumode);
+        if (!mi)
+                return -ENOMEM;
+
+        if (rep->hide_unresolved && !al->sym)
+                return 0;
+
+        cost = sample->weight;
+        if (!cost)
+                cost = 1;
+
+        /*
+         * must pass period=weight in order to get the correct
+         * sorting from hists__collapse_resort() which is solely
+         * based on periods. We want sorting be done on nr_events * weight
+         * and this is indirectly achieved by passing period=weight here
+         * and the he_stat__add_period() function.
+         */
+        he = __hists__add_mem_entry(&evsel->hists, al, parent, mi, cost, cost);
+        if (!he)
+                return -ENOMEM;
+
+        /*
+         * In the TUI browser, we are doing integrated annotation,
+         * so we don't allocate the extra space needed because the stdio
+         * code will not use it.
+         */
+        if (sort__has_sym && he->ms.sym && use_browser > 0) {
+                struct annotation *notes = symbol__annotation(he->ms.sym);
+
+                assert(evsel != NULL);
+
+                if (notes->src == NULL && symbol__alloc_hist(he->ms.sym) < 0)
+                        goto out;
+
+                err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
+                if (err)
+                        goto out;
+        }
+
+        if (sort__has_sym && he->mem_info->daddr.sym && use_browser > 0) {
+                struct annotation *notes;
+
+                mx = he->mem_info;
+
+                notes = symbol__annotation(mx->daddr.sym);
+                if (notes->src == NULL && symbol__alloc_hist(mx->daddr.sym) < 0)
+                        goto out;
+
+                err = symbol__inc_addr_samples(mx->daddr.sym,
+                                               mx->daddr.map,
+                                               evsel->idx,
+                                               mx->daddr.al_addr);
+                if (err)
+                        goto out;
+        }
+
+        evsel->hists.stats.total_period += cost;
+        hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
+        err = 0;
+
+        if (symbol_conf.use_callchain) {
+                err = callchain_append(he->callchain,
+                                       &callchain_cursor,
+                                       sample->period);
+        }
+out:
+        return err;
+}
+
 static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
                                         struct addr_location *al,
                                         struct perf_sample *sample,
@@ -83,15 +193,17 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
         for (i = 0; i < sample->branch_stack->nr; i++) {
                 if (rep->hide_unresolved && !(bi[i].from.sym && bi[i].to.sym))
                         continue;
+
+                err = -ENOMEM;
+
                 /*
                  * The report shows the percentage of total branches captured
                  * and not events sampled. Thus we use a pseudo period of 1.
                  */
                 he = __hists__add_branch_entry(&evsel->hists, al, parent,
-                                &bi[i], 1);
+                                &bi[i], 1, 1);
                 if (he) {
                         struct annotation *notes;
-                        err = -ENOMEM;
                         bx = he->branch_info;
                         if (bx->from.sym && use_browser == 1 && sort__has_sym) {
                                 notes = symbol__annotation(bx->from.sym);
@@ -122,11 +234,12 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
                         }
                         evsel->hists.stats.total_period += 1;
                         hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
-                        err = 0;
                 } else
-                        return -ENOMEM;
+                        goto out;
         }
+        err = 0;
 out:
+        free(bi);
         return err;
 }
 
@@ -146,7 +259,8 @@ static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
                         return err;
         }
 
-        he = __hists__add_entry(&evsel->hists, al, parent, sample->period);
+        he = __hists__add_entry(&evsel->hists, al, parent, sample->period,
+                                        sample->weight);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -158,7 +272,7 @@ static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
                         return err;
         }
         /*
-         * Only in the newt browser we are doing integrated annotation,
+         * Only in the TUI browser we are doing integrated annotation,
          * so we don't allocated the extra space needed because the stdio
          * code will not use it.
          */
@@ -189,6 +303,7 @@ static int process_sample_event(struct perf_tool *tool,
 {
         struct perf_report *rep = container_of(tool, struct perf_report, tool);
         struct addr_location al;
+        int ret;
 
         if (perf_event__preprocess_sample(event, machine, &al, sample,
                                           rep->annotate_init) < 0) {
@@ -203,22 +318,25 @@ static int process_sample_event(struct perf_tool *tool,
         if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
                 return 0;
 
-        if (sort__branch_mode == 1) {
-                if (perf_report__add_branch_hist_entry(tool, &al, sample,
-                                                       evsel, machine)) {
+        if (sort__mode == SORT_MODE__BRANCH) {
+                ret = perf_report__add_branch_hist_entry(tool, &al, sample,
+                                                         evsel, machine);
+                if (ret < 0)
                         pr_debug("problem adding lbr entry, skipping event\n");
-                        return -1;
-                }
+        } else if (rep->mem_mode == 1) {
+                ret = perf_report__add_mem_hist_entry(tool, &al, sample,
+                                                      evsel, machine, event);
+                if (ret < 0)
+                        pr_debug("problem adding mem entry, skipping event\n");
         } else {
                 if (al.map != NULL)
                         al.map->dso->hit = 1;
 
-                if (perf_evsel__add_hist_entry(evsel, &al, sample, machine)) {
+                ret = perf_evsel__add_hist_entry(evsel, &al, sample, machine);
+                if (ret < 0)
                         pr_debug("problem incrementing symbol period, skipping event\n");
-                        return -1;
-                }
         }
-        return 0;
+        return ret;
 }
 
 static int process_read_event(struct perf_tool *tool,
@@ -273,7 +391,7 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
                         }
         }
 
-        if (sort__branch_mode == 1) {
+        if (sort__mode == SORT_MODE__BRANCH) {
                 if (!self->fd_pipe &&
                     !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
                         ui__error("Selected -b but no branch data. "
@@ -292,20 +410,40 @@ static void sig_handler(int sig __maybe_unused)
         session_done = 1;
 }
 
-static size_t hists__fprintf_nr_sample_events(struct hists *self,
+static size_t hists__fprintf_nr_sample_events(struct perf_report *rep,
+                                              struct hists *self,
                                               const char *evname, FILE *fp)
 {
         size_t ret;
         char unit;
         unsigned long nr_samples = self->stats.nr_events[PERF_RECORD_SAMPLE];
         u64 nr_events = self->stats.total_period;
+        struct perf_evsel *evsel = hists_to_evsel(self);
+        char buf[512];
+        size_t size = sizeof(buf);
+
+        if (perf_evsel__is_group_event(evsel)) {
+                struct perf_evsel *pos;
+
+                perf_evsel__group_desc(evsel, buf, size);
+                evname = buf;
+
+                for_each_group_member(pos, evsel) {
+                        nr_samples += pos->hists.stats.nr_events[PERF_RECORD_SAMPLE];
+                        nr_events += pos->hists.stats.total_period;
+                }
+        }
 
         nr_samples = convert_unit(nr_samples, &unit);
         ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);
         if (evname != NULL)
                 ret += fprintf(fp, " of event '%s'", evname);
 
-        ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
+        if (rep->mem_mode) {
+                ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
+                ret += fprintf(fp, "\n# Sort order   : %s", sort_order);
+        } else
+                ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
         return ret + fprintf(fp, "\n#\n");
 }
 
@@ -319,8 +457,12 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
                 struct hists *hists = &pos->hists;
                 const char *evname = perf_evsel__name(pos);
 
-                hists__fprintf_nr_sample_events(hists, evname, stdout);
-                hists__fprintf(hists, true, 0, 0, stdout);
+                if (symbol_conf.event_group &&
+                    !perf_evsel__is_group_leader(pos))
+                        continue;
+
+                hists__fprintf_nr_sample_events(rep, hists, evname, stdout);
+                hists__fprintf(hists, true, 0, 0, rep->min_percent, stdout);
                 fprintf(stdout, "\n\n");
         }
 
@@ -372,7 +514,7 @@ static int __cmd_report(struct perf_report *rep)
         if (ret)
                 goto out_delete;
 
-        kernel_map = session->host_machine.vmlinux_maps[MAP__FUNCTION];
+        kernel_map = session->machines.host.vmlinux_maps[MAP__FUNCTION];
         kernel_kmap = map__kmap(kernel_map);
         if (kernel_map == NULL ||
             (kernel_map->dso->hit &&
@@ -416,8 +558,16 @@ static int __cmd_report(struct perf_report *rep)
                         hists->symbol_filter_str = rep->symbol_filter_str;
 
                 hists__collapse_resort(hists);
-                hists__output_resort(hists);
                 nr_samples += hists->stats.nr_events[PERF_RECORD_SAMPLE];
+
+                /* Non-group events are considered as leader */
+                if (symbol_conf.event_group &&
+                    !perf_evsel__is_group_leader(pos)) {
+                        struct hists *leader_hists = &pos->leader->hists;
+
+                        hists__match(leader_hists, hists);
+                        hists__link(leader_hists, hists);
+                }
         }
 
         if (nr_samples == 0) {
@@ -425,14 +575,25 @@ static int __cmd_report(struct perf_report *rep)
                 goto out_delete;
         }
 
+        list_for_each_entry(pos, &session->evlist->entries, node)
+                hists__output_resort(&pos->hists);
+
         if (use_browser > 0) {
                 if (use_browser == 1) {
-                        perf_evlist__tui_browse_hists(session->evlist, help,
-                                                      NULL,
-                                                      &session->header.env);
+                        ret = perf_evlist__tui_browse_hists(session->evlist,
+                                                        help, NULL,
+                                                        rep->min_percent,
+                                                        &session->header.env);
+                        /*
+                         * Usually "ret" is the last pressed key, and we only
+                         * care if the key notifies us to switch data file.
+                         */
+                        if (ret != K_SWITCH_INPUT_DATA)
+                                ret = 0;
+
                 } else if (use_browser == 2) {
                         perf_evlist__gtk_browse_hists(session->evlist, help,
-                                                      NULL);
+                                                      NULL, rep->min_percent);
                 }
         } else
                 perf_evlist__tty_browse_hists(session->evlist, rep, help);
@@ -537,7 +698,19 @@ static int
 parse_branch_mode(const struct option *opt __maybe_unused,
                   const char *str __maybe_unused, int unset)
 {
-        sort__branch_mode = !unset;
+        int *branch_mode = opt->value;
+
+        *branch_mode = !unset;
+        return 0;
+}
+
+static int
+parse_percent_limit(const struct option *opt, const char *str,
+                    int unset __maybe_unused)
+{
+        struct perf_report *rep = opt->value;
+
+        rep->min_percent = strtof(str, NULL);
         return 0;
 }
 
@@ -546,6 +719,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         struct perf_session *session;
         struct stat st;
         bool has_br_stack = false;
+        int branch_mode = -1;
         int ret = -1;
         char callchain_default_opt[] = "fractal,0.5,callee";
         const char * const report_usage[] = {
@@ -595,8 +769,10 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_BOOLEAN(0, "stdio", &report.use_stdio,
                     "Use the stdio interface"),
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
-                   "sort by key(s): pid, comm, dso, symbol, parent, dso_to,"
-                   " dso_from, symbol_to, symbol_from, mispredict"),
+                   "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline,"
+                   " dso_to, dso_from, symbol_to, symbol_from, mispredict,"
+                   " weight, local_weight, mem, symbol_daddr, dso_daddr, tlb, "
+                   "snoop, locked"),
         OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
                     "Show sample percentage for different cpu modes"),
         OPT_STRING('p', "parent", &parent_pattern, "regex",
@@ -638,13 +814,22 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
         OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
                     "Show a column with the sum of periods"),
-        OPT_CALLBACK_NOOPT('b', "branch-stack", &sort__branch_mode, "",
+        OPT_BOOLEAN(0, "group", &symbol_conf.event_group,
+                    "Show event group information together"),
+        OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "",
                     "use branch records for histogram filling", parse_branch_mode),
         OPT_STRING(0, "objdump", &objdump_path, "path",
                    "objdump binary to use for disassembly and annotations"),
+        OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
+                    "Disable symbol demangling"),
+        OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),
+        OPT_CALLBACK(0, "percent-limit", &report, "percent",
+                     "Don't show entries under that percent", parse_percent_limit),
         OPT_END()
         };
 
+        perf_config(perf_report_config, &report);
+
         argc = parse_options(argc, argv, options, report_usage, 0);
 
         if (report.use_stdio)
@@ -663,6 +848,16 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                 else
                         input_name = "perf.data";
         }
+
+        if (strcmp(input_name, "-") != 0)
+                setup_browser(true);
+        else {
+                use_browser = 0;
+                perf_hpp__column_enable(PERF_HPP__OVERHEAD);
+                perf_hpp__init();
+        }
+
+repeat:
         session = perf_session__new(input_name, O_RDONLY,
                                     report.force, false, &report.tool);
         if (session == NULL)
@@ -673,11 +868,11 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         has_br_stack = perf_header__has_feat(&session->header,
                                              HEADER_BRANCH_STACK);
 
-        if (sort__branch_mode == -1 && has_br_stack)
-                sort__branch_mode = 1;
+        if (branch_mode == -1 && has_br_stack)
+                sort__mode = SORT_MODE__BRANCH;
 
-        /* sort__branch_mode could be 0 if --no-branch-stack */
-        if (sort__branch_mode == 1) {
+        /* sort__mode could be NORMAL if --no-branch-stack */
+        if (sort__mode == SORT_MODE__BRANCH) {
                 /*
                  * if no sort_order is provided, then specify
                  * branch-mode specific order
@@ -687,18 +882,26 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                                      "dso_to,symbol_to";
 
         }
+        if (report.mem_mode) {
+                if (sort__mode == SORT_MODE__BRANCH) {
+                        fprintf(stderr, "branch and mem mode incompatible\n");
+                        goto error;
+                }
+                sort__mode = SORT_MODE__MEMORY;
 
-        if (strcmp(input_name, "-") != 0)
-                setup_browser(true);
-        else {
-                use_browser = 0;
-                perf_hpp__init();
+                /*
+                 * if no sort_order is provided, then specify
+                 * branch-mode specific order
+                 */
+                if (sort_order == default_sort_order)
+                        sort_order = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
         }
 
-        setup_sorting(report_usage, options);
+        if (setup_sorting() < 0)
+                usage_with_options(report_usage, options);
 
         /*
-         * Only in the newt browser we are doing integrated annotation,
+         * Only in the TUI browser we are doing integrated annotation,
          * so don't allocate extra space that won't be used in the stdio
          * implementation.
          */
@@ -750,19 +953,15 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                 report.symbol_filter_str = argv[0];
         }
 
-        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
-
-        if (sort__branch_mode == 1) {
-                sort_entry__setup_elide(&sort_dso_from, symbol_conf.dso_from_list, "dso_from", stdout);
-                sort_entry__setup_elide(&sort_dso_to, symbol_conf.dso_to_list, "dso_to", stdout);
-                sort_entry__setup_elide(&sort_sym_from, symbol_conf.sym_from_list, "sym_from", stdout);
-                sort_entry__setup_elide(&sort_sym_to, symbol_conf.sym_to_list, "sym_to", stdout);
-        } else {
-                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
-                sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
-        }
+        sort__setup_elide(stdout);
 
         ret = __cmd_report(&report);
+        if (ret == K_SWITCH_INPUT_DATA) {
+                perf_session__delete(session);
+                goto repeat;
+        } else
+                ret = 0;
+
 error:
         perf_session__delete(session);
         return ret;
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index cc28b85dabd5..2da2a6ca22bf 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -1475,9 +1475,9 @@ static int perf_sched__read_events(struct perf_sched *sched, bool destroy,
                         goto out_delete;
                 }
 
-                sched->nr_events      = session->hists.stats.nr_events[0];
-                sched->nr_lost_events = session->hists.stats.total_lost;
-                sched->nr_lost_chunks = session->hists.stats.nr_events[PERF_RECORD_LOST];
+                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];
         }
 
         if (destroy)
@@ -1671,7 +1671,6 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
                         .sample          = perf_sched__process_tracepoint_sample,
                         .comm            = perf_event__process_comm,
                         .lost            = perf_event__process_lost,
-                        .exit            = perf_event__process_exit,
                         .fork            = perf_event__process_fork,
                         .ordered_samples = true,
                 },
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index b363e7b292b2..92d4658f56fb 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -692,7 +692,7 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
                             const char *arg, int unset __maybe_unused)
 {
         char *tok;
-        int i, imax = sizeof(all_output_options) / sizeof(struct output_option);
+        int i, imax = ARRAY_SIZE(all_output_options);
         int j;
         int rc = 0;
         char *str = strdup(arg);
@@ -909,18 +909,6 @@ static const char *ends_with(const char *str, const char *suffix)
         return NULL;
 }
 
-static char *ltrim(char *str)
-{
-        int len = strlen(str);
-
-        while (len && isspace(*str)) {
-                len--;
-                str++;
-        }
-
-        return str;
-}
-
 static int read_script_info(struct script_desc *desc, const char *filename)
 {
         char line[BUFSIZ], *p;
@@ -1487,7 +1475,8 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                         return -1;
         }
 
-        perf_session__fprintf_info(session, stdout, show_full_info);
+        if (!script_name && !generate_script_lang)
+                perf_session__fprintf_info(session, stdout, show_full_info);
 
         if (!no_callchain)
                 symbol_conf.use_callchain = true;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index c247faca7127..7e910bab1097 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -65,16 +65,28 @@
 #define CNTR_NOT_SUPPORTED      "<not supported>"
 #define CNTR_NOT_COUNTED        "<not counted>"
 
+static void print_stat(int argc, const char **argv);
+static void print_counter_aggr(struct perf_evsel *counter, char *prefix);
+static void print_counter(struct perf_evsel *counter, char *prefix);
+static void print_aggr(char *prefix);
+
 static struct perf_evlist       *evsel_list;
 
 static struct perf_target       target = {
         .uid    = UINT_MAX,
 };
 
+enum aggr_mode {
+        AGGR_NONE,
+        AGGR_GLOBAL,
+        AGGR_SOCKET,
+        AGGR_CORE,
+};
+
 static int                      run_count                       =  1;
 static bool                     no_inherit                      = false;
 static bool                     scale                           =  true;
-static bool                     no_aggr                         = false;
+static enum aggr_mode           aggr_mode                       = AGGR_GLOBAL;
 static pid_t                    child_pid                       = -1;
 static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
@@ -87,6 +99,11 @@ static FILE			*output				= NULL;
 static const char               *pre_cmd                        = NULL;
 static const char               *post_cmd                       = NULL;
 static bool                     sync_run                        = false;
+static unsigned int             interval                        = 0;
+static bool                     forever                         = false;
+static struct timespec          ref_time;
+static struct cpu_map           *aggr_map;
+static int                      (*aggr_get_id)(struct cpu_map *m, int cpu);
 
 static volatile int done = 0;
 
@@ -94,6 +111,33 @@ struct perf_stat {
         struct stats      res_stats[3];
 };
 
+static inline void diff_timespec(struct timespec *r, struct timespec *a,
+                                 struct timespec *b)
+{
+        r->tv_sec = a->tv_sec - b->tv_sec;
+        if (a->tv_nsec < b->tv_nsec) {
+                r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
+                r->tv_sec--;
+        } else {
+                r->tv_nsec = a->tv_nsec - b->tv_nsec ;
+        }
+}
+
+static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel)
+{
+        return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus;
+}
+
+static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel)
+{
+        return perf_evsel__cpus(evsel)->nr;
+}
+
+static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
+{
+        memset(evsel->priv, 0, sizeof(struct perf_stat));
+}
+
 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 {
         evsel->priv = zalloc(sizeof(struct perf_stat));
@@ -106,14 +150,56 @@ static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
         evsel->priv = NULL;
 }
 
-static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel)
+static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel)
 {
-        return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus;
+        void *addr;
+        size_t sz;
+
+        sz = sizeof(*evsel->counts) +
+             (perf_evsel__nr_cpus(evsel) * sizeof(struct perf_counts_values));
+
+        addr = zalloc(sz);
+        if (!addr)
+                return -ENOMEM;
+
+        evsel->prev_raw_counts =  addr;
+
+        return 0;
 }
 
-static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel)
+static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel)
 {
-        return perf_evsel__cpus(evsel)->nr;
+        free(evsel->prev_raw_counts);
+        evsel->prev_raw_counts = NULL;
+}
+
+static void perf_evlist__free_stats(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                perf_evsel__free_stat_priv(evsel);
+                perf_evsel__free_counts(evsel);
+                perf_evsel__free_prev_raw_counts(evsel);
+        }
+}
+
+static int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                if (perf_evsel__alloc_stat_priv(evsel) < 0 ||
+                    perf_evsel__alloc_counts(evsel, perf_evsel__nr_cpus(evsel)) < 0 ||
+                    (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel) < 0))
+                        goto out_free;
+        }
+
+        return 0;
+
+out_free:
+        perf_evlist__free_stats(evlist);
+        return -1;
 }
 
 static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
@@ -129,11 +215,32 @@ static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
 static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
 static struct stats walltime_nsecs_stats;
 
+static void perf_stat__reset_stats(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                perf_evsel__reset_stat_priv(evsel);
+                perf_evsel__reset_counts(evsel, perf_evsel__nr_cpus(evsel));
+        }
+
+        memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats));
+        memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats));
+        memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats));
+        memset(runtime_stalled_cycles_back_stats, 0, sizeof(runtime_stalled_cycles_back_stats));
+        memset(runtime_branches_stats, 0, sizeof(runtime_branches_stats));
+        memset(runtime_cacherefs_stats, 0, sizeof(runtime_cacherefs_stats));
+        memset(runtime_l1_dcache_stats, 0, sizeof(runtime_l1_dcache_stats));
+        memset(runtime_l1_icache_stats, 0, sizeof(runtime_l1_icache_stats));
+        memset(runtime_ll_cache_stats, 0, sizeof(runtime_ll_cache_stats));
+        memset(runtime_itlb_cache_stats, 0, sizeof(runtime_itlb_cache_stats));
+        memset(runtime_dtlb_cache_stats, 0, sizeof(runtime_dtlb_cache_stats));
+        memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats));
+}
+
 static int create_perf_stat_counter(struct perf_evsel *evsel)
 {
         struct perf_event_attr *attr = &evsel->attr;
-        bool exclude_guest_missing = false;
-        int ret;
 
         if (scale)
                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
@@ -141,38 +248,16 @@ static int create_perf_stat_counter(struct perf_evsel *evsel)
 
         attr->inherit = !no_inherit;
 
-retry:
-        if (exclude_guest_missing)
-                evsel->attr.exclude_guest = evsel->attr.exclude_host = 0;
-
-        if (perf_target__has_cpu(&target)) {
-                ret = perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
-                if (ret)
-                        goto check_ret;
-                return 0;
-        }
+        if (perf_target__has_cpu(&target))
+                return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel));
 
         if (!perf_target__has_task(&target) &&
-            !perf_evsel__is_group_member(evsel)) {
+            perf_evsel__is_group_leader(evsel)) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
 
-        ret = perf_evsel__open_per_thread(evsel, evsel_list->threads);
-        if (!ret)
-                return 0;
-        /* fall through */
-check_ret:
-        if (ret && errno == EINVAL) {
-                if (!exclude_guest_missing &&
-                    (evsel->attr.exclude_guest || evsel->attr.exclude_host)) {
-                        pr_debug("Old kernel, cannot exclude "
-                                 "guest or host samples.\n");
-                        exclude_guest_missing = true;
-                        goto retry;
-                }
-        }
-        return ret;
+        return perf_evsel__open_per_thread(evsel, evsel_list->threads);
 }
 
 /*
@@ -229,7 +314,7 @@ static int read_counter_aggr(struct perf_evsel *counter)
         int i;
 
         if (__perf_evsel__read(counter, perf_evsel__nr_cpus(counter),
-                               evsel_list->threads->nr, scale) < 0)
+                               thread_map__nr(evsel_list->threads), scale) < 0)
                 return -1;
 
         for (i = 0; i < 3; i++)
@@ -269,64 +354,91 @@ static int read_counter(struct perf_evsel *counter)
         return 0;
 }
 
-static int __run_perf_stat(int argc __maybe_unused, const char **argv)
+static void print_interval(void)
 {
-        unsigned long long t0, t1;
+        static int num_print_interval;
         struct perf_evsel *counter;
-        int status = 0;
-        int child_ready_pipe[2], go_pipe[2];
-        const bool forks = (argc > 0);
-        char buf;
+        struct perf_stat *ps;
+        struct timespec ts, rs;
+        char prefix[64];
 
-        if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
-                perror("failed to create pipes");
-                return -1;
+        if (aggr_mode == AGGR_GLOBAL) {
+                list_for_each_entry(counter, &evsel_list->entries, node) {
+                        ps = counter->priv;
+                        memset(ps->res_stats, 0, sizeof(ps->res_stats));
+                        read_counter_aggr(counter);
+                }
+        } else  {
+                list_for_each_entry(counter, &evsel_list->entries, node) {
+                        ps = counter->priv;
+                        memset(ps->res_stats, 0, sizeof(ps->res_stats));
+                        read_counter(counter);
+                }
         }
 
-        if (forks) {
-                if ((child_pid = fork()) < 0)
-                        perror("failed to fork");
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        diff_timespec(&rs, &ts, &ref_time);
+        sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep);
+
+        if (num_print_interval == 0 && !csv_output) {
+                switch (aggr_mode) {
+                case AGGR_SOCKET:
+                        fprintf(output, "#           time socket cpus             counts events\n");
+                        break;
+                case AGGR_CORE:
+                        fprintf(output, "#           time core         cpus             counts events\n");
+                        break;
+                case AGGR_NONE:
+                        fprintf(output, "#           time CPU                 counts events\n");
+                        break;
+                case AGGR_GLOBAL:
+                default:
+                        fprintf(output, "#           time             counts events\n");
+                }
+        }
 
-                if (!child_pid) {
-                        close(child_ready_pipe[0]);
-                        close(go_pipe[1]);
-                        fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+        if (++num_print_interval == 25)
+                num_print_interval = 0;
 
-                        /*
-                         * Do a dummy execvp to get the PLT entry resolved,
-                         * so we avoid the resolver overhead on the real
-                         * execvp call.
-                         */
-                        execvp("", (char **)argv);
-
-                        /*
-                         * Tell the parent we're ready to go
-                         */
-                        close(child_ready_pipe[1]);
+        switch (aggr_mode) {
+        case AGGR_CORE:
+        case AGGR_SOCKET:
+                print_aggr(prefix);
+                break;
+        case AGGR_NONE:
+                list_for_each_entry(counter, &evsel_list->entries, node)
+                        print_counter(counter, prefix);
+                break;
+        case AGGR_GLOBAL:
+        default:
+                list_for_each_entry(counter, &evsel_list->entries, node)
+                        print_counter_aggr(counter, prefix);
+        }
+}
 
-                        /*
-                         * Wait until the parent tells us to go.
-                         */
-                        if (read(go_pipe[0], &buf, 1) == -1)
-                                perror("unable to read pipe");
+static int __run_perf_stat(int argc, const char **argv)
+{
+        char msg[512];
+        unsigned long long t0, t1;
+        struct perf_evsel *counter;
+        struct timespec ts;
+        int status = 0;
+        const bool forks = (argc > 0);
 
-                        execvp(argv[0], (char **)argv);
+        if (interval) {
+                ts.tv_sec  = interval / 1000;
+                ts.tv_nsec = (interval % 1000) * 1000000;
+        } else {
+                ts.tv_sec  = 1;
+                ts.tv_nsec = 0;
+        }
 
-                        perror(argv[0]);
-                        exit(-1);
+        if (forks) {
+                if (perf_evlist__prepare_workload(evsel_list, &target, argv,
+                                                  false, false) < 0) {
+                        perror("failed to prepare workload");
+                        return -1;
                 }
-
-                if (perf_target__none(&target))
-                        evsel_list->threads->map[0] = child_pid;
-
-                /*
-                 * Wait for the child to be ready to exec.
-                 */
-                close(child_ready_pipe[1]);
-                close(go_pipe[0]);
-                if (read(child_ready_pipe[0], &buf, 1) == -1)
-                        perror("unable to read pipe");
-                close(child_ready_pipe[0]);
         }
 
         if (group)
@@ -348,20 +460,13 @@ static int __run_perf_stat(int argc __maybe_unused, const char **argv)
                                 continue;
                         }
 
-                        if (errno == EPERM || errno == EACCES) {
-                                error("You may not have permission to collect %sstats.\n"
-                                      "\t Consider tweaking"
-                                      " /proc/sys/kernel/perf_event_paranoid or running as root.",
-                                      target.system_wide ? "system-wide " : "");
-                        } else {
-                                error("open_counter returned with %d (%s). "
-                                      "/bin/dmesg may provide additional information.\n",
-                                       errno, strerror(errno));
-                        }
+                        perf_evsel__open_strerror(counter, &target,
+                                                  errno, msg, sizeof(msg));
+                        ui__error("%s\n", msg);
+
                         if (child_pid != -1)
                                 kill(child_pid, SIGTERM);
 
-                        pr_err("Not all events could be opened.\n");
                         return -1;
                 }
                 counter->supported = true;
@@ -377,30 +482,42 @@ static int __run_perf_stat(int argc __maybe_unused, const char **argv)
          * Enable counters and exec the command:
          */
         t0 = rdclock();
+        clock_gettime(CLOCK_MONOTONIC, &ref_time);
 
         if (forks) {
-                close(go_pipe[1]);
+                perf_evlist__start_workload(evsel_list);
+
+                if (interval) {
+                        while (!waitpid(child_pid, &status, WNOHANG)) {
+                                nanosleep(&ts, NULL);
+                                print_interval();
+                        }
+                }
                 wait(&status);
                 if (WIFSIGNALED(status))
                         psignal(WTERMSIG(status), argv[0]);
         } else {
-                while(!done) sleep(1);
+                while (!done) {
+                        nanosleep(&ts, NULL);
+                        if (interval)
+                                print_interval();
+                }
         }
 
         t1 = rdclock();
 
         update_stats(&walltime_nsecs_stats, t1 - t0);
 
-        if (no_aggr) {
+        if (aggr_mode == AGGR_GLOBAL) {
                 list_for_each_entry(counter, &evsel_list->entries, node) {
-                        read_counter(counter);
-                        perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
+                        read_counter_aggr(counter);
+                        perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
+                                             thread_map__nr(evsel_list->threads));
                 }
         } else {
                 list_for_each_entry(counter, &evsel_list->entries, node) {
-                        read_counter_aggr(counter);
-                        perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
-                                             evsel_list->threads->nr);
+                        read_counter(counter);
+                        perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
                 }
         }
 
@@ -454,23 +571,52 @@ static void print_noise(struct perf_evsel *evsel, double avg)
         print_noise_pct(stddev_stats(&ps->res_stats[0]), avg);
 }
 
-static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
+static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
+{
+        switch (aggr_mode) {
+        case AGGR_CORE:
+                fprintf(output, "S%d-C%*d%s%*d%s",
+                        cpu_map__id_to_socket(id),
+                        csv_output ? 0 : -8,
+                        cpu_map__id_to_cpu(id),
+                        csv_sep,
+                        csv_output ? 0 : 4,
+                        nr,
+                        csv_sep);
+                break;
+        case AGGR_SOCKET:
+                fprintf(output, "S%*d%s%*d%s",
+                        csv_output ? 0 : -5,
+                        id,
+                        csv_sep,
+                        csv_output ? 0 : 4,
+                        nr,
+                        csv_sep);
+                        break;
+        case AGGR_NONE:
+                fprintf(output, "CPU%*d%s",
+                        csv_output ? 0 : -4,
+                        perf_evsel__cpus(evsel)->map[id], csv_sep);
+                break;
+        case AGGR_GLOBAL:
+        default:
+                break;
+        }
+}
+
+static void nsec_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
 {
         double msecs = avg / 1e6;
-        char cpustr[16] = { '\0', };
-        const char *fmt = csv_output ? "%s%.6f%s%s" : "%s%18.6f%s%-25s";
+        const char *fmt = csv_output ? "%.6f%s%s" : "%18.6f%s%-25s";
 
-        if (no_aggr)
-                sprintf(cpustr, "CPU%*d%s",
-                        csv_output ? 0 : -4,
-                        perf_evsel__cpus(evsel)->map[cpu], csv_sep);
+        aggr_printout(evsel, cpu, nr);
 
-        fprintf(output, fmt, cpustr, msecs, csv_sep, perf_evsel__name(evsel));
+        fprintf(output, fmt, msecs, csv_sep, perf_evsel__name(evsel));
 
         if (evsel->cgrp)
                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 
-        if (csv_output)
+        if (csv_output || interval)
                 return;
 
         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
@@ -659,37 +805,33 @@ static void print_ll_cache_misses(int cpu,
         fprintf(output, " of all LL-cache hits   ");
 }
 
-static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
+static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
 {
         double total, ratio = 0.0;
-        char cpustr[16] = { '\0', };
         const char *fmt;
 
         if (csv_output)
-                fmt = "%s%.0f%s%s";
+                fmt = "%.0f%s%s";
         else if (big_num)
-                fmt = "%s%'18.0f%s%-25s";
+                fmt = "%'18.0f%s%-25s";
         else
-                fmt = "%s%18.0f%s%-25s";
+                fmt = "%18.0f%s%-25s";
 
-        if (no_aggr)
-                sprintf(cpustr, "CPU%*d%s",
-                        csv_output ? 0 : -4,
-                        perf_evsel__cpus(evsel)->map[cpu], csv_sep);
-        else
+        aggr_printout(evsel, cpu, nr);
+
+        if (aggr_mode == AGGR_GLOBAL)
                 cpu = 0;
 
-        fprintf(output, fmt, cpustr, avg, csv_sep, perf_evsel__name(evsel));
+        fprintf(output, fmt, avg, csv_sep, perf_evsel__name(evsel));
 
         if (evsel->cgrp)
                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 
-        if (csv_output)
+        if (csv_output || interval)
                 return;
 
         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
                 total = avg_stats(&runtime_cycles_stats[cpu]);
-
                 if (total)
                         ratio = avg / total;
 
@@ -779,16 +921,80 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
         }
 }
 
+static void print_aggr(char *prefix)
+{
+        struct perf_evsel *counter;
+        int cpu, s, s2, id, nr;
+        u64 ena, run, val;
+
+        if (!(aggr_map || aggr_get_id))
+                return;
+
+        for (s = 0; s < aggr_map->nr; s++) {
+                id = aggr_map->map[s];
+                list_for_each_entry(counter, &evsel_list->entries, node) {
+                        val = ena = run = 0;
+                        nr = 0;
+                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                                s2 = aggr_get_id(evsel_list->cpus, cpu);
+                                if (s2 != id)
+                                        continue;
+                                val += counter->counts->cpu[cpu].val;
+                                ena += counter->counts->cpu[cpu].ena;
+                                run += counter->counts->cpu[cpu].run;
+                                nr++;
+                        }
+                        if (prefix)
+                                fprintf(output, "%s", prefix);
+
+                        if (run == 0 || ena == 0) {
+                                aggr_printout(counter, cpu, nr);
+
+                                fprintf(output, "%*s%s%*s",
+                                        csv_output ? 0 : 18,
+                                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
+                                        csv_sep,
+                                        csv_output ? 0 : -24,
+                                        perf_evsel__name(counter));
+
+                                if (counter->cgrp)
+                                        fprintf(output, "%s%s",
+                                                csv_sep, counter->cgrp->name);
+
+                                fputc('\n', output);
+                                continue;
+                        }
+
+                        if (nsec_counter(counter))
+                                nsec_printout(id, nr, counter, val);
+                        else
+                                abs_printout(id, nr, counter, val);
+
+                        if (!csv_output) {
+                                print_noise(counter, 1.0);
+
+                                if (run != ena)
+                                        fprintf(output, "  (%.2f%%)",
+                                                100.0 * run / ena);
+                        }
+                        fputc('\n', output);
+                }
+        }
+}
+
 /*
  * Print out the results of a single counter:
  * aggregated counts in system-wide mode
  */
-static void print_counter_aggr(struct perf_evsel *counter)
+static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
 {
         struct perf_stat *ps = counter->priv;
         double avg = avg_stats(&ps->res_stats[0]);
         int scaled = counter->counts->scaled;
 
+        if (prefix)
+                fprintf(output, "%s", prefix);
+
         if (scaled == -1) {
                 fprintf(output, "%*s%s%*s",
                         csv_output ? 0 : 18,
@@ -805,9 +1011,9 @@ static void print_counter_aggr(struct perf_evsel *counter)
         }
 
         if (nsec_counter(counter))
-                nsec_printout(-1, counter, avg);
+                nsec_printout(-1, 0, counter, avg);
         else
-                abs_printout(-1, counter, avg);
+                abs_printout(-1, 0, counter, avg);
 
         print_noise(counter, avg);
 
@@ -831,7 +1037,7 @@ static void print_counter_aggr(struct perf_evsel *counter)
  * Print out the results of a single counter:
  * does not use aggregated count in system-wide
  */
-static void print_counter(struct perf_evsel *counter)
+static void print_counter(struct perf_evsel *counter, char *prefix)
 {
         u64 ena, run, val;
         int cpu;
@@ -840,6 +1046,10 @@ static void print_counter(struct perf_evsel *counter)
                 val = counter->counts->cpu[cpu].val;
                 ena = counter->counts->cpu[cpu].ena;
                 run = counter->counts->cpu[cpu].run;
+
+                if (prefix)
+                        fprintf(output, "%s", prefix);
+
                 if (run == 0 || ena == 0) {
                         fprintf(output, "CPU%*d%s%*s%s%*s",
                                 csv_output ? 0 : -4,
@@ -859,9 +1069,9 @@ static void print_counter(struct perf_evsel *counter)
                 }
 
                 if (nsec_counter(counter))
-                        nsec_printout(cpu, counter, val);
+                        nsec_printout(cpu, 0, counter, val);
                 else
-                        abs_printout(cpu, counter, val);
+                        abs_printout(cpu, 0, counter, val);
 
                 if (!csv_output) {
                         print_noise(counter, 1.0);
@@ -899,12 +1109,21 @@ static void print_stat(int argc, const char **argv)
                 fprintf(output, ":\n\n");
         }
 
-        if (no_aggr) {
+        switch (aggr_mode) {
+        case AGGR_CORE:
+        case AGGR_SOCKET:
+                print_aggr(NULL);
+                break;
+        case AGGR_GLOBAL:
                 list_for_each_entry(counter, &evsel_list->entries, node)
-                        print_counter(counter);
-        } else {
+                        print_counter_aggr(counter, NULL);
+                break;
+        case AGGR_NONE:
                 list_for_each_entry(counter, &evsel_list->entries, node)
-                        print_counter_aggr(counter);
+                        print_counter(counter, NULL);
+                break;
+        default:
+                break;
         }
 
         if (!csv_output) {
@@ -925,7 +1144,7 @@ static volatile int signr = -1;
 
 static void skip_signal(int signo)
 {
-        if(child_pid == -1)
+        if ((child_pid == -1) || interval)
                 done = 1;
 
         signr = signo;
@@ -950,6 +1169,32 @@ static int stat__set_big_num(const struct option *opt __maybe_unused,
         return 0;
 }
 
+static int perf_stat_init_aggr_mode(void)
+{
+        switch (aggr_mode) {
+        case AGGR_SOCKET:
+                if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) {
+                        perror("cannot build socket map");
+                        return -1;
+                }
+                aggr_get_id = cpu_map__get_socket;
+                break;
+        case AGGR_CORE:
+                if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) {
+                        perror("cannot build core map");
+                        return -1;
+                }
+                aggr_get_id = cpu_map__get_core;
+                break;
+        case AGGR_NONE:
+        case AGGR_GLOBAL:
+        default:
+                break;
+        }
+        return 0;
+}
+
+
 /*
  * Add default attributes, if there were no attributes specified or
  * if -d/--detailed, -d -d or -d -d -d is used:
@@ -1120,7 +1365,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_INTEGER('r', "repeat", &run_count,
-                    "repeat command and print average + stddev (max: 100)"),
+                    "repeat command and print average + stddev (max: 100, forever: 0)"),
         OPT_BOOLEAN('n', "null", &null_run,
                     "null run - dont start any counters"),
         OPT_INCR('d', "detailed", &detailed_run,
@@ -1132,7 +1377,8 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
                            stat__set_big_num),
         OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
                     "list of cpus to monitor in system-wide"),
-        OPT_BOOLEAN('A', "no-aggr", &no_aggr, "disable CPU count aggregation"),
+        OPT_SET_UINT('A', "no-aggr", &aggr_mode,
+                    "disable CPU count aggregation", AGGR_NONE),
         OPT_STRING('x', "field-separator", &csv_sep, "separator",
                    "print counts with custom separator"),
         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
@@ -1145,19 +1391,24 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
                         "command to run prior to the measured command"),
         OPT_STRING(0, "post", &post_cmd, "command",
                         "command to run after to the measured command"),
+        OPT_UINTEGER('I', "interval-print", &interval,
+                    "print counts at regular interval in ms (>= 100)"),
+        OPT_SET_UINT(0, "per-socket", &aggr_mode,
+                     "aggregate counts per processor socket", AGGR_SOCKET),
+        OPT_SET_UINT(0, "per-core", &aggr_mode,
+                     "aggregate counts per physical processor core", AGGR_CORE),
         OPT_END()
         };
         const char * const stat_usage[] = {
                 "perf stat [<options>] [<command>]",
                 NULL
         };
-        struct perf_evsel *pos;
         int status = -ENOMEM, run_idx;
         const char *mode;
 
         setlocale(LC_ALL, "");
 
-        evsel_list = perf_evlist__new(NULL, NULL);
+        evsel_list = perf_evlist__new();
         if (evsel_list == NULL)
                 return -ENOMEM;
 
@@ -1220,15 +1471,21 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
 
         if (!argc && !perf_target__has_task(&target))
                 usage_with_options(stat_usage, options);
-        if (run_count <= 0)
+        if (run_count < 0) {
                 usage_with_options(stat_usage, options);
+        } else if (run_count == 0) {
+                forever = true;
+                run_count = 1;
+        }
 
         /* no_aggr, cgroup are for system-wide only */
-        if ((no_aggr || nr_cgroups) && !perf_target__has_cpu(&target)) {
+        if ((aggr_mode != AGGR_GLOBAL || nr_cgroups)
+             && !perf_target__has_cpu(&target)) {
                 fprintf(stderr, "both cgroup and no-aggregation "
                         "modes only available in system-wide mode\n");
 
                 usage_with_options(stat_usage, options);
+                return -1;
         }
 
         if (add_default_attributes())
@@ -1245,13 +1502,18 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
                 usage_with_options(stat_usage, options);
                 return -1;
         }
-
-        list_for_each_entry(pos, &evsel_list->entries, node) {
-                if (perf_evsel__alloc_stat_priv(pos) < 0 ||
-                    perf_evsel__alloc_counts(pos, perf_evsel__nr_cpus(pos)) < 0)
-                        goto out_free_fd;
+        if (interval && interval < 100) {
+                pr_err("print interval must be >= 100ms\n");
+                usage_with_options(stat_usage, options);
+                return -1;
         }
 
+        if (perf_evlist__alloc_stats(evsel_list, interval))
+                goto out_free_maps;
+
+        if (perf_stat_init_aggr_mode())
+                goto out;
+
         /*
          * We dont want to block the signals - that would cause
          * child tasks to inherit that and Ctrl-C would not work.
@@ -1259,24 +1521,30 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
          * task, but being ignored by perf stat itself:
          */
         atexit(sig_atexit);
-        signal(SIGINT,  skip_signal);
+        if (!forever)
+                signal(SIGINT,  skip_signal);
+        signal(SIGCHLD, skip_signal);
         signal(SIGALRM, skip_signal);
         signal(SIGABRT, skip_signal);
 
         status = 0;
-        for (run_idx = 0; run_idx < run_count; run_idx++) {
+        for (run_idx = 0; forever || run_idx < run_count; run_idx++) {
                 if (run_count != 1 && verbose)
                         fprintf(output, "[ perf stat: executing run #%d ... ]\n",
                                 run_idx + 1);
 
                 status = run_perf_stat(argc, argv);
+                if (forever && status != -1) {
+                        print_stat(argc, argv);
+                        perf_stat__reset_stats(evsel_list);
+                }
         }
 
-        if (status != -1)
+        if (!forever && status != -1 && !interval)
                 print_stat(argc, argv);
-out_free_fd:
-        list_for_each_entry(pos, &evsel_list->entries, node)
-                perf_evsel__free_stat_priv(pos);
+
+        perf_evlist__free_stats(evsel_list);
+out_free_maps:
         perf_evlist__delete_maps(evsel_list);
 out:
         perf_evlist__delete(evsel_list);
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index c9ff3950cd4b..f036af9b6f09 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -68,32 +68,13 @@
 #include <linux/unistd.h>
 #include <linux/types.h>
 
-void get_term_dimensions(struct winsize *ws)
-{
-        char *s = getenv("LINES");
-
-        if (s != NULL) {
-                ws->ws_row = atoi(s);
-                s = getenv("COLUMNS");
-                if (s != NULL) {
-                        ws->ws_col = atoi(s);
-                        if (ws->ws_row && ws->ws_col)
-                                return;
-                }
-        }
-#ifdef TIOCGWINSZ
-        if (ioctl(1, TIOCGWINSZ, ws) == 0 &&
-            ws->ws_row && ws->ws_col)
-                return;
-#endif
-        ws->ws_row = 25;
-        ws->ws_col = 80;
-}
+static volatile int done;
+
+#define HEADER_LINE_NR  5
 
 static void perf_top__update_print_entries(struct perf_top *top)
 {
-        if (top->print_entries > 9)
-                top->print_entries -= 9;
+        top->print_entries = top->winsize.ws_row - HEADER_LINE_NR;
 }
 
 static void perf_top__sig_winch(int sig __maybe_unused,
@@ -102,13 +83,6 @@ static void perf_top__sig_winch(int sig __maybe_unused,
         struct perf_top *top = arg;
 
         get_term_dimensions(&top->winsize);
-        if (!top->print_entries
-            || (top->print_entries+4) > top->winsize.ws_row) {
-                top->print_entries = top->winsize.ws_row;
-        } else {
-                top->print_entries += 4;
-                top->winsize.ws_row = top->print_entries;
-        }
         perf_top__update_print_entries(top);
 }
 
@@ -251,7 +225,7 @@ static void perf_top__show_details(struct perf_top *top)
         printf("Showing %s for %s\n", perf_evsel__name(top->sym_evsel), symbol->name);
         printf("  Events  Pcnt (>=%d%%)\n", top->sym_pcnt_filter);
 
-        more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel->idx,
+        more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel,
                                        0, top->sym_pcnt_filter, top->print_entries, 4);
         if (top->zero)
                 symbol__annotate_zero_histogram(symbol, top->sym_evsel->idx);
@@ -271,7 +245,11 @@ static struct hist_entry *perf_evsel__add_hist_entry(struct perf_evsel *evsel,
 {
         struct hist_entry *he;
 
-        he = __hists__add_entry(&evsel->hists, al, NULL, sample->period);
+        pthread_mutex_lock(&evsel->hists.lock);
+        he = __hists__add_entry(&evsel->hists, al, NULL, sample->period,
+                                sample->weight);
+        pthread_mutex_unlock(&evsel->hists.lock);
+
         if (he == NULL)
                 return NULL;
 
@@ -309,16 +287,17 @@ static void perf_top__print_sym_table(struct perf_top *top)
                 return;
         }
 
-        hists__collapse_resort_threaded(&top->sym_evsel->hists);
-        hists__output_resort_threaded(&top->sym_evsel->hists);
-        hists__decay_entries_threaded(&top->sym_evsel->hists,
-                                      top->hide_user_symbols,
-                                      top->hide_kernel_symbols);
+        hists__collapse_resort(&top->sym_evsel->hists);
+        hists__output_resort(&top->sym_evsel->hists);
+        hists__decay_entries(&top->sym_evsel->hists,
+                             top->hide_user_symbols,
+                             top->hide_kernel_symbols);
         hists__output_recalc_col_len(&top->sym_evsel->hists,
-                                     top->winsize.ws_row - 3);
+                                     top->print_entries - printed);
         putchar('\n');
         hists__fprintf(&top->sym_evsel->hists, false,
-                       top->winsize.ws_row - 4 - printed, win_width, stdout);
+                       top->print_entries - printed, win_width,
+                       top->min_percent, stdout);
 }
 
 static void prompt_integer(int *target, const char *msg)
@@ -453,8 +432,10 @@ static int perf_top__key_mapped(struct perf_top *top, int c)
         return 0;
 }
 
-static void perf_top__handle_keypress(struct perf_top *top, int c)
+static bool perf_top__handle_keypress(struct perf_top *top, int c)
 {
+        bool ret = true;
+
         if (!perf_top__key_mapped(top, c)) {
                 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
                 struct termios tc, save;
@@ -475,7 +456,7 @@ static void perf_top__handle_keypress(struct perf_top *top, int c)
 
                 tcsetattr(0, TCSAFLUSH, &save);
                 if (!perf_top__key_mapped(top, c))
-                        return;
+                        return ret;
         }
 
         switch (c) {
@@ -494,7 +475,6 @@ static void perf_top__handle_keypress(struct perf_top *top, int c)
                                 perf_top__sig_winch(SIGWINCH, NULL, top);
                                 sigaction(SIGWINCH, &act, NULL);
                         } else {
-                                perf_top__sig_winch(SIGWINCH, NULL, top);
                                 signal(SIGWINCH, SIG_DFL);
                         }
                         break;
@@ -537,7 +517,8 @@ static void perf_top__handle_keypress(struct perf_top *top, int c)
                         printf("exiting.\n");
                         if (top->dump_symtab)
                                 perf_session__fprintf_dsos(top->session, stderr);
-                        exit(0);
+                        ret = false;
+                        break;
                 case 's':
                         perf_top__prompt_symbol(top, "Enter details symbol");
                         break;
@@ -560,6 +541,8 @@ static void perf_top__handle_keypress(struct perf_top *top, int c)
                 default:
                         break;
         }
+
+        return ret;
 }
 
 static void perf_top__sort_new_samples(void *arg)
@@ -570,11 +553,11 @@ static void perf_top__sort_new_samples(void *arg)
         if (t->evlist->selected != NULL)
                 t->sym_evsel = t->evlist->selected;
 
-        hists__collapse_resort_threaded(&t->sym_evsel->hists);
-        hists__output_resort_threaded(&t->sym_evsel->hists);
-        hists__decay_entries_threaded(&t->sym_evsel->hists,
-                                      t->hide_user_symbols,
-                                      t->hide_kernel_symbols);
+        hists__collapse_resort(&t->sym_evsel->hists);
+        hists__output_resort(&t->sym_evsel->hists);
+        hists__decay_entries(&t->sym_evsel->hists,
+                             t->hide_user_symbols,
+                             t->hide_kernel_symbols);
 }
 
 static void *display_thread_tui(void *arg)
@@ -596,13 +579,12 @@ static void *display_thread_tui(void *arg)
          * via --uid.
          */
         list_for_each_entry(pos, &top->evlist->entries, node)
-                pos->hists.uid_filter_str = top->target.uid_str;
+                pos->hists.uid_filter_str = top->record_opts.target.uid_str;
 
-        perf_evlist__tui_browse_hists(top->evlist, help, &hbt,
+        perf_evlist__tui_browse_hists(top->evlist, help, &hbt, top->min_percent,
                                       &top->session->header.env);
 
-        exit_browser(0);
-        exit(0);
+        done = 1;
         return NULL;
 }
 
@@ -626,7 +608,7 @@ repeat:
         /* trash return*/
         getc(stdin);
 
-        while (1) {
+        while (!done) {
                 perf_top__print_sym_table(top);
                 /*
                  * Either timeout expired or we got an EINTR due to SIGWINCH,
@@ -640,15 +622,14 @@ repeat:
                                 continue;
                         /* Fall trhu */
                 default:
-                        goto process_hotkey;
+                        c = getc(stdin);
+                        tcsetattr(0, TCSAFLUSH, &save);
+
+                        if (perf_top__handle_keypress(top, c))
+                                goto repeat;
+                        done = 1;
                 }
         }
-process_hotkey:
-        c = getc(stdin);
-        tcsetattr(0, TCSAFLUSH, &save);
-
-        perf_top__handle_keypress(top, c);
-        goto repeat;
 
         return NULL;
 }
@@ -716,7 +697,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
                 static struct intlist *seen;
 
                 if (!seen)
-                        seen = intlist__new();
+                        seen = intlist__new(NULL);
 
                 if (!intlist__has_entry(seen, event->ip.pid)) {
                         pr_err("Can't find guest [%d]'s kernel information\n",
@@ -727,8 +708,8 @@ static void perf_event__process_sample(struct perf_tool *tool,
         }
 
         if (!machine) {
-                pr_err("%u unprocessable samples recorded.",
-                       top->session->hists.stats.nr_unprocessable_samples++);
+                pr_err("%u unprocessable samples recorded.\r",
+                       top->session->stats.nr_unprocessable_samples++);
                 return;
         }
 
@@ -810,7 +791,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
                                 return;
                 }
 
-                if (top->sort_has_symbols)
+                if (sort__has_sym)
                         perf_top__record_precise_ip(top, he, evsel->idx, ip);
         }
 
@@ -847,13 +828,13 @@ static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
                         ++top->us_samples;
                         if (top->hide_user_symbols)
                                 continue;
-                        machine = perf_session__find_host_machine(session);
+                        machine = &session->machines.host;
                         break;
                 case PERF_RECORD_MISC_KERNEL:
                         ++top->kernel_samples;
                         if (top->hide_kernel_symbols)
                                 continue;
-                        machine = perf_session__find_host_machine(session);
+                        machine = &session->machines.host;
                         break;
                 case PERF_RECORD_MISC_GUEST_KERNEL:
                         ++top->guest_kernel_samples;
@@ -878,7 +859,7 @@ static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
                         hists__inc_nr_events(&evsel->hists, event->header.type);
                         machine__process_event(machine, event);
                 } else
-                        ++session->hists.stats.nr_unknown_events;
+                        ++session->stats.nr_unknown_events;
         }
 }
 
@@ -890,133 +871,52 @@ static void perf_top__mmap_read(struct perf_top *top)
                 perf_top__mmap_read_idx(top, i);
 }
 
-static void perf_top__start_counters(struct perf_top *top)
+static int perf_top__start_counters(struct perf_top *top)
 {
+        char msg[512];
         struct perf_evsel *counter;
         struct perf_evlist *evlist = top->evlist;
+        struct perf_record_opts *opts = &top->record_opts;
 
-        if (top->group)
-                perf_evlist__set_leader(evlist);
+        perf_evlist__config(evlist, opts);
 
         list_for_each_entry(counter, &evlist->entries, node) {
-                struct perf_event_attr *attr = &counter->attr;
-
-                attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
-
-                if (top->freq) {
-                        attr->sample_type |= PERF_SAMPLE_PERIOD;
-                        attr->freq        = 1;
-                        attr->sample_freq = top->freq;
-                }
-
-                if (evlist->nr_entries > 1) {
-                        attr->sample_type |= PERF_SAMPLE_ID;
-                        attr->read_format |= PERF_FORMAT_ID;
-                }
-
-                if (perf_target__has_cpu(&top->target))
-                        attr->sample_type |= PERF_SAMPLE_CPU;
-
-                if (symbol_conf.use_callchain)
-                        attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
-
-                attr->mmap = 1;
-                attr->comm = 1;
-                attr->inherit = top->inherit;
-fallback_missing_features:
-                if (top->exclude_guest_missing)
-                        attr->exclude_guest = attr->exclude_host = 0;
-retry_sample_id:
-                attr->sample_id_all = top->sample_id_all_missing ? 0 : 1;
 try_again:
                 if (perf_evsel__open(counter, top->evlist->cpus,
                                      top->evlist->threads) < 0) {
-                        int err = errno;
-
-                        if (err == EPERM || err == EACCES) {
-                                ui__error_paranoid();
-                                goto out_err;
-                        } else if (err == EINVAL) {
-                                if (!top->exclude_guest_missing &&
-                                    (attr->exclude_guest || attr->exclude_host)) {
-                                        pr_debug("Old kernel, cannot exclude "
-                                                 "guest or host samples.\n");
-                                        top->exclude_guest_missing = true;
-                                        goto fallback_missing_features;
-                                } else if (!top->sample_id_all_missing) {
-                                        /*
-                                         * Old kernel, no attr->sample_id_type_all field
-                                         */
-                                        top->sample_id_all_missing = true;
-                                        goto retry_sample_id;
-                                }
-                        }
-                        /*
-                         * If it's cycles then fall back to hrtimer
-                         * based cpu-clock-tick sw counter, which
-                         * is always available even if no PMU support:
-                         */
-                        if ((err == ENOENT || err == ENXIO) &&
-                            (attr->type == PERF_TYPE_HARDWARE) &&
-                            (attr->config == PERF_COUNT_HW_CPU_CYCLES)) {
-
+                        if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
                                 if (verbose)
-                                        ui__warning("Cycles event not supported,\n"
-                                                    "trying to fall back to cpu-clock-ticks\n");
-
-                                attr->type = PERF_TYPE_SOFTWARE;
-                                attr->config = PERF_COUNT_SW_CPU_CLOCK;
-                                if (counter->name) {
-                                        free(counter->name);
-                                        counter->name = NULL;
-                                }
+                                        ui__warning("%s\n", msg);
                                 goto try_again;
                         }
 
-                        if (err == ENOENT) {
-                                ui__error("The %s event is not supported.\n",
-                                          perf_evsel__name(counter));
-                                goto out_err;
-                        } else if (err == EMFILE) {
-                                ui__error("Too many events are opened.\n"
-                                            "Try again after reducing the number of events\n");
-                                goto out_err;
-                        } else if ((err == EOPNOTSUPP) && (attr->precise_ip)) {
-                                ui__error("\'precise\' request may not be supported. "
-                                          "Try removing 'p' modifier\n");
-                                goto out_err;
-                        }
-
-                        ui__error("The sys_perf_event_open() syscall "
-                                    "returned with %d (%s).  /bin/dmesg "
-                                    "may provide additional information.\n"
-                                    "No CONFIG_PERF_EVENTS=y kernel support "
-                                    "configured?\n", err, strerror(err));
+                        perf_evsel__open_strerror(counter, &opts->target,
+                                                  errno, msg, sizeof(msg));
+                        ui__error("%s\n", msg);
                         goto out_err;
                 }
         }
 
-        if (perf_evlist__mmap(evlist, top->mmap_pages, false) < 0) {
+        if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
                 ui__error("Failed to mmap with %d (%s)\n",
                             errno, strerror(errno));
                 goto out_err;
         }
 
-        return;
+        return 0;
 
 out_err:
-        exit_browser(0);
-        exit(0);
+        return -1;
 }
 
-static int perf_top__setup_sample_type(struct perf_top *top)
+static int perf_top__setup_sample_type(struct perf_top *top __maybe_unused)
 {
-        if (!top->sort_has_symbols) {
+        if (!sort__has_sym) {
                 if (symbol_conf.use_callchain) {
                         ui__error("Selected -g but \"sym\" not present in --sort/-s.");
                         return -EINVAL;
                 }
-        } else if (!top->dont_use_callchains && callchain_param.mode != CHAIN_NONE) {
+        } else if (callchain_param.mode != CHAIN_NONE) {
                 if (callchain_register_param(&callchain_param) < 0) {
                         ui__error("Can't register callchain params.\n");
                         return -EINVAL;
@@ -1028,6 +928,7 @@ static int perf_top__setup_sample_type(struct perf_top *top)
 
 static int __cmd_top(struct perf_top *top)
 {
+        struct perf_record_opts *opts = &top->record_opts;
         pthread_t thread;
         int ret;
         /*
@@ -1042,26 +943,42 @@ static int __cmd_top(struct perf_top *top)
         if (ret)
                 goto out_delete;
 
-        if (perf_target__has_task(&top->target))
+        if (perf_target__has_task(&opts->target))
                 perf_event__synthesize_thread_map(&top->tool, top->evlist->threads,
                                                   perf_event__process,
-                                                  &top->session->host_machine);
+                                                  &top->session->machines.host);
         else
                 perf_event__synthesize_threads(&top->tool, perf_event__process,
-                                               &top->session->host_machine);
-        perf_top__start_counters(top);
+                                               &top->session->machines.host);
+
+        ret = perf_top__start_counters(top);
+        if (ret)
+                goto out_delete;
+
         top->session->evlist = top->evlist;
         perf_session__set_id_hdr_size(top->session);
 
+        /*
+         * When perf is starting the traced process, all the events (apart from
+         * group members) have enable_on_exec=1 set, so don't spoil it by
+         * prematurely enabling them.
+         *
+         * XXX 'top' still doesn't start workloads like record, trace, but should,
+         * so leave the check here.
+         */
+        if (!perf_target__none(&opts->target))
+                perf_evlist__enable(top->evlist);
+
         /* Wait for a minimal set of events before starting the snapshot */
         poll(top->evlist->pollfd, top->evlist->nr_fds, 100);
 
         perf_top__mmap_read(top);
 
+        ret = -1;
         if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
                                                             display_thread), top)) {
                 ui__error("Could not create display thread.\n");
-                exit(-1);
+                goto out_delete;
         }
 
         if (top->realtime_prio) {
@@ -1070,11 +987,11 @@ static int __cmd_top(struct perf_top *top)
                 param.sched_priority = top->realtime_prio;
                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
                         ui__error("Could not set realtime priority.\n");
-                        exit(-1);
+                        goto out_delete;
                 }
         }
 
-        while (1) {
+        while (!done) {
                 u64 hits = top->samples;
 
                 perf_top__mmap_read(top);
@@ -1083,126 +1000,77 @@ static int __cmd_top(struct perf_top *top)
                         ret = poll(top->evlist->pollfd, top->evlist->nr_fds, 100);
         }
 
+        ret = 0;
 out_delete:
         perf_session__delete(top->session);
         top->session = NULL;
 
-        return 0;
+        return ret;
 }
 
 static int
 parse_callchain_opt(const struct option *opt, const char *arg, int unset)
 {
-        struct perf_top *top = (struct perf_top *)opt->value;
-        char *tok, *tok2;
-        char *endptr;
-
         /*
          * --no-call-graph
          */
-        if (unset) {
-                top->dont_use_callchains = true;
+        if (unset)
                 return 0;
-        }
 
         symbol_conf.use_callchain = true;
 
-        if (!arg)
-                return 0;
-
-        tok = strtok((char *)arg, ",");
-        if (!tok)
-                return -1;
-
-        /* get the output mode */
-        if (!strncmp(tok, "graph", strlen(arg)))
-                callchain_param.mode = CHAIN_GRAPH_ABS;
-
-        else if (!strncmp(tok, "flat", strlen(arg)))
-                callchain_param.mode = CHAIN_FLAT;
-
-        else if (!strncmp(tok, "fractal", strlen(arg)))
-                callchain_param.mode = CHAIN_GRAPH_REL;
-
-        else if (!strncmp(tok, "none", strlen(arg))) {
-                callchain_param.mode = CHAIN_NONE;
-                symbol_conf.use_callchain = false;
-
-                return 0;
-        } else
-                return -1;
-
-        /* get the min percentage */
-        tok = strtok(NULL, ",");
-        if (!tok)
-                goto setup;
-
-        callchain_param.min_percent = strtod(tok, &endptr);
-        if (tok == endptr)
-                return -1;
-
-        /* get the print limit */
-        tok2 = strtok(NULL, ",");
-        if (!tok2)
-                goto setup;
+        return record_parse_callchain_opt(opt, arg, unset);
+}
 
-        if (tok2[0] != 'c') {
-                callchain_param.print_limit = strtod(tok2, &endptr);
-                tok2 = strtok(NULL, ",");
-                if (!tok2)
-                        goto setup;
-        }
+static int
+parse_percent_limit(const struct option *opt, const char *arg,
+                    int unset __maybe_unused)
+{
+        struct perf_top *top = opt->value;
 
-        /* get the call chain order */
-        if (!strcmp(tok2, "caller"))
-                callchain_param.order = ORDER_CALLER;
-        else if (!strcmp(tok2, "callee"))
-                callchain_param.order = ORDER_CALLEE;
-        else
-                return -1;
-setup:
-        if (callchain_register_param(&callchain_param) < 0) {
-                fprintf(stderr, "Can't register callchain params\n");
-                return -1;
-        }
+        top->min_percent = strtof(arg, NULL);
         return 0;
 }
 
 int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        struct perf_evsel *pos;
         int status;
         char errbuf[BUFSIZ];
         struct perf_top top = {
                 .count_filter        = 5,
                 .delay_secs          = 2,
-                .freq                = 4000, /* 4 KHz */
-                .mmap_pages          = 128,
-                .sym_pcnt_filter     = 5,
-                .target              = {
-                        .uses_mmap   = true,
+                .record_opts = {
+                        .mmap_pages     = UINT_MAX,
+                        .user_freq      = UINT_MAX,
+                        .user_interval  = ULLONG_MAX,
+                        .freq           = 4000, /* 4 KHz */
+                        .target              = {
+                                .uses_mmap   = true,
+                        },
                 },
+                .sym_pcnt_filter     = 5,
         };
-        char callchain_default_opt[] = "fractal,0.5,callee";
+        struct perf_record_opts *opts = &top.record_opts;
+        struct perf_target *target = &opts->target;
         const struct option options[] = {
         OPT_CALLBACK('e', "event", &top.evlist, "event",
                      "event selector. use 'perf list' to list available events",
                      parse_events_option),
-        OPT_INTEGER('c', "count", &top.default_interval,
-                    "event period to sample"),
-        OPT_STRING('p', "pid", &top.target.pid, "pid",
+        OPT_U64('c', "count", &opts->user_interval, "event period to sample"),
+        OPT_STRING('p', "pid", &target->pid, "pid",
                     "profile events on existing process id"),
-        OPT_STRING('t', "tid", &top.target.tid, "tid",
+        OPT_STRING('t', "tid", &target->tid, "tid",
                     "profile events on existing thread id"),
-        OPT_BOOLEAN('a', "all-cpus", &top.target.system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &target->system_wide,
                             "system-wide collection from all CPUs"),
-        OPT_STRING('C', "cpu", &top.target.cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &target->cpu_list, "cpu",
                     "list of cpus to monitor"),
         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
                    "file", "vmlinux pathname"),
         OPT_BOOLEAN('K', "hide_kernel_symbols", &top.hide_kernel_symbols,
                     "hide kernel symbols"),
-        OPT_UINTEGER('m', "mmap-pages", &top.mmap_pages, "number of mmap data pages"),
+        OPT_UINTEGER('m', "mmap-pages", &opts->mmap_pages,
+                     "number of mmap data pages"),
         OPT_INTEGER('r', "realtime", &top.realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
         OPT_INTEGER('d', "delay", &top.delay_secs,
@@ -1211,16 +1079,14 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                             "dump the symbol table used for profiling"),
         OPT_INTEGER('f', "count-filter", &top.count_filter,
                     "only display functions with more events than this"),
-        OPT_BOOLEAN('g', "group", &top.group,
+        OPT_BOOLEAN('g', "group", &opts->group,
                             "put the counters into a counter group"),
-        OPT_BOOLEAN('i', "inherit", &top.inherit,
-                    "child tasks inherit counters"),
+        OPT_BOOLEAN('i', "no-inherit", &opts->no_inherit,
+                    "child tasks do not inherit counters"),
         OPT_STRING(0, "sym-annotate", &top.sym_filter, "symbol name",
                     "symbol to annotate"),
-        OPT_BOOLEAN('z', "zero", &top.zero,
-                    "zero history across updates"),
-        OPT_INTEGER('F', "freq", &top.freq,
-                    "profile at this frequency"),
+        OPT_BOOLEAN('z', "zero", &top.zero, "zero history across updates"),
+        OPT_UINTEGER('F', "freq", &opts->user_freq, "profile at this frequency"),
         OPT_INTEGER('E', "entries", &top.print_entries,
                     "display this many functions"),
         OPT_BOOLEAN('U', "hide_user_symbols", &top.hide_user_symbols,
@@ -1230,13 +1096,12 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
-                   "sort by key(s): pid, comm, dso, symbol, parent"),
+                   "sort by key(s): pid, comm, dso, symbol, parent, weight, local_weight"),
         OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
                     "Show a column with the number of samples"),
-        OPT_CALLBACK_DEFAULT('G', "call-graph", &top, "output_type,min_percent, call_order",
-                     "Display callchains using output_type (graph, flat, fractal, or none), min percent threshold and callchain order. "
-                     "Default: fractal,0.5,callee", &parse_callchain_opt,
-                     callchain_default_opt),
+        OPT_CALLBACK_DEFAULT('G', "call-graph", &top.record_opts,
+                             "mode[,dump_size]", record_callchain_help,
+                             &parse_callchain_opt, "fp"),
         OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
                     "Show a column with the sum of periods"),
         OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
@@ -1251,7 +1116,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Display raw encoding of assembly instructions (default)"),
         OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
-        OPT_STRING('u', "uid", &top.target.uid_str, "user", "user to profile"),
+        OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"),
+        OPT_CALLBACK(0, "percent-limit", &top, "percent",
+                     "Don't show entries under that percent", parse_percent_limit),
         OPT_END()
         };
         const char * const top_usage[] = {
@@ -1259,7 +1126,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                 NULL
         };
 
-        top.evlist = perf_evlist__new(NULL, NULL);
+        top.evlist = perf_evlist__new();
         if (top.evlist == NULL)
                 return -ENOMEM;
 
@@ -1272,7 +1139,11 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (sort_order == default_sort_order)
                 sort_order = "dso,symbol";
 
-        setup_sorting(top_usage, options);
+        if (setup_sorting() < 0)
+                usage_with_options(top_usage, options);
+
+        /* display thread wants entries to be collapsed in a different tree */
+        sort__need_collapse = 1;
 
         if (top.use_stdio)
                 use_browser = 0;
@@ -1281,33 +1152,33 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 
         setup_browser(false);
 
-        status = perf_target__validate(&top.target);
+        status = perf_target__validate(target);
         if (status) {
-                perf_target__strerror(&top.target, status, errbuf, BUFSIZ);
+                perf_target__strerror(target, status, errbuf, BUFSIZ);
                 ui__warning("%s", errbuf);
         }
 
-        status = perf_target__parse_uid(&top.target);
+        status = perf_target__parse_uid(target);
         if (status) {
                 int saved_errno = errno;
 
-                perf_target__strerror(&top.target, status, errbuf, BUFSIZ);
+                perf_target__strerror(target, status, errbuf, BUFSIZ);
                 ui__error("%s", errbuf);
 
                 status = -saved_errno;
                 goto out_delete_evlist;
         }
 
-        if (perf_target__none(&top.target))
-                top.target.system_wide = true;
+        if (perf_target__none(target))
+                target->system_wide = true;
 
-        if (perf_evlist__create_maps(top.evlist, &top.target) < 0)
+        if (perf_evlist__create_maps(top.evlist, target) < 0)
                 usage_with_options(top_usage, options);
 
         if (!top.evlist->nr_entries &&
             perf_evlist__add_default(top.evlist) < 0) {
                 ui__error("Not enough memory for event selector list\n");
-                return -ENOMEM;
+                goto out_delete_maps;
         }
 
         symbol_conf.nr_events = top.evlist->nr_entries;
@@ -1315,24 +1186,22 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (top.delay_secs < 1)
                 top.delay_secs = 1;
 
+        if (opts->user_interval != ULLONG_MAX)
+                opts->default_interval = opts->user_interval;
+        if (opts->user_freq != UINT_MAX)
+                opts->freq = opts->user_freq;
+
         /*
          * User specified count overrides default frequency.
          */
-        if (top.default_interval)
-                top.freq = 0;
-        else if (top.freq) {
-                top.default_interval = top.freq;
+        if (opts->default_interval)
+                opts->freq = 0;
+        else if (opts->freq) {
+                opts->default_interval = opts->freq;
         } else {
                 ui__error("frequency and count are zero, aborting\n");
-                exit(EXIT_FAILURE);
-        }
-
-        list_for_each_entry(pos, &top.evlist->entries, node) {
-                /*
-                 * Fill in the ones not specifically initialized via -c:
-                 */
-                if (!pos->attr.sample_period)
-                        pos->attr.sample_period = top.default_interval;
+                status = -EINVAL;
+                goto out_delete_maps;
         }
 
         top.sym_evsel = perf_evlist__first(top.evlist);
@@ -1343,15 +1212,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (symbol__init() < 0)
                 return -1;
 
-        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
-        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
-        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
-
-        /*
-         * Avoid annotation data structures overhead when symbols aren't on the
-         * sort list.
-         */
-        top.sort_has_symbols = sort_sym.list.next != NULL;
+        sort__setup_elide(stdout);
 
         get_term_dimensions(&top.winsize);
         if (top.print_entries == 0) {
@@ -1365,6 +1226,8 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 
         status = __cmd_top(&top);
 
+out_delete_maps:
+        perf_evlist__delete_maps(top.evlist);
 out_delete_evlist:
         perf_evlist__delete(top.evlist);
 
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 7932ffa29889..ab3ed4af1466 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -419,7 +419,7 @@ out_dump:
 
 static int trace__run(struct trace *trace, int argc, const char **argv)
 {
-        struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
+        struct perf_evlist *evlist = perf_evlist__new();
         struct perf_evsel *evsel;
         int err = -1, i;
         unsigned long before;
@@ -452,32 +452,33 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
         err = trace__symbols_init(trace, evlist);
         if (err < 0) {
                 printf("Problems initializing symbol libraries!\n");
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
-        perf_evlist__config_attrs(evlist, &trace->opts);
+        perf_evlist__config(evlist, &trace->opts);
 
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
 
         if (forks) {
-                err = perf_evlist__prepare_workload(evlist, &trace->opts, argv);
+                err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
+                                                    argv, false, false);
                 if (err < 0) {
                         printf("Couldn't run the workload!\n");
-                        goto out_delete_evlist;
+                        goto out_delete_maps;
                 }
         }
 
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 printf("Couldn't create the events: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
         err = perf_evlist__mmap(evlist, UINT_MAX, false);
         if (err < 0) {
                 printf("Couldn't mmap the events: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_close_evlist;
         }
 
         perf_evlist__enable(evlist);
@@ -526,13 +527,6 @@ again:
                                 continue;
                         }
 
-                        if (sample.raw_data == NULL) {
-                                printf("%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);
-                                continue;
-                        }
-
                         handler = evsel->handler.func;
                         handler(trace, evsel, &sample);
                 }
@@ -540,7 +534,7 @@ again:
 
         if (trace->nr_events == before) {
                 if (done)
-                        goto out_delete_evlist;
+                        goto out_unmap_evlist;
 
                 poll(evlist->pollfd, evlist->nr_fds, -1);
         }
@@ -550,6 +544,12 @@ again:
 
         goto again;
 
+out_unmap_evlist:
+        perf_evlist__munmap(evlist);
+out_close_evlist:
+        perf_evlist__close(evlist);
+out_delete_maps:
+        perf_evlist__delete_maps(evlist);
 out_delete_evlist:
         perf_evlist__delete(evlist);
 out:
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index 08143bd854c7..b210d62907e4 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -36,6 +36,7 @@ extern int cmd_kvm(int argc, const char **argv, const char *prefix);
 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 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 3e86bbd8c2d5..0906fc401c52 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -10,17 +10,18 @@ perf-buildid-list		mainporcelain common
 perf-diff                       mainporcelain common
 perf-evlist                     mainporcelain common
 perf-inject                     mainporcelain common
+perf-kmem                       mainporcelain common
+perf-kvm                        mainporcelain common
 perf-list                       mainporcelain common
-perf-sched                      mainporcelain common
+perf-lock                       mainporcelain common
+perf-mem                        mainporcelain common
+perf-probe                      mainporcelain full
 perf-record                     mainporcelain common
 perf-report                     mainporcelain common
+perf-sched                      mainporcelain common
+perf-script                     mainporcelain common
 perf-stat                       mainporcelain common
+perf-test                       mainporcelain common
 perf-timechart                  mainporcelain common
 perf-top                        mainporcelain common
 perf-trace                      mainporcelain common
-perf-script                     mainporcelain common
-perf-probe                      mainporcelain full
-perf-kmem                       mainporcelain common
-perf-lock                       mainporcelain common
-perf-kvm                        mainporcelain common
-perf-test                       mainporcelain common
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
new file mode 100644
index 000000000000..f139dcd2796e
--- /dev/null
+++ b/tools/perf/config/Makefile
@@ -0,0 +1,477 @@
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
+                                  -e 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/ )
+NO_PERF_REGS := 1
+CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)
+
+# Additional ARCH settings for x86
+ifeq ($(ARCH),i386)
+  override ARCH := x86
+  NO_PERF_REGS := 0
+  LIBUNWIND_LIBS = -lunwind -lunwind-x86
+endif
+
+ifeq ($(ARCH),x86_64)
+  override ARCH := x86
+  IS_X86_64 := 0
+  ifeq (, $(findstring m32,$(CFLAGS)))
+    IS_X86_64 := $(shell echo __x86_64__ | ${CC} -E -x c - | tail -n 1)
+  endif
+  ifeq (${IS_X86_64}, 1)
+    RAW_ARCH := x86_64
+    CFLAGS += -DARCH_X86_64
+    ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
+  endif
+  NO_PERF_REGS := 0
+  LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
+endif
+
+ifeq ($(NO_PERF_REGS),0)
+  CFLAGS += -DHAVE_PERF_REGS
+endif
+
+ifeq ($(src-perf),)
+src-perf := $(srctree)/tools/perf
+endif
+
+ifeq ($(obj-perf),)
+obj-perf := $(objtree)
+endif
+
+ifneq ($(obj-perf),)
+obj-perf := $(abspath $(obj-perf))/
+endif
+
+# include ARCH specific config
+-include $(src-perf)/arch/$(ARCH)/Makefile
+
+include $(src-perf)/config/feature-tests.mak
+include $(src-perf)/config/utilities.mak
+
+ifeq ($(call get-executable,$(FLEX)),)
+  dummy := $(error Error: $(FLEX) is missing on this system, please install it)
+endif
+
+ifeq ($(call get-executable,$(BISON)),)
+  dummy := $(error Error: $(BISON) is missing on this system, please install it)
+endif
+
+# Treat warnings as errors unless directed not to
+ifneq ($(WERROR),0)
+  CFLAGS += -Werror
+endif
+
+ifeq ("$(origin DEBUG)", "command line")
+  PERF_DEBUG = $(DEBUG)
+endif
+ifndef PERF_DEBUG
+  CFLAGS += -O6
+endif
+
+ifdef PARSER_DEBUG
+  PARSER_DEBUG_BISON := -t
+  PARSER_DEBUG_FLEX  := -d
+  CFLAGS             += -DPARSER_DEBUG
+endif
+
+CFLAGS += -fno-omit-frame-pointer
+CFLAGS += -ggdb3
+CFLAGS += -funwind-tables
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -std=gnu99
+
+EXTLIBS = -lpthread -lrt -lelf -lm
+
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -fstack-protector-all,-fstack-protector-all),y)
+  CFLAGS += -fstack-protector-all
+endif
+
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wstack-protector,-Wstack-protector),y)
+  CFLAGS += -Wstack-protector
+endif
+
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wvolatile-register-var,-Wvolatile-register-var),y)
+  CFLAGS += -Wvolatile-register-var
+endif
+
+ifndef PERF_DEBUG
+  ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -D_FORTIFY_SOURCE=2,-D_FORTIFY_SOURCE=2),y)
+    CFLAGS += -D_FORTIFY_SOURCE=2
+  endif
+endif
+
+CFLAGS += -I$(src-perf)/util/include
+CFLAGS += -I$(src-perf)/arch/$(ARCH)/include
+CFLAGS += -I$(srctree)/arch/$(ARCH)/include/uapi
+CFLAGS += -I$(srctree)/arch/$(ARCH)/include
+CFLAGS += -I$(srctree)/include/uapi
+CFLAGS += -I$(srctree)/include
+
+# $(obj-perf)      for generated common-cmds.h
+# $(obj-perf)/util for generated bison/flex headers
+ifneq ($(OUTPUT),)
+CFLAGS += -I$(obj-perf)/util
+CFLAGS += -I$(obj-perf)
+endif
+
+CFLAGS += -I$(src-perf)/util
+CFLAGS += -I$(src-perf)
+CFLAGS += -I$(TRACE_EVENT_DIR)
+CFLAGS += -I$(srctree)/tools/lib/
+
+CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
+
+ifndef NO_BIONIC
+ifeq ($(call try-cc,$(SOURCE_BIONIC),$(CFLAGS),bionic),y)
+  BIONIC := 1
+  EXTLIBS := $(filter-out -lrt,$(EXTLIBS))
+  EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))
+endif
+endif # NO_BIONIC
+
+ifdef NO_LIBELF
+  NO_DWARF := 1
+  NO_DEMANGLE := 1
+  NO_LIBUNWIND := 1
+else
+FLAGS_LIBELF=$(CFLAGS) $(LDFLAGS) $(EXTLIBS)
+ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF),libelf),y)
+  FLAGS_GLIBC=$(CFLAGS) $(LDFLAGS)
+  ifeq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC),glibc),y)
+    LIBC_SUPPORT := 1
+  endif
+  ifeq ($(BIONIC),1)
+    LIBC_SUPPORT := 1
+  endif
+  ifeq ($(LIBC_SUPPORT),1)
+    msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);
+
+    NO_LIBELF := 1
+    NO_DWARF := 1
+    NO_DEMANGLE := 1
+  else
+    msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
+  endif
+else
+  # for linking with debug library, run like:
+  # make DEBUG=1 LIBDW_DIR=/opt/libdw/
+  ifdef LIBDW_DIR
+    LIBDW_CFLAGS  := -I$(LIBDW_DIR)/include
+    LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib
+  endif
+
+  FLAGS_DWARF=$(CFLAGS) $(LIBDW_CFLAGS) -ldw -lelf $(LIBDW_LDFLAGS) $(LDFLAGS) $(EXTLIBS)
+  ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF),libdw),y)
+    msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
+    NO_DWARF := 1
+  endif # Dwarf support
+endif # SOURCE_LIBELF
+endif # NO_LIBELF
+
+ifndef NO_LIBELF
+CFLAGS += -DLIBELF_SUPPORT
+FLAGS_LIBELF=$(CFLAGS) $(LDFLAGS) $(EXTLIBS)
+ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
+  CFLAGS += -DLIBELF_MMAP
+endif
+
+# include ARCH specific config
+-include $(src-perf)/arch/$(ARCH)/Makefile
+
+ifndef NO_DWARF
+ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
+  msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
+  NO_DWARF := 1
+else
+  CFLAGS += -DDWARF_SUPPORT $(LIBDW_CFLAGS)
+  LDFLAGS += $(LIBDW_LDFLAGS)
+  EXTLIBS += -lelf -ldw
+endif # PERF_HAVE_DWARF_REGS
+endif # NO_DWARF
+
+endif # NO_LIBELF
+
+ifndef NO_LIBELF
+CFLAGS += -DLIBELF_SUPPORT
+FLAGS_LIBELF=$(CFLAGS) $(LDFLAGS) $(EXTLIBS)
+ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
+  CFLAGS += -DLIBELF_MMAP
+endif # try-cc
+endif # NO_LIBELF
+
+# There's only x86 (both 32 and 64) support for CFI unwind so far
+ifneq ($(ARCH),x86)
+  NO_LIBUNWIND := 1
+endif
+
+ifndef NO_LIBUNWIND
+# for linking with debug library, run like:
+# make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/
+ifdef LIBUNWIND_DIR
+  LIBUNWIND_CFLAGS  := -I$(LIBUNWIND_DIR)/include
+  LIBUNWIND_LDFLAGS := -L$(LIBUNWIND_DIR)/lib
+endif
+
+FLAGS_UNWIND=$(LIBUNWIND_CFLAGS) $(CFLAGS) $(LIBUNWIND_LDFLAGS) $(LDFLAGS) $(EXTLIBS) $(LIBUNWIND_LIBS)
+ifneq ($(call try-cc,$(SOURCE_LIBUNWIND),$(FLAGS_UNWIND),libunwind),y)
+  msg := $(warning No libunwind found, disabling post unwind support. Please install libunwind-dev[el] >= 0.99);
+  NO_LIBUNWIND := 1
+endif # Libunwind support
+endif # NO_LIBUNWIND
+
+ifndef NO_LIBUNWIND
+  CFLAGS += -DLIBUNWIND_SUPPORT
+  EXTLIBS += $(LIBUNWIND_LIBS)
+  CFLAGS += $(LIBUNWIND_CFLAGS)
+  LDFLAGS += $(LIBUNWIND_LDFLAGS)
+endif # NO_LIBUNWIND
+
+ifndef NO_LIBAUDIT
+  FLAGS_LIBAUDIT = $(CFLAGS) $(LDFLAGS) -laudit
+  ifneq ($(call try-cc,$(SOURCE_LIBAUDIT),$(FLAGS_LIBAUDIT),libaudit),y)
+    msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);
+    NO_LIBAUDIT := 1
+  else
+    CFLAGS += -DLIBAUDIT_SUPPORT
+    EXTLIBS += -laudit
+  endif
+endif
+
+ifdef NO_NEWT
+  NO_SLANG=1
+endif
+
+ifndef NO_SLANG
+  FLAGS_SLANG=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) -I/usr/include/slang -lslang
+  ifneq ($(call try-cc,$(SOURCE_SLANG),$(FLAGS_SLANG),libslang),y)
+    msg := $(warning slang not found, disables TUI support. Please install slang-devel or libslang-dev);
+    NO_SLANG := 1
+  else
+    # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
+    CFLAGS += -I/usr/include/slang
+    CFLAGS += -DSLANG_SUPPORT
+    EXTLIBS += -lslang
+  endif
+endif
+
+ifndef NO_GTK2
+  FLAGS_GTK2=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) $(shell pkg-config --libs --cflags gtk+-2.0 2>/dev/null)
+  ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2),gtk2),y)
+    msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
+    NO_GTK2 := 1
+  else
+    ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2),-DHAVE_GTK_INFO_BAR),y)
+      CFLAGS += -DHAVE_GTK_INFO_BAR
+    endif
+    CFLAGS += -DGTK2_SUPPORT
+    CFLAGS += $(shell pkg-config --cflags gtk+-2.0 2>/dev/null)
+    EXTLIBS += $(shell pkg-config --libs gtk+-2.0 2>/dev/null)
+  endif
+endif
+
+grep-libs  = $(filter -l%,$(1))
+strip-libs = $(filter-out -l%,$(1))
+
+ifdef NO_LIBPERL
+  CFLAGS += -DNO_LIBPERL
+else
+  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)
+
+  ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED),perl),y)
+    CFLAGS += -DNO_LIBPERL
+    NO_LIBPERL := 1
+  else
+    LDFLAGS += $(PERL_EMBED_LDFLAGS)
+    EXTLIBS += $(PERL_EMBED_LIBADD)
+  endif
+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)
+  NO_LIBPYTHON := 1
+endef
+
+override PYTHON := \
+  $(call get-executable-or-default,PYTHON,python)
+
+ifndef PYTHON
+  $(call disable-python,python interpreter)
+else
+
+  PYTHON_WORD := $(call shell-wordify,$(PYTHON))
+
+  ifdef NO_LIBPYTHON
+    $(call disable-python)
+  else
+
+    override PYTHON_CONFIG := \
+      $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
+
+    ifndef PYTHON_CONFIG
+      $(call disable-python,python-config tool)
+    else
+
+      PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
+
+      PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
+      PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
+      PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
+      PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
+      FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
+
+      ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED),python),y)
+        $(call disable-python,Python.h (for Python 2.x))
+      else
+
+        ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED),python version),y)
+          $(warning Python 3 is not yet supported; please set)
+          $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
+          $(warning If you also have Python 2 installed, then)
+          $(warning try something like:)
+          $(warning $(and ,))
+          $(warning $(and ,)  make PYTHON=python2)
+          $(warning $(and ,))
+          $(warning Otherwise, disable Python support entirely:)
+          $(warning $(and ,))
+          $(warning $(and ,)  make NO_LIBPYTHON=1)
+          $(warning $(and ,))
+          $(error   $(and ,))
+        else
+          LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
+          EXTLIBS += $(PYTHON_EMBED_LIBADD)
+          LANG_BINDINGS += $(obj-perf)python/perf.so
+        endif
+      endif
+    endif
+  endif
+endif
+
+ifdef NO_DEMANGLE
+  CFLAGS += -DNO_DEMANGLE
+else
+  ifdef HAVE_CPLUS_DEMANGLE
+    EXTLIBS += -liberty
+    CFLAGS += -DHAVE_CPLUS_DEMANGLE
+  else
+    FLAGS_BFD=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) -DPACKAGE='perf' -lbfd
+    has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD),libbfd)
+    ifeq ($(has_bfd),y)
+      EXTLIBS += -lbfd
+    else
+      FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
+      has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY),liberty)
+      ifeq ($(has_bfd_iberty),y)
+        EXTLIBS += -lbfd -liberty
+      else
+        FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
+        has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z),libz)
+        ifeq ($(has_bfd_iberty_z),y)
+          EXTLIBS += -lbfd -liberty -lz
+        else
+          FLAGS_CPLUS_DEMANGLE=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) -liberty
+          has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE),demangle)
+          ifeq ($(has_cplus_demangle),y)
+            EXTLIBS += -liberty
+            CFLAGS += -DHAVE_CPLUS_DEMANGLE
+          else
+            msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
+            CFLAGS += -DNO_DEMANGLE
+          endif
+        endif
+      endif
+    endif
+  endif
+endif
+
+ifndef NO_STRLCPY
+  ifeq ($(call try-cc,$(SOURCE_STRLCPY),,-DHAVE_STRLCPY),y)
+    CFLAGS += -DHAVE_STRLCPY
+  endif
+endif
+
+ifndef NO_ON_EXIT
+  ifeq ($(call try-cc,$(SOURCE_ON_EXIT),,-DHAVE_ON_EXIT),y)
+    CFLAGS += -DHAVE_ON_EXIT
+  endif
+endif
+
+ifndef NO_BACKTRACE
+  ifeq ($(call try-cc,$(SOURCE_BACKTRACE),,-DBACKTRACE_SUPPORT),y)
+    CFLAGS += -DBACKTRACE_SUPPORT
+  endif
+endif
+
+ifndef NO_LIBNUMA
+  FLAGS_LIBNUMA = $(CFLAGS) $(LDFLAGS) -lnuma
+  ifneq ($(call try-cc,$(SOURCE_LIBNUMA),$(FLAGS_LIBNUMA),libnuma),y)
+    msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numa-libs-devel or libnuma-dev);
+    NO_LIBNUMA := 1
+  else
+    CFLAGS += -DLIBNUMA_SUPPORT
+    EXTLIBS += -lnuma
+  endif
+endif
+
+# Among the variables below, these:
+#   perfexecdir
+#   template_dir
+#   mandir
+#   infodir
+#   htmldir
+#   ETC_PERFCONFIG (but not sysconfdir)
+# can be specified as a relative path some/where/else;
+# this is interpreted as relative to $(prefix) and "perf" at
+# runtime figures out where they are based on the path to the executable.
+# This can help installing the suite in a relocatable way.
+
+# Make the path relative to DESTDIR, not to prefix
+ifndef DESTDIR
+prefix = $(HOME)
+endif
+bindir_relative = bin
+bindir = $(prefix)/$(bindir_relative)
+mandir = share/man
+infodir = share/info
+perfexecdir = libexec/perf-core
+sharedir = $(prefix)/share
+template_dir = share/perf-core/templates
+htmldir = share/doc/perf-doc
+ifeq ($(prefix),/usr)
+sysconfdir = /etc
+ETC_PERFCONFIG = $(sysconfdir)/perfconfig
+else
+sysconfdir = $(prefix)/etc
+ETC_PERFCONFIG = etc/perfconfig
+endif
+lib = lib
+
+# Shell quote (do not use $(call) to accommodate ancient setups);
+ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
+DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
+bindir_SQ = $(subst ','\'',$(bindir))
+mandir_SQ = $(subst ','\'',$(mandir))
+infodir_SQ = $(subst ','\'',$(infodir))
+perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
+template_dir_SQ = $(subst ','\'',$(template_dir))
+htmldir_SQ = $(subst ','\'',$(htmldir))
+prefix_SQ = $(subst ','\'',$(prefix))
+sysconfdir_SQ = $(subst ','\'',$(sysconfdir))
+
+ifneq ($(filter /%,$(firstword $(perfexecdir))),)
+perfexec_instdir = $(perfexecdir)
+else
+perfexec_instdir = $(prefix)/$(perfexecdir)
+endif
+perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
diff --git a/tools/perf/config/feature-tests.mak b/tools/perf/config/feature-tests.mak
index f5ac77485a4f..708fb8e9822a 100644
--- a/tools/perf/config/feature-tests.mak
+++ b/tools/perf/config/feature-tests.mak
@@ -61,15 +61,13 @@ int main(void)
 }
 endef
 
-ifndef NO_NEWT
-define SOURCE_NEWT
-#include <newt.h>
+ifndef NO_SLANG
+define SOURCE_SLANG
+#include <slang.h>
 
 int main(void)
 {
-        newtInit();
-        newtCls();
-        return newtFinished();
+        return SLsmg_init_smg();
 }
 endef
 endif
@@ -225,3 +223,14 @@ int main(void)
         return on_exit(NULL, NULL);
 }
 endef
+
+define SOURCE_LIBNUMA
+#include <numa.h>
+#include <numaif.h>
+
+int main(void)
+{
+        numa_available();
+        return 0;
+}
+endef
diff --git a/tools/perf/config/utilities.mak b/tools/perf/config/utilities.mak
index e5413125e6bb..8ef3bd30a549 100644
--- a/tools/perf/config/utilities.mak
+++ b/tools/perf/config/utilities.mak
@@ -13,7 +13,7 @@ newline := $(newline)
 # what should replace a newline when escaping
 # newlines; the default is a bizarre string.
 #
-nl-escape = $(or $(1),m822df3020w6a44id34bt574ctac44eb9f4n)
+nl-escape = $(if $(1),$(1),m822df3020w6a44id34bt574ctac44eb9f4n)
 
 # escape-nl
 #
@@ -173,9 +173,9 @@ _ge-abspath = $(if $(is-executable),$(1))
 # Usage: absolute-executable-path-or-empty = $(call get-executable-or-default,variable,default)
 #
 define get-executable-or-default
-$(if $($(1)),$(call _ge_attempt,$($(1)),$(1)),$(call _ge_attempt,$(2)))
+$(if $($(1)),$(call _ge_attempt,$($(1)),$(1)),$(call _ge_attempt,$(2),$(1)))
 endef
-_ge_attempt = $(or $(get-executable),$(_gea_warn),$(call _gea_err,$(2)))
+_ge_attempt = $(if $(get-executable),$(get-executable),$(_gea_warn)$(call _gea_err,$(2)))
 _gea_warn = $(warning The path '$(1)' is not executable.)
 _gea_err  = $(if $(1),$(error Please set '$(1)' appropriately))
 
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 0f661fbce6a8..85e1aed95204 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -13,7 +13,7 @@
 #include "util/quote.h"
 #include "util/run-command.h"
 #include "util/parse-events.h"
-#include "util/debugfs.h"
+#include <lk/debugfs.h>
 #include <pthread.h>
 
 const char perf_usage_string[] =
@@ -60,6 +60,7 @@ static struct cmd_struct commands[] = {
         { "trace",      cmd_trace,      0 },
 #endif
         { "inject",     cmd_inject,     0 },
+        { "mem",        cmd_mem,        0 },
 };
 
 struct pager_config {
@@ -193,13 +194,13 @@ static int handle_options(const char ***argv, int *argc, int *envchanged)
                                 fprintf(stderr, "No directory given for --debugfs-dir.\n");
                                 usage(perf_usage_string);
                         }
-                        debugfs_set_path((*argv)[1]);
+                        perf_debugfs_set_path((*argv)[1]);
                         if (envchanged)
                                 *envchanged = 1;
                         (*argv)++;
                         (*argc)--;
                 } else if (!prefixcmp(cmd, CMD_DEBUGFS_DIR)) {
-                        debugfs_set_path(cmd + strlen(CMD_DEBUGFS_DIR));
+                        perf_debugfs_set_path(cmd + strlen(CMD_DEBUGFS_DIR));
                         fprintf(stderr, "dir: %s\n", debugfs_mountpoint);
                         if (envchanged)
                                 *envchanged = 1;
@@ -328,14 +329,23 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode))
                 return 0;
 
+        status = 1;
         /* Check for ENOSPC and EIO errors.. */
-        if (fflush(stdout))
-                die("write failure on standard output: %s", strerror(errno));
-        if (ferror(stdout))
-                die("unknown write failure on standard output");
-        if (fclose(stdout))
-                die("close failed on standard output: %s", strerror(errno));
-        return 0;
+        if (fflush(stdout)) {
+                fprintf(stderr, "write failure on standard output: %s", strerror(errno));
+                goto out;
+        }
+        if (ferror(stdout)) {
+                fprintf(stderr, "unknown write failure on standard output");
+                goto out;
+        }
+        if (fclose(stdout)) {
+                fprintf(stderr, "close failed on standard output: %s", strerror(errno));
+                goto out;
+        }
+        status = 0;
+out:
+        return status;
 }
 
 static void handle_internal_command(int argc, const char **argv)
@@ -452,7 +462,7 @@ int main(int argc, const char **argv)
         if (!cmd)
                 cmd = "perf-help";
         /* get debugfs mount point from /proc/mounts */
-        debugfs_mount(NULL);
+        perf_debugfs_mount(NULL);
         /*
          * "perf-xxxx" is the same as "perf xxxx", but we obviously:
          *
@@ -467,7 +477,8 @@ int main(int argc, const char **argv)
                 cmd += 5;
                 argv[0] = cmd;
                 handle_internal_command(argc, argv);
-                die("cannot handle %s internally", cmd);
+                fprintf(stderr, "cannot handle %s internally", cmd);
+                goto out;
         }
 
         /* Look for flags.. */
@@ -485,7 +496,7 @@ int main(int argc, const char **argv)
                 printf("\n usage: %s\n\n", perf_usage_string);
                 list_common_cmds_help();
                 printf("\n %s\n\n", perf_more_info_string);
-                exit(1);
+                goto out;
         }
         cmd = argv[0];
 
@@ -507,9 +518,8 @@ int main(int argc, const char **argv)
 
         while (1) {
                 static int done_help;
-                static int was_alias;
+                int was_alias = run_argv(&argc, &argv);
 
-                was_alias = run_argv(&argc, &argv);
                 if (errno != ENOENT)
                         break;
 
@@ -517,7 +527,7 @@ int main(int argc, const char **argv)
                         fprintf(stderr, "Expansion of alias '%s' failed; "
                                 "'%s' is not a perf-command\n",
                                 cmd, argv[0]);
-                        exit(1);
+                        goto out;
                 }
                 if (!done_help) {
                         cmd = argv[0] = help_unknown_cmd(cmd);
@@ -528,6 +538,6 @@ int main(int argc, const char **argv)
 
         fprintf(stderr, "Failed to run command '%s': %s\n",
                 cmd, strerror(errno));
-
+out:
         return 1;
 }
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 2c340e7da458..32bd102c32b6 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -1,10 +1,6 @@
 #ifndef _PERF_PERF_H
 #define _PERF_PERF_H
 
-struct winsize;
-
-void get_term_dimensions(struct winsize *ws);
-
 #include <asm/unistd.h>
 
 #if defined(__i386__)
@@ -98,6 +94,18 @@ void get_term_dimensions(struct winsize *ws);
 #define CPUINFO_PROC    "cpu model"
 #endif
 
+#ifdef __arc__
+#define rmb()           asm volatile("" ::: "memory")
+#define cpu_relax()     rmb()
+#define CPUINFO_PROC    "Processor"
+#endif
+
+#ifdef __metag__
+#define rmb()           asm volatile("" ::: "memory")
+#define cpu_relax()     asm volatile("" ::: "memory")
+#define CPUINFO_PROC    "CPU"
+#endif
+
 #include <time.h>
 #include <unistd.h>
 #include <sys/types.h>
@@ -107,32 +115,6 @@ void get_term_dimensions(struct winsize *ws);
 #include "util/types.h"
 #include <stdbool.h>
 
-struct perf_mmap {
-        void                    *base;
-        int                     mask;
-        unsigned int            prev;
-};
-
-static inline unsigned int perf_mmap__read_head(struct perf_mmap *mm)
-{
-        struct perf_event_mmap_page *pc = mm->base;
-        int head = pc->data_head;
-        rmb();
-        return head;
-}
-
-static inline void perf_mmap__write_tail(struct perf_mmap *md,
-                                         unsigned long tail)
-{
-        struct perf_event_mmap_page *pc = md->base;
-
-        /*
-         * ensure all reads are done before we write the tail out.
-         */
-        /* mb(); */
-        pc->data_tail = tail;
-}
-
 /*
  * prctl(PR_TASK_PERF_EVENTS_DISABLE) will (cheaply) disable all
  * counters in the current task.
@@ -236,9 +218,8 @@ struct perf_record_opts {
         bool         pipe_output;
         bool         raw_samples;
         bool         sample_address;
+        bool         sample_weight;
         bool         sample_time;
-        bool         sample_id_all_missing;
-        bool         exclude_guest_missing;
         bool         period;
         unsigned int freq;
         unsigned int mmap_pages;
diff --git a/tools/perf/scripts/perl/bin/workqueue-stats-record b/tools/perf/scripts/perl/bin/workqueue-stats-record
deleted file mode 100644
index 8edda9078d5d..000000000000
--- a/tools/perf/scripts/perl/bin/workqueue-stats-record
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash
-perf record -e workqueue:workqueue_creation -e workqueue:workqueue_destruction -e workqueue:workqueue_execution -e workqueue:workqueue_insertion $@
diff --git a/tools/perf/scripts/perl/bin/workqueue-stats-report b/tools/perf/scripts/perl/bin/workqueue-stats-report
deleted file mode 100644
index 6d91411d248c..000000000000
--- a/tools/perf/scripts/perl/bin/workqueue-stats-report
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-# description: workqueue stats (ins/exe/create/destroy)
-perf script $@ -s "$PERF_EXEC_PATH"/scripts/perl/workqueue-stats.pl
diff --git a/tools/perf/scripts/perl/rwtop.pl b/tools/perf/scripts/perl/rwtop.pl
index 4bb3ecd33472..8b20787021c1 100644
--- a/tools/perf/scripts/perl/rwtop.pl
+++ b/tools/perf/scripts/perl/rwtop.pl
@@ -17,6 +17,7 @@ use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
 use lib "./Perf-Trace-Util/lib";
 use Perf::Trace::Core;
 use Perf::Trace::Util;
+use POSIX qw/SIGALRM SA_RESTART/;
 
 my $default_interval = 3;
 my $nlines = 20;
@@ -90,7 +91,10 @@ sub syscalls::sys_enter_write
 
 sub trace_begin
 {
-    $SIG{ALRM} = \&set_print_pending;
+    my $sa = POSIX::SigAction->new(\&set_print_pending);
+    $sa->flags(SA_RESTART);
+    $sa->safe(1);
+    POSIX::sigaction(SIGALRM, $sa) or die "Can't set SIGALRM handler: $!\n";
     alarm 1;
 }
 
diff --git a/tools/perf/scripts/perl/workqueue-stats.pl b/tools/perf/scripts/perl/workqueue-stats.pl
deleted file mode 100644
index a8eaff5119e0..000000000000
--- a/tools/perf/scripts/perl/workqueue-stats.pl
+++ /dev/null
@@ -1,129 +0,0 @@
-#!/usr/bin/perl -w
-# (c) 2009, Tom Zanussi <tzanussi@gmail.com>
-# Licensed under the terms of the GNU GPL License version 2
-
-# Displays workqueue stats
-#
-# Usage:
-#
-#   perf record -c 1 -f -a -R -e workqueue:workqueue_creation -e
-#     workqueue:workqueue_destruction -e workqueue:workqueue_execution
-#     -e workqueue:workqueue_insertion
-#
-#   perf script -p -s tools/perf/scripts/perl/workqueue-stats.pl
-
-use 5.010000;
-use strict;
-use warnings;
-
-use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
-use lib "./Perf-Trace-Util/lib";
-use Perf::Trace::Core;
-use Perf::Trace::Util;
-
-my @cpus;
-
-sub workqueue::workqueue_destruction
-{
-    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
-        $common_pid, $common_comm,
-        $thread_comm, $thread_pid) = @_;
-
-    $cpus[$common_cpu]{$thread_pid}{destroyed}++;
-    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
-}
-
-sub workqueue::workqueue_creation
-{
-    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
-        $common_pid, $common_comm,
-        $thread_comm, $thread_pid, $cpu) = @_;
-
-    $cpus[$common_cpu]{$thread_pid}{created}++;
-    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
-}
-
-sub workqueue::workqueue_execution
-{
-    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
-        $common_pid, $common_comm,
-        $thread_comm, $thread_pid, $func) = @_;
-
-    $cpus[$common_cpu]{$thread_pid}{executed}++;
-    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
-}
-
-sub workqueue::workqueue_insertion
-{
-    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
-        $common_pid, $common_comm,
-        $thread_comm, $thread_pid, $func) = @_;
-
-    $cpus[$common_cpu]{$thread_pid}{inserted}++;
-    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
-}
-
-sub trace_end
-{
-    print "workqueue work stats:\n\n";
-    my $cpu = 0;
-    printf("%3s %6s %6s\t%-20s\n", "cpu", "ins", "exec", "name");
-    printf("%3s %6s %6s\t%-20s\n", "---", "---", "----", "----");
-    foreach my $pidhash (@cpus) {
-        while ((my $pid, my $wqhash) = each %$pidhash) {
-            my $ins = $$wqhash{'inserted'} || 0;
-            my $exe = $$wqhash{'executed'} || 0;
-            my $comm = $$wqhash{'comm'} || "";
-            if ($ins || $exe) {
-                printf("%3u %6u %6u\t%-20s\n", $cpu, $ins, $exe, $comm);
-            }
-        }
-        $cpu++;
-    }
-
-    $cpu = 0;
-    print "\nworkqueue lifecycle stats:\n\n";
-    printf("%3s %6s %6s\t%-20s\n", "cpu", "created", "destroyed", "name");
-    printf("%3s %6s %6s\t%-20s\n", "---", "-------", "---------", "----");
-    foreach my $pidhash (@cpus) {
-        while ((my $pid, my $wqhash) = each %$pidhash) {
-            my $created = $$wqhash{'created'} || 0;
-            my $destroyed = $$wqhash{'destroyed'} || 0;
-            my $comm = $$wqhash{'comm'} || "";
-            if ($created || $destroyed) {
-                printf("%3u %6u %6u\t%-20s\n", $cpu, $created, $destroyed,
-                       $comm);
-            }
-        }
-        $cpu++;
-    }
-
-    print_unhandled();
-}
-
-my %unhandled;
-
-sub print_unhandled
-{
-    if ((scalar keys %unhandled) == 0) {
-        return;
-    }
-
-    print "\nunhandled events:\n\n";
-
-    printf("%-40s  %10s\n", "event", "count");
-    printf("%-40s  %10s\n", "----------------------------------------",
-           "-----------");
-
-    foreach my $event_name (keys %unhandled) {
-        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
-    }
-}
-
-sub trace_unhandled
-{
-    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
-        $common_pid, $common_comm) = @_;
-
-    $unhandled{$event_name}++;
-}
diff --git a/tools/perf/scripts/python/net_dropmonitor.py b/tools/perf/scripts/python/net_dropmonitor.py
index a4ffc9500023..b5740599aabd 100755
--- a/tools/perf/scripts/python/net_dropmonitor.py
+++ b/tools/perf/scripts/python/net_dropmonitor.py
@@ -15,35 +15,38 @@ kallsyms = []
 
 def get_kallsyms_table():
         global kallsyms
+
         try:
                 f = open("/proc/kallsyms", "r")
-                linecount = 0
-                for line in f:
-                        linecount = linecount+1
-                f.seek(0)
         except:
                 return
 
-
-        j = 0
         for line in f:
                 loc = int(line.split()[0], 16)
                 name = line.split()[2]
-                j = j +1
-                if ((j % 100) == 0):
-                        print "\r" + str(j) + "/" + str(linecount),
-                kallsyms.append({ 'loc': loc, 'name' : name})
-
-        print "\r" + str(j) + "/" + str(linecount)
+                kallsyms.append((loc, name))
         kallsyms.sort()
-        return
 
 def get_sym(sloc):
         loc = int(sloc)
-        for i in kallsyms:
-                if (i['loc'] >= loc):
-                        return (i['name'], i['loc']-loc)
-        return (None, 0)
+
+        # Invariant: kallsyms[i][0] <= loc for all 0 <= i <= start
+        #            kallsyms[i][0] > loc for all end <= i < len(kallsyms)
+        start, end = -1, len(kallsyms)
+        while end != start + 1:
+                pivot = (start + end) // 2
+                if loc < kallsyms[pivot][0]:
+                        end = pivot
+                else:
+                        start = pivot
+
+        # Now (start == -1 or kallsyms[start][0] <= loc)
+        # and (start == len(kallsyms) - 1 or loc < kallsyms[start + 1][0])
+        if start >= 0:
+                symloc, name = kallsyms[start]
+                return (name, loc - symloc)
+        else:
+                return (None, 0)
 
 def print_drop_table():
         print "%25s %25s %25s" % ("LOCATION", "OFFSET", "COUNT")
@@ -64,7 +67,7 @@ def trace_end():
 
 # called from perf, when it finds a correspoinding event
 def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm,
-                        skbaddr, protocol, location):
+                   skbaddr, location, protocol):
         slocation = str(location)
         try:
                 drop_log[slocation] = drop_log[slocation] + 1
diff --git a/tools/perf/tests/attr.c b/tools/perf/tests/attr.c
index 25638a986257..00218f503b2e 100644
--- a/tools/perf/tests/attr.c
+++ b/tools/perf/tests/attr.c
@@ -19,6 +19,11 @@
  * permissions. All the event text files are stored there.
  */
 
+/*
+ * Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
+ * 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
+ */
+#define __SANE_USERSPACE_TYPES__
 #include <stdlib.h>
 #include <stdio.h>
 #include <inttypes.h>
@@ -33,8 +38,6 @@
 
 extern int verbose;
 
-bool test_attr__enabled;
-
 static char *dir;
 
 void test_attr__init(void)
@@ -144,10 +147,15 @@ void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu,
 
 static int run_dir(const char *d, const char *perf)
 {
+        char v[] = "-vvvvv";
+        int vcnt = min(verbose, (int) sizeof(v) - 1);
         char cmd[3*PATH_MAX];
 
-        snprintf(cmd, 3*PATH_MAX, "python %s/attr.py -d %s/attr/ -p %s %s",
-                 d, d, perf, verbose ? "-v" : "");
+        if (verbose)
+                vcnt++;
+
+        snprintf(cmd, 3*PATH_MAX, PYTHON " %s/attr.py -d %s/attr/ -p %s %.*s",
+                 d, d, perf, vcnt, v);
 
         return system(cmd);
 }
@@ -170,6 +178,6 @@ int test__attr(void)
             !lstat(path_perf, &st))
                 return run_dir(path_dir, path_perf);
 
-        fprintf(stderr, " (ommitted)");
+        fprintf(stderr, " (omitted)");
         return 0;
 }
diff --git a/tools/perf/tests/attr.py b/tools/perf/tests/attr.py
index e702b82dcb86..c9b4b6269b51 100644
--- a/tools/perf/tests/attr.py
+++ b/tools/perf/tests/attr.py
@@ -24,6 +24,7 @@ class Unsup(Exception):
 
 class Event(dict):
     terms = [
+        'cpu',
         'flags',
         'type',
         'size',
@@ -68,7 +69,7 @@ class Event(dict):
             self[key] = val
 
     def __init__(self, name, data, base):
-        log.info("    Event %s" % name);
+        log.debug("    Event %s" % name);
         self.name  = name;
         self.group = ''
         self.add(base)
@@ -97,6 +98,14 @@ class Event(dict):
                 return False
         return True
 
+    def diff(self, other):
+        for t in Event.terms:
+            if not self.has_key(t) or not other.has_key(t):
+                continue
+            if not self.compare_data(self[t], other[t]):
+                log.warning("expected %s=%s, got %s" % (t, self[t], other[t]))
+                
+
 # Test file description needs to have following sections:
 # [config]
 #   - just single instance in file
@@ -128,7 +137,7 @@ class Test(object):
 
         self.expect   = {}
         self.result   = {}
-        log.info("  loading expected events");
+        log.debug("  loading expected events");
         self.load_events(path, self.expect)
 
     def is_event(self, name):
@@ -164,7 +173,7 @@ class Test(object):
               self.perf, self.command, tempdir, self.args)
         ret = os.WEXITSTATUS(os.system(cmd))
 
-        log.info("  running '%s' ret %d " % (cmd, ret))
+        log.info("  '%s' ret %d " % (cmd, ret))
 
         if ret != int(self.ret):
             raise Unsup(self)
@@ -172,7 +181,7 @@ class Test(object):
     def compare(self, expect, result):
         match = {}
 
-        log.info("  compare");
+        log.debug("  compare");
 
         # For each expected event find all matching
         # events in result. Fail if there's not any.
@@ -187,10 +196,11 @@ class Test(object):
                 else:
                     log.debug("    ->FAIL");
 
-            log.info("    match: [%s] matches %s" % (exp_name, str(exp_list)))
+            log.debug("    match: [%s] matches %s" % (exp_name, str(exp_list)))
 
             # we did not any matching event - fail
             if (not exp_list):
+                exp_event.diff(res_event)
                 raise Fail(self, 'match failure');
 
             match[exp_name] = exp_list
@@ -208,10 +218,10 @@ class Test(object):
                 if res_group not in match[group]:
                     raise Fail(self, 'group failure')
 
-                log.info("    group: [%s] matches group leader %s" %
+                log.debug("    group: [%s] matches group leader %s" %
                          (exp_name, str(match[group])))
 
-        log.info("  matched")
+        log.debug("  matched")
 
     def resolve_groups(self, events):
         for name, event in events.items():
@@ -233,7 +243,7 @@ class Test(object):
             self.run_cmd(tempdir);
 
             # load events expectation for the test
-            log.info("  loading result events");
+            log.debug("  loading result events");
             for f in glob.glob(tempdir + '/event*'):
                 self.load_events(f, self.result);
 
diff --git a/tools/perf/tests/attr/base-record b/tools/perf/tests/attr/base-record
index f1485d8e6a0b..e9bd6391f2ae 100644
--- a/tools/perf/tests/attr/base-record
+++ b/tools/perf/tests/attr/base-record
@@ -2,12 +2,13 @@
 fd=1
 group_fd=-1
 flags=0
+cpu=*
 type=0|1
 size=96
 config=0
 sample_period=4000
 sample_type=263
-read_format=7
+read_format=0
 disabled=1
 inherit=1
 pinned=0
@@ -26,8 +27,8 @@ watermark=0
 precise_ip=0
 mmap_data=0
 sample_id_all=1
-exclude_host=0
-exclude_guest=1
+exclude_host=0|1
+exclude_guest=0|1
 exclude_callchain_kernel=0
 exclude_callchain_user=0
 wakeup_events=0
diff --git a/tools/perf/tests/attr/base-stat b/tools/perf/tests/attr/base-stat
index 4bd79a82784f..91cd48b399f3 100644
--- a/tools/perf/tests/attr/base-stat
+++ b/tools/perf/tests/attr/base-stat
@@ -2,6 +2,7 @@
 fd=1
 group_fd=-1
 flags=0
+cpu=*
 type=0
 size=96
 config=0
@@ -26,8 +27,8 @@ watermark=0
 precise_ip=0
 mmap_data=0
 sample_id_all=0
-exclude_host=0
-exclude_guest=1
+exclude_host=0|1
+exclude_guest=0|1
 exclude_callchain_kernel=0
 exclude_callchain_user=0
 wakeup_events=0
diff --git a/tools/perf/tests/attr/test-record-C0 b/tools/perf/tests/attr/test-record-C0
new file mode 100644
index 000000000000..d6a7e43f61b3
--- /dev/null
+++ b/tools/perf/tests/attr/test-record-C0
@@ -0,0 +1,13 @@
+[config]
+command = record
+args    = -C 0 kill >/dev/null 2>&1
+
+[event:base-record]
+cpu=0
+
+# no enable on exec for CPU attached
+enable_on_exec=0
+
+# PERF_SAMPLE_IP | PERF_SAMPLE_TID PERF_SAMPLE_TIME | # PERF_SAMPLE_PERIOD
+# + PERF_SAMPLE_CPU added by -C 0
+sample_type=391
diff --git a/tools/perf/tests/attr/test-record-data b/tools/perf/tests/attr/test-record-data
index 6627c3e7534a..716e143b5291 100644
--- a/tools/perf/tests/attr/test-record-data
+++ b/tools/perf/tests/attr/test-record-data
@@ -4,5 +4,8 @@ args    = -d kill >/dev/null 2>&1
 
 [event:base-record]
 sample_period=4000
-sample_type=271
+
+# sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_TIME |
+# PERF_SAMPLE_ADDR | PERF_SAMPLE_PERIOD | PERF_SAMPLE_DATA_SRC
+sample_type=33039
 mmap_data=1
diff --git a/tools/perf/tests/attr/test-record-group b/tools/perf/tests/attr/test-record-group
index a6599e9a19d3..57739cacdb2a 100644
--- a/tools/perf/tests/attr/test-record-group
+++ b/tools/perf/tests/attr/test-record-group
@@ -6,12 +6,14 @@ args    = --group -e cycles,instructions kill >/dev/null 2>&1
 fd=1
 group_fd=-1
 sample_type=327
+read_format=4
 
 [event-2:base-record]
 fd=2
 group_fd=1
 config=1
 sample_type=327
+read_format=4
 mmap=0
 comm=0
 enable_on_exec=0
diff --git a/tools/perf/tests/attr/test-record-group1 b/tools/perf/tests/attr/test-record-group1
index 5a8359da38af..c5548d054aff 100644
--- a/tools/perf/tests/attr/test-record-group1
+++ b/tools/perf/tests/attr/test-record-group1
@@ -1,11 +1,12 @@
 [config]
 command = record
-args    = -e '{cycles,instructions}' kill >/tmp/krava 2>&1
+args    = -e '{cycles,instructions}' kill >/dev/null 2>&1
 
 [event-1:base-record]
 fd=1
 group_fd=-1
 sample_type=327
+read_format=4
 
 [event-2:base-record]
 fd=2
@@ -13,6 +14,7 @@ group_fd=1
 type=0
 config=1
 sample_type=327
+read_format=4
 mmap=0
 comm=0
 enable_on_exec=0
diff --git a/tools/perf/tests/attr/test-stat-C0 b/tools/perf/tests/attr/test-stat-C0
new file mode 100644
index 000000000000..aa835950751f
--- /dev/null
+++ b/tools/perf/tests/attr/test-stat-C0
@@ -0,0 +1,9 @@
+[config]
+command = stat
+args    = -e cycles -C 0 kill >/dev/null 2>&1
+ret     = 1
+
+[event:base-stat]
+# events are enabled by default when attached to cpu
+disabled=0
+enable_on_exec=0
diff --git a/tools/perf/tests/bp_signal.c b/tools/perf/tests/bp_signal.c
new file mode 100644
index 000000000000..aba095489193
--- /dev/null
+++ b/tools/perf/tests/bp_signal.c
@@ -0,0 +1,192 @@
+/*
+ * Inspired by breakpoint overflow test done by
+ * Vince Weaver <vincent.weaver@maine.edu> for perf_event_tests
+ * (git://github.com/deater/perf_event_tests)
+ */
+
+/*
+ * Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
+ * 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
+ */
+#define __SANE_USERSPACE_TYPES__
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <linux/compiler.h>
+#include <linux/hw_breakpoint.h>
+
+#include "tests.h"
+#include "debug.h"
+#include "perf.h"
+
+static int fd1;
+static int fd2;
+static int overflows;
+
+__attribute__ ((noinline))
+static int test_function(void)
+{
+        return time(NULL);
+}
+
+static void sig_handler(int signum __maybe_unused,
+                        siginfo_t *oh __maybe_unused,
+                        void *uc __maybe_unused)
+{
+        overflows++;
+
+        if (overflows > 10) {
+                /*
+                 * This should be executed only once during
+                 * this test, if we are here for the 10th
+                 * time, consider this the recursive issue.
+                 *
+                 * We can get out of here by disable events,
+                 * so no new SIGIO is delivered.
+                 */
+                ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
+                ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
+        }
+}
+
+static int bp_event(void *fn, int setup_signal)
+{
+        struct perf_event_attr pe;
+        int fd;
+
+        memset(&pe, 0, sizeof(struct perf_event_attr));
+        pe.type = PERF_TYPE_BREAKPOINT;
+        pe.size = sizeof(struct perf_event_attr);
+
+        pe.config = 0;
+        pe.bp_type = HW_BREAKPOINT_X;
+        pe.bp_addr = (unsigned long) fn;
+        pe.bp_len = sizeof(long);
+
+        pe.sample_period = 1;
+        pe.sample_type = PERF_SAMPLE_IP;
+        pe.wakeup_events = 1;
+
+        pe.disabled = 1;
+        pe.exclude_kernel = 1;
+        pe.exclude_hv = 1;
+
+        fd = sys_perf_event_open(&pe, 0, -1, -1, 0);
+        if (fd < 0) {
+                pr_debug("failed opening event %llx\n", pe.config);
+                return TEST_FAIL;
+        }
+
+        if (setup_signal) {
+                fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);
+                fcntl(fd, F_SETSIG, SIGIO);
+                fcntl(fd, F_SETOWN, getpid());
+        }
+
+        ioctl(fd, PERF_EVENT_IOC_RESET, 0);
+
+        return fd;
+}
+
+static long long bp_count(int fd)
+{
+        long long count;
+        int ret;
+
+        ret = read(fd, &count, sizeof(long long));
+        if (ret != sizeof(long long)) {
+                pr_debug("failed to read: %d\n", ret);
+                return TEST_FAIL;
+        }
+
+        return count;
+}
+
+int test__bp_signal(void)
+{
+        struct sigaction sa;
+        long long count1, count2;
+
+        /* setup SIGIO signal handler */
+        memset(&sa, 0, sizeof(struct sigaction));
+        sa.sa_sigaction = (void *) sig_handler;
+        sa.sa_flags = SA_SIGINFO;
+
+        if (sigaction(SIGIO, &sa, NULL) < 0) {
+                pr_debug("failed setting up signal handler\n");
+                return TEST_FAIL;
+        }
+
+        /*
+         * We create following events:
+         *
+         * fd1 - breakpoint event on test_function with SIGIO
+         *       signal configured. We should get signal
+         *       notification each time the breakpoint is hit
+         *
+         * fd2 - breakpoint event on sig_handler without SIGIO
+         *       configured.
+         *
+         * Following processing should happen:
+         *   - execute test_function
+         *   - fd1 event breakpoint hit -> count1 == 1
+         *   - SIGIO is delivered       -> overflows == 1
+         *   - fd2 event breakpoint hit -> count2 == 1
+         *
+         * The test case check following error conditions:
+         * - we get stuck in signal handler because of debug
+         *   exception being triggered receursively due to
+         *   the wrong RF EFLAG management
+         *
+         * - we never trigger the sig_handler breakpoint due
+         *   to the rong RF EFLAG management
+         *
+         */
+
+        fd1 = bp_event(test_function, 1);
+        fd2 = bp_event(sig_handler, 0);
+
+        ioctl(fd1, PERF_EVENT_IOC_ENABLE, 0);
+        ioctl(fd2, PERF_EVENT_IOC_ENABLE, 0);
+
+        /*
+         * Kick off the test by trigering 'fd1'
+         * breakpoint.
+         */
+        test_function();
+
+        ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
+        ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
+
+        count1 = bp_count(fd1);
+        count2 = bp_count(fd2);
+
+        close(fd1);
+        close(fd2);
+
+        pr_debug("count1 %lld, count2 %lld, overflow %d\n",
+                 count1, count2, overflows);
+
+        if (count1 != 1) {
+                if (count1 == 11)
+                        pr_debug("failed: RF EFLAG recursion issue detected\n");
+                else
+                        pr_debug("failed: wrong count for bp1%lld\n", count1);
+        }
+
+        if (overflows != 1)
+                pr_debug("failed: wrong overflow hit\n");
+
+        if (count2 != 1)
+                pr_debug("failed: wrong count for bp2\n");
+
+        return count1 == 1 && overflows == 1 && count2 == 1 ?
+                TEST_OK : TEST_FAIL;
+}
diff --git a/tools/perf/tests/bp_signal_overflow.c b/tools/perf/tests/bp_signal_overflow.c
new file mode 100644
index 000000000000..44ac82179708
--- /dev/null
+++ b/tools/perf/tests/bp_signal_overflow.c
@@ -0,0 +1,132 @@
+/*
+ * Originally done by Vince Weaver <vincent.weaver@maine.edu> for
+ * perf_event_tests (git://github.com/deater/perf_event_tests)
+ */
+
+/*
+ * Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
+ * 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
+ */
+#define __SANE_USERSPACE_TYPES__
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <linux/compiler.h>
+#include <linux/hw_breakpoint.h>
+
+#include "tests.h"
+#include "debug.h"
+#include "perf.h"
+
+static int overflows;
+
+__attribute__ ((noinline))
+static int test_function(void)
+{
+        return time(NULL);
+}
+
+static void sig_handler(int signum __maybe_unused,
+                        siginfo_t *oh __maybe_unused,
+                        void *uc __maybe_unused)
+{
+        overflows++;
+}
+
+static long long bp_count(int fd)
+{
+        long long count;
+        int ret;
+
+        ret = read(fd, &count, sizeof(long long));
+        if (ret != sizeof(long long)) {
+                pr_debug("failed to read: %d\n", ret);
+                return TEST_FAIL;
+        }
+
+        return count;
+}
+
+#define EXECUTIONS 10000
+#define THRESHOLD  100
+
+int test__bp_signal_overflow(void)
+{
+        struct perf_event_attr pe;
+        struct sigaction sa;
+        long long count;
+        int fd, i, fails = 0;
+
+        /* setup SIGIO signal handler */
+        memset(&sa, 0, sizeof(struct sigaction));
+        sa.sa_sigaction = (void *) sig_handler;
+        sa.sa_flags = SA_SIGINFO;
+
+        if (sigaction(SIGIO, &sa, NULL) < 0) {
+                pr_debug("failed setting up signal handler\n");
+                return TEST_FAIL;
+        }
+
+        memset(&pe, 0, sizeof(struct perf_event_attr));
+        pe.type = PERF_TYPE_BREAKPOINT;
+        pe.size = sizeof(struct perf_event_attr);
+
+        pe.config = 0;
+        pe.bp_type = HW_BREAKPOINT_X;
+        pe.bp_addr = (unsigned long) test_function;
+        pe.bp_len = sizeof(long);
+
+        pe.sample_period = THRESHOLD;
+        pe.sample_type = PERF_SAMPLE_IP;
+        pe.wakeup_events = 1;
+
+        pe.disabled = 1;
+        pe.exclude_kernel = 1;
+        pe.exclude_hv = 1;
+
+        fd = sys_perf_event_open(&pe, 0, -1, -1, 0);
+        if (fd < 0) {
+                pr_debug("failed opening event %llx\n", pe.config);
+                return TEST_FAIL;
+        }
+
+        fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);
+        fcntl(fd, F_SETSIG, SIGIO);
+        fcntl(fd, F_SETOWN, getpid());
+
+        ioctl(fd, PERF_EVENT_IOC_RESET, 0);
+        ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
+
+        for (i = 0; i < EXECUTIONS; i++)
+                test_function();
+
+        ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);
+
+        count = bp_count(fd);
+
+        close(fd);
+
+        pr_debug("count %lld, overflow %d\n",
+                 count, overflows);
+
+        if (count != EXECUTIONS) {
+                pr_debug("\tWrong number of executions %lld != %d\n",
+                count, EXECUTIONS);
+                fails++;
+        }
+
+        if (overflows != EXECUTIONS / THRESHOLD) {
+                pr_debug("\tWrong number of overflows %d != %d\n",
+                overflows, EXECUTIONS / THRESHOLD);
+                fails++;
+        }
+
+        return fails ? TEST_FAIL : TEST_OK;
+}
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 186f67535494..35b45f1466b5 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -4,6 +4,7 @@
  * Builtin regression testing command: ever growing number of sanity tests
  */
 #include "builtin.h"
+#include "intlist.h"
 #include "tests.h"
 #include "debug.h"
 #include "color.h"
@@ -69,6 +70,30 @@ static struct test {
                 .func = test__attr,
         },
         {
+                .desc = "Test matching and linking multiple hists",
+                .func = test__hists_link,
+        },
+        {
+                .desc = "Try 'use perf' in python, checking link problems",
+                .func = test__python_use,
+        },
+        {
+                .desc = "Test breakpoint overflow signal handler",
+                .func = test__bp_signal,
+        },
+        {
+                .desc = "Test breakpoint overflow sampling",
+                .func = test__bp_signal_overflow,
+        },
+        {
+                .desc = "Test number of exit event of a simple workload",
+                .func = test__task_exit,
+        },
+        {
+                .desc = "Test software clock events have valid period values",
+                .func = test__sw_clock_freq,
+        },
+        {
                 .func = NULL,
         },
 };
@@ -97,7 +122,7 @@ static bool perf_test__matches(int curr, int argc, const char *argv[])
         return false;
 }
 
-static int __cmd_test(int argc, const char *argv[])
+static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist)
 {
         int i = 0;
         int width = 0;
@@ -118,13 +143,28 @@ static int __cmd_test(int argc, const char *argv[])
                         continue;
 
                 pr_info("%2d: %-*s:", i, width, tests[curr].desc);
+
+                if (intlist__find(skiplist, i)) {
+                        color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n");
+                        continue;
+                }
+
                 pr_debug("\n--- start ---\n");
                 err = tests[curr].func();
                 pr_debug("---- end ----\n%s:", tests[curr].desc);
-                if (err)
-                        color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n");
-                else
+
+                switch (err) {
+                case TEST_OK:
                         pr_info(" Ok\n");
+                        break;
+                case TEST_SKIP:
+                        color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip\n");
+                        break;
+                case TEST_FAIL:
+                default:
+                        color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n");
+                        break;
+                }
         }
 
         return 0;
@@ -152,11 +192,14 @@ int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
         "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
         NULL,
         };
+        const char *skip = NULL;
         const struct option test_options[] = {
+        OPT_STRING('s', "skip", &skip, "tests", "tests to skip"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_END()
         };
+        struct intlist *skiplist = NULL;
 
         argc = parse_options(argc, argv, test_options, test_usage, 0);
         if (argc >= 1 && !strcmp(argv[0], "list"))
@@ -169,5 +212,8 @@ int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
         if (symbol__init() < 0)
                 return -1;
 
-        return __cmd_test(argc, argv);
+        if (skip != NULL)
+                skiplist = intlist__new(skip);
+
+        return __cmd_test(argc, argv, skiplist);
 }
diff --git a/tools/perf/tests/evsel-roundtrip-name.c b/tools/perf/tests/evsel-roundtrip-name.c
index e61fc828a158..0197bda9c461 100644
--- a/tools/perf/tests/evsel-roundtrip-name.c
+++ b/tools/perf/tests/evsel-roundtrip-name.c
@@ -8,7 +8,7 @@ static int perf_evsel__roundtrip_cache_name_test(void)
         char name[128];
         int type, op, err = 0, ret = 0, i, idx;
         struct perf_evsel *evsel;
-        struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
+        struct perf_evlist *evlist = perf_evlist__new();
 
         if (evlist == NULL)
                 return -ENOMEM;
@@ -22,7 +22,7 @@ static int perf_evsel__roundtrip_cache_name_test(void)
                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
                                 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
                                                                         name, sizeof(name));
-                                err = parse_events(evlist, name, 0);
+                                err = parse_events(evlist, name);
                                 if (err)
                                         ret = err;
                         }
@@ -64,13 +64,13 @@ static int __perf_evsel__name_array_test(const char *names[], int nr_names)
 {
         int i, err;
         struct perf_evsel *evsel;
-        struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
+        struct perf_evlist *evlist = perf_evlist__new();
 
         if (evlist == NULL)
                 return -ENOMEM;
 
         for (i = 0; i < nr_names; ++i) {
-                err = parse_events(evlist, names[i], 0);
+                err = parse_events(evlist, names[i]);
                 if (err) {
                         pr_debug("failed to parse event '%s', err %d\n",
                                  names[i], err);
diff --git a/tools/perf/tests/hists_link.c b/tools/perf/tests/hists_link.c
new file mode 100644
index 000000000000..89085a9615e2
--- /dev/null
+++ b/tools/perf/tests/hists_link.c
@@ -0,0 +1,500 @@
+#include "perf.h"
+#include "tests.h"
+#include "debug.h"
+#include "symbol.h"
+#include "sort.h"
+#include "evsel.h"
+#include "evlist.h"
+#include "machine.h"
+#include "thread.h"
+#include "parse-events.h"
+
+static struct {
+        u32 pid;
+        const char *comm;
+} fake_threads[] = {
+        { 100, "perf" },
+        { 200, "perf" },
+        { 300, "bash" },
+};
+
+static struct {
+        u32 pid;
+        u64 start;
+        const char *filename;
+} fake_mmap_info[] = {
+        { 100, 0x40000, "perf" },
+        { 100, 0x50000, "libc" },
+        { 100, 0xf0000, "[kernel]" },
+        { 200, 0x40000, "perf" },
+        { 200, 0x50000, "libc" },
+        { 200, 0xf0000, "[kernel]" },
+        { 300, 0x40000, "bash" },
+        { 300, 0x50000, "libc" },
+        { 300, 0xf0000, "[kernel]" },
+};
+
+struct fake_sym {
+        u64 start;
+        u64 length;
+        const char *name;
+};
+
+static struct fake_sym perf_syms[] = {
+        { 700, 100, "main" },
+        { 800, 100, "run_command" },
+        { 900, 100, "cmd_record" },
+};
+
+static struct fake_sym bash_syms[] = {
+        { 700, 100, "main" },
+        { 800, 100, "xmalloc" },
+        { 900, 100, "xfree" },
+};
+
+static struct fake_sym libc_syms[] = {
+        { 700, 100, "malloc" },
+        { 800, 100, "free" },
+        { 900, 100, "realloc" },
+};
+
+static struct fake_sym kernel_syms[] = {
+        { 700, 100, "schedule" },
+        { 800, 100, "page_fault" },
+        { 900, 100, "sys_perf_event_open" },
+};
+
+static struct {
+        const char *dso_name;
+        struct fake_sym *syms;
+        size_t nr_syms;
+} fake_symbols[] = {
+        { "perf", perf_syms, ARRAY_SIZE(perf_syms) },
+        { "bash", bash_syms, ARRAY_SIZE(bash_syms) },
+        { "libc", libc_syms, ARRAY_SIZE(libc_syms) },
+        { "[kernel]", kernel_syms, ARRAY_SIZE(kernel_syms) },
+};
+
+static struct machine *setup_fake_machine(struct machines *machines)
+{
+        struct machine *machine = machines__find(machines, HOST_KERNEL_ID);
+        size_t i;
+
+        if (machine == NULL) {
+                pr_debug("Not enough memory for machine setup\n");
+                return NULL;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
+                struct thread *thread;
+
+                thread = machine__findnew_thread(machine, fake_threads[i].pid);
+                if (thread == NULL)
+                        goto out;
+
+                thread__set_comm(thread, fake_threads[i].comm);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(fake_mmap_info); i++) {
+                union perf_event fake_mmap_event = {
+                        .mmap = {
+                                .header = { .misc = PERF_RECORD_MISC_USER, },
+                                .pid = fake_mmap_info[i].pid,
+                                .start = fake_mmap_info[i].start,
+                                .len = 0x1000ULL,
+                                .pgoff = 0ULL,
+                        },
+                };
+
+                strcpy(fake_mmap_event.mmap.filename,
+                       fake_mmap_info[i].filename);
+
+                machine__process_mmap_event(machine, &fake_mmap_event);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(fake_symbols); i++) {
+                size_t k;
+                struct dso *dso;
+
+                dso = __dsos__findnew(&machine->user_dsos,
+                                      fake_symbols[i].dso_name);
+                if (dso == NULL)
+                        goto out;
+
+                /* emulate dso__load() */
+                dso__set_loaded(dso, MAP__FUNCTION);
+
+                for (k = 0; k < fake_symbols[i].nr_syms; k++) {
+                        struct symbol *sym;
+                        struct fake_sym *fsym = &fake_symbols[i].syms[k];
+
+                        sym = symbol__new(fsym->start, fsym->length,
+                                          STB_GLOBAL, fsym->name);
+                        if (sym == NULL)
+                                goto out;
+
+                        symbols__insert(&dso->symbols[MAP__FUNCTION], sym);
+                }
+        }
+
+        return machine;
+
+out:
+        pr_debug("Not enough memory for machine setup\n");
+        machine__delete_threads(machine);
+        machine__delete(machine);
+        return NULL;
+}
+
+struct sample {
+        u32 pid;
+        u64 ip;
+        struct thread *thread;
+        struct map *map;
+        struct symbol *sym;
+};
+
+static struct sample fake_common_samples[] = {
+        /* perf [kernel] schedule() */
+        { .pid = 100, .ip = 0xf0000 + 700, },
+        /* perf [perf]   main() */
+        { .pid = 200, .ip = 0x40000 + 700, },
+        /* perf [perf]   cmd_record() */
+        { .pid = 200, .ip = 0x40000 + 900, },
+        /* bash [bash]   xmalloc() */
+        { .pid = 300, .ip = 0x40000 + 800, },
+        /* bash [libc]   malloc() */
+        { .pid = 300, .ip = 0x50000 + 700, },
+};
+
+static struct sample fake_samples[][5] = {
+        {
+                /* perf [perf]   run_command() */
+                { .pid = 100, .ip = 0x40000 + 800, },
+                /* perf [libc]   malloc() */
+                { .pid = 100, .ip = 0x50000 + 700, },
+                /* perf [kernel] page_fault() */
+                { .pid = 100, .ip = 0xf0000 + 800, },
+                /* perf [kernel] sys_perf_event_open() */
+                { .pid = 200, .ip = 0xf0000 + 900, },
+                /* bash [libc]   free() */
+                { .pid = 300, .ip = 0x50000 + 800, },
+        },
+        {
+                /* perf [libc]   free() */
+                { .pid = 200, .ip = 0x50000 + 800, },
+                /* bash [libc]   malloc() */
+                { .pid = 300, .ip = 0x50000 + 700, }, /* will be merged */
+                /* bash [bash]   xfee() */
+                { .pid = 300, .ip = 0x40000 + 900, },
+                /* bash [libc]   realloc() */
+                { .pid = 300, .ip = 0x50000 + 900, },
+                /* bash [kernel] page_fault() */
+                { .pid = 300, .ip = 0xf0000 + 800, },
+        },
+};
+
+static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
+{
+        struct perf_evsel *evsel;
+        struct addr_location al;
+        struct hist_entry *he;
+        struct perf_sample sample = { .cpu = 0, };
+        size_t i = 0, k;
+
+        /*
+         * each evsel will have 10 samples - 5 common and 5 distinct.
+         * However the second evsel also has a collapsed entry for
+         * "bash [libc] malloc" so total 9 entries will be in the tree.
+         */
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
+                        const union perf_event event = {
+                                .ip = {
+                                        .header = {
+                                                .misc = PERF_RECORD_MISC_USER,
+                                        },
+                                        .pid = fake_common_samples[k].pid,
+                                        .ip  = fake_common_samples[k].ip,
+                                },
+                        };
+
+                        if (perf_event__preprocess_sample(&event, machine, &al,
+                                                          &sample, 0) < 0)
+                                goto out;
+
+                        he = __hists__add_entry(&evsel->hists, &al, NULL, 1, 1);
+                        if (he == NULL)
+                                goto out;
+
+                        fake_common_samples[k].thread = al.thread;
+                        fake_common_samples[k].map = al.map;
+                        fake_common_samples[k].sym = al.sym;
+                }
+
+                for (k = 0; k < ARRAY_SIZE(fake_samples[i]); k++) {
+                        const union perf_event event = {
+                                .ip = {
+                                        .header = {
+                                                .misc = PERF_RECORD_MISC_USER,
+                                        },
+                                        .pid = fake_samples[i][k].pid,
+                                        .ip  = fake_samples[i][k].ip,
+                                },
+                        };
+
+                        if (perf_event__preprocess_sample(&event, machine, &al,
+                                                          &sample, 0) < 0)
+                                goto out;
+
+                        he = __hists__add_entry(&evsel->hists, &al, NULL, 1, 1);
+                        if (he == NULL)
+                                goto out;
+
+                        fake_samples[i][k].thread = al.thread;
+                        fake_samples[i][k].map = al.map;
+                        fake_samples[i][k].sym = al.sym;
+                }
+                i++;
+        }
+
+        return 0;
+
+out:
+        pr_debug("Not enough memory for adding a hist entry\n");
+        return -1;
+}
+
+static int find_sample(struct sample *samples, size_t nr_samples,
+                       struct thread *t, struct map *m, struct symbol *s)
+{
+        while (nr_samples--) {
+                if (samples->thread == t && samples->map == m &&
+                    samples->sym == s)
+                        return 1;
+                samples++;
+        }
+        return 0;
+}
+
+static int __validate_match(struct hists *hists)
+{
+        size_t count = 0;
+        struct rb_root *root;
+        struct rb_node *node;
+
+        /*
+         * Only entries from fake_common_samples should have a pair.
+         */
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
+
+        node = rb_first(root);
+        while (node) {
+                struct hist_entry *he;
+
+                he = rb_entry(node, struct hist_entry, rb_node_in);
+
+                if (hist_entry__has_pairs(he)) {
+                        if (find_sample(fake_common_samples,
+                                        ARRAY_SIZE(fake_common_samples),
+                                        he->thread, he->ms.map, he->ms.sym)) {
+                                count++;
+                        } else {
+                                pr_debug("Can't find the matched entry\n");
+                                return -1;
+                        }
+                }
+
+                node = rb_next(node);
+        }
+
+        if (count != ARRAY_SIZE(fake_common_samples)) {
+                pr_debug("Invalid count for matched entries: %zd of %zd\n",
+                         count, ARRAY_SIZE(fake_common_samples));
+                return -1;
+        }
+
+        return 0;
+}
+
+static int validate_match(struct hists *leader, struct hists *other)
+{
+        return __validate_match(leader) || __validate_match(other);
+}
+
+static int __validate_link(struct hists *hists, int idx)
+{
+        size_t count = 0;
+        size_t count_pair = 0;
+        size_t count_dummy = 0;
+        struct rb_root *root;
+        struct rb_node *node;
+
+        /*
+         * Leader hists (idx = 0) will have dummy entries from other,
+         * and some entries will have no pair.  However every entry
+         * in other hists should have (dummy) pair.
+         */
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
+
+        node = rb_first(root);
+        while (node) {
+                struct hist_entry *he;
+
+                he = rb_entry(node, struct hist_entry, rb_node_in);
+
+                if (hist_entry__has_pairs(he)) {
+                        if (!find_sample(fake_common_samples,
+                                         ARRAY_SIZE(fake_common_samples),
+                                         he->thread, he->ms.map, he->ms.sym) &&
+                            !find_sample(fake_samples[idx],
+                                         ARRAY_SIZE(fake_samples[idx]),
+                                         he->thread, he->ms.map, he->ms.sym)) {
+                                count_dummy++;
+                        }
+                        count_pair++;
+                } else if (idx) {
+                        pr_debug("A entry from the other hists should have pair\n");
+                        return -1;
+                }
+
+                count++;
+                node = rb_next(node);
+        }
+
+        /*
+         * Note that we have a entry collapsed in the other (idx = 1) hists.
+         */
+        if (idx == 0) {
+                if (count_dummy != ARRAY_SIZE(fake_samples[1]) - 1) {
+                        pr_debug("Invalid count of dummy entries: %zd of %zd\n",
+                                 count_dummy, ARRAY_SIZE(fake_samples[1]) - 1);
+                        return -1;
+                }
+                if (count != count_pair + ARRAY_SIZE(fake_samples[0])) {
+                        pr_debug("Invalid count of total leader entries: %zd of %zd\n",
+                                 count, count_pair + ARRAY_SIZE(fake_samples[0]));
+                        return -1;
+                }
+        } else {
+                if (count != count_pair) {
+                        pr_debug("Invalid count of total other entries: %zd of %zd\n",
+                                 count, count_pair);
+                        return -1;
+                }
+                if (count_dummy > 0) {
+                        pr_debug("Other hists should not have dummy entries: %zd\n",
+                                 count_dummy);
+                        return -1;
+                }
+        }
+
+        return 0;
+}
+
+static int validate_link(struct hists *leader, struct hists *other)
+{
+        return __validate_link(leader, 0) || __validate_link(other, 1);
+}
+
+static void print_hists(struct hists *hists)
+{
+        int i = 0;
+        struct rb_root *root;
+        struct rb_node *node;
+
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
+
+        pr_info("----- %s --------\n", __func__);
+        node = rb_first(root);
+        while (node) {
+                struct hist_entry *he;
+
+                he = rb_entry(node, struct hist_entry, rb_node_in);
+
+                pr_info("%2d: entry: %-8s [%-8s] %20s: period = %"PRIu64"\n",
+                        i, he->thread->comm, he->ms.map->dso->short_name,
+                        he->ms.sym->name, he->stat.period);
+
+                i++;
+                node = rb_next(node);
+        }
+}
+
+int test__hists_link(void)
+{
+        int err = -1;
+        struct machines machines;
+        struct machine *machine = NULL;
+        struct perf_evsel *evsel, *first;
+        struct perf_evlist *evlist = perf_evlist__new();
+
+        if (evlist == NULL)
+                return -ENOMEM;
+
+        err = parse_events(evlist, "cpu-clock");
+        if (err)
+                goto out;
+        err = parse_events(evlist, "task-clock");
+        if (err)
+                goto out;
+
+        /* default sort order (comm,dso,sym) will be used */
+        if (setup_sorting() < 0)
+                goto out;
+
+        machines__init(&machines);
+
+        /* setup threads/dso/map/symbols also */
+        machine = setup_fake_machine(&machines);
+        if (!machine)
+                goto out;
+
+        if (verbose > 1)
+                machine__fprintf(machine, stderr);
+
+        /* process sample events */
+        err = add_hist_entries(evlist, machine);
+        if (err < 0)
+                goto out;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                hists__collapse_resort(&evsel->hists);
+
+                if (verbose > 2)
+                        print_hists(&evsel->hists);
+        }
+
+        first = perf_evlist__first(evlist);
+        evsel = perf_evlist__last(evlist);
+
+        /* match common entries */
+        hists__match(&first->hists, &evsel->hists);
+        err = validate_match(&first->hists, &evsel->hists);
+        if (err)
+                goto out;
+
+        /* link common and/or dummy entries */
+        hists__link(&first->hists, &evsel->hists);
+        err = validate_link(&first->hists, &evsel->hists);
+        if (err)
+                goto out;
+
+        err = 0;
+
+out:
+        /* tear down everything */
+        perf_evlist__delete(evlist);
+        machines__exit(&machines);
+
+        return err;
+}
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
new file mode 100644
index 000000000000..c441a2875128
--- /dev/null
+++ b/tools/perf/tests/make
@@ -0,0 +1,138 @@
+PERF := .
+MK   := Makefile
+
+# standard single make variable specified
+make_clean_all      := clean all
+make_python_perf_so := python/perf.so
+make_debug          := DEBUG=1
+make_no_libperl     := NO_LIBPERL=1
+make_no_libpython   := NO_LIBPYTHON=1
+make_no_scripts     := NO_LIBPYTHON=1 NO_LIBPERL=1
+make_no_newt        := NO_NEWT=1
+make_no_slang       := NO_SLANG=1
+make_no_gtk2        := NO_GTK2=1
+make_no_ui          := NO_NEWT=1 NO_SLANG=1 NO_GTK2=1
+make_no_demangle    := NO_DEMANGLE=1
+make_no_libelf      := NO_LIBELF=1
+make_no_libunwind   := NO_LIBUNWIND=1
+make_no_backtrace   := NO_BACKTRACE=1
+make_no_libnuma     := NO_LIBNUMA=1
+make_no_libaudit    := NO_LIBAUDIT=1
+make_no_libbionic   := NO_LIBBIONIC=1
+make_tags           := tags
+make_cscope         := cscope
+make_help           := help
+make_doc            := doc
+make_perf_o         := perf.o
+make_util_map_o     := util/map.o
+
+# all the NO_* variable combined
+make_minimal        := NO_LIBPERL=1 NO_LIBPYTHON=1 NO_NEWT=1 NO_GTK2=1
+make_minimal        += NO_DEMANGLE=1 NO_LIBELF=1 NO_LIBUNWIND=1 NO_BACKTRACE=1
+make_minimal        += NO_LIBNUMA=1 NO_LIBAUDIT=1 NO_LIBBIONIC=1
+
+# $(run) contains all available tests
+run := make_pure
+run += make_clean_all
+run += make_python_perf_so
+run += make_debug
+run += make_no_libperl
+run += make_no_libpython
+run += make_no_scripts
+run += make_no_newt
+run += make_no_slang
+run += make_no_gtk2
+run += make_no_ui
+run += make_no_demangle
+run += make_no_libelf
+run += make_no_libunwind
+run += make_no_backtrace
+run += make_no_libnuma
+run += make_no_libaudit
+run += make_no_libbionic
+run += make_tags
+run += make_cscope
+run += make_help
+run += make_doc
+run += make_perf_o
+run += make_util_map_o
+run += make_minimal
+
+# $(run_O) contains same portion of $(run) tests with '_O' attached
+# to distinguish O=... tests
+run_O := $(addsuffix _O,$(run))
+
+# disable some tests for O=...
+run_O := $(filter-out make_python_perf_so_O,$(run_O))
+
+# define test for each compile as 'test_NAME' variable
+# with the test itself as a value
+test_make_tags   = test -f tags
+test_make_cscope = test -f cscope.out
+
+test_make_tags_O   := $(test_make_tags)
+test_make_cscope_O := $(test_make_cscope)
+
+test_ok          := true
+test_make_help   := $(test_ok)
+test_make_doc    := $(test_ok)
+test_make_help_O := $(test_ok)
+test_make_doc_O  := $(test_ok)
+
+test_make_python_perf_so := test -f $(PERF)/python/perf.so
+
+test_make_perf_o     := test -f $(PERF)/perf.o
+test_make_util_map_o := test -f $(PERF)/util/map.o
+
+# Kbuild tests only
+#test_make_python_perf_so_O := test -f $$TMP/tools/perf/python/perf.so
+#test_make_perf_o_O         := test -f $$TMP/tools/perf/perf.o
+#test_make_util_map_o_O     := test -f $$TMP/tools/perf/util/map.o
+
+test_make_perf_o_O     := true
+test_make_util_map_o_O := true
+
+test_default = test -x $(PERF)/perf
+test = $(if $(test_$1),$(test_$1),$(test_default))
+
+test_default_O = test -x $$TMP/perf
+test_O = $(if $(test_$1),$(test_$1),$(test_default_O))
+
+all:
+
+ifdef DEBUG
+d := $(info run   $(run))
+d := $(info run_O $(run_O))
+endif
+
+MAKEFLAGS := --no-print-directory
+
+clean := @(cd $(PERF); make -s -f $(MK) clean >/dev/null)
+
+$(run):
+        $(call clean)
+        @cmd="cd $(PERF) && make -f $(MK) $($@)"; \
+        echo "- $@: $$cmd" && echo $$cmd > $@ && \
+        ( eval $$cmd ) >> $@ 2>&1; \
+        echo "  test: $(call test,$@)"; \
+        $(call test,$@) && \
+        rm -f $@
+
+$(run_O):
+        $(call clean)
+        @TMP=$$(mktemp -d); \
+        cmd="cd $(PERF) && make -f $(MK) $($(patsubst %_O,%,$@)) O=$$TMP"; \
+        echo "- $@: $$cmd" && echo $$cmd > $@ && \
+        ( eval $$cmd ) >> $@ 2>&1 && \
+        echo "  test: $(call test_O,$@)"; \
+        $(call test_O,$@) && \
+        rm -f $@ && \
+        rm -rf $$TMP
+
+all: $(run) $(run_O)
+        @echo OK
+
+out: $(run_O)
+        @echo OK
+
+.PHONY: all $(run) $(run_O) clean
diff --git a/tools/perf/tests/mmap-basic.c b/tools/perf/tests/mmap-basic.c
index e1746811e14b..5b1b5aba722b 100644
--- a/tools/perf/tests/mmap-basic.c
+++ b/tools/perf/tests/mmap-basic.c
@@ -22,36 +22,16 @@ int test__basic_mmap(void)
         struct thread_map *threads;
         struct cpu_map *cpus;
         struct perf_evlist *evlist;
-        struct perf_event_attr attr = {
-                .type           = PERF_TYPE_TRACEPOINT,
-                .read_format    = PERF_FORMAT_ID,
-                .sample_type    = PERF_SAMPLE_ID,
-                .watermark      = 0,
-        };
         cpu_set_t cpu_set;
         const char *syscall_names[] = { "getsid", "getppid", "getpgrp",
                                         "getpgid", };
         pid_t (*syscalls[])(void) = { (void *)getsid, getppid, getpgrp,
                                       (void*)getpgid };
 #define nsyscalls ARRAY_SIZE(syscall_names)
-        int ids[nsyscalls];
         unsigned int nr_events[nsyscalls],
                      expected_nr_events[nsyscalls], i, j;
         struct perf_evsel *evsels[nsyscalls], *evsel;
 
-        for (i = 0; i < nsyscalls; ++i) {
-                char name[64];
-
-                snprintf(name, sizeof(name), "sys_enter_%s", syscall_names[i]);
-                ids[i] = trace_event__id(name);
-                if (ids[i] < 0) {
-                        pr_debug("Is debugfs mounted on /sys/kernel/debug?\n");
-                        return -1;
-                }
-                nr_events[i] = 0;
-                expected_nr_events[i] = random() % 257;
-        }
-
         threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
@@ -73,24 +53,27 @@ int test__basic_mmap(void)
                 goto out_free_cpus;
         }
 
-        evlist = perf_evlist__new(cpus, threads);
+        evlist = perf_evlist__new();
         if (evlist == NULL) {
                 pr_debug("perf_evlist__new\n");
                 goto out_free_cpus;
         }
 
-        /* anonymous union fields, can't be initialized above */
-        attr.wakeup_events = 1;
-        attr.sample_period = 1;
+        perf_evlist__set_maps(evlist, cpus, threads);
 
         for (i = 0; i < nsyscalls; ++i) {
-                attr.config = ids[i];
-                evsels[i] = perf_evsel__new(&attr, i);
+                char name[64];
+
+                snprintf(name, sizeof(name), "sys_enter_%s", syscall_names[i]);
+                evsels[i] = perf_evsel__newtp("syscalls", name, i);
                 if (evsels[i] == NULL) {
                         pr_debug("perf_evsel__new\n");
                         goto out_free_evlist;
                 }
 
+                evsels[i]->attr.wakeup_events = 1;
+                perf_evsel__set_sample_id(evsels[i]);
+
                 perf_evlist__add(evlist, evsels[i]);
 
                 if (perf_evsel__open(evsels[i], cpus, threads) < 0) {
@@ -99,6 +82,9 @@ int test__basic_mmap(void)
                                  strerror(errno));
                         goto out_close_fd;
                 }
+
+                nr_events[i] = 0;
+                expected_nr_events[i] = 1 + rand() % 127;
         }
 
         if (perf_evlist__mmap(evlist, 128, true) < 0) {
@@ -128,6 +114,7 @@ int test__basic_mmap(void)
                         goto out_munmap;
                 }
 
+                err = -1;
                 evsel = perf_evlist__id2evsel(evlist, sample.id);
                 if (evsel == NULL) {
                         pr_debug("event with id %" PRIu64
@@ -137,16 +124,17 @@ int test__basic_mmap(void)
                 nr_events[evsel->idx]++;
         }
 
+        err = 0;
         list_for_each_entry(evsel, &evlist->entries, node) {
                 if (nr_events[evsel->idx] != expected_nr_events[evsel->idx]) {
                         pr_debug("expected %d %s events, got %d\n",
                                  expected_nr_events[evsel->idx],
                                  perf_evsel__name(evsel), nr_events[evsel->idx]);
+                        err = -1;
                         goto out_munmap;
                 }
         }
 
-        err = 0;
 out_munmap:
         perf_evlist__munmap(evlist);
 out_close_fd:
diff --git a/tools/perf/tests/open-syscall-all-cpus.c b/tools/perf/tests/open-syscall-all-cpus.c
index 31072aba0d54..b0657a9ccda6 100644
--- a/tools/perf/tests/open-syscall-all-cpus.c
+++ b/tools/perf/tests/open-syscall-all-cpus.c
@@ -7,20 +7,12 @@
 int test__open_syscall_event_on_all_cpus(void)
 {
         int err = -1, fd, cpu;
-        struct thread_map *threads;
         struct cpu_map *cpus;
         struct perf_evsel *evsel;
-        struct perf_event_attr attr;
         unsigned int nr_open_calls = 111, i;
         cpu_set_t cpu_set;
-        int id = trace_event__id("sys_enter_open");
+        struct thread_map *threads = thread_map__new(-1, getpid(), UINT_MAX);
 
-        if (id < 0) {
-                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
-                return -1;
-        }
-
-        threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
                 return -1;
@@ -32,15 +24,11 @@ int test__open_syscall_event_on_all_cpus(void)
                 goto out_thread_map_delete;
         }
 
-
         CPU_ZERO(&cpu_set);
 
-        memset(&attr, 0, sizeof(attr));
-        attr.type = PERF_TYPE_TRACEPOINT;
-        attr.config = id;
-        evsel = perf_evsel__new(&attr, 0);
+        evsel = perf_evsel__newtp("syscalls", "sys_enter_open", 0);
         if (evsel == NULL) {
-                pr_debug("perf_evsel__new\n");
+                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
                 goto out_thread_map_delete;
         }
 
@@ -110,6 +98,7 @@ int test__open_syscall_event_on_all_cpus(void)
                 }
         }
 
+        perf_evsel__free_counts(evsel);
 out_close_fd:
         perf_evsel__close_fd(evsel, 1, threads->nr);
 out_evsel_delete:
diff --git a/tools/perf/tests/open-syscall-tp-fields.c b/tools/perf/tests/open-syscall-tp-fields.c
index 1c52fdc1164e..fc5b9fca8b47 100644
--- a/tools/perf/tests/open-syscall-tp-fields.c
+++ b/tools/perf/tests/open-syscall-tp-fields.c
@@ -18,7 +18,7 @@ int test__syscall_open_tp_fields(void)
         };
         const char *filename = "/etc/passwd";
         int flags = O_RDONLY | O_DIRECTORY;
-        struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
+        struct perf_evlist *evlist = perf_evlist__new();
         struct perf_evsel *evsel;
         int err = -1, i, nr_events = 0, nr_polls = 0;
 
@@ -48,13 +48,13 @@ int test__syscall_open_tp_fields(void)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
         err = perf_evlist__mmap(evlist, UINT_MAX, false);
         if (err < 0) {
                 pr_debug("perf_evlist__mmap: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_close_evlist;
         }
 
         perf_evlist__enable(evlist);
@@ -110,6 +110,10 @@ out_ok:
         err = 0;
 out_munmap:
         perf_evlist__munmap(evlist);
+out_close_evlist:
+        perf_evlist__close(evlist);
+out_delete_maps:
+        perf_evlist__delete_maps(evlist);
 out_delete_evlist:
         perf_evlist__delete(evlist);
 out:
diff --git a/tools/perf/tests/open-syscall.c b/tools/perf/tests/open-syscall.c
index 98be8b518b4f..befc0671f95d 100644
--- a/tools/perf/tests/open-syscall.c
+++ b/tools/perf/tests/open-syscall.c
@@ -6,29 +6,18 @@
 int test__open_syscall_event(void)
 {
         int err = -1, fd;
-        struct thread_map *threads;
         struct perf_evsel *evsel;
-        struct perf_event_attr attr;
         unsigned int nr_open_calls = 111, i;
-        int id = trace_event__id("sys_enter_open");
+        struct thread_map *threads = thread_map__new(-1, getpid(), UINT_MAX);
 
-        if (id < 0) {
-                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
-                return -1;
-        }
-
-        threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
                 return -1;
         }
 
-        memset(&attr, 0, sizeof(attr));
-        attr.type = PERF_TYPE_TRACEPOINT;
-        attr.config = id;
-        evsel = perf_evsel__new(&attr, 0);
+        evsel = perf_evsel__newtp("syscalls", "sys_enter_open", 0);
         if (evsel == NULL) {
-                pr_debug("perf_evsel__new\n");
+                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
                 goto out_thread_map_delete;
         }
 
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 32ee478905eb..0275bab4ea9e 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 "sysfs.h"
+#include <lk/debugfs.h>
 #include "tests.h"
 #include <linux/hw_breakpoint.h>
 
@@ -22,6 +23,7 @@ static int test__checkevent_tracepoint(struct perf_evlist *evlist)
         struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->nr_groups);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
         TEST_ASSERT_VAL("wrong sample_type",
                 PERF_TP_SAMPLE_TYPE == evsel->attr.sample_type);
@@ -34,6 +36,7 @@ static int test__checkevent_tracepoint_multi(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
 
         TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
+        TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->nr_groups);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 TEST_ASSERT_VAL("wrong type",
@@ -463,10 +466,10 @@ static int test__checkevent_pmu_events(struct perf_evlist *evlist)
 
 static int test__checkterms_simple(struct list_head *terms)
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
         /* config=10 */
-        term = list_entry(terms->next, struct parse_events__term, list);
+        term = list_entry(terms->next, struct parse_events_term, list);
         TEST_ASSERT_VAL("wrong type term",
                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
         TEST_ASSERT_VAL("wrong type val",
@@ -475,7 +478,7 @@ static int test__checkterms_simple(struct list_head *terms)
         TEST_ASSERT_VAL("wrong config", !term->config);
 
         /* config1 */
-        term = list_entry(term->list.next, struct parse_events__term, list);
+        term = list_entry(term->list.next, struct parse_events_term, list);
         TEST_ASSERT_VAL("wrong type term",
                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1);
         TEST_ASSERT_VAL("wrong type val",
@@ -484,7 +487,7 @@ static int test__checkterms_simple(struct list_head *terms)
         TEST_ASSERT_VAL("wrong config", !term->config);
 
         /* config2=3 */
-        term = list_entry(term->list.next, struct parse_events__term, list);
+        term = list_entry(term->list.next, struct parse_events_term, list);
         TEST_ASSERT_VAL("wrong type term",
                         term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2);
         TEST_ASSERT_VAL("wrong type val",
@@ -493,7 +496,7 @@ static int test__checkterms_simple(struct list_head *terms)
         TEST_ASSERT_VAL("wrong config", !term->config);
 
         /* umask=1*/
-        term = list_entry(term->list.next, struct parse_events__term, list);
+        term = list_entry(term->list.next, struct parse_events_term, list);
         TEST_ASSERT_VAL("wrong type term",
                         term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
         TEST_ASSERT_VAL("wrong type val",
@@ -509,6 +512,7 @@ static int test__group1(struct perf_evlist *evlist)
         struct perf_evsel *evsel, *leader;
 
         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
         /* instructions:k */
         evsel = leader = perf_evlist__first(evlist);
@@ -521,7 +525,9 @@ static int test__group1(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* cycles:upp */
         evsel = perf_evsel__next(evsel);
@@ -536,6 +542,7 @@ static int test__group1(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 2);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         return 0;
 }
@@ -545,6 +552,7 @@ static int test__group2(struct perf_evlist *evlist)
         struct perf_evsel *evsel, *leader;
 
         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
         /* faults + :ku modifier */
         evsel = leader = perf_evlist__first(evlist);
@@ -557,7 +565,9 @@ static int test__group2(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* cache-references + :u modifier */
         evsel = perf_evsel__next(evsel);
@@ -567,10 +577,11 @@ static int test__group2(struct perf_evlist *evlist)
         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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         /* cycles:k */
         evsel = perf_evsel__next(evsel);
@@ -583,7 +594,7 @@ static int test__group2(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 
         return 0;
 }
@@ -593,6 +604,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         struct perf_evsel *evsel, *leader;
 
         TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->nr_groups);
 
         /* group1 syscalls:sys_enter_open:H */
         evsel = leader = perf_evlist__first(evlist);
@@ -606,9 +618,11 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong group name",
                 !strcmp(leader->group_name, "group1"));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* group1 cycles:kppp */
         evsel = perf_evsel__next(evsel);
@@ -624,6 +638,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 3);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         /* group2 cycles + G modifier */
         evsel = leader = perf_evsel__next(evsel);
@@ -636,9 +651,11 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong group name",
                 !strcmp(leader->group_name, "group2"));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* group2 1:3 + G modifier */
         evsel = perf_evsel__next(evsel);
@@ -651,6 +668,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         /* instructions:u */
         evsel = perf_evsel__next(evsel);
@@ -663,7 +681,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
 
         return 0;
 }
@@ -673,6 +691,7 @@ static int test__group4(struct perf_evlist *evlist __maybe_unused)
         struct perf_evsel *evsel, *leader;
 
         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
 
         /* cycles:u + p */
         evsel = leader = perf_evlist__first(evlist);
@@ -687,7 +706,9 @@ static int test__group4(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 1);
         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* instructions:kp + p */
         evsel = perf_evsel__next(evsel);
@@ -702,6 +723,7 @@ static int test__group4(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 2);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         return 0;
 }
@@ -711,6 +733,7 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         struct perf_evsel *evsel, *leader;
 
         TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 2 == evlist->nr_groups);
 
         /* cycles + G */
         evsel = leader = perf_evlist__first(evlist);
@@ -724,7 +747,9 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* instructions + G */
         evsel = perf_evsel__next(evsel);
@@ -738,6 +763,7 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         /* cycles:G */
         evsel = leader = perf_evsel__next(evsel);
@@ -751,7 +777,9 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
 
         /* instructions:G */
         evsel = perf_evsel__next(evsel);
@@ -765,6 +793,7 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         /* cycles */
         evsel = perf_evsel__next(evsel);
@@ -777,18 +806,235 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
-        TEST_ASSERT_VAL("wrong leader", !perf_evsel__is_group_member(evsel));
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+
+        return 0;
+}
+
+static int test__group_gh1(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
+
+        /* cycles + :H group modifier */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+
+        /* cache-misses:G + :H group modifier */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_MISSES == evsel->attr.config);
+        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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+
+        return 0;
+}
+
+static int test__group_gh2(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
+
+        /* cycles + :G group modifier */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+
+        /* cache-misses:H + :G group modifier */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_MISSES == evsel->attr.config);
+        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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+
+        return 0;
+}
+
+static int test__group_gh3(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
+
+        /* cycles:G + :u group modifier */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+
+        /* cache-misses:H + :u group modifier */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_MISSES == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+
+        return 0;
+}
+
+static int test__group_gh4(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong number of groups", 1 == evlist->nr_groups);
+
+        /* cycles:G + :uG group modifier */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+
+        /* cache-misses:H + :uG group modifier */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_MISSES == evsel->attr.config);
+        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 exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
 
         return 0;
 }
 
-struct test__event_st {
+static int count_tracepoints(void)
+{
+        char events_path[PATH_MAX];
+        struct dirent *events_ent;
+        DIR *events_dir;
+        int cnt = 0;
+
+        scnprintf(events_path, PATH_MAX, "%s/tracing/events",
+                  debugfs_find_mountpoint());
+
+        events_dir = opendir(events_path);
+
+        TEST_ASSERT_VAL("Can't open events dir", events_dir);
+
+        while ((events_ent = readdir(events_dir))) {
+                char sys_path[PATH_MAX];
+                struct dirent *sys_ent;
+                DIR *sys_dir;
+
+                if (!strcmp(events_ent->d_name, ".")
+                    || !strcmp(events_ent->d_name, "..")
+                    || !strcmp(events_ent->d_name, "enable")
+                    || !strcmp(events_ent->d_name, "header_event")
+                    || !strcmp(events_ent->d_name, "header_page"))
+                        continue;
+
+                scnprintf(sys_path, PATH_MAX, "%s/%s",
+                          events_path, events_ent->d_name);
+
+                sys_dir = opendir(sys_path);
+                TEST_ASSERT_VAL("Can't open sys dir", sys_dir);
+
+                while ((sys_ent = readdir(sys_dir))) {
+                        if (!strcmp(sys_ent->d_name, ".")
+                            || !strcmp(sys_ent->d_name, "..")
+                            || !strcmp(sys_ent->d_name, "enable")
+                            || !strcmp(sys_ent->d_name, "filter"))
+                                continue;
+
+                        cnt++;
+                }
+
+                closedir(sys_dir);
+        }
+
+        closedir(events_dir);
+        return cnt;
+}
+
+static int test__all_tracepoints(struct perf_evlist *evlist)
+{
+        TEST_ASSERT_VAL("wrong events count",
+                        count_tracepoints() == evlist->nr_entries);
+
+        return test__checkevent_tracepoint_multi(evlist);
+}
+
+struct evlist_test {
         const char *name;
         __u32 type;
         int (*check)(struct perf_evlist *evlist);
 };
 
-static struct test__event_st test__events[] = {
+static struct evlist_test test__events[] = {
         [0] = {
                 .name  = "syscalls:sys_enter_open",
                 .check = test__checkevent_tracepoint,
@@ -921,9 +1167,29 @@ static struct test__event_st test__events[] = {
                 .name  = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles",
                 .check = test__group5,
         },
+        [33] = {
+                .name  = "*:*",
+                .check = test__all_tracepoints,
+        },
+        [34] = {
+                .name  = "{cycles,cache-misses:G}:H",
+                .check = test__group_gh1,
+        },
+        [35] = {
+                .name  = "{cycles,cache-misses:H}:G",
+                .check = test__group_gh2,
+        },
+        [36] = {
+                .name  = "{cycles:G,cache-misses:H}:u",
+                .check = test__group_gh3,
+        },
+        [37] = {
+                .name  = "{cycles:G,cache-misses:H}:uG",
+                .check = test__group_gh4,
+        },
 };
 
-static struct test__event_st test__events_pmu[] = {
+static struct evlist_test test__events_pmu[] = {
         [0] = {
                 .name  = "cpu/config=10,config1,config2=3,period=1000/u",
                 .check = test__checkevent_pmu,
@@ -934,29 +1200,29 @@ static struct test__event_st test__events_pmu[] = {
         },
 };
 
-struct test__term {
+struct terms_test {
         const char *str;
         __u32 type;
         int (*check)(struct list_head *terms);
 };
 
-static struct test__term test__terms[] = {
+static struct terms_test test__terms[] = {
         [0] = {
                 .str   = "config=10,config1,config2=3,umask=1",
                 .check = test__checkterms_simple,
         },
 };
 
-static int test_event(struct test__event_st *e)
+static int test_event(struct evlist_test *e)
 {
         struct perf_evlist *evlist;
         int ret;
 
-        evlist = perf_evlist__new(NULL, NULL);
+        evlist = perf_evlist__new();
         if (evlist == NULL)
                 return -ENOMEM;
 
-        ret = parse_events(evlist, e->name, 0);
+        ret = parse_events(evlist, e->name);
         if (ret) {
                 pr_debug("failed to parse event '%s', err %d\n",
                          e->name, ret);
@@ -969,13 +1235,13 @@ static int test_event(struct test__event_st *e)
         return ret;
 }
 
-static int test_events(struct test__event_st *events, unsigned cnt)
+static int test_events(struct evlist_test *events, unsigned cnt)
 {
         int ret1, ret2 = 0;
         unsigned i;
 
         for (i = 0; i < cnt; i++) {
-                struct test__event_st *e = &events[i];
+                struct evlist_test *e = &events[i];
 
                 pr_debug("running test %d '%s'\n", i, e->name);
                 ret1 = test_event(e);
@@ -986,7 +1252,7 @@ static int test_events(struct test__event_st *events, unsigned cnt)
         return ret2;
 }
 
-static int test_term(struct test__term *t)
+static int test_term(struct terms_test *t)
 {
         struct list_head *terms;
         int ret;
@@ -1010,13 +1276,13 @@ static int test_term(struct test__term *t)
         return ret;
 }
 
-static int test_terms(struct test__term *terms, unsigned cnt)
+static int test_terms(struct terms_test *terms, unsigned cnt)
 {
         int ret = 0;
         unsigned i;
 
         for (i = 0; i < cnt; i++) {
-                struct test__term *t = &terms[i];
+                struct terms_test *t = &terms[i];
 
                 pr_debug("running test %d '%s'\n", i, t->str);
                 ret = test_term(t);
@@ -1055,7 +1321,7 @@ static int test_pmu_events(void)
 
         ret = stat(path, &st);
         if (ret) {
-                pr_debug("ommiting PMU cpu events tests\n");
+                pr_debug("omitting PMU cpu events tests\n");
                 return 0;
         }
 
@@ -1067,7 +1333,7 @@ static int test_pmu_events(void)
 
         while (!ret && (ent = readdir(dir))) {
 #define MAX_NAME 100
-                struct test__event_st e;
+                struct evlist_test e;
                 char name[MAX_NAME];
 
                 if (!strcmp(ent->d_name, ".") ||
diff --git a/tools/perf/tests/perf-record.c b/tools/perf/tests/perf-record.c
index 70e0d4421df8..72d8881873b0 100644
--- a/tools/perf/tests/perf-record.c
+++ b/tools/perf/tests/perf-record.c
@@ -45,7 +45,7 @@ int test__PERF_RECORD(void)
         };
         cpu_set_t cpu_mask;
         size_t cpu_mask_size = sizeof(cpu_mask);
-        struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
+        struct perf_evlist *evlist = perf_evlist__new();
         struct perf_evsel *evsel;
         struct perf_sample sample;
         const char *cmd = "sleep";
@@ -93,25 +93,26 @@ int test__PERF_RECORD(void)
          * so that we have time to open the evlist (calling sys_perf_event_open
          * on all the fds) and then mmap them.
          */
-        err = perf_evlist__prepare_workload(evlist, &opts, argv);
+        err = perf_evlist__prepare_workload(evlist, &opts.target, argv,
+                                            false, false);
         if (err < 0) {
                 pr_debug("Couldn't run the workload!\n");
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
         /*
          * Config the evsels, setting attr->comm on the first one, etc.
          */
         evsel = perf_evlist__first(evlist);
-        evsel->attr.sample_type |= PERF_SAMPLE_CPU;
-        evsel->attr.sample_type |= PERF_SAMPLE_TID;
-        evsel->attr.sample_type |= PERF_SAMPLE_TIME;
-        perf_evlist__config_attrs(evlist, &opts);
+        perf_evsel__set_sample_bit(evsel, CPU);
+        perf_evsel__set_sample_bit(evsel, TID);
+        perf_evsel__set_sample_bit(evsel, TIME);
+        perf_evlist__config(evlist, &opts);
 
         err = sched__get_first_possible_cpu(evlist->workload.pid, &cpu_mask);
         if (err < 0) {
                 pr_debug("sched__get_first_possible_cpu: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
         cpu = err;
@@ -121,7 +122,7 @@ int test__PERF_RECORD(void)
          */
         if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, &cpu_mask) < 0) {
                 pr_debug("sched_setaffinity: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
         /*
@@ -131,7 +132,7 @@ int test__PERF_RECORD(void)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_delete_maps;
         }
 
         /*
@@ -142,7 +143,7 @@ int test__PERF_RECORD(void)
         err = perf_evlist__mmap(evlist, opts.mmap_pages, false);
         if (err < 0) {
                 pr_debug("perf_evlist__mmap: %s\n", strerror(errno));
-                goto out_delete_evlist;
+                goto out_close_evlist;
         }
 
         /*
@@ -305,6 +306,10 @@ found_exit:
         }
 out_err:
         perf_evlist__munmap(evlist);
+out_close_evlist:
+        perf_evlist__close(evlist);
+out_delete_maps:
+        perf_evlist__delete_maps(evlist);
 out_delete_evlist:
         perf_evlist__delete(evlist);
 out:
diff --git a/tools/perf/tests/pmu.c b/tools/perf/tests/pmu.c
index a5f379863b8f..12b322fa3475 100644
--- a/tools/perf/tests/pmu.c
+++ b/tools/perf/tests/pmu.c
@@ -19,10 +19,8 @@ static struct test_format {
         { "krava23", "config2:28-29,38\n", },
 };
 
-#define TEST_FORMATS_CNT (sizeof(test_formats) / sizeof(struct test_format))
-
 /* Simulated users input. */
-static struct parse_events__term test_terms[] = {
+static struct parse_events_term test_terms[] = {
         {
                 .config    = (char *) "krava01",
                 .val.num   = 15,
@@ -78,7 +76,6 @@ static struct parse_events__term test_terms[] = {
                 .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
 };
-#define TERMS_CNT (sizeof(test_terms) / sizeof(struct parse_events__term))
 
 /*
  * Prepare format directory data, exported by kernel
@@ -93,7 +90,7 @@ static char *test_format_dir_get(void)
         if (!mkdtemp(dir))
                 return NULL;
 
-        for (i = 0; i < TEST_FORMATS_CNT; i++) {
+        for (i = 0; i < ARRAY_SIZE(test_formats); i++) {
                 static char name[PATH_MAX];
                 struct test_format *format = &test_formats[i];
                 FILE *file;
@@ -130,14 +127,12 @@ static struct list_head *test_terms_list(void)
         static LIST_HEAD(terms);
         unsigned int i;
 
-        for (i = 0; i < TERMS_CNT; i++)
+        for (i = 0; i < ARRAY_SIZE(test_terms); i++)
                 list_add_tail(&test_terms[i].list, &terms);
 
         return &terms;
 }
 
-#undef TERMS_CNT
-
 int test__pmu(void)
 {
         char *format = test_format_dir_get();
diff --git a/tools/perf/tests/python-use.c b/tools/perf/tests/python-use.c
new file mode 100644
index 000000000000..7760277c6def
--- /dev/null
+++ b/tools/perf/tests/python-use.c
@@ -0,0 +1,23 @@
+/*
+ * Just test if we can load the python binding.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "tests.h"
+
+extern int verbose;
+
+int test__python_use(void)
+{
+        char *cmd;
+        int ret;
+
+        if (asprintf(&cmd, "echo \"import sys ; sys.path.append('%s'); import perf\" | %s %s",
+                     PYTHONPATH, PYTHON, verbose ? "" : "2> /dev/null") < 0)
+                return -1;
+
+        ret = system(cmd) ? -1 : 0;
+        free(cmd);
+        return ret;
+}
diff --git a/tools/perf/tests/sw-clock.c b/tools/perf/tests/sw-clock.c
new file mode 100644
index 000000000000..2e41e2d32ccc
--- /dev/null
+++ b/tools/perf/tests/sw-clock.c
@@ -0,0 +1,119 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/mman.h>
+
+#include "tests.h"
+#include "util/evsel.h"
+#include "util/evlist.h"
+#include "util/cpumap.h"
+#include "util/thread_map.h"
+
+#define NR_LOOPS  1000000
+
+/*
+ * This test will open software clock events (cpu-clock, task-clock)
+ * then check their frequency -> period conversion has no artifact of
+ * setting period to 1 forcefully.
+ */
+static int __test__sw_clock_freq(enum perf_sw_ids clock_id)
+{
+        int i, err = -1;
+        volatile int tmp = 0;
+        u64 total_periods = 0;
+        int nr_samples = 0;
+        union perf_event *event;
+        struct perf_evsel *evsel;
+        struct perf_evlist *evlist;
+        struct perf_event_attr attr = {
+                .type = PERF_TYPE_SOFTWARE,
+                .config = clock_id,
+                .sample_type = PERF_SAMPLE_PERIOD,
+                .exclude_kernel = 1,
+                .disabled = 1,
+                .freq = 1,
+        };
+
+        attr.sample_freq = 10000;
+
+        evlist = perf_evlist__new();
+        if (evlist == NULL) {
+                pr_debug("perf_evlist__new\n");
+                return -1;
+        }
+
+        evsel = perf_evsel__new(&attr, 0);
+        if (evsel == NULL) {
+                pr_debug("perf_evsel__new\n");
+                goto out_free_evlist;
+        }
+        perf_evlist__add(evlist, evsel);
+
+        evlist->cpus = cpu_map__dummy_new();
+        evlist->threads = thread_map__new_by_tid(getpid());
+        if (!evlist->cpus || !evlist->threads) {
+                err = -ENOMEM;
+                pr_debug("Not enough memory to create thread/cpu maps\n");
+                goto out_delete_maps;
+        }
+
+        perf_evlist__open(evlist);
+
+        err = perf_evlist__mmap(evlist, 128, true);
+        if (err < 0) {
+                pr_debug("failed to mmap event: %d (%s)\n", errno,
+                         strerror(errno));
+                goto out_close_evlist;
+        }
+
+        perf_evlist__enable(evlist);
+
+        /* collect samples */
+        for (i = 0; i < NR_LOOPS; i++)
+                tmp++;
+
+        perf_evlist__disable(evlist);
+
+        while ((event = perf_evlist__mmap_read(evlist, 0)) != NULL) {
+                struct perf_sample sample;
+
+                if (event->header.type != PERF_RECORD_SAMPLE)
+                        continue;
+
+                err = perf_evlist__parse_sample(evlist, event, &sample);
+                if (err < 0) {
+                        pr_debug("Error during parse sample\n");
+                        goto out_unmap_evlist;
+                }
+
+                total_periods += sample.period;
+                nr_samples++;
+        }
+
+        if ((u64) nr_samples == total_periods) {
+                pr_debug("All (%d) samples have period value of 1!\n",
+                         nr_samples);
+                err = -1;
+        }
+
+out_unmap_evlist:
+        perf_evlist__munmap(evlist);
+out_close_evlist:
+        perf_evlist__close(evlist);
+out_delete_maps:
+        perf_evlist__delete_maps(evlist);
+out_free_evlist:
+        perf_evlist__delete(evlist);
+        return err;
+}
+
+int test__sw_clock_freq(void)
+{
+        int ret;
+
+        ret = __test__sw_clock_freq(PERF_COUNT_SW_CPU_CLOCK);
+        if (!ret)
+                ret = __test__sw_clock_freq(PERF_COUNT_SW_TASK_CLOCK);
+
+        return ret;
+}
diff --git a/tools/perf/tests/task-exit.c b/tools/perf/tests/task-exit.c
new file mode 100644
index 000000000000..28fe5894b061
--- /dev/null
+++ b/tools/perf/tests/task-exit.c
@@ -0,0 +1,123 @@
+#include "evlist.h"
+#include "evsel.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "tests.h"
+
+#include <signal.h>
+
+static int exited;
+static int nr_exit;
+
+static void sig_handler(int sig)
+{
+        exited = 1;
+
+        if (sig == SIGUSR1)
+                nr_exit = -1;
+}
+
+/*
+ * This test will start a workload that does nothing then it checks
+ * if the number of exit event reported by the kernel is 1 or not
+ * in order to check the kernel returns correct number of event.
+ */
+int test__task_exit(void)
+{
+        int err = -1;
+        union perf_event *event;
+        struct perf_evsel *evsel;
+        struct perf_evlist *evlist;
+        struct perf_target target = {
+                .uid            = UINT_MAX,
+                .uses_mmap      = true,
+        };
+        const char *argv[] = { "true", NULL };
+
+        signal(SIGCHLD, sig_handler);
+        signal(SIGUSR1, sig_handler);
+
+        evlist = perf_evlist__new();
+        if (evlist == NULL) {
+                pr_debug("perf_evlist__new\n");
+                return -1;
+        }
+        /*
+         * We need at least one evsel in the evlist, use the default
+         * one: "cycles".
+         */
+        err = perf_evlist__add_default(evlist);
+        if (err < 0) {
+                pr_debug("Not enough memory to create evsel\n");
+                goto out_free_evlist;
+        }
+
+        /*
+         * Create maps of threads and cpus to monitor. In this case
+         * we start with all threads and cpus (-1, -1) but then in
+         * perf_evlist__prepare_workload we'll fill in the only thread
+         * we're monitoring, the one forked there.
+         */
+        evlist->cpus = cpu_map__dummy_new();
+        evlist->threads = thread_map__new_by_tid(-1);
+        if (!evlist->cpus || !evlist->threads) {
+                err = -ENOMEM;
+                pr_debug("Not enough memory to create thread/cpu maps\n");
+                goto out_delete_maps;
+        }
+
+        err = perf_evlist__prepare_workload(evlist, &target, argv, false, true);
+        if (err < 0) {
+                pr_debug("Couldn't run the workload!\n");
+                goto out_delete_maps;
+        }
+
+        evsel = perf_evlist__first(evlist);
+        evsel->attr.task = 1;
+        evsel->attr.sample_freq = 0;
+        evsel->attr.inherit = 0;
+        evsel->attr.watermark = 0;
+        evsel->attr.wakeup_events = 1;
+        evsel->attr.exclude_kernel = 1;
+
+        err = perf_evlist__open(evlist);
+        if (err < 0) {
+                pr_debug("Couldn't open the evlist: %s\n", strerror(-err));
+                goto out_delete_maps;
+        }
+
+        if (perf_evlist__mmap(evlist, 128, true) < 0) {
+                pr_debug("failed to mmap events: %d (%s)\n", errno,
+                         strerror(errno));
+                goto out_close_evlist;
+        }
+
+        perf_evlist__start_workload(evlist);
+
+retry:
+        while ((event = perf_evlist__mmap_read(evlist, 0)) != NULL) {
+                if (event->header.type != PERF_RECORD_EXIT)
+                        continue;
+
+                nr_exit++;
+        }
+
+        if (!exited || !nr_exit) {
+                poll(evlist->pollfd, evlist->nr_fds, -1);
+                goto retry;
+        }
+
+        if (nr_exit != 1) {
+                pr_debug("received %d EXIT records\n", nr_exit);
+                err = -1;
+        }
+
+        perf_evlist__munmap(evlist);
+out_close_evlist:
+        perf_evlist__close(evlist);
+out_delete_maps:
+        perf_evlist__delete_maps(evlist);
+out_free_evlist:
+        perf_evlist__delete(evlist);
+        return err;
+}
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index fc121edab016..dd7feae2d37b 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -1,6 +1,12 @@
 #ifndef TESTS_H
 #define TESTS_H
 
+enum {
+        TEST_OK   =  0,
+        TEST_FAIL = -1,
+        TEST_SKIP = -2,
+};
+
 /* Tests */
 int test__vmlinux_matches_kallsyms(void);
 int test__open_syscall_event(void);
@@ -15,8 +21,11 @@ int test__pmu(void);
 int test__attr(void);
 int test__dso_data(void);
 int test__parse_events(void);
-
-/* Util */
-int trace_event__id(const char *evname);
+int test__hists_link(void);
+int test__python_use(void);
+int test__bp_signal(void);
+int test__bp_signal_overflow(void);
+int test__task_exit(void);
+int test__sw_clock_freq(void);
 
 #endif /* TESTS_H */
diff --git a/tools/perf/tests/util.c b/tools/perf/tests/util.c
deleted file mode 100644
index 748f2e8f6961..000000000000
--- a/tools/perf/tests/util.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include "tests.h"
-#include "debugfs.h"
-
-int trace_event__id(const char *evname)
-{
-        char *filename;
-        int err = -1, fd;
-
-        if (asprintf(&filename,
-                     "%s/syscalls/%s/id",
-                     tracing_events_path, evname) < 0)
-                return -1;
-
-        fd = open(filename, O_RDONLY);
-        if (fd >= 0) {
-                char id[16];
-                if (read(fd, id, sizeof(id)) > 0)
-                        err = atoi(id);
-                close(fd);
-        }
-
-        free(filename);
-        return err;
-}
diff --git a/tools/perf/tests/vmlinux-kallsyms.c b/tools/perf/tests/vmlinux-kallsyms.c
index 0d1cdbee2f59..7b4c4d26d1ba 100644
--- a/tools/perf/tests/vmlinux-kallsyms.c
+++ b/tools/perf/tests/vmlinux-kallsyms.c
@@ -44,7 +44,7 @@ int test__vmlinux_matches_kallsyms(void)
          */
         if (machine__create_kernel_maps(&kallsyms) < 0) {
                 pr_debug("machine__create_kernel_maps ");
-                return -1;
+                goto out;
         }
 
         /*
@@ -101,7 +101,8 @@ int test__vmlinux_matches_kallsyms(void)
          */
         if (machine__load_vmlinux_path(&vmlinux, type,
                                        vmlinux_matches_kallsyms_filter) <= 0) {
-                pr_debug("machine__load_vmlinux_path ");
+                pr_debug("Couldn't find a vmlinux that matches the kernel running on this machine, skipping test\n");
+                err = TEST_SKIP;
                 goto out;
         }
 
@@ -226,5 +227,7 @@ detour:
                         map__fprintf(pos, stderr);
         }
 out:
+        machine__exit(&kallsyms);
+        machine__exit(&vmlinux);
         return err;
 }
diff --git a/tools/perf/ui/browser.c b/tools/perf/ui/browser.c
index 4aeb7d5df939..bbc782e364b0 100644
--- a/tools/perf/ui/browser.c
+++ b/tools/perf/ui/browser.c
@@ -2,7 +2,6 @@
 #include "../cache.h"
 #include "../../perf.h"
 #include "libslang.h"
-#include <newt.h>
 #include "ui.h"
 #include "util.h"
 #include <linux/compiler.h>
@@ -234,7 +233,7 @@ void ui_browser__reset_index(struct ui_browser *browser)
 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
 {
         SLsmg_gotorc(0, 0);
-        ui_browser__set_color(browser, NEWT_COLORSET_ROOT);
+        ui_browser__set_color(browser, HE_COLORSET_ROOT);
         slsmg_write_nstring(title, browser->width + 1);
 }
 
@@ -273,6 +272,8 @@ void ui_browser__hide(struct ui_browser *browser __maybe_unused)
 {
         pthread_mutex_lock(&ui__lock);
         ui_helpline__pop();
+        free(browser->helpline);
+        browser->helpline = NULL;
         pthread_mutex_unlock(&ui__lock);
 }
 
@@ -471,7 +472,7 @@ unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
         return row;
 }
 
-static struct ui_browser__colorset {
+static struct ui_browser_colorset {
         const char *name, *fg, *bg;
         int colorset;
 } ui_browser__colorsets[] = {
@@ -512,6 +513,12 @@ static struct ui_browser__colorset {
                 .bg       = "default",
         },
         {
+                .colorset = HE_COLORSET_ROOT,
+                .name     = "root",
+                .fg       = "white",
+                .bg       = "blue",
+        },
+        {
                 .name = NULL,
         }
 };
@@ -706,7 +713,7 @@ void ui_browser__init(void)
         perf_config(ui_browser__color_config, NULL);
 
         while (ui_browser__colorsets[i].name) {
-                struct ui_browser__colorset *c = &ui_browser__colorsets[i++];
+                struct ui_browser_colorset *c = &ui_browser__colorsets[i++];
                 sltt_set_color(c->colorset, c->name, c->fg, c->bg);
         }
 
diff --git a/tools/perf/ui/browser.h b/tools/perf/ui/browser.h
index af70314605e5..404ff66a3e36 100644
--- a/tools/perf/ui/browser.h
+++ b/tools/perf/ui/browser.h
@@ -11,6 +11,7 @@
 #define HE_COLORSET_SELECTED    53
 #define HE_COLORSET_CODE        54
 #define HE_COLORSET_ADDR        55
+#define HE_COLORSET_ROOT        56
 
 struct ui_browser {
         u64           index, top_idx;
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index 5dab3ca96980..cc64d3f7fc36 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -8,15 +8,19 @@
 #include "../../util/hist.h"
 #include "../../util/sort.h"
 #include "../../util/symbol.h"
+#include "../../util/evsel.h"
 #include <pthread.h>
-#include <newt.h>
 
 struct browser_disasm_line {
         struct rb_node  rb_node;
-        double          percent;
         u32             idx;
         int             idx_asm;
         int             jump_sources;
+        /*
+         * actual length of this array is saved on the nr_events field
+         * of the struct annotate_browser
+         */
+        double          percent[1];
 };
 
 static struct annotate_browser_opt {
@@ -33,8 +37,9 @@ struct annotate_browser {
         struct ui_browser b;
         struct rb_root    entries;
         struct rb_node    *curr_hot;
-        struct disasm_line        *selection;
+        struct disasm_line  *selection;
         struct disasm_line  **offsets;
+        int                 nr_events;
         u64                 start;
         int                 nr_asm_entries;
         int                 nr_entries;
@@ -94,14 +99,24 @@ static void annotate_browser__write(struct ui_browser *browser, void *entry, int
                              (!current_entry || (browser->use_navkeypressed &&
                                                  !browser->navkeypressed)));
         int width = browser->width, printed;
+        int i, pcnt_width = 7 * ab->nr_events;
+        double percent_max = 0.0;
         char bf[256];
 
-        if (dl->offset != -1 && bdl->percent != 0.0) {
-                ui_browser__set_percent_color(browser, bdl->percent, current_entry);
-                slsmg_printf("%6.2f ", bdl->percent);
+        for (i = 0; i < ab->nr_events; i++) {
+                if (bdl->percent[i] > percent_max)
+                        percent_max = bdl->percent[i];
+        }
+
+        if (dl->offset != -1 && percent_max != 0.0) {
+                for (i = 0; i < ab->nr_events; i++) {
+                        ui_browser__set_percent_color(browser, bdl->percent[i],
+                                                      current_entry);
+                        slsmg_printf("%6.2f ", bdl->percent[i]);
+                }
         } else {
                 ui_browser__set_percent_color(browser, 0, current_entry);
-                slsmg_write_nstring(" ", 7);
+                slsmg_write_nstring(" ", pcnt_width);
         }
 
         SLsmg_write_char(' ');
@@ -111,12 +126,12 @@ static void annotate_browser__write(struct ui_browser *browser, void *entry, int
                 width += 1;
 
         if (!*dl->line)
-                slsmg_write_nstring(" ", width - 7);
+                slsmg_write_nstring(" ", width - pcnt_width);
         else if (dl->offset == -1) {
                 printed = scnprintf(bf, sizeof(bf), "%*s  ",
                                     ab->addr_width, " ");
                 slsmg_write_nstring(bf, printed);
-                slsmg_write_nstring(dl->line, width - printed - 6);
+                slsmg_write_nstring(dl->line, width - printed - pcnt_width + 1);
         } else {
                 u64 addr = dl->offset;
                 int color = -1;
@@ -175,13 +190,23 @@ static void annotate_browser__write(struct ui_browser *browser, void *entry, int
                 }
 
                 disasm_line__scnprintf(dl, bf, sizeof(bf), !annotate_browser__opts.use_offset);
-                slsmg_write_nstring(bf, width - 10 - printed);
+                slsmg_write_nstring(bf, width - pcnt_width - 3 - printed);
         }
 
         if (current_entry)
                 ab->selection = dl;
 }
 
+static bool disasm_line__is_valid_jump(struct disasm_line *dl, struct symbol *sym)
+{
+        if (!dl || !dl->ins || !ins__is_jump(dl->ins)
+            || !disasm_line__has_offset(dl)
+            || dl->ops.target.offset >= symbol__size(sym))
+                return false;
+
+        return true;
+}
+
 static void annotate_browser__draw_current_jump(struct ui_browser *browser)
 {
         struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
@@ -190,13 +215,13 @@ static void annotate_browser__draw_current_jump(struct ui_browser *browser)
         unsigned int from, to;
         struct map_symbol *ms = ab->b.priv;
         struct symbol *sym = ms->sym;
+        u8 pcnt_width = 7;
 
         /* PLT symbols contain external offsets */
         if (strstr(sym->name, "@plt"))
                 return;
 
-        if (!cursor || !cursor->ins || !ins__is_jump(cursor->ins) ||
-            !disasm_line__has_offset(cursor))
+        if (!disasm_line__is_valid_jump(cursor, sym))
                 return;
 
         target = ab->offsets[cursor->ops.target.offset];
@@ -214,57 +239,44 @@ static void annotate_browser__draw_current_jump(struct ui_browser *browser)
                 to = (u64)btarget->idx;
         }
 
+        pcnt_width *= ab->nr_events;
+
         ui_browser__set_color(browser, HE_COLORSET_CODE);
-        __ui_browser__line_arrow(browser, 9 + ab->addr_width, from, to);
+        __ui_browser__line_arrow(browser, pcnt_width + 2 + ab->addr_width,
+                                 from, to);
 }
 
 static unsigned int annotate_browser__refresh(struct ui_browser *browser)
 {
+        struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
         int ret = ui_browser__list_head_refresh(browser);
+        int pcnt_width;
+
+        pcnt_width = 7 * ab->nr_events;
 
         if (annotate_browser__opts.jump_arrows)
                 annotate_browser__draw_current_jump(browser);
 
         ui_browser__set_color(browser, HE_COLORSET_NORMAL);
-        __ui_browser__vline(browser, 7, 0, browser->height - 1);
+        __ui_browser__vline(browser, pcnt_width, 0, browser->height - 1);
         return ret;
 }
 
-static double disasm_line__calc_percent(struct disasm_line *dl, struct symbol *sym, int evidx)
+static int disasm__cmp(struct browser_disasm_line *a,
+                       struct browser_disasm_line *b, int nr_pcnt)
 {
-        double percent = 0.0;
-
-        if (dl->offset != -1) {
-                int len = sym->end - sym->start;
-                unsigned int hits = 0;
-                struct annotation *notes = symbol__annotation(sym);
-                struct source_line *src_line = notes->src->lines;
-                struct sym_hist *h = annotation__histogram(notes, evidx);
-                s64 offset = dl->offset;
-                struct disasm_line *next;
-
-                next = disasm__get_next_ip_line(&notes->src->source, dl);
-                while (offset < (s64)len &&
-                       (next == NULL || offset < next->offset)) {
-                        if (src_line) {
-                                percent += src_line[offset].percent;
-                        } else
-                                hits += h->addr[offset];
+        int i;
 
-                        ++offset;
-                }
-                /*
-                 * If the percentage wasn't already calculated in
-                 * symbol__get_source_line, do it now:
-                 */
-                if (src_line == NULL && h->sum)
-                        percent = 100.0 * hits / h->sum;
+        for (i = 0; i < nr_pcnt; i++) {
+                if (a->percent[i] == b->percent[i])
+                        continue;
+                return a->percent[i] < b->percent[i];
         }
-
-        return percent;
+        return 0;
 }
 
-static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_line *bdl)
+static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_line *bdl,
+                                   int nr_events)
 {
         struct rb_node **p = &root->rb_node;
         struct rb_node *parent = NULL;
@@ -273,7 +285,8 @@ static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_l
         while (*p != NULL) {
                 parent = *p;
                 l = rb_entry(parent, struct browser_disasm_line, rb_node);
-                if (bdl->percent < l->percent)
+
+                if (disasm__cmp(bdl, l, nr_events))
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -322,12 +335,13 @@ static void annotate_browser__set_rb_top(struct annotate_browser *browser,
 }
 
 static void annotate_browser__calc_percent(struct annotate_browser *browser,
-                                           int evidx)
+                                           struct perf_evsel *evsel)
 {
         struct map_symbol *ms = browser->b.priv;
         struct symbol *sym = ms->sym;
         struct annotation *notes = symbol__annotation(sym);
-        struct disasm_line *pos;
+        struct disasm_line *pos, *next;
+        s64 len = symbol__size(sym);
 
         browser->entries = RB_ROOT;
 
@@ -335,12 +349,34 @@ static void annotate_browser__calc_percent(struct annotate_browser *browser,
 
         list_for_each_entry(pos, &notes->src->source, node) {
                 struct browser_disasm_line *bpos = disasm_line__browser(pos);
-                bpos->percent = disasm_line__calc_percent(pos, sym, evidx);
-                if (bpos->percent < 0.01) {
+                const char *path = NULL;
+                double max_percent = 0.0;
+                int i;
+
+                if (pos->offset == -1) {
                         RB_CLEAR_NODE(&bpos->rb_node);
                         continue;
                 }
-                disasm_rb_tree__insert(&browser->entries, bpos);
+
+                next = disasm__get_next_ip_line(&notes->src->source, pos);
+
+                for (i = 0; i < browser->nr_events; i++) {
+                        bpos->percent[i] = disasm__calc_percent(notes,
+                                                evsel->idx + i,
+                                                pos->offset,
+                                                next ? next->offset : len,
+                                                &path);
+
+                        if (max_percent < bpos->percent[i])
+                                max_percent = bpos->percent[i];
+                }
+
+                if (max_percent < 0.01) {
+                        RB_CLEAR_NODE(&bpos->rb_node);
+                        continue;
+                }
+                disasm_rb_tree__insert(&browser->entries, bpos,
+                                       browser->nr_events);
         }
         pthread_mutex_unlock(&notes->lock);
 
@@ -392,7 +428,8 @@ static void annotate_browser__init_asm_mode(struct annotate_browser *browser)
         browser->b.nr_entries = browser->nr_asm_entries;
 }
 
-static bool annotate_browser__callq(struct annotate_browser *browser, int evidx,
+static bool annotate_browser__callq(struct annotate_browser *browser,
+                                    struct perf_evsel *evsel,
                                     struct hist_browser_timer *hbt)
 {
         struct map_symbol *ms = browser->b.priv;
@@ -423,7 +460,7 @@ static bool annotate_browser__callq(struct annotate_browser *browser, int evidx,
         }
 
         pthread_mutex_unlock(&notes->lock);
-        symbol__tui_annotate(target, ms->map, evidx, hbt);
+        symbol__tui_annotate(target, ms->map, evsel, hbt);
         ui_browser__show_title(&browser->b, sym->name);
         return true;
 }
@@ -606,7 +643,8 @@ static void annotate_browser__update_addr_width(struct annotate_browser *browser
                 browser->addr_width += browser->jumps_width + 1;
 }
 
-static int annotate_browser__run(struct annotate_browser *browser, int evidx,
+static int annotate_browser__run(struct annotate_browser *browser,
+                                 struct perf_evsel *evsel,
                                  struct hist_browser_timer *hbt)
 {
         struct rb_node *nd = NULL;
@@ -619,7 +657,7 @@ static int annotate_browser__run(struct annotate_browser *browser, int evidx,
         if (ui_browser__show(&browser->b, sym->name, help) < 0)
                 return -1;
 
-        annotate_browser__calc_percent(browser, evidx);
+        annotate_browser__calc_percent(browser, evsel);
 
         if (browser->curr_hot) {
                 annotate_browser__set_rb_top(browser, browser->curr_hot);
@@ -632,7 +670,7 @@ static int annotate_browser__run(struct annotate_browser *browser, int evidx,
                 key = ui_browser__run(&browser->b, delay_secs);
 
                 if (delay_secs != 0) {
-                        annotate_browser__calc_percent(browser, evidx);
+                        annotate_browser__calc_percent(browser, evsel);
                         /*
                          * Current line focus got out of the list of most active
                          * lines, NULL it so that if TAB|UNTAB is pressed, we
@@ -648,7 +686,7 @@ static int annotate_browser__run(struct annotate_browser *browser, int evidx,
                                 hbt->timer(hbt->arg);
 
                         if (delay_secs != 0)
-                                symbol__annotate_decay_histogram(sym, evidx);
+                                symbol__annotate_decay_histogram(sym, evsel->idx);
                         continue;
                 case K_TAB:
                         if (nd != NULL) {
@@ -745,7 +783,7 @@ show_help:
                                         goto show_sup_ins;
                                 goto out;
                         } else if (!(annotate_browser__jump(browser) ||
-                                     annotate_browser__callq(browser, evidx, hbt))) {
+                                     annotate_browser__callq(browser, evsel, hbt))) {
 show_sup_ins:
                                 ui_helpline__puts("Actions are only available for 'callq', 'retq' & jump instructions.");
                         }
@@ -767,10 +805,10 @@ out:
         return key;
 }
 
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
+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, evidx, hbt);
+        return symbol__tui_annotate(he->ms.sym, he->ms.map, evsel, hbt);
 }
 
 static void annotate_browser__mark_jump_targets(struct annotate_browser *browser,
@@ -788,17 +826,9 @@ static void annotate_browser__mark_jump_targets(struct annotate_browser *browser
                 struct disasm_line *dl = browser->offsets[offset], *dlt;
                 struct browser_disasm_line *bdlt;
 
-                if (!dl || !dl->ins || !ins__is_jump(dl->ins) ||
-                    !disasm_line__has_offset(dl))
+                if (!disasm_line__is_valid_jump(dl, sym))
                         continue;
 
-                if (dl->ops.target.offset >= size) {
-                        ui__error("jump to after symbol!\n"
-                                  "size: %zx, jump target: %" PRIx64,
-                                  size, dl->ops.target.offset);
-                        continue;
-                }
-
                 dlt = browser->offsets[dl->ops.target.offset];
                 /*
                  * FIXME: Oops, no jump target? Buggy disassembler? Or do we
@@ -825,7 +855,8 @@ static inline int width_jumps(int n)
         return 1;
 }
 
-int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
+int symbol__tui_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel,
                          struct hist_browser_timer *hbt)
 {
         struct disasm_line *pos, *n;
@@ -846,6 +877,8 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
                 },
         };
         int ret = -1;
+        int nr_pcnt = 1;
+        size_t sizeof_bdl = sizeof(struct browser_disasm_line);
 
         if (sym == NULL)
                 return -1;
@@ -861,7 +894,12 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
                 return -1;
         }
 
-        if (symbol__annotate(sym, map, sizeof(struct browser_disasm_line)) < 0) {
+        if (perf_evsel__is_group_event(evsel)) {
+                nr_pcnt = evsel->nr_members;
+                sizeof_bdl += sizeof(double) * (nr_pcnt - 1);
+        }
+
+        if (symbol__annotate(sym, map, sizeof_bdl) < 0) {
                 ui__error("%s", ui_helpline__last_msg);
                 goto out_free_offsets;
         }
@@ -899,6 +937,7 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
         browser.addr_width = browser.target_width = browser.min_addr_width = hex_width(size);
         browser.max_addr_width = hex_width(sym->end);
         browser.jumps_width = width_jumps(browser.max_jump_sources);
+        browser.nr_events = nr_pcnt;
         browser.b.nr_entries = browser.nr_entries;
         browser.b.entries = &notes->src->source,
         browser.b.width += 18; /* Percentage */
@@ -908,7 +947,7 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
 
         annotate_browser__update_addr_width(&browser);
 
-        ret = annotate_browser__run(&browser, evidx, hbt);
+        ret = annotate_browser__run(&browser, evsel, hbt);
         list_for_each_entry_safe(pos, n, &notes->src->source, node) {
                 list_del(&pos->node);
                 disasm_line__free(pos);
@@ -921,11 +960,11 @@ out_free_offsets:
 
 #define ANNOTATE_CFG(n) \
         { .name = #n, .value = &annotate_browser__opts.n, }
-        
+
 /*
  * Keep the entries sorted, they are bsearch'ed
  */
-static struct annotate__config {
+static struct annotate_config {
         const char *name;
         bool *value;
 } annotate__configs[] = {
@@ -939,7 +978,7 @@ static struct annotate__config {
 
 static int annotate_config__cmp(const void *name, const void *cfgp)
 {
-        const struct annotate__config *cfg = cfgp;
+        const struct annotate_config *cfg = cfgp;
 
         return strcmp(name, cfg->name);
 }
@@ -947,7 +986,7 @@ static int annotate_config__cmp(const void *name, const void *cfgp)
 static int annotate__config(const char *var, const char *value,
                             void *data __maybe_unused)
 {
-        struct annotate__config *cfg;
+        struct annotate_config *cfg;
         const char *name;
 
         if (prefixcmp(var, "annotate.") != 0)
@@ -955,7 +994,7 @@ static int annotate__config(const char *var, const char *value,
 
         name = var + 9;
         cfg = bsearch(name, annotate__configs, ARRAY_SIZE(annotate__configs),
-                      sizeof(struct annotate__config), annotate_config__cmp);
+                      sizeof(struct annotate_config), annotate_config__cmp);
 
         if (cfg == NULL)
                 return -1;
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index ccc4bd161420..fc0bd3843d34 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -2,7 +2,6 @@
 #include "../libslang.h"
 #include <stdlib.h>
 #include <string.h>
-#include <newt.h>
 #include <linux/rbtree.h>
 
 #include "../../util/evsel.h"
@@ -26,7 +25,8 @@ struct hist_browser {
         struct map_symbol   *selection;
         int                  print_seq;
         bool                 show_dso;
-        bool                 has_symbols;
+        float                min_pcnt;
+        u64                  nr_pcnt_entries;
 };
 
 extern void hist_browser__init_hpp(void);
@@ -310,6 +310,8 @@ static void ui_browser__warn_lost_events(struct ui_browser *browser)
                 "Or reduce the sampling frequency.");
 }
 
+static void hist_browser__update_pcnt_entries(struct hist_browser *hb);
+
 static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                              struct hist_browser_timer *hbt)
 {
@@ -319,6 +321,8 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
 
         browser->b.entries = &browser->hists->entries;
         browser->b.nr_entries = browser->hists->nr_entries;
+        if (browser->min_pcnt)
+                browser->b.nr_entries = browser->nr_pcnt_entries;
 
         hist_browser__refresh_dimensions(browser);
         hists__browser_title(browser->hists, title, sizeof(title), ev_name);
@@ -331,9 +335,18 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                 key = ui_browser__run(&browser->b, delay_secs);
 
                 switch (key) {
-                case K_TIMER:
+                case K_TIMER: {
+                        u64 nr_entries;
                         hbt->timer(hbt->arg);
-                        ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
+
+                        if (browser->min_pcnt) {
+                                hist_browser__update_pcnt_entries(browser);
+                                nr_entries = browser->nr_pcnt_entries;
+                        } else {
+                                nr_entries = browser->hists->nr_entries;
+                        }
+
+                        ui_browser__update_nr_entries(&browser->b, nr_entries);
 
                         if (browser->hists->stats.nr_lost_warned !=
                             browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
@@ -345,6 +358,7 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                         hists__browser_title(browser->hists, title, sizeof(title), ev_name);
                         ui_browser__show_title(&browser->b, title);
                         continue;
+                }
                 case 'D': { /* Debug */
                         static int seq;
                         struct hist_entry *h = rb_entry(browser->b.top,
@@ -567,26 +581,128 @@ static int hist_browser__show_callchain(struct hist_browser *browser,
         return row - first_row;
 }
 
-#define HPP__COLOR_FN(_name, _field)                                    \
-static int hist_browser__hpp_color_ ## _name(struct perf_hpp *hpp,      \
-                                             struct hist_entry *he)     \
+struct hpp_arg {
+        struct ui_browser *b;
+        char folded_sign;
+        bool current_entry;
+};
+
+static int __hpp__color_callchain(struct hpp_arg *arg)
+{
+        if (!symbol_conf.use_callchain)
+                return 0;
+
+        slsmg_printf("%c ", arg->folded_sign);
+        return 2;
+}
+
+static int __hpp__color_fmt(struct perf_hpp *hpp, struct hist_entry *he,
+                            u64 (*get_field)(struct hist_entry *),
+                            int (*callchain_cb)(struct hpp_arg *))
+{
+        int ret = 0;
+        double percent = 0.0;
+        struct hists *hists = he->hists;
+        struct hpp_arg *arg = hpp->ptr;
+
+        if (hists->stats.total_period)
+                percent = 100.0 * get_field(he) / hists->stats.total_period;
+
+        ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
+
+        if (callchain_cb)
+                ret += callchain_cb(arg);
+
+        ret += scnprintf(hpp->buf, hpp->size, "%6.2f%%", percent);
+        slsmg_printf("%s", hpp->buf);
+
+        if (symbol_conf.event_group) {
+                int prev_idx, idx_delta;
+                struct perf_evsel *evsel = hists_to_evsel(hists);
+                struct hist_entry *pair;
+                int nr_members = evsel->nr_members;
+
+                if (nr_members <= 1)
+                        goto out;
+
+                prev_idx = perf_evsel__group_idx(evsel);
+
+                list_for_each_entry(pair, &he->pairs.head, pairs.node) {
+                        u64 period = get_field(pair);
+                        u64 total = pair->hists->stats.total_period;
+
+                        if (!total)
+                                continue;
+
+                        evsel = hists_to_evsel(pair->hists);
+                        idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
+
+                        while (idx_delta--) {
+                                /*
+                                 * zero-fill group members in the middle which
+                                 * have no sample
+                                 */
+                                ui_browser__set_percent_color(arg->b, 0.0,
+                                                        arg->current_entry);
+                                ret += scnprintf(hpp->buf, hpp->size,
+                                                 " %6.2f%%", 0.0);
+                                slsmg_printf("%s", hpp->buf);
+                        }
+
+                        percent = 100.0 * period / total;
+                        ui_browser__set_percent_color(arg->b, percent,
+                                                      arg->current_entry);
+                        ret += scnprintf(hpp->buf, hpp->size,
+                                         " %6.2f%%", percent);
+                        slsmg_printf("%s", hpp->buf);
+
+                        prev_idx = perf_evsel__group_idx(evsel);
+                }
+
+                idx_delta = nr_members - prev_idx - 1;
+
+                while (idx_delta--) {
+                        /*
+                         * zero-fill group members at last which have no sample
+                         */
+                        ui_browser__set_percent_color(arg->b, 0.0,
+                                                      arg->current_entry);
+                        ret += scnprintf(hpp->buf, hpp->size,
+                                         " %6.2f%%", 0.0);
+                        slsmg_printf("%s", hpp->buf);
+                }
+        }
+out:
+        if (!arg->current_entry || !arg->b->navkeypressed)
+                ui_browser__set_color(arg->b, HE_COLORSET_NORMAL);
+
+        return ret;
+}
+
+#define __HPP_COLOR_PERCENT_FN(_type, _field, _cb)                      \
+static u64 __hpp_get_##_field(struct hist_entry *he)                    \
+{                                                                       \
+        return he->stat._field;                                         \
+}                                                                       \
+                                                                        \
+static int hist_browser__hpp_color_##_type(struct perf_hpp *hpp,        \
+                                           struct hist_entry *he)       \
 {                                                                       \
-        struct hists *hists = he->hists;                                \
-        double percent = 100.0 * he->stat._field / hists->stats.total_period; \
-        *(double *)hpp->ptr = percent;                                  \
-        return scnprintf(hpp->buf, hpp->size, "%6.2f%%", percent);      \
+        return __hpp__color_fmt(hpp, he, __hpp_get_##_field, _cb);      \
 }
 
-HPP__COLOR_FN(overhead, period)
-HPP__COLOR_FN(overhead_sys, period_sys)
-HPP__COLOR_FN(overhead_us, period_us)
-HPP__COLOR_FN(overhead_guest_sys, period_guest_sys)
-HPP__COLOR_FN(overhead_guest_us, period_guest_us)
+__HPP_COLOR_PERCENT_FN(overhead, period, __hpp__color_callchain)
+__HPP_COLOR_PERCENT_FN(overhead_sys, period_sys, NULL)
+__HPP_COLOR_PERCENT_FN(overhead_us, period_us, NULL)
+__HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys, NULL)
+__HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us, NULL)
 
-#undef HPP__COLOR_FN
+#undef __HPP_COLOR_PERCENT_FN
 
 void hist_browser__init_hpp(void)
 {
+        perf_hpp__column_enable(PERF_HPP__OVERHEAD);
+
         perf_hpp__init();
 
         perf_hpp__format[PERF_HPP__OVERHEAD].color =
@@ -606,13 +722,13 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                                     unsigned short row)
 {
         char s[256];
-        double percent;
-        int i, printed = 0;
+        int printed = 0;
         int width = browser->b.width;
         char folded_sign = ' ';
         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
         off_t row_offset = entry->row_offset;
         bool first = true;
+        struct perf_hpp_fmt *fmt;
 
         if (current_entry) {
                 browser->he_selection = entry;
@@ -625,41 +741,30 @@ static int hist_browser__show_entry(struct hist_browser *browser,
         }
 
         if (row_offset == 0) {
+                struct hpp_arg arg = {
+                        .b              = &browser->b,
+                        .folded_sign    = folded_sign,
+                        .current_entry  = current_entry,
+                };
                 struct perf_hpp hpp = {
                         .buf            = s,
                         .size           = sizeof(s),
+                        .ptr            = &arg,
                 };
 
                 ui_browser__gotorc(&browser->b, row, 0);
 
-                for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
-                        if (!perf_hpp__format[i].cond)
-                                continue;
-
+                perf_hpp__for_each_format(fmt) {
                         if (!first) {
                                 slsmg_printf("  ");
                                 width -= 2;
                         }
                         first = false;
 
-                        if (perf_hpp__format[i].color) {
-                                hpp.ptr = &percent;
-                                /* It will set percent for us. See HPP__COLOR_FN above. */
-                                width -= perf_hpp__format[i].color(&hpp, entry);
-
-                                ui_browser__set_percent_color(&browser->b, percent, current_entry);
-
-                                if (i == PERF_HPP__OVERHEAD && symbol_conf.use_callchain) {
-                                        slsmg_printf("%c ", folded_sign);
-                                        width -= 2;
-                                }
-
-                                slsmg_printf("%s", s);
-
-                                if (!current_entry || !browser->b.navkeypressed)
-                                        ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
+                        if (fmt->color) {
+                                width -= fmt->color(&hpp, entry);
                         } else {
-                                width -= perf_hpp__format[i].entry(&hpp, entry);
+                                width -= fmt->entry(&hpp, entry);
                                 slsmg_printf("%s", s);
                         }
                 }
@@ -706,10 +811,15 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
 
         for (nd = browser->top; nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                float percent = h->stat.period * 100.0 /
+                                        hb->hists->stats.total_period;
 
                 if (h->filtered)
                         continue;
 
+                if (percent < hb->min_pcnt)
+                        continue;
+
                 row += hist_browser__show_entry(hb, h, row);
                 if (row == browser->height)
                         break;
@@ -718,10 +828,18 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
         return row;
 }
 
-static struct rb_node *hists__filter_entries(struct rb_node *nd)
+static struct rb_node *hists__filter_entries(struct rb_node *nd,
+                                             struct hists *hists,
+                                             float min_pcnt)
 {
         while (nd != NULL) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
+
+                if (percent < min_pcnt)
+                        return NULL;
+
                 if (!h->filtered)
                         return nd;
 
@@ -731,11 +849,16 @@ static struct rb_node *hists__filter_entries(struct rb_node *nd)
         return NULL;
 }
 
-static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
+static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
+                                                  struct hists *hists,
+                                                  float min_pcnt)
 {
         while (nd != NULL) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
-                if (!h->filtered)
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
+
+                if (!h->filtered && percent >= min_pcnt)
                         return nd;
 
                 nd = rb_prev(nd);
@@ -750,6 +873,9 @@ static void ui_browser__hists_seek(struct ui_browser *browser,
         struct hist_entry *h;
         struct rb_node *nd;
         bool first = true;
+        struct hist_browser *hb;
+
+        hb = container_of(browser, struct hist_browser, b);
 
         if (browser->nr_entries == 0)
                 return;
@@ -758,13 +884,15 @@ static void ui_browser__hists_seek(struct ui_browser *browser,
 
         switch (whence) {
         case SEEK_SET:
-                nd = hists__filter_entries(rb_first(browser->entries));
+                nd = hists__filter_entries(rb_first(browser->entries),
+                                           hb->hists, hb->min_pcnt);
                 break;
         case SEEK_CUR:
                 nd = browser->top;
                 goto do_offset;
         case SEEK_END:
-                nd = hists__filter_prev_entries(rb_last(browser->entries));
+                nd = hists__filter_prev_entries(rb_last(browser->entries),
+                                                hb->hists, hb->min_pcnt);
                 first = false;
                 break;
         default:
@@ -807,7 +935,8 @@ do_offset:
                                         break;
                                 }
                         }
-                        nd = hists__filter_entries(rb_next(nd));
+                        nd = hists__filter_entries(rb_next(nd), hb->hists,
+                                                   hb->min_pcnt);
                         if (nd == NULL)
                                 break;
                         --offset;
@@ -840,7 +969,8 @@ do_offset:
                                 }
                         }
 
-                        nd = hists__filter_prev_entries(rb_prev(nd));
+                        nd = hists__filter_prev_entries(rb_prev(nd), hb->hists,
+                                                        hb->min_pcnt);
                         if (nd == NULL)
                                 break;
                         ++offset;
@@ -1009,14 +1139,17 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser,
 
 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
 {
-        struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries));
+        struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
+                                                   browser->hists,
+                                                   browser->min_pcnt);
         int printed = 0;
 
         while (nd) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 printed += hist_browser__fprintf_entry(browser, h, fp);
-                nd = hists__filter_entries(rb_next(nd));
+                nd = hists__filter_entries(rb_next(nd), browser->hists,
+                                           browser->min_pcnt);
         }
 
         return printed;
@@ -1065,10 +1198,6 @@ static struct hist_browser *hist_browser__new(struct hists *hists)
                 browser->b.refresh = hist_browser__refresh;
                 browser->b.seek = ui_browser__hists_seek;
                 browser->b.use_navkeypressed = true;
-                if (sort__branch_mode == 1)
-                        browser->has_symbols = sort_sym_from.list.next != NULL;
-                else
-                        browser->has_symbols = sort_sym.list.next != NULL;
         }
 
         return browser;
@@ -1098,6 +1227,21 @@ static int hists__browser_title(struct hists *hists, char *bf, size_t size,
         const struct thread *thread = hists->thread_filter;
         unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
         u64 nr_events = hists->stats.total_period;
+        struct perf_evsel *evsel = hists_to_evsel(hists);
+        char buf[512];
+        size_t buflen = sizeof(buf);
+
+        if (perf_evsel__is_group_event(evsel)) {
+                struct perf_evsel *pos;
+
+                perf_evsel__group_desc(evsel, buf, buflen);
+                ev_name = buf;
+
+                for_each_group_member(pos, evsel) {
+                        nr_samples += pos->hists.stats.nr_events[PERF_RECORD_SAMPLE];
+                        nr_events += pos->hists.stats.total_period;
+                }
+        }
 
         nr_samples = convert_unit(nr_samples, &unit);
         printed = scnprintf(bf, size,
@@ -1135,10 +1279,114 @@ static inline bool is_report_browser(void *timer)
         return timer == NULL;
 }
 
+/*
+ * Only runtime switching of perf data file will make "input_name" point
+ * to a malloced buffer. So add "is_input_name_malloced" flag to decide
+ * whether we need to call free() for current "input_name" during the switch.
+ */
+static bool is_input_name_malloced = false;
+
+static int switch_data_file(void)
+{
+        char *pwd, *options[32], *abs_path[32], *tmp;
+        DIR *pwd_dir;
+        int nr_options = 0, choice = -1, ret = -1;
+        struct dirent *dent;
+
+        pwd = getenv("PWD");
+        if (!pwd)
+                return ret;
+
+        pwd_dir = opendir(pwd);
+        if (!pwd_dir)
+                return ret;
+
+        memset(options, 0, sizeof(options));
+        memset(options, 0, sizeof(abs_path));
+
+        while ((dent = readdir(pwd_dir))) {
+                char path[PATH_MAX];
+                u64 magic;
+                char *name = dent->d_name;
+                FILE *file;
+
+                if (!(dent->d_type == DT_REG))
+                        continue;
+
+                snprintf(path, sizeof(path), "%s/%s", pwd, name);
+
+                file = fopen(path, "r");
+                if (!file)
+                        continue;
+
+                if (fread(&magic, 1, 8, file) < 8)
+                        goto close_file_and_continue;
+
+                if (is_perf_magic(magic)) {
+                        options[nr_options] = strdup(name);
+                        if (!options[nr_options])
+                                goto close_file_and_continue;
+
+                        abs_path[nr_options] = strdup(path);
+                        if (!abs_path[nr_options]) {
+                                free(options[nr_options]);
+                                ui__warning("Can't search all data files due to memory shortage.\n");
+                                fclose(file);
+                                break;
+                        }
+
+                        nr_options++;
+                }
+
+close_file_and_continue:
+                fclose(file);
+                if (nr_options >= 32) {
+                        ui__warning("Too many perf data files in PWD!\n"
+                                    "Only the first 32 files will be listed.\n");
+                        break;
+                }
+        }
+        closedir(pwd_dir);
+
+        if (nr_options) {
+                choice = ui__popup_menu(nr_options, options);
+                if (choice < nr_options && choice >= 0) {
+                        tmp = strdup(abs_path[choice]);
+                        if (tmp) {
+                                if (is_input_name_malloced)
+                                        free((void *)input_name);
+                                input_name = tmp;
+                                is_input_name_malloced = true;
+                                ret = 0;
+                        } else
+                                ui__warning("Data switch failed due to memory shortage!\n");
+                }
+        }
+
+        free_popup_options(options, nr_options);
+        free_popup_options(abs_path, nr_options);
+        return ret;
+}
+
+static void hist_browser__update_pcnt_entries(struct hist_browser *hb)
+{
+        u64 nr_entries = 0;
+        struct rb_node *nd = rb_first(&hb->hists->entries);
+
+        while (nd) {
+                nr_entries++;
+                nd = hists__filter_entries(rb_next(nd), hb->hists,
+                                           hb->min_pcnt);
+        }
+
+        hb->nr_pcnt_entries = nr_entries;
+}
+
 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                     const char *helpline, const char *ev_name,
                                     bool left_exits,
                                     struct hist_browser_timer *hbt,
+                                    float min_pcnt,
                                     struct perf_session_env *env)
 {
         struct hists *hists = &evsel->hists;
@@ -1155,6 +1403,11 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         if (browser == NULL)
                 return -1;
 
+        if (min_pcnt) {
+                browser->min_pcnt = min_pcnt;
+                hist_browser__update_pcnt_entries(browser);
+        }
+
         fstack = pstack__new(2);
         if (fstack == NULL)
                 goto out;
@@ -1169,7 +1422,8 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                 int choice = 0,
                     annotate = -2, zoom_dso = -2, zoom_thread = -2,
                     annotate_f = -2, annotate_t = -2, browse_map = -2;
-                int scripts_comm = -2, scripts_symbol = -2, scripts_all = -2;
+                int scripts_comm = -2, scripts_symbol = -2,
+                    scripts_all = -2, switch_data = -2;
 
                 nr_options = 0;
 
@@ -1190,7 +1444,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                          */
                         goto out_free_stack;
                 case 'a':
-                        if (!browser->has_symbols) {
+                        if (!sort__has_sym) {
                                 ui_browser__warning(&browser->b, delay_secs * 2,
                         "Annotation is only available for symbolic views, "
                         "include \"sym*\" in --sort to use it.");
@@ -1226,6 +1480,10 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         if (is_report_browser(hbt))
                                 goto do_scripts;
                         continue;
+                case 's':
+                        if (is_report_browser(hbt))
+                                goto do_data_switch;
+                        continue;
                 case K_F1:
                 case 'h':
                 case '?':
@@ -1245,6 +1503,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                         "d             Zoom into current DSO\n"
                                         "t             Zoom into current Thread\n"
                                         "r             Run available scripts('perf report' only)\n"
+                                        "s             Switch to another data file in PWD ('perf report' only)\n"
                                         "P             Print histograms to perf.hist.N\n"
                                         "V             Verbose (DSO names in callchains, etc)\n"
                                         "/             Filter symbol by name");
@@ -1284,10 +1543,10 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         continue;
                 }
 
-                if (!browser->has_symbols)
+                if (!sort__has_sym)
                         goto add_exit_option;
 
-                if (sort__branch_mode == 1) {
+                if (sort__mode == SORT_MODE__BRANCH) {
                         bi = browser->he_selection->branch_info;
                         if (browser->selection != NULL &&
                             bi &&
@@ -1352,6 +1611,9 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                 if (asprintf(&options[nr_options], "Run scripts for all samples") > 0)
                         scripts_all = nr_options++;
 
+                if (is_report_browser(hbt) && asprintf(&options[nr_options],
+                                "Switch to another data file in PWD") > 0)
+                        switch_data = nr_options++;
 add_exit_option:
                 options[nr_options++] = (char *)"Exit";
 retry_popup_menu:
@@ -1394,7 +1656,7 @@ do_annotate:
                          * Don't let this be freed, say, by hists__decay_entry.
                          */
                         he->used = true;
-                        err = hist_entry__tui_annotate(he, evsel->idx, hbt);
+                        err = hist_entry__tui_annotate(he, evsel, hbt);
                         he->used = false;
                         /*
                          * offer option to annotate the other branch source or target
@@ -1462,6 +1724,16 @@ do_scripts:
 
                         script_browse(script_opt);
                 }
+                /* Switch to another data file */
+                else if (choice == switch_data) {
+do_data_switch:
+                        if (!switch_data_file()) {
+                                key = K_SWITCH_INPUT_DATA;
+                                break;
+                        } else
+                                ui__warning("Won't switch the data files due to\n"
+                                        "no valid data file get selected!\n");
+                }
         }
 out_free_stack:
         pstack__delete(fstack);
@@ -1475,6 +1747,7 @@ struct perf_evsel_menu {
         struct ui_browser b;
         struct perf_evsel *selection;
         bool lost_events, lost_events_warned;
+        float min_pcnt;
         struct perf_session_env *env;
 };
 
@@ -1494,6 +1767,16 @@ static void perf_evsel_menu__write(struct ui_browser *browser,
         ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
                                                        HE_COLORSET_NORMAL);
 
+        if (perf_evsel__is_group_event(evsel)) {
+                struct perf_evsel *pos;
+
+                ev_name = perf_evsel__group_name(evsel);
+
+                for_each_group_member(pos, evsel) {
+                        nr_events += pos->hists.stats.nr_events[PERF_RECORD_SAMPLE];
+                }
+        }
+
         nr_events = convert_unit(nr_events, &unit);
         printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
                            unit, unit == ' ' ? "" : " ", ev_name);
@@ -1558,6 +1841,7 @@ browse_hists:
                         ev_name = perf_evsel__name(pos);
                         key = perf_evsel__hists_browse(pos, nr_events, help,
                                                        ev_name, true, hbt,
+                                                       menu->min_pcnt,
                                                        menu->env);
                         ui_browser__show_title(&menu->b, title);
                         switch (key) {
@@ -1578,6 +1862,7 @@ browse_hists:
                                                 "Do you really want to exit?"))
                                         continue;
                                 /* Fall thru */
+                        case K_SWITCH_INPUT_DATA:
                         case 'q':
                         case CTRL('c'):
                                 goto out;
@@ -1604,9 +1889,21 @@ out:
         return key;
 }
 
+static bool filter_group_entries(struct ui_browser *self __maybe_unused,
+                                 void *entry)
+{
+        struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
+
+        if (symbol_conf.event_group && !perf_evsel__is_group_leader(evsel))
+                return true;
+
+        return false;
+}
+
 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
-                                           const char *help,
+                                           int nr_entries, const char *help,
                                            struct hist_browser_timer *hbt,
+                                           float min_pcnt,
                                            struct perf_session_env *env)
 {
         struct perf_evsel *pos;
@@ -1616,9 +1913,11 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
                         .refresh    = ui_browser__list_head_refresh,
                         .seek       = ui_browser__list_head_seek,
                         .write      = perf_evsel_menu__write,
-                        .nr_entries = evlist->nr_entries,
+                        .filter     = filter_group_entries,
+                        .nr_entries = nr_entries,
                         .priv       = evlist,
                 },
+                .min_pcnt = min_pcnt,
                 .env = env,
         };
 
@@ -1632,20 +1931,39 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
                         menu.b.width = line_len;
         }
 
-        return perf_evsel_menu__run(&menu, evlist->nr_entries, help, hbt);
+        return perf_evsel_menu__run(&menu, nr_entries, help, hbt);
 }
 
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
                                   struct hist_browser_timer *hbt,
+                                  float min_pcnt,
                                   struct perf_session_env *env)
 {
-        if (evlist->nr_entries == 1) {
+        int nr_entries = evlist->nr_entries;
+
+single_entry:
+        if (nr_entries == 1) {
                 struct perf_evsel *first = list_entry(evlist->entries.next,
                                                       struct perf_evsel, node);
                 const char *ev_name = perf_evsel__name(first);
-                return perf_evsel__hists_browse(first, evlist->nr_entries, help,
-                                                ev_name, false, hbt, env);
+
+                return perf_evsel__hists_browse(first, nr_entries, help,
+                                                ev_name, false, hbt, min_pcnt,
+                                                env);
+        }
+
+        if (symbol_conf.event_group) {
+                struct perf_evsel *pos;
+
+                nr_entries = 0;
+                list_for_each_entry(pos, &evlist->entries, node)
+                        if (perf_evsel__is_group_leader(pos))
+                                nr_entries++;
+
+                if (nr_entries == 1)
+                        goto single_entry;
         }
 
-        return __perf_evlist__tui_browse_hists(evlist, help, hbt, env);
+        return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
+                                               hbt, min_pcnt, env);
 }
diff --git a/tools/perf/ui/browsers/map.c b/tools/perf/ui/browsers/map.c
index 98851d55a53e..95c7cfb8f2c6 100644
--- a/tools/perf/ui/browsers/map.c
+++ b/tools/perf/ui/browsers/map.c
@@ -1,6 +1,5 @@
 #include "../libslang.h"
 #include <elf.h>
-#include <newt.h>
 #include <inttypes.h>
 #include <sys/ttydefaults.h>
 #include <string.h>
@@ -10,41 +9,9 @@
 #include "../../util/symbol.h"
 #include "../browser.h"
 #include "../helpline.h"
+#include "../keysyms.h"
 #include "map.h"
 
-static int ui_entry__read(const char *title, char *bf, size_t size, int width)
-{
-        struct newtExitStruct es;
-        newtComponent form, entry;
-        const char *result;
-        int err = -1;
-
-        newtCenteredWindow(width, 1, title);
-        form = newtForm(NULL, NULL, 0);
-        if (form == NULL)
-                return -1;
-
-        entry = newtEntry(0, 0, "0x", width, &result, NEWT_FLAG_SCROLL);
-        if (entry == NULL)
-                goto out_free_form;
-
-        newtFormAddComponent(form, entry);
-        newtFormAddHotKey(form, NEWT_KEY_ENTER);
-        newtFormAddHotKey(form, NEWT_KEY_ESCAPE);
-        newtFormAddHotKey(form, NEWT_KEY_LEFT);
-        newtFormAddHotKey(form, CTRL('c'));
-        newtFormRun(form, &es);
-
-        if (result != NULL) {
-                strncpy(bf, result, size);
-                err = 0;
-        }
-out_free_form:
-        newtPopWindow();
-        newtFormDestroy(form);
-        return err;
-}
-
 struct map_browser {
         struct ui_browser b;
         struct map        *map;
@@ -78,10 +45,11 @@ static int map_browser__search(struct map_browser *self)
 {
         char target[512];
         struct symbol *sym;
-        int err = ui_entry__read("Search by name/addr", target, sizeof(target), 40);
-
-        if (err)
-                return err;
+        int err = ui_browser__input_window("Search by name/addr",
+                                           "Prefix with 0x to search by address",
+                                           target, "ENTER: OK, ESC: Cancel", 0);
+        if (err != K_ENTER)
+                return -1;
 
         if (target[0] == '0' && tolower(target[1]) == 'x') {
                 u64 addr = strtoull(target, NULL, 16);
@@ -112,12 +80,20 @@ static int map_browser__run(struct map_browser *self)
         while (1) {
                 key = ui_browser__run(&self->b, 0);
 
-                if (verbose && key == '/')
-                        map_browser__search(self);
-                else
+                switch (key) {
+                case '/':
+                        if (verbose)
+                                map_browser__search(self);
+                default:
                         break;
+                case K_LEFT:
+                case K_ESC:
+                case 'q':
+                case CTRL('c'):
+                        goto out;
+                }
         }
-
+out:
         ui_browser__hide(&self->b);
         return key;
 }
diff --git a/tools/perf/ui/browsers/scripts.c b/tools/perf/ui/browsers/scripts.c
index cbbd44b0d93e..12f009e61e94 100644
--- a/tools/perf/ui/browsers/scripts.c
+++ b/tools/perf/ui/browsers/scripts.c
@@ -1,5 +1,4 @@
 #include <elf.h>
-#include <newt.h>
 #include <inttypes.h>
 #include <sys/ttydefaults.h>
 #include <string.h>
diff --git a/tools/perf/ui/gtk/annotate.c b/tools/perf/ui/gtk/annotate.c
new file mode 100644
index 000000000000..f538794615db
--- /dev/null
+++ b/tools/perf/ui/gtk/annotate.c
@@ -0,0 +1,245 @@
+#include "gtk.h"
+#include "util/debug.h"
+#include "util/annotate.h"
+#include "util/evsel.h"
+#include "ui/helpline.h"
+
+
+enum {
+        ANN_COL__PERCENT,
+        ANN_COL__OFFSET,
+        ANN_COL__LINE,
+
+        MAX_ANN_COLS
+};
+
+static const char *const col_names[] = {
+        "Overhead",
+        "Offset",
+        "Line"
+};
+
+static int perf_gtk__get_percent(char *buf, size_t size, struct symbol *sym,
+                                 struct disasm_line *dl, int evidx)
+{
+        struct sym_hist *symhist;
+        double percent = 0.0;
+        const char *markup;
+        int ret = 0;
+
+        strcpy(buf, "");
+
+        if (dl->offset == (s64) -1)
+                return 0;
+
+        symhist = annotation__histogram(symbol__annotation(sym), evidx);
+        if (!symbol_conf.event_group && !symhist->addr[dl->offset])
+                return 0;
+
+        percent = 100.0 * symhist->addr[dl->offset] / symhist->sum;
+
+        markup = perf_gtk__get_percent_color(percent);
+        if (markup)
+                ret += scnprintf(buf, size, "%s", markup);
+        ret += scnprintf(buf + ret, size - ret, "%6.2f%%", percent);
+        if (markup)
+                ret += scnprintf(buf + ret, size - ret, "</span>");
+
+        return ret;
+}
+
+static int perf_gtk__get_offset(char *buf, size_t size, struct symbol *sym,
+                                struct map *map, struct disasm_line *dl)
+{
+        u64 start = map__rip_2objdump(map, sym->start);
+
+        strcpy(buf, "");
+
+        if (dl->offset == (s64) -1)
+                return 0;
+
+        return scnprintf(buf, size, "%"PRIx64, start + dl->offset);
+}
+
+static int perf_gtk__get_line(char *buf, size_t size, struct disasm_line *dl)
+{
+        int ret = 0;
+        char *line = g_markup_escape_text(dl->line, -1);
+        const char *markup = "<span fgcolor='gray'>";
+
+        strcpy(buf, "");
+
+        if (!line)
+                return 0;
+
+        if (dl->offset != (s64) -1)
+                markup = NULL;
+
+        if (markup)
+                ret += scnprintf(buf, size, "%s", markup);
+        ret += scnprintf(buf + ret, size - ret, "%s", line);
+        if (markup)
+                ret += scnprintf(buf + ret, size - ret, "</span>");
+
+        g_free(line);
+        return ret;
+}
+
+static int perf_gtk__annotate_symbol(GtkWidget *window, struct symbol *sym,
+                                struct map *map, struct perf_evsel *evsel,
+                                struct hist_browser_timer *hbt __maybe_unused)
+{
+        struct disasm_line *pos, *n;
+        struct annotation *notes;
+        GType col_types[MAX_ANN_COLS];
+        GtkCellRenderer *renderer;
+        GtkListStore *store;
+        GtkWidget *view;
+        int i;
+        char s[512];
+
+        notes = symbol__annotation(sym);
+
+        for (i = 0; i < MAX_ANN_COLS; i++) {
+                col_types[i] = G_TYPE_STRING;
+        }
+        store = gtk_list_store_newv(MAX_ANN_COLS, col_types);
+
+        view = gtk_tree_view_new();
+        renderer = gtk_cell_renderer_text_new();
+
+        for (i = 0; i < MAX_ANN_COLS; i++) {
+                gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
+                                        -1, col_names[i], renderer, "markup",
+                                        i, NULL);
+        }
+
+        gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
+        g_object_unref(GTK_TREE_MODEL(store));
+
+        list_for_each_entry(pos, &notes->src->source, node) {
+                GtkTreeIter iter;
+                int ret = 0;
+
+                gtk_list_store_append(store, &iter);
+
+                if (perf_evsel__is_group_event(evsel)) {
+                        for (i = 0; i < evsel->nr_members; i++) {
+                                ret += perf_gtk__get_percent(s + ret,
+                                                             sizeof(s) - ret,
+                                                             sym, pos,
+                                                             evsel->idx + i);
+                                ret += scnprintf(s + ret, sizeof(s) - ret, " ");
+                        }
+                } else {
+                        ret = perf_gtk__get_percent(s, sizeof(s), sym, pos,
+                                                    evsel->idx);
+                }
+
+                if (ret)
+                        gtk_list_store_set(store, &iter, ANN_COL__PERCENT, s, -1);
+                if (perf_gtk__get_offset(s, sizeof(s), sym, map, pos))
+                        gtk_list_store_set(store, &iter, ANN_COL__OFFSET, s, -1);
+                if (perf_gtk__get_line(s, sizeof(s), pos))
+                        gtk_list_store_set(store, &iter, ANN_COL__LINE, s, -1);
+        }
+
+        gtk_container_add(GTK_CONTAINER(window), view);
+
+        list_for_each_entry_safe(pos, n, &notes->src->source, node) {
+                list_del(&pos->node);
+                disasm_line__free(pos);
+        }
+
+        return 0;
+}
+
+int symbol__gtk_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel,
+                         struct hist_browser_timer *hbt)
+{
+        GtkWidget *window;
+        GtkWidget *notebook;
+        GtkWidget *scrolled_window;
+        GtkWidget *tab_label;
+
+        if (map->dso->annotate_warned)
+                return -1;
+
+        if (symbol__annotate(sym, map, 0) < 0) {
+                ui__error("%s", ui_helpline__current);
+                return -1;
+        }
+
+        if (perf_gtk__is_active_context(pgctx)) {
+                window = pgctx->main_window;
+                notebook = pgctx->notebook;
+        } else {
+                GtkWidget *vbox;
+                GtkWidget *infobar;
+                GtkWidget *statbar;
+
+                signal(SIGSEGV, perf_gtk__signal);
+                signal(SIGFPE,  perf_gtk__signal);
+                signal(SIGINT,  perf_gtk__signal);
+                signal(SIGQUIT, perf_gtk__signal);
+                signal(SIGTERM, perf_gtk__signal);
+
+                window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+                gtk_window_set_title(GTK_WINDOW(window), "perf annotate");
+
+                g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
+
+                pgctx = perf_gtk__activate_context(window);
+                if (!pgctx)
+                        return -1;
+
+                vbox = gtk_vbox_new(FALSE, 0);
+                notebook = gtk_notebook_new();
+                pgctx->notebook = notebook;
+
+                gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
+
+                infobar = perf_gtk__setup_info_bar();
+                if (infobar) {
+                        gtk_box_pack_start(GTK_BOX(vbox), infobar,
+                                           FALSE, FALSE, 0);
+                }
+
+                statbar = perf_gtk__setup_statusbar();
+                gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
+
+                gtk_container_add(GTK_CONTAINER(window), vbox);
+        }
+
+        scrolled_window = gtk_scrolled_window_new(NULL, NULL);
+        tab_label = gtk_label_new(sym->name);
+
+        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
+                                       GTK_POLICY_AUTOMATIC,
+                                       GTK_POLICY_AUTOMATIC);
+
+        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window,
+                                 tab_label);
+
+        perf_gtk__annotate_symbol(scrolled_window, sym, map, evsel, hbt);
+        return 0;
+}
+
+void perf_gtk__show_annotations(void)
+{
+        GtkWidget *window;
+
+        if (!perf_gtk__is_active_context(pgctx))
+                return;
+
+        window = pgctx->main_window;
+        gtk_widget_show_all(window);
+
+        perf_gtk__resize_window(window);
+        gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
+
+        gtk_main();
+
+        perf_gtk__deactivate_context(&pgctx);
+}
diff --git a/tools/perf/ui/gtk/browser.c b/tools/perf/ui/gtk/browser.c
index 253b6219a39e..c95012cdb438 100644
--- a/tools/perf/ui/gtk/browser.c
+++ b/tools/perf/ui/gtk/browser.c
@@ -8,15 +8,13 @@
 
 #include <signal.h>
 
-#define MAX_COLUMNS                     32
-
-static void perf_gtk__signal(int sig)
+void perf_gtk__signal(int sig)
 {
         perf_gtk__exit(false);
         psignal(sig, "perf");
 }
 
-static void perf_gtk__resize_window(GtkWidget *window)
+void perf_gtk__resize_window(GtkWidget *window)
 {
         GdkRectangle rect;
         GdkScreen *screen;
@@ -36,7 +34,7 @@ static void perf_gtk__resize_window(GtkWidget *window)
         gtk_window_resize(GTK_WINDOW(window), width, height);
 }
 
-static const char *perf_gtk__get_percent_color(double percent)
+const char *perf_gtk__get_percent_color(double percent)
 {
         if (percent >= MIN_RED)
                 return "<span fgcolor='red'>";
@@ -45,155 +43,8 @@ static const char *perf_gtk__get_percent_color(double percent)
         return NULL;
 }
 
-#define HPP__COLOR_FN(_name, _field)                                            \
-static int perf_gtk__hpp_color_ ## _name(struct perf_hpp *hpp,                  \
-                                         struct hist_entry *he)                 \
-{                                                                               \
-        struct hists *hists = he->hists;                                        \
-        double percent = 100.0 * he->stat._field / hists->stats.total_period;   \
-        const char *markup;                                                     \
-        int ret = 0;                                                            \
-                                                                                \
-        markup = perf_gtk__get_percent_color(percent);                          \
-        if (markup)                                                             \
-                ret += scnprintf(hpp->buf, hpp->size, "%s", markup);            \
-        ret += scnprintf(hpp->buf + ret, hpp->size - ret, "%6.2f%%", percent);  \
-        if (markup)                                                             \
-                ret += scnprintf(hpp->buf + ret, hpp->size - ret, "</span>");   \
-                                                                                \
-        return ret;                                                             \
-}
-
-HPP__COLOR_FN(overhead, period)
-HPP__COLOR_FN(overhead_sys, period_sys)
-HPP__COLOR_FN(overhead_us, period_us)
-HPP__COLOR_FN(overhead_guest_sys, period_guest_sys)
-HPP__COLOR_FN(overhead_guest_us, period_guest_us)
-
-#undef HPP__COLOR_FN
-
-void perf_gtk__init_hpp(void)
-{
-        perf_hpp__init();
-
-        perf_hpp__format[PERF_HPP__OVERHEAD].color =
-                                perf_gtk__hpp_color_overhead;
-        perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
-                                perf_gtk__hpp_color_overhead_sys;
-        perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
-                                perf_gtk__hpp_color_overhead_us;
-        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
-                                perf_gtk__hpp_color_overhead_guest_sys;
-        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
-                                perf_gtk__hpp_color_overhead_guest_us;
-}
-
-static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
-{
-        GType col_types[MAX_COLUMNS];
-        GtkCellRenderer *renderer;
-        struct sort_entry *se;
-        GtkListStore *store;
-        struct rb_node *nd;
-        GtkWidget *view;
-        int i, col_idx;
-        int nr_cols;
-        char s[512];
-
-        struct perf_hpp hpp = {
-                .buf            = s,
-                .size           = sizeof(s),
-        };
-
-        nr_cols = 0;
-
-        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
-                if (!perf_hpp__format[i].cond)
-                        continue;
-
-                col_types[nr_cols++] = G_TYPE_STRING;
-        }
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                if (se->elide)
-                        continue;
-
-                col_types[nr_cols++] = G_TYPE_STRING;
-        }
-
-        store = gtk_list_store_newv(nr_cols, col_types);
-
-        view = gtk_tree_view_new();
-
-        renderer = gtk_cell_renderer_text_new();
-
-        col_idx = 0;
-
-        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
-                if (!perf_hpp__format[i].cond)
-                        continue;
-
-                perf_hpp__format[i].header(&hpp);
-
-                gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
-                                                            -1, s,
-                                                            renderer, "markup",
-                                                            col_idx++, NULL);
-        }
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                if (se->elide)
-                        continue;
-
-                gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
-                                                            -1, se->se_header,
-                                                            renderer, "text",
-                                                            col_idx++, NULL);
-        }
-
-        gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
-
-        g_object_unref(GTK_TREE_MODEL(store));
-
-        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
-                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
-                GtkTreeIter iter;
-
-                if (h->filtered)
-                        continue;
-
-                gtk_list_store_append(store, &iter);
-
-                col_idx = 0;
-
-                for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
-                        if (!perf_hpp__format[i].cond)
-                                continue;
-
-                        if (perf_hpp__format[i].color)
-                                perf_hpp__format[i].color(&hpp, h);
-                        else
-                                perf_hpp__format[i].entry(&hpp, h);
-
-                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
-                }
-
-                list_for_each_entry(se, &hist_entry__sort_list, list) {
-                        if (se->elide)
-                                continue;
-
-                        se->se_snprintf(h, s, ARRAY_SIZE(s),
-                                        hists__col_len(hists, se->se_width_idx));
-
-                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
-                }
-        }
-
-        gtk_container_add(GTK_CONTAINER(window), view);
-}
-
 #ifdef HAVE_GTK_INFO_BAR
-static GtkWidget *perf_gtk__setup_info_bar(void)
+GtkWidget *perf_gtk__setup_info_bar(void)
 {
         GtkWidget *info_bar;
         GtkWidget *label;
@@ -220,7 +71,7 @@ static GtkWidget *perf_gtk__setup_info_bar(void)
 }
 #endif
 
-static GtkWidget *perf_gtk__setup_statusbar(void)
+GtkWidget *perf_gtk__setup_statusbar(void)
 {
         GtkWidget *stbar;
         unsigned ctxid;
@@ -234,79 +85,3 @@ static GtkWidget *perf_gtk__setup_statusbar(void)
 
         return stbar;
 }
-
-int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
-                                  const char *help,
-                                  struct hist_browser_timer *hbt __maybe_unused)
-{
-        struct perf_evsel *pos;
-        GtkWidget *vbox;
-        GtkWidget *notebook;
-        GtkWidget *info_bar;
-        GtkWidget *statbar;
-        GtkWidget *window;
-
-        signal(SIGSEGV, perf_gtk__signal);
-        signal(SIGFPE,  perf_gtk__signal);
-        signal(SIGINT,  perf_gtk__signal);
-        signal(SIGQUIT, perf_gtk__signal);
-        signal(SIGTERM, perf_gtk__signal);
-
-        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-
-        gtk_window_set_title(GTK_WINDOW(window), "perf report");
-
-        g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
-
-        pgctx = perf_gtk__activate_context(window);
-        if (!pgctx)
-                return -1;
-
-        vbox = gtk_vbox_new(FALSE, 0);
-
-        notebook = gtk_notebook_new();
-
-        list_for_each_entry(pos, &evlist->entries, node) {
-                struct hists *hists = &pos->hists;
-                const char *evname = perf_evsel__name(pos);
-                GtkWidget *scrolled_window;
-                GtkWidget *tab_label;
-
-                scrolled_window = gtk_scrolled_window_new(NULL, NULL);
-
-                gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
-                                                        GTK_POLICY_AUTOMATIC,
-                                                        GTK_POLICY_AUTOMATIC);
-
-                perf_gtk__show_hists(scrolled_window, hists);
-
-                tab_label = gtk_label_new(evname);
-
-                gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
-        }
-
-        gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
-
-        info_bar = perf_gtk__setup_info_bar();
-        if (info_bar)
-                gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);
-
-        statbar = perf_gtk__setup_statusbar();
-        gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
-
-        gtk_container_add(GTK_CONTAINER(window), vbox);
-
-        gtk_widget_show_all(window);
-
-        perf_gtk__resize_window(window);
-
-        gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
-
-        ui_helpline__push(help);
-
-        gtk_main();
-
-        perf_gtk__deactivate_context(&pgctx);
-
-        return 0;
-}
diff --git a/tools/perf/ui/gtk/gtk.h b/tools/perf/ui/gtk/gtk.h
index 856320e2cc05..3d96785ef155 100644
--- a/tools/perf/ui/gtk/gtk.h
+++ b/tools/perf/ui/gtk/gtk.h
@@ -10,6 +10,7 @@
 
 struct perf_gtk_context {
         GtkWidget *main_window;
+        GtkWidget *notebook;
 
 #ifdef HAVE_GTK_INFO_BAR
         GtkWidget *info_bar;
@@ -33,7 +34,14 @@ void perf_gtk__init_helpline(void);
 void perf_gtk__init_progress(void);
 void perf_gtk__init_hpp(void);
 
-#ifndef HAVE_GTK_INFO_BAR
+void perf_gtk__signal(int sig);
+void perf_gtk__resize_window(GtkWidget *window);
+const char *perf_gtk__get_percent_color(double percent);
+GtkWidget *perf_gtk__setup_statusbar(void);
+
+#ifdef HAVE_GTK_INFO_BAR
+GtkWidget *perf_gtk__setup_info_bar(void);
+#else
 static inline GtkWidget *perf_gtk__setup_info_bar(void)
 {
         return NULL;
diff --git a/tools/perf/ui/gtk/helpline.c b/tools/perf/ui/gtk/helpline.c
index 5db4432ff12a..3388cbd12186 100644
--- a/tools/perf/ui/gtk/helpline.c
+++ b/tools/perf/ui/gtk/helpline.c
@@ -24,17 +24,7 @@ static void gtk_helpline_push(const char *msg)
                            pgctx->statbar_ctx_id, msg);
 }
 
-static struct ui_helpline gtk_helpline_fns = {
-        .pop    = gtk_helpline_pop,
-        .push   = gtk_helpline_push,
-};
-
-void perf_gtk__init_helpline(void)
-{
-        helpline_fns = &gtk_helpline_fns;
-}
-
-int perf_gtk__show_helpline(const char *fmt, va_list ap)
+static int gtk_helpline_show(const char *fmt, va_list ap)
 {
         int ret;
         char *ptr;
@@ -54,3 +44,14 @@ int perf_gtk__show_helpline(const char *fmt, va_list ap)
 
         return ret;
 }
+
+static struct ui_helpline gtk_helpline_fns = {
+        .pop    = gtk_helpline_pop,
+        .push   = gtk_helpline_push,
+        .show   = gtk_helpline_show,
+};
+
+void perf_gtk__init_helpline(void)
+{
+        helpline_fns = &gtk_helpline_fns;
+}
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
new file mode 100644
index 000000000000..9708dd5fb8f3
--- /dev/null
+++ b/tools/perf/ui/gtk/hists.c
@@ -0,0 +1,316 @@
+#include "../evlist.h"
+#include "../cache.h"
+#include "../evsel.h"
+#include "../sort.h"
+#include "../hist.h"
+#include "../helpline.h"
+#include "gtk.h"
+
+#define MAX_COLUMNS                     32
+
+static int __percent_color_snprintf(char *buf, size_t size, double percent)
+{
+        int ret = 0;
+        const char *markup;
+
+        markup = perf_gtk__get_percent_color(percent);
+        if (markup)
+                ret += scnprintf(buf, size, markup);
+
+        ret += scnprintf(buf + ret, size - ret, " %6.2f%%", percent);
+
+        if (markup)
+                ret += scnprintf(buf + ret, size - ret, "</span>");
+
+        return ret;
+}
+
+
+static int __hpp__color_fmt(struct perf_hpp *hpp, struct hist_entry *he,
+                            u64 (*get_field)(struct hist_entry *))
+{
+        int ret;
+        double percent = 0.0;
+        struct hists *hists = he->hists;
+        struct perf_evsel *evsel = hists_to_evsel(hists);
+
+        if (hists->stats.total_period)
+                percent = 100.0 * get_field(he) / hists->stats.total_period;
+
+        ret = __percent_color_snprintf(hpp->buf, hpp->size, percent);
+
+        if (perf_evsel__is_group_event(evsel)) {
+                int prev_idx, idx_delta;
+                struct hist_entry *pair;
+                int nr_members = evsel->nr_members;
+
+                prev_idx = perf_evsel__group_idx(evsel);
+
+                list_for_each_entry(pair, &he->pairs.head, pairs.node) {
+                        u64 period = get_field(pair);
+                        u64 total = pair->hists->stats.total_period;
+
+                        evsel = hists_to_evsel(pair->hists);
+                        idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
+
+                        while (idx_delta--) {
+                                /*
+                                 * zero-fill group members in the middle which
+                                 * have no sample
+                                 */
+                                ret += __percent_color_snprintf(hpp->buf + ret,
+                                                                hpp->size - ret,
+                                                                0.0);
+                        }
+
+                        percent = 100.0 * period / total;
+                        ret += __percent_color_snprintf(hpp->buf + ret,
+                                                        hpp->size - ret,
+                                                        percent);
+
+                        prev_idx = perf_evsel__group_idx(evsel);
+                }
+
+                idx_delta = nr_members - prev_idx - 1;
+
+                while (idx_delta--) {
+                        /*
+                         * zero-fill group members at last which have no sample
+                         */
+                        ret += __percent_color_snprintf(hpp->buf + ret,
+                                                        hpp->size - ret,
+                                                        0.0);
+                }
+        }
+        return ret;
+}
+
+#define __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
+static u64 he_get_##_field(struct hist_entry *he)                               \
+{                                                                               \
+        return he->stat._field;                                                 \
+}                                                                               \
+                                                                                \
+static int perf_gtk__hpp_color_##_type(struct perf_hpp *hpp,                    \
+                                       struct hist_entry *he)                   \
+{                                                                               \
+        return __hpp__color_fmt(hpp, he, he_get_##_field);                      \
+}
+
+__HPP_COLOR_PERCENT_FN(overhead, period)
+__HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
+__HPP_COLOR_PERCENT_FN(overhead_us, period_us)
+__HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
+__HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
+
+#undef __HPP_COLOR_PERCENT_FN
+
+
+void perf_gtk__init_hpp(void)
+{
+        perf_hpp__column_enable(PERF_HPP__OVERHEAD);
+
+        perf_hpp__init();
+
+        perf_hpp__format[PERF_HPP__OVERHEAD].color =
+                                perf_gtk__hpp_color_overhead;
+        perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
+                                perf_gtk__hpp_color_overhead_sys;
+        perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
+                                perf_gtk__hpp_color_overhead_us;
+        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
+                                perf_gtk__hpp_color_overhead_guest_sys;
+        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
+                                perf_gtk__hpp_color_overhead_guest_us;
+}
+
+static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,
+                                 float min_pcnt)
+{
+        struct perf_hpp_fmt *fmt;
+        GType col_types[MAX_COLUMNS];
+        GtkCellRenderer *renderer;
+        struct sort_entry *se;
+        GtkListStore *store;
+        struct rb_node *nd;
+        GtkWidget *view;
+        int col_idx;
+        int nr_cols;
+        char s[512];
+
+        struct perf_hpp hpp = {
+                .buf            = s,
+                .size           = sizeof(s),
+                .ptr            = hists_to_evsel(hists),
+        };
+
+        nr_cols = 0;
+
+        perf_hpp__for_each_format(fmt)
+                col_types[nr_cols++] = G_TYPE_STRING;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+
+                col_types[nr_cols++] = G_TYPE_STRING;
+        }
+
+        store = gtk_list_store_newv(nr_cols, col_types);
+
+        view = gtk_tree_view_new();
+
+        renderer = gtk_cell_renderer_text_new();
+
+        col_idx = 0;
+
+        perf_hpp__for_each_format(fmt) {
+                fmt->header(&hpp);
+
+                gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
+                                                            -1, ltrim(s),
+                                                            renderer, "markup",
+                                                            col_idx++, NULL);
+        }
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+
+                gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
+                                                            -1, se->se_header,
+                                                            renderer, "text",
+                                                            col_idx++, NULL);
+        }
+
+        gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
+
+        g_object_unref(GTK_TREE_MODEL(store));
+
+        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                GtkTreeIter iter;
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
+
+                if (h->filtered)
+                        continue;
+
+                if (percent < min_pcnt)
+                        continue;
+
+                gtk_list_store_append(store, &iter);
+
+                col_idx = 0;
+
+                perf_hpp__for_each_format(fmt) {
+                        if (fmt->color)
+                                fmt->color(&hpp, h);
+                        else
+                                fmt->entry(&hpp, h);
+
+                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
+                }
+
+                list_for_each_entry(se, &hist_entry__sort_list, list) {
+                        if (se->elide)
+                                continue;
+
+                        se->se_snprintf(h, s, ARRAY_SIZE(s),
+                                        hists__col_len(hists, se->se_width_idx));
+
+                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
+                }
+        }
+
+        gtk_container_add(GTK_CONTAINER(window), view);
+}
+
+int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
+                                  const char *help,
+                                  struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt)
+{
+        struct perf_evsel *pos;
+        GtkWidget *vbox;
+        GtkWidget *notebook;
+        GtkWidget *info_bar;
+        GtkWidget *statbar;
+        GtkWidget *window;
+
+        signal(SIGSEGV, perf_gtk__signal);
+        signal(SIGFPE,  perf_gtk__signal);
+        signal(SIGINT,  perf_gtk__signal);
+        signal(SIGQUIT, perf_gtk__signal);
+        signal(SIGTERM, perf_gtk__signal);
+
+        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+
+        gtk_window_set_title(GTK_WINDOW(window), "perf report");
+
+        g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
+
+        pgctx = perf_gtk__activate_context(window);
+        if (!pgctx)
+                return -1;
+
+        vbox = gtk_vbox_new(FALSE, 0);
+
+        notebook = gtk_notebook_new();
+
+        gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
+
+        info_bar = perf_gtk__setup_info_bar();
+        if (info_bar)
+                gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);
+
+        statbar = perf_gtk__setup_statusbar();
+        gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
+
+        gtk_container_add(GTK_CONTAINER(window), vbox);
+
+        list_for_each_entry(pos, &evlist->entries, node) {
+                struct hists *hists = &pos->hists;
+                const char *evname = perf_evsel__name(pos);
+                GtkWidget *scrolled_window;
+                GtkWidget *tab_label;
+                char buf[512];
+                size_t size = sizeof(buf);
+
+                if (symbol_conf.event_group) {
+                        if (!perf_evsel__is_group_leader(pos))
+                                continue;
+
+                        if (pos->nr_members > 1) {
+                                perf_evsel__group_desc(pos, buf, size);
+                                evname = buf;
+                        }
+                }
+
+                scrolled_window = gtk_scrolled_window_new(NULL, NULL);
+
+                gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
+                                                        GTK_POLICY_AUTOMATIC,
+                                                        GTK_POLICY_AUTOMATIC);
+
+                perf_gtk__show_hists(scrolled_window, hists, min_pcnt);
+
+                tab_label = gtk_label_new(evname);
+
+                gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
+        }
+
+        gtk_widget_show_all(window);
+
+        perf_gtk__resize_window(window);
+
+        gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
+
+        ui_helpline__push(help);
+
+        gtk_main();
+
+        perf_gtk__deactivate_context(&pgctx);
+
+        return 0;
+}
diff --git a/tools/perf/ui/helpline.c b/tools/perf/ui/helpline.c
index a49bcf3c190b..700fb3cfa1c7 100644
--- a/tools/perf/ui/helpline.c
+++ b/tools/perf/ui/helpline.c
@@ -16,9 +16,16 @@ static void nop_helpline__push(const char *msg __maybe_unused)
 {
 }
 
+static int nop_helpline__show(const char *fmt __maybe_unused,
+                               va_list ap __maybe_unused)
+{
+        return 0;
+}
+
 static struct ui_helpline default_helpline_fns = {
         .pop    = nop_helpline__pop,
         .push   = nop_helpline__push,
+        .show   = nop_helpline__show,
 };
 
 struct ui_helpline *helpline_fns = &default_helpline_fns;
@@ -59,3 +66,8 @@ void ui_helpline__puts(const char *msg)
         ui_helpline__pop();
         ui_helpline__push(msg);
 }
+
+int ui_helpline__vshow(const char *fmt, va_list ap)
+{
+        return helpline_fns->show(fmt, ap);
+}
diff --git a/tools/perf/ui/helpline.h b/tools/perf/ui/helpline.h
index baa28a4d16b9..46181f4fc07e 100644
--- a/tools/perf/ui/helpline.h
+++ b/tools/perf/ui/helpline.h
@@ -9,6 +9,7 @@
 struct ui_helpline {
         void (*pop)(void);
         void (*push)(const char *msg);
+        int  (*show)(const char *fmt, va_list ap);
 };
 
 extern struct ui_helpline *helpline_fns;
@@ -20,28 +21,9 @@ void ui_helpline__push(const char *msg);
 void ui_helpline__vpush(const char *fmt, va_list ap);
 void ui_helpline__fpush(const char *fmt, ...);
 void ui_helpline__puts(const char *msg);
+int  ui_helpline__vshow(const char *fmt, va_list ap);
 
 extern char ui_helpline__current[512];
-
-#ifdef NEWT_SUPPORT
 extern char ui_helpline__last_msg[];
-int ui_helpline__show_help(const char *format, va_list ap);
-#else
-static inline int ui_helpline__show_help(const char *format __maybe_unused,
-                                         va_list ap __maybe_unused)
-{
-        return 0;
-}
-#endif /* NEWT_SUPPORT */
-
-#ifdef GTK2_SUPPORT
-int perf_gtk__show_helpline(const char *format, va_list ap);
-#else
-static inline int perf_gtk__show_helpline(const char *format __maybe_unused,
-                                          va_list ap __maybe_unused)
-{
-        return 0;
-}
-#endif /* GTK2_SUPPORT */
 
 #endif /* _PERF_UI_HELPLINE_H_ */
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index aa84130024d5..4bf91b09d62d 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -3,151 +3,160 @@
 #include "../util/hist.h"
 #include "../util/util.h"
 #include "../util/sort.h"
-
+#include "../util/evsel.h"
 
 /* hist period print (hpp) functions */
-static int hpp__header_overhead(struct perf_hpp *hpp)
-{
-        return scnprintf(hpp->buf, hpp->size, "Overhead");
-}
-
-static int hpp__width_overhead(struct perf_hpp *hpp __maybe_unused)
-{
-        return 8;
-}
-
-static int hpp__color_overhead(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period / hists->stats.total_period;
-
-        return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent);
-}
-
-static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period / hists->stats.total_period;
-        const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%%";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, percent);
-}
-
-static int hpp__header_overhead_sys(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "sys");
-}
-
-static int hpp__width_overhead_sys(struct perf_hpp *hpp __maybe_unused)
-{
-        return 7;
-}
-
-static int hpp__color_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_sys / hists->stats.total_period;
-
-        return percent_color_snprintf(hpp->buf, hpp->size, "%6.2f%%", percent);
-}
-
-static int hpp__entry_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_sys / hists->stats.total_period;
-        const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, percent);
-}
 
-static int hpp__header_overhead_us(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "user");
-}
-
-static int hpp__width_overhead_us(struct perf_hpp *hpp __maybe_unused)
-{
-        return 7;
-}
+typedef int (*hpp_snprint_fn)(char *buf, size_t size, const char *fmt, ...);
 
-static int hpp__color_overhead_us(struct perf_hpp *hpp, struct hist_entry *he)
+static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
+                      u64 (*get_field)(struct hist_entry *),
+                      const char *fmt, hpp_snprint_fn print_fn,
+                      bool fmt_percent)
 {
+        int ret;
         struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_us / hists->stats.total_period;
+        struct perf_evsel *evsel = hists_to_evsel(hists);
 
-        return percent_color_snprintf(hpp->buf, hpp->size, "%6.2f%%", percent);
-}
+        if (fmt_percent) {
+                double percent = 0.0;
 
-static int hpp__entry_overhead_us(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_us / hists->stats.total_period;
-        const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
+                if (hists->stats.total_period)
+                        percent = 100.0 * get_field(he) /
+                                  hists->stats.total_period;
 
-        return scnprintf(hpp->buf, hpp->size, fmt, percent);
-}
+                ret = print_fn(hpp->buf, hpp->size, fmt, percent);
+        } else
+                ret = print_fn(hpp->buf, hpp->size, fmt, get_field(he));
 
-static int hpp__header_overhead_guest_sys(struct perf_hpp *hpp)
-{
-        return scnprintf(hpp->buf, hpp->size, "guest sys");
-}
+        if (perf_evsel__is_group_event(evsel)) {
+                int prev_idx, idx_delta;
+                struct hist_entry *pair;
+                int nr_members = evsel->nr_members;
 
-static int hpp__width_overhead_guest_sys(struct perf_hpp *hpp __maybe_unused)
-{
-        return 9;
-}
+                prev_idx = perf_evsel__group_idx(evsel);
 
-static int hpp__color_overhead_guest_sys(struct perf_hpp *hpp,
-                                         struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_guest_sys / hists->stats.total_period;
+                list_for_each_entry(pair, &he->pairs.head, pairs.node) {
+                        u64 period = get_field(pair);
+                        u64 total = pair->hists->stats.total_period;
 
-        return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%% ", percent);
-}
+                        if (!total)
+                                continue;
 
-static int hpp__entry_overhead_guest_sys(struct perf_hpp *hpp,
-                                         struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_guest_sys / hists->stats.total_period;
-        const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%% ";
+                        evsel = hists_to_evsel(pair->hists);
+                        idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
 
-        return scnprintf(hpp->buf, hpp->size, fmt, percent);
-}
+                        while (idx_delta--) {
+                                /*
+                                 * zero-fill group members in the middle which
+                                 * have no sample
+                                 */
+                                ret += print_fn(hpp->buf + ret, hpp->size - ret,
+                                                fmt, 0);
+                        }
 
-static int hpp__header_overhead_guest_us(struct perf_hpp *hpp)
-{
-        return scnprintf(hpp->buf, hpp->size, "guest usr");
-}
+                        if (fmt_percent)
+                                ret += print_fn(hpp->buf + ret, hpp->size - ret,
+                                                fmt, 100.0 * period / total);
+                        else
+                                ret += print_fn(hpp->buf + ret, hpp->size - ret,
+                                                fmt, period);
 
-static int hpp__width_overhead_guest_us(struct perf_hpp *hpp __maybe_unused)
-{
-        return 9;
-}
+                        prev_idx = perf_evsel__group_idx(evsel);
+                }
 
-static int hpp__color_overhead_guest_us(struct perf_hpp *hpp,
-                                        struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_guest_us / hists->stats.total_period;
+                idx_delta = nr_members - prev_idx - 1;
 
-        return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%% ", percent);
+                while (idx_delta--) {
+                        /*
+                         * zero-fill group members at last which have no sample
+                         */
+                        ret += print_fn(hpp->buf + ret, hpp->size - ret,
+                                        fmt, 0);
+                }
+        }
+        return ret;
 }
 
-static int hpp__entry_overhead_guest_us(struct perf_hpp *hpp,
-                                        struct hist_entry *he)
-{
-        struct hists *hists = he->hists;
-        double percent = 100.0 * he->stat.period_guest_us / hists->stats.total_period;
-        const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%% ";
+#define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)           \
+static int hpp__header_##_type(struct perf_hpp *hpp)                    \
+{                                                                       \
+        int len = _min_width;                                           \
+                                                                        \
+        if (symbol_conf.event_group) {                                  \
+                struct perf_evsel *evsel = hpp->ptr;                    \
+                                                                        \
+                len = max(len, evsel->nr_members * _unit_width);        \
+        }                                                               \
+        return scnprintf(hpp->buf, hpp->size, "%*s", len, _str);        \
+}
+
+#define __HPP_WIDTH_FN(_type, _min_width, _unit_width)                  \
+static int hpp__width_##_type(struct perf_hpp *hpp __maybe_unused)      \
+{                                                                       \
+        int len = _min_width;                                           \
+                                                                        \
+        if (symbol_conf.event_group) {                                  \
+                struct perf_evsel *evsel = hpp->ptr;                    \
+                                                                        \
+                len = max(len, evsel->nr_members * _unit_width);        \
+        }                                                               \
+        return len;                                                     \
+}
+
+#define __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
+static u64 he_get_##_field(struct hist_entry *he)                               \
+{                                                                               \
+        return he->stat._field;                                                 \
+}                                                                               \
+                                                                                \
+static int hpp__color_##_type(struct perf_hpp *hpp, struct hist_entry *he)      \
+{                                                                               \
+        return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%",                 \
+                          (hpp_snprint_fn)percent_color_snprintf, true);        \
+}
+
+#define __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
+static int hpp__entry_##_type(struct perf_hpp *hpp, struct hist_entry *he)      \
+{                                                                               \
+        const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%";         \
+        return __hpp__fmt(hpp, he, he_get_##_field, fmt,                        \
+                          scnprintf, true);                                     \
+}
+
+#define __HPP_ENTRY_RAW_FN(_type, _field)                                       \
+static u64 he_get_raw_##_field(struct hist_entry *he)                           \
+{                                                                               \
+        return he->stat._field;                                                 \
+}                                                                               \
+                                                                                \
+static int hpp__entry_##_type(struct perf_hpp *hpp, struct hist_entry *he)      \
+{                                                                               \
+        const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64;    \
+        return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, scnprintf, false); \
+}
+
+#define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width)   \
+__HPP_HEADER_FN(_type, _str, _min_width, _unit_width)                   \
+__HPP_WIDTH_FN(_type, _min_width, _unit_width)                          \
+__HPP_COLOR_PERCENT_FN(_type, _field)                                   \
+__HPP_ENTRY_PERCENT_FN(_type, _field)
+
+#define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width)       \
+__HPP_HEADER_FN(_type, _str, _min_width, _unit_width)                   \
+__HPP_WIDTH_FN(_type, _min_width, _unit_width)                          \
+__HPP_ENTRY_RAW_FN(_type, _field)
+
+
+HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8)
+HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8)
+HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8)
+HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8)
+HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8)
+
+HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12)
+HPP_RAW_FNS(period, "Period", period, 12, 12)
 
-        return scnprintf(hpp->buf, hpp->size, fmt, percent);
-}
 
 static int hpp__header_baseline(struct perf_hpp *hpp)
 {
@@ -179,7 +188,7 @@ static int hpp__color_baseline(struct perf_hpp *hpp, struct hist_entry *he)
 {
         double percent = baseline_percent(he);
 
-        if (hist_entry__has_pairs(he))
+        if (hist_entry__has_pairs(he) || symbol_conf.field_sep)
                 return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent);
         else
                 return scnprintf(hpp->buf, hpp->size, "        ");
@@ -196,44 +205,6 @@ static int hpp__entry_baseline(struct perf_hpp *hpp, struct hist_entry *he)
                 return scnprintf(hpp->buf, hpp->size, "            ");
 }
 
-static int hpp__header_samples(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%11s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Samples");
-}
-
-static int hpp__width_samples(struct perf_hpp *hpp __maybe_unused)
-{
-        return 11;
-}
-
-static int hpp__entry_samples(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%11" PRIu64;
-
-        return scnprintf(hpp->buf, hpp->size, fmt, he->stat.nr_events);
-}
-
-static int hpp__header_period(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%12s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Period");
-}
-
-static int hpp__width_period(struct perf_hpp *hpp __maybe_unused)
-{
-        return 12;
-}
-
-static int hpp__entry_period(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64;
-
-        return scnprintf(hpp->buf, hpp->size, fmt, he->stat.period);
-}
-
 static int hpp__header_period_baseline(struct perf_hpp *hpp)
 {
         const char *fmt = symbol_conf.field_sep ? "%s" : "%12s";
@@ -254,6 +225,7 @@ static int hpp__entry_period_baseline(struct perf_hpp *hpp, struct hist_entry *h
 
         return scnprintf(hpp->buf, hpp->size, fmt, period);
 }
+
 static int hpp__header_delta(struct perf_hpp *hpp)
 {
         const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
@@ -268,14 +240,18 @@ static int hpp__width_delta(struct perf_hpp *hpp __maybe_unused)
 
 static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he)
 {
+        struct hist_entry *pair = hist_entry__next_pair(he);
         const char *fmt = symbol_conf.field_sep ? "%s" : "%7.7s";
         char buf[32] = " ";
-        double diff;
+        double diff = 0.0;
 
-        if (he->diff.computed)
-                diff = he->diff.period_ratio_delta;
-        else
-                diff = perf_diff__compute_delta(he);
+        if (pair) {
+                if (he->diff.computed)
+                        diff = he->diff.period_ratio_delta;
+                else
+                        diff = perf_diff__compute_delta(he, pair);
+        } else
+                diff = perf_diff__period_percent(he, he->stat.period);
 
         if (fabs(diff) >= 0.01)
                 scnprintf(buf, sizeof(buf), "%+4.2F%%", diff);
@@ -297,14 +273,17 @@ static int hpp__width_ratio(struct perf_hpp *hpp __maybe_unused)
 
 static int hpp__entry_ratio(struct perf_hpp *hpp, struct hist_entry *he)
 {
+        struct hist_entry *pair = hist_entry__next_pair(he);
         const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
         char buf[32] = " ";
-        double ratio;
+        double ratio = 0.0;
 
-        if (he->diff.computed)
-                ratio = he->diff.period_ratio;
-        else
-                ratio = perf_diff__compute_ratio(he);
+        if (pair) {
+                if (he->diff.computed)
+                        ratio = he->diff.period_ratio;
+                else
+                        ratio = perf_diff__compute_ratio(he, pair);
+        }
 
         if (ratio > 0.0)
                 scnprintf(buf, sizeof(buf), "%+14.6F", ratio);
@@ -326,14 +305,17 @@ static int hpp__width_wdiff(struct perf_hpp *hpp __maybe_unused)
 
 static int hpp__entry_wdiff(struct perf_hpp *hpp, struct hist_entry *he)
 {
+        struct hist_entry *pair = hist_entry__next_pair(he);
         const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
         char buf[32] = " ";
-        s64 wdiff;
+        s64 wdiff = 0;
 
-        if (he->diff.computed)
-                wdiff = he->diff.wdiff;
-        else
-                wdiff = perf_diff__compute_wdiff(he);
+        if (pair) {
+                if (he->diff.computed)
+                        wdiff = he->diff.wdiff;
+                else
+                        wdiff = perf_diff__compute_wdiff(he, pair);
+        }
 
         if (wdiff != 0)
                 scnprintf(buf, sizeof(buf), "%14ld", wdiff);
@@ -341,30 +323,6 @@ static int hpp__entry_wdiff(struct perf_hpp *hpp, struct hist_entry *he)
         return scnprintf(hpp->buf, hpp->size, fmt, buf);
 }
 
-static int hpp__header_displ(struct perf_hpp *hpp)
-{
-        return scnprintf(hpp->buf, hpp->size, "Displ.");
-}
-
-static int hpp__width_displ(struct perf_hpp *hpp __maybe_unused)
-{
-        return 6;
-}
-
-static int hpp__entry_displ(struct perf_hpp *hpp,
-                            struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        long displacement = pair ? pair->position - he->position : 0;
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%6.6s";
-        char buf[32] = " ";
-
-        if (displacement)
-                scnprintf(buf, sizeof(buf), "%+4ld", displacement);
-
-        return scnprintf(hpp->buf, hpp->size, fmt, buf);
-}
-
 static int hpp__header_formula(struct perf_hpp *hpp)
 {
         const char *fmt = symbol_conf.field_sep ? "%s" : "%70s";
@@ -379,67 +337,91 @@ static int hpp__width_formula(struct perf_hpp *hpp __maybe_unused)
 
 static int hpp__entry_formula(struct perf_hpp *hpp, struct hist_entry *he)
 {
+        struct hist_entry *pair = hist_entry__next_pair(he);
         const char *fmt = symbol_conf.field_sep ? "%s" : "%-70s";
         char buf[96] = " ";
 
-        perf_diff__formula(buf, sizeof(buf), he);
+        if (pair)
+                perf_diff__formula(he, pair, buf, sizeof(buf));
+
         return scnprintf(hpp->buf, hpp->size, fmt, buf);
 }
 
-#define HPP__COLOR_PRINT_FNS(_name)             \
-        .header = hpp__header_ ## _name,                \
-        .width  = hpp__width_ ## _name,         \
-        .color  = hpp__color_ ## _name,         \
-        .entry  = hpp__entry_ ## _name
+#define HPP__COLOR_PRINT_FNS(_name)                     \
+        {                                               \
+                .header = hpp__header_ ## _name,        \
+                .width  = hpp__width_ ## _name,         \
+                .color  = hpp__color_ ## _name,         \
+                .entry  = hpp__entry_ ## _name          \
+        }
 
-#define HPP__PRINT_FNS(_name)                   \
-        .header = hpp__header_ ## _name,                \
-        .width  = hpp__width_ ## _name,         \
-        .entry  = hpp__entry_ ## _name
+#define HPP__PRINT_FNS(_name)                           \
+        {                                               \
+                .header = hpp__header_ ## _name,        \
+                .width  = hpp__width_ ## _name,         \
+                .entry  = hpp__entry_ ## _name          \
+        }
 
 struct perf_hpp_fmt perf_hpp__format[] = {
-        { .cond = false, HPP__COLOR_PRINT_FNS(baseline) },
-        { .cond = true,  HPP__COLOR_PRINT_FNS(overhead) },
-        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_sys) },
-        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_us) },
-        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_guest_sys) },
-        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_guest_us) },
-        { .cond = false, HPP__PRINT_FNS(samples) },
-        { .cond = false, HPP__PRINT_FNS(period) },
-        { .cond = false, HPP__PRINT_FNS(period_baseline) },
-        { .cond = false, HPP__PRINT_FNS(delta) },
-        { .cond = false, HPP__PRINT_FNS(ratio) },
-        { .cond = false, HPP__PRINT_FNS(wdiff) },
-        { .cond = false, HPP__PRINT_FNS(displ) },
-        { .cond = false, HPP__PRINT_FNS(formula) }
+        HPP__COLOR_PRINT_FNS(baseline),
+        HPP__COLOR_PRINT_FNS(overhead),
+        HPP__COLOR_PRINT_FNS(overhead_sys),
+        HPP__COLOR_PRINT_FNS(overhead_us),
+        HPP__COLOR_PRINT_FNS(overhead_guest_sys),
+        HPP__COLOR_PRINT_FNS(overhead_guest_us),
+        HPP__PRINT_FNS(samples),
+        HPP__PRINT_FNS(period),
+        HPP__PRINT_FNS(period_baseline),
+        HPP__PRINT_FNS(delta),
+        HPP__PRINT_FNS(ratio),
+        HPP__PRINT_FNS(wdiff),
+        HPP__PRINT_FNS(formula)
 };
 
+LIST_HEAD(perf_hpp__list);
+
+
 #undef HPP__COLOR_PRINT_FNS
 #undef HPP__PRINT_FNS
 
+#undef HPP_PERCENT_FNS
+#undef HPP_RAW_FNS
+
+#undef __HPP_HEADER_FN
+#undef __HPP_WIDTH_FN
+#undef __HPP_COLOR_PERCENT_FN
+#undef __HPP_ENTRY_PERCENT_FN
+#undef __HPP_ENTRY_RAW_FN
+
+
 void perf_hpp__init(void)
 {
         if (symbol_conf.show_cpu_utilization) {
-                perf_hpp__format[PERF_HPP__OVERHEAD_SYS].cond = true;
-                perf_hpp__format[PERF_HPP__OVERHEAD_US].cond = true;
+                perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
+                perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
 
                 if (perf_guest) {
-                        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].cond = true;
-                        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].cond = true;
+                        perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
+                        perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
                 }
         }
 
         if (symbol_conf.show_nr_samples)
-                perf_hpp__format[PERF_HPP__SAMPLES].cond = true;
+                perf_hpp__column_enable(PERF_HPP__SAMPLES);
 
         if (symbol_conf.show_total_period)
-                perf_hpp__format[PERF_HPP__PERIOD].cond = true;
+                perf_hpp__column_enable(PERF_HPP__PERIOD);
+}
+
+void perf_hpp__column_register(struct perf_hpp_fmt *format)
+{
+        list_add_tail(&format->list, &perf_hpp__list);
 }
 
-void perf_hpp__column_enable(unsigned col, bool enable)
+void perf_hpp__column_enable(unsigned col)
 {
         BUG_ON(col >= PERF_HPP__MAX_INDEX);
-        perf_hpp__format[col].cond = enable;
+        perf_hpp__column_register(&perf_hpp__format[col]);
 }
 
 static inline void advance_hpp(struct perf_hpp *hpp, int inc)
@@ -452,27 +434,29 @@ int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
                                 bool color)
 {
         const char *sep = symbol_conf.field_sep;
+        struct perf_hpp_fmt *fmt;
         char *start = hpp->buf;
-        int i, ret;
+        int ret;
         bool first = true;
 
         if (symbol_conf.exclude_other && !he->parent)
                 return 0;
 
-        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
-                if (!perf_hpp__format[i].cond)
-                        continue;
-
+        perf_hpp__for_each_format(fmt) {
+                /*
+                 * If there's no field_sep, we still need
+                 * to display initial '  '.
+                 */
                 if (!sep || !first) {
                         ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
                         advance_hpp(hpp, ret);
+                } else
                         first = false;
-                }
 
-                if (color && perf_hpp__format[i].color)
-                        ret = perf_hpp__format[i].color(hpp, he);
+                if (color && fmt->color)
+                        ret = fmt->color(hpp, he);
                 else
-                        ret = perf_hpp__format[i].entry(hpp, he);
+                        ret = fmt->entry(hpp, he);
 
                 advance_hpp(hpp, ret);
         }
@@ -504,16 +488,18 @@ int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size,
  */
 unsigned int hists__sort_list_width(struct hists *hists)
 {
+        struct perf_hpp_fmt *fmt;
         struct sort_entry *se;
-        int i, ret = 0;
+        int i = 0, ret = 0;
+        struct perf_hpp dummy_hpp = {
+                .ptr    = hists_to_evsel(hists),
+        };
 
-        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
-                if (!perf_hpp__format[i].cond)
-                        continue;
+        perf_hpp__for_each_format(fmt) {
                 if (i)
                         ret += 2;
 
-                ret += perf_hpp__format[i].width(NULL);
+                ret += fmt->width(&dummy_hpp);
         }
 
         list_for_each_entry(se, &hist_entry__sort_list, list)
diff --git a/tools/perf/ui/keysyms.h b/tools/perf/ui/keysyms.h
index 809eca5707fa..65092d576b4e 100644
--- a/tools/perf/ui/keysyms.h
+++ b/tools/perf/ui/keysyms.h
@@ -23,5 +23,6 @@
 #define K_TIMER  -1
 #define K_ERROR  -2
 #define K_RESIZE -3
+#define K_SWITCH_INPUT_DATA -4
 
 #endif /* _PERF_KEYSYMS_H_ */
diff --git a/tools/perf/ui/setup.c b/tools/perf/ui/setup.c
index ebb4cc107876..ae6a789cb0f6 100644
--- a/tools/perf/ui/setup.c
+++ b/tools/perf/ui/setup.c
@@ -8,7 +8,7 @@ pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 
 void setup_browser(bool fallback_to_pager)
 {
-        if (!isatty(1) || dump_trace)
+        if (use_browser < 2 && (!isatty(1) || dump_trace))
                 use_browser = 0;
 
         /* default to TUI */
@@ -30,6 +30,7 @@ void setup_browser(bool fallback_to_pager)
                 if (fallback_to_pager)
                         setup_pager();
 
+                perf_hpp__column_enable(PERF_HPP__OVERHEAD);
                 perf_hpp__init();
                 break;
         }
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index f0ee204f99bb..ae7a75432249 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -3,6 +3,7 @@
 #include "../../util/util.h"
 #include "../../util/hist.h"
 #include "../../util/sort.h"
+#include "../../util/evsel.h"
 
 
 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
@@ -333,19 +334,21 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
 }
 
 size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
-                      int max_cols, FILE *fp)
+                      int max_cols, float min_pcnt, FILE *fp)
 {
+        struct perf_hpp_fmt *fmt;
         struct sort_entry *se;
         struct rb_node *nd;
         size_t ret = 0;
         unsigned int width;
         const char *sep = symbol_conf.field_sep;
         const char *col_width = symbol_conf.col_width_list_str;
-        int idx, nr_rows = 0;
+        int nr_rows = 0;
         char bf[96];
         struct perf_hpp dummy_hpp = {
                 .buf    = bf,
                 .size   = sizeof(bf),
+                .ptr    = hists_to_evsel(hists),
         };
         bool first = true;
 
@@ -355,16 +358,14 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
                 goto print_entries;
 
         fprintf(fp, "# ");
-        for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
-                if (!perf_hpp__format[idx].cond)
-                        continue;
 
+        perf_hpp__for_each_format(fmt) {
                 if (!first)
                         fprintf(fp, "%s", sep ?: "  ");
                 else
                         first = false;
 
-                perf_hpp__format[idx].header(&dummy_hpp);
+                fmt->header(&dummy_hpp);
                 fprintf(fp, "%s", bf);
         }
 
@@ -400,18 +401,16 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
         first = true;
 
         fprintf(fp, "# ");
-        for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
-                unsigned int i;
 
-                if (!perf_hpp__format[idx].cond)
-                        continue;
+        perf_hpp__for_each_format(fmt) {
+                unsigned int i;
 
                 if (!first)
                         fprintf(fp, "%s", sep ?: "  ");
                 else
                         first = false;
 
-                width = perf_hpp__format[idx].width(&dummy_hpp);
+                width = fmt->width(&dummy_hpp);
                 for (i = 0; i < width; i++)
                         fprintf(fp, ".");
         }
@@ -441,10 +440,15 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
 print_entries:
         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
 
                 if (h->filtered)
                         continue;
 
+                if (percent < min_pcnt)
+                        continue;
+
                 ret += hist_entry__fprintf(h, max_cols, hists, fp);
 
                 if (max_rows && ++nr_rows >= max_rows)
@@ -462,7 +466,7 @@ out:
         return ret;
 }
 
-size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
+size_t events_stats__fprintf(struct events_stats *stats, FILE *fp)
 {
         int i;
         size_t ret = 0;
@@ -470,7 +474,7 @@ size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
         for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
                 const char *name;
 
-                if (hists->stats.nr_events[i] == 0)
+                if (stats->nr_events[i] == 0)
                         continue;
 
                 name = perf_event__name(i);
@@ -478,7 +482,7 @@ size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
                         continue;
 
                 ret += fprintf(fp, "%16s events: %10d\n", name,
-                               hists->stats.nr_events[i]);
+                               stats->nr_events[i]);
         }
 
         return ret;
diff --git a/tools/perf/ui/tui/helpline.c b/tools/perf/ui/tui/helpline.c
index 2884d2f41e33..1c8b9afd5d6e 100644
--- a/tools/perf/ui/tui/helpline.c
+++ b/tools/perf/ui/tui/helpline.c
@@ -8,6 +8,8 @@
 #include "../ui.h"
 #include "../libslang.h"
 
+char ui_helpline__last_msg[1024];
+
 static void tui_helpline__pop(void)
 {
 }
@@ -23,20 +25,7 @@ static void tui_helpline__push(const char *msg)
         strncpy(ui_helpline__current, msg, sz)[sz - 1] = '\0';
 }
 
-struct ui_helpline tui_helpline_fns = {
-        .pop    = tui_helpline__pop,
-        .push   = tui_helpline__push,
-};
-
-void ui_helpline__init(void)
-{
-        helpline_fns = &tui_helpline_fns;
-        ui_helpline__puts(" ");
-}
-
-char ui_helpline__last_msg[1024];
-
-int ui_helpline__show_help(const char *format, va_list ap)
+static int tui_helpline__show(const char *format, va_list ap)
 {
         int ret;
         static int backlog;
@@ -55,3 +44,15 @@ int ui_helpline__show_help(const char *format, va_list ap)
 
         return ret;
 }
+
+struct ui_helpline tui_helpline_fns = {
+        .pop    = tui_helpline__pop,
+        .push   = tui_helpline__push,
+        .show   = tui_helpline__show,
+};
+
+void ui_helpline__init(void)
+{
+        helpline_fns = &tui_helpline_fns;
+        ui_helpline__puts(" ");
+}
diff --git a/tools/perf/ui/tui/setup.c b/tools/perf/ui/tui/setup.c
index 81efa192e86c..b9401482d110 100644
--- a/tools/perf/ui/tui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -1,4 +1,3 @@
-#include <newt.h>
 #include <signal.h>
 #include <stdbool.h>
 
@@ -88,13 +87,6 @@ int ui__getch(int delay_secs)
         return SLkp_getkey();
 }
 
-static void newt_suspend(void *d __maybe_unused)
-{
-        newtSuspend();
-        raise(SIGTSTP);
-        newtResume();
-}
-
 static void ui__signal(int sig)
 {
         ui__exit(false);
@@ -106,7 +98,17 @@ int ui__init(void)
 {
         int err;
 
-        newtInit();
+        SLutf8_enable(-1);
+        SLtt_get_terminfo();
+        SLtt_get_screen_size();
+
+        err = SLsmg_init_smg();
+        if (err < 0)
+                goto out;
+        err = SLang_init_tty(0, 0, 0);
+        if (err < 0)
+                goto out;
+
         err = SLkp_init();
         if (err < 0) {
                 pr_err("TUI initialization failed.\n");
@@ -115,7 +117,6 @@ int ui__init(void)
 
         SLkp_define_keysym((char *)"^(kB)", SL_KEY_UNTAB);
 
-        newtSetSuspendCallback(newt_suspend, NULL);
         ui_helpline__init();
         ui_browser__init();
         ui_progress__init();
diff --git a/tools/perf/ui/ui.h b/tools/perf/ui/ui.h
index d86359c99907..70cb0d4eb8aa 100644
--- a/tools/perf/ui/ui.h
+++ b/tools/perf/ui/ui.h
@@ -12,7 +12,7 @@ extern int use_browser;
 void setup_browser(bool fallback_to_pager);
 void exit_browser(bool wait_for_ok);
 
-#ifdef NEWT_SUPPORT
+#ifdef SLANG_SUPPORT
 int ui__init(void);
 void ui__exit(bool wait_for_ok);
 #else
diff --git a/tools/perf/ui/util.c b/tools/perf/ui/util.c
index 4f989774c8c6..e3e0a963d03a 100644
--- a/tools/perf/ui/util.c
+++ b/tools/perf/ui/util.c
@@ -52,7 +52,6 @@ int ui__warning(const char *format, ...)
         return ret;
 }
 
-
 /**
  * perf_error__register - Register error logging functions
  * @eops: The pointer to error logging function struct
diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index 6aa34e5afdcf..055fef34b6f6 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -26,13 +26,13 @@ VN=$(expr "$VN" : v*'\(.*\)')
 
 if test -r $GVF
 then
-        VC=$(sed -e 's/^PERF_VERSION = //' <$GVF)
+        VC=$(sed -e 's/^#define PERF_VERSION "\(.*\)"/\1/' <$GVF)
 else
         VC=unset
 fi
 test "$VN" = "$VC" || {
         echo >&2 "PERF_VERSION = $VN"
-        echo "PERF_VERSION = $VN" >$GVF
+        echo "#define PERF_VERSION \"$VN\"" >$GVF
 }
 
 
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 07aaeea60000..d102716c43a1 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -14,6 +14,7 @@
 #include "symbol.h"
 #include "debug.h"
 #include "annotate.h"
+#include "evsel.h"
 #include <pthread.h>
 #include <linux/bitops.h>
 
@@ -602,8 +603,42 @@ struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disa
         return NULL;
 }
 
+double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
+                            s64 end, const char **path)
+{
+        struct source_line *src_line = notes->src->lines;
+        double percent = 0.0;
+
+        if (src_line) {
+                size_t sizeof_src_line = sizeof(*src_line) +
+                                sizeof(src_line->p) * (src_line->nr_pcnt - 1);
+
+                while (offset < end) {
+                        src_line = (void *)notes->src->lines +
+                                        (sizeof_src_line * offset);
+
+                        if (*path == NULL)
+                                *path = src_line->path;
+
+                        percent += src_line->p[evidx].percent;
+                        offset++;
+                }
+        } else {
+                struct sym_hist *h = annotation__histogram(notes, evidx);
+                unsigned int hits = 0;
+
+                while (offset < end)
+                        hits += h->addr[offset++];
+
+                if (h->sum)
+                        percent = 100.0 * hits / h->sum;
+        }
+
+        return percent;
+}
+
 static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 start,
-                      int evidx, u64 len, int min_pcnt, int printed,
+                      struct perf_evsel *evsel, u64 len, int min_pcnt, int printed,
                       int max_lines, struct disasm_line *queue)
 {
         static const char *prev_line;
@@ -611,34 +646,37 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
 
         if (dl->offset != -1) {
                 const char *path = NULL;
-                unsigned int hits = 0;
-                double percent = 0.0;
+                double percent, max_percent = 0.0;
+                double *ppercents = &percent;
+                int i, nr_percent = 1;
                 const char *color;
                 struct annotation *notes = symbol__annotation(sym);
-                struct source_line *src_line = notes->src->lines;
-                struct sym_hist *h = annotation__histogram(notes, evidx);
                 s64 offset = dl->offset;
                 const u64 addr = start + offset;
                 struct disasm_line *next;
 
                 next = disasm__get_next_ip_line(&notes->src->source, dl);
 
-                while (offset < (s64)len &&
-                       (next == NULL || offset < next->offset)) {
-                        if (src_line) {
-                                if (path == NULL)
-                                        path = src_line[offset].path;
-                                percent += src_line[offset].percent;
-                        } else
-                                hits += h->addr[offset];
-
-                        ++offset;
+                if (perf_evsel__is_group_event(evsel)) {
+                        nr_percent = evsel->nr_members;
+                        ppercents = calloc(nr_percent, sizeof(double));
+                        if (ppercents == NULL)
+                                return -1;
                 }
 
-                if (src_line == NULL && h->sum)
-                        percent = 100.0 * hits / h->sum;
+                for (i = 0; i < nr_percent; i++) {
+                        percent = disasm__calc_percent(notes,
+                                        notes->src->lines ? i : evsel->idx + i,
+                                        offset,
+                                        next ? next->offset : (s64) len,
+                                        &path);
+
+                        ppercents[i] = percent;
+                        if (percent > max_percent)
+                                max_percent = percent;
+                }
 
-                if (percent < min_pcnt)
+                if (max_percent < min_pcnt)
                         return -1;
 
                 if (max_lines && printed >= max_lines)
@@ -648,12 +686,12 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
                         list_for_each_entry_from(queue, &notes->src->source, node) {
                                 if (queue == dl)
                                         break;
-                                disasm_line__print(queue, sym, start, evidx, len,
+                                disasm_line__print(queue, sym, start, evsel, len,
                                                     0, 0, 1, NULL);
                         }
                 }
 
-                color = get_percent_color(percent);
+                color = get_percent_color(max_percent);
 
                 /*
                  * Also color the filename and line if needed, with
@@ -669,25 +707,59 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
                         }
                 }
 
-                color_fprintf(stdout, color, " %7.2f", percent);
+                for (i = 0; i < nr_percent; i++) {
+                        percent = ppercents[i];
+                        color = get_percent_color(percent);
+                        color_fprintf(stdout, color, " %7.2f", percent);
+                }
+
                 printf(" :      ");
                 color_fprintf(stdout, PERF_COLOR_MAGENTA, "  %" PRIx64 ":", addr);
                 color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", dl->line);
+
+                if (ppercents != &percent)
+                        free(ppercents);
+
         } else if (max_lines && printed >= max_lines)
                 return 1;
         else {
+                int width = 8;
+
                 if (queue)
                         return -1;
 
+                if (perf_evsel__is_group_event(evsel))
+                        width *= evsel->nr_members;
+
                 if (!*dl->line)
-                        printf("         :\n");
+                        printf(" %*s:\n", width, " ");
                 else
-                        printf("         :      %s\n", dl->line);
+                        printf(" %*s:   %s\n", width, " ", dl->line);
         }
 
         return 0;
 }
 
+/*
+ * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw)
+ * which looks like following
+ *
+ *  0000000000415500 <_init>:
+ *    415500:       sub    $0x8,%rsp
+ *    415504:       mov    0x2f5ad5(%rip),%rax        # 70afe0 <_DYNAMIC+0x2f8>
+ *    41550b:       test   %rax,%rax
+ *    41550e:       je     415515 <_init+0x15>
+ *    415510:       callq  416e70 <__gmon_start__@plt>
+ *    415515:       add    $0x8,%rsp
+ *    415519:       retq
+ *
+ * it will be parsed and saved into struct disasm_line as
+ *  <offset>       <name>  <ops.raw>
+ *
+ * The offset will be a relative offset from the start of the symbol and -1
+ * means that it's not a disassembly line so should be treated differently.
+ * The ops.raw part will be parsed further according to type of the instruction.
+ */
 static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                                       FILE *file, size_t privsize)
 {
@@ -809,7 +881,7 @@ fallback:
                 pr_err("Can't annotate %s:\n\n"
                        "No vmlinux file%s\nwas found in the path.\n\n"
                        "Please use:\n\n"
-                       "  perf buildid-cache -av vmlinux\n\n"
+                       "  perf buildid-cache -vu vmlinux\n\n"
                        "or:\n\n"
                        "  --vmlinux vmlinux\n",
                        sym->name, build_id_msg ?: "");
@@ -858,7 +930,7 @@ static void insert_source_line(struct rb_root *root, struct source_line *src_lin
         struct source_line *iter;
         struct rb_node **p = &root->rb_node;
         struct rb_node *parent = NULL;
-        int ret;
+        int i, ret;
 
         while (*p != NULL) {
                 parent = *p;
@@ -866,7 +938,8 @@ static void insert_source_line(struct rb_root *root, struct source_line *src_lin
 
                 ret = strcmp(iter->path, src_line->path);
                 if (ret == 0) {
-                        iter->percent_sum += src_line->percent;
+                        for (i = 0; i < src_line->nr_pcnt; i++)
+                                iter->p[i].percent_sum += src_line->p[i].percent;
                         return;
                 }
 
@@ -876,12 +949,26 @@ static void insert_source_line(struct rb_root *root, struct source_line *src_lin
                         p = &(*p)->rb_right;
         }
 
-        src_line->percent_sum = src_line->percent;
+        for (i = 0; i < src_line->nr_pcnt; i++)
+                src_line->p[i].percent_sum = src_line->p[i].percent;
 
         rb_link_node(&src_line->node, parent, p);
         rb_insert_color(&src_line->node, root);
 }
 
+static int cmp_source_line(struct source_line *a, struct source_line *b)
+{
+        int i;
+
+        for (i = 0; i < a->nr_pcnt; i++) {
+                if (a->p[i].percent_sum == b->p[i].percent_sum)
+                        continue;
+                return a->p[i].percent_sum > b->p[i].percent_sum;
+        }
+
+        return 0;
+}
+
 static void __resort_source_line(struct rb_root *root, struct source_line *src_line)
 {
         struct source_line *iter;
@@ -892,7 +979,7 @@ static void __resort_source_line(struct rb_root *root, struct source_line *src_l
                 parent = *p;
                 iter = rb_entry(parent, struct source_line, node);
 
-                if (src_line->percent_sum > iter->percent_sum)
+                if (cmp_source_line(src_line, iter))
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -924,32 +1011,52 @@ static void symbol__free_source_line(struct symbol *sym, int len)
 {
         struct annotation *notes = symbol__annotation(sym);
         struct source_line *src_line = notes->src->lines;
+        size_t sizeof_src_line;
         int i;
 
-        for (i = 0; i < len; i++)
-                free(src_line[i].path);
+        sizeof_src_line = sizeof(*src_line) +
+                          (sizeof(src_line->p) * (src_line->nr_pcnt - 1));
+
+        for (i = 0; i < len; i++) {
+                free(src_line->path);
+                src_line = (void *)src_line + sizeof_src_line;
+        }
 
-        free(src_line);
+        free(notes->src->lines);
         notes->src->lines = NULL;
 }
 
 /* Get the filename:line for the colored entries */
 static int symbol__get_source_line(struct symbol *sym, struct map *map,
-                                   int evidx, struct rb_root *root, int len,
+                                   struct perf_evsel *evsel,
+                                   struct rb_root *root, int len,
                                    const char *filename)
 {
         u64 start;
-        int i;
+        int i, k;
+        int evidx = evsel->idx;
         char cmd[PATH_MAX * 2];
         struct source_line *src_line;
         struct annotation *notes = symbol__annotation(sym);
         struct sym_hist *h = annotation__histogram(notes, evidx);
         struct rb_root tmp_root = RB_ROOT;
+        int nr_pcnt = 1;
+        u64 h_sum = h->sum;
+        size_t sizeof_src_line = sizeof(struct source_line);
+
+        if (perf_evsel__is_group_event(evsel)) {
+                for (i = 1; i < evsel->nr_members; i++) {
+                        h = annotation__histogram(notes, evidx + i);
+                        h_sum += h->sum;
+                }
+                nr_pcnt = evsel->nr_members;
+                sizeof_src_line += (nr_pcnt - 1) * sizeof(src_line->p);
+        }
 
-        if (!h->sum)
+        if (!h_sum)
                 return 0;
 
-        src_line = notes->src->lines = calloc(len, sizeof(struct source_line));
+        src_line = notes->src->lines = calloc(len, sizeof_src_line);
         if (!notes->src->lines)
                 return -1;
 
@@ -960,29 +1067,41 @@ static int symbol__get_source_line(struct symbol *sym, struct map *map,
                 size_t line_len;
                 u64 offset;
                 FILE *fp;
+                double percent_max = 0.0;
 
-                src_line[i].percent = 100.0 * h->addr[i] / h->sum;
-                if (src_line[i].percent <= 0.5)
-                        continue;
+                src_line->nr_pcnt = nr_pcnt;
+
+                for (k = 0; k < nr_pcnt; k++) {
+                        h = annotation__histogram(notes, evidx + k);
+                        src_line->p[k].percent = 100.0 * h->addr[i] / h->sum;
+
+                        if (src_line->p[k].percent > percent_max)
+                                percent_max = src_line->p[k].percent;
+                }
+
+                if (percent_max <= 0.5)
+                        goto next;
 
                 offset = start + i;
                 sprintf(cmd, "addr2line -e %s %016" PRIx64, filename, offset);
                 fp = popen(cmd, "r");
                 if (!fp)
-                        continue;
+                        goto next;
 
                 if (getline(&path, &line_len, fp) < 0 || !line_len)
-                        goto next;
+                        goto next_close;
 
-                src_line[i].path = malloc(sizeof(char) * line_len + 1);
-                if (!src_line[i].path)
-                        goto next;
+                src_line->path = malloc(sizeof(char) * line_len + 1);
+                if (!src_line->path)
+                        goto next_close;
 
-                strcpy(src_line[i].path, path);
-                insert_source_line(&tmp_root, &src_line[i]);
+                strcpy(src_line->path, path);
+                insert_source_line(&tmp_root, src_line);
 
-        next:
+        next_close:
                 pclose(fp);
+        next:
+                src_line = (void *)src_line + sizeof_src_line;
         }
 
         resort_source_line(root, &tmp_root);
@@ -1004,24 +1123,33 @@ static void print_summary(struct rb_root *root, const char *filename)
 
         node = rb_first(root);
         while (node) {
-                double percent;
+                double percent, percent_max = 0.0;
                 const char *color;
                 char *path;
+                int i;
 
                 src_line = rb_entry(node, struct source_line, node);
-                percent = src_line->percent_sum;
-                color = get_percent_color(percent);
+                for (i = 0; i < src_line->nr_pcnt; i++) {
+                        percent = src_line->p[i].percent_sum;
+                        color = get_percent_color(percent);
+                        color_fprintf(stdout, color, " %7.2f", percent);
+
+                        if (percent > percent_max)
+                                percent_max = percent;
+                }
+
                 path = src_line->path;
+                color = get_percent_color(percent_max);
+                color_fprintf(stdout, color, " %s", path);
 
-                color_fprintf(stdout, color, " %7.2f %s", percent, path);
                 node = rb_next(node);
         }
 }
 
-static void symbol__annotate_hits(struct symbol *sym, int evidx)
+static void symbol__annotate_hits(struct symbol *sym, struct perf_evsel *evsel)
 {
         struct annotation *notes = symbol__annotation(sym);
-        struct sym_hist *h = annotation__histogram(notes, evidx);
+        struct sym_hist *h = annotation__histogram(notes, evsel->idx);
         u64 len = symbol__size(sym), offset;
 
         for (offset = 0; offset < len; ++offset)
@@ -1031,9 +1159,9 @@ static void symbol__annotate_hits(struct symbol *sym, int evidx)
         printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->sum", h->sum);
 }
 
-int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
-                            bool full_paths, int min_pcnt, int max_lines,
-                            int context)
+int symbol__annotate_printf(struct symbol *sym, struct map *map,
+                            struct perf_evsel *evsel, bool full_paths,
+                            int min_pcnt, int max_lines, int context)
 {
         struct dso *dso = map->dso;
         char *filename;
@@ -1044,6 +1172,8 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
         int printed = 2, queue_len = 0;
         int more = 0;
         u64 len;
+        int width = 8;
+        int namelen;
 
         filename = strdup(dso->long_name);
         if (!filename)
@@ -1055,12 +1185,18 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                 d_filename = basename(filename);
 
         len = symbol__size(sym);
+        namelen = strlen(d_filename);
+
+        if (perf_evsel__is_group_event(evsel))
+                width *= evsel->nr_members;
 
-        printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
-        printf("------------------------------------------------\n");
+        printf(" %-*.*s|        Source code & Disassembly of %s\n",
+               width, width, "Percent", d_filename);
+        printf("-%-*.*s-------------------------------------\n",
+               width+namelen, width+namelen, graph_dotted_line);
 
         if (verbose)
-                symbol__annotate_hits(sym, evidx);
+                symbol__annotate_hits(sym, evsel);
 
         list_for_each_entry(pos, &notes->src->source, node) {
                 if (context && queue == NULL) {
@@ -1068,7 +1204,7 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                         queue_len = 0;
                 }
 
-                switch (disasm_line__print(pos, sym, start, evidx, len,
+                switch (disasm_line__print(pos, sym, start, evsel, len,
                                             min_pcnt, printed, max_lines,
                                             queue)) {
                 case 0:
@@ -1163,9 +1299,9 @@ size_t disasm__fprintf(struct list_head *head, FILE *fp)
         return printed;
 }
 
-int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
-                         bool print_lines, bool full_paths, int min_pcnt,
-                         int max_lines)
+int symbol__tty_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel, bool print_lines,
+                         bool full_paths, int min_pcnt, int max_lines)
 {
         struct dso *dso = map->dso;
         const char *filename = dso->long_name;
@@ -1178,12 +1314,12 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
         len = symbol__size(sym);
 
         if (print_lines) {
-                symbol__get_source_line(sym, map, evidx, &source_line,
+                symbol__get_source_line(sym, map, evsel, &source_line,
                                         len, filename);
                 print_summary(&source_line, filename);
         }
 
-        symbol__annotate_printf(sym, map, evidx, full_paths,
+        symbol__annotate_printf(sym, map, evsel, full_paths,
                                 min_pcnt, max_lines, 0);
         if (print_lines)
                 symbol__free_source_line(sym, len);
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index 8eec94358a4a..af755156d278 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -6,6 +6,7 @@
 #include "types.h"
 #include "symbol.h"
 #include "hist.h"
+#include "sort.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <pthread.h>
@@ -49,6 +50,8 @@ bool ins__is_jump(const struct ins *ins);
 bool ins__is_call(const struct ins *ins);
 int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops);
 
+struct annotation;
+
 struct disasm_line {
         struct list_head    node;
         s64                 offset;
@@ -67,17 +70,24 @@ void disasm_line__free(struct disasm_line *dl);
 struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos);
 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw);
 size_t disasm__fprintf(struct list_head *head, FILE *fp);
+double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
+                            s64 end, const char **path);
 
 struct sym_hist {
         u64             sum;
         u64             addr[0];
 };
 
-struct source_line {
-        struct rb_node  node;
+struct source_line_percent {
         double          percent;
         double          percent_sum;
+};
+
+struct source_line {
+        struct rb_node  node;
         char            *path;
+        int             nr_pcnt;
+        struct source_line_percent p[1];
 };
 
 /** struct annotated_source - symbols with hits have this attached as in sannotation
@@ -129,31 +139,56 @@ void symbol__annotate_zero_histograms(struct symbol *sym);
 
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize);
 int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym);
-int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
-                            bool full_paths, int min_pcnt, int max_lines,
-                            int context);
+int symbol__annotate_printf(struct symbol *sym, struct map *map,
+                            struct perf_evsel *evsel, bool full_paths,
+                            int min_pcnt, int max_lines, int context);
 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
 void disasm__purge(struct list_head *head);
 
-int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
-                         bool print_lines, bool full_paths, int min_pcnt,
-                         int max_lines);
+int symbol__tty_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel, bool print_lines,
+                         bool full_paths, int min_pcnt, int max_lines);
 
-#ifdef NEWT_SUPPORT
-int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
+#ifdef SLANG_SUPPORT
+int symbol__tui_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel,
                          struct hist_browser_timer *hbt);
 #else
 static inline int symbol__tui_annotate(struct symbol *sym __maybe_unused,
-                                       struct map *map __maybe_unused,
-                                       int evidx __maybe_unused,
-                                       struct hist_browser_timer *hbt
-                                       __maybe_unused)
+                                struct map *map __maybe_unused,
+                                struct perf_evsel *evsel  __maybe_unused,
+                                struct hist_browser_timer *hbt
+                                __maybe_unused)
 {
         return 0;
 }
 #endif
 
+#ifdef GTK2_SUPPORT
+int symbol__gtk_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel,
+                         struct hist_browser_timer *hbt);
+
+static inline int hist_entry__gtk_annotate(struct hist_entry *he,
+                                           struct perf_evsel *evsel,
+                                           struct hist_browser_timer *hbt)
+{
+        return symbol__gtk_annotate(he->ms.sym, he->ms.map, evsel, hbt);
+}
+
+void perf_gtk__show_annotations(void);
+#else
+static inline int hist_entry__gtk_annotate(struct hist_entry *he __maybe_unused,
+                                struct perf_evsel *evsel __maybe_unused,
+                                struct hist_browser_timer *hbt __maybe_unused)
+{
+        return 0;
+}
+
+static inline void perf_gtk__show_annotations(void) {}
+#endif
+
 extern const char       *disassembler_style;
 
 #endif  /* __PERF_ANNOTATE_H */
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index d3b3f5d82137..42b6a632fe7b 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -444,7 +444,7 @@ int callchain_cursor_append(struct callchain_cursor *cursor,
         struct callchain_cursor_node *node = *cursor->last;
 
         if (!node) {
-                node = calloc(sizeof(*node), 1);
+                node = calloc(1, sizeof(*node));
                 if (!node)
                         return -ENOMEM;
 
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index eb340571e7d6..3ee9f67d5af0 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -143,4 +143,9 @@ static inline void callchain_cursor_advance(struct callchain_cursor *cursor)
         cursor->curr = cursor->curr->next;
         cursor->pos++;
 }
+
+struct option;
+
+int record_parse_callchain_opt(const struct option *opt, const char *arg, int unset);
+extern const char record_callchain_help[];
 #endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index 2b32ffa9ebdb..beb8cf9f9976 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -1,8 +1,10 @@
 #include "util.h"
+#include "sysfs.h"
 #include "../perf.h"
 #include "cpumap.h"
 #include <assert.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 static struct cpu_map *cpu_map__default_new(void)
 {
@@ -201,3 +203,117 @@ void cpu_map__delete(struct cpu_map *map)
 {
         free(map);
 }
+
+int cpu_map__get_socket(struct cpu_map *map, int idx)
+{
+        FILE *fp;
+        const char *mnt;
+        char path[PATH_MAX];
+        int cpu, ret;
+
+        if (idx > map->nr)
+                return -1;
+
+        cpu = map->map[idx];
+
+        mnt = sysfs_find_mountpoint();
+        if (!mnt)
+                return -1;
+
+        snprintf(path, PATH_MAX,
+                "%s/devices/system/cpu/cpu%d/topology/physical_package_id",
+                mnt, cpu);
+
+        fp = fopen(path, "r");
+        if (!fp)
+                return -1;
+        ret = fscanf(fp, "%d", &cpu);
+        fclose(fp);
+        return ret == 1 ? cpu : -1;
+}
+
+static int cmp_ids(const void *a, const void *b)
+{
+        return *(int *)a - *(int *)b;
+}
+
+static int cpu_map__build_map(struct cpu_map *cpus, struct cpu_map **res,
+                              int (*f)(struct cpu_map *map, int cpu))
+{
+        struct cpu_map *c;
+        int nr = cpus->nr;
+        int cpu, s1, s2;
+
+        /* allocate as much as possible */
+        c = calloc(1, sizeof(*c) + nr * sizeof(int));
+        if (!c)
+                return -1;
+
+        for (cpu = 0; cpu < nr; cpu++) {
+                s1 = f(cpus, cpu);
+                for (s2 = 0; s2 < c->nr; s2++) {
+                        if (s1 == c->map[s2])
+                                break;
+                }
+                if (s2 == c->nr) {
+                        c->map[c->nr] = s1;
+                        c->nr++;
+                }
+        }
+        /* ensure we process id in increasing order */
+        qsort(c->map, c->nr, sizeof(int), cmp_ids);
+
+        *res = c;
+        return 0;
+}
+
+int cpu_map__get_core(struct cpu_map *map, int idx)
+{
+        FILE *fp;
+        const char *mnt;
+        char path[PATH_MAX];
+        int cpu, ret, s;
+
+        if (idx > map->nr)
+                return -1;
+
+        cpu = map->map[idx];
+
+        mnt = sysfs_find_mountpoint();
+        if (!mnt)
+                return -1;
+
+        snprintf(path, PATH_MAX,
+                "%s/devices/system/cpu/cpu%d/topology/core_id",
+                mnt, cpu);
+
+        fp = fopen(path, "r");
+        if (!fp)
+                return -1;
+        ret = fscanf(fp, "%d", &cpu);
+        fclose(fp);
+        if (ret != 1)
+                return -1;
+
+        s = cpu_map__get_socket(map, idx);
+        if (s == -1)
+                return -1;
+
+        /*
+         * encode socket in upper 16 bits
+         * core_id is relative to socket, and
+         * we need a global id. So we combine
+         * socket+ core id
+         */
+        return (s << 16) | (cpu & 0xffff);
+}
+
+int cpu_map__build_socket_map(struct cpu_map *cpus, struct cpu_map **sockp)
+{
+        return cpu_map__build_map(cpus, sockp, cpu_map__get_socket);
+}
+
+int cpu_map__build_core_map(struct cpu_map *cpus, struct cpu_map **corep)
+{
+        return cpu_map__build_map(cpus, corep, cpu_map__get_core);
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 2f68a3b8c285..9bed02e5fb3d 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -14,6 +14,27 @@ struct cpu_map *cpu_map__dummy_new(void);
 void cpu_map__delete(struct cpu_map *map);
 struct cpu_map *cpu_map__read(FILE *file);
 size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp);
+int cpu_map__get_socket(struct cpu_map *map, int idx);
+int cpu_map__get_core(struct cpu_map *map, int idx);
+int cpu_map__build_socket_map(struct cpu_map *cpus, struct cpu_map **sockp);
+int cpu_map__build_core_map(struct cpu_map *cpus, struct cpu_map **corep);
+
+static inline int cpu_map__socket(struct cpu_map *sock, int s)
+{
+        if (!sock || s > sock->nr || s < 0)
+                return 0;
+        return sock->map[s];
+}
+
+static inline int cpu_map__id_to_socket(int id)
+{
+        return id >> 16;
+}
+
+static inline int cpu_map__id_to_cpu(int id)
+{
+        return id & 0xffff;
+}
 
 static inline int cpu_map__nr(const struct cpu_map *map)
 {
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 03f830b48148..399e74c34c1a 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -23,10 +23,8 @@ int eprintf(int level, const char *fmt, ...)
 
         if (verbose >= level) {
                 va_start(args, fmt);
-                if (use_browser == 1)
-                        ret = ui_helpline__show_help(fmt, args);
-                else if (use_browser == 2)
-                        ret = perf_gtk__show_helpline(fmt, args);
+                if (use_browser >= 1)
+                        ui_helpline__vshow(fmt, args);
                 else
                         ret = vfprintf(stderr, fmt, args);
                 va_end(args);
@@ -49,28 +47,6 @@ int dump_printf(const char *fmt, ...)
         return ret;
 }
 
-#if !defined(NEWT_SUPPORT) && !defined(GTK2_SUPPORT)
-int ui__warning(const char *format, ...)
-{
-        va_list args;
-
-        va_start(args, format);
-        vfprintf(stderr, format, args);
-        va_end(args);
-        return 0;
-}
-#endif
-
-int ui__error_paranoid(void)
-{
-        return ui__error("Permission error - are you root?\n"
-                    "Consider tweaking /proc/sys/kernel/perf_event_paranoid:\n"
-                    " -1 - Not paranoid at all\n"
-                    "  0 - Disallow raw tracepoint access for unpriv\n"
-                    "  1 - Disallow cpu events for unpriv\n"
-                    "  2 - Disallow kernel profiling for unpriv\n");
-}
-
 void trace_event(union perf_event *event)
 {
         unsigned char *raw_event = (void *)event;
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 83e8d234af6b..efbd98805ad0 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -5,6 +5,8 @@
 #include <stdbool.h>
 #include "event.h"
 #include "../ui/helpline.h"
+#include "../ui/progress.h"
+#include "../ui/util.h"
 
 extern int verbose;
 extern bool quiet, dump_trace;
@@ -12,39 +14,7 @@ extern bool quiet, dump_trace;
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(union perf_event *event);
 
-struct ui_progress;
-struct perf_error_ops;
-
-#if defined(NEWT_SUPPORT) || defined(GTK2_SUPPORT)
-
-#include "../ui/progress.h"
 int ui__error(const char *format, ...) __attribute__((format(printf, 1, 2)));
-#include "../ui/util.h"
-
-#else
-
-static inline void ui_progress__update(u64 curr __maybe_unused,
-                                       u64 total __maybe_unused,
-                                       const char *title __maybe_unused) {}
-static inline void ui_progress__finish(void) {}
-
-#define ui__error(format, arg...) ui__warning(format, ##arg)
-
-static inline int
-perf_error__register(struct perf_error_ops *eops __maybe_unused)
-{
-        return 0;
-}
-
-static inline int
-perf_error__unregister(struct perf_error_ops *eops __maybe_unused)
-{
-        return 0;
-}
-
-#endif /* NEWT_SUPPORT || GTK2_SUPPORT */
-
 int ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));
-int ui__error_paranoid(void);
 
 #endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
deleted file mode 100644
index dd8b19319c03..000000000000
--- a/tools/perf/util/debugfs.c
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "util.h"
-#include "debugfs.h"
-#include "cache.h"
-
-#include <linux/kernel.h>
-#include <sys/mount.h>
-
-static int debugfs_premounted;
-char debugfs_mountpoint[PATH_MAX + 1] = "/sys/kernel/debug";
-char tracing_events_path[PATH_MAX + 1] = "/sys/kernel/debug/tracing/events";
-
-static const char *debugfs_known_mountpoints[] = {
-        "/sys/kernel/debug/",
-        "/debug/",
-        0,
-};
-
-static int debugfs_found;
-
-/* find the path to the mounted debugfs */
-const char *debugfs_find_mountpoint(void)
-{
-        const char **ptr;
-        char type[100];
-        FILE *fp;
-
-        if (debugfs_found)
-                return (const char *) debugfs_mountpoint;
-
-        ptr = debugfs_known_mountpoints;
-        while (*ptr) {
-                if (debugfs_valid_mountpoint(*ptr) == 0) {
-                        debugfs_found = 1;
-                        strcpy(debugfs_mountpoint, *ptr);
-                        return debugfs_mountpoint;
-                }
-                ptr++;
-        }
-
-        /* give up and parse /proc/mounts */
-        fp = fopen("/proc/mounts", "r");
-        if (fp == NULL)
-                return NULL;
-
-        while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
-                      debugfs_mountpoint, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-
-        if (strcmp(type, "debugfs") != 0)
-                return NULL;
-
-        debugfs_found = 1;
-
-        return debugfs_mountpoint;
-}
-
-/* verify that a mountpoint is actually a debugfs instance */
-
-int debugfs_valid_mountpoint(const char *debugfs)
-{
-        struct statfs st_fs;
-
-        if (statfs(debugfs, &st_fs) < 0)
-                return -ENOENT;
-        else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
-                return -ENOENT;
-
-        return 0;
-}
-
-static void debugfs_set_tracing_events_path(const char *mountpoint)
-{
-        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
-                 mountpoint, "tracing/events");
-}
-
-/* mount the debugfs somewhere if it's not mounted */
-
-char *debugfs_mount(const char *mountpoint)
-{
-        /* see if it's already mounted */
-        if (debugfs_find_mountpoint()) {
-                debugfs_premounted = 1;
-                goto out;
-        }
-
-        /* if not mounted and no argument */
-        if (mountpoint == NULL) {
-                /* see if environment variable set */
-                mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
-                /* if no environment variable, use default */
-                if (mountpoint == NULL)
-                        mountpoint = "/sys/kernel/debug";
-        }
-
-        if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
-                return NULL;
-
-        /* save the mountpoint */
-        debugfs_found = 1;
-        strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
-out:
-        debugfs_set_tracing_events_path(debugfs_mountpoint);
-        return debugfs_mountpoint;
-}
-
-void debugfs_set_path(const char *mountpoint)
-{
-        snprintf(debugfs_mountpoint, sizeof(debugfs_mountpoint), "%s", mountpoint);
-        debugfs_set_tracing_events_path(mountpoint);
-}
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
deleted file mode 100644
index 68f3e87ec57f..000000000000
--- a/tools/perf/util/debugfs.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef __DEBUGFS_H__
-#define __DEBUGFS_H__
-
-const char *debugfs_find_mountpoint(void);
-int debugfs_valid_mountpoint(const char *debugfs);
-char *debugfs_mount(const char *mountpoint);
-void debugfs_set_path(const char *mountpoint);
-
-extern char debugfs_mountpoint[];
-extern char tracing_events_path[];
-
-#endif /* __DEBUGFS_H__ */
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index d6d9a465acdb..6f7d5a9d6b05 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -539,13 +539,13 @@ struct dso *__dsos__findnew(struct list_head *head, const char *name)
 }
 
 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
-                               bool with_hits)
+                               bool (skip)(struct dso *dso, int parm), int parm)
 {
         struct dso *pos;
         size_t ret = 0;
 
         list_for_each_entry(pos, head, node) {
-                if (with_hits && !pos->hit)
+                if (skip && skip(pos, parm))
                         continue;
                 ret += dso__fprintf_buildid(pos, fp);
                 ret += fprintf(fp, " %s\n", pos->long_name);
@@ -583,7 +583,7 @@ size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
         if (dso->short_name != dso->long_name)
                 ret += fprintf(fp, "%s, ", dso->long_name);
         ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
-                       dso->loaded ? "" : "NOT ");
+                       dso__loaded(dso, type) ? "" : "NOT ");
         ret += dso__fprintf_buildid(dso, fp);
         ret += fprintf(fp, ")\n");
         for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index e03276940b99..450199ab51b5 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -138,7 +138,7 @@ struct dso *__dsos__findnew(struct list_head *head, const char *name);
 bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
 
 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
-                               bool with_hits);
+                               bool (skip)(struct dso *dso, int parm), int parm);
 size_t __dsos__fprintf(struct list_head *head, FILE *fp);
 
 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp);
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 3cf2c3e0605f..5cd13d768cec 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -476,8 +476,10 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
                 }
         }
 
-        if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
+        if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0) {
+                free(event);
                 return -ENOENT;
+        }
 
         map = machine->vmlinux_maps[MAP__FUNCTION];
         size = snprintf(event->mmap.filename, sizeof(event->mmap.filename),
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 0d573ff4771a..181389535c0c 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -88,8 +88,10 @@ struct perf_sample {
         u64 id;
         u64 stream_id;
         u64 period;
+        u64 weight;
         u32 cpu;
         u32 raw_size;
+        u64 data_src;
         void *raw_data;
         struct ip_callchain *callchain;
         struct branch_stack *branch_stack;
@@ -97,6 +99,13 @@ struct perf_sample {
         struct stack_dump user_stack;
 };
 
+#define PERF_MEM_DATA_SRC_NONE \
+        (PERF_MEM_S(OP, NA) |\
+         PERF_MEM_S(LVL, NA) |\
+         PERF_MEM_S(SNOOP, NA) |\
+         PERF_MEM_S(LOCK, NA) |\
+         PERF_MEM_S(TLB, NA))
+
 struct build_id_event {
         struct perf_event_header header;
         pid_t                    pid;
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 705293489e3c..99b43dd18c57 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -7,7 +7,7 @@
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "util.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
@@ -38,21 +38,26 @@ void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
         evlist->workload.pid = -1;
 }
 
-struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
-                                     struct thread_map *threads)
+struct perf_evlist *perf_evlist__new(void)
 {
         struct perf_evlist *evlist = zalloc(sizeof(*evlist));
 
         if (evlist != NULL)
-                perf_evlist__init(evlist, cpus, threads);
+                perf_evlist__init(evlist, NULL, NULL);
 
         return evlist;
 }
 
-void perf_evlist__config_attrs(struct perf_evlist *evlist,
-                               struct perf_record_opts *opts)
+void perf_evlist__config(struct perf_evlist *evlist,
+                        struct perf_record_opts *opts)
 {
         struct perf_evsel *evsel;
+        /*
+         * Set the evsel leader links before we configure attributes,
+         * since some might depend on this info.
+         */
+        if (opts->group)
+                perf_evlist__set_leader(evlist);
 
         if (evlist->cpus->map[0] < 0)
                 opts->no_inherit = true;
@@ -61,7 +66,7 @@ void perf_evlist__config_attrs(struct perf_evlist *evlist,
                 perf_evsel__config(evsel, opts);
 
                 if (evlist->nr_entries > 1)
-                        evsel->attr.sample_type |= PERF_SAMPLE_ID;
+                        perf_evsel__set_sample_id(evsel);
         }
 }
 
@@ -111,18 +116,21 @@ void __perf_evlist__set_leader(struct list_head *list)
         struct perf_evsel *evsel, *leader;
 
         leader = list_entry(list->next, struct perf_evsel, node);
-        leader->leader = NULL;
+        evsel = list_entry(list->prev, struct perf_evsel, node);
+
+        leader->nr_members = evsel->idx - leader->idx + 1;
 
         list_for_each_entry(evsel, list, node) {
-                if (evsel != leader)
-                        evsel->leader = leader;
+                evsel->leader = leader;
         }
 }
 
 void perf_evlist__set_leader(struct perf_evlist *evlist)
 {
-        if (evlist->nr_entries)
+        if (evlist->nr_entries) {
+                evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
                 __perf_evlist__set_leader(&evlist->entries);
+        }
 }
 
 int perf_evlist__add_default(struct perf_evlist *evlist)
@@ -219,12 +227,14 @@ void perf_evlist__disable(struct perf_evlist *evlist)
 {
         int cpu, thread;
         struct perf_evsel *pos;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
-                        if (perf_evsel__is_group_member(pos))
+                        if (!perf_evsel__is_group_leader(pos))
                                 continue;
-                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                        for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
                                       PERF_EVENT_IOC_DISABLE, 0);
                 }
@@ -235,12 +245,14 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 {
         int cpu, thread;
         struct perf_evsel *pos;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (cpu = 0; cpu < cpu_map__nr(evlist->cpus); cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
-                        if (perf_evsel__is_group_member(pos))
+                        if (!perf_evsel__is_group_leader(pos))
                                 continue;
-                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                        for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
                                       PERF_EVENT_IOC_ENABLE, 0);
                 }
@@ -249,7 +261,9 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 
 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
-        int nfds = cpu_map__nr(evlist->cpus) * evlist->threads->nr * evlist->nr_entries;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
+        int nfds = nr_cpus * nr_threads * evlist->nr_entries;
         evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
         return evlist->pollfd != NULL ? 0 : -ENOMEM;
 }
@@ -305,7 +319,6 @@ static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
 {
         struct hlist_head *head;
-        struct hlist_node *pos;
         struct perf_sample_id *sid;
         int hash;
 
@@ -315,7 +328,7 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
         head = &evlist->heads[hash];
 
-        hlist_for_each_entry(sid, pos, head, node)
+        hlist_for_each_entry(sid, head, node)
                 if (sid->id == id)
                         return sid->evsel;
 
@@ -366,7 +379,7 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
                 if ((old & md->mask) + size != ((old + size) & md->mask)) {
                         unsigned int offset = old;
                         unsigned int len = min(sizeof(*event), size), cpy;
-                        void *dst = &evlist->event_copy;
+                        void *dst = &md->event_copy;
 
                         do {
                                 cpy = min(md->mask + 1 - (offset & md->mask), len);
@@ -376,7 +389,7 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
                                 len -= cpy;
                         } while (len);
 
-                        event = &evlist->event_copy;
+                        event = &md->event_copy;
                 }
 
                 old += size;
@@ -409,7 +422,7 @@ static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
         evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
         if (cpu_map__all(evlist->cpus))
-                evlist->nr_mmaps = evlist->threads->nr;
+                evlist->nr_mmaps = thread_map__nr(evlist->threads);
         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
         return evlist->mmap != NULL ? 0 : -ENOMEM;
 }
@@ -434,11 +447,13 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
 {
         struct perf_evsel *evsel;
         int cpu, thread;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 int output = -1;
 
-                for (thread = 0; thread < evlist->threads->nr; thread++) {
+                for (thread = 0; thread < nr_threads; thread++) {
                         list_for_each_entry(evsel, &evlist->entries, node) {
                                 int fd = FD(evsel, cpu, thread);
 
@@ -462,7 +477,7 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
         return 0;
 
 out_unmap:
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 if (evlist->mmap[cpu].base != NULL) {
                         munmap(evlist->mmap[cpu].base, evlist->mmap_len);
                         evlist->mmap[cpu].base = NULL;
@@ -475,8 +490,9 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
 {
         struct perf_evsel *evsel;
         int thread;
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (thread = 0; thread < evlist->threads->nr; thread++) {
+        for (thread = 0; thread < nr_threads; thread++) {
                 int output = -1;
 
                 list_for_each_entry(evsel, &evlist->entries, node) {
@@ -501,7 +517,7 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
         return 0;
 
 out_unmap:
-        for (thread = 0; thread < evlist->threads->nr; thread++) {
+        for (thread = 0; thread < nr_threads; thread++) {
                 if (evlist->mmap[thread].base != NULL) {
                         munmap(evlist->mmap[thread].base, evlist->mmap_len);
                         evlist->mmap[thread].base = NULL;
@@ -602,7 +618,7 @@ int perf_evlist__apply_filters(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
         int err = 0;
         const int ncpus = cpu_map__nr(evlist->cpus),
-                  nthreads = evlist->threads->nr;
+                  nthreads = thread_map__nr(evlist->threads);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 if (evsel->filter == NULL)
@@ -621,7 +637,7 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
         struct perf_evsel *evsel;
         int err = 0;
         const int ncpus = cpu_map__nr(evlist->cpus),
-                  nthreads = evlist->threads->nr;
+                  nthreads = thread_map__nr(evlist->threads);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
@@ -704,10 +720,20 @@ void perf_evlist__set_selected(struct perf_evlist *evlist,
         evlist->selected = evsel;
 }
 
+void perf_evlist__close(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+        int ncpus = cpu_map__nr(evlist->cpus);
+        int nthreads = thread_map__nr(evlist->threads);
+
+        list_for_each_entry_reverse(evsel, &evlist->entries, node)
+                perf_evsel__close(evsel, ncpus, nthreads);
+}
+
 int perf_evlist__open(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
-        int err, ncpus, nthreads;
+        int err;
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
@@ -717,19 +743,15 @@ int perf_evlist__open(struct perf_evlist *evlist)
 
         return 0;
 out_err:
-        ncpus = evlist->cpus ? evlist->cpus->nr : 1;
-        nthreads = evlist->threads ? evlist->threads->nr : 1;
-
-        list_for_each_entry_reverse(evsel, &evlist->entries, node)
-                perf_evsel__close(evsel, ncpus, nthreads);
-
+        perf_evlist__close(evlist);
         errno = -err;
         return err;
 }
 
 int perf_evlist__prepare_workload(struct perf_evlist *evlist,
-                                  struct perf_record_opts *opts,
-                                  const char *argv[])
+                                  struct perf_target *target,
+                                  const char *argv[], bool pipe_output,
+                                  bool want_signal)
 {
         int child_ready_pipe[2], go_pipe[2];
         char bf;
@@ -751,9 +773,11 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
         }
 
         if (!evlist->workload.pid) {
-                if (opts->pipe_output)
+                if (pipe_output)
                         dup2(2, 1);
 
+                signal(SIGTERM, SIG_DFL);
+
                 close(child_ready_pipe[0]);
                 close(go_pipe[1]);
                 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
@@ -779,11 +803,12 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
                 execvp(argv[0], (char **)argv);
 
                 perror(argv[0]);
-                kill(getppid(), SIGUSR1);
+                if (want_signal)
+                        kill(getppid(), SIGUSR1);
                 exit(-1);
         }
 
-        if (perf_target__none(&opts->target))
+        if (perf_target__none(target))
                 evlist->threads->map[0] = evlist->workload.pid;
 
         close(child_ready_pipe[1]);
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 56003f779e60..0583d36252be 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -17,10 +17,18 @@ struct perf_record_opts;
 #define PERF_EVLIST__HLIST_BITS 8
 #define PERF_EVLIST__HLIST_SIZE (1 << PERF_EVLIST__HLIST_BITS)
 
+struct perf_mmap {
+        void             *base;
+        int              mask;
+        unsigned int     prev;
+        union perf_event event_copy;
+};
+
 struct perf_evlist {
         struct list_head entries;
         struct hlist_head heads[PERF_EVLIST__HLIST_SIZE];
         int              nr_entries;
+        int              nr_groups;
         int              nr_fds;
         int              nr_mmaps;
         int              mmap_len;
@@ -29,7 +37,6 @@ struct perf_evlist {
                 pid_t   pid;
         } workload;
         bool             overwrite;
-        union perf_event event_copy;
         struct perf_mmap *mmap;
         struct pollfd    *pollfd;
         struct thread_map *threads;
@@ -42,8 +49,7 @@ struct perf_evsel_str_handler {
         void       *handler;
 };
 
-struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
-                                     struct thread_map *threads);
+struct perf_evlist *perf_evlist__new(void);
 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
                        struct thread_map *threads);
 void perf_evlist__exit(struct perf_evlist *evlist);
@@ -75,13 +81,15 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 
 int perf_evlist__open(struct perf_evlist *evlist);
+void perf_evlist__close(struct perf_evlist *evlist);
 
-void perf_evlist__config_attrs(struct perf_evlist *evlist,
-                               struct perf_record_opts *opts);
+void perf_evlist__config(struct perf_evlist *evlist,
+                         struct perf_record_opts *opts);
 
 int perf_evlist__prepare_workload(struct perf_evlist *evlist,
-                                  struct perf_record_opts *opts,
-                                  const char *argv[]);
+                                  struct perf_target *target,
+                                  const char *argv[], bool pipe_output,
+                                  bool want_signal);
 int perf_evlist__start_workload(struct perf_evlist *evlist);
 
 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
@@ -135,4 +143,25 @@ static inline struct perf_evsel *perf_evlist__last(struct perf_evlist *evlist)
 }
 
 size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp);
+
+static inline unsigned int perf_mmap__read_head(struct perf_mmap *mm)
+{
+        struct perf_event_mmap_page *pc = mm->base;
+        int head = pc->data_head;
+        rmb();
+        return head;
+}
+
+static inline void perf_mmap__write_tail(struct perf_mmap *md,
+                                         unsigned long tail)
+{
+        struct perf_event_mmap_page *pc = md->base;
+
+        /*
+         * ensure all reads are done before we write the tail out.
+         */
+        /* mb(); */
+        pc->data_tail = tail;
+}
+
 #endif /* __PERF_EVLIST_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 1b16dd1edc8e..63b6f8c8edf2 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -10,7 +10,7 @@
 #include <byteswap.h>
 #include <linux/bitops.h>
 #include "asm/bug.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "event-parse.h"
 #include "evsel.h"
 #include "evlist.h"
@@ -22,6 +22,11 @@
 #include <linux/perf_event.h>
 #include "perf_regs.h"
 
+static struct {
+        bool sample_id_all;
+        bool exclude_guest;
+} perf_missing_features;
+
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 
 static int __perf_evsel__sample_size(u64 sample_type)
@@ -50,11 +55,36 @@ void hists__init(struct hists *hists)
         pthread_mutex_init(&hists->lock, NULL);
 }
 
+void __perf_evsel__set_sample_bit(struct perf_evsel *evsel,
+                                  enum perf_event_sample_format bit)
+{
+        if (!(evsel->attr.sample_type & bit)) {
+                evsel->attr.sample_type |= bit;
+                evsel->sample_size += sizeof(u64);
+        }
+}
+
+void __perf_evsel__reset_sample_bit(struct perf_evsel *evsel,
+                                    enum perf_event_sample_format bit)
+{
+        if (evsel->attr.sample_type & bit) {
+                evsel->attr.sample_type &= ~bit;
+                evsel->sample_size -= sizeof(u64);
+        }
+}
+
+void perf_evsel__set_sample_id(struct perf_evsel *evsel)
+{
+        perf_evsel__set_sample_bit(evsel, ID);
+        evsel->attr.read_format |= PERF_FORMAT_ID;
+}
+
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx)
 {
         evsel->idx         = idx;
         evsel->attr        = *attr;
+        evsel->leader      = evsel;
         INIT_LIST_HEAD(&evsel->node);
         hists__init(&evsel->hists);
         evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
@@ -404,6 +434,31 @@ const char *perf_evsel__name(struct perf_evsel *evsel)
         return evsel->name ?: "unknown";
 }
 
+const char *perf_evsel__group_name(struct perf_evsel *evsel)
+{
+        return evsel->group_name ?: "anon group";
+}
+
+int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size)
+{
+        int ret;
+        struct perf_evsel *pos;
+        const char *group_name = perf_evsel__group_name(evsel);
+
+        ret = scnprintf(buf, size, "%s", group_name);
+
+        ret += scnprintf(buf + ret, size - ret, " { %s",
+                         perf_evsel__name(evsel));
+
+        for_each_group_member(pos, evsel)
+                ret += scnprintf(buf + ret, size - ret, ", %s",
+                                 perf_evsel__name(pos));
+
+        ret += scnprintf(buf + ret, size - ret, " }");
+
+        return ret;
+}
+
 /*
  * The enable_on_exec/disabled value strategy:
  *
@@ -438,13 +493,11 @@ void perf_evsel__config(struct perf_evsel *evsel,
         struct perf_event_attr *attr = &evsel->attr;
         int track = !evsel->idx; /* only the first counter needs these */
 
-        attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
+        attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1;
         attr->inherit       = !opts->no_inherit;
-        attr->read_format   = PERF_FORMAT_TOTAL_TIME_ENABLED |
-                              PERF_FORMAT_TOTAL_TIME_RUNNING |
-                              PERF_FORMAT_ID;
 
-        attr->sample_type  |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
+        perf_evsel__set_sample_bit(evsel, IP);
+        perf_evsel__set_sample_bit(evsel, TID);
 
         /*
          * We default some events to a 1 default interval. But keep
@@ -453,7 +506,7 @@ void perf_evsel__config(struct perf_evsel *evsel,
         if (!attr->sample_period || (opts->user_freq != UINT_MAX &&
                                      opts->user_interval != ULLONG_MAX)) {
                 if (opts->freq) {
-                        attr->sample_type       |= PERF_SAMPLE_PERIOD;
+                        perf_evsel__set_sample_bit(evsel, PERIOD);
                         attr->freq              = 1;
                         attr->sample_freq       = opts->freq;
                 } else {
@@ -468,16 +521,16 @@ void perf_evsel__config(struct perf_evsel *evsel,
                 attr->inherit_stat = 1;
 
         if (opts->sample_address) {
-                attr->sample_type       |= PERF_SAMPLE_ADDR;
+                perf_evsel__set_sample_bit(evsel, ADDR);
                 attr->mmap_data = track;
         }
 
         if (opts->call_graph) {
-                attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
+                perf_evsel__set_sample_bit(evsel, CALLCHAIN);
 
                 if (opts->call_graph == CALLCHAIN_DWARF) {
-                        attr->sample_type |= PERF_SAMPLE_REGS_USER |
-                                             PERF_SAMPLE_STACK_USER;
+                        perf_evsel__set_sample_bit(evsel, REGS_USER);
+                        perf_evsel__set_sample_bit(evsel, STACK_USER);
                         attr->sample_regs_user = PERF_REGS_MASK;
                         attr->sample_stack_user = opts->stack_dump_size;
                         attr->exclude_callchain_user = 1;
@@ -485,31 +538,37 @@ void perf_evsel__config(struct perf_evsel *evsel,
         }
 
         if (perf_target__has_cpu(&opts->target))
-                attr->sample_type       |= PERF_SAMPLE_CPU;
+                perf_evsel__set_sample_bit(evsel, CPU);
 
         if (opts->period)
-                attr->sample_type       |= PERF_SAMPLE_PERIOD;
+                perf_evsel__set_sample_bit(evsel, PERIOD);
 
-        if (!opts->sample_id_all_missing &&
+        if (!perf_missing_features.sample_id_all &&
             (opts->sample_time || !opts->no_inherit ||
              perf_target__has_cpu(&opts->target)))
-                attr->sample_type       |= PERF_SAMPLE_TIME;
+                perf_evsel__set_sample_bit(evsel, TIME);
 
         if (opts->raw_samples) {
-                attr->sample_type       |= PERF_SAMPLE_TIME;
-                attr->sample_type       |= PERF_SAMPLE_RAW;
-                attr->sample_type       |= PERF_SAMPLE_CPU;
+                perf_evsel__set_sample_bit(evsel, TIME);
+                perf_evsel__set_sample_bit(evsel, RAW);
+                perf_evsel__set_sample_bit(evsel, CPU);
         }
 
+        if (opts->sample_address)
+                attr->sample_type       |= PERF_SAMPLE_DATA_SRC;
+
         if (opts->no_delay) {
                 attr->watermark = 0;
                 attr->wakeup_events = 1;
         }
         if (opts->branch_stack) {
-                attr->sample_type       |= PERF_SAMPLE_BRANCH_STACK;
+                perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
                 attr->branch_sample_type = opts->branch_stack;
         }
 
+        if (opts->sample_weight)
+                attr->sample_type       |= PERF_SAMPLE_WEIGHT;
+
         attr->mmap = track;
         attr->comm = track;
 
@@ -519,14 +578,14 @@ void perf_evsel__config(struct perf_evsel *evsel,
          * Disabling only independent events or group leaders,
          * keeping group members enabled.
          */
-        if (!perf_evsel__is_group_member(evsel))
+        if (perf_evsel__is_group_leader(evsel))
                 attr->disabled = 1;
 
         /*
          * Setting enable_on_exec for independent events and
          * group leaders for traced executed by perf.
          */
-        if (perf_target__none(&opts->target) && !perf_evsel__is_group_member(evsel))
+        if (perf_target__none(&opts->target) && perf_evsel__is_group_leader(evsel))
                 attr->enable_on_exec = 1;
 }
 
@@ -580,6 +639,12 @@ int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
         return 0;
 }
 
+void perf_evsel__reset_counts(struct perf_evsel *evsel, int ncpus)
+{
+        memset(evsel->counts, 0, (sizeof(*evsel->counts) +
+                                 (ncpus * sizeof(struct perf_counts_values))));
+}
+
 int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
 {
         evsel->counts = zalloc((sizeof(*evsel->counts) +
@@ -612,12 +677,16 @@ void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
                 }
 }
 
+void perf_evsel__free_counts(struct perf_evsel *evsel)
+{
+        free(evsel->counts);
+}
+
 void perf_evsel__exit(struct perf_evsel *evsel)
 {
         assert(list_empty(&evsel->node));
-        xyarray__delete(evsel->fd);
-        xyarray__delete(evsel->sample_id);
-        free(evsel->id);
+        perf_evsel__free_fd(evsel);
+        perf_evsel__free_id(evsel);
 }
 
 void perf_evsel__delete(struct perf_evsel *evsel)
@@ -631,6 +700,28 @@ void perf_evsel__delete(struct perf_evsel *evsel)
         free(evsel);
 }
 
+static inline void compute_deltas(struct perf_evsel *evsel,
+                                  int cpu,
+                                  struct perf_counts_values *count)
+{
+        struct perf_counts_values tmp;
+
+        if (!evsel->prev_raw_counts)
+                return;
+
+        if (cpu == -1) {
+                tmp = evsel->prev_raw_counts->aggr;
+                evsel->prev_raw_counts->aggr = *count;
+        } else {
+                tmp = evsel->prev_raw_counts->cpu[cpu];
+                evsel->prev_raw_counts->cpu[cpu] = *count;
+        }
+
+        count->val = count->val - tmp.val;
+        count->ena = count->ena - tmp.ena;
+        count->run = count->run - tmp.run;
+}
+
 int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
                               int cpu, int thread, bool scale)
 {
@@ -646,6 +737,8 @@ int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
         if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
                 return -errno;
 
+        compute_deltas(evsel, cpu, &count);
+
         if (scale) {
                 if (count.run == 0)
                         count.val = 0;
@@ -684,6 +777,8 @@ int __perf_evsel__read(struct perf_evsel *evsel,
                 }
         }
 
+        compute_deltas(evsel, -1, aggr);
+
         evsel->counts->scaled = 0;
         if (scale) {
                 if (aggr->run == 0) {
@@ -707,7 +802,7 @@ static int get_group_fd(struct perf_evsel *evsel, int cpu, int thread)
         struct perf_evsel *leader = evsel->leader;
         int fd;
 
-        if (!perf_evsel__is_group_member(evsel))
+        if (perf_evsel__is_group_leader(evsel))
                 return -1;
 
         /*
@@ -738,6 +833,13 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                 pid = evsel->cgrp->fd;
         }
 
+fallback_missing_features:
+        if (perf_missing_features.exclude_guest)
+                evsel->attr.exclude_guest = evsel->attr.exclude_host = 0;
+retry_sample_id:
+        if (perf_missing_features.sample_id_all)
+                evsel->attr.sample_id_all = 0;
+
         for (cpu = 0; cpu < cpus->nr; cpu++) {
 
                 for (thread = 0; thread < threads->nr; thread++) {
@@ -754,13 +856,26 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                                                                      group_fd, flags);
                         if (FD(evsel, cpu, thread) < 0) {
                                 err = -errno;
-                                goto out_close;
+                                goto try_fallback;
                         }
                 }
         }
 
         return 0;
 
+try_fallback:
+        if (err != -EINVAL || cpu > 0 || thread > 0)
+                goto out_close;
+
+        if (!perf_missing_features.exclude_guest &&
+            (evsel->attr.exclude_guest || evsel->attr.exclude_host)) {
+                perf_missing_features.exclude_guest = true;
+                goto fallback_missing_features;
+        } else if (!perf_missing_features.sample_id_all) {
+                perf_missing_features.sample_id_all = true;
+                goto retry_sample_id;
+        }
+
 out_close:
         do {
                 while (--thread >= 0) {
@@ -908,6 +1023,7 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
         data->cpu = data->pid = data->tid = -1;
         data->stream_id = data->id = data->time = -1ULL;
         data->period = 1;
+        data->weight = 0;
 
         if (event->header.type != PERF_RECORD_SAMPLE) {
                 if (!evsel->attr.sample_id_all)
@@ -1058,6 +1174,18 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                 }
         }
 
+        data->weight = 0;
+        if (type & PERF_SAMPLE_WEIGHT) {
+                data->weight = *array;
+                array++;
+        }
+
+        data->data_src = PERF_MEM_DATA_SRC_NONE;
+        if (type & PERF_SAMPLE_DATA_SRC) {
+                data->data_src = *array;
+                array++;
+        }
+
         return 0;
 }
 
@@ -1205,3 +1333,225 @@ u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
 
         return 0;
 }
+
+static int comma_fprintf(FILE *fp, bool *first, const char *fmt, ...)
+{
+        va_list args;
+        int ret = 0;
+
+        if (!*first) {
+                ret += fprintf(fp, ",");
+        } else {
+                ret += fprintf(fp, ":");
+                *first = false;
+        }
+
+        va_start(args, fmt);
+        ret += vfprintf(fp, fmt, args);
+        va_end(args);
+        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),
+                { .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)
+{
+#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);
+}
+
+int perf_evsel__fprintf(struct perf_evsel *evsel,
+                        struct perf_attr_details *details, FILE *fp)
+{
+        bool first = true;
+        int printed = 0;
+
+        if (details->event_group) {
+                struct perf_evsel *pos;
+
+                if (!perf_evsel__is_group_leader(evsel))
+                        return 0;
+
+                if (evsel->nr_members > 1)
+                        printed += fprintf(fp, "%s{", evsel->group_name ?: "");
+
+                printed += fprintf(fp, "%s", perf_evsel__name(evsel));
+                for_each_group_member(pos, evsel)
+                        printed += fprintf(fp, ",%s", perf_evsel__name(pos));
+
+                if (evsel->nr_members > 1)
+                        printed += fprintf(fp, "}");
+                goto out;
+        }
+
+        printed += fprintf(fp, "%s", perf_evsel__name(evsel));
+
+        if (details->verbose || 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(comm);
+                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;
+}
+
+bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
+                          char *msg, size_t msgsize)
+{
+        if ((err == ENOENT || err == ENXIO) &&
+            evsel->attr.type   == PERF_TYPE_HARDWARE &&
+            evsel->attr.config == PERF_COUNT_HW_CPU_CYCLES) {
+                /*
+                 * If it's cycles then fall back to hrtimer based
+                 * cpu-clock-tick sw counter, which is always available even if
+                 * no PMU support.
+                 *
+                 * PPC returns ENXIO until 2.6.37 (behavior changed with commit
+                 * b0a873e).
+                 */
+                scnprintf(msg, msgsize, "%s",
+"The cycles event is not supported, trying to fall back to cpu-clock-ticks");
+
+                evsel->attr.type   = PERF_TYPE_SOFTWARE;
+                evsel->attr.config = PERF_COUNT_SW_CPU_CLOCK;
+
+                free(evsel->name);
+                evsel->name = NULL;
+                return true;
+        }
+
+        return false;
+}
+
+int perf_evsel__open_strerror(struct perf_evsel *evsel,
+                              struct perf_target *target,
+                              int err, char *msg, size_t size)
+{
+        switch (err) {
+        case EPERM:
+        case EACCES:
+                return scnprintf(msg, size,
+                 "You may not have permission to collect %sstats.\n"
+                 "Consider tweaking /proc/sys/kernel/perf_event_paranoid:\n"
+                 " -1 - Not paranoid at all\n"
+                 "  0 - Disallow raw tracepoint access for unpriv\n"
+                 "  1 - Disallow cpu events for unpriv\n"
+                 "  2 - Disallow kernel profiling for unpriv",
+                                 target->system_wide ? "system-wide " : "");
+        case ENOENT:
+                return scnprintf(msg, size, "The %s event is not supported.",
+                                 perf_evsel__name(evsel));
+        case EMFILE:
+                return scnprintf(msg, size, "%s",
+                         "Too many events are opened.\n"
+                         "Try again after reducing the number of events.");
+        case ENODEV:
+                if (target->cpu_list)
+                        return scnprintf(msg, size, "%s",
+         "No such device - did you specify an out-of-range profile CPU?\n");
+                break;
+        case EOPNOTSUPP:
+                if (evsel->attr.precise_ip)
+                        return scnprintf(msg, size, "%s",
+        "\'precise\' request may not be supported. Try removing 'p' modifier.");
+#if defined(__i386__) || defined(__x86_64__)
+                if (evsel->attr.type == PERF_TYPE_HARDWARE)
+                        return scnprintf(msg, size, "%s",
+        "No hardware sampling interrupt available.\n"
+        "No APIC? If so then you can boot the kernel with the \"lapic\" boot parameter to force-enable it.");
+#endif
+                break;
+        default:
+                break;
+        }
+
+        return scnprintf(msg, size,
+        "The sys_perf_event_open() syscall returned with %d (%s) for event (%s).  \n"
+        "/bin/dmesg may provide additional information.\n"
+        "No CONFIG_PERF_EVENTS=y kernel support configured?\n",
+                         err, strerror(err), perf_evsel__name(evsel));
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 3d2b8017438c..3f156ccc1acb 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -9,6 +9,7 @@
 #include "xyarray.h"
 #include "cgroup.h"
 #include "hist.h"
+#include "symbol.h"
  
 struct perf_counts_values {
         union {
@@ -53,6 +54,7 @@ struct perf_evsel {
         struct xyarray          *sample_id;
         u64                     *id;
         struct perf_counts      *counts;
+        struct perf_counts      *prev_raw_counts;
         int                     idx;
         u32                     ids;
         struct hists            hists;
@@ -73,10 +75,13 @@ struct perf_evsel {
         bool                    needs_swap;
         /* parse modifier helper */
         int                     exclude_GH;
+        int                     nr_members;
         struct perf_evsel       *leader;
         char                    *group_name;
 };
 
+#define hists_to_evsel(h) container_of(h, struct perf_evsel, hists)
+
 struct cpu_map;
 struct thread_map;
 struct perf_evlist;
@@ -110,14 +115,31 @@ extern const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX];
 int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
                                             char *bf, size_t size);
 const char *perf_evsel__name(struct perf_evsel *evsel);
+const char *perf_evsel__group_name(struct perf_evsel *evsel);
+int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size);
 
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads);
 int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus);
+void perf_evsel__reset_counts(struct perf_evsel *evsel, int ncpus);
 void perf_evsel__free_fd(struct perf_evsel *evsel);
 void perf_evsel__free_id(struct perf_evsel *evsel);
+void perf_evsel__free_counts(struct perf_evsel *evsel);
 void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
 
+void __perf_evsel__set_sample_bit(struct perf_evsel *evsel,
+                                  enum perf_event_sample_format bit);
+void __perf_evsel__reset_sample_bit(struct perf_evsel *evsel,
+                                    enum perf_event_sample_format bit);
+
+#define perf_evsel__set_sample_bit(evsel, bit) \
+        __perf_evsel__set_sample_bit(evsel, PERF_SAMPLE_##bit)
+
+#define perf_evsel__reset_sample_bit(evsel, bit) \
+        __perf_evsel__reset_sample_bit(evsel, PERF_SAMPLE_##bit)
+
+void perf_evsel__set_sample_id(struct perf_evsel *evsel);
+
 int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
                            const char *filter);
 
@@ -226,8 +248,57 @@ static inline struct perf_evsel *perf_evsel__next(struct perf_evsel *evsel)
         return list_entry(evsel->node.next, struct perf_evsel, node);
 }
 
-static inline bool perf_evsel__is_group_member(const struct perf_evsel *evsel)
+/**
+ * perf_evsel__is_group_leader - Return whether given evsel is a leader event
+ *
+ * @evsel - evsel selector to be tested
+ *
+ * Return %true if @evsel is a group leader or a stand-alone event
+ */
+static inline bool perf_evsel__is_group_leader(const struct perf_evsel *evsel)
+{
+        return evsel->leader == evsel;
+}
+
+/**
+ * perf_evsel__is_group_event - Return whether given evsel is a group event
+ *
+ * @evsel - evsel selector to be tested
+ *
+ * Return %true iff event group view is enabled and @evsel is a actual group
+ * leader which has other members in the group
+ */
+static inline bool perf_evsel__is_group_event(struct perf_evsel *evsel)
+{
+        if (!symbol_conf.event_group)
+                return false;
+
+        return perf_evsel__is_group_leader(evsel) && evsel->nr_members > 1;
+}
+
+struct perf_attr_details {
+        bool freq;
+        bool verbose;
+        bool event_group;
+};
+
+int perf_evsel__fprintf(struct perf_evsel *evsel,
+                        struct perf_attr_details *details, FILE *fp);
+
+bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
+                          char *msg, size_t msgsize);
+int perf_evsel__open_strerror(struct perf_evsel *evsel,
+                              struct perf_target *target,
+                              int err, char *msg, size_t size);
+
+static inline int perf_evsel__group_idx(struct perf_evsel *evsel)
 {
-        return evsel->leader != NULL;
+        return evsel->idx - evsel->leader->idx;
 }
+
+#define for_each_group_member(_evsel, _leader)                                  \
+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))
+
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index b7da4634a047..738d3b8d9745 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,5 +1,3 @@
-#define _FILE_OFFSET_BITS 64
-
 #include "util.h"
 #include <sys/types.h>
 #include <byteswap.h>
@@ -148,7 +146,7 @@ static char *do_read_string(int fd, struct perf_header *ph)
         u32 len;
         char *buf;
 
-        sz = read(fd, &len, sizeof(len));
+        sz = readn(fd, &len, sizeof(len));
         if (sz < (ssize_t)sizeof(len))
                 return NULL;
 
@@ -159,7 +157,7 @@ static char *do_read_string(int fd, struct perf_header *ph)
         if (!buf)
                 return NULL;
 
-        ret = read(fd, buf, len);
+        ret = readn(fd, buf, len);
         if (ret == (ssize_t)len) {
                 /*
                  * strings are padded by zeroes
@@ -287,12 +285,12 @@ static int dsos__write_buildid_table(struct perf_header *header, int fd)
         struct perf_session *session = container_of(header,
                         struct perf_session, header);
         struct rb_node *nd;
-        int err = machine__write_buildid_table(&session->host_machine, fd);
+        int err = machine__write_buildid_table(&session->machines.host, fd);
 
         if (err)
                 return err;
 
-        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
                 err = machine__write_buildid_table(pos, fd);
                 if (err)
@@ -313,7 +311,8 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
         if (is_kallsyms) {
                 if (symbol_conf.kptr_restrict) {
                         pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
-                        return 0;
+                        err = 0;
+                        goto out_free;
                 }
                 realname = (char *) name;
         } else
@@ -448,9 +447,9 @@ static int perf_session__cache_build_ids(struct perf_session *session)
         if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
                 return -1;
 
-        ret = machine__cache_build_ids(&session->host_machine, debugdir);
+        ret = machine__cache_build_ids(&session->machines.host, debugdir);
 
-        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+        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, debugdir);
         }
@@ -467,9 +466,9 @@ static bool machine__read_build_ids(struct machine *machine, bool with_hits)
 static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
 {
         struct rb_node *nd;
-        bool ret = machine__read_build_ids(&session->host_machine, with_hits);
+        bool ret = machine__read_build_ids(&session->machines.host, with_hits);
 
-        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
                 ret |= machine__read_build_ids(pos, with_hits);
         }
@@ -954,6 +953,7 @@ static int write_topo_node(int fd, int node)
         }
 
         fclose(fp);
+        fp = NULL;
 
         ret = do_write(fd, &mem_total, sizeof(u64));
         if (ret)
@@ -980,7 +980,8 @@ static int write_topo_node(int fd, int node)
         ret = do_write_string(fd, buf);
 done:
         free(buf);
-        fclose(fp);
+        if (fp)
+                fclose(fp);
         return ret;
 }
 
@@ -1051,16 +1052,25 @@ static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
         struct perf_pmu *pmu = NULL;
         off_t offset = lseek(fd, 0, SEEK_CUR);
         __u32 pmu_num = 0;
+        int ret;
 
         /* write real pmu_num later */
-        do_write(fd, &pmu_num, sizeof(pmu_num));
+        ret = do_write(fd, &pmu_num, sizeof(pmu_num));
+        if (ret < 0)
+                return ret;
 
         while ((pmu = perf_pmu__scan(pmu))) {
                 if (!pmu->name)
                         continue;
                 pmu_num++;
-                do_write(fd, &pmu->type, sizeof(pmu->type));
-                do_write_string(fd, pmu->name);
+
+                ret = do_write(fd, &pmu->type, sizeof(pmu->type));
+                if (ret < 0)
+                        return ret;
+
+                ret = do_write_string(fd, pmu->name);
+                if (ret < 0)
+                        return ret;
         }
 
         if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) {
@@ -1073,6 +1083,52 @@ static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
 }
 
 /*
+ * File format:
+ *
+ * struct group_descs {
+ *      u32     nr_groups;
+ *      struct group_desc {
+ *              char    name[];
+ *              u32     leader_idx;
+ *              u32     nr_members;
+ *      }[nr_groups];
+ * };
+ */
+static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
+                            struct perf_evlist *evlist)
+{
+        u32 nr_groups = evlist->nr_groups;
+        struct perf_evsel *evsel;
+        int ret;
+
+        ret = do_write(fd, &nr_groups, sizeof(nr_groups));
+        if (ret < 0)
+                return ret;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                if (perf_evsel__is_group_leader(evsel) &&
+                    evsel->nr_members > 1) {
+                        const char *name = evsel->group_name ?: "{anon_group}";
+                        u32 leader_idx = evsel->idx;
+                        u32 nr_members = evsel->nr_members;
+
+                        ret = do_write_string(fd, name);
+                        if (ret < 0)
+                                return ret;
+
+                        ret = do_write(fd, &leader_idx, sizeof(leader_idx));
+                        if (ret < 0)
+                                return ret;
+
+                        ret = do_write(fd, &nr_members, sizeof(nr_members));
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+        return 0;
+}
+
+/*
  * default get_cpuid(): nothing gets recorded
  * actual implementation must be in arch/$(ARCH)/util/header.c
  */
@@ -1209,14 +1265,14 @@ read_event_desc(struct perf_header *ph, int fd)
         size_t msz;
 
         /* number of events */
-        ret = read(fd, &nre, sizeof(nre));
+        ret = readn(fd, &nre, sizeof(nre));
         if (ret != (ssize_t)sizeof(nre))
                 goto error;
 
         if (ph->needs_swap)
                 nre = bswap_32(nre);
 
-        ret = read(fd, &sz, sizeof(sz));
+        ret = readn(fd, &sz, sizeof(sz));
         if (ret != (ssize_t)sizeof(sz))
                 goto error;
 
@@ -1244,7 +1300,7 @@ read_event_desc(struct perf_header *ph, int fd)
                  * must read entire on-file attr struct to
                  * sync up with layout.
                  */
-                ret = read(fd, buf, sz);
+                ret = readn(fd, buf, sz);
                 if (ret != (ssize_t)sz)
                         goto error;
 
@@ -1253,7 +1309,7 @@ read_event_desc(struct perf_header *ph, int fd)
 
                 memcpy(&evsel->attr, buf, msz);
 
-                ret = read(fd, &nr, sizeof(nr));
+                ret = readn(fd, &nr, sizeof(nr));
                 if (ret != (ssize_t)sizeof(nr))
                         goto error;
 
@@ -1274,7 +1330,7 @@ read_event_desc(struct perf_header *ph, int fd)
                 evsel->id = id;
 
                 for (j = 0 ; j < nr; j++) {
-                        ret = read(fd, id, sizeof(*id));
+                        ret = readn(fd, id, sizeof(*id));
                         if (ret != (ssize_t)sizeof(*id))
                                 goto error;
                         if (ph->needs_swap)
@@ -1435,6 +1491,31 @@ error:
         fprintf(fp, "# pmu mappings: unable to read\n");
 }
 
+static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
+                             FILE *fp)
+{
+        struct perf_session *session;
+        struct perf_evsel *evsel;
+        u32 nr = 0;
+
+        session = container_of(ph, struct perf_session, header);
+
+        list_for_each_entry(evsel, &session->evlist->entries, node) {
+                if (perf_evsel__is_group_leader(evsel) &&
+                    evsel->nr_members > 1) {
+                        fprintf(fp, "# group: %s{%s", evsel->group_name ?: "",
+                                perf_evsel__name(evsel));
+
+                        nr = evsel->nr_members - 1;
+                } else if (nr) {
+                        fprintf(fp, ",%s", perf_evsel__name(evsel));
+
+                        if (--nr == 0)
+                                fprintf(fp, "}\n");
+                }
+        }
+}
+
 static int __event_process_build_id(struct build_id_event *bev,
                                     char *filename,
                                     struct perf_session *session)
@@ -1506,14 +1587,14 @@ static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
         while (offset < limit) {
                 ssize_t len;
 
-                if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
+                if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
                         return -1;
 
                 if (header->needs_swap)
                         perf_event_header__bswap(&old_bev.header);
 
                 len = old_bev.header.size - sizeof(old_bev);
-                if (read(input, filename, len) != len)
+                if (readn(input, filename, len) != len)
                         return -1;
 
                 bev.header = old_bev.header;
@@ -1548,14 +1629,14 @@ static int perf_header__read_build_ids(struct perf_header *header,
         while (offset < limit) {
                 ssize_t len;
 
-                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
+                if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
                         goto out;
 
                 if (header->needs_swap)
                         perf_event_header__bswap(&bev.header);
 
                 len = bev.header.size - sizeof(bev);
-                if (read(input, filename, len) != len)
+                if (readn(input, filename, len) != len)
                         goto out;
                 /*
                  * The a1645ce1 changeset:
@@ -1589,8 +1670,8 @@ static int process_tracing_data(struct perf_file_section *section __maybe_unused
                                 struct perf_header *ph __maybe_unused,
                                 int fd, void *data)
 {
-        trace_report(fd, data, false);
-        return 0;
+        ssize_t ret = trace_report(fd, data, false);
+        return ret < 0 ? -1 : 0;
 }
 
 static int process_build_id(struct perf_file_section *section,
@@ -1641,7 +1722,7 @@ static int process_nrcpus(struct perf_file_section *section __maybe_unused,
         size_t ret;
         u32 nr;
 
-        ret = read(fd, &nr, sizeof(nr));
+        ret = readn(fd, &nr, sizeof(nr));
         if (ret != sizeof(nr))
                 return -1;
 
@@ -1650,7 +1731,7 @@ static int process_nrcpus(struct perf_file_section *section __maybe_unused,
 
         ph->env.nr_cpus_online = nr;
 
-        ret = read(fd, &nr, sizeof(nr));
+        ret = readn(fd, &nr, sizeof(nr));
         if (ret != sizeof(nr))
                 return -1;
 
@@ -1684,7 +1765,7 @@ static int process_total_mem(struct perf_file_section *section __maybe_unused,
         uint64_t mem;
         size_t ret;
 
-        ret = read(fd, &mem, sizeof(mem));
+        ret = readn(fd, &mem, sizeof(mem));
         if (ret != sizeof(mem))
                 return -1;
 
@@ -1756,7 +1837,7 @@ static int process_cmdline(struct perf_file_section *section __maybe_unused,
         u32 nr, i;
         struct strbuf sb;
 
-        ret = read(fd, &nr, sizeof(nr));
+        ret = readn(fd, &nr, sizeof(nr));
         if (ret != sizeof(nr))
                 return -1;
 
@@ -1792,7 +1873,7 @@ static int process_cpu_topology(struct perf_file_section *section __maybe_unused
         char *str;
         struct strbuf sb;
 
-        ret = read(fd, &nr, sizeof(nr));
+        ret = readn(fd, &nr, sizeof(nr));
         if (ret != sizeof(nr))
                 return -1;
 
@@ -1813,7 +1894,7 @@ static int process_cpu_topology(struct perf_file_section *section __maybe_unused
         }
         ph->env.sibling_cores = strbuf_detach(&sb, NULL);
 
-        ret = read(fd, &nr, sizeof(nr));
+        ret = readn(fd, &nr, sizeof(nr));
         if (ret != sizeof(nr))
                 return -1;
 
@@ -1850,7 +1931,7 @@ static int process_numa_topology(struct perf_file_section *section __maybe_unuse
         struct strbuf sb;
 
         /* nr nodes */
-        ret = read(fd, &nr, sizeof(nr));
+        ret = readn(fd, &nr, sizeof(nr));
         if (ret != sizeof(nr))
                 goto error;
 
@@ -1862,15 +1943,15 @@ static int process_numa_topology(struct perf_file_section *section __maybe_unuse
 
         for (i = 0; i < nr; i++) {
                 /* node number */
-                ret = read(fd, &node, sizeof(node));
+                ret = readn(fd, &node, sizeof(node));
                 if (ret != sizeof(node))
                         goto error;
 
-                ret = read(fd, &mem_total, sizeof(u64));
+                ret = readn(fd, &mem_total, sizeof(u64));
                 if (ret != sizeof(u64))
                         goto error;
 
-                ret = read(fd, &mem_free, sizeof(u64));
+                ret = readn(fd, &mem_free, sizeof(u64));
                 if (ret != sizeof(u64))
                         goto error;
 
@@ -1909,7 +1990,7 @@ static int process_pmu_mappings(struct perf_file_section *section __maybe_unused
         u32 type;
         struct strbuf sb;
 
-        ret = read(fd, &pmu_num, sizeof(pmu_num));
+        ret = readn(fd, &pmu_num, sizeof(pmu_num));
         if (ret != sizeof(pmu_num))
                 return -1;
 
@@ -1925,7 +2006,7 @@ static int process_pmu_mappings(struct perf_file_section *section __maybe_unused
         strbuf_init(&sb, 128);
 
         while (pmu_num) {
-                if (read(fd, &type, sizeof(type)) != sizeof(type))
+                if (readn(fd, &type, sizeof(type)) != sizeof(type))
                         goto error;
                 if (ph->needs_swap)
                         type = bswap_32(type);
@@ -1949,6 +2030,98 @@ error:
         return -1;
 }
 
+static int process_group_desc(struct perf_file_section *section __maybe_unused,
+                              struct perf_header *ph, int fd,
+                              void *data __maybe_unused)
+{
+        size_t ret = -1;
+        u32 i, nr, nr_groups;
+        struct perf_session *session;
+        struct perf_evsel *evsel, *leader = NULL;
+        struct group_desc {
+                char *name;
+                u32 leader_idx;
+                u32 nr_members;
+        } *desc;
+
+        if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups))
+                return -1;
+
+        if (ph->needs_swap)
+                nr_groups = bswap_32(nr_groups);
+
+        ph->env.nr_groups = nr_groups;
+        if (!nr_groups) {
+                pr_debug("group desc not available\n");
+                return 0;
+        }
+
+        desc = calloc(nr_groups, sizeof(*desc));
+        if (!desc)
+                return -1;
+
+        for (i = 0; i < nr_groups; i++) {
+                desc[i].name = do_read_string(fd, ph);
+                if (!desc[i].name)
+                        goto out_free;
+
+                if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32))
+                        goto out_free;
+
+                if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32))
+                        goto out_free;
+
+                if (ph->needs_swap) {
+                        desc[i].leader_idx = bswap_32(desc[i].leader_idx);
+                        desc[i].nr_members = bswap_32(desc[i].nr_members);
+                }
+        }
+
+        /*
+         * Rebuild group relationship based on the group_desc
+         */
+        session = container_of(ph, struct perf_session, header);
+        session->evlist->nr_groups = nr_groups;
+
+        i = nr = 0;
+        list_for_each_entry(evsel, &session->evlist->entries, node) {
+                if (evsel->idx == (int) desc[i].leader_idx) {
+                        evsel->leader = evsel;
+                        /* {anon_group} is a dummy name */
+                        if (strcmp(desc[i].name, "{anon_group}"))
+                                evsel->group_name = desc[i].name;
+                        evsel->nr_members = desc[i].nr_members;
+
+                        if (i >= nr_groups || nr > 0) {
+                                pr_debug("invalid group desc\n");
+                                goto out_free;
+                        }
+
+                        leader = evsel;
+                        nr = evsel->nr_members - 1;
+                        i++;
+                } else if (nr) {
+                        /* This is a group member */
+                        evsel->leader = leader;
+
+                        nr--;
+                }
+        }
+
+        if (i != nr_groups || nr != 0) {
+                pr_debug("invalid group desc\n");
+                goto out_free;
+        }
+
+        ret = 0;
+out_free:
+        while ((int) --i >= 0)
+                free(desc[i].name);
+        free(desc);
+
+        return ret;
+}
+
 struct feature_ops {
         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
         void (*print)(struct perf_header *h, int fd, FILE *fp);
@@ -1988,6 +2161,7 @@ static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
         FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
+        FEAT_OPP(HEADER_GROUP_DESC,     group_desc),
 };
 
 struct header_print_data {
@@ -2077,7 +2251,7 @@ static int perf_header__adds_write(struct perf_header *header,
         if (!nr_sections)
                 return 0;
 
-        feat_sec = p = calloc(sizeof(*feat_sec), nr_sections);
+        feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
         if (feat_sec == NULL)
                 return -ENOMEM;
 
@@ -2217,7 +2391,6 @@ out_err_write:
         }
         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
 
-        header->frozen = 1;
         return 0;
 }
 
@@ -2249,7 +2422,7 @@ int perf_header__process_sections(struct perf_header *header, int fd,
         if (!nr_sections)
                 return 0;
 
-        feat_sec = sec = calloc(sizeof(*feat_sec), nr_sections);
+        feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
         if (!feat_sec)
                 return -1;
 
@@ -2576,6 +2749,11 @@ static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
         if (evsel->tp_format)
                 return 0;
 
+        if (pevent == NULL) {
+                pr_debug("broken or missing trace data\n");
+                return -1;
+        }
+
         event = pevent_find_event(pevent, evsel->attr.config);
         if (event == NULL)
                 return -1;
@@ -2613,7 +2791,7 @@ int perf_session__read_header(struct perf_session *session, int fd)
         u64                     f_id;
         int nr_attrs, nr_ids, i, j;
 
-        session->evlist = perf_evlist__new(NULL, NULL);
+        session->evlist = perf_evlist__new();
         if (session->evlist == NULL)
                 return -ENOMEM;
 
@@ -2692,7 +2870,6 @@ int perf_session__read_header(struct perf_session *session, int fd)
                                                    session->pevent))
                 goto out_delete_evlist;
 
-        header->frozen = 1;
         return 0;
 out_errno:
         return -errno;
@@ -2764,7 +2941,7 @@ int perf_event__process_attr(union perf_event *event,
         struct perf_evlist *evlist = *pevlist;
 
         if (evlist == NULL) {
-                *pevlist = evlist = perf_evlist__new(NULL, NULL);
+                *pevlist = evlist = perf_evlist__new();
                 if (evlist == NULL)
                         return -ENOMEM;
         }
@@ -2912,16 +3089,22 @@ int perf_event__process_tracing_data(union perf_event *event,
                                  session->repipe);
         padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
 
-        if (read(session->fd, buf, padding) < 0)
-                die("reading input file");
+        if (readn(session->fd, buf, padding) < 0) {
+                pr_err("%s: reading input file", __func__);
+                return -1;
+        }
         if (session->repipe) {
                 int retw = write(STDOUT_FILENO, buf, padding);
-                if (retw <= 0 || retw != padding)
-                        die("repiping tracing data padding");
+                if (retw <= 0 || retw != padding) {
+                        pr_err("%s: repiping tracing data padding", __func__);
+                        return -1;
+                }
         }
 
-        if (size_read + padding != size)
-                die("tracing data size mismatch");
+        if (size_read + padding != size) {
+                pr_err("%s: tracing data size mismatch", __func__);
+                return -1;
+        }
 
         perf_evlist__prepare_tracepoint_events(session->evlist,
                                                session->pevent);
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 20f0344accb1..16a3e83c584e 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -29,6 +29,7 @@ enum {
         HEADER_NUMA_TOPOLOGY,
         HEADER_BRANCH_STACK,
         HEADER_PMU_MAPPINGS,
+        HEADER_GROUP_DESC,
         HEADER_LAST_FEATURE,
         HEADER_FEAT_BITS        = 256,
 };
@@ -79,10 +80,10 @@ struct perf_session_env {
         char                    *numa_nodes;
         int                     nr_pmu_mappings;
         char                    *pmu_mappings;
+        int                     nr_groups;
 };
 
 struct perf_header {
-        int                     frozen;
         bool                    needs_swap;
         s64                     attr_offset;
         u64                     data_offset;
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index cb17e2a8c6ed..b11a6cfdb414 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -4,6 +4,7 @@
 #include "hist.h"
 #include "session.h"
 #include "sort.h"
+#include "evsel.h"
 #include <math.h>
 
 static bool hists__filter_entry_by_dso(struct hists *hists,
@@ -66,12 +67,24 @@ static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
 void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 {
         const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
+        int symlen;
         u16 len;
 
-        if (h->ms.sym)
-                hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen + 4);
-        else
+        /*
+         * +4 accounts for '[x] ' priv level info
+         * +2 accounts for 0x prefix on raw addresses
+         * +3 accounts for ' y ' symtab origin info
+         */
+        if (h->ms.sym) {
+                symlen = h->ms.sym->namelen + 4;
+                if (verbose)
+                        symlen += BITS_PER_LONG / 4 + 2 + 3;
+                hists__new_col_len(hists, HISTC_SYMBOL, symlen);
+        } else {
+                symlen = unresolved_col_width + 4 + 2;
+                hists__new_col_len(hists, HISTC_SYMBOL, symlen);
                 hists__set_unres_dso_col_len(hists, HISTC_DSO);
+        }
 
         len = thread__comm_len(h->thread);
         if (hists__new_col_len(hists, HISTC_COMM, len))
@@ -82,14 +95,14 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                 hists__new_col_len(hists, HISTC_DSO, len);
         }
 
+        if (h->parent)
+                hists__new_col_len(hists, HISTC_PARENT, h->parent->namelen);
+
         if (h->branch_info) {
-                int symlen;
-                /*
-                 * +4 accounts for '[x] ' priv level info
-                 * +2 account of 0x prefix on raw addresses
-                 */
                 if (h->branch_info->from.sym) {
                         symlen = (int)h->branch_info->from.sym->namelen + 4;
+                        if (verbose)
+                                symlen += BITS_PER_LONG / 4 + 2 + 3;
                         hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
 
                         symlen = dso__name_len(h->branch_info->from.map->dso);
@@ -102,6 +115,8 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 
                 if (h->branch_info->to.sym) {
                         symlen = (int)h->branch_info->to.sym->namelen + 4;
+                        if (verbose)
+                                symlen += BITS_PER_LONG / 4 + 2 + 3;
                         hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
 
                         symlen = dso__name_len(h->branch_info->to.map->dso);
@@ -112,6 +127,38 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                         hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
                 }
         }
+
+        if (h->mem_info) {
+                if (h->mem_info->daddr.sym) {
+                        symlen = (int)h->mem_info->daddr.sym->namelen + 4
+                               + unresolved_col_width + 2;
+                        hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
+                                           symlen);
+                } else {
+                        symlen = unresolved_col_width + 4 + 2;
+                        hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
+                                           symlen);
+                }
+                if (h->mem_info->daddr.map) {
+                        symlen = dso__name_len(h->mem_info->daddr.map->dso);
+                        hists__new_col_len(hists, HISTC_MEM_DADDR_DSO,
+                                           symlen);
+                } else {
+                        symlen = unresolved_col_width + 4 + 2;
+                        hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
+                }
+        } else {
+                symlen = unresolved_col_width + 4 + 2;
+                hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL, symlen);
+                hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
+        }
+
+        hists__new_col_len(hists, HISTC_MEM_LOCKED, 6);
+        hists__new_col_len(hists, HISTC_MEM_TLB, 22);
+        hists__new_col_len(hists, HISTC_MEM_SNOOP, 12);
+        hists__new_col_len(hists, HISTC_MEM_LVL, 21 + 3);
+        hists__new_col_len(hists, HISTC_LOCAL_WEIGHT, 12);
+        hists__new_col_len(hists, HISTC_GLOBAL_WEIGHT, 12);
 }
 
 void hists__output_recalc_col_len(struct hists *hists, int max_rows)
@@ -151,9 +198,12 @@ static void hist_entry__add_cpumode_period(struct hist_entry *he,
         }
 }
 
-static void he_stat__add_period(struct he_stat *he_stat, u64 period)
+static void he_stat__add_period(struct he_stat *he_stat, u64 period,
+                                u64 weight)
 {
+
         he_stat->period         += period;
+        he_stat->weight         += weight;
         he_stat->nr_events      += 1;
 }
 
@@ -165,12 +215,14 @@ static void he_stat__add_stat(struct he_stat *dest, struct he_stat *src)
         dest->period_guest_sys  += src->period_guest_sys;
         dest->period_guest_us   += src->period_guest_us;
         dest->nr_events         += src->nr_events;
+        dest->weight            += src->weight;
 }
 
 static void hist_entry__decay(struct hist_entry *he)
 {
         he->stat.period = (he->stat.period * 7) / 8;
         he->stat.nr_events = (he->stat.nr_events * 7) / 8;
+        /* XXX need decay for weight too? */
 }
 
 static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
@@ -188,8 +240,7 @@ static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
         return he->stat.period == 0;
 }
 
-static void __hists__decay_entries(struct hists *hists, bool zap_user,
-                                   bool zap_kernel, bool threaded)
+void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
 {
         struct rb_node *next = rb_first(&hists->entries);
         struct hist_entry *n;
@@ -208,7 +259,7 @@ static void __hists__decay_entries(struct hists *hists, bool zap_user,
                     !n->used) {
                         rb_erase(&n->rb_node, &hists->entries);
 
-                        if (sort__need_collapse || threaded)
+                        if (sort__need_collapse)
                                 rb_erase(&n->rb_node_in, &hists->entries_collapsed);
 
                         hist_entry__free(n);
@@ -217,17 +268,6 @@ static void __hists__decay_entries(struct hists *hists, bool zap_user,
         }
 }
 
-void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
-{
-        return __hists__decay_entries(hists, zap_user, zap_kernel, false);
-}
-
-void hists__decay_entries_threaded(struct hists *hists,
-                                   bool zap_user, bool zap_kernel)
-{
-        return __hists__decay_entries(hists, zap_user, zap_kernel, true);
-}
-
 /*
  * histogram, sorted on item, collects periods
  */
@@ -235,13 +275,42 @@ void hists__decay_entries_threaded(struct hists *hists,
 static struct hist_entry *hist_entry__new(struct hist_entry *template)
 {
         size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
-        struct hist_entry *he = malloc(sizeof(*he) + callchain_size);
+        struct hist_entry *he = zalloc(sizeof(*he) + callchain_size);
 
         if (he != NULL) {
                 *he = *template;
 
                 if (he->ms.map)
                         he->ms.map->referenced = true;
+
+                if (he->branch_info) {
+                        /*
+                         * This branch info is (a part of) allocated from
+                         * machine__resolve_bstack() and will be freed after
+                         * adding new entries.  So we need to save a copy.
+                         */
+                        he->branch_info = malloc(sizeof(*he->branch_info));
+                        if (he->branch_info == NULL) {
+                                free(he);
+                                return NULL;
+                        }
+
+                        memcpy(he->branch_info, template->branch_info,
+                               sizeof(*he->branch_info));
+
+                        if (he->branch_info->from.map)
+                                he->branch_info->from.map->referenced = true;
+                        if (he->branch_info->to.map)
+                                he->branch_info->to.map->referenced = true;
+                }
+
+                if (he->mem_info) {
+                        if (he->mem_info->iaddr.map)
+                                he->mem_info->iaddr.map->referenced = true;
+                        if (he->mem_info->daddr.map)
+                                he->mem_info->daddr.map->referenced = true;
+                }
+
                 if (symbol_conf.use_callchain)
                         callchain_init(he->callchain);
 
@@ -251,7 +320,7 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template)
         return he;
 }
 
-static void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
+void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
 {
         if (!h->filtered) {
                 hists__calc_col_len(hists, h);
@@ -270,25 +339,36 @@ static u8 symbol__parent_filter(const struct symbol *parent)
 static struct hist_entry *add_hist_entry(struct hists *hists,
                                       struct hist_entry *entry,
                                       struct addr_location *al,
-                                      u64 period)
+                                      u64 period,
+                                      u64 weight)
 {
         struct rb_node **p;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
         int cmp;
 
-        pthread_mutex_lock(&hists->lock);
-
         p = &hists->entries_in->rb_node;
 
         while (*p != NULL) {
                 parent = *p;
                 he = rb_entry(parent, struct hist_entry, rb_node_in);
 
-                cmp = hist_entry__cmp(entry, he);
+                /*
+                 * Make sure that it receives arguments in a same order as
+                 * hist_entry__collapse() so that we can use an appropriate
+                 * function when searching an entry regardless which sort
+                 * keys were used.
+                 */
+                cmp = hist_entry__cmp(he, entry);
 
                 if (!cmp) {
-                        he_stat__add_period(&he->stat, period);
+                        he_stat__add_period(&he->stat, period, weight);
+
+                        /*
+                         * This mem info was allocated from machine__resolve_mem
+                         * and will not be used anymore.
+                         */
+                        free(entry->mem_info);
 
                         /* If the map of an existing hist_entry has
                          * become out-of-date due to an exec() or
@@ -312,22 +392,51 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
 
         he = hist_entry__new(entry);
         if (!he)
-                goto out_unlock;
+                return NULL;
 
         rb_link_node(&he->rb_node_in, parent, p);
         rb_insert_color(&he->rb_node_in, hists->entries_in);
 out:
         hist_entry__add_cpumode_period(he, al->cpumode, period);
-out_unlock:
-        pthread_mutex_unlock(&hists->lock);
         return he;
 }
 
+struct hist_entry *__hists__add_mem_entry(struct hists *self,
+                                          struct addr_location *al,
+                                          struct symbol *sym_parent,
+                                          struct mem_info *mi,
+                                          u64 period,
+                                          u64 weight)
+{
+        struct hist_entry entry = {
+                .thread = al->thread,
+                .ms = {
+                        .map    = al->map,
+                        .sym    = al->sym,
+                },
+                .stat = {
+                        .period = period,
+                        .weight = weight,
+                        .nr_events = 1,
+                },
+                .cpu    = al->cpu,
+                .ip     = al->addr,
+                .level  = al->level,
+                .parent = sym_parent,
+                .filtered = symbol__parent_filter(sym_parent),
+                .hists = self,
+                .mem_info = mi,
+                .branch_info = NULL,
+        };
+        return add_hist_entry(self, &entry, al, period, weight);
+}
+
 struct hist_entry *__hists__add_branch_entry(struct hists *self,
                                              struct addr_location *al,
                                              struct symbol *sym_parent,
                                              struct branch_info *bi,
-                                             u64 period)
+                                             u64 period,
+                                             u64 weight)
 {
         struct hist_entry entry = {
                 .thread = al->thread,
@@ -341,19 +450,22 @@ struct hist_entry *__hists__add_branch_entry(struct hists *self,
                 .stat = {
                         .period = period,
                         .nr_events = 1,
+                        .weight = weight,
                 },
                 .parent = sym_parent,
                 .filtered = symbol__parent_filter(sym_parent),
                 .branch_info = bi,
                 .hists  = self,
+                .mem_info = NULL,
         };
 
-        return add_hist_entry(self, &entry, al, period);
+        return add_hist_entry(self, &entry, al, period, weight);
 }
 
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
-                                      struct symbol *sym_parent, u64 period)
+                                      struct symbol *sym_parent, u64 period,
+                                      u64 weight)
 {
         struct hist_entry entry = {
                 .thread = al->thread,
@@ -367,13 +479,16 @@ struct hist_entry *__hists__add_entry(struct hists *self,
                 .stat = {
                         .period = period,
                         .nr_events = 1,
+                        .weight = weight,
                 },
                 .parent = sym_parent,
                 .filtered = symbol__parent_filter(sym_parent),
                 .hists  = self,
+                .branch_info = NULL,
+                .mem_info = NULL,
         };
 
-        return add_hist_entry(self, &entry, al, period);
+        return add_hist_entry(self, &entry, al, period, weight);
 }
 
 int64_t
@@ -413,6 +528,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
 void hist_entry__free(struct hist_entry *he)
 {
         free(he->branch_info);
+        free(he->mem_info);
         free(he);
 }
 
@@ -481,13 +597,13 @@ static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
         hists__filter_entry_by_symbol(hists, he);
 }
 
-static void __hists__collapse_resort(struct hists *hists, bool threaded)
+void hists__collapse_resort(struct hists *hists)
 {
         struct rb_root *root;
         struct rb_node *next;
         struct hist_entry *n;
 
-        if (!sort__need_collapse && !threaded)
+        if (!sort__need_collapse)
                 return;
 
         root = hists__get_rotate_entries_in(hists);
@@ -509,19 +625,65 @@ static void __hists__collapse_resort(struct hists *hists, bool threaded)
         }
 }
 
-void hists__collapse_resort(struct hists *hists)
+/*
+ * reverse the map, sort on period.
+ */
+
+static int period_cmp(u64 period_a, u64 period_b)
 {
-        return __hists__collapse_resort(hists, false);
+        if (period_a > period_b)
+                return 1;
+        if (period_a < period_b)
+                return -1;
+        return 0;
 }
 
-void hists__collapse_resort_threaded(struct hists *hists)
+static int hist_entry__sort_on_period(struct hist_entry *a,
+                                      struct hist_entry *b)
 {
-        return __hists__collapse_resort(hists, true);
-}
+        int ret;
+        int i, nr_members;
+        struct perf_evsel *evsel;
+        struct hist_entry *pair;
+        u64 *periods_a, *periods_b;
 
-/*
- * reverse the map, sort on period.
- */
+        ret = period_cmp(a->stat.period, b->stat.period);
+        if (ret || !symbol_conf.event_group)
+                return ret;
+
+        evsel = hists_to_evsel(a->hists);
+        nr_members = evsel->nr_members;
+        if (nr_members <= 1)
+                return ret;
+
+        periods_a = zalloc(sizeof(periods_a) * nr_members);
+        periods_b = zalloc(sizeof(periods_b) * nr_members);
+
+        if (!periods_a || !periods_b)
+                goto out;
+
+        list_for_each_entry(pair, &a->pairs.head, pairs.node) {
+                evsel = hists_to_evsel(pair->hists);
+                periods_a[perf_evsel__group_idx(evsel)] = pair->stat.period;
+        }
+
+        list_for_each_entry(pair, &b->pairs.head, pairs.node) {
+                evsel = hists_to_evsel(pair->hists);
+                periods_b[perf_evsel__group_idx(evsel)] = pair->stat.period;
+        }
+
+        for (i = 1; i < nr_members; i++) {
+                ret = period_cmp(periods_a[i], periods_b[i]);
+                if (ret)
+                        break;
+        }
+
+out:
+        free(periods_a);
+        free(periods_b);
+
+        return ret;
+}
 
 static void __hists__insert_output_entry(struct rb_root *entries,
                                          struct hist_entry *he,
@@ -539,7 +701,7 @@ static void __hists__insert_output_entry(struct rb_root *entries,
                 parent = *p;
                 iter = rb_entry(parent, struct hist_entry, rb_node);
 
-                if (he->stat.period > iter->stat.period)
+                if (hist_entry__sort_on_period(he, iter) > 0)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -549,7 +711,7 @@ static void __hists__insert_output_entry(struct rb_root *entries,
         rb_insert_color(&he->rb_node, entries);
 }
 
-static void __hists__output_resort(struct hists *hists, bool threaded)
+void hists__output_resort(struct hists *hists)
 {
         struct rb_root *root;
         struct rb_node *next;
@@ -558,7 +720,7 @@ static void __hists__output_resort(struct hists *hists, bool threaded)
 
         min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
 
-        if (sort__need_collapse || threaded)
+        if (sort__need_collapse)
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
@@ -579,16 +741,6 @@ static void __hists__output_resort(struct hists *hists, bool threaded)
         }
 }
 
-void hists__output_resort(struct hists *hists)
-{
-        return __hists__output_resort(hists, false);
-}
-
-void hists__output_resort_threaded(struct hists *hists)
-{
-        return __hists__output_resort(hists, true);
-}
-
 static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
                                        enum hist_filter filter)
 {
@@ -711,25 +863,38 @@ int hist_entry__annotate(struct hist_entry *he, size_t privsize)
         return symbol__annotate(he->ms.sym, he->ms.map, privsize);
 }
 
+void events_stats__inc(struct events_stats *stats, u32 type)
+{
+        ++stats->nr_events[0];
+        ++stats->nr_events[type];
+}
+
 void hists__inc_nr_events(struct hists *hists, u32 type)
 {
-        ++hists->stats.nr_events[0];
-        ++hists->stats.nr_events[type];
+        events_stats__inc(&hists->stats, type);
 }
 
 static struct hist_entry *hists__add_dummy_entry(struct hists *hists,
                                                  struct hist_entry *pair)
 {
-        struct rb_node **p = &hists->entries.rb_node;
+        struct rb_root *root;
+        struct rb_node **p;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
         int cmp;
 
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
+
+        p = &root->rb_node;
+
         while (*p != NULL) {
                 parent = *p;
-                he = rb_entry(parent, struct hist_entry, rb_node);
+                he = rb_entry(parent, struct hist_entry, rb_node_in);
 
-                cmp = hist_entry__cmp(pair, he);
+                cmp = hist_entry__collapse(he, pair);
 
                 if (!cmp)
                         goto out;
@@ -744,8 +909,8 @@ static struct hist_entry *hists__add_dummy_entry(struct hists *hists,
         if (he) {
                 memset(&he->stat, 0, sizeof(he->stat));
                 he->hists = hists;
-                rb_link_node(&he->rb_node, parent, p);
-                rb_insert_color(&he->rb_node, &hists->entries);
+                rb_link_node(&he->rb_node_in, parent, p);
+                rb_insert_color(&he->rb_node_in, root);
                 hists__inc_nr_entries(hists, he);
         }
 out:
@@ -755,11 +920,16 @@ out:
 static struct hist_entry *hists__find_entry(struct hists *hists,
                                             struct hist_entry *he)
 {
-        struct rb_node *n = hists->entries.rb_node;
+        struct rb_node *n;
+
+        if (sort__need_collapse)
+                n = hists->entries_collapsed.rb_node;
+        else
+                n = hists->entries_in->rb_node;
 
         while (n) {
-                struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
-                int64_t cmp = hist_entry__cmp(he, iter);
+                struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node_in);
+                int64_t cmp = hist_entry__collapse(iter, he);
 
                 if (cmp < 0)
                         n = n->rb_left;
@@ -777,15 +947,21 @@ static struct hist_entry *hists__find_entry(struct hists *hists,
  */
 void hists__match(struct hists *leader, struct hists *other)
 {
+        struct rb_root *root;
         struct rb_node *nd;
         struct hist_entry *pos, *pair;
 
-        for (nd = rb_first(&leader->entries); nd; nd = rb_next(nd)) {
-                pos  = rb_entry(nd, struct hist_entry, rb_node);
+        if (sort__need_collapse)
+                root = &leader->entries_collapsed;
+        else
+                root = leader->entries_in;
+
+        for (nd = rb_first(root); nd; nd = rb_next(nd)) {
+                pos  = rb_entry(nd, struct hist_entry, rb_node_in);
                 pair = hists__find_entry(other, pos);
 
                 if (pair)
-                        hist__entry_add_pair(pos, pair);
+                        hist_entry__add_pair(pair, pos);
         }
 }
 
@@ -796,17 +972,23 @@ void hists__match(struct hists *leader, struct hists *other)
  */
 int hists__link(struct hists *leader, struct hists *other)
 {
+        struct rb_root *root;
         struct rb_node *nd;
         struct hist_entry *pos, *pair;
 
-        for (nd = rb_first(&other->entries); nd; nd = rb_next(nd)) {
-                pos = rb_entry(nd, struct hist_entry, rb_node);
+        if (sort__need_collapse)
+                root = &other->entries_collapsed;
+        else
+                root = other->entries_in;
+
+        for (nd = rb_first(root); nd; nd = rb_next(nd)) {
+                pos = rb_entry(nd, struct hist_entry, rb_node_in);
 
                 if (!hist_entry__has_pairs(pos)) {
                         pair = hists__add_dummy_entry(leader, pos);
                         if (pair == NULL)
                                 return -1;
-                        hist__entry_add_pair(pair, pos);
+                        hist_entry__add_pair(pos, pair);
                 }
         }
 
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 8b091a51e4a2..2d3790fd99bb 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -43,12 +43,20 @@ enum hist_column {
         HISTC_COMM,
         HISTC_PARENT,
         HISTC_CPU,
+        HISTC_SRCLINE,
         HISTC_MISPREDICT,
         HISTC_SYMBOL_FROM,
         HISTC_SYMBOL_TO,
         HISTC_DSO_FROM,
         HISTC_DSO_TO,
-        HISTC_SRCLINE,
+        HISTC_LOCAL_WEIGHT,
+        HISTC_GLOBAL_WEIGHT,
+        HISTC_MEM_DADDR_SYMBOL,
+        HISTC_MEM_DADDR_DSO,
+        HISTC_MEM_LOCKED,
+        HISTC_MEM_TLB,
+        HISTC_MEM_LVL,
+        HISTC_MEM_SNOOP,
         HISTC_NR_COLS, /* Last entry */
 };
 
@@ -73,7 +81,8 @@ struct hists {
 
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
-                                      struct symbol *parent, u64 period);
+                                      struct symbol *parent, u64 period,
+                                      u64 weight);
 int64_t hist_entry__cmp(struct hist_entry *left, struct hist_entry *right);
 int64_t hist_entry__collapse(struct hist_entry *left, struct hist_entry *right);
 int hist_entry__sort_snprintf(struct hist_entry *self, char *bf, size_t size,
@@ -84,23 +93,29 @@ struct hist_entry *__hists__add_branch_entry(struct hists *self,
                                              struct addr_location *al,
                                              struct symbol *sym_parent,
                                              struct branch_info *bi,
-                                             u64 period);
+                                             u64 period,
+                                             u64 weight);
+
+struct hist_entry *__hists__add_mem_entry(struct hists *self,
+                                          struct addr_location *al,
+                                          struct symbol *sym_parent,
+                                          struct mem_info *mi,
+                                          u64 period,
+                                          u64 weight);
 
 void hists__output_resort(struct hists *self);
-void hists__output_resort_threaded(struct hists *hists);
 void hists__collapse_resort(struct hists *self);
-void hists__collapse_resort_threaded(struct hists *hists);
 
 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel);
-void hists__decay_entries_threaded(struct hists *hists, bool zap_user,
-                                   bool zap_kernel);
 void hists__output_recalc_col_len(struct hists *hists, int max_rows);
 
+void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h);
 void hists__inc_nr_events(struct hists *self, u32 type);
-size_t hists__fprintf_nr_events(struct hists *self, FILE *fp);
+void events_stats__inc(struct events_stats *stats, u32 type);
+size_t events_stats__fprintf(struct events_stats *stats, FILE *fp);
 
 size_t hists__fprintf(struct hists *self, bool show_header, int max_rows,
-                      int max_cols, FILE *fp);
+                      int max_cols, float min_pcnt, FILE *fp);
 
 int hist_entry__inc_addr_samples(struct hist_entry *self, int evidx, u64 addr);
 int hist_entry__annotate(struct hist_entry *self, size_t privsize);
@@ -126,13 +141,19 @@ struct perf_hpp {
 };
 
 struct perf_hpp_fmt {
-        bool cond;
         int (*header)(struct perf_hpp *hpp);
         int (*width)(struct perf_hpp *hpp);
         int (*color)(struct perf_hpp *hpp, struct hist_entry *he);
         int (*entry)(struct perf_hpp *hpp, struct hist_entry *he);
+
+        struct list_head list;
 };
 
+extern struct list_head perf_hpp__list;
+
+#define perf_hpp__for_each_format(format) \
+        list_for_each_entry(format, &perf_hpp__list, list)
+
 extern struct perf_hpp_fmt perf_hpp__format[];
 
 enum {
@@ -148,14 +169,14 @@ enum {
         PERF_HPP__DELTA,
         PERF_HPP__RATIO,
         PERF_HPP__WEIGHTED_DIFF,
-        PERF_HPP__DISPL,
         PERF_HPP__FORMULA,
 
         PERF_HPP__MAX_INDEX
 };
 
 void perf_hpp__init(void);
-void perf_hpp__column_enable(unsigned col, bool enable);
+void perf_hpp__column_register(struct perf_hpp_fmt *format);
+void perf_hpp__column_enable(unsigned col);
 int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
                                 bool color);
 
@@ -167,13 +188,14 @@ struct hist_browser_timer {
         int refresh;
 };
 
-#ifdef NEWT_SUPPORT
+#ifdef SLANG_SUPPORT
 #include "../ui/keysyms.h"
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
+int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
                              struct hist_browser_timer *hbt);
 
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
                                   struct hist_browser_timer *hbt,
+                                  float min_pcnt,
                                   struct perf_session_env *env);
 int script_browse(const char *script_opt);
 #else
@@ -181,6 +203,7 @@ static inline
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
                                   const char *help __maybe_unused,
                                   struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt __maybe_unused,
                                   struct perf_session_env *env __maybe_unused)
 {
         return 0;
@@ -188,7 +211,8 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
 
 static inline int hist_entry__tui_annotate(struct hist_entry *self
                                            __maybe_unused,
-                                           int evidx __maybe_unused,
+                                           struct perf_evsel *evsel
+                                           __maybe_unused,
                                            struct hist_browser_timer *hbt
                                            __maybe_unused)
 {
@@ -200,18 +224,21 @@ static inline int script_browse(const char *script_opt __maybe_unused)
         return 0;
 }
 
-#define K_LEFT -1
-#define K_RIGHT -2
+#define K_LEFT  -1000
+#define K_RIGHT -2000
+#define K_SWITCH_INPUT_DATA -3000
 #endif
 
 #ifdef GTK2_SUPPORT
 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist, const char *help,
-                                  struct hist_browser_timer *hbt __maybe_unused);
+                                  struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt);
 #else
 static inline
 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist __maybe_unused,
                                   const char *help __maybe_unused,
-                                  struct hist_browser_timer *hbt __maybe_unused)
+                                  struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt __maybe_unused)
 {
         return 0;
 }
@@ -219,8 +246,10 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist __maybe_unused,
 
 unsigned int hists__sort_list_width(struct hists *self);
 
-double perf_diff__compute_delta(struct hist_entry *he);
-double perf_diff__compute_ratio(struct hist_entry *he);
-s64 perf_diff__compute_wdiff(struct hist_entry *he);
-int perf_diff__formula(char *buf, size_t size, struct hist_entry *he);
+double perf_diff__compute_delta(struct hist_entry *he, struct hist_entry *pair);
+double perf_diff__compute_ratio(struct hist_entry *he, struct hist_entry *pair);
+s64 perf_diff__compute_wdiff(struct hist_entry *he, struct hist_entry *pair);
+int perf_diff__formula(struct hist_entry *he, struct hist_entry *pair,
+                       char *buf, size_t size);
+double perf_diff__period_percent(struct hist_entry *he, u64 period);
 #endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index a55d8cf083c9..45cf10a562bd 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -14,6 +14,7 @@
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #define BITS_TO_U64(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64))
 #define BITS_TO_U32(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32))
+#define BITS_TO_BYTES(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE)
 
 #define for_each_set_bit(bit, addr, size) \
         for ((bit) = find_first_bit((addr), (size));            \
diff --git a/tools/perf/util/intlist.c b/tools/perf/util/intlist.c
index 9d0740024ba8..11a8d86f7fea 100644
--- a/tools/perf/util/intlist.c
+++ b/tools/perf/util/intlist.c
@@ -59,16 +59,40 @@ void intlist__remove(struct intlist *ilist, struct int_node *node)
 
 struct int_node *intlist__find(struct intlist *ilist, int i)
 {
-        struct int_node *node = NULL;
-        struct rb_node *rb_node = rblist__find(&ilist->rblist, (void *)((long)i));
+        struct int_node *node;
+        struct rb_node *rb_node;
 
+        if (ilist == NULL)
+                return NULL;
+
+        node = NULL;
+        rb_node = rblist__find(&ilist->rblist, (void *)((long)i));
         if (rb_node)
                 node = container_of(rb_node, struct int_node, rb_node);
 
         return node;
 }
 
-struct intlist *intlist__new(void)
+static int intlist__parse_list(struct intlist *ilist, const char *s)
+{
+        char *sep;
+        int err;
+
+        do {
+                long value = strtol(s, &sep, 10);
+                err = -EINVAL;
+                if (*sep != ',' && *sep != '\0')
+                        break;
+                err = intlist__add(ilist, value);
+                if (err)
+                        break;
+                s = sep + 1;
+        } while (*sep != '\0');
+
+        return err;
+}
+
+struct intlist *intlist__new(const char *slist)
 {
         struct intlist *ilist = malloc(sizeof(*ilist));
 
@@ -77,9 +101,15 @@ struct intlist *intlist__new(void)
                 ilist->rblist.node_cmp    = intlist__node_cmp;
                 ilist->rblist.node_new    = intlist__node_new;
                 ilist->rblist.node_delete = intlist__node_delete;
+
+                if (slist && intlist__parse_list(ilist, slist))
+                        goto out_delete;
         }
 
         return ilist;
+out_delete:
+        intlist__delete(ilist);
+        return NULL;
 }
 
 void intlist__delete(struct intlist *ilist)
diff --git a/tools/perf/util/intlist.h b/tools/perf/util/intlist.h
index 6d63ab90db50..62351dad848f 100644
--- a/tools/perf/util/intlist.h
+++ b/tools/perf/util/intlist.h
@@ -15,7 +15,7 @@ struct intlist {
         struct rblist rblist;
 };
 
-struct intlist *intlist__new(void);
+struct intlist *intlist__new(const char *slist);
 void intlist__delete(struct intlist *ilist);
 
 void intlist__remove(struct intlist *ilist, struct int_node *in);
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 1f09d0581e6b..b2ecad6ec46b 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -1,10 +1,15 @@
+#include "callchain.h"
 #include "debug.h"
 #include "event.h"
+#include "evsel.h"
+#include "hist.h"
 #include "machine.h"
 #include "map.h"
+#include "sort.h"
 #include "strlist.h"
 #include "thread.h"
 #include <stdbool.h>
+#include "unwind.h"
 
 int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
 {
@@ -48,6 +53,29 @@ static void dsos__delete(struct list_head *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);
+
+        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);
+        }
+}
+
 void machine__exit(struct machine *machine)
 {
         map_groups__exit(&machine->kmaps);
@@ -63,10 +91,22 @@ void machine__delete(struct machine *machine)
         free(machine);
 }
 
-struct machine *machines__add(struct rb_root *machines, pid_t pid,
+void machines__init(struct machines *machines)
+{
+        machine__init(&machines->host, "", HOST_KERNEL_ID);
+        machines->guests = RB_ROOT;
+}
+
+void machines__exit(struct machines *machines)
+{
+        machine__exit(&machines->host);
+        /* XXX exit guest */
+}
+
+struct machine *machines__add(struct machines *machines, pid_t pid,
                               const char *root_dir)
 {
-        struct rb_node **p = &machines->rb_node;
+        struct rb_node **p = &machines->guests.rb_node;
         struct rb_node *parent = NULL;
         struct machine *pos, *machine = malloc(sizeof(*machine));
 
@@ -88,18 +128,21 @@ struct machine *machines__add(struct rb_root *machines, pid_t pid,
         }
 
         rb_link_node(&machine->rb_node, parent, p);
-        rb_insert_color(&machine->rb_node, machines);
+        rb_insert_color(&machine->rb_node, &machines->guests);
 
         return machine;
 }
 
-struct machine *machines__find(struct rb_root *machines, pid_t pid)
+struct machine *machines__find(struct machines *machines, pid_t pid)
 {
-        struct rb_node **p = &machines->rb_node;
+        struct rb_node **p = &machines->guests.rb_node;
         struct rb_node *parent = NULL;
         struct machine *machine;
         struct machine *default_machine = NULL;
 
+        if (pid == HOST_KERNEL_ID)
+                return &machines->host;
+
         while (*p != NULL) {
                 parent = *p;
                 machine = rb_entry(parent, struct machine, rb_node);
@@ -116,7 +159,7 @@ struct machine *machines__find(struct rb_root *machines, pid_t pid)
         return default_machine;
 }
 
-struct machine *machines__findnew(struct rb_root *machines, pid_t pid)
+struct machine *machines__findnew(struct machines *machines, pid_t pid)
 {
         char path[PATH_MAX];
         const char *root_dir = "";
@@ -150,12 +193,12 @@ out:
         return machine;
 }
 
-void machines__process(struct rb_root *machines,
-                       machine__process_t process, void *data)
+void machines__process_guests(struct machines *machines,
+                              machine__process_t process, void *data)
 {
         struct rb_node *nd;
 
-        for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
                 process(pos, data);
         }
@@ -175,12 +218,14 @@ char *machine__mmap_name(struct machine *machine, char *bf, size_t size)
         return bf;
 }
 
-void machines__set_id_hdr_size(struct rb_root *machines, u16 id_hdr_size)
+void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
 {
         struct rb_node *node;
         struct machine *machine;
 
-        for (node = rb_first(machines); node; node = rb_next(node)) {
+        machines->host.id_hdr_size = id_hdr_size;
+
+        for (node = rb_first(&machines->guests); node; node = rb_next(node)) {
                 machine = rb_entry(node, struct machine, rb_node);
                 machine->id_hdr_size = id_hdr_size;
         }
@@ -264,6 +309,537 @@ int machine__process_lost_event(struct machine *machine __maybe_unused,
         return 0;
 }
 
+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);
+
+        if (dso == NULL)
+                return NULL;
+
+        map = map__new2(start, dso, MAP__FUNCTION);
+        if (map == 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;
+        map_groups__insert(&machine->kmaps, map);
+        return map;
+}
+
+size_t machines__fprintf_dsos(struct machines *machines, FILE *fp)
+{
+        struct rb_node *nd;
+        size_t ret = __dsos__fprintf(&machines->host.kernel_dsos, fp) +
+                     __dsos__fprintf(&machines->host.user_dsos, fp);
+
+        for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret += __dsos__fprintf(&pos->kernel_dsos, fp);
+                ret += __dsos__fprintf(&pos->user_dsos, fp);
+        }
+
+        return ret;
+}
+
+size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
+                                     bool (skip)(struct dso *dso, int parm), int parm)
+{
+        return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, skip, parm) +
+               __dsos__fprintf_buildid(&machine->user_dsos, fp, skip, parm);
+}
+
+size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp,
+                                     bool (skip)(struct dso *dso, int parm), int parm)
+{
+        struct rb_node *nd;
+        size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm);
+
+        for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm);
+        }
+        return ret;
+}
+
+size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
+{
+        int i;
+        size_t printed = 0;
+        struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
+
+        if (kdso->has_build_id) {
+                char filename[PATH_MAX];
+                if (dso__build_id_filename(kdso, filename, sizeof(filename)))
+                        printed += fprintf(fp, "[0] %s\n", filename);
+        }
+
+        for (i = 0; i < vmlinux_path__nr_entries; ++i)
+                printed += fprintf(fp, "[%d] %s\n",
+                                   i + kdso->has_build_id, vmlinux_path[i]);
+
+        return printed;
+}
+
+size_t machine__fprintf(struct machine *machine, FILE *fp)
+{
+        size_t ret = 0;
+        struct rb_node *nd;
+
+        for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
+                struct thread *pos = rb_entry(nd, struct thread, rb_node);
+
+                ret += thread__fprintf(pos, fp);
+        }
+
+        return ret;
+}
+
+static struct dso *machine__get_kernel(struct machine *machine)
+{
+        const char *vmlinux_name = NULL;
+        struct dso *kernel;
+
+        if (machine__is_host(machine)) {
+                vmlinux_name = symbol_conf.vmlinux_name;
+                if (!vmlinux_name)
+                        vmlinux_name = "[kernel.kallsyms]";
+
+                kernel = dso__kernel_findnew(machine, vmlinux_name,
+                                             "[kernel]",
+                                             DSO_TYPE_KERNEL);
+        } else {
+                char bf[PATH_MAX];
+
+                if (machine__is_default_guest(machine))
+                        vmlinux_name = symbol_conf.default_guest_vmlinux_name;
+                if (!vmlinux_name)
+                        vmlinux_name = machine__mmap_name(machine, bf,
+                                                          sizeof(bf));
+
+                kernel = dso__kernel_findnew(machine, vmlinux_name,
+                                             "[guest.kernel]",
+                                             DSO_TYPE_GUEST_KERNEL);
+        }
+
+        if (kernel != NULL && (!kernel->has_build_id))
+                dso__read_running_kernel_build_id(kernel, machine);
+
+        return kernel;
+}
+
+struct process_args {
+        u64 start;
+};
+
+static int symbol__in_kernel(void *arg, const char *name,
+                             char type __maybe_unused, u64 start)
+{
+        struct process_args *args = arg;
+
+        if (strchr(name, '['))
+                return 0;
+
+        args->start = start;
+        return 1;
+}
+
+/* Figure out the start address of kernel map from /proc/kallsyms */
+static u64 machine__get_kernel_start_addr(struct machine *machine)
+{
+        const char *filename;
+        char path[PATH_MAX];
+        struct process_args args;
+
+        if (machine__is_host(machine)) {
+                filename = "/proc/kallsyms";
+        } else {
+                if (machine__is_default_guest(machine))
+                        filename = (char *)symbol_conf.default_guest_kallsyms;
+                else {
+                        sprintf(path, "%s/proc/kallsyms", machine->root_dir);
+                        filename = path;
+                }
+        }
+
+        if (symbol__restricted_filename(filename, "/proc/kallsyms"))
+                return 0;
+
+        if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
+                return 0;
+
+        return args.start;
+}
+
+int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
+{
+        enum map_type type;
+        u64 start = machine__get_kernel_start_addr(machine);
+
+        for (type = 0; type < MAP__NR_TYPES; ++type) {
+                struct kmap *kmap;
+
+                machine->vmlinux_maps[type] = map__new2(start, kernel, type);
+                if (machine->vmlinux_maps[type] == NULL)
+                        return -1;
+
+                machine->vmlinux_maps[type]->map_ip =
+                        machine->vmlinux_maps[type]->unmap_ip =
+                                identity__map_ip;
+                kmap = map__kmap(machine->vmlinux_maps[type]);
+                kmap->kmaps = &machine->kmaps;
+                map_groups__insert(&machine->kmaps,
+                                   machine->vmlinux_maps[type]);
+        }
+
+        return 0;
+}
+
+void machine__destroy_kernel_maps(struct machine *machine)
+{
+        enum map_type type;
+
+        for (type = 0; type < MAP__NR_TYPES; ++type) {
+                struct kmap *kmap;
+
+                if (machine->vmlinux_maps[type] == NULL)
+                        continue;
+
+                kmap = map__kmap(machine->vmlinux_maps[type]);
+                map_groups__remove(&machine->kmaps,
+                                   machine->vmlinux_maps[type]);
+                if (kmap->ref_reloc_sym) {
+                        /*
+                         * ref_reloc_sym is shared among all maps, so free just
+                         * on one of them.
+                         */
+                        if (type == MAP__FUNCTION) {
+                                free((char *)kmap->ref_reloc_sym->name);
+                                kmap->ref_reloc_sym->name = NULL;
+                                free(kmap->ref_reloc_sym);
+                        }
+                        kmap->ref_reloc_sym = NULL;
+                }
+
+                map__delete(machine->vmlinux_maps[type]);
+                machine->vmlinux_maps[type] = NULL;
+        }
+}
+
+int machines__create_guest_kernel_maps(struct machines *machines)
+{
+        int ret = 0;
+        struct dirent **namelist = NULL;
+        int i, items = 0;
+        char path[PATH_MAX];
+        pid_t pid;
+        char *endp;
+
+        if (symbol_conf.default_guest_vmlinux_name ||
+            symbol_conf.default_guest_modules ||
+            symbol_conf.default_guest_kallsyms) {
+                machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
+        }
+
+        if (symbol_conf.guestmount) {
+                items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
+                if (items <= 0)
+                        return -ENOENT;
+                for (i = 0; i < items; i++) {
+                        if (!isdigit(namelist[i]->d_name[0])) {
+                                /* Filter out . and .. */
+                                continue;
+                        }
+                        pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10);
+                        if ((*endp != '\0') ||
+                            (endp == namelist[i]->d_name) ||
+                            (errno == ERANGE)) {
+                                pr_debug("invalid directory (%s). Skipping.\n",
+                                         namelist[i]->d_name);
+                                continue;
+                        }
+                        sprintf(path, "%s/%s/proc/kallsyms",
+                                symbol_conf.guestmount,
+                                namelist[i]->d_name);
+                        ret = access(path, R_OK);
+                        if (ret) {
+                                pr_debug("Can't access file %s\n", path);
+                                goto failure;
+                        }
+                        machines__create_kernel_maps(machines, pid);
+                }
+failure:
+                free(namelist);
+        }
+
+        return ret;
+}
+
+void machines__destroy_kernel_maps(struct machines *machines)
+{
+        struct rb_node *next = rb_first(&machines->guests);
+
+        machine__destroy_kernel_maps(&machines->host);
+
+        while (next) {
+                struct machine *pos = rb_entry(next, struct machine, rb_node);
+
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, &machines->guests);
+                machine__delete(pos);
+        }
+}
+
+int machines__create_kernel_maps(struct machines *machines, pid_t pid)
+{
+        struct machine *machine = machines__findnew(machines, pid);
+
+        if (machine == NULL)
+                return -1;
+
+        return machine__create_kernel_maps(machine);
+}
+
+int machine__load_kallsyms(struct machine *machine, const char *filename,
+                           enum map_type type, symbol_filter_t filter)
+{
+        struct map *map = machine->vmlinux_maps[type];
+        int ret = dso__load_kallsyms(map->dso, filename, map, filter);
+
+        if (ret > 0) {
+                dso__set_loaded(map->dso, type);
+                /*
+                 * Since /proc/kallsyms will have multiple sessions for the
+                 * kernel, with modules between them, fixup the end of all
+                 * sections.
+                 */
+                __map_groups__fixup_end(&machine->kmaps, type);
+        }
+
+        return ret;
+}
+
+int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
+                               symbol_filter_t filter)
+{
+        struct map *map = machine->vmlinux_maps[type];
+        int ret = dso__load_vmlinux_path(map->dso, map, filter);
+
+        if (ret > 0) {
+                dso__set_loaded(map->dso, type);
+                map__reloc_vmlinux(map);
+        }
+
+        return ret;
+}
+
+static void map_groups__fixup_end(struct map_groups *mg)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                __map_groups__fixup_end(mg, i);
+}
+
+static char *get_kernel_version(const char *root_dir)
+{
+        char version[PATH_MAX];
+        FILE *file;
+        char *name, *tmp;
+        const char *prefix = "Linux version ";
+
+        sprintf(version, "%s/proc/version", root_dir);
+        file = fopen(version, "r");
+        if (!file)
+                return NULL;
+
+        version[0] = '\0';
+        tmp = fgets(version, sizeof(version), file);
+        fclose(file);
+
+        name = strstr(version, prefix);
+        if (!name)
+                return NULL;
+        name += strlen(prefix);
+        tmp = strchr(name, ' ');
+        if (tmp)
+                *tmp = '\0';
+
+        return strdup(name);
+}
+
+static int map_groups__set_modules_path_dir(struct map_groups *mg,
+                                const char *dir_name)
+{
+        struct dirent *dent;
+        DIR *dir = opendir(dir_name);
+        int ret = 0;
+
+        if (!dir) {
+                pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
+                return -1;
+        }
+
+        while ((dent = readdir(dir)) != NULL) {
+                char path[PATH_MAX];
+                struct stat st;
+
+                /*sshfs might return bad dent->d_type, so we have to stat*/
+                snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
+                if (stat(path, &st))
+                        continue;
+
+                if (S_ISDIR(st.st_mode)) {
+                        if (!strcmp(dent->d_name, ".") ||
+                            !strcmp(dent->d_name, ".."))
+                                continue;
+
+                        ret = map_groups__set_modules_path_dir(mg, path);
+                        if (ret < 0)
+                                goto out;
+                } else {
+                        char *dot = strrchr(dent->d_name, '.'),
+                             dso_name[PATH_MAX];
+                        struct map *map;
+                        char *long_name;
+
+                        if (dot == NULL || strcmp(dot, ".ko"))
+                                continue;
+                        snprintf(dso_name, sizeof(dso_name), "[%.*s]",
+                                 (int)(dot - dent->d_name), dent->d_name);
+
+                        strxfrchar(dso_name, '-', '_');
+                        map = map_groups__find_by_name(mg, MAP__FUNCTION,
+                                                       dso_name);
+                        if (map == NULL)
+                                continue;
+
+                        long_name = strdup(path);
+                        if (long_name == NULL) {
+                                ret = -1;
+                                goto out;
+                        }
+                        dso__set_long_name(map->dso, long_name);
+                        map->dso->lname_alloc = 1;
+                        dso__kernel_module_get_build_id(map->dso, "");
+                }
+        }
+
+out:
+        closedir(dir);
+        return ret;
+}
+
+static int machine__set_modules_path(struct machine *machine)
+{
+        char *version;
+        char modules_path[PATH_MAX];
+
+        version = get_kernel_version(machine->root_dir);
+        if (!version)
+                return -1;
+
+        snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
+                 machine->root_dir, version);
+        free(version);
+
+        return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
+}
+
+static int machine__create_modules(struct machine *machine)
+{
+        char *line = NULL;
+        size_t n;
+        FILE *file;
+        struct map *map;
+        const char *modules;
+        char path[PATH_MAX];
+
+        if (machine__is_default_guest(machine))
+                modules = symbol_conf.default_guest_modules;
+        else {
+                sprintf(path, "%s/proc/modules", machine->root_dir);
+                modules = path;
+        }
+
+        if (symbol__restricted_filename(path, "/proc/modules"))
+                return -1;
+
+        file = fopen(modules, "r");
+        if (file == NULL)
+                return -1;
+
+        while (!feof(file)) {
+                char name[PATH_MAX];
+                u64 start;
+                char *sep;
+                int line_len;
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
+
+                if (!line)
+                        goto out_failure;
+
+                line[--line_len] = '\0'; /* \n */
+
+                sep = strrchr(line, 'x');
+                if (sep == NULL)
+                        continue;
+
+                hex2u64(sep + 1, &start);
+
+                sep = strchr(line, ' ');
+                if (sep == NULL)
+                        continue;
+
+                *sep = '\0';
+
+                snprintf(name, sizeof(name), "[%s]", line);
+                map = machine__new_module(machine, start, name);
+                if (map == NULL)
+                        goto out_delete_line;
+                dso__kernel_module_get_build_id(map->dso, machine->root_dir);
+        }
+
+        free(line);
+        fclose(file);
+
+        return machine__set_modules_path(machine);
+
+out_delete_line:
+        free(line);
+out_failure:
+        return -1;
+}
+
+int machine__create_kernel_maps(struct machine *machine)
+{
+        struct dso *kernel = machine__get_kernel(machine);
+
+        if (kernel == NULL ||
+            __machine__create_kernel_maps(machine, kernel) < 0)
+                return -1;
+
+        if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
+                if (machine__is_host(machine))
+                        pr_debug("Problems creating module maps, "
+                                 "continuing anyway...\n");
+                else
+                        pr_debug("Problems creating module maps for guest %d, "
+                                 "continuing anyway...\n", machine->pid);
+        }
+
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        map_groups__fixup_end(&machine->kmaps);
+        return 0;
+}
+
 static void machine__set_kernel_mmap_len(struct machine *machine,
                                          union perf_event *event)
 {
@@ -379,6 +955,7 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
         struct thread *thread;
         struct map *map;
+        enum map_type type;
         int ret = 0;
 
         if (dump_trace)
@@ -395,10 +972,17 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         thread = machine__findnew_thread(machine, event->mmap.pid);
         if (thread == NULL)
                 goto out_problem;
+
+        if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
+                type = MAP__VARIABLE;
+        else
+                type = MAP__FUNCTION;
+
         map = map__new(&machine->user_dsos, event->mmap.start,
                         event->mmap.len, event->mmap.pgoff,
                         event->mmap.pid, event->mmap.filename,
-                        MAP__FUNCTION);
+                        type);
+
         if (map == NULL)
                 goto out_problem;
 
@@ -427,6 +1011,17 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event
         return 0;
 }
 
+static void machine__remove_thread(struct machine *machine, struct thread *th)
+{
+        machine->last_match = NULL;
+        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.
+         */
+        list_add_tail(&th->node, &machine->dead_threads);
+}
+
 int machine__process_exit_event(struct machine *machine, union perf_event *event)
 {
         struct thread *thread = machine__find_thread(machine, event->fork.tid);
@@ -462,3 +1057,210 @@ int machine__process_event(struct machine *machine, union perf_event *event)
 
         return ret;
 }
+
+static bool symbol__match_parent_regex(struct symbol *sym)
+{
+        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
+                return 1;
+
+        return 0;
+}
+
+static const u8 cpumodes[] = {
+        PERF_RECORD_MISC_USER,
+        PERF_RECORD_MISC_KERNEL,
+        PERF_RECORD_MISC_GUEST_USER,
+        PERF_RECORD_MISC_GUEST_KERNEL
+};
+#define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
+
+static void ip__resolve_ams(struct machine *machine, struct thread *thread,
+                            struct addr_map_symbol *ams,
+                            u64 ip)
+{
+        struct addr_location al;
+        size_t i;
+        u8 m;
+
+        memset(&al, 0, sizeof(al));
+
+        for (i = 0; i < NCPUMODES; i++) {
+                m = cpumodes[i];
+                /*
+                 * We cannot use the header.misc hint to determine whether a
+                 * branch stack address is user, kernel, guest, hypervisor.
+                 * Branches may straddle the kernel/user/hypervisor boundaries.
+                 * Thus, we have to try consecutively until we find a match
+                 * or else, the symbol is unknown
+                 */
+                thread__find_addr_location(thread, machine, m, MAP__FUNCTION,
+                                ip, &al, NULL);
+                if (al.sym)
+                        goto found;
+        }
+found:
+        ams->addr = ip;
+        ams->al_addr = al.addr;
+        ams->sym = al.sym;
+        ams->map = al.map;
+}
+
+static void ip__resolve_data(struct machine *machine, struct thread *thread,
+                             u8 m, struct addr_map_symbol *ams, u64 addr)
+{
+        struct addr_location al;
+
+        memset(&al, 0, sizeof(al));
+
+        thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr, &al,
+                                   NULL);
+        ams->addr = addr;
+        ams->al_addr = al.addr;
+        ams->sym = al.sym;
+        ams->map = al.map;
+}
+
+struct mem_info *machine__resolve_mem(struct machine *machine,
+                                      struct thread *thr,
+                                      struct perf_sample *sample,
+                                      u8 cpumode)
+{
+        struct mem_info *mi = zalloc(sizeof(*mi));
+
+        if (!mi)
+                return NULL;
+
+        ip__resolve_ams(machine, thr, &mi->iaddr, sample->ip);
+        ip__resolve_data(machine, thr, cpumode, &mi->daddr, sample->addr);
+        mi->data_src.val = sample->data_src;
+
+        return mi;
+}
+
+struct branch_info *machine__resolve_bstack(struct machine *machine,
+                                            struct thread *thr,
+                                            struct branch_stack *bs)
+{
+        struct branch_info *bi;
+        unsigned int i;
+
+        bi = calloc(bs->nr, sizeof(struct branch_info));
+        if (!bi)
+                return NULL;
+
+        for (i = 0; i < bs->nr; i++) {
+                ip__resolve_ams(machine, thr, &bi[i].to, bs->entries[i].to);
+                ip__resolve_ams(machine, thr, &bi[i].from, bs->entries[i].from);
+                bi[i].flags = bs->entries[i].flags;
+        }
+        return bi;
+}
+
+static int machine__resolve_callchain_sample(struct machine *machine,
+                                             struct thread *thread,
+                                             struct ip_callchain *chain,
+                                             struct symbol **parent)
+
+{
+        u8 cpumode = PERF_RECORD_MISC_USER;
+        unsigned int i;
+        int err;
+
+        callchain_cursor_reset(&callchain_cursor);
+
+        if (chain->nr > PERF_MAX_STACK_DEPTH) {
+                pr_warning("corrupted callchain. skipping...\n");
+                return 0;
+        }
+
+        for (i = 0; i < chain->nr; i++) {
+                u64 ip;
+                struct addr_location al;
+
+                if (callchain_param.order == ORDER_CALLEE)
+                        ip = chain->ips[i];
+                else
+                        ip = chain->ips[chain->nr - i - 1];
+
+                if (ip >= PERF_CONTEXT_MAX) {
+                        switch (ip) {
+                        case PERF_CONTEXT_HV:
+                                cpumode = PERF_RECORD_MISC_HYPERVISOR;
+                                break;
+                        case PERF_CONTEXT_KERNEL:
+                                cpumode = PERF_RECORD_MISC_KERNEL;
+                                break;
+                        case PERF_CONTEXT_USER:
+                                cpumode = PERF_RECORD_MISC_USER;
+                                break;
+                        default:
+                                pr_debug("invalid callchain context: "
+                                         "%"PRId64"\n", (s64) ip);
+                                /*
+                                 * It seems the callchain is corrupted.
+                                 * Discard all.
+                                 */
+                                callchain_cursor_reset(&callchain_cursor);
+                                return 0;
+                        }
+                        continue;
+                }
+
+                al.filtered = false;
+                thread__find_addr_location(thread, machine, cpumode,
+                                           MAP__FUNCTION, ip, &al, NULL);
+                if (al.sym != NULL) {
+                        if (sort__has_parent && !*parent &&
+                            symbol__match_parent_regex(al.sym))
+                                *parent = al.sym;
+                        if (!symbol_conf.use_callchain)
+                                break;
+                }
+
+                err = callchain_cursor_append(&callchain_cursor,
+                                              ip, al.map, al.sym);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int unwind_entry(struct unwind_entry *entry, void *arg)
+{
+        struct callchain_cursor *cursor = arg;
+        return callchain_cursor_append(cursor, entry->ip,
+                                       entry->map, entry->sym);
+}
+
+int machine__resolve_callchain(struct machine *machine,
+                               struct perf_evsel *evsel,
+                               struct thread *thread,
+                               struct perf_sample *sample,
+                               struct symbol **parent)
+
+{
+        int ret;
+
+        callchain_cursor_reset(&callchain_cursor);
+
+        ret = machine__resolve_callchain_sample(machine, thread,
+                                                sample->callchain, parent);
+        if (ret)
+                return ret;
+
+        /* Can we do dwarf post unwind? */
+        if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
+              (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
+                return 0;
+
+        /* Bail out if nothing was captured. */
+        if ((!sample->user_regs.regs) ||
+            (!sample->user_stack.size))
+                return 0;
+
+        return unwind__get_entries(unwind_entry, &callchain_cursor, machine,
+                                   thread, evsel->attr.sample_regs_user,
+                                   sample);
+
+}
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index b7cde7467d55..77940680f1fc 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -47,26 +47,38 @@ int machine__process_event(struct machine *machine, union perf_event *event);
 
 typedef void (*machine__process_t)(struct machine *machine, void *data);
 
-void machines__process(struct rb_root *machines,
-                       machine__process_t process, void *data);
+struct machines {
+        struct machine host;
+        struct rb_root guests;
+};
+
+void machines__init(struct machines *machines);
+void machines__exit(struct machines *machines);
 
-struct machine *machines__add(struct rb_root *machines, pid_t pid,
+void machines__process_guests(struct machines *machines,
+                              machine__process_t process, void *data);
+
+struct machine *machines__add(struct machines *machines, pid_t pid,
                               const char *root_dir);
-struct machine *machines__find_host(struct rb_root *machines);
-struct machine *machines__find(struct rb_root *machines, pid_t pid);
-struct machine *machines__findnew(struct rb_root *machines, pid_t pid);
+struct machine *machines__find_host(struct machines *machines);
+struct machine *machines__find(struct machines *machines, pid_t pid);
+struct machine *machines__findnew(struct machines *machines, pid_t pid);
 
-void machines__set_id_hdr_size(struct rb_root *machines, u16 id_hdr_size);
+void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size);
 char *machine__mmap_name(struct machine *machine, char *bf, size_t size);
 
 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);
 
-
 struct branch_info *machine__resolve_bstack(struct machine *machine,
                                             struct thread *thread,
                                             struct branch_stack *bs);
+struct mem_info *machine__resolve_mem(struct machine *machine,
+                                      struct thread *thread,
+                                      struct perf_sample *sample, u8 cpumode);
 int machine__resolve_callchain(struct machine *machine,
                                struct perf_evsel *evsel,
                                struct thread *thread,
@@ -88,7 +100,6 @@ static inline bool machine__is_host(struct machine *machine)
 }
 
 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid);
-void machine__remove_thread(struct machine *machine, struct thread *th);
 
 size_t machine__fprintf(struct machine *machine, FILE *fp);
 
@@ -129,19 +140,19 @@ int machine__load_kallsyms(struct machine *machine, const char *filename,
 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
                                symbol_filter_t filter);
 
-size_t machine__fprintf_dsos_buildid(struct machine *machine,
-                                     FILE *fp, bool with_hits);
-size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp);
-size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
-                                      FILE *fp, bool with_hits);
+size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
+                                     bool (skip)(struct dso *dso, int parm), int parm);
+size_t machines__fprintf_dsos(struct machines *machines, FILE *fp);
+size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp,
+                                     bool (skip)(struct dso *dso, int parm), int parm);
 
 void machine__destroy_kernel_maps(struct machine *machine);
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel);
 int machine__create_kernel_maps(struct machine *machine);
 
-int machines__create_kernel_maps(struct rb_root *machines, pid_t pid);
-int machines__create_guest_kernel_maps(struct rb_root *machines);
-void machines__destroy_guest_kernel_maps(struct rb_root *machines);
+int machines__create_kernel_maps(struct machines *machines, pid_t pid);
+int machines__create_guest_kernel_maps(struct machines *machines);
+void machines__destroy_kernel_maps(struct machines *machines);
 
 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp);
 
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 0328d45c4f2a..8bcdf9e54089 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -11,6 +11,7 @@
 #include "strlist.h"
 #include "vdso.h"
 #include "build-id.h"
+#include <linux/string.h>
 
 const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__FUNCTION] = "Functions",
@@ -19,7 +20,9 @@ const char *map_type__name[MAP__NR_TYPES] = {
 
 static inline int is_anon_memory(const char *filename)
 {
-        return strcmp(filename, "//anon") == 0;
+        return !strcmp(filename, "//anon") ||
+               !strcmp(filename, "/dev/zero (deleted)") ||
+               !strcmp(filename, "/anon_hugepage (deleted)");
 }
 
 static inline int is_no_dso_memory(const char *filename)
@@ -28,29 +31,29 @@ static inline int is_no_dso_memory(const char *filename)
                !strcmp(filename, "[heap]");
 }
 
-void map__init(struct map *self, enum map_type type,
+void map__init(struct map *map, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso)
 {
-        self->type     = type;
-        self->start    = start;
-        self->end      = end;
-        self->pgoff    = pgoff;
-        self->dso      = dso;
-        self->map_ip   = map__map_ip;
-        self->unmap_ip = map__unmap_ip;
-        RB_CLEAR_NODE(&self->rb_node);
-        self->groups   = NULL;
-        self->referenced = false;
-        self->erange_warned = false;
+        map->type     = type;
+        map->start    = start;
+        map->end      = end;
+        map->pgoff    = pgoff;
+        map->dso      = dso;
+        map->map_ip   = map__map_ip;
+        map->unmap_ip = map__unmap_ip;
+        RB_CLEAR_NODE(&map->rb_node);
+        map->groups   = NULL;
+        map->referenced = false;
+        map->erange_warned = false;
 }
 
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                      u64 pgoff, u32 pid, char *filename,
                      enum map_type type)
 {
-        struct map *self = malloc(sizeof(*self));
+        struct map *map = malloc(sizeof(*map));
 
-        if (self != NULL) {
+        if (map != NULL) {
                 char newfilename[PATH_MAX];
                 struct dso *dso;
                 int anon, no_dso, vdso;
@@ -73,10 +76,10 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                 if (dso == NULL)
                         goto out_delete;
 
-                map__init(self, type, start, start + len, pgoff, dso);
+                map__init(map, type, start, start + len, pgoff, dso);
 
                 if (anon || no_dso) {
-                        self->map_ip = self->unmap_ip = identity__map_ip;
+                        map->map_ip = map->unmap_ip = identity__map_ip;
 
                         /*
                          * Set memory without DSO as loaded. All map__find_*
@@ -84,12 +87,12 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                          * unnecessary map__load warning.
                          */
                         if (no_dso)
-                                dso__set_loaded(dso, self->type);
+                                dso__set_loaded(dso, map->type);
                 }
         }
-        return self;
+        return map;
 out_delete:
-        free(self);
+        free(map);
         return NULL;
 }
 
@@ -112,48 +115,48 @@ struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
         return map;
 }
 
-void map__delete(struct map *self)
+void map__delete(struct map *map)
 {
-        free(self);
+        free(map);
 }
 
-void map__fixup_start(struct map *self)
+void map__fixup_start(struct map *map)
 {
-        struct rb_root *symbols = &self->dso->symbols[self->type];
+        struct rb_root *symbols = &map->dso->symbols[map->type];
         struct rb_node *nd = rb_first(symbols);
         if (nd != NULL) {
                 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
-                self->start = sym->start;
+                map->start = sym->start;
         }
 }
 
-void map__fixup_end(struct map *self)
+void map__fixup_end(struct map *map)
 {
-        struct rb_root *symbols = &self->dso->symbols[self->type];
+        struct rb_root *symbols = &map->dso->symbols[map->type];
         struct rb_node *nd = rb_last(symbols);
         if (nd != NULL) {
                 struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
-                self->end = sym->end;
+                map->end = sym->end;
         }
 }
 
 #define DSO__DELETED "(deleted)"
 
-int map__load(struct map *self, symbol_filter_t filter)
+int map__load(struct map *map, symbol_filter_t filter)
 {
-        const char *name = self->dso->long_name;
+        const char *name = map->dso->long_name;
         int nr;
 
-        if (dso__loaded(self->dso, self->type))
+        if (dso__loaded(map->dso, map->type))
                 return 0;
 
-        nr = dso__load(self->dso, self, filter);
+        nr = dso__load(map->dso, map, filter);
         if (nr < 0) {
-                if (self->dso->has_build_id) {
+                if (map->dso->has_build_id) {
                         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 
-                        build_id__sprintf(self->dso->build_id,
-                                          sizeof(self->dso->build_id),
+                        build_id__sprintf(map->dso->build_id,
+                                          sizeof(map->dso->build_id),
                                           sbuild_id);
                         pr_warning("%s with build id %s not found",
                                    name, sbuild_id);
@@ -183,43 +186,36 @@ int map__load(struct map *self, symbol_filter_t filter)
          * Only applies to the kernel, as its symtabs aren't relative like the
          * module ones.
          */
-        if (self->dso->kernel)
-                map__reloc_vmlinux(self);
+        if (map->dso->kernel)
+                map__reloc_vmlinux(map);
 
         return 0;
 }
 
-struct symbol *map__find_symbol(struct map *self, u64 addr,
+struct symbol *map__find_symbol(struct map *map, u64 addr,
                                 symbol_filter_t filter)
 {
-        if (map__load(self, filter) < 0)
+        if (map__load(map, filter) < 0)
                 return NULL;
 
-        return dso__find_symbol(self->dso, self->type, addr);
+        return dso__find_symbol(map->dso, map->type, addr);
 }
 
-struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+struct symbol *map__find_symbol_by_name(struct map *map, const char *name,
                                         symbol_filter_t filter)
 {
-        if (map__load(self, filter) < 0)
+        if (map__load(map, filter) < 0)
                 return NULL;
 
-        if (!dso__sorted_by_name(self->dso, self->type))
-                dso__sort_by_name(self->dso, self->type);
+        if (!dso__sorted_by_name(map->dso, map->type))
+                dso__sort_by_name(map->dso, map->type);
 
-        return dso__find_symbol_by_name(self->dso, self->type, name);
+        return dso__find_symbol_by_name(map->dso, map->type, name);
 }
 
-struct map *map__clone(struct map *self)
+struct map *map__clone(struct map *map)
 {
-        struct map *map = malloc(sizeof(*self));
-
-        if (!map)
-                return NULL;
-
-        memcpy(map, self, sizeof(*self));
-
-        return map;
+        return memdup(map, sizeof(*map));
 }
 
 int map__overlap(struct map *l, struct map *r)
@@ -236,10 +232,10 @@ int map__overlap(struct map *l, struct map *r)
         return 0;
 }
 
-size_t map__fprintf(struct map *self, FILE *fp)
+size_t map__fprintf(struct map *map, FILE *fp)
 {
         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s\n",
-                       self->start, self->end, self->pgoff, self->dso->name);
+                       map->start, map->end, map->pgoff, map->dso->name);
 }
 
 size_t map__fprintf_dsoname(struct map *map, FILE *fp)
@@ -527,9 +523,9 @@ static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
         return ip - (s64)map->pgoff;
 }
 
-void map__reloc_vmlinux(struct map *self)
+void map__reloc_vmlinux(struct map *map)
 {
-        struct kmap *kmap = map__kmap(self);
+        struct kmap *kmap = map__kmap(map);
         s64 reloc;
 
         if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
@@ -541,9 +537,9 @@ void map__reloc_vmlinux(struct map *self)
         if (!reloc)
                 return;
 
-        self->map_ip   = map__reloc_map_ip;
-        self->unmap_ip = map__reloc_unmap_ip;
-        self->pgoff    = reloc;
+        map->map_ip   = map__reloc_map_ip;
+        map->unmap_ip = map__reloc_unmap_ip;
+        map->pgoff    = reloc;
 }
 
 void maps__insert(struct rb_root *maps, struct map *map)
@@ -566,9 +562,9 @@ void maps__insert(struct rb_root *maps, struct map *map)
         rb_insert_color(&map->rb_node, maps);
 }
 
-void maps__remove(struct rb_root *self, struct map *map)
+void maps__remove(struct rb_root *maps, struct map *map)
 {
-        rb_erase(&map->rb_node, self);
+        rb_erase(&map->rb_node, maps);
 }
 
 struct map *maps__find(struct rb_root *maps, u64 ip)
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index bcb39e2a6965..a887f2c9dfbb 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -57,9 +57,9 @@ struct map_groups {
         struct machine   *machine;
 };
 
-static inline struct kmap *map__kmap(struct map *self)
+static inline struct kmap *map__kmap(struct map *map)
 {
-        return (struct kmap *)(self + 1);
+        return (struct kmap *)(map + 1);
 }
 
 static inline u64 map__map_ip(struct map *map, u64 ip)
@@ -85,27 +85,27 @@ struct symbol;
 
 typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
 
-void map__init(struct map *self, enum map_type type,
+void map__init(struct map *map, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso);
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                      u64 pgoff, u32 pid, char *filename,
                      enum map_type type);
 struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
-void map__delete(struct map *self);
-struct map *map__clone(struct map *self);
+void map__delete(struct map *map);
+struct map *map__clone(struct map *map);
 int map__overlap(struct map *l, struct map *r);
-size_t map__fprintf(struct map *self, FILE *fp);
+size_t map__fprintf(struct map *map, FILE *fp);
 size_t map__fprintf_dsoname(struct map *map, FILE *fp);
 
-int map__load(struct map *self, symbol_filter_t filter);
-struct symbol *map__find_symbol(struct map *self,
+int map__load(struct map *map, symbol_filter_t filter);
+struct symbol *map__find_symbol(struct map *map,
                                 u64 addr, symbol_filter_t filter);
-struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+struct symbol *map__find_symbol_by_name(struct map *map, const char *name,
                                         symbol_filter_t filter);
-void map__fixup_start(struct map *self);
-void map__fixup_end(struct map *self);
+void map__fixup_start(struct map *map);
+void map__fixup_end(struct map *map);
 
-void map__reloc_vmlinux(struct map *self);
+void map__reloc_vmlinux(struct map *map);
 
 size_t __map_groups__fprintf_maps(struct map_groups *mg,
                                   enum map_type type, int verbose, FILE *fp);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 2d8d53bec17e..6c8bb0fb189b 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -10,7 +10,7 @@
 #include "symbol.h"
 #include "cache.h"
 #include "header.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "parse-events-bison.h"
 #define YY_EXTRA_TYPE int
 #include "parse-events-flex.h"
@@ -380,8 +380,8 @@ static int add_tracepoint(struct list_head **listp, int *idx,
         return 0;
 }
 
-static int add_tracepoint_multi(struct list_head **list, int *idx,
-                                char *sys_name, char *evt_name)
+static int add_tracepoint_multi_event(struct list_head **list, int *idx,
+                                      char *sys_name, char *evt_name)
 {
         char evt_path[MAXPATHLEN];
         struct dirent *evt_ent;
@@ -408,6 +408,47 @@ static int add_tracepoint_multi(struct list_head **list, int *idx,
                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
         }
 
+        closedir(evt_dir);
+        return ret;
+}
+
+static int add_tracepoint_event(struct list_head **list, int *idx,
+                                char *sys_name, char *evt_name)
+{
+        return strpbrk(evt_name, "*?") ?
+               add_tracepoint_multi_event(list, idx, sys_name, evt_name) :
+               add_tracepoint(list, idx, sys_name, evt_name);
+}
+
+static int add_tracepoint_multi_sys(struct list_head **list, int *idx,
+                                    char *sys_name, char *evt_name)
+{
+        struct dirent *events_ent;
+        DIR *events_dir;
+        int ret = 0;
+
+        events_dir = opendir(tracing_events_path);
+        if (!events_dir) {
+                perror("Can't open event dir");
+                return -1;
+        }
+
+        while (!ret && (events_ent = readdir(events_dir))) {
+                if (!strcmp(events_ent->d_name, ".")
+                    || !strcmp(events_ent->d_name, "..")
+                    || !strcmp(events_ent->d_name, "enable")
+                    || !strcmp(events_ent->d_name, "header_event")
+                    || !strcmp(events_ent->d_name, "header_page"))
+                        continue;
+
+                if (!strglobmatch(events_ent->d_name, sys_name))
+                        continue;
+
+                ret = add_tracepoint_event(list, idx, events_ent->d_name,
+                                           evt_name);
+        }
+
+        closedir(events_dir);
         return ret;
 }
 
@@ -420,9 +461,10 @@ int parse_events_add_tracepoint(struct list_head **list, int *idx,
         if (ret)
                 return ret;
 
-        return strpbrk(event, "*?") ?
-               add_tracepoint_multi(list, idx, sys, event) :
-               add_tracepoint(list, idx, sys, event);
+        if (strpbrk(sys, "*?"))
+                return add_tracepoint_multi_sys(list, idx, sys, event);
+        else
+                return add_tracepoint_event(list, idx, sys, event);
 }
 
 static int
@@ -492,7 +534,7 @@ int parse_events_add_breakpoint(struct list_head **list, int *idx,
 }
 
 static int config_term(struct perf_event_attr *attr,
-                       struct parse_events__term *term)
+                       struct parse_events_term *term)
 {
 #define CHECK_TYPE_VAL(type)                                    \
 do {                                                            \
@@ -537,7 +579,7 @@ do {								\
 static int config_attr(struct perf_event_attr *attr,
                        struct list_head *head, int fail)
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
         list_for_each_entry(term, head, list)
                 if (config_term(attr, term) && fail)
@@ -563,14 +605,14 @@ int parse_events_add_numeric(struct list_head **list, int *idx,
         return add_event(list, idx, &attr, NULL);
 }
 
-static int parse_events__is_name_term(struct parse_events__term *term)
+static int parse_events__is_name_term(struct parse_events_term *term)
 {
         return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
 }
 
 static char *pmu_event_name(struct list_head *head_terms)
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
         list_for_each_entry(term, head_terms, list)
                 if (parse_events__is_name_term(term))
@@ -657,14 +699,6 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
         int exclude = eu | ek | eh;
         int exclude_GH = evsel ? evsel->exclude_GH : 0;
 
-        /*
-         * We are here for group and 'GH' was not set as event
-         * modifier and whatever event/group modifier override
-         * default 'GH' setup.
-         */
-        if (evsel && !exclude_GH)
-                eH = eG = 0;
-
         memset(mod, 0, sizeof(*mod));
 
         while (*str) {
@@ -814,7 +848,7 @@ static int parse_events__scanner(const char *str, void *data, int start_token)
  */
 int parse_events_terms(struct list_head *terms, const char *str)
 {
-        struct parse_events_data__terms data = {
+        struct parse_events_terms data = {
                 .terms = NULL,
         };
         int ret;
@@ -830,10 +864,9 @@ int parse_events_terms(struct list_head *terms, const char *str)
         return ret;
 }
 
-int parse_events(struct perf_evlist *evlist, const char *str,
-                 int unset __maybe_unused)
+int parse_events(struct perf_evlist *evlist, const char *str)
 {
-        struct parse_events_data__events data = {
+        struct parse_events_evlist data = {
                 .list = LIST_HEAD_INIT(data.list),
                 .idx  = evlist->nr_entries,
         };
@@ -843,6 +876,7 @@ int parse_events(struct perf_evlist *evlist, const char *str,
         if (!ret) {
                 int entries = data.idx - evlist->nr_entries;
                 perf_evlist__splice_list_tail(evlist, &data.list, entries);
+                evlist->nr_groups += data.nr_groups;
                 return 0;
         }
 
@@ -858,7 +892,7 @@ int parse_events_option(const struct option *opt, const char *str,
                         int unset __maybe_unused)
 {
         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
-        int ret = parse_events(evlist, str, unset);
+        int ret = parse_events(evlist, str);
 
         if (ret) {
                 fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
@@ -1121,16 +1155,16 @@ void print_events(const char *event_glob, bool name_only)
         print_tracepoint_events(NULL, NULL, name_only);
 }
 
-int parse_events__is_hardcoded_term(struct parse_events__term *term)
+int parse_events__is_hardcoded_term(struct parse_events_term *term)
 {
         return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
 }
 
-static int new_term(struct parse_events__term **_term, int type_val,
+static int new_term(struct parse_events_term **_term, int type_val,
                     int type_term, char *config,
                     char *str, u64 num)
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
         term = zalloc(sizeof(*term));
         if (!term)
@@ -1156,21 +1190,21 @@ static int new_term(struct parse_events__term **_term, int type_val,
         return 0;
 }
 
-int parse_events__term_num(struct parse_events__term **term,
+int parse_events_term__num(struct parse_events_term **term,
                            int type_term, char *config, u64 num)
 {
         return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
                         config, NULL, num);
 }
 
-int parse_events__term_str(struct parse_events__term **term,
+int parse_events_term__str(struct parse_events_term **term,
                            int type_term, char *config, char *str)
 {
         return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
                         config, str, 0);
 }
 
-int parse_events__term_sym_hw(struct parse_events__term **term,
+int parse_events_term__sym_hw(struct parse_events_term **term,
                               char *config, unsigned idx)
 {
         struct event_symbol *sym;
@@ -1188,8 +1222,8 @@ int parse_events__term_sym_hw(struct parse_events__term **term,
                                 (char *) "event", (char *) sym->symbol, 0);
 }
 
-int parse_events__term_clone(struct parse_events__term **new,
-                             struct parse_events__term *term)
+int parse_events_term__clone(struct parse_events_term **new,
+                             struct parse_events_term *term)
 {
         return new_term(new, term->type_val, term->type_term, term->config,
                         term->val.str, term->val.num);
@@ -1197,7 +1231,7 @@ int parse_events__term_clone(struct parse_events__term **new,
 
 void parse_events__free_terms(struct list_head *terms)
 {
-        struct parse_events__term *term, *h;
+        struct parse_events_term *term, *h;
 
         list_for_each_entry_safe(term, h, terms, list)
                 free(term);
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index b7af80b8bdda..8a4859315fd9 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -29,8 +29,7 @@ const char *event_type(int type);
 
 extern int parse_events_option(const struct option *opt, const char *str,
                                int unset);
-extern int parse_events(struct perf_evlist *evlist, const char *str,
-                        int unset);
+extern int parse_events(struct perf_evlist *evlist, const char *str);
 extern int parse_events_terms(struct list_head *terms, const char *str);
 extern int parse_filter(const struct option *opt, const char *str, int unset);
 
@@ -51,7 +50,7 @@ enum {
         PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
 };
 
-struct parse_events__term {
+struct parse_events_term {
         char *config;
         union {
                 char *str;
@@ -62,24 +61,25 @@ struct parse_events__term {
         struct list_head list;
 };
 
-struct parse_events_data__events {
+struct parse_events_evlist {
         struct list_head list;
         int idx;
+        int nr_groups;
 };
 
-struct parse_events_data__terms {
+struct parse_events_terms {
         struct list_head *terms;
 };
 
-int parse_events__is_hardcoded_term(struct parse_events__term *term);
-int parse_events__term_num(struct parse_events__term **_term,
+int parse_events__is_hardcoded_term(struct parse_events_term *term);
+int parse_events_term__num(struct parse_events_term **_term,
                            int type_term, char *config, u64 num);
-int parse_events__term_str(struct parse_events__term **_term,
+int parse_events_term__str(struct parse_events_term **_term,
                            int type_term, char *config, char *str);
-int parse_events__term_sym_hw(struct parse_events__term **term,
+int parse_events_term__sym_hw(struct parse_events_term **term,
                               char *config, unsigned idx);
-int parse_events__term_clone(struct parse_events__term **new,
-                             struct parse_events__term *term);
+int parse_events_term__clone(struct parse_events_term **new,
+                             struct parse_events_term *term);
 void parse_events__free_terms(struct list_head *terms);
 int parse_events__modifier_event(struct list_head *list, char *str, bool add);
 int parse_events__modifier_group(struct list_head *list, char *event_mod);
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 0f9914ae6bac..afc44c18dfe1 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -1,5 +1,4 @@
 %pure-parser
-%name-prefix "parse_events_"
 %parse-param {void *_data}
 %parse-param {void *scanner}
 %lex-param {void* scanner}
@@ -23,6 +22,14 @@ do { \
                 YYABORT; \
 } while (0)
 
+static inc_group_count(struct list_head *list,
+                       struct parse_events_evlist *data)
+{
+        /* Count groups only have more than 1 members */
+        if (!list_is_last(list->next, list))
+                data->nr_groups++;
+}
+
 %}
 
 %token PE_START_EVENTS PE_START_TERMS
@@ -68,7 +75,7 @@ do { \
         char *str;
         u64 num;
         struct list_head *head;
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 }
 %%
 
@@ -79,7 +86,7 @@ PE_START_TERMS  start_terms
 
 start_events: groups
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
 
         parse_events_update_lists($1, &data->list);
 }
@@ -123,6 +130,7 @@ PE_NAME '{' events '}'
 {
         struct list_head *list = $3;
 
+        inc_group_count(list, _data);
         parse_events__set_leader($1, list);
         $$ = list;
 }
@@ -131,6 +139,7 @@ PE_NAME '{' events '}'
 {
         struct list_head *list = $2;
 
+        inc_group_count(list, _data);
         parse_events__set_leader(NULL, list);
         $$ = list;
 }
@@ -186,7 +195,7 @@ event_def: event_pmu |
 event_pmu:
 PE_NAME '/' event_config '/'
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_pmu(&list, &data->idx, $1, $3));
@@ -202,7 +211,7 @@ PE_VALUE_SYM_SW
 event_legacy_symbol:
 value_sym '/' event_config '/'
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
         int type = $1 >> 16;
         int config = $1 & 255;
@@ -215,7 +224,7 @@ value_sym '/' event_config '/'
 |
 value_sym sep_slash_dc
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
         int type = $1 >> 16;
         int config = $1 & 255;
@@ -228,7 +237,7 @@ value_sym sep_slash_dc
 event_legacy_cache:
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, $5));
@@ -237,7 +246,7 @@ PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
 |
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, NULL));
@@ -246,7 +255,7 @@ PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
 |
 PE_NAME_CACHE_TYPE
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, NULL, NULL));
@@ -256,7 +265,7 @@ PE_NAME_CACHE_TYPE
 event_legacy_mem:
 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
@@ -266,7 +275,7 @@ PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 |
 PE_PREFIX_MEM PE_VALUE sep_dc
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
@@ -277,7 +286,7 @@ PE_PREFIX_MEM PE_VALUE sep_dc
 event_legacy_tracepoint:
 PE_NAME ':' PE_NAME
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_tracepoint(&list, &data->idx, $1, $3));
@@ -287,7 +296,7 @@ PE_NAME ':' PE_NAME
 event_legacy_numeric:
 PE_VALUE ':' PE_VALUE
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_numeric(&list, &data->idx, (u32)$1, $3, NULL));
@@ -297,7 +306,7 @@ PE_VALUE ':' PE_VALUE
 event_legacy_raw:
 PE_RAW
 {
-        struct parse_events_data__events *data = _data;
+        struct parse_events_evlist *data = _data;
         struct list_head *list = NULL;
 
         ABORT_ON(parse_events_add_numeric(&list, &data->idx,
@@ -307,7 +316,7 @@ PE_RAW
 
 start_terms: event_config
 {
-        struct parse_events_data__terms *data = _data;
+        struct parse_events_terms *data = _data;
         data->terms = $1;
 }
 
@@ -315,7 +324,7 @@ event_config:
 event_config ',' event_term
 {
         struct list_head *head = $1;
-        struct parse_events__term *term = $3;
+        struct parse_events_term *term = $3;
 
         ABORT_ON(!head);
         list_add_tail(&term->list, head);
@@ -325,7 +334,7 @@ event_config ',' event_term
 event_term
 {
         struct list_head *head = malloc(sizeof(*head));
-        struct parse_events__term *term = $1;
+        struct parse_events_term *term = $1;
 
         ABORT_ON(!head);
         INIT_LIST_HEAD(head);
@@ -336,70 +345,70 @@ event_term
 event_term:
 PE_NAME '=' PE_NAME
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
-        ABORT_ON(parse_events__term_str(&term, PARSE_EVENTS__TERM_TYPE_USER,
+        ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_USER,
                                         $1, $3));
         $$ = term;
 }
 |
 PE_NAME '=' PE_VALUE
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
-        ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+        ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
                                         $1, $3));
         $$ = term;
 }
 |
 PE_NAME '=' PE_VALUE_SYM_HW
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
         int config = $3 & 255;
 
-        ABORT_ON(parse_events__term_sym_hw(&term, $1, config));
+        ABORT_ON(parse_events_term__sym_hw(&term, $1, config));
         $$ = term;
 }
 |
 PE_NAME
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
-        ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+        ABORT_ON(parse_events_term__num(&term, PARSE_EVENTS__TERM_TYPE_USER,
                                         $1, 1));
         $$ = term;
 }
 |
 PE_VALUE_SYM_HW
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events__term_sym_hw(&term, NULL, config));
+        ABORT_ON(parse_events_term__sym_hw(&term, NULL, config));
         $$ = term;
 }
 |
 PE_TERM '=' PE_NAME
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
-        ABORT_ON(parse_events__term_str(&term, (int)$1, NULL, $3));
+        ABORT_ON(parse_events_term__str(&term, (int)$1, NULL, $3));
         $$ = term;
 }
 |
 PE_TERM '=' PE_VALUE
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
-        ABORT_ON(parse_events__term_num(&term, (int)$1, NULL, $3));
+        ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, $3));
         $$ = term;
 }
 |
 PE_TERM
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
-        ABORT_ON(parse_events__term_num(&term, (int)$1, NULL, 1));
+        ABORT_ON(parse_events_term__num(&term, (int)$1, NULL, 1));
         $$ = term;
 }
 
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 9bdc60c6f138..4c6f9c490a8d 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -1,4 +1,3 @@
-
 #include <linux/list.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -11,6 +10,19 @@
 #include "parse-events.h"
 #include "cpumap.h"
 
+struct perf_pmu_alias {
+        char *name;
+        struct list_head terms;
+        struct list_head list;
+};
+
+struct perf_pmu_format {
+        char *name;
+        int value;
+        DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
+        struct list_head list;
+};
+
 #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/"
 
 int perf_pmu_parse(struct list_head *list, char *name);
@@ -85,7 +97,7 @@ static int pmu_format(char *name, struct list_head *format)
 
 static int perf_pmu__new_alias(struct list_head *list, char *name, FILE *file)
 {
-        struct perf_pmu__alias *alias;
+        struct perf_pmu_alias *alias;
         char buf[256];
         int ret;
 
@@ -172,15 +184,15 @@ static int pmu_aliases(char *name, struct list_head *head)
         return 0;
 }
 
-static int pmu_alias_terms(struct perf_pmu__alias *alias,
+static int pmu_alias_terms(struct perf_pmu_alias *alias,
                            struct list_head *terms)
 {
-        struct parse_events__term *term, *clone;
+        struct parse_events_term *term, *clone;
         LIST_HEAD(list);
         int ret;
 
         list_for_each_entry(term, &alias->terms, list) {
-                ret = parse_events__term_clone(&clone, term);
+                ret = parse_events_term__clone(&clone, term);
                 if (ret) {
                         parse_events__free_terms(&list);
                         return ret;
@@ -360,10 +372,10 @@ struct perf_pmu *perf_pmu__find(char *name)
         return pmu_lookup(name);
 }
 
-static struct perf_pmu__format*
+static struct perf_pmu_format *
 pmu_find_format(struct list_head *formats, char *name)
 {
-        struct perf_pmu__format *format;
+        struct perf_pmu_format *format;
 
         list_for_each_entry(format, formats, list)
                 if (!strcmp(format->name, name))
@@ -403,9 +415,9 @@ static __u64 pmu_format_value(unsigned long *format, __u64 value)
  */
 static int pmu_config_term(struct list_head *formats,
                            struct perf_event_attr *attr,
-                           struct parse_events__term *term)
+                           struct parse_events_term *term)
 {
-        struct perf_pmu__format *format;
+        struct perf_pmu_format *format;
         __u64 *vp;
 
         /*
@@ -450,7 +462,7 @@ int perf_pmu__config_terms(struct list_head *formats,
                            struct perf_event_attr *attr,
                            struct list_head *head_terms)
 {
-        struct parse_events__term *term;
+        struct parse_events_term *term;
 
         list_for_each_entry(term, head_terms, list)
                 if (pmu_config_term(formats, attr, term))
@@ -471,10 +483,10 @@ int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
         return perf_pmu__config_terms(&pmu->format, attr, head_terms);
 }
 
-static struct perf_pmu__alias *pmu_find_alias(struct perf_pmu *pmu,
-                                              struct parse_events__term *term)
+static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
+                                             struct parse_events_term *term)
 {
-        struct perf_pmu__alias *alias;
+        struct perf_pmu_alias *alias;
         char *name;
 
         if (parse_events__is_hardcoded_term(term))
@@ -507,8 +519,8 @@ static struct perf_pmu__alias *pmu_find_alias(struct perf_pmu *pmu,
  */
 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms)
 {
-        struct parse_events__term *term, *h;
-        struct perf_pmu__alias *alias;
+        struct parse_events_term *term, *h;
+        struct perf_pmu_alias *alias;
         int ret;
 
         list_for_each_entry_safe(term, h, head_terms, list) {
@@ -527,7 +539,7 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms)
 int perf_pmu__new_format(struct list_head *list, char *name,
                          int config, unsigned long *bits)
 {
-        struct perf_pmu__format *format;
+        struct perf_pmu_format *format;
 
         format = zalloc(sizeof(*format));
         if (!format)
@@ -548,7 +560,7 @@ void perf_pmu__set_format(unsigned long *bits, long from, long to)
         if (!to)
                 to = from;
 
-        memset(bits, 0, BITS_TO_LONGS(PERF_PMU_FORMAT_BITS));
+        memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
         for (b = from; b <= to; b++)
                 set_bit(b, bits);
 }
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index a313ed76a49a..32fe55b659fa 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -12,19 +12,6 @@ enum {
 
 #define PERF_PMU_FORMAT_BITS 64
 
-struct perf_pmu__format {
-        char *name;
-        int value;
-        DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
-        struct list_head list;
-};
-
-struct perf_pmu__alias {
-        char *name;
-        struct list_head terms;
-        struct list_head list;
-};
-
 struct perf_pmu {
         char *name;
         __u32 type;
@@ -42,7 +29,7 @@ int perf_pmu__config_terms(struct list_head *formats,
                            struct list_head *head_terms);
 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms);
 struct list_head *perf_pmu__alias(struct perf_pmu *pmu,
-                                struct list_head *head_terms);
+                                  struct list_head *head_terms);
 int perf_pmu_wrap(void);
 void perf_pmu_error(struct list_head *list, char *name, char const *msg);
 
diff --git a/tools/perf/util/pmu.y b/tools/perf/util/pmu.y
index ec898047ebb9..bfd7e8509869 100644
--- a/tools/perf/util/pmu.y
+++ b/tools/perf/util/pmu.y
@@ -1,5 +1,4 @@
 
-%name-prefix "perf_pmu_"
 %parse-param {struct list_head *format}
 %parse-param {char *name}
 
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 49a256e6e0a2..aa04bf9c9ad7 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -40,7 +40,7 @@
 #include "color.h"
 #include "symbol.h"
 #include "thread.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "trace-event.h"        /* For __maybe_unused */
 #include "probe-event.h"
 #include "probe-finder.h"
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 1daf5c14e751..be0329394d56 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -413,12 +413,12 @@ static int convert_variable_type(Dwarf_Die *vr_die,
                                    dwarf_diename(vr_die), dwarf_diename(&type));
                         return -EINVAL;
                 }
+                if (die_get_real_type(&type, &type) == NULL) {
+                        pr_warning("Failed to get a type"
+                                   " information.\n");
+                        return -ENOENT;
+                }
                 if (ret == DW_TAG_pointer_type) {
-                        if (die_get_real_type(&type, &type) == NULL) {
-                                pr_warning("Failed to get a type"
-                                           " information.\n");
-                                return -ENOENT;
-                        }
                         while (*ref_ptr)
                                 ref_ptr = &(*ref_ptr)->next;
                         /* Add new reference with offset +0 */
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index c40c2d33199e..f75ae1b9900c 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -15,7 +15,7 @@ util/thread_map.c
 util/util.c
 util/xyarray.c
 util/cgroup.c
-util/debugfs.c
 util/rblist.c
 util/strlist.c
+util/sysfs.c
 ../../lib/rbtree.c
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index a2657fd96837..925e0c3e6d91 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -1045,3 +1045,12 @@ error:
         if (PyErr_Occurred())
                 PyErr_SetString(PyExc_ImportError, "perf: Init failed!");
 }
+
+/*
+ * Dummy, to avoid dragging all the test_attr infrastructure in the python
+ * binding.
+ */
+void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu,
+                     int fd, int group_fd, unsigned long flags)
+{
+}
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index f80605eb1855..eacec859f299 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -292,6 +292,7 @@ static void perl_process_tracepoint(union perf_event *perf_event __maybe_unused,
         ns = nsecs - s * NSECS_PER_SEC;
 
         scripting_context->event_data = data;
+        scripting_context->pevent = evsel->tp_format->pevent;
 
         ENTER;
         SAVETMPS;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 14683dfca2ee..e87aa5d9696b 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -265,6 +265,7 @@ static void python_process_tracepoint(union perf_event *perf_event
         ns = nsecs - s * NSECS_PER_SEC;
 
         scripting_context->event_data = data;
+        scripting_context->pevent = evsel->tp_format->pevent;
 
         context = PyCObject_FromVoidPtr(scripting_context, NULL);
 
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index ce6f51162386..cf1fe01b7e89 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1,5 +1,3 @@
-#define _FILE_OFFSET_BITS 64
-
 #include <linux/kernel.h>
 
 #include <byteswap.h>
@@ -16,7 +14,6 @@
 #include "cpumap.h"
 #include "event-parse.h"
 #include "perf_regs.h"
-#include "unwind.h"
 #include "vdso.h"
 
 static int perf_session__open(struct perf_session *self, bool force)
@@ -87,13 +84,12 @@ void perf_session__set_id_hdr_size(struct perf_session *session)
 {
         u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
 
-        session->host_machine.id_hdr_size = id_hdr_size;
         machines__set_id_hdr_size(&session->machines, id_hdr_size);
 }
 
 int perf_session__create_kernel_maps(struct perf_session *self)
 {
-        int ret = machine__create_kernel_maps(&self->host_machine);
+        int ret = machine__create_kernel_maps(&self->machines.host);
 
         if (ret >= 0)
                 ret = machines__create_guest_kernel_maps(&self->machines);
@@ -102,8 +98,7 @@ int perf_session__create_kernel_maps(struct perf_session *self)
 
 static void perf_session__destroy_kernel_maps(struct perf_session *self)
 {
-        machine__destroy_kernel_maps(&self->host_machine);
-        machines__destroy_guest_kernel_maps(&self->machines);
+        machines__destroy_kernel_maps(&self->machines);
 }
 
 struct perf_session *perf_session__new(const char *filename, int mode,
@@ -128,22 +123,11 @@ struct perf_session *perf_session__new(const char *filename, int mode,
                 goto out;
 
         memcpy(self->filename, filename, len);
-        /*
-         * On 64bit we can mmap the data file in one go. No need for tiny mmap
-         * slices. On 32bit we use 32MB.
-         */
-#if BITS_PER_LONG == 64
-        self->mmap_window = ULLONG_MAX;
-#else
-        self->mmap_window = 32 * 1024 * 1024ULL;
-#endif
-        self->machines = RB_ROOT;
         self->repipe = repipe;
         INIT_LIST_HEAD(&self->ordered_samples.samples);
         INIT_LIST_HEAD(&self->ordered_samples.sample_cache);
         INIT_LIST_HEAD(&self->ordered_samples.to_free);
-        machine__init(&self->host_machine, "", HOST_KERNEL_ID);
-        hists__init(&self->hists);
+        machines__init(&self->machines);
 
         if (mode == O_RDONLY) {
                 if (perf_session__open(self, force) < 0)
@@ -171,37 +155,30 @@ out_delete:
         return NULL;
 }
 
-static 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);
-        }
-}
-
 static void perf_session__delete_dead_threads(struct perf_session *session)
 {
-        machine__delete_dead_threads(&session->host_machine);
+        machine__delete_dead_threads(&session->machines.host);
 }
 
-static void machine__delete_threads(struct machine *self)
+static void perf_session__delete_threads(struct perf_session *session)
 {
-        struct rb_node *nd = rb_first(&self->threads);
-
-        while (nd) {
-                struct thread *t = rb_entry(nd, struct thread, rb_node);
-
-                rb_erase(&t->rb_node, &self->threads);
-                nd = rb_next(nd);
-                thread__delete(t);
-        }
+        machine__delete_threads(&session->machines.host);
 }
 
-static void perf_session__delete_threads(struct perf_session *session)
+static void perf_session_env__delete(struct perf_session_env *env)
 {
-        machine__delete_threads(&session->host_machine);
+        free(env->hostname);
+        free(env->os_release);
+        free(env->version);
+        free(env->arch);
+        free(env->cpu_desc);
+        free(env->cpuid);
+
+        free(env->cmdline);
+        free(env->sibling_cores);
+        free(env->sibling_threads);
+        free(env->numa_nodes);
+        free(env->pmu_mappings);
 }
 
 void perf_session__delete(struct perf_session *self)
@@ -209,198 +186,13 @@ void perf_session__delete(struct perf_session *self)
         perf_session__destroy_kernel_maps(self);
         perf_session__delete_dead_threads(self);
         perf_session__delete_threads(self);
-        machine__exit(&self->host_machine);
+        perf_session_env__delete(&self->header.env);
+        machines__exit(&self->machines);
         close(self->fd);
         free(self);
         vdso__exit();
 }
 
-void machine__remove_thread(struct machine *self, struct thread *th)
-{
-        self->last_match = NULL;
-        rb_erase(&th->rb_node, &self->threads);
-        /*
-         * We may have references to this thread, for instance in some hist_entry
-         * instances, so just move them to a separate list.
-         */
-        list_add_tail(&th->node, &self->dead_threads);
-}
-
-static bool symbol__match_parent_regex(struct symbol *sym)
-{
-        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
-                return 1;
-
-        return 0;
-}
-
-static const u8 cpumodes[] = {
-        PERF_RECORD_MISC_USER,
-        PERF_RECORD_MISC_KERNEL,
-        PERF_RECORD_MISC_GUEST_USER,
-        PERF_RECORD_MISC_GUEST_KERNEL
-};
-#define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
-
-static void ip__resolve_ams(struct machine *self, struct thread *thread,
-                            struct addr_map_symbol *ams,
-                            u64 ip)
-{
-        struct addr_location al;
-        size_t i;
-        u8 m;
-
-        memset(&al, 0, sizeof(al));
-
-        for (i = 0; i < NCPUMODES; i++) {
-                m = cpumodes[i];
-                /*
-                 * We cannot use the header.misc hint to determine whether a
-                 * branch stack address is user, kernel, guest, hypervisor.
-                 * Branches may straddle the kernel/user/hypervisor boundaries.
-                 * Thus, we have to try consecutively until we find a match
-                 * or else, the symbol is unknown
-                 */
-                thread__find_addr_location(thread, self, m, MAP__FUNCTION,
-                                ip, &al, NULL);
-                if (al.sym)
-                        goto found;
-        }
-found:
-        ams->addr = ip;
-        ams->al_addr = al.addr;
-        ams->sym = al.sym;
-        ams->map = al.map;
-}
-
-struct branch_info *machine__resolve_bstack(struct machine *self,
-                                            struct thread *thr,
-                                            struct branch_stack *bs)
-{
-        struct branch_info *bi;
-        unsigned int i;
-
-        bi = calloc(bs->nr, sizeof(struct branch_info));
-        if (!bi)
-                return NULL;
-
-        for (i = 0; i < bs->nr; i++) {
-                ip__resolve_ams(self, thr, &bi[i].to, bs->entries[i].to);
-                ip__resolve_ams(self, thr, &bi[i].from, bs->entries[i].from);
-                bi[i].flags = bs->entries[i].flags;
-        }
-        return bi;
-}
-
-static int machine__resolve_callchain_sample(struct machine *machine,
-                                             struct thread *thread,
-                                             struct ip_callchain *chain,
-                                             struct symbol **parent)
-
-{
-        u8 cpumode = PERF_RECORD_MISC_USER;
-        unsigned int i;
-        int err;
-
-        callchain_cursor_reset(&callchain_cursor);
-
-        if (chain->nr > PERF_MAX_STACK_DEPTH) {
-                pr_warning("corrupted callchain. skipping...\n");
-                return 0;
-        }
-
-        for (i = 0; i < chain->nr; i++) {
-                u64 ip;
-                struct addr_location al;
-
-                if (callchain_param.order == ORDER_CALLEE)
-                        ip = chain->ips[i];
-                else
-                        ip = chain->ips[chain->nr - i - 1];
-
-                if (ip >= PERF_CONTEXT_MAX) {
-                        switch (ip) {
-                        case PERF_CONTEXT_HV:
-                                cpumode = PERF_RECORD_MISC_HYPERVISOR;
-                                break;
-                        case PERF_CONTEXT_KERNEL:
-                                cpumode = PERF_RECORD_MISC_KERNEL;
-                                break;
-                        case PERF_CONTEXT_USER:
-                                cpumode = PERF_RECORD_MISC_USER;
-                                break;
-                        default:
-                                pr_debug("invalid callchain context: "
-                                         "%"PRId64"\n", (s64) ip);
-                                /*
-                                 * It seems the callchain is corrupted.
-                                 * Discard all.
-                                 */
-                                callchain_cursor_reset(&callchain_cursor);
-                                return 0;
-                        }
-                        continue;
-                }
-
-                al.filtered = false;
-                thread__find_addr_location(thread, machine, cpumode,
-                                           MAP__FUNCTION, ip, &al, NULL);
-                if (al.sym != NULL) {
-                        if (sort__has_parent && !*parent &&
-                            symbol__match_parent_regex(al.sym))
-                                *parent = al.sym;
-                        if (!symbol_conf.use_callchain)
-                                break;
-                }
-
-                err = callchain_cursor_append(&callchain_cursor,
-                                              ip, al.map, al.sym);
-                if (err)
-                        return err;
-        }
-
-        return 0;
-}
-
-static int unwind_entry(struct unwind_entry *entry, void *arg)
-{
-        struct callchain_cursor *cursor = arg;
-        return callchain_cursor_append(cursor, entry->ip,
-                                       entry->map, entry->sym);
-}
-
-int machine__resolve_callchain(struct machine *machine,
-                               struct perf_evsel *evsel,
-                               struct thread *thread,
-                               struct perf_sample *sample,
-                               struct symbol **parent)
-
-{
-        int ret;
-
-        callchain_cursor_reset(&callchain_cursor);
-
-        ret = machine__resolve_callchain_sample(machine, thread,
-                                                sample->callchain, parent);
-        if (ret)
-                return ret;
-
-        /* Can we do dwarf post unwind? */
-        if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
-              (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
-                return 0;
-
-        /* Bail out if nothing was captured. */
-        if ((!sample->user_regs.regs) ||
-            (!sample->user_stack.size))
-                return 0;
-
-        return unwind__get_entries(unwind_entry, &callchain_cursor, machine,
-                                   thread, evsel->attr.sample_regs_user,
-                                   sample);
-
-}
-
 static int process_event_synth_tracing_data_stub(union perf_event *event
                                                  __maybe_unused,
                                                  struct perf_session *session
@@ -1006,6 +798,12 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
 
         if (sample_type & PERF_SAMPLE_STACK_USER)
                 stack_user__printf(&sample->user_stack);
+
+        if (sample_type & PERF_SAMPLE_WEIGHT)
+                printf("... weight: %" PRIu64 "\n", sample->weight);
+
+        if (sample_type & PERF_SAMPLE_DATA_SRC)
+                printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
 }
 
 static struct machine *
@@ -1027,7 +825,7 @@ static struct machine *
                 return perf_session__findnew_machine(session, pid);
         }
 
-        return perf_session__find_host_machine(session);
+        return &session->machines.host;
 }
 
 static int perf_session_deliver_event(struct perf_session *session,
@@ -1065,11 +863,11 @@ static int perf_session_deliver_event(struct perf_session *session,
         case PERF_RECORD_SAMPLE:
                 dump_sample(evsel, event, sample);
                 if (evsel == NULL) {
-                        ++session->hists.stats.nr_unknown_id;
+                        ++session->stats.nr_unknown_id;
                         return 0;
                 }
                 if (machine == NULL) {
-                        ++session->hists.stats.nr_unprocessable_samples;
+                        ++session->stats.nr_unprocessable_samples;
                         return 0;
                 }
                 return tool->sample(tool, event, sample, evsel, machine);
@@ -1083,7 +881,7 @@ static 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->hists.stats.total_lost += event->lost.lost;
+                        session->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);
@@ -1092,7 +890,7 @@ static int perf_session_deliver_event(struct perf_session *session,
         case PERF_RECORD_UNTHROTTLE:
                 return tool->unthrottle(tool, event, sample, machine);
         default:
-                ++session->hists.stats.nr_unknown_events;
+                ++session->stats.nr_unknown_events;
                 return -1;
         }
 }
@@ -1106,8 +904,8 @@ static int perf_session__preprocess_sample(struct perf_session *session,
 
         if (!ip_callchain__valid(sample->callchain, event)) {
                 pr_debug("call-chain problem with event, skipping it.\n");
-                ++session->hists.stats.nr_invalid_chains;
-                session->hists.stats.total_invalid_chains += sample->period;
+                ++session->stats.nr_invalid_chains;
+                session->stats.total_invalid_chains += sample->period;
                 return -EINVAL;
         }
         return 0;
@@ -1165,7 +963,7 @@ static int perf_session__process_event(struct perf_session *session,
         if (event->header.type >= PERF_RECORD_HEADER_MAX)
                 return -EINVAL;
 
-        hists__inc_nr_events(&session->hists, event->header.type);
+        events_stats__inc(&session->stats, event->header.type);
 
         if (event->header.type >= PERF_RECORD_USER_TYPE_START)
                 return perf_session__process_user_event(session, event, tool, file_offset);
@@ -1201,7 +999,7 @@ void perf_event_header__bswap(struct perf_event_header *self)
 
 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
 {
-        return machine__findnew_thread(&session->host_machine, pid);
+        return machine__findnew_thread(&session->machines.host, pid);
 }
 
 static struct thread *perf_session__register_idle_thread(struct perf_session *self)
@@ -1220,39 +1018,39 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
                                             const struct perf_tool *tool)
 {
         if (tool->lost == perf_event__process_lost &&
-            session->hists.stats.nr_events[PERF_RECORD_LOST] != 0) {
+            session->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->hists.stats.nr_events[0],
-                            session->hists.stats.nr_events[PERF_RECORD_LOST]);
+                            session->stats.nr_events[0],
+                            session->stats.nr_events[PERF_RECORD_LOST]);
         }
 
-        if (session->hists.stats.nr_unknown_events != 0) {
+        if (session->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->hists.stats.nr_unknown_events);
+                            session->stats.nr_unknown_events);
         }
 
-        if (session->hists.stats.nr_unknown_id != 0) {
+        if (session->stats.nr_unknown_id != 0) {
                 ui__warning("%u samples with id not present in the header\n",
-                            session->hists.stats.nr_unknown_id);
+                            session->stats.nr_unknown_id);
         }
 
-        if (session->hists.stats.nr_invalid_chains != 0) {
+        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->hists.stats.nr_invalid_chains,
-                            session->hists.stats.nr_events[PERF_RECORD_SAMPLE]);
+                            session->stats.nr_invalid_chains,
+                            session->stats.nr_events[PERF_RECORD_SAMPLE]);
         }
 
-        if (session->hists.stats.nr_unprocessable_samples != 0) {
+        if (session->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->hists.stats.nr_unprocessable_samples);
+                            session->stats.nr_unprocessable_samples);
         }
 }
 
@@ -1369,6 +1167,18 @@ fetch_mmaped_event(struct perf_session *session,
         return event;
 }
 
+/*
+ * On 64bit we can mmap the data file in one go. No need for tiny mmap
+ * slices. On 32bit we use 32MB.
+ */
+#if BITS_PER_LONG == 64
+#define MMAP_SIZE ULLONG_MAX
+#define NUM_MMAPS 1
+#else
+#define MMAP_SIZE (32 * 1024 * 1024ULL)
+#define NUM_MMAPS 128
+#endif
+
 int __perf_session__process_events(struct perf_session *session,
                                    u64 data_offset, u64 data_size,
                                    u64 file_size, struct perf_tool *tool)
@@ -1376,7 +1186,7 @@ int __perf_session__process_events(struct perf_session *session,
         u64 head, page_offset, file_offset, file_pos, progress_next;
         int err, mmap_prot, mmap_flags, map_idx = 0;
         size_t  mmap_size;
-        char *buf, *mmaps[8];
+        char *buf, *mmaps[NUM_MMAPS];
         union perf_event *event;
         uint32_t size;
 
@@ -1391,7 +1201,7 @@ int __perf_session__process_events(struct perf_session *session,
 
         progress_next = file_size / 16;
 
-        mmap_size = session->mmap_window;
+        mmap_size = MMAP_SIZE;
         if (mmap_size > file_size)
                 mmap_size = file_size;
 
@@ -1526,16 +1336,13 @@ int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
 
 size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
 {
-        return __dsos__fprintf(&self->host_machine.kernel_dsos, fp) +
-               __dsos__fprintf(&self->host_machine.user_dsos, fp) +
-               machines__fprintf_dsos(&self->machines, fp);
+        return machines__fprintf_dsos(&self->machines, fp);
 }
 
 size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
-                                          bool with_hits)
+                                          bool (skip)(struct dso *dso, int parm), int parm)
 {
-        size_t ret = machine__fprintf_dsos_buildid(&self->host_machine, fp, with_hits);
-        return ret + machines__fprintf_dsos_buildid(&self->machines, fp, with_hits);
+        return machines__fprintf_dsos_buildid(&self->machines, fp, skip, parm);
 }
 
 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
@@ -1543,11 +1350,11 @@ size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
         struct perf_evsel *pos;
         size_t ret = fprintf(fp, "Aggregated stats:\n");
 
-        ret += hists__fprintf_nr_events(&session->hists, fp);
+        ret += events_stats__fprintf(&session->stats, fp);
 
         list_for_each_entry(pos, &session->evlist->entries, node) {
                 ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
-                ret += hists__fprintf_nr_events(&pos->hists, fp);
+                ret += events_stats__fprintf(&pos->hists.stats, fp);
         }
 
         return ret;
@@ -1559,19 +1366,7 @@ size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
          * FIXME: Here we have to actually print all the machines in this
          * session, not just the host...
          */
-        return machine__fprintf(&session->host_machine, fp);
-}
-
-void perf_session__remove_thread(struct perf_session *session,
-                                 struct thread *th)
-{
-        /*
-         * FIXME: This one makes no sense, we need to remove the thread from
-         * the machine it belongs to, perf_session can have many machines, so
-         * doing it always on ->host_machine is wrong.  Fix when auditing all
-         * the 'perf kvm' code.
-         */
-        machine__remove_thread(&session->host_machine, th);
+        return machine__fprintf(&session->machines.host, fp);
 }
 
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index cea133a6bdf1..f3b235ec7bf4 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -30,20 +30,13 @@ struct ordered_samples {
 struct perf_session {
         struct perf_header      header;
         unsigned long           size;
-        unsigned long           mmap_window;
-        struct machine          host_machine;
-        struct rb_root          machines;
+        struct machines         machines;
         struct perf_evlist      *evlist;
         struct pevent           *pevent;
-        /*
-         * FIXME: Need to split this up further, we need global
-         *        stats + per event stats.
-         */
-        struct hists            hists;
+        struct events_stats     stats;
         int                     fd;
         bool                    fd_pipe;
         bool                    repipe;
-        int                     cwdlen;
         char                    *cwd;
         struct ordered_samples  ordered_samples;
         char                    filename[1];
@@ -54,7 +47,7 @@ struct perf_tool;
 struct perf_session *perf_session__new(const char *filename, int mode,
                                        bool force, bool repipe,
                                        struct perf_tool *tool);
-void perf_session__delete(struct perf_session *self);
+void perf_session__delete(struct perf_session *session);
 
 void perf_event_header__bswap(struct perf_event_header *self);
 
@@ -78,46 +71,26 @@ void perf_event__attr_swap(struct perf_event_attr *attr);
 int perf_session__create_kernel_maps(struct perf_session *self);
 
 void perf_session__set_id_hdr_size(struct perf_session *session);
-void perf_session__remove_thread(struct perf_session *self, struct thread *th);
-
-static inline
-struct machine *perf_session__find_host_machine(struct perf_session *self)
-{
-        return &self->host_machine;
-}
 
 static inline
 struct machine *perf_session__find_machine(struct perf_session *self, pid_t pid)
 {
-        if (pid == HOST_KERNEL_ID)
-                return &self->host_machine;
         return machines__find(&self->machines, pid);
 }
 
 static inline
 struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t pid)
 {
-        if (pid == HOST_KERNEL_ID)
-                return &self->host_machine;
         return machines__findnew(&self->machines, pid);
 }
 
-static inline
-void perf_session__process_machines(struct perf_session *self,
-                                    struct perf_tool *tool,
-                                    machine__process_t process)
-{
-        process(&self->host_machine, tool);
-        return machines__process(&self->machines, process, tool);
-}
-
 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
 size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
 
 size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp);
 
-size_t perf_session__fprintf_dsos_buildid(struct perf_session *self,
-                                          FILE *fp, bool with_hits);
+size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
+                                          bool (fn)(struct dso *dso, int parm), int parm);
 
 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp);
 
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 73d510269784..58ea5ca6c255 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -18,12 +18,14 @@ class install_lib(_install_lib):
         self.build_dir = build_lib
 
 
-cflags = ['-fno-strict-aliasing', '-Wno-write-strings']
-cflags += getenv('CFLAGS', '').split()
+cflags = getenv('CFLAGS', '').split()
+# switch off several checks (need to be at the end of cflags list)
+cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter' ]
 
 build_lib = getenv('PYTHON_EXTBUILD_LIB')
 build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 libtraceevent = getenv('LIBTRACEEVENT')
+liblk = getenv('LIBLK')
 
 ext_sources = [f.strip() for f in file('util/python-ext-sources')
                                 if len(f.strip()) > 0 and f[0] != '#']
@@ -32,7 +34,7 @@ perf = Extension('perf',
                   sources = ext_sources,
                   include_dirs = ['util/include'],
                   extra_compile_args = cflags,
-                  extra_objects = [libtraceevent],
+                  extra_objects = [libtraceevent, liblk],
                  )
 
 setup(name='perf',
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index cfd1c0feb32d..313a5a730112 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,5 +1,6 @@
 #include "sort.h"
 #include "hist.h"
+#include "symbol.h"
 
 regex_t         parent_regex;
 const char      default_parent_pattern[] = "^sys_|^do_page_fault";
@@ -9,7 +10,7 @@ const char	*sort_order = default_sort_order;
 int             sort__need_collapse = 0;
 int             sort__has_parent = 0;
 int             sort__has_sym = 0;
-int             sort__branch_mode = -1; /* -1 = means not set */
+enum sort_mode  sort__mode = SORT_MODE__NORMAL;
 
 enum sort_type  sort__first_dimension;
 
@@ -60,7 +61,7 @@ sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
 static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
                                        size_t size, unsigned int width)
 {
-        return repsep_snprintf(bf, size, "%*s:%5d", width,
+        return repsep_snprintf(bf, size, "%*s:%5d", width - 6,
                               self->thread->comm ?: "", self->thread->pid);
 }
 
@@ -97,6 +98,16 @@ static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
         return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
 }
 
+struct sort_entry sort_comm = {
+        .se_header      = "Command",
+        .se_cmp         = sort__comm_cmp,
+        .se_collapse    = sort__comm_collapse,
+        .se_snprintf    = hist_entry__comm_snprintf,
+        .se_width_idx   = HISTC_COMM,
+};
+
+/* --sort dso */
+
 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
 {
         struct dso *dso_l = map_l ? map_l->dso : NULL;
@@ -117,40 +128,12 @@ static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
         return strcmp(dso_name_l, dso_name_r);
 }
 
-struct sort_entry sort_comm = {
-        .se_header      = "Command",
-        .se_cmp         = sort__comm_cmp,
-        .se_collapse    = sort__comm_collapse,
-        .se_snprintf    = hist_entry__comm_snprintf,
-        .se_width_idx   = HISTC_COMM,
-};
-
-/* --sort dso */
-
 static int64_t
 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         return _sort__dso_cmp(left->ms.map, right->ms.map);
 }
 
-
-static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r,
-                              u64 ip_l, u64 ip_r)
-{
-        if (!sym_l || !sym_r)
-                return cmp_null(sym_l, sym_r);
-
-        if (sym_l == sym_r)
-                return 0;
-
-        if (sym_l)
-                ip_l = sym_l->start;
-        if (sym_r)
-                ip_r = sym_r->start;
-
-        return (int64_t)(ip_r - ip_l);
-}
-
 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
                                      size_t size, unsigned int width)
 {
@@ -169,24 +152,66 @@ static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
         return _hist_entry__dso_snprintf(self->ms.map, bf, size, width);
 }
 
+struct sort_entry sort_dso = {
+        .se_header      = "Shared Object",
+        .se_cmp         = sort__dso_cmp,
+        .se_snprintf    = hist_entry__dso_snprintf,
+        .se_width_idx   = HISTC_DSO,
+};
+
+/* --sort symbol */
+
+static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
+{
+        u64 ip_l, ip_r;
+
+        if (!sym_l || !sym_r)
+                return cmp_null(sym_l, sym_r);
+
+        if (sym_l == sym_r)
+                return 0;
+
+        ip_l = sym_l->start;
+        ip_r = sym_r->start;
+
+        return (int64_t)(ip_r - ip_l);
+}
+
+static int64_t
+sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        if (!left->ms.sym && !right->ms.sym)
+                return right->level - left->level;
+
+        return _sort__sym_cmp(left->ms.sym, right->ms.sym);
+}
+
 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
                                      u64 ip, char level, char *bf, size_t size,
-                                     unsigned int width __maybe_unused)
+                                     unsigned int width)
 {
         size_t ret = 0;
 
         if (verbose) {
                 char o = map ? dso__symtab_origin(map->dso) : '!';
                 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
-                                       BITS_PER_LONG / 4, ip, o);
+                                       BITS_PER_LONG / 4 + 2, ip, o);
         }
 
         ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
-        if (sym)
-                ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
-                                       width - ret,
-                                       sym->name);
-        else {
+        if (sym && map) {
+                if (map->type == MAP__VARIABLE) {
+                        ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
+                        ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
+                                        ip - map->unmap_ip(map, sym->start));
+                        ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                       width - ret, "");
+                } else {
+                        ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                               width - ret,
+                                               sym->name);
+                }
+        } else {
                 size_t len = BITS_PER_LONG / 4;
                 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
                                        len, ip);
@@ -197,43 +222,13 @@ static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
         return ret;
 }
 
-
-struct sort_entry sort_dso = {
-        .se_header      = "Shared Object",
-        .se_cmp         = sort__dso_cmp,
-        .se_snprintf    = hist_entry__dso_snprintf,
-        .se_width_idx   = HISTC_DSO,
-};
-
 static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
-                                    size_t size,
-                                    unsigned int width __maybe_unused)
+                                    size_t size, unsigned int width)
 {
         return _hist_entry__sym_snprintf(self->ms.map, self->ms.sym, self->ip,
                                          self->level, bf, size, width);
 }
 
-/* --sort symbol */
-static int64_t
-sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        u64 ip_l, ip_r;
-
-        if (!left->ms.sym && !right->ms.sym)
-                return right->level - left->level;
-
-        if (!left->ms.sym || !right->ms.sym)
-                return cmp_null(left->ms.sym, right->ms.sym);
-
-        if (left->ms.sym == right->ms.sym)
-                return 0;
-
-        ip_l = left->ms.sym->start;
-        ip_r = right->ms.sym->start;
-
-        return _sort__sym_cmp(left->ms.sym, right->ms.sym, ip_l, ip_r);
-}
-
 struct sort_entry sort_sym = {
         .se_header      = "Symbol",
         .se_cmp         = sort__sym_cmp,
@@ -253,7 +248,7 @@ static int hist_entry__srcline_snprintf(struct hist_entry *self, char *bf,
                                         size_t size,
                                         unsigned int width __maybe_unused)
 {
-        FILE *fp;
+        FILE *fp = NULL;
         char cmd[PATH_MAX + 2], *path = self->srcline, *nl;
         size_t line_len;
 
@@ -274,7 +269,6 @@ static int hist_entry__srcline_snprintf(struct hist_entry *self, char *bf,
 
         if (getline(&path, &line_len, fp) < 0 || !line_len)
                 goto out_ip;
-        fclose(fp);
         self->srcline = strdup(path);
         if (self->srcline == NULL)
                 goto out_ip;
@@ -284,8 +278,12 @@ static int hist_entry__srcline_snprintf(struct hist_entry *self, char *bf,
                 *nl = '\0';
         path = self->srcline;
 out_path:
+        if (fp)
+                pclose(fp);
         return repsep_snprintf(bf, size, "%s", path);
 out_ip:
+        if (fp)
+                pclose(fp);
         return repsep_snprintf(bf, size, "%-#*llx", BITS_PER_LONG / 4, self->ip);
 }
 
@@ -335,7 +333,7 @@ sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
 static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
                                        size_t size, unsigned int width)
 {
-        return repsep_snprintf(bf, size, "%-*d", width, self->cpu);
+        return repsep_snprintf(bf, size, "%*d", width, self->cpu);
 }
 
 struct sort_entry sort_cpu = {
@@ -345,6 +343,8 @@ struct sort_entry sort_cpu = {
         .se_width_idx   = HISTC_CPU,
 };
 
+/* sort keys for branch stacks */
+
 static int64_t
 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
 {
@@ -359,13 +359,6 @@ static int hist_entry__dso_from_snprintf(struct hist_entry *self, char *bf,
                                          bf, size, width);
 }
 
-struct sort_entry sort_dso_from = {
-        .se_header      = "Source Shared Object",
-        .se_cmp         = sort__dso_from_cmp,
-        .se_snprintf    = hist_entry__dso_from_snprintf,
-        .se_width_idx   = HISTC_DSO_FROM,
-};
-
 static int64_t
 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
 {
@@ -389,8 +382,7 @@ sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
         if (!from_l->sym && !from_r->sym)
                 return right->level - left->level;
 
-        return _sort__sym_cmp(from_l->sym, from_r->sym, from_l->addr,
-                             from_r->addr);
+        return _sort__sym_cmp(from_l->sym, from_r->sym);
 }
 
 static int64_t
@@ -402,12 +394,11 @@ sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
         if (!to_l->sym && !to_r->sym)
                 return right->level - left->level;
 
-        return _sort__sym_cmp(to_l->sym, to_r->sym, to_l->addr, to_r->addr);
+        return _sort__sym_cmp(to_l->sym, to_r->sym);
 }
 
 static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
-                                        size_t size,
-                                        unsigned int width __maybe_unused)
+                                         size_t size, unsigned int width)
 {
         struct addr_map_symbol *from = &self->branch_info->from;
         return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
@@ -416,8 +407,7 @@ static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
 }
 
 static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
-                                       size_t size,
-                                       unsigned int width __maybe_unused)
+                                       size_t size, unsigned int width)
 {
         struct addr_map_symbol *to = &self->branch_info->to;
         return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
@@ -425,6 +415,13 @@ static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
 
 }
 
+struct sort_entry sort_dso_from = {
+        .se_header      = "Source Shared Object",
+        .se_cmp         = sort__dso_from_cmp,
+        .se_snprintf    = hist_entry__dso_from_snprintf,
+        .se_width_idx   = HISTC_DSO_FROM,
+};
+
 struct sort_entry sort_dso_to = {
         .se_header      = "Target Shared Object",
         .se_cmp         = sort__dso_to_cmp,
@@ -469,6 +466,304 @@ static int hist_entry__mispredict_snprintf(struct hist_entry *self, char *bf,
         return repsep_snprintf(bf, size, "%-*s", width, out);
 }
 
+/* --sort daddr_sym */
+static int64_t
+sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        uint64_t l = 0, r = 0;
+
+        if (left->mem_info)
+                l = left->mem_info->daddr.addr;
+        if (right->mem_info)
+                r = right->mem_info->daddr.addr;
+
+        return (int64_t)(r - l);
+}
+
+static int hist_entry__daddr_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        uint64_t addr = 0;
+        struct map *map = NULL;
+        struct symbol *sym = NULL;
+
+        if (self->mem_info) {
+                addr = self->mem_info->daddr.addr;
+                map = self->mem_info->daddr.map;
+                sym = self->mem_info->daddr.sym;
+        }
+        return _hist_entry__sym_snprintf(map, sym, addr, self->level, bf, size,
+                                         width);
+}
+
+static int64_t
+sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct map *map_l = NULL;
+        struct map *map_r = NULL;
+
+        if (left->mem_info)
+                map_l = left->mem_info->daddr.map;
+        if (right->mem_info)
+                map_r = right->mem_info->daddr.map;
+
+        return _sort__dso_cmp(map_l, map_r);
+}
+
+static int hist_entry__dso_daddr_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        struct map *map = NULL;
+
+        if (self->mem_info)
+                map = self->mem_info->daddr.map;
+
+        return _hist_entry__dso_snprintf(map, bf, size, width);
+}
+
+static int64_t
+sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_lock = PERF_MEM_LOCK_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_lock = PERF_MEM_LOCK_NA;
+
+        return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
+}
+
+static int hist_entry__locked_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        const char *out;
+        u64 mask = PERF_MEM_LOCK_NA;
+
+        if (self->mem_info)
+                mask = self->mem_info->data_src.mem_lock;
+
+        if (mask & PERF_MEM_LOCK_NA)
+                out = "N/A";
+        else if (mask & PERF_MEM_LOCK_LOCKED)
+                out = "Yes";
+        else
+                out = "No";
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+static int64_t
+sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
+
+        return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
+}
+
+static const char * const tlb_access[] = {
+        "N/A",
+        "HIT",
+        "MISS",
+        "L1",
+        "L2",
+        "Walker",
+        "Fault",
+};
+#define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
+
+static int hist_entry__tlb_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        char out[64];
+        size_t sz = sizeof(out) - 1; /* -1 for null termination */
+        size_t l = 0, i;
+        u64 m = PERF_MEM_TLB_NA;
+        u64 hit, miss;
+
+        out[0] = '\0';
+
+        if (self->mem_info)
+                m = self->mem_info->data_src.mem_dtlb;
+
+        hit = m & PERF_MEM_TLB_HIT;
+        miss = m & PERF_MEM_TLB_MISS;
+
+        /* already taken care of */
+        m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
+
+        for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
+                if (!(m & 0x1))
+                        continue;
+                if (l) {
+                        strcat(out, " or ");
+                        l += 4;
+                }
+                strncat(out, tlb_access[i], sz - l);
+                l += strlen(tlb_access[i]);
+        }
+        if (*out == '\0')
+                strcpy(out, "N/A");
+        if (hit)
+                strncat(out, " hit", sz - l);
+        if (miss)
+                strncat(out, " miss", sz - l);
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+static int64_t
+sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_lvl = PERF_MEM_LVL_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_lvl = PERF_MEM_LVL_NA;
+
+        return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
+}
+
+static const char * const mem_lvl[] = {
+        "N/A",
+        "HIT",
+        "MISS",
+        "L1",
+        "LFB",
+        "L2",
+        "L3",
+        "Local RAM",
+        "Remote RAM (1 hop)",
+        "Remote RAM (2 hops)",
+        "Remote Cache (1 hop)",
+        "Remote Cache (2 hops)",
+        "I/O",
+        "Uncached",
+};
+#define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
+
+static int hist_entry__lvl_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        char out[64];
+        size_t sz = sizeof(out) - 1; /* -1 for null termination */
+        size_t i, l = 0;
+        u64 m =  PERF_MEM_LVL_NA;
+        u64 hit, miss;
+
+        if (self->mem_info)
+                m  = self->mem_info->data_src.mem_lvl;
+
+        out[0] = '\0';
+
+        hit = m & PERF_MEM_LVL_HIT;
+        miss = m & PERF_MEM_LVL_MISS;
+
+        /* already taken care of */
+        m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
+
+        for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
+                if (!(m & 0x1))
+                        continue;
+                if (l) {
+                        strcat(out, " or ");
+                        l += 4;
+                }
+                strncat(out, mem_lvl[i], sz - l);
+                l += strlen(mem_lvl[i]);
+        }
+        if (*out == '\0')
+                strcpy(out, "N/A");
+        if (hit)
+                strncat(out, " hit", sz - l);
+        if (miss)
+                strncat(out, " miss", sz - l);
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+static int64_t
+sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
+
+        return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
+}
+
+static const char * const snoop_access[] = {
+        "N/A",
+        "None",
+        "Miss",
+        "Hit",
+        "HitM",
+};
+#define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
+
+static int hist_entry__snoop_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        char out[64];
+        size_t sz = sizeof(out) - 1; /* -1 for null termination */
+        size_t i, l = 0;
+        u64 m = PERF_MEM_SNOOP_NA;
+
+        out[0] = '\0';
+
+        if (self->mem_info)
+                m = self->mem_info->data_src.mem_snoop;
+
+        for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
+                if (!(m & 0x1))
+                        continue;
+                if (l) {
+                        strcat(out, " or ");
+                        l += 4;
+                }
+                strncat(out, snoop_access[i], sz - l);
+                l += strlen(snoop_access[i]);
+        }
+
+        if (*out == '\0')
+                strcpy(out, "N/A");
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
 struct sort_entry sort_mispredict = {
         .se_header      = "Branch Mispredicted",
         .se_cmp         = sort__mispredict_cmp,
@@ -476,6 +771,91 @@ struct sort_entry sort_mispredict = {
         .se_width_idx   = HISTC_MISPREDICT,
 };
 
+static u64 he_weight(struct hist_entry *he)
+{
+        return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
+}
+
+static int64_t
+sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return he_weight(left) - he_weight(right);
+}
+
+static int hist_entry__local_weight_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        return repsep_snprintf(bf, size, "%-*llu", width, he_weight(self));
+}
+
+struct sort_entry sort_local_weight = {
+        .se_header      = "Local Weight",
+        .se_cmp         = sort__local_weight_cmp,
+        .se_snprintf    = hist_entry__local_weight_snprintf,
+        .se_width_idx   = HISTC_LOCAL_WEIGHT,
+};
+
+static int64_t
+sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return left->stat.weight - right->stat.weight;
+}
+
+static int hist_entry__global_weight_snprintf(struct hist_entry *self, char *bf,
+                                              size_t size, unsigned int width)
+{
+        return repsep_snprintf(bf, size, "%-*llu", width, self->stat.weight);
+}
+
+struct sort_entry sort_global_weight = {
+        .se_header      = "Weight",
+        .se_cmp         = sort__global_weight_cmp,
+        .se_snprintf    = hist_entry__global_weight_snprintf,
+        .se_width_idx   = HISTC_GLOBAL_WEIGHT,
+};
+
+struct sort_entry sort_mem_daddr_sym = {
+        .se_header      = "Data Symbol",
+        .se_cmp         = sort__daddr_cmp,
+        .se_snprintf    = hist_entry__daddr_snprintf,
+        .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
+};
+
+struct sort_entry sort_mem_daddr_dso = {
+        .se_header      = "Data Object",
+        .se_cmp         = sort__dso_daddr_cmp,
+        .se_snprintf    = hist_entry__dso_daddr_snprintf,
+        .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
+};
+
+struct sort_entry sort_mem_locked = {
+        .se_header      = "Locked",
+        .se_cmp         = sort__locked_cmp,
+        .se_snprintf    = hist_entry__locked_snprintf,
+        .se_width_idx   = HISTC_MEM_LOCKED,
+};
+
+struct sort_entry sort_mem_tlb = {
+        .se_header      = "TLB access",
+        .se_cmp         = sort__tlb_cmp,
+        .se_snprintf    = hist_entry__tlb_snprintf,
+        .se_width_idx   = HISTC_MEM_TLB,
+};
+
+struct sort_entry sort_mem_lvl = {
+        .se_header      = "Memory access",
+        .se_cmp         = sort__lvl_cmp,
+        .se_snprintf    = hist_entry__lvl_snprintf,
+        .se_width_idx   = HISTC_MEM_LVL,
+};
+
+struct sort_entry sort_mem_snoop = {
+        .se_header      = "Snoop",
+        .se_cmp         = sort__snoop_cmp,
+        .se_snprintf    = hist_entry__snoop_snprintf,
+        .se_width_idx   = HISTC_MEM_SNOOP,
+};
+
 struct sort_dimension {
         const char              *name;
         struct sort_entry       *entry;
@@ -484,30 +864,70 @@ struct sort_dimension {
 
 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
 
-static struct sort_dimension sort_dimensions[] = {
+static struct sort_dimension common_sort_dimensions[] = {
         DIM(SORT_PID, "pid", sort_thread),
         DIM(SORT_COMM, "comm", sort_comm),
         DIM(SORT_DSO, "dso", sort_dso),
-        DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
-        DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
         DIM(SORT_SYM, "symbol", sort_sym),
-        DIM(SORT_SYM_TO, "symbol_from", sort_sym_from),
-        DIM(SORT_SYM_FROM, "symbol_to", sort_sym_to),
         DIM(SORT_PARENT, "parent", sort_parent),
         DIM(SORT_CPU, "cpu", sort_cpu),
-        DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
         DIM(SORT_SRCLINE, "srcline", sort_srcline),
 };
 
+#undef DIM
+
+#define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
+
+static struct sort_dimension bstack_sort_dimensions[] = {
+        DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
+        DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
+        DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
+        DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
+        DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
+};
+
+#undef DIM
+
+#define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
+
+static struct sort_dimension memory_sort_dimensions[] = {
+        DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
+        DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
+        DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
+        DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
+        DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
+        DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
+        DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
+        DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
+};
+
+#undef DIM
+
+static void __sort_dimension__add(struct sort_dimension *sd, enum sort_type idx)
+{
+        if (sd->taken)
+                return;
+
+        if (sd->entry->se_collapse)
+                sort__need_collapse = 1;
+
+        if (list_empty(&hist_entry__sort_list))
+                sort__first_dimension = idx;
+
+        list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+        sd->taken = 1;
+}
+
 int sort_dimension__add(const char *tok)
 {
         unsigned int i;
 
-        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
-                struct sort_dimension *sd = &sort_dimensions[i];
+        for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
+                struct sort_dimension *sd = &common_sort_dimensions[i];
 
                 if (strncasecmp(tok, sd->name, strlen(tok)))
                         continue;
+
                 if (sd->entry == &sort_parent) {
                         int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
                         if (ret) {
@@ -518,68 +938,78 @@ int sort_dimension__add(const char *tok)
                                 return -EINVAL;
                         }
                         sort__has_parent = 1;
-                } else if (sd->entry == &sort_sym ||
-                           sd->entry == &sort_sym_from ||
-                           sd->entry == &sort_sym_to) {
+                } else if (sd->entry == &sort_sym) {
                         sort__has_sym = 1;
                 }
 
-                if (sd->taken)
-                        return 0;
-
-                if (sd->entry->se_collapse)
-                        sort__need_collapse = 1;
-
-                if (list_empty(&hist_entry__sort_list)) {
-                        if (!strcmp(sd->name, "pid"))
-                                sort__first_dimension = SORT_PID;
-                        else if (!strcmp(sd->name, "comm"))
-                                sort__first_dimension = SORT_COMM;
-                        else if (!strcmp(sd->name, "dso"))
-                                sort__first_dimension = SORT_DSO;
-                        else if (!strcmp(sd->name, "symbol"))
-                                sort__first_dimension = SORT_SYM;
-                        else if (!strcmp(sd->name, "parent"))
-                                sort__first_dimension = SORT_PARENT;
-                        else if (!strcmp(sd->name, "cpu"))
-                                sort__first_dimension = SORT_CPU;
-                        else if (!strcmp(sd->name, "symbol_from"))
-                                sort__first_dimension = SORT_SYM_FROM;
-                        else if (!strcmp(sd->name, "symbol_to"))
-                                sort__first_dimension = SORT_SYM_TO;
-                        else if (!strcmp(sd->name, "dso_from"))
-                                sort__first_dimension = SORT_DSO_FROM;
-                        else if (!strcmp(sd->name, "dso_to"))
-                                sort__first_dimension = SORT_DSO_TO;
-                        else if (!strcmp(sd->name, "mispredict"))
-                                sort__first_dimension = SORT_MISPREDICT;
-                }
+                __sort_dimension__add(sd, i);
+                return 0;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
+                struct sort_dimension *sd = &bstack_sort_dimensions[i];
+
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
+
+                if (sort__mode != SORT_MODE__BRANCH)
+                        return -EINVAL;
+
+                if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
+                        sort__has_sym = 1;
+
+                __sort_dimension__add(sd, i + __SORT_BRANCH_STACK);
+                return 0;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
+                struct sort_dimension *sd = &memory_sort_dimensions[i];
 
-                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-                sd->taken = 1;
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
+
+                if (sort__mode != SORT_MODE__MEMORY)
+                        return -EINVAL;
+
+                if (sd->entry == &sort_mem_daddr_sym)
+                        sort__has_sym = 1;
 
+                __sort_dimension__add(sd, i + __SORT_MEMORY_MODE);
                 return 0;
         }
+
         return -ESRCH;
 }
 
-void setup_sorting(const char * const usagestr[], const struct option *opts)
+int setup_sorting(void)
 {
         char *tmp, *tok, *str = strdup(sort_order);
+        int ret = 0;
+
+        if (str == NULL) {
+                error("Not enough memory to setup sort keys");
+                return -ENOMEM;
+        }
 
         for (tok = strtok_r(str, ", ", &tmp);
                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
-                if (sort_dimension__add(tok) < 0) {
+                ret = sort_dimension__add(tok);
+                if (ret == -EINVAL) {
+                        error("Invalid --sort key: `%s'", tok);
+                        break;
+                } else if (ret == -ESRCH) {
                         error("Unknown --sort key: `%s'", tok);
-                        usage_with_options(usagestr, opts);
+                        break;
                 }
         }
 
         free(str);
+        return ret;
 }
 
-void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
-                             const char *list_name, FILE *fp)
+static void sort_entry__setup_elide(struct sort_entry *self,
+                                    struct strlist *list,
+                                    const char *list_name, FILE *fp)
 {
         if (list && strlist__nr_entries(list) == 1) {
                 if (fp != NULL)
@@ -588,3 +1018,42 @@ void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
                 self->elide = true;
         }
 }
+
+void sort__setup_elide(FILE *output)
+{
+        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                "dso", output);
+        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list,
+                                "comm", output);
+        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list,
+                                "symbol", output);
+
+        if (sort__mode == SORT_MODE__BRANCH) {
+                sort_entry__setup_elide(&sort_dso_from,
+                                        symbol_conf.dso_from_list,
+                                        "dso_from", output);
+                sort_entry__setup_elide(&sort_dso_to,
+                                        symbol_conf.dso_to_list,
+                                        "dso_to", output);
+                sort_entry__setup_elide(&sort_sym_from,
+                                        symbol_conf.sym_from_list,
+                                        "sym_from", output);
+                sort_entry__setup_elide(&sort_sym_to,
+                                        symbol_conf.sym_to_list,
+                                        "sym_to", output);
+        } else if (sort__mode == SORT_MODE__MEMORY) {
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "symbol_daddr", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "dso_daddr", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "mem", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "local_weight", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "tlb", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "snoop", output);
+        }
+
+}
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index b4e8c3ba559d..45ac84c1e037 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -32,7 +32,7 @@ extern const char default_sort_order[];
 extern int sort__need_collapse;
 extern int sort__has_parent;
 extern int sort__has_sym;
-extern int sort__branch_mode;
+extern enum sort_mode sort__mode;
 extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
@@ -49,15 +49,13 @@ struct he_stat {
         u64                     period_us;
         u64                     period_guest_sys;
         u64                     period_guest_us;
+        u64                     weight;
         u32                     nr_events;
 };
 
 struct hist_entry_diff {
         bool    computed;
 
-        /* PERF_HPP__DISPL */
-        int     displacement;
-
         /* PERF_HPP__DELTA */
         double  period_ratio_delta;
 
@@ -103,7 +101,8 @@ struct hist_entry {
         struct rb_root          sorted_chain;
         struct branch_info      *branch_info;
         struct hists            *hists;
-        struct callchain_root   callchain[0];
+        struct mem_info         *mem_info;
+        struct callchain_root   callchain[0]; /* must be last member */
 };
 
 static inline bool hist_entry__has_pairs(struct hist_entry *he)
@@ -118,25 +117,46 @@ static inline struct hist_entry *hist_entry__next_pair(struct hist_entry *he)
         return NULL;
 }
 
-static inline void hist__entry_add_pair(struct hist_entry *he,
-                                        struct hist_entry *pair)
+static inline void hist_entry__add_pair(struct hist_entry *pair,
+                                        struct hist_entry *he)
 {
-        list_add_tail(&he->pairs.head, &pair->pairs.node);
+        list_add_tail(&pair->pairs.node, &he->pairs.head);
 }
 
+enum sort_mode {
+        SORT_MODE__NORMAL,
+        SORT_MODE__BRANCH,
+        SORT_MODE__MEMORY,
+};
+
 enum sort_type {
+        /* common sort keys */
         SORT_PID,
         SORT_COMM,
         SORT_DSO,
         SORT_SYM,
         SORT_PARENT,
         SORT_CPU,
-        SORT_DSO_FROM,
+        SORT_SRCLINE,
+
+        /* branch stack specific sort keys */
+        __SORT_BRANCH_STACK,
+        SORT_DSO_FROM = __SORT_BRANCH_STACK,
         SORT_DSO_TO,
         SORT_SYM_FROM,
         SORT_SYM_TO,
         SORT_MISPREDICT,
-        SORT_SRCLINE,
+
+        /* memory mode specific sort keys */
+        __SORT_MEMORY_MODE,
+        SORT_LOCAL_WEIGHT = __SORT_MEMORY_MODE,
+        SORT_GLOBAL_WEIGHT,
+        SORT_MEM_DADDR_SYMBOL,
+        SORT_MEM_DADDR_DSO,
+        SORT_MEM_LOCKED,
+        SORT_MEM_TLB,
+        SORT_MEM_LVL,
+        SORT_MEM_SNOOP,
 };
 
 /*
@@ -159,9 +179,8 @@ struct sort_entry {
 extern struct sort_entry sort_thread;
 extern struct list_head hist_entry__sort_list;
 
-void setup_sorting(const char * const usagestr[], const struct option *opts);
+int setup_sorting(void);
 extern int sort_dimension__add(const char *);
-void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
-                             const char *list_name, FILE *fp);
+void sort__setup_elide(FILE *fp);
 
 #endif  /* __PERF_SORT_H */
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index 23742126f47c..7c59c28afcc5 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -37,7 +37,7 @@ double stddev_stats(struct stats *stats)
 {
         double variance, variance_mean;
 
-        if (!stats->n)
+        if (stats->n < 2)
                 return 0.0;
 
         variance = stats->M2 / (stats->n - 1);
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index 346707df04b9..29c7b2cb2521 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -332,6 +332,24 @@ char *strxfrchar(char *s, char from, char to)
 }
 
 /**
+ * ltrim - Removes leading whitespace from @s.
+ * @s: The string to be stripped.
+ *
+ * Return pointer to the first non-whitespace character in @s.
+ */
+char *ltrim(char *s)
+{
+        int len = strlen(s);
+
+        while (len && isspace(*s)) {
+                len--;
+                s++;
+        }
+
+        return s;
+}
+
+/**
  * rtrim - Removes trailing whitespace from @s.
  * @s: The string to be stripped.
  *
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
index 155d8b7078a7..eabdce0a2daa 100644
--- a/tools/perf/util/strlist.c
+++ b/tools/perf/util/strlist.c
@@ -35,11 +35,11 @@ out_delete:
         return NULL;
 }
 
-static void str_node__delete(struct str_node *self, bool dupstr)
+static void str_node__delete(struct str_node *snode, bool dupstr)
 {
         if (dupstr)
-                free((void *)self->s);
-        free(self);
+                free((void *)snode->s);
+        free(snode);
 }
 
 static
@@ -59,12 +59,12 @@ static int strlist__node_cmp(struct rb_node *rb_node, const void *entry)
         return strcmp(snode->s, str);
 }
 
-int strlist__add(struct strlist *self, const char *new_entry)
+int strlist__add(struct strlist *slist, const char *new_entry)
 {
-        return rblist__add_node(&self->rblist, new_entry);
+        return rblist__add_node(&slist->rblist, new_entry);
 }
 
-int strlist__load(struct strlist *self, const char *filename)
+int strlist__load(struct strlist *slist, const char *filename)
 {
         char entry[1024];
         int err;
@@ -80,7 +80,7 @@ int strlist__load(struct strlist *self, const char *filename)
                         continue;
                 entry[len - 1] = '\0';
 
-                err = strlist__add(self, entry);
+                err = strlist__add(slist, entry);
                 if (err != 0)
                         goto out;
         }
@@ -107,56 +107,56 @@ struct str_node *strlist__find(struct strlist *slist, const char *entry)
         return snode;
 }
 
-static int strlist__parse_list_entry(struct strlist *self, const char *s)
+static int strlist__parse_list_entry(struct strlist *slist, const char *s)
 {
         if (strncmp(s, "file://", 7) == 0)
-                return strlist__load(self, s + 7);
+                return strlist__load(slist, s + 7);
 
-        return strlist__add(self, s);
+        return strlist__add(slist, s);
 }
 
-int strlist__parse_list(struct strlist *self, const char *s)
+int strlist__parse_list(struct strlist *slist, const char *s)
 {
         char *sep;
         int err;
 
         while ((sep = strchr(s, ',')) != NULL) {
                 *sep = '\0';
-                err = strlist__parse_list_entry(self, s);
+                err = strlist__parse_list_entry(slist, s);
                 *sep = ',';
                 if (err != 0)
                         return err;
                 s = sep + 1;
         }
 
-        return *s ? strlist__parse_list_entry(self, s) : 0;
+        return *s ? strlist__parse_list_entry(slist, s) : 0;
 }
 
-struct strlist *strlist__new(bool dupstr, const char *slist)
+struct strlist *strlist__new(bool dupstr, const char *list)
 {
-        struct strlist *self = malloc(sizeof(*self));
+        struct strlist *slist = malloc(sizeof(*slist));
 
-        if (self != NULL) {
-                rblist__init(&self->rblist);
-                self->rblist.node_cmp    = strlist__node_cmp;
-                self->rblist.node_new    = strlist__node_new;
-                self->rblist.node_delete = strlist__node_delete;
+        if (slist != NULL) {
+                rblist__init(&slist->rblist);
+                slist->rblist.node_cmp    = strlist__node_cmp;
+                slist->rblist.node_new    = strlist__node_new;
+                slist->rblist.node_delete = strlist__node_delete;
 
-                self->dupstr     = dupstr;
-                if (slist && strlist__parse_list(self, slist) != 0)
+                slist->dupstr    = dupstr;
+                if (list && strlist__parse_list(slist, list) != 0)
                         goto out_error;
         }
 
-        return self;
+        return slist;
 out_error:
-        free(self);
+        free(slist);
         return NULL;
 }
 
-void strlist__delete(struct strlist *self)
+void strlist__delete(struct strlist *slist)
 {
-        if (self != NULL)
-                rblist__delete(&self->rblist);
+        if (slist != NULL)
+                rblist__delete(&slist->rblist);
 }
 
 struct str_node *strlist__entry(const struct strlist *slist, unsigned int idx)
diff --git a/tools/perf/util/strlist.h b/tools/perf/util/strlist.h
index dd9f922ec67c..5c7f87069d9c 100644
--- a/tools/perf/util/strlist.h
+++ b/tools/perf/util/strlist.h
@@ -17,34 +17,34 @@ struct strlist {
 };
 
 struct strlist *strlist__new(bool dupstr, const char *slist);
-void strlist__delete(struct strlist *self);
+void strlist__delete(struct strlist *slist);
 
-void strlist__remove(struct strlist *self, struct str_node *sn);
-int strlist__load(struct strlist *self, const char *filename);
-int strlist__add(struct strlist *self, const char *str);
+void strlist__remove(struct strlist *slist, struct str_node *sn);
+int strlist__load(struct strlist *slist, const char *filename);
+int strlist__add(struct strlist *slist, const char *str);
 
-struct str_node *strlist__entry(const struct strlist *self, unsigned int idx);
-struct str_node *strlist__find(struct strlist *self, const char *entry);
+struct str_node *strlist__entry(const struct strlist *slist, unsigned int idx);
+struct str_node *strlist__find(struct strlist *slist, const char *entry);
 
-static inline bool strlist__has_entry(struct strlist *self, const char *entry)
+static inline bool strlist__has_entry(struct strlist *slist, const char *entry)
 {
-        return strlist__find(self, entry) != NULL;
+        return strlist__find(slist, entry) != NULL;
 }
 
-static inline bool strlist__empty(const struct strlist *self)
+static inline bool strlist__empty(const struct strlist *slist)
 {
-        return rblist__empty(&self->rblist);
+        return rblist__empty(&slist->rblist);
 }
 
-static inline unsigned int strlist__nr_entries(const struct strlist *self)
+static inline unsigned int strlist__nr_entries(const struct strlist *slist)
 {
-        return rblist__nr_entries(&self->rblist);
+        return rblist__nr_entries(&slist->rblist);
 }
 
 /* For strlist iteration */
-static inline struct str_node *strlist__first(struct strlist *self)
+static inline struct str_node *strlist__first(struct strlist *slist)
 {
-        struct rb_node *rn = rb_first(&self->rblist.entries);
+        struct rb_node *rn = rb_first(&slist->rblist.entries);
         return rn ? rb_entry(rn, struct str_node, rb_node) : NULL;
 }
 static inline struct str_node *strlist__next(struct str_node *sn)
@@ -59,21 +59,21 @@ static inline struct str_node *strlist__next(struct str_node *sn)
 /**
  * strlist_for_each      - iterate over a strlist
  * @pos:        the &struct str_node to use as a loop cursor.
- * @self:       the &struct strlist for loop.
+ * @slist:      the &struct strlist for loop.
  */
-#define strlist__for_each(pos, self)    \
-        for (pos = strlist__first(self); pos; pos = strlist__next(pos))
+#define strlist__for_each(pos, slist)   \
+        for (pos = strlist__first(slist); pos; pos = strlist__next(pos))
 
 /**
  * strlist_for_each_safe - iterate over a strlist safe against removal of
  *                         str_node
  * @pos:        the &struct str_node to use as a loop cursor.
  * @n:          another &struct str_node to use as temporary storage.
- * @self:       the &struct strlist for loop.
+ * @slist:      the &struct strlist for loop.
  */
-#define strlist__for_each_safe(pos, n, self)    \
-        for (pos = strlist__first(self), n = strlist__next(pos); pos;\
+#define strlist__for_each_safe(pos, n, slist)   \
+        for (pos = strlist__first(slist), n = strlist__next(pos); pos;\
              pos = n, n = strlist__next(n))
 
-int strlist__parse_list(struct strlist *self, const char *s);
+int strlist__parse_list(struct strlist *slist, const char *s);
 #endif /* __PERF_STRLIST_H */
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index db0cc92cf2ea..4b12bf850325 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -1,6 +1,3 @@
-#include <libelf.h>
-#include <gelf.h>
-#include <elf.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <errno.h>
@@ -718,6 +715,17 @@ int dso__load_sym(struct dso *dso, struct map *map,
                                         sym.st_value);
                         used_opd = true;
                 }
+                /*
+                 * When loading symbols in a data mapping, ABS symbols (which
+                 * has a value of SHN_ABS in its st_shndx) failed at
+                 * elf_getscn().  And it marks the loading as a failure so
+                 * already loaded symbols cannot be fixed up.
+                 *
+                 * I'm not sure what should be done. Just ignore them for now.
+                 * - Namhyung Kim
+                 */
+                if (sym.st_shndx == SHN_ABS)
+                        continue;
 
                 sec = elf_getscn(runtime_ss->elf, sym.st_shndx);
                 if (!sec)
@@ -798,9 +806,12 @@ int dso__load_sym(struct dso *dso, struct map *map,
                  * DWARF DW_compile_unit has this, but we don't always have access
                  * to it...
                  */
-                demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
-                if (demangled != NULL)
-                        elf_name = demangled;
+                if (symbol_conf.demangle) {
+                        demangled = bfd_demangle(NULL, elf_name,
+                                                 DMGL_PARAMS | DMGL_ANSI);
+                        if (demangled != NULL)
+                                elf_name = demangled;
+                }
 new_symbol:
                 f = symbol__new(sym.st_value, sym.st_size,
                                 GELF_ST_BIND(sym.st_info), elf_name);
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index 259f8f2ea9c9..a7390cde63bc 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -1,6 +1,5 @@
 #include "symbol.h"
 
-#include <elf.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <string.h>
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 295f8d4feedf..8cf3b5426a9a 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -28,14 +28,15 @@ static int dso__load_kernel_sym(struct dso *dso, struct map *map,
                                 symbol_filter_t filter);
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
                         symbol_filter_t filter);
-static int vmlinux_path__nr_entries;
-static char **vmlinux_path;
+int vmlinux_path__nr_entries;
+char **vmlinux_path;
 
 struct symbol_conf symbol_conf = {
         .exclude_other    = true,
         .use_modules      = true,
         .try_vmlinux_path = true,
         .annotate_src     = true,
+        .demangle         = true,
         .symfs            = "",
 };
 
@@ -202,13 +203,6 @@ void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
         curr->end = ~0ULL;
 }
 
-static void map_groups__fixup_end(struct map_groups *mg)
-{
-        int i;
-        for (i = 0; i < MAP__NR_TYPES; ++i)
-                __map_groups__fixup_end(mg, i);
-}
-
 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
 {
         size_t namelen = strlen(name) + 1;
@@ -652,8 +646,8 @@ discard_symbol:		rb_erase(&pos->rb_node, root);
         return count + moved;
 }
 
-static bool symbol__restricted_filename(const char *filename,
-                                        const char *restricted_filename)
+bool symbol__restricted_filename(const char *filename,
+                                 const char *restricted_filename)
 {
         bool restricted = false;
 
@@ -775,10 +769,6 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
         else
                 machine = NULL;
 
-        name = malloc(PATH_MAX);
-        if (!name)
-                return -1;
-
         dso->adjust_symbols = 0;
 
         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
@@ -802,6 +792,10 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
         if (machine)
                 root_dir = machine->root_dir;
 
+        name = malloc(PATH_MAX);
+        if (!name)
+                return -1;
+
         /* Iterate over candidate debug images.
          * Keep track of "interesting" ones (those which have a symtab, dynsym,
          * and/or opd section) for processing.
@@ -887,200 +881,6 @@ struct map *map_groups__find_by_name(struct map_groups *mg,
         return NULL;
 }
 
-static int map_groups__set_modules_path_dir(struct map_groups *mg,
-                                const char *dir_name)
-{
-        struct dirent *dent;
-        DIR *dir = opendir(dir_name);
-        int ret = 0;
-
-        if (!dir) {
-                pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
-                return -1;
-        }
-
-        while ((dent = readdir(dir)) != NULL) {
-                char path[PATH_MAX];
-                struct stat st;
-
-                /*sshfs might return bad dent->d_type, so we have to stat*/
-                snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
-                if (stat(path, &st))
-                        continue;
-
-                if (S_ISDIR(st.st_mode)) {
-                        if (!strcmp(dent->d_name, ".") ||
-                            !strcmp(dent->d_name, ".."))
-                                continue;
-
-                        ret = map_groups__set_modules_path_dir(mg, path);
-                        if (ret < 0)
-                                goto out;
-                } else {
-                        char *dot = strrchr(dent->d_name, '.'),
-                             dso_name[PATH_MAX];
-                        struct map *map;
-                        char *long_name;
-
-                        if (dot == NULL || strcmp(dot, ".ko"))
-                                continue;
-                        snprintf(dso_name, sizeof(dso_name), "[%.*s]",
-                                 (int)(dot - dent->d_name), dent->d_name);
-
-                        strxfrchar(dso_name, '-', '_');
-                        map = map_groups__find_by_name(mg, MAP__FUNCTION,
-                                                       dso_name);
-                        if (map == NULL)
-                                continue;
-
-                        long_name = strdup(path);
-                        if (long_name == NULL) {
-                                ret = -1;
-                                goto out;
-                        }
-                        dso__set_long_name(map->dso, long_name);
-                        map->dso->lname_alloc = 1;
-                        dso__kernel_module_get_build_id(map->dso, "");
-                }
-        }
-
-out:
-        closedir(dir);
-        return ret;
-}
-
-static char *get_kernel_version(const char *root_dir)
-{
-        char version[PATH_MAX];
-        FILE *file;
-        char *name, *tmp;
-        const char *prefix = "Linux version ";
-
-        sprintf(version, "%s/proc/version", root_dir);
-        file = fopen(version, "r");
-        if (!file)
-                return NULL;
-
-        version[0] = '\0';
-        tmp = fgets(version, sizeof(version), file);
-        fclose(file);
-
-        name = strstr(version, prefix);
-        if (!name)
-                return NULL;
-        name += strlen(prefix);
-        tmp = strchr(name, ' ');
-        if (tmp)
-                *tmp = '\0';
-
-        return strdup(name);
-}
-
-static int machine__set_modules_path(struct machine *machine)
-{
-        char *version;
-        char modules_path[PATH_MAX];
-
-        version = get_kernel_version(machine->root_dir);
-        if (!version)
-                return -1;
-
-        snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
-                 machine->root_dir, version);
-        free(version);
-
-        return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
-}
-
-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);
-
-        if (dso == NULL)
-                return NULL;
-
-        map = map__new2(start, dso, MAP__FUNCTION);
-        if (map == 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;
-        map_groups__insert(&machine->kmaps, map);
-        return map;
-}
-
-static int machine__create_modules(struct machine *machine)
-{
-        char *line = NULL;
-        size_t n;
-        FILE *file;
-        struct map *map;
-        const char *modules;
-        char path[PATH_MAX];
-
-        if (machine__is_default_guest(machine))
-                modules = symbol_conf.default_guest_modules;
-        else {
-                sprintf(path, "%s/proc/modules", machine->root_dir);
-                modules = path;
-        }
-
-        if (symbol__restricted_filename(path, "/proc/modules"))
-                return -1;
-
-        file = fopen(modules, "r");
-        if (file == NULL)
-                return -1;
-
-        while (!feof(file)) {
-                char name[PATH_MAX];
-                u64 start;
-                char *sep;
-                int line_len;
-
-                line_len = getline(&line, &n, file);
-                if (line_len < 0)
-                        break;
-
-                if (!line)
-                        goto out_failure;
-
-                line[--line_len] = '\0'; /* \n */
-
-                sep = strrchr(line, 'x');
-                if (sep == NULL)
-                        continue;
-
-                hex2u64(sep + 1, &start);
-
-                sep = strchr(line, ' ');
-                if (sep == NULL)
-                        continue;
-
-                *sep = '\0';
-
-                snprintf(name, sizeof(name), "[%s]", line);
-                map = machine__new_module(machine, start, name);
-                if (map == NULL)
-                        goto out_delete_line;
-                dso__kernel_module_get_build_id(map->dso, machine->root_dir);
-        }
-
-        free(line);
-        fclose(file);
-
-        return machine__set_modules_path(machine);
-
-out_delete_line:
-        free(line);
-out_failure:
-        return -1;
-}
-
 int dso__load_vmlinux(struct dso *dso, struct map *map,
                       const char *vmlinux, symbol_filter_t filter)
 {
@@ -1124,8 +924,10 @@ int dso__load_vmlinux_path(struct dso *dso, struct map *map,
         filename = dso__build_id_filename(dso, NULL, 0);
         if (filename != NULL) {
                 err = dso__load_vmlinux(dso, map, filename, filter);
-                if (err > 0)
+                if (err > 0) {
+                        dso->lname_alloc = 1;
                         goto out;
+                }
                 free(filename);
         }
 
@@ -1133,6 +935,7 @@ int dso__load_vmlinux_path(struct dso *dso, struct map *map,
                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
                 if (err > 0) {
                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
+                        dso->lname_alloc = 1;
                         break;
                 }
         }
@@ -1172,6 +975,7 @@ static int dso__load_kernel_sym(struct dso *dso, struct map *map,
                 if (err > 0) {
                         dso__set_long_name(dso,
                                            strdup(symbol_conf.vmlinux_name));
+                        dso->lname_alloc = 1;
                         goto out_fixup;
                 }
                 return err;
@@ -1300,195 +1104,6 @@ out_try_fixup:
         return err;
 }
 
-size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
-{
-        struct rb_node *nd;
-        size_t ret = 0;
-
-        for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
-                struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                ret += __dsos__fprintf(&pos->kernel_dsos, fp);
-                ret += __dsos__fprintf(&pos->user_dsos, fp);
-        }
-
-        return ret;
-}
-
-size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
-                                     bool with_hits)
-{
-        return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
-               __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
-}
-
-size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
-                                      FILE *fp, bool with_hits)
-{
-        struct rb_node *nd;
-        size_t ret = 0;
-
-        for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
-                struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
-        }
-        return ret;
-}
-
-static struct dso *machine__get_kernel(struct machine *machine)
-{
-        const char *vmlinux_name = NULL;
-        struct dso *kernel;
-
-        if (machine__is_host(machine)) {
-                vmlinux_name = symbol_conf.vmlinux_name;
-                if (!vmlinux_name)
-                        vmlinux_name = "[kernel.kallsyms]";
-
-                kernel = dso__kernel_findnew(machine, vmlinux_name,
-                                             "[kernel]",
-                                             DSO_TYPE_KERNEL);
-        } else {
-                char bf[PATH_MAX];
-
-                if (machine__is_default_guest(machine))
-                        vmlinux_name = symbol_conf.default_guest_vmlinux_name;
-                if (!vmlinux_name)
-                        vmlinux_name = machine__mmap_name(machine, bf,
-                                                          sizeof(bf));
-
-                kernel = dso__kernel_findnew(machine, vmlinux_name,
-                                             "[guest.kernel]",
-                                             DSO_TYPE_GUEST_KERNEL);
-        }
-
-        if (kernel != NULL && (!kernel->has_build_id))
-                dso__read_running_kernel_build_id(kernel, machine);
-
-        return kernel;
-}
-
-struct process_args {
-        u64 start;
-};
-
-static int symbol__in_kernel(void *arg, const char *name,
-                             char type __maybe_unused, u64 start)
-{
-        struct process_args *args = arg;
-
-        if (strchr(name, '['))
-                return 0;
-
-        args->start = start;
-        return 1;
-}
-
-/* Figure out the start address of kernel map from /proc/kallsyms */
-static u64 machine__get_kernel_start_addr(struct machine *machine)
-{
-        const char *filename;
-        char path[PATH_MAX];
-        struct process_args args;
-
-        if (machine__is_host(machine)) {
-                filename = "/proc/kallsyms";
-        } else {
-                if (machine__is_default_guest(machine))
-                        filename = (char *)symbol_conf.default_guest_kallsyms;
-                else {
-                        sprintf(path, "%s/proc/kallsyms", machine->root_dir);
-                        filename = path;
-                }
-        }
-
-        if (symbol__restricted_filename(filename, "/proc/kallsyms"))
-                return 0;
-
-        if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
-                return 0;
-
-        return args.start;
-}
-
-int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
-{
-        enum map_type type;
-        u64 start = machine__get_kernel_start_addr(machine);
-
-        for (type = 0; type < MAP__NR_TYPES; ++type) {
-                struct kmap *kmap;
-
-                machine->vmlinux_maps[type] = map__new2(start, kernel, type);
-                if (machine->vmlinux_maps[type] == NULL)
-                        return -1;
-
-                machine->vmlinux_maps[type]->map_ip =
-                        machine->vmlinux_maps[type]->unmap_ip =
-                                identity__map_ip;
-                kmap = map__kmap(machine->vmlinux_maps[type]);
-                kmap->kmaps = &machine->kmaps;
-                map_groups__insert(&machine->kmaps,
-                                   machine->vmlinux_maps[type]);
-        }
-
-        return 0;
-}
-
-void machine__destroy_kernel_maps(struct machine *machine)
-{
-        enum map_type type;
-
-        for (type = 0; type < MAP__NR_TYPES; ++type) {
-                struct kmap *kmap;
-
-                if (machine->vmlinux_maps[type] == NULL)
-                        continue;
-
-                kmap = map__kmap(machine->vmlinux_maps[type]);
-                map_groups__remove(&machine->kmaps,
-                                   machine->vmlinux_maps[type]);
-                if (kmap->ref_reloc_sym) {
-                        /*
-                         * ref_reloc_sym is shared among all maps, so free just
-                         * on one of them.
-                         */
-                        if (type == MAP__FUNCTION) {
-                                free((char *)kmap->ref_reloc_sym->name);
-                                kmap->ref_reloc_sym->name = NULL;
-                                free(kmap->ref_reloc_sym);
-                        }
-                        kmap->ref_reloc_sym = NULL;
-                }
-
-                map__delete(machine->vmlinux_maps[type]);
-                machine->vmlinux_maps[type] = NULL;
-        }
-}
-
-int machine__create_kernel_maps(struct machine *machine)
-{
-        struct dso *kernel = machine__get_kernel(machine);
-
-        if (kernel == NULL ||
-            __machine__create_kernel_maps(machine, kernel) < 0)
-                return -1;
-
-        if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
-                if (machine__is_host(machine))
-                        pr_debug("Problems creating module maps, "
-                                 "continuing anyway...\n");
-                else
-                        pr_debug("Problems creating module maps for guest %d, "
-                                 "continuing anyway...\n", machine->pid);
-        }
-
-        /*
-         * Now that we have all the maps created, just set the ->end of them:
-         */
-        map_groups__fixup_end(&machine->kmaps);
-        return 0;
-}
-
 static void vmlinux_path__exit(void)
 {
         while (--vmlinux_path__nr_entries >= 0) {
@@ -1549,25 +1164,6 @@ out_fail:
         return -1;
 }
 
-size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
-{
-        int i;
-        size_t printed = 0;
-        struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
-
-        if (kdso->has_build_id) {
-                char filename[PATH_MAX];
-                if (dso__build_id_filename(kdso, filename, sizeof(filename)))
-                        printed += fprintf(fp, "[0] %s\n", filename);
-        }
-
-        for (i = 0; i < vmlinux_path__nr_entries; ++i)
-                printed += fprintf(fp, "[%d] %s\n",
-                                   i + kdso->has_build_id, vmlinux_path[i]);
-
-        return printed;
-}
-
 static int setup_list(struct strlist **list, const char *list_str,
                       const char *list_name)
 {
@@ -1671,108 +1267,3 @@ void symbol__exit(void)
         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
         symbol_conf.initialized = false;
 }
-
-int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
-{
-        struct machine *machine = machines__findnew(machines, pid);
-
-        if (machine == NULL)
-                return -1;
-
-        return machine__create_kernel_maps(machine);
-}
-
-int machines__create_guest_kernel_maps(struct rb_root *machines)
-{
-        int ret = 0;
-        struct dirent **namelist = NULL;
-        int i, items = 0;
-        char path[PATH_MAX];
-        pid_t pid;
-        char *endp;
-
-        if (symbol_conf.default_guest_vmlinux_name ||
-            symbol_conf.default_guest_modules ||
-            symbol_conf.default_guest_kallsyms) {
-                machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
-        }
-
-        if (symbol_conf.guestmount) {
-                items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
-                if (items <= 0)
-                        return -ENOENT;
-                for (i = 0; i < items; i++) {
-                        if (!isdigit(namelist[i]->d_name[0])) {
-                                /* Filter out . and .. */
-                                continue;
-                        }
-                        pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10);
-                        if ((*endp != '\0') ||
-                            (endp == namelist[i]->d_name) ||
-                            (errno == ERANGE)) {
-                                pr_debug("invalid directory (%s). Skipping.\n",
-                                         namelist[i]->d_name);
-                                continue;
-                        }
-                        sprintf(path, "%s/%s/proc/kallsyms",
-                                symbol_conf.guestmount,
-                                namelist[i]->d_name);
-                        ret = access(path, R_OK);
-                        if (ret) {
-                                pr_debug("Can't access file %s\n", path);
-                                goto failure;
-                        }
-                        machines__create_kernel_maps(machines, pid);
-                }
-failure:
-                free(namelist);
-        }
-
-        return ret;
-}
-
-void machines__destroy_guest_kernel_maps(struct rb_root *machines)
-{
-        struct rb_node *next = rb_first(machines);
-
-        while (next) {
-                struct machine *pos = rb_entry(next, struct machine, rb_node);
-
-                next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, machines);
-                machine__delete(pos);
-        }
-}
-
-int machine__load_kallsyms(struct machine *machine, const char *filename,
-                           enum map_type type, symbol_filter_t filter)
-{
-        struct map *map = machine->vmlinux_maps[type];
-        int ret = dso__load_kallsyms(map->dso, filename, map, filter);
-
-        if (ret > 0) {
-                dso__set_loaded(map->dso, type);
-                /*
-                 * Since /proc/kallsyms will have multiple sessions for the
-                 * kernel, with modules between them, fixup the end of all
-                 * sections.
-                 */
-                __map_groups__fixup_end(&machine->kmaps, type);
-        }
-
-        return ret;
-}
-
-int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
-                               symbol_filter_t filter)
-{
-        struct map *map = machine->vmlinux_maps[type];
-        int ret = dso__load_vmlinux_path(map->dso, map, filter);
-
-        if (ret > 0) {
-                dso__set_loaded(map->dso, type);
-                map__reloc_vmlinux(map);
-        }
-
-        return ret;
-}
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index de68f98b236d..5f720dc076da 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -16,8 +16,8 @@
 #ifdef LIBELF_SUPPORT
 #include <libelf.h>
 #include <gelf.h>
-#include <elf.h>
 #endif
+#include <elf.h>
 
 #include "dso.h"
 
@@ -96,7 +96,9 @@ struct symbol_conf {
                         initialized,
                         kptr_restrict,
                         annotate_asm_raw,
-                        annotate_src;
+                        annotate_src,
+                        event_group,
+                        demangle;
         const char      *vmlinux_name,
                         *kallsyms_name,
                         *source_prefix,
@@ -120,6 +122,8 @@ struct symbol_conf {
 };
 
 extern struct symbol_conf symbol_conf;
+extern int vmlinux_path__nr_entries;
+extern char **vmlinux_path;
 
 static inline void *symbol__priv(struct symbol *sym)
 {
@@ -152,6 +156,12 @@ struct branch_info {
         struct branch_flags flags;
 };
 
+struct mem_info {
+        struct addr_map_symbol iaddr;
+        struct addr_map_symbol daddr;
+        union perf_mem_data_src data_src;
+};
+
 struct addr_location {
         struct thread *thread;
         struct map    *map;
@@ -223,6 +233,8 @@ size_t symbol__fprintf_symname_offs(const struct symbol *sym,
 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp);
 size_t symbol__fprintf(struct symbol *sym, FILE *fp);
 bool symbol_type__is_a(char symbol_type, enum map_type map_type);
+bool symbol__restricted_filename(const char *filename,
+                                 const char *restricted_filename);
 
 int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
                   struct symsrc *runtime_ss, symbol_filter_t filter,
diff --git a/tools/perf/util/sysfs.c b/tools/perf/util/sysfs.c
index 48c6902e749f..f71e9eafe15a 100644
--- a/tools/perf/util/sysfs.c
+++ b/tools/perf/util/sysfs.c
@@ -8,7 +8,7 @@ static const char * const sysfs_known_mountpoints[] = {
 };
 
 static int sysfs_found;
-char sysfs_mountpoint[PATH_MAX];
+char sysfs_mountpoint[PATH_MAX + 1];
 
 static int sysfs_valid_mountpoint(const char *sysfs)
 {
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index df59623ac763..40399cbcca77 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -14,6 +14,7 @@ struct thread *thread__new(pid_t pid)
         if (self != NULL) {
                 map_groups__init(&self->mg);
                 self->pid = pid;
+                self->ppid = -1;
                 self->comm = malloc(32);
                 if (self->comm)
                         snprintf(self->comm, 32, ":%d", self->pid);
@@ -54,10 +55,10 @@ int thread__comm_len(struct thread *self)
         return self->comm_len;
 }
 
-static size_t thread__fprintf(struct thread *self, FILE *fp)
+size_t thread__fprintf(struct thread *thread, FILE *fp)
 {
-        return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
-               map_groups__fprintf(&self->mg, verbose, fp);
+        return fprintf(fp, "Thread %d %s\n", thread->pid, thread->comm) +
+               map_groups__fprintf(&thread->mg, verbose, fp);
 }
 
 void thread__insert_map(struct thread *self, struct map *map)
@@ -82,19 +83,8 @@ int thread__fork(struct thread *self, struct thread *parent)
         for (i = 0; i < MAP__NR_TYPES; ++i)
                 if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
                         return -ENOMEM;
-        return 0;
-}
-
-size_t machine__fprintf(struct machine *machine, FILE *fp)
-{
-        size_t ret = 0;
-        struct rb_node *nd;
 
-        for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
-                struct thread *pos = rb_entry(nd, struct thread, rb_node);
+        self->ppid = parent->pid;
 
-                ret += thread__fprintf(pos, fp);
-        }
-
-        return ret;
+        return 0;
 }
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index f2fa17caa7d5..eeb7ac62b9e3 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -13,6 +13,7 @@ struct thread {
         };
         struct map_groups       mg;
         pid_t                   pid;
+        pid_t                   ppid;
         char                    shortname[3];
         bool                    comm_set;
         char                    *comm;
@@ -30,6 +31,7 @@ int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
 void thread__insert_map(struct thread *self, struct map *map);
 int thread__fork(struct thread *self, struct thread *parent);
+size_t thread__fprintf(struct thread *thread, FILE *fp);
 
 static inline struct map *thread__find_map(struct thread *self,
                                            enum map_type type, u64 addr)
diff --git a/tools/perf/util/thread_map.h b/tools/perf/util/thread_map.h
index f718df8a3c59..0cd8b3108084 100644
--- a/tools/perf/util/thread_map.h
+++ b/tools/perf/util/thread_map.h
@@ -21,4 +21,9 @@ void thread_map__delete(struct thread_map *threads);
 
 size_t thread_map__fprintf(struct thread_map *threads, FILE *fp);
 
+static inline int thread_map__nr(struct thread_map *threads)
+{
+        return threads ? threads->nr : 1;
+}
+
 #endif  /* __PERF_THREAD_MAP_H */
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index 884dde9b9bc1..f857b51b6bde 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -23,18 +23,31 @@
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
 {
-        float samples_per_sec = top->samples / top->delay_secs;
-        float ksamples_per_sec = top->kernel_samples / top->delay_secs;
-        float esamples_percent = (100.0 * top->exact_samples) / top->samples;
+        float samples_per_sec;
+        float ksamples_per_sec;
+        float esamples_percent;
+        struct perf_record_opts *opts = &top->record_opts;
+        struct perf_target *target = &opts->target;
         size_t ret = 0;
 
+        if (top->samples) {
+                samples_per_sec = top->samples / top->delay_secs;
+                ksamples_per_sec = top->kernel_samples / top->delay_secs;
+                esamples_percent = (100.0 * top->exact_samples) / top->samples;
+        } else {
+                samples_per_sec = ksamples_per_sec = esamples_percent = 0.0;
+        }
+
         if (!perf_guest) {
+                float ksamples_percent = 0.0;
+
+                if (samples_per_sec)
+                        ksamples_percent = (100.0 * ksamples_per_sec) /
+                                                        samples_per_sec;
                 ret = SNPRINTF(bf, size,
                                "   PerfTop:%8.0f irqs/sec  kernel:%4.1f%%"
                                "  exact: %4.1f%% [", samples_per_sec,
-                               100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) /
-                                        samples_per_sec)),
-                                esamples_percent);
+                               ksamples_percent, esamples_percent);
         } else {
                 float us_samples_per_sec = top->us_samples / top->delay_secs;
                 float guest_kernel_samples_per_sec = top->guest_kernel_samples / top->delay_secs;
@@ -61,31 +74,31 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
                 struct perf_evsel *first = perf_evlist__first(top->evlist);
                 ret += SNPRINTF(bf + ret, size - ret, "%" PRIu64 "%s ",
                                 (uint64_t)first->attr.sample_period,
-                                top->freq ? "Hz" : "");
+                                opts->freq ? "Hz" : "");
         }
 
         ret += SNPRINTF(bf + ret, size - ret, "%s", perf_evsel__name(top->sym_evsel));
 
         ret += SNPRINTF(bf + ret, size - ret, "], ");
 
-        if (top->target.pid)
+        if (target->pid)
                 ret += SNPRINTF(bf + ret, size - ret, " (target_pid: %s",
-                                top->target.pid);
-        else if (top->target.tid)
+                                target->pid);
+        else if (target->tid)
                 ret += SNPRINTF(bf + ret, size - ret, " (target_tid: %s",
-                                top->target.tid);
-        else if (top->target.uid_str != NULL)
+                                target->tid);
+        else if (target->uid_str != NULL)
                 ret += SNPRINTF(bf + ret, size - ret, " (uid: %s",
-                                top->target.uid_str);
+                                target->uid_str);
         else
                 ret += SNPRINTF(bf + ret, size - ret, " (all");
 
-        if (top->target.cpu_list)
+        if (target->cpu_list)
                 ret += SNPRINTF(bf + ret, size - ret, ", CPU%s: %s)",
                                 top->evlist->cpus->nr > 1 ? "s" : "",
-                                top->target.cpu_list);
+                                target->cpu_list);
         else {
-                if (top->target.tid)
+                if (target->tid)
                         ret += SNPRINTF(bf + ret, size - ret, ")");
                 else
                         ret += SNPRINTF(bf + ret, size - ret, ", %d CPU%s)",
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index 86ff1b15059b..df46be93d902 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -14,7 +14,7 @@ struct perf_session;
 struct perf_top {
         struct perf_tool   tool;
         struct perf_evlist *evlist;
-        struct perf_target target;
+        struct perf_record_opts record_opts;
         /*
          * Symbols will be added here in perf_event__process_sample and will
          * get out after decayed.
@@ -24,27 +24,19 @@ struct perf_top {
         u64                exact_samples;
         u64                guest_us_samples, guest_kernel_samples;
         int                print_entries, count_filter, delay_secs;
-        int                freq;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
         bool               use_tui, use_stdio;
-        bool               sort_has_symbols;
-        bool               dont_use_callchains;
         bool               kptr_restrict_warned;
         bool               vmlinux_warned;
-        bool               inherit;
-        bool               group;
-        bool               sample_id_all_missing;
-        bool               exclude_guest_missing;
         bool               dump_symtab;
         struct hist_entry  *sym_filter_entry;
         struct perf_evsel  *sym_evsel;
         struct perf_session *session;
         struct winsize     winsize;
-        unsigned int       mmap_pages;
-        int                default_interval;
         int                realtime_prio;
         int                sym_pcnt_filter;
         const char         *sym_filter;
+        float              min_percent;
 };
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index a8d81c35ef66..3917eb9a8479 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -38,52 +38,20 @@
 
 #include "../perf.h"
 #include "trace-event.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "evsel.h"
 
 #define VERSION "0.5"
 
-#define TRACE_CTRL      "tracing_on"
-#define TRACE           "trace"
-#define AVAILABLE       "available_tracers"
-#define CURRENT         "current_tracer"
-#define ITER_CTRL       "trace_options"
-#define MAX_LATENCY     "tracing_max_latency"
-
-unsigned int page_size;
-
-static const char *output_file = "trace.info";
 static int output_fd;
 
-struct event_list {
-        struct event_list *next;
-        const char *event;
-};
-
-struct events {
-        struct events *sibling;
-        struct events *children;
-        struct events *next;
-        char *name;
-};
-
-
-static void *malloc_or_die(unsigned int size)
-{
-        void *data;
-
-        data = malloc(size);
-        if (!data)
-                die("malloc");
-        return data;
-}
 
 static const char *find_debugfs(void)
 {
-        const char *path = debugfs_mount(NULL);
+        const char *path = perf_debugfs_mount(NULL);
 
         if (!path)
-                die("Your kernel not support debugfs filesystem");
+                pr_debug("Your kernel does not support the debugfs filesystem");
 
         return path;
 }
@@ -102,8 +70,12 @@ static const char *find_tracing_dir(void)
                 return tracing;
 
         debugfs = find_debugfs();
+        if (!debugfs)
+                return NULL;
 
-        tracing = malloc_or_die(strlen(debugfs) + 9);
+        tracing = malloc(strlen(debugfs) + 9);
+        if (!tracing)
+                return NULL;
 
         sprintf(tracing, "%s/tracing", debugfs);
 
@@ -120,7 +92,9 @@ static char *get_tracing_file(const char *name)
         if (!tracing)
                 return NULL;
 
-        file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
+        file = malloc(strlen(tracing) + strlen(name) + 2);
+        if (!file)
+                return NULL;
 
         sprintf(file, "%s/%s", tracing, name);
         return file;
@@ -131,24 +105,6 @@ static void put_tracing_file(char *file)
         free(file);
 }
 
-static ssize_t calc_data_size;
-
-static ssize_t write_or_die(const void *buf, size_t len)
-{
-        int ret;
-
-        if (calc_data_size) {
-                calc_data_size += len;
-                return len;
-        }
-
-        ret = write(output_fd, buf, len);
-        if (ret < 0)
-                die("writing to '%s'", output_file);
-
-        return ret;
-}
-
 int bigendian(void)
 {
         unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
@@ -159,59 +115,106 @@ int bigendian(void)
 }
 
 /* unfortunately, you can not stat debugfs or proc files for size */
-static void record_file(const char *file, size_t hdr_sz)
+static int record_file(const char *file, ssize_t hdr_sz)
 {
         unsigned long long size = 0;
         char buf[BUFSIZ], *sizep;
         off_t hdr_pos = lseek(output_fd, 0, SEEK_CUR);
         int r, fd;
+        int err = -EIO;
 
         fd = open(file, O_RDONLY);
-        if (fd < 0)
-                die("Can't read '%s'", file);
+        if (fd < 0) {
+                pr_debug("Can't read '%s'", file);
+                return -errno;
+        }
 
         /* put in zeros for file size, then fill true size later */
-        if (hdr_sz)
-                write_or_die(&size, hdr_sz);
+        if (hdr_sz) {
+                if (write(output_fd, &size, hdr_sz) != hdr_sz)
+                        goto out;
+        }
 
         do {
                 r = read(fd, buf, BUFSIZ);
                 if (r > 0) {
                         size += r;
-                        write_or_die(buf, r);
+                        if (write(output_fd, buf, r) != r)
+                                goto out;
                 }
         } while (r > 0);
-        close(fd);
 
         /* ugh, handle big-endian hdr_size == 4 */
         sizep = (char*)&size;
         if (bigendian())
                 sizep += sizeof(u64) - hdr_sz;
 
-        if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0)
-                die("writing to %s", output_file);
+        if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0) {
+                pr_debug("writing file size failed\n");
+                goto out;
+        }
+
+        err = 0;
+out:
+        close(fd);
+        return err;
 }
 
-static void read_header_files(void)
+static int read_header_files(void)
 {
         char *path;
         struct stat st;
+        int err = -EIO;
 
         path = get_tracing_file("events/header_page");
-        if (stat(path, &st) < 0)
-                die("can't read '%s'", path);
+        if (!path) {
+                pr_debug("can't get tracing/events/header_page");
+                return -ENOMEM;
+        }
+
+        if (stat(path, &st) < 0) {
+                pr_debug("can't read '%s'", path);
+                goto out;
+        }
+
+        if (write(output_fd, "header_page", 12) != 12) {
+                pr_debug("can't write header_page\n");
+                goto out;
+        }
+
+        if (record_file(path, 8) < 0) {
+                pr_debug("can't record header_page file\n");
+                goto out;
+        }
 
-        write_or_die("header_page", 12);
-        record_file(path, 8);
         put_tracing_file(path);
 
         path = get_tracing_file("events/header_event");
-        if (stat(path, &st) < 0)
-                die("can't read '%s'", path);
+        if (!path) {
+                pr_debug("can't get tracing/events/header_event");
+                err = -ENOMEM;
+                goto out;
+        }
+
+        if (stat(path, &st) < 0) {
+                pr_debug("can't read '%s'", path);
+                goto out;
+        }
 
-        write_or_die("header_event", 13);
-        record_file(path, 8);
+        if (write(output_fd, "header_event", 13) != 13) {
+                pr_debug("can't write header_event\n");
+                goto out;
+        }
+
+        if (record_file(path, 8) < 0) {
+                pr_debug("can't record header_event file\n");
+                goto out;
+        }
+
+        err = 0;
+out:
         put_tracing_file(path);
+        return err;
 }
 
 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -225,7 +228,7 @@ static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
         return false;
 }
 
-static void copy_event_system(const char *sys, struct tracepoint_path *tps)
+static int copy_event_system(const char *sys, struct tracepoint_path *tps)
 {
         struct dirent *dent;
         struct stat st;
@@ -233,10 +236,13 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
         DIR *dir;
         int count = 0;
         int ret;
+        int err;
 
         dir = opendir(sys);
-        if (!dir)
-                die("can't read directory '%s'", sys);
+        if (!dir) {
+                pr_debug("can't read directory '%s'", sys);
+                return -errno;
+        }
 
         while ((dent = readdir(dir))) {
                 if (dent->d_type != DT_DIR ||
@@ -244,7 +250,11 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
-                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                format = malloc(strlen(sys) + strlen(dent->d_name) + 10);
+                if (!format) {
+                        err = -ENOMEM;
+                        goto out;
+                }
                 sprintf(format, "%s/%s/format", sys, dent->d_name);
                 ret = stat(format, &st);
                 free(format);
@@ -253,7 +263,11 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                 count++;
         }
 
-        write_or_die(&count, 4);
+        if (write(output_fd, &count, 4) != 4) {
+                err = -EIO;
+                pr_debug("can't write count\n");
+                goto out;
+        }
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
@@ -262,27 +276,45 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
-                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                format = malloc(strlen(sys) + strlen(dent->d_name) + 10);
+                if (!format) {
+                        err = -ENOMEM;
+                        goto out;
+                }
                 sprintf(format, "%s/%s/format", sys, dent->d_name);
                 ret = stat(format, &st);
 
-                if (ret >= 0)
-                        record_file(format, 8);
-
+                if (ret >= 0) {
+                        err = record_file(format, 8);
+                        if (err) {
+                                free(format);
+                                goto out;
+                        }
+                }
                 free(format);
         }
+        err = 0;
+out:
         closedir(dir);
+        return err;
 }
 
-static void read_ftrace_files(struct tracepoint_path *tps)
+static int read_ftrace_files(struct tracepoint_path *tps)
 {
         char *path;
+        int ret;
 
         path = get_tracing_file("events/ftrace");
+        if (!path) {
+                pr_debug("can't get tracing/events/ftrace");
+                return -ENOMEM;
+        }
 
-        copy_event_system(path, tps);
+        ret = copy_event_system(path, tps);
 
         put_tracing_file(path);
+
+        return ret;
 }
 
 static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -296,7 +328,7 @@ static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
         return false;
 }
 
-static void read_event_files(struct tracepoint_path *tps)
+static int read_event_files(struct tracepoint_path *tps)
 {
         struct dirent *dent;
         struct stat st;
@@ -305,12 +337,20 @@ static void read_event_files(struct tracepoint_path *tps)
         DIR *dir;
         int count = 0;
         int ret;
+        int err;
 
         path = get_tracing_file("events");
+        if (!path) {
+                pr_debug("can't get tracing/events");
+                return -ENOMEM;
+        }
 
         dir = opendir(path);
-        if (!dir)
-                die("can't read directory '%s'", path);
+        if (!dir) {
+                err = -errno;
+                pr_debug("can't read directory '%s'", path);
+                goto out;
+        }
 
         while ((dent = readdir(dir))) {
                 if (dent->d_type != DT_DIR ||
@@ -322,7 +362,11 @@ static void read_event_files(struct tracepoint_path *tps)
                 count++;
         }
 
-        write_or_die(&count, 4);
+        if (write(output_fd, &count, 4) != 4) {
+                err = -EIO;
+                pr_debug("can't write count\n");
+                goto out;
+        }
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
@@ -332,56 +376,90 @@ static void read_event_files(struct tracepoint_path *tps)
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
                         continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
+                sys = malloc(strlen(path) + strlen(dent->d_name) + 2);
+                if (!sys) {
+                        err = -ENOMEM;
+                        goto out;
+                }
                 sprintf(sys, "%s/%s", path, dent->d_name);
                 ret = stat(sys, &st);
                 if (ret >= 0) {
-                        write_or_die(dent->d_name, strlen(dent->d_name) + 1);
-                        copy_event_system(sys, tps);
+                        ssize_t size = strlen(dent->d_name) + 1;
+
+                        if (write(output_fd, dent->d_name, size) != size ||
+                            copy_event_system(sys, tps) < 0) {
+                                err = -EIO;
+                                free(sys);
+                                goto out;
+                        }
                 }
                 free(sys);
         }
-
+        err = 0;
+out:
         closedir(dir);
         put_tracing_file(path);
+
+        return err;
 }
 
-static void read_proc_kallsyms(void)
+static int read_proc_kallsyms(void)
 {
         unsigned int size;
         const char *path = "/proc/kallsyms";
         struct stat st;
-        int ret;
+        int ret, err = 0;
 
         ret = stat(path, &st);
         if (ret < 0) {
                 /* not found */
                 size = 0;
-                write_or_die(&size, 4);
-                return;
+                if (write(output_fd, &size, 4) != 4)
+                        err = -EIO;
+                return err;
         }
-        record_file(path, 4);
+        return record_file(path, 4);
 }
 
-static void read_ftrace_printk(void)
+static int read_ftrace_printk(void)
 {
         unsigned int size;
         char *path;
         struct stat st;
-        int ret;
+        int ret, err = 0;
 
         path = get_tracing_file("printk_formats");
+        if (!path) {
+                pr_debug("can't get tracing/printk_formats");
+                return -ENOMEM;
+        }
+
         ret = stat(path, &st);
         if (ret < 0) {
                 /* not found */
                 size = 0;
-                write_or_die(&size, 4);
+                if (write(output_fd, &size, 4) != 4)
+                        err = -EIO;
                 goto out;
         }
-        record_file(path, 4);
+        err = record_file(path, 4);
 
 out:
         put_tracing_file(path);
+        return err;
+}
+
+static void
+put_tracepoints_path(struct tracepoint_path *tps)
+{
+        while (tps) {
+                struct tracepoint_path *t = tps;
+
+                tps = tps->next;
+                free(t->name);
+                free(t->system);
+                free(t);
+        }
 }
 
 static struct tracepoint_path *
@@ -396,27 +474,17 @@ get_tracepoints_path(struct list_head *pattrs)
                         continue;
                 ++nr_tracepoints;
                 ppath->next = tracepoint_id_to_path(pos->attr.config);
-                if (!ppath->next)
-                        die("%s\n", "No memory to alloc tracepoints list");
+                if (!ppath->next) {
+                        pr_debug("No memory to alloc tracepoints list\n");
+                        put_tracepoints_path(&path);
+                        return NULL;
+                }
                 ppath = ppath->next;
         }
 
         return nr_tracepoints > 0 ? path.next : NULL;
 }
 
-static void
-put_tracepoints_path(struct tracepoint_path *tps)
-{
-        while (tps) {
-                struct tracepoint_path *t = tps;
-
-                tps = tps->next;
-                free(t->name);
-                free(t->system);
-                free(t);
-        }
-}
-
 bool have_tracepoints(struct list_head *pattrs)
 {
         struct perf_evsel *pos;
@@ -428,9 +496,10 @@ bool have_tracepoints(struct list_head *pattrs)
         return false;
 }
 
-static void tracing_data_header(void)
+static int tracing_data_header(void)
 {
         char buf[20];
+        ssize_t size;
 
         /* just guessing this is someone's birthday.. ;) */
         buf[0] = 23;
@@ -438,9 +507,12 @@ static void tracing_data_header(void)
         buf[2] = 68;
         memcpy(buf + 3, "tracing", 7);
 
-        write_or_die(buf, 10);
+        if (write(output_fd, buf, 10) != 10)
+                return -1;
 
-        write_or_die(VERSION, strlen(VERSION) + 1);
+        size = strlen(VERSION) + 1;
+        if (write(output_fd, VERSION, size) != size)
+                return -1;
 
         /* save endian */
         if (bigendian())
@@ -450,15 +522,19 @@ static void tracing_data_header(void)
 
         read_trace_init(buf[0], buf[0]);
 
-        write_or_die(buf, 1);
+        if (write(output_fd, buf, 1) != 1)
+                return -1;
 
         /* save size of long */
         buf[0] = sizeof(long);
-        write_or_die(buf, 1);
+        if (write(output_fd, buf, 1) != 1)
+                return -1;
 
         /* save page_size */
-        page_size = sysconf(_SC_PAGESIZE);
-        write_or_die(&page_size, 4);
+        if (write(output_fd, &page_size, 4) != 4)
+                return -1;
+
+        return 0;
 }
 
 struct tracing_data *tracing_data_get(struct list_head *pattrs,
@@ -466,6 +542,7 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
 {
         struct tracepoint_path *tps;
         struct tracing_data *tdata;
+        int err;
 
         output_fd = fd;
 
@@ -473,7 +550,10 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
         if (!tps)
                 return NULL;
 
-        tdata = malloc_or_die(sizeof(*tdata));
+        tdata = malloc(sizeof(*tdata));
+        if (!tdata)
+                return NULL;
+
         tdata->temp = temp;
         tdata->size = 0;
 
@@ -482,12 +562,16 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
 
                 snprintf(tdata->temp_file, sizeof(tdata->temp_file),
                          "/tmp/perf-XXXXXX");
-                if (!mkstemp(tdata->temp_file))
-                        die("Can't make temp file");
+                if (!mkstemp(tdata->temp_file)) {
+                        pr_debug("Can't make temp file");
+                        return NULL;
+                }
 
                 temp_fd = open(tdata->temp_file, O_RDWR);
-                if (temp_fd < 0)
-                        die("Can't read '%s'", tdata->temp_file);
+                if (temp_fd < 0) {
+                        pr_debug("Can't read '%s'", tdata->temp_file);
+                        return NULL;
+                }
 
                 /*
                  * Set the temp file the default output, so all the
@@ -496,13 +580,24 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                 output_fd = temp_fd;
         }
 
-        tracing_data_header();
-        read_header_files();
-        read_ftrace_files(tps);
-        read_event_files(tps);
-        read_proc_kallsyms();
-        read_ftrace_printk();
+        err = tracing_data_header();
+        if (err)
+                goto out;
+        err = read_header_files();
+        if (err)
+                goto out;
+        err = read_ftrace_files(tps);
+        if (err)
+                goto out;
+        err = read_event_files(tps);
+        if (err)
+                goto out;
+        err = read_proc_kallsyms();
+        if (err)
+                goto out;
+        err = read_ftrace_printk();
 
+out:
         /*
          * All tracing data are stored by now, we can restore
          * the default output file in case we used temp file.
@@ -513,22 +608,31 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                 output_fd = fd;
         }
 
+        if (err) {
+                free(tdata);
+                tdata = NULL;
+        }
+
         put_tracepoints_path(tps);
         return tdata;
 }
 
-void tracing_data_put(struct tracing_data *tdata)
+int tracing_data_put(struct tracing_data *tdata)
 {
+        int err = 0;
+
         if (tdata->temp) {
-                record_file(tdata->temp_file, 0);
+                err = record_file(tdata->temp_file, 0);
                 unlink(tdata->temp_file);
         }
 
         free(tdata);
+        return err;
 }
 
 int read_tracing_data(int fd, struct list_head *pattrs)
 {
+        int err;
         struct tracing_data *tdata;
 
         /*
@@ -539,6 +643,6 @@ int read_tracing_data(int fd, struct list_head *pattrs)
         if (!tdata)
                 return -ENOMEM;
 
-        tracing_data_put(tdata);
-        return 0;
+        err = tracing_data_put(tdata);
+        return err;
 }
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 3aabcd687cd5..4454835a9ebc 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -183,43 +183,6 @@ void event_format__print(struct event_format *event,
         trace_seq_do_printf(&s);
 }
 
-void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
-{
-        int type = trace_parse_common_type(pevent, data);
-        struct event_format *event = pevent_find_event(pevent, type);
-
-        if (!event) {
-                warning("ug! no event found for type %d", type);
-                return;
-        }
-
-        event_format__print(event, cpu, data, size);
-}
-
-void print_event(struct pevent *pevent, int cpu, void *data, int size,
-                 unsigned long long nsecs, char *comm)
-{
-        struct pevent_record record;
-        struct trace_seq s;
-        int pid;
-
-        pevent->latency_format = latency_format;
-
-        record.ts = nsecs;
-        record.cpu = cpu;
-        record.size = size;
-        record.data = data;
-        pid = pevent_data_pid(pevent, &record);
-
-        if (!pevent_pid_is_registered(pevent, pid))
-                pevent_register_comm(pevent, comm, pid);
-
-        trace_seq_init(&s);
-        pevent_print_event(pevent, &s, &record);
-        trace_seq_do_printf(&s);
-        printf("\n");
-}
-
 void parse_proc_kallsyms(struct pevent *pevent,
                          char *file, unsigned int size __maybe_unused)
 {
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 3741572696af..af215c0d2379 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -18,8 +18,6 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#define _FILE_OFFSET_BITS 64
-
 #include <dirent.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -41,26 +39,14 @@
 
 static int input_fd;
 
-static int read_page;
-
 int file_bigendian;
 int host_bigendian;
 static int long_size;
 
-static ssize_t calc_data_size;
+static ssize_t trace_data_size;
 static bool repipe;
 
-static void *malloc_or_die(int size)
-{
-        void *ret;
-
-        ret = malloc(size);
-        if (!ret)
-                die("malloc");
-        return ret;
-}
-
-static int do_read(int fd, void *buf, int size)
+static int __do_read(int fd, void *buf, int size)
 {
         int rsize = size;
 
@@ -73,8 +59,10 @@ static int do_read(int fd, void *buf, int size)
                 if (repipe) {
                         int retw = write(STDOUT_FILENO, buf, ret);
 
-                        if (retw <= 0 || retw != ret)
-                                die("repiping input file");
+                        if (retw <= 0 || retw != ret) {
+                                pr_debug("repiping input file");
+                                return -1;
+                        }
                 }
 
                 size -= ret;
@@ -84,17 +72,18 @@ static int do_read(int fd, void *buf, int size)
         return rsize;
 }
 
-static int read_or_die(void *data, int size)
+static int do_read(void *data, int size)
 {
         int r;
 
-        r = do_read(input_fd, data, size);
-        if (r <= 0)
-                die("reading input file (size expected=%d received=%d)",
-                    size, r);
+        r = __do_read(input_fd, data, size);
+        if (r <= 0) {
+                pr_debug("reading input file (size expected=%d received=%d)",
+                         size, r);
+                return -1;
+        }
 
-        if (calc_data_size)
-                calc_data_size += r;
+        trace_data_size += r;
 
         return r;
 }
@@ -107,7 +96,7 @@ static void skip(int size)
 
         while (size) {
                 r = size > BUFSIZ ? BUFSIZ : size;
-                read_or_die(buf, r);
+                do_read(buf, r);
                 size -= r;
         };
 }
@@ -116,7 +105,8 @@ static unsigned int read4(struct pevent *pevent)
 {
         unsigned int data;
 
-        read_or_die(&data, 4);
+        if (do_read(&data, 4) < 0)
+                return 0;
         return __data2host4(pevent, data);
 }
 
@@ -124,7 +114,8 @@ static unsigned long long read8(struct pevent *pevent)
 {
         unsigned long long data;
 
-        read_or_die(&data, 8);
+        if (do_read(&data, 8) < 0)
+                return 0;
         return __data2host8(pevent, data);
 }
 
@@ -138,17 +129,23 @@ static char *read_string(void)
 
         for (;;) {
                 r = read(input_fd, &c, 1);
-                if (r < 0)
-                        die("reading input file");
+                if (r < 0) {
+                        pr_debug("reading input file");
+                        goto out;
+                }
 
-                if (!r)
-                        die("no data");
+                if (!r) {
+                        pr_debug("no data");
+                        goto out;
+                }
 
                 if (repipe) {
                         int retw = write(STDOUT_FILENO, &c, 1);
 
-                        if (retw <= 0 || retw != r)
-                                die("repiping input file string");
+                        if (retw <= 0 || retw != r) {
+                                pr_debug("repiping input file string");
+                                goto out;
+                        }
                 }
 
                 buf[size++] = c;
@@ -157,60 +154,79 @@ static char *read_string(void)
                         break;
         }
 
-        if (calc_data_size)
-                calc_data_size += size;
-
-        str = malloc_or_die(size);
-        memcpy(str, buf, size);
+        trace_data_size += size;
 
+        str = malloc(size);
+        if (str)
+                memcpy(str, buf, size);
+out:
         return str;
 }
 
-static void read_proc_kallsyms(struct pevent *pevent)
+static int read_proc_kallsyms(struct pevent *pevent)
 {
         unsigned int size;
         char *buf;
 
         size = read4(pevent);
         if (!size)
-                return;
+                return 0;
+
+        buf = malloc(size + 1);
+        if (buf == NULL)
+                return -1;
 
-        buf = malloc_or_die(size + 1);
-        read_or_die(buf, size);
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
         buf[size] = '\0';
 
         parse_proc_kallsyms(pevent, buf, size);
 
         free(buf);
+        return 0;
 }
 
-static void read_ftrace_printk(struct pevent *pevent)
+static int read_ftrace_printk(struct pevent *pevent)
 {
         unsigned int size;
         char *buf;
 
+        /* it can have 0 size */
         size = read4(pevent);
         if (!size)
-                return;
+                return 0;
+
+        buf = malloc(size);
+        if (buf == NULL)
+                return -1;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
 
         parse_ftrace_printk(pevent, buf, size);
 
         free(buf);
+        return 0;
 }
 
-static void read_header_files(struct pevent *pevent)
+static int read_header_files(struct pevent *pevent)
 {
         unsigned long long size;
         char *header_event;
         char buf[BUFSIZ];
+        int ret = 0;
 
-        read_or_die(buf, 12);
+        if (do_read(buf, 12) < 0)
+                return -1;
 
-        if (memcmp(buf, "header_page", 12) != 0)
-                die("did not read header page");
+        if (memcmp(buf, "header_page", 12) != 0) {
+                pr_debug("did not read header page");
+                return -1;
+        }
 
         size = read8(pevent);
         skip(size);
@@ -221,269 +237,107 @@ static void read_header_files(struct pevent *pevent)
          */
         long_size = header_page_size_size;
 
-        read_or_die(buf, 13);
-        if (memcmp(buf, "header_event", 13) != 0)
-                die("did not read header event");
+        if (do_read(buf, 13) < 0)
+                return -1;
+
+        if (memcmp(buf, "header_event", 13) != 0) {
+                pr_debug("did not read header event");
+                return -1;
+        }
 
         size = read8(pevent);
-        header_event = malloc_or_die(size);
-        read_or_die(header_event, size);
+        header_event = malloc(size);
+        if (header_event == NULL)
+                return -1;
+
+        if (do_read(header_event, size) < 0)
+                ret = -1;
+
         free(header_event);
+        return ret;
 }
 
-static void read_ftrace_file(struct pevent *pevent, unsigned long long size)
+static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
 {
         char *buf;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        buf = malloc(size);
+        if (buf == NULL)
+                return -1;
+
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
+
         parse_ftrace_file(pevent, buf, size);
         free(buf);
+        return 0;
 }
 
-static void read_event_file(struct pevent *pevent, char *sys,
+static int read_event_file(struct pevent *pevent, char *sys,
                             unsigned long long size)
 {
         char *buf;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        buf = malloc(size);
+        if (buf == NULL)
+                return -1;
+
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
+
         parse_event_file(pevent, buf, size, sys);
         free(buf);
+        return 0;
 }
 
-static void read_ftrace_files(struct pevent *pevent)
+static int read_ftrace_files(struct pevent *pevent)
 {
         unsigned long long size;
         int count;
         int i;
+        int ret;
 
         count = read4(pevent);
 
         for (i = 0; i < count; i++) {
                 size = read8(pevent);
-                read_ftrace_file(pevent, size);
+                ret = read_ftrace_file(pevent, size);
+                if (ret)
+                        return ret;
         }
+        return 0;
 }
 
-static void read_event_files(struct pevent *pevent)
+static int read_event_files(struct pevent *pevent)
 {
         unsigned long long size;
         char *sys;
         int systems;
         int count;
         int i,x;
+        int ret;
 
         systems = read4(pevent);
 
         for (i = 0; i < systems; i++) {
                 sys = read_string();
+                if (sys == NULL)
+                        return -1;
 
                 count = read4(pevent);
+
                 for (x=0; x < count; x++) {
                         size = read8(pevent);
-                        read_event_file(pevent, sys, size);
+                        ret = read_event_file(pevent, sys, size);
+                        if (ret)
+                                return ret;
                 }
         }
-}
-
-struct cpu_data {
-        unsigned long long      offset;
-        unsigned long long      size;
-        unsigned long long      timestamp;
-        struct pevent_record    *next;
-        char                    *page;
-        int                     cpu;
-        int                     index;
-        int                     page_size;
-};
-
-static struct cpu_data *cpu_data;
-
-static void update_cpu_data_index(int cpu)
-{
-        cpu_data[cpu].offset += page_size;
-        cpu_data[cpu].size -= page_size;
-        cpu_data[cpu].index = 0;
-}
-
-static void get_next_page(int cpu)
-{
-        off_t save_seek;
-        off_t ret;
-
-        if (!cpu_data[cpu].page)
-                return;
-
-        if (read_page) {
-                if (cpu_data[cpu].size <= page_size) {
-                        free(cpu_data[cpu].page);
-                        cpu_data[cpu].page = NULL;
-                        return;
-                }
-
-                update_cpu_data_index(cpu);
-
-                /* other parts of the code may expect the pointer to not move */
-                save_seek = lseek(input_fd, 0, SEEK_CUR);
-
-                ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
-                if (ret == (off_t)-1)
-                        die("failed to lseek");
-                ret = read(input_fd, cpu_data[cpu].page, page_size);
-                if (ret < 0)
-                        die("failed to read page");
-
-                /* reset the file pointer back */
-                lseek(input_fd, save_seek, SEEK_SET);
-
-                return;
-        }
-
-        munmap(cpu_data[cpu].page, page_size);
-        cpu_data[cpu].page = NULL;
-
-        if (cpu_data[cpu].size <= page_size)
-                return;
-
-        update_cpu_data_index(cpu);
-
-        cpu_data[cpu].page = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE,
-                                  input_fd, cpu_data[cpu].offset);
-        if (cpu_data[cpu].page == MAP_FAILED)
-                die("failed to mmap cpu %d at offset 0x%llx",
-                    cpu, cpu_data[cpu].offset);
-}
-
-static unsigned int type_len4host(unsigned int type_len_ts)
-{
-        if (file_bigendian)
-                return (type_len_ts >> 27) & ((1 << 5) - 1);
-        else
-                return type_len_ts & ((1 << 5) - 1);
-}
-
-static unsigned int ts4host(unsigned int type_len_ts)
-{
-        if (file_bigendian)
-                return type_len_ts & ((1 << 27) - 1);
-        else
-                return type_len_ts >> 5;
-}
-
-static int calc_index(void *ptr, int cpu)
-{
-        return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
-}
-
-struct pevent_record *trace_peek_data(struct pevent *pevent, int cpu)
-{
-        struct pevent_record *data;
-        void *page = cpu_data[cpu].page;
-        int idx = cpu_data[cpu].index;
-        void *ptr = page + idx;
-        unsigned long long extend;
-        unsigned int type_len_ts;
-        unsigned int type_len;
-        unsigned int delta;
-        unsigned int length = 0;
-
-        if (cpu_data[cpu].next)
-                return cpu_data[cpu].next;
-
-        if (!page)
-                return NULL;
-
-        if (!idx) {
-                /* FIXME: handle header page */
-                if (header_page_ts_size != 8)
-                        die("expected a long long type for timestamp");
-                cpu_data[cpu].timestamp = data2host8(pevent, ptr);
-                ptr += 8;
-                switch (header_page_size_size) {
-                case 4:
-                        cpu_data[cpu].page_size = data2host4(pevent, ptr);
-                        ptr += 4;
-                        break;
-                case 8:
-                        cpu_data[cpu].page_size = data2host8(pevent, ptr);
-                        ptr += 8;
-                        break;
-                default:
-                        die("bad long size");
-                }
-                ptr = cpu_data[cpu].page + header_page_data_offset;
-        }
-
-read_again:
-        idx = calc_index(ptr, cpu);
-
-        if (idx >= cpu_data[cpu].page_size) {
-                get_next_page(cpu);
-                return trace_peek_data(pevent, cpu);
-        }
-
-        type_len_ts = data2host4(pevent, ptr);
-        ptr += 4;
-
-        type_len = type_len4host(type_len_ts);
-        delta = ts4host(type_len_ts);
-
-        switch (type_len) {
-        case RINGBUF_TYPE_PADDING:
-                if (!delta)
-                        die("error, hit unexpected end of page");
-                length = data2host4(pevent, ptr);
-                ptr += 4;
-                length *= 4;
-                ptr += length;
-                goto read_again;
-
-        case RINGBUF_TYPE_TIME_EXTEND:
-                extend = data2host4(pevent, ptr);
-                ptr += 4;
-                extend <<= TS_SHIFT;
-                extend += delta;
-                cpu_data[cpu].timestamp += extend;
-                goto read_again;
-
-        case RINGBUF_TYPE_TIME_STAMP:
-                ptr += 12;
-                break;
-        case 0:
-                length = data2host4(pevent, ptr);
-                ptr += 4;
-                die("here! length=%d", length);
-                break;
-        default:
-                length = type_len * 4;
-                break;
-        }
-
-        cpu_data[cpu].timestamp += delta;
-
-        data = malloc_or_die(sizeof(*data));
-        memset(data, 0, sizeof(*data));
-
-        data->ts = cpu_data[cpu].timestamp;
-        data->size = length;
-        data->data = ptr;
-        ptr += length;
-
-        cpu_data[cpu].index = calc_index(ptr, cpu);
-        cpu_data[cpu].next = data;
-
-        return data;
-}
-
-struct pevent_record *trace_read_data(struct pevent *pevent, int cpu)
-{
-        struct pevent_record *data;
-
-        data = trace_peek_data(pevent, cpu);
-        cpu_data[cpu].next = NULL;
-
-        return data;
+        return 0;
 }
 
 ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
@@ -494,58 +348,85 @@ ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
         int show_version = 0;
         int show_funcs = 0;
         int show_printk = 0;
-        ssize_t size;
+        ssize_t size = -1;
+        struct pevent *pevent;
+        int err;
 
-        calc_data_size = 1;
-        repipe = __repipe;
+        *ppevent = NULL;
 
+        repipe = __repipe;
         input_fd = fd;
 
-        read_or_die(buf, 3);
-        if (memcmp(buf, test, 3) != 0)
-                die("no trace data in the file");
+        if (do_read(buf, 3) < 0)
+                return -1;
+        if (memcmp(buf, test, 3) != 0) {
+                pr_debug("no trace data in the file");
+                return -1;
+        }
 
-        read_or_die(buf, 7);
-        if (memcmp(buf, "tracing", 7) != 0)
-                die("not a trace file (missing 'tracing' tag)");
+        if (do_read(buf, 7) < 0)
+                return -1;
+        if (memcmp(buf, "tracing", 7) != 0) {
+                pr_debug("not a trace file (missing 'tracing' tag)");
+                return -1;
+        }
 
         version = read_string();
+        if (version == NULL)
+                return -1;
         if (show_version)
                 printf("version = %s\n", version);
         free(version);
 
-        read_or_die(buf, 1);
+        if (do_read(buf, 1) < 0)
+                return -1;
         file_bigendian = buf[0];
         host_bigendian = bigendian();
 
-        *ppevent = read_trace_init(file_bigendian, host_bigendian);
-        if (*ppevent == NULL)
-                die("read_trace_init failed");
+        pevent = read_trace_init(file_bigendian, host_bigendian);
+        if (pevent == NULL) {
+                pr_debug("read_trace_init failed");
+                goto out;
+        }
 
-        read_or_die(buf, 1);
+        if (do_read(buf, 1) < 0)
+                goto out;
         long_size = buf[0];
 
-        page_size = read4(*ppevent);
-
-        read_header_files(*ppevent);
-
-        read_ftrace_files(*ppevent);
-        read_event_files(*ppevent);
-        read_proc_kallsyms(*ppevent);
-        read_ftrace_printk(*ppevent);
-
-        size = calc_data_size - 1;
-        calc_data_size = 0;
+        page_size = read4(pevent);
+        if (!page_size)
+                goto out;
+
+        err = read_header_files(pevent);
+        if (err)
+                goto out;
+        err = read_ftrace_files(pevent);
+        if (err)
+                goto out;
+        err = read_event_files(pevent);
+        if (err)
+                goto out;
+        err = read_proc_kallsyms(pevent);
+        if (err)
+                goto out;
+        err = read_ftrace_printk(pevent);
+        if (err)
+                goto out;
+
+        size = trace_data_size;
         repipe = false;
 
         if (show_funcs) {
-                pevent_print_funcs(*ppevent);
-                return size;
-        }
-        if (show_printk) {
-                pevent_print_printk(*ppevent);
-                return size;
+                pevent_print_funcs(pevent);
+        } else if (show_printk) {
+                pevent_print_printk(pevent);
         }
 
+        *ppevent = pevent;
+        pevent = NULL;
+
+out:
+        if (pevent)
+                pevent_free(pevent);
         return size;
 }
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index a55fd37ffea1..1978c398ad87 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -30,13 +30,9 @@ enum {
 int bigendian(void);
 
 struct pevent *read_trace_init(int file_bigendian, int host_bigendian);
-void print_trace_event(struct pevent *pevent, int cpu, void *data, int size);
 void event_format__print(struct event_format *event,
                          int cpu, void *data, int size);
 
-void print_event(struct pevent *pevent, int cpu, void *data, int size,
-                 unsigned long long nsecs, char *comm);
-
 int parse_ftrace_file(struct pevent *pevent, char *buf, unsigned long size);
 int parse_event_file(struct pevent *pevent,
                      char *buf, unsigned long size, char *sys);
@@ -72,7 +68,7 @@ struct tracing_data {
 
 struct tracing_data *tracing_data_get(struct list_head *pattrs,
                                       int fd, bool temp);
-void tracing_data_put(struct tracing_data *tdata);
+int tracing_data_put(struct tracing_data *tdata);
 
 
 struct addr_location;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 5906e8426cc7..59d868add275 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -12,9 +12,13 @@
  */
 unsigned int page_size;
 
+bool test_attr__enabled;
+
 bool perf_host  = true;
 bool perf_guest = false;
 
+char tracing_events_path[PATH_MAX + 1] = "/sys/kernel/debug/tracing/events";
+
 void event_attr_init(struct perf_event_attr *attr)
 {
         if (!perf_host)
@@ -218,3 +222,50 @@ void dump_stack(void)
 #else
 void dump_stack(void) {}
 #endif
+
+void get_term_dimensions(struct winsize *ws)
+{
+        char *s = getenv("LINES");
+
+        if (s != NULL) {
+                ws->ws_row = atoi(s);
+                s = getenv("COLUMNS");
+                if (s != NULL) {
+                        ws->ws_col = atoi(s);
+                        if (ws->ws_row && ws->ws_col)
+                                return;
+                }
+        }
+#ifdef TIOCGWINSZ
+        if (ioctl(1, TIOCGWINSZ, ws) == 0 &&
+            ws->ws_row && ws->ws_col)
+                return;
+#endif
+        ws->ws_row = 25;
+        ws->ws_col = 80;
+}
+
+static void set_tracing_events_path(const char *mountpoint)
+{
+        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
+                 mountpoint, "tracing/events");
+}
+
+const char *perf_debugfs_mount(const char *mountpoint)
+{
+        const char *mnt;
+
+        mnt = debugfs_mount(mountpoint);
+        if (!mnt)
+                return NULL;
+
+        set_tracing_events_path(mnt);
+
+        return mnt;
+}
+
+void perf_debugfs_set_path(const char *mntpt)
+{
+        snprintf(debugfs_mountpoint, strlen(debugfs_mountpoint), "%s", mntpt);
+        set_tracing_events_path(mntpt);
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index c2330918110c..7a484c97e500 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -1,8 +1,6 @@
 #ifndef GIT_COMPAT_UTIL_H
 #define GIT_COMPAT_UTIL_H
 
-#define _FILE_OFFSET_BITS 64
-
 #ifndef FLEX_ARRAY
 /*
  * See if our compiler is known to support flexible array members.
@@ -73,10 +71,14 @@
 #include <linux/magic.h>
 #include "types.h"
 #include <sys/ttydefaults.h>
+#include <lk/debugfs.h>
 
 extern const char *graph_line;
 extern const char *graph_dotted_line;
 extern char buildid_dir[];
+extern char tracing_events_path[];
+extern void perf_debugfs_set_path(const char *mountpoint);
+const char *perf_debugfs_mount(const char *mountpoint);
 
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
@@ -219,8 +221,8 @@ extern unsigned char sane_ctype[256];
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
-#define islower(x) (sane_istest(x,GIT_ALPHA) && sane_istest(x,0x20))
-#define isupper(x) (sane_istest(x,GIT_ALPHA) && !sane_istest(x,0x20))
+#define islower(x) (sane_istest(x,GIT_ALPHA) && (x & 0x20))
+#define isupper(x) (sane_istest(x,GIT_ALPHA) && !(x & 0x20))
 #define tolower(x) sane_case((unsigned char)(x), 0x20)
 #define toupper(x) sane_case((unsigned char)(x), 0)
 
@@ -265,10 +267,13 @@ bool is_power_of_2(unsigned long n)
 size_t hex_width(u64 v);
 int hex2u64(const char *ptr, u64 *val);
 
+char *ltrim(char *s);
 char *rtrim(char *s);
 
 void dump_stack(void);
 
 extern unsigned int page_size;
 
-#endif
+struct winsize;
+void get_term_dimensions(struct winsize *ws);
+#endif /* GIT_COMPAT_UTIL_H */