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

Pull perf updates from Ingo Molnar:
 "Kernel side updates:

   - Fix and enhance poll support (Jiri Olsa)

   - Re-enable inheritance optimization (Jiri Olsa)

   - Enhance Intel memory events support (Stephane Eranian)

   - Refactor the Intel uncore driver to be more maintainable (Zheng
     Yan)

   - Enhance and fix Intel CPU and uncore PMU drivers (Peter Zijlstra,
     Andi Kleen)

   - [ plus various smaller fixes/cleanups ]

  User visible tooling updates:

   - Add +field argument support for --field option, so that one can add
     fields to the default list of fields to show, ie now one can just
     do:

         perf report --fields +pid

     And the pid will appear in addition to the default fields (Jiri
     Olsa)

   - Add +field argument support for --sort option (Jiri Olsa)

   - Honour -w in the report tools (report, top), allowing to specify
     the widths for the histogram entries columns (Namhyung Kim)

   - Properly show submicrosecond times in 'perf kvm stat' (Christian
     Borntraeger)

   - Add beautifier for mremap flags param in 'trace' (Alex Snast)

   - perf script: Allow callchains if any event samples them

   - Don't truncate Intel style addresses in 'annotate' (Alex Converse)

   - Allow profiling when kptr_restrict == 1 for non root users, kernel
     samples will just remain unresolved (Andi Kleen)

   - Allow configuring default options for callchains in config file
     (Namhyung Kim)

   - Support operations for shared futexes.  (Davidlohr Bueso)

   - "perf kvm stat report" improvements by Alexander Yarygin:
       -  Save pid string in opts.target.pid
       -  Enable the target.system_wide flag
       -  Unify the title bar output

   - [ plus lots of other fixes and small improvements.  ]

  Tooling infrastructure changes:

   - Refactor unit and scale function parameters for PMU parsing
     routines (Matt Fleming)

   - Improve DSO long names lookup with rbtree, resulting in great
     speedup for workloads with lots of DSOs (Waiman Long)

   - We were not handling POLLHUP notifications for event file
     descriptors

     Fix it by filtering entries in the events file descriptor array
     after poll() returns, refcounting mmaps so that when the last fd
     pointing to a perf mmap goes away we do the unmap (Arnaldo Carvalho
     de Melo)

   - Intel PT prep work, from Adrian Hunter, including:
       - Let a user specify a PMU event without any config terms
       - Add perf-with-kcore script
       - Let default config be defined for a PMU
       - Add perf_pmu__scan_file()
       - Add a 'perf test' for tracking with sched_switch
       - Add 'flush' callback to scripting API

   - Use ring buffer consume method to look like other tools (Arnaldo
     Carvalho de Melo)

   - hists browser (used in top and report) refactorings, getting rid of
     unused variables and reducing source code size by handling similar
     cases in a fewer functions (Namhyung Kim).

   - Replace thread unsafe strerror() with strerror_r() accross the
     whole tools/perf/ tree (Masami Hiramatsu)

   - Rename ordered_samples to ordered_events and allow setting a queue
     size for ordering events (Jiri Olsa)

   - [ plus lots of fixes, cleanups and other improvements ]"

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (198 commits)
  perf/x86: Tone down kernel messages when the PMU check fails in a virtual environment
  perf/x86/intel/uncore: Fix minor race in box set up
  perf record: Fix error message for --filter option not coming after tracepoint
  perf tools: Fix build breakage on arm64 targets
  perf symbols: Improve DSO long names lookup speed with rbtree
  perf symbols: Encapsulate dsos list head into struct dsos
  perf bench futex: Sanitize -q option in requeue
  perf bench futex: Support operations for shared futexes
  perf trace: Fix mmap return address truncation to 32-bit
  perf tools: Refactor unit and scale function parameters
  perf tools: Fix line number in the config file error message
  perf tools: Convert {record,top}.call-graph option to call-graph.record-mode
  perf tools: Introduce perf_callchain_config()
  perf callchain: Move some parser functions to callchain.c
  perf tools: Move callchain config from record_opts to callchain_param
  perf hists browser: Fix callchain print bug on TUI
  perf tools: Use ACCESS_ONCE() instead of volatile cast
  perf tools: Modify error code for when perf_session__new() fails
  perf tools: Fix perf record as non root with kptr_restrict == 1
  perf stat: Fix --per-core on multi socket systems
  ...

117 files changed, 4085 insertions, 1462 deletions

diff --git a/tools/lib/api/Makefile b/tools/lib/api/Makefile
index ce00f7ee6455..36c08b1f4afb 100644
--- a/tools/lib/api/Makefile
+++ b/tools/lib/api/Makefile
@@ -10,9 +10,14 @@ LIB_OBJS=
 
 LIB_H += fs/debugfs.h
 LIB_H += fs/fs.h
+# See comment below about piggybacking...
+LIB_H += fd/array.h
 
 LIB_OBJS += $(OUTPUT)fs/debugfs.o
 LIB_OBJS += $(OUTPUT)fs/fs.o
+# XXX piggybacking here, need to introduce libapikfd, or rename this
+# to plain libapik.a and make it have it all api goodies
+LIB_OBJS += $(OUTPUT)fd/array.o
 
 LIBFILE = libapikfs.a
 
@@ -29,7 +34,7 @@ $(LIBFILE): $(LIB_OBJS)
 $(LIB_OBJS): $(LIB_H)
 
 libapi_dirs:
-        $(QUIET_MKDIR)mkdir -p $(OUTPUT)fs/
+        $(QUIET_MKDIR)mkdir -p $(OUTPUT)fd $(OUTPUT)fs
 
 $(OUTPUT)%.o: %.c libapi_dirs
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
diff --git a/tools/lib/api/fd/array.c b/tools/lib/api/fd/array.c
new file mode 100644
index 000000000000..0e636c4339b8
--- /dev/null
+++ b/tools/lib/api/fd/array.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2014, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
+ */
+#include "array.h"
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void fdarray__init(struct fdarray *fda, int nr_autogrow)
+{
+        fda->entries     = NULL;
+        fda->priv        = NULL;
+        fda->nr          = fda->nr_alloc = 0;
+        fda->nr_autogrow = nr_autogrow;
+}
+
+int fdarray__grow(struct fdarray *fda, int nr)
+{
+        void *priv;
+        int nr_alloc = fda->nr_alloc + nr;
+        size_t psize = sizeof(fda->priv[0]) * nr_alloc;
+        size_t size  = sizeof(struct pollfd) * nr_alloc;
+        struct pollfd *entries = realloc(fda->entries, size);
+
+        if (entries == NULL)
+                return -ENOMEM;
+
+        priv = realloc(fda->priv, psize);
+        if (priv == NULL) {
+                free(entries);
+                return -ENOMEM;
+        }
+
+        fda->nr_alloc = nr_alloc;
+        fda->entries  = entries;
+        fda->priv     = priv;
+        return 0;
+}
+
+struct fdarray *fdarray__new(int nr_alloc, int nr_autogrow)
+{
+        struct fdarray *fda = calloc(1, sizeof(*fda));
+
+        if (fda != NULL) {
+                if (fdarray__grow(fda, nr_alloc)) {
+                        free(fda);
+                        fda = NULL;
+                } else {
+                        fda->nr_autogrow = nr_autogrow;
+                }
+        }
+
+        return fda;
+}
+
+void fdarray__exit(struct fdarray *fda)
+{
+        free(fda->entries);
+        free(fda->priv);
+        fdarray__init(fda, 0);
+}
+
+void fdarray__delete(struct fdarray *fda)
+{
+        fdarray__exit(fda);
+        free(fda);
+}
+
+int fdarray__add(struct fdarray *fda, int fd, short revents)
+{
+        int pos = fda->nr;
+
+        if (fda->nr == fda->nr_alloc &&
+            fdarray__grow(fda, fda->nr_autogrow) < 0)
+                return -ENOMEM;
+
+        fda->entries[fda->nr].fd     = fd;
+        fda->entries[fda->nr].events = revents;
+        fda->nr++;
+        return pos;
+}
+
+int fdarray__filter(struct fdarray *fda, short revents,
+                    void (*entry_destructor)(struct fdarray *fda, int fd))
+{
+        int fd, nr = 0;
+
+        if (fda->nr == 0)
+                return 0;
+
+        for (fd = 0; fd < fda->nr; ++fd) {
+                if (fda->entries[fd].revents & revents) {
+                        if (entry_destructor)
+                                entry_destructor(fda, fd);
+
+                        continue;
+                }
+
+                if (fd != nr) {
+                        fda->entries[nr] = fda->entries[fd];
+                        fda->priv[nr]    = fda->priv[fd];
+                }
+
+                ++nr;
+        }
+
+        return fda->nr = nr;
+}
+
+int fdarray__poll(struct fdarray *fda, int timeout)
+{
+        return poll(fda->entries, fda->nr, timeout);
+}
+
+int fdarray__fprintf(struct fdarray *fda, FILE *fp)
+{
+        int fd, printed = fprintf(fp, "%d [ ", fda->nr);
+
+        for (fd = 0; fd < fda->nr; ++fd)
+                printed += fprintf(fp, "%s%d", fd ? ", " : "", fda->entries[fd].fd);
+
+        return printed + fprintf(fp, " ]");
+}
diff --git a/tools/lib/api/fd/array.h b/tools/lib/api/fd/array.h
new file mode 100644
index 000000000000..45db01818f45
--- /dev/null
+++ b/tools/lib/api/fd/array.h
@@ -0,0 +1,46 @@
+#ifndef __API_FD_ARRAY__
+#define __API_FD_ARRAY__
+
+#include <stdio.h>
+
+struct pollfd;
+
+/**
+ * struct fdarray: Array of file descriptors
+ *
+ * @priv: Per array entry priv area, users should access just its contents,
+ *        not set it to anything, as it is kept in synch with @entries, being
+ *        realloc'ed, * for instance, in fdarray__{grow,filter}.
+ *
+ *        I.e. using 'fda->priv[N].idx = * value' where N < fda->nr is ok,
+ *        but doing 'fda->priv = malloc(M)' is not allowed.
+ */
+struct fdarray {
+        int            nr;
+        int            nr_alloc;
+        int            nr_autogrow;
+        struct pollfd *entries;
+        union {
+                int    idx;
+        } *priv;
+};
+
+void fdarray__init(struct fdarray *fda, int nr_autogrow);
+void fdarray__exit(struct fdarray *fda);
+
+struct fdarray *fdarray__new(int nr_alloc, int nr_autogrow);
+void fdarray__delete(struct fdarray *fda);
+
+int fdarray__add(struct fdarray *fda, int fd, short revents);
+int fdarray__poll(struct fdarray *fda, int timeout);
+int fdarray__filter(struct fdarray *fda, short revents,
+                    void (*entry_destructor)(struct fdarray *fda, int fd));
+int fdarray__grow(struct fdarray *fda, int extra);
+int fdarray__fprintf(struct fdarray *fda, FILE *fp);
+
+static inline int fdarray__available_entries(struct fdarray *fda)
+{
+        return fda->nr_alloc - fda->nr;
+}
+
+#endif /* __API_FD_ARRAY__ */
diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 782d86e961b9..717221e98450 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -15,6 +15,7 @@ perf.data
 perf.data.old
 output.svg
 perf-archive
+perf-with-kcore
 tags
 TAGS
 cscope*
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index 1513935c399b..aaa869be3dc1 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -104,6 +104,9 @@ OPTIONS
         Specify path to the executable or shared library file for user
         space tracing. Can also be used with --funcs option.
 
+--demangle-kernel::
+        Demangle kernel symbols.
+
 In absence of -m/-x options, perf probe checks if the first argument after
 the options is an absolute path name. If its an absolute path, perf probe
 uses it as a target module/target user space binary to probe.
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index d2b59af62bc0..0927bf4e6c2a 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -147,7 +147,7 @@ OPTIONS
 -w::
 --column-widths=<width[,width...]>::
         Force each column width to the provided list, for large terminal
-        readability.
+        readability.  0 means no limit (default behavior).
 
 -t::
 --field-separator=::
@@ -276,6 +276,9 @@ OPTIONS
         Demangle symbol names to human readable form. It's enabled by default,
         disable with --no-demangle.
 
+--demangle-kernel::
+        Demangle kernel symbol names to human readable form (for C++ kernels).
+
 --mem-mode::
         Use the data addresses of samples in addition to instruction addresses
         to build the histograms.  To generate meaningful output, the perf.data
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 180ae02137a5..3265b1070518 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -98,6 +98,9 @@ Default is to monitor all CPUS.
 --hide_user_symbols::
         Hide user symbols.
 
+--demangle-kernel::
+        Demangle kernel symbols.
+
 -D::
 --dump-symtab::
         Dump the symbol table used for profiling.
@@ -193,6 +196,12 @@ Default is to monitor all CPUS.
         sum of shown entries will be always 100%. "absolute" means it retains
         the original value before and after the filter is applied.
 
+-w::
+--column-widths=<width[,width...]>::
+        Force each column width to the provided list, for large terminal
+        readability.  0 means no limit (default behavior).
+
+
 INTERACTIVE PROMPTING KEYS
 --------------------------
 
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index 2240974b7745..262916f4a377 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -126,6 +126,7 @@ PYRF_OBJS =
 SCRIPT_SH =
 
 SCRIPT_SH += perf-archive.sh
+SCRIPT_SH += perf-with-kcore.sh
 
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
@@ -263,6 +264,7 @@ LIB_H += util/xyarray.h
 LIB_H += util/header.h
 LIB_H += util/help.h
 LIB_H += util/session.h
+LIB_H += util/ordered-events.h
 LIB_H += util/strbuf.h
 LIB_H += util/strlist.h
 LIB_H += util/strfilter.h
@@ -347,6 +349,7 @@ LIB_OBJS += $(OUTPUT)util/machine.o
 LIB_OBJS += $(OUTPUT)util/map.o
 LIB_OBJS += $(OUTPUT)util/pstack.o
 LIB_OBJS += $(OUTPUT)util/session.o
+LIB_OBJS += $(OUTPUT)util/ordered-events.o
 LIB_OBJS += $(OUTPUT)util/comm.o
 LIB_OBJS += $(OUTPUT)util/thread.o
 LIB_OBJS += $(OUTPUT)util/thread_map.o
@@ -399,6 +402,7 @@ LIB_OBJS += $(OUTPUT)tests/perf-record.o
 LIB_OBJS += $(OUTPUT)tests/rdpmc.o
 LIB_OBJS += $(OUTPUT)tests/evsel-roundtrip-name.o
 LIB_OBJS += $(OUTPUT)tests/evsel-tp-sched.o
+LIB_OBJS += $(OUTPUT)tests/fdarray.o
 LIB_OBJS += $(OUTPUT)tests/pmu.o
 LIB_OBJS += $(OUTPUT)tests/hists_common.o
 LIB_OBJS += $(OUTPUT)tests/hists_link.o
@@ -423,6 +427,7 @@ endif
 endif
 LIB_OBJS += $(OUTPUT)tests/mmap-thread-lookup.o
 LIB_OBJS += $(OUTPUT)tests/thread-mg-share.o
+LIB_OBJS += $(OUTPUT)tests/switch-tracking.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
@@ -765,7 +770,7 @@ $(LIBTRACEEVENT)-clean:
 install-traceevent-plugins: $(LIBTRACEEVENT)
         $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) install_plugins
 
-LIBAPIKFS_SOURCES = $(wildcard $(LIB_PATH)fs/*.[ch])
+LIBAPIKFS_SOURCES = $(wildcard $(LIB_PATH)fs/*.[ch] $(LIB_PATH)fd/*.[ch])
 
 # if subdir is set, we've been called from above so target has been built
 # already
@@ -875,6 +880,8 @@ install-bin: all install-gtk
                 $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(call QUIET_INSTALL, perf-archive) \
                 $(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+        $(call QUIET_INSTALL, perf-with-kcore) \
+                $(INSTALL) $(OUTPUT)perf-with-kcore -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 ifndef NO_LIBPERL
         $(call QUIET_INSTALL, perl-scripts) \
                 $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'; \
@@ -920,7 +927,7 @@ config-clean:
         @$(MAKE) -C config/feature-checks clean >/dev/null
 
 clean: $(LIBTRACEEVENT)-clean $(LIBAPIKFS)-clean config-clean
-        $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf.o $(LANG_BINDINGS) $(GTK_OBJS)
+        $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(OUTPUT)perf.o $(LANG_BINDINGS) $(GTK_OBJS)
         $(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf
         $(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS $(OUTPUT)PERF-FEATURES $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex*
         $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
diff --git a/tools/perf/arch/arm/tests/dwarf-unwind.c b/tools/perf/arch/arm/tests/dwarf-unwind.c
index 9f870d27cb39..62eff847f91c 100644
--- a/tools/perf/arch/arm/tests/dwarf-unwind.c
+++ b/tools/perf/arch/arm/tests/dwarf-unwind.c
@@ -3,6 +3,7 @@
 #include "thread.h"
 #include "map.h"
 #include "event.h"
+#include "debug.h"
 #include "tests/tests.h"
 
 #define STACK_SIZE 8192
diff --git a/tools/perf/arch/arm/util/unwind-libunwind.c b/tools/perf/arch/arm/util/unwind-libunwind.c
index 729ed69a6664..62c397ed3d97 100644
--- a/tools/perf/arch/arm/util/unwind-libunwind.c
+++ b/tools/perf/arch/arm/util/unwind-libunwind.c
@@ -3,6 +3,7 @@
 #include <libunwind.h>
 #include "perf_regs.h"
 #include "../../util/unwind.h"
+#include "../../util/debug.h"
 
 int libunwind__arch_reg_id(int regnum)
 {
diff --git a/tools/perf/arch/arm64/include/perf_regs.h b/tools/perf/arch/arm64/include/perf_regs.h
index e9441b9e2a30..1d3f39c3aa56 100644
--- a/tools/perf/arch/arm64/include/perf_regs.h
+++ b/tools/perf/arch/arm64/include/perf_regs.h
@@ -6,6 +6,8 @@
 #include <asm/perf_regs.h>
 
 #define PERF_REGS_MASK  ((1ULL << PERF_REG_ARM64_MAX) - 1)
+#define PERF_REGS_MAX   PERF_REG_ARM64_MAX
+
 #define PERF_REG_IP     PERF_REG_ARM64_PC
 #define PERF_REG_SP     PERF_REG_ARM64_SP
 
diff --git a/tools/perf/arch/arm64/util/unwind-libunwind.c b/tools/perf/arch/arm64/util/unwind-libunwind.c
index 436ee43859dc..a87afa91a99e 100644
--- a/tools/perf/arch/arm64/util/unwind-libunwind.c
+++ b/tools/perf/arch/arm64/util/unwind-libunwind.c
@@ -3,6 +3,7 @@
 #include <libunwind.h>
 #include "perf_regs.h"
 #include "../../util/unwind.h"
+#include "../../util/debug.h"
 
 int libunwind__arch_reg_id(int regnum)
 {
diff --git a/tools/perf/arch/common.c b/tools/perf/arch/common.c
index 42faf369211c..49776f190abf 100644
--- a/tools/perf/arch/common.c
+++ b/tools/perf/arch/common.c
@@ -12,6 +12,11 @@ const char *const arm_triplets[] = {
         NULL
 };
 
+const char *const arm64_triplets[] = {
+        "aarch64-linux-android-",
+        NULL
+};
+
 const char *const powerpc_triplets[] = {
         "powerpc-unknown-linux-gnu-",
         "powerpc64-unknown-linux-gnu-",
@@ -105,6 +110,8 @@ static const char *normalize_arch(char *arch)
                 return "x86";
         if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5))
                 return "sparc";
+        if (!strcmp(arch, "aarch64") || !strcmp(arch, "arm64"))
+                return "arm64";
         if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110"))
                 return "arm";
         if (!strncmp(arch, "s390", 4))
@@ -159,6 +166,8 @@ static int perf_session_env__lookup_binutils_path(struct perf_session_env *env,
 
         if (!strcmp(arch, "arm"))
                 path_list = arm_triplets;
+        else if (!strcmp(arch, "arm64"))
+                path_list = arm64_triplets;
         else if (!strcmp(arch, "powerpc"))
                 path_list = powerpc_triplets;
         else if (!strcmp(arch, "sh"))
diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
index b92219b1900d..6f7782bea5dd 100644
--- a/tools/perf/arch/powerpc/Makefile
+++ b/tools/perf/arch/powerpc/Makefile
@@ -1,6 +1,6 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/skip-callchain-idx.o
 endif
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/skip-callchain-idx.o
diff --git a/tools/perf/arch/powerpc/util/skip-callchain-idx.c b/tools/perf/arch/powerpc/util/skip-callchain-idx.c
index a7c23a4b3778..d73ef8bb08c7 100644
--- a/tools/perf/arch/powerpc/util/skip-callchain-idx.c
+++ b/tools/perf/arch/powerpc/util/skip-callchain-idx.c
@@ -15,6 +15,7 @@
 
 #include "util/thread.h"
 #include "util/callchain.h"
+#include "util/debug.h"
 
 /*
  * When saving the callchain on Power, the kernel conservatively saves
diff --git a/tools/perf/bench/futex-hash.c b/tools/perf/bench/futex-hash.c
index a84206e9c4aa..fc9bebd2cca0 100644
--- a/tools/perf/bench/futex-hash.c
+++ b/tools/perf/bench/futex-hash.c
@@ -26,6 +26,7 @@ static unsigned int nsecs    = 10;
 /* amount of futexes per thread */
 static unsigned int nfutexes = 1024;
 static bool fshared = false, done = false, silent = false;
+static int futex_flag = 0;
 
 struct timeval start, end, runtime;
 static pthread_mutex_t thread_lock;
@@ -75,8 +76,7 @@ static void *workerfn(void *arg)
                          * such as internal waitqueue handling, thus enlarging
                          * the critical region protected by hb->lock.
                          */
-                        ret = futex_wait(&w->futex[i], 1234, NULL,
-                                         fshared ? 0 : FUTEX_PRIVATE_FLAG);
+                        ret = futex_wait(&w->futex[i], 1234, NULL, futex_flag);
                         if (!silent &&
                             (!ret || errno != EAGAIN || errno != EWOULDBLOCK))
                                 warn("Non-expected futex return call");
@@ -135,6 +135,9 @@ int bench_futex_hash(int argc, const char **argv,
         if (!worker)
                 goto errmem;
 
+        if (!fshared)
+                futex_flag = FUTEX_PRIVATE_FLAG;
+
         printf("Run summary [PID %d]: %d threads, each operating on %d [%s] futexes for %d secs.\n\n",
                getpid(), nthreads, nfutexes, fshared ? "shared":"private", nsecs);
 
diff --git a/tools/perf/bench/futex-requeue.c b/tools/perf/bench/futex-requeue.c
index 732403bfd31a..bedff6b5b3cf 100644
--- a/tools/perf/bench/futex-requeue.c
+++ b/tools/perf/bench/futex-requeue.c
@@ -30,16 +30,18 @@ static u_int32_t futex1 = 0, futex2 = 0;
 static unsigned int nrequeue = 1;
 
 static pthread_t *worker;
-static bool done = 0, silent = 0;
+static bool done = false, silent = false, fshared = false;
 static pthread_mutex_t thread_lock;
 static pthread_cond_t thread_parent, thread_worker;
 static struct stats requeuetime_stats, requeued_stats;
 static unsigned int ncpus, threads_starting, nthreads = 0;
+static int futex_flag = 0;
 
 static const struct option options[] = {
         OPT_UINTEGER('t', "threads",  &nthreads, "Specify amount of threads"),
         OPT_UINTEGER('q', "nrequeue", &nrequeue, "Specify amount of threads to requeue at once"),
         OPT_BOOLEAN( 's', "silent",   &silent,   "Silent mode: do not display data/details"),
+        OPT_BOOLEAN( 'S', "shared",   &fshared,  "Use shared futexes instead of private ones"),
         OPT_END()
 };
 
@@ -70,7 +72,7 @@ static void *workerfn(void *arg __maybe_unused)
         pthread_cond_wait(&thread_worker, &thread_lock);
         pthread_mutex_unlock(&thread_lock);
 
-        futex_wait(&futex1, 0, NULL, FUTEX_PRIVATE_FLAG);
+        futex_wait(&futex1, 0, NULL, futex_flag);
         return NULL;
 }
 
@@ -127,9 +129,12 @@ int bench_futex_requeue(int argc, const char **argv,
         if (!worker)
                 err(EXIT_FAILURE, "calloc");
 
-        printf("Run summary [PID %d]: Requeuing %d threads (from %p to %p), "
-               "%d at a time.\n\n",
-               getpid(), nthreads, &futex1, &futex2, nrequeue);
+        if (!fshared)
+                futex_flag = FUTEX_PRIVATE_FLAG;
+
+        printf("Run summary [PID %d]: Requeuing %d threads (from [%s] %p to %p), "
+               "%d at a time.\n\n",  getpid(), nthreads,
+               fshared ? "shared":"private", &futex1, &futex2, nrequeue);
 
         init_stats(&requeued_stats);
         init_stats(&requeuetime_stats);
@@ -156,16 +161,20 @@ int bench_futex_requeue(int argc, const char **argv,
 
                 /* Ok, all threads are patiently blocked, start requeueing */
                 gettimeofday(&start, NULL);
-                for (nrequeued = 0; nrequeued < nthreads; nrequeued += nrequeue)
+                for (nrequeued = 0; nrequeued < nthreads; nrequeued += nrequeue) {
                         /*
                          * Do not wakeup any tasks blocked on futex1, allowing
                          * us to really measure futex_wait functionality.
                          */
-                        futex_cmp_requeue(&futex1, 0, &futex2, 0, nrequeue,
-                                          FUTEX_PRIVATE_FLAG);
+                        futex_cmp_requeue(&futex1, 0, &futex2, 0,
+                                          nrequeue, futex_flag);
+                }
                 gettimeofday(&end, NULL);
                 timersub(&end, &start, &runtime);
 
+                if (nrequeued > nthreads)
+                        nrequeued = nthreads;
+
                 update_stats(&requeued_stats, nrequeued);
                 update_stats(&requeuetime_stats, runtime.tv_usec);
 
@@ -175,7 +184,7 @@ int bench_futex_requeue(int argc, const char **argv,
                 }
 
                 /* everybody should be blocked on futex2, wake'em up */
-                nrequeued = futex_wake(&futex2, nthreads, FUTEX_PRIVATE_FLAG);
+                nrequeued = futex_wake(&futex2, nthreads, futex_flag);
                 if (nthreads != nrequeued)
                         warnx("couldn't wakeup all tasks (%d/%d)", nrequeued, nthreads);
 
@@ -184,7 +193,6 @@ int bench_futex_requeue(int argc, const char **argv,
                         if (ret)
                                 err(EXIT_FAILURE, "pthread_join");
                 }
-
         }
 
         /* cleanup & report results */
diff --git a/tools/perf/bench/futex-wake.c b/tools/perf/bench/futex-wake.c
index 50022cbce87e..929f762be47e 100644
--- a/tools/perf/bench/futex-wake.c
+++ b/tools/perf/bench/futex-wake.c
@@ -31,16 +31,18 @@ static u_int32_t futex1 = 0;
 static unsigned int nwakes = 1;
 
 pthread_t *worker;
-static bool done = false, silent = false;
+static bool done = false, silent = false, fshared = false;
 static pthread_mutex_t thread_lock;
 static pthread_cond_t thread_parent, thread_worker;
 static struct stats waketime_stats, wakeup_stats;
 static unsigned int ncpus, threads_starting, nthreads = 0;
+static int futex_flag = 0;
 
 static const struct option options[] = {
         OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
         OPT_UINTEGER('w', "nwakes",  &nwakes,   "Specify amount of threads to wake at once"),
         OPT_BOOLEAN( 's', "silent",  &silent,   "Silent mode: do not display data/details"),
+        OPT_BOOLEAN( 'S', "shared",  &fshared,  "Use shared futexes instead of private ones"),
         OPT_END()
 };
 
@@ -58,7 +60,7 @@ static void *workerfn(void *arg __maybe_unused)
         pthread_cond_wait(&thread_worker, &thread_lock);
         pthread_mutex_unlock(&thread_lock);
 
-        futex_wait(&futex1, 0, NULL, FUTEX_PRIVATE_FLAG);
+        futex_wait(&futex1, 0, NULL, futex_flag);
         return NULL;
 }
 
@@ -130,9 +132,12 @@ int bench_futex_wake(int argc, const char **argv,
         if (!worker)
                 err(EXIT_FAILURE, "calloc");
 
-        printf("Run summary [PID %d]: blocking on %d threads (at futex %p), "
+        if (!fshared)
+                futex_flag = FUTEX_PRIVATE_FLAG;
+
+        printf("Run summary [PID %d]: blocking on %d threads (at [%s] futex %p), "
                "waking up %d at a time.\n\n",
-               getpid(), nthreads, &futex1, nwakes);
+               getpid(), nthreads, fshared ? "shared":"private",  &futex1, nwakes);
 
         init_stats(&wakeup_stats);
         init_stats(&waketime_stats);
@@ -160,7 +165,7 @@ int bench_futex_wake(int argc, const char **argv,
                 /* Ok, all threads are patiently blocked, start waking folks up */
                 gettimeofday(&start, NULL);
                 while (nwoken != nthreads)
-                        nwoken += futex_wake(&futex1, nwakes, FUTEX_PRIVATE_FLAG);
+                        nwoken += futex_wake(&futex1, nwakes, futex_flag);
                 gettimeofday(&end, NULL);
                 timersub(&end, &start, &runtime);
 
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index 52a56599a543..d7f281c2828d 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -26,7 +26,7 @@
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <sys/time.h>
-#include <sys/poll.h>
+#include <poll.h>
 #include <limits.h>
 #include <err.h>
 
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 1ec429fef2be..be5939418425 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -36,7 +36,8 @@
 
 struct perf_annotate {
         struct perf_tool tool;
-        bool       force, use_tui, use_stdio, use_gtk;
+        struct perf_session *session;
+        bool       use_tui, use_stdio, use_gtk;
         bool       full_paths;
         bool       print_line;
         bool       skip_missing;
@@ -188,18 +189,9 @@ find_next:
 static int __cmd_annotate(struct perf_annotate *ann)
 {
         int ret;
-        struct perf_session *session;
+        struct perf_session *session = ann->session;
         struct perf_evsel *pos;
         u64 total_nr_samples;
-        struct perf_data_file file = {
-                .path  = input_name,
-                .mode  = PERF_DATA_MODE_READ,
-                .force = ann->force,
-        };
-
-        session = perf_session__new(&file, false, &ann->tool);
-        if (session == NULL)
-                return -ENOMEM;
 
         machines__set_symbol_filter(&session->machines, symbol__annotate_init);
 
@@ -207,22 +199,22 @@ static int __cmd_annotate(struct perf_annotate *ann)
                 ret = perf_session__cpu_bitmap(session, ann->cpu_list,
                                                ann->cpu_bitmap);
                 if (ret)
-                        goto out_delete;
+                        goto out;
         }
 
         if (!objdump_path) {
                 ret = perf_session_env__lookup_objdump(&session->header.env);
                 if (ret)
-                        goto out_delete;
+                        goto out;
         }
 
         ret = perf_session__process_events(session, &ann->tool);
         if (ret)
-                goto out_delete;
+                goto out;
 
         if (dump_trace) {
                 perf_session__fprintf_nr_events(session, stdout);
-                goto out_delete;
+                goto out;
         }
 
         if (verbose > 3)
@@ -250,8 +242,8 @@ static int __cmd_annotate(struct perf_annotate *ann)
         }
 
         if (total_nr_samples == 0) {
-                ui__error("The %s file has no samples!\n", file.path);
-                goto out_delete;
+                ui__error("The %s file has no samples!\n", session->file->path);
+                goto out;
         }
 
         if (use_browser == 2) {
@@ -261,24 +253,12 @@ static int __cmd_annotate(struct perf_annotate *ann)
                                          "perf_gtk__show_annotations");
                 if (show_annotations == NULL) {
                         ui__error("GTK browser not found!\n");
-                        goto out_delete;
+                        goto out;
                 }
                 show_annotations();
         }
 
-out_delete:
-        /*
-         * Speed up the exit process, for large files this can
-         * take quite a while.
-         *
-         * XXX Enable this when using valgrind or if we ever
-         * librarize this command.
-         *
-         * Also experiment with obstacks to see how much speed
-         * up we'll get here.
-         *
-         * perf_session__delete(session);
-         */
+out:
         return ret;
 }
 
@@ -297,10 +277,14 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                         .comm   = perf_event__process_comm,
                         .exit   = perf_event__process_exit,
                         .fork   = perf_event__process_fork,
-                        .ordered_samples = true,
+                        .ordered_events = true,
                         .ordering_requires_timestamps = true,
                 },
         };
+        struct perf_data_file file = {
+                .path  = input_name,
+                .mode  = PERF_DATA_MODE_READ,
+        };
         const struct option options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
@@ -308,7 +292,7 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                    "only consider symbols in these dsos"),
         OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol",
                     "symbol to annotate"),
-        OPT_BOOLEAN('f', "force", &annotate.force, "don't complain, do it"),
+        OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
@@ -341,6 +325,7 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show event group information together"),
         OPT_END()
         };
+        int ret;
 
         argc = parse_options(argc, argv, options, annotate_usage, 0);
 
@@ -353,11 +338,16 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
 
         setup_browser(true);
 
+        annotate.session = perf_session__new(&file, false, &annotate.tool);
+        if (annotate.session == NULL)
+                return -1;
+
         symbol_conf.priv_size = sizeof(struct annotation);
         symbol_conf.try_vmlinux_path = true;
 
-        if (symbol__init() < 0)
-                return -1;
+        ret = symbol__init(&annotate.session->header.env);
+        if (ret < 0)
+                goto out_delete;
 
         if (setup_sorting() < 0)
                 usage_with_options(annotate_usage, options);
@@ -373,5 +363,20 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                 annotate.sym_hist_filter = argv[0];
         }
 
-        return __cmd_annotate(&annotate);
+        ret = __cmd_annotate(&annotate);
+
+out_delete:
+        /*
+         * Speed up the exit process, for large files this can
+         * take quite a while.
+         *
+         * XXX Enable this when using valgrind or if we ever
+         * librarize this command.
+         *
+         * Also experiment with obstacks to see how much speed
+         * up we'll get here.
+         *
+         * perf_session__delete(session);
+         */
+        return ret;
 }
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index 2a2c78f80876..70385756da63 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -246,20 +246,9 @@ static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused)
         return true;
 }
 
-static int build_id_cache__fprintf_missing(const char *filename, bool force, FILE *fp)
+static int build_id_cache__fprintf_missing(struct perf_session *session, FILE *fp)
 {
-        struct perf_data_file file = {
-                .path  = filename,
-                .mode  = PERF_DATA_MODE_READ,
-                .force = force,
-        };
-        struct perf_session *session = perf_session__new(&file, 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;
 }
 
@@ -302,6 +291,12 @@ int cmd_buildid_cache(int argc, const char **argv,
                    *missing_filename = NULL,
                    *update_name_list_str = NULL,
                    *kcore_filename;
+        char sbuf[STRERR_BUFSIZE];
+
+        struct perf_data_file file = {
+                .mode  = PERF_DATA_MODE_READ,
+        };
+        struct perf_session *session = NULL;
 
         const struct option buildid_cache_options[] = {
         OPT_STRING('a', "add", &add_name_list_str,
@@ -326,8 +321,17 @@ int cmd_buildid_cache(int argc, const char **argv,
         argc = parse_options(argc, argv, buildid_cache_options,
                              buildid_cache_usage, 0);
 
-        if (symbol__init() < 0)
-                return -1;
+        if (missing_filename) {
+                file.path = missing_filename;
+                file.force = force;
+
+                session = perf_session__new(&file, false, NULL);
+                if (session == NULL)
+                        return -1;
+        }
+
+        if (symbol__init(session ? &session->header.env : NULL) < 0)
+                goto out;
 
         setup_pager();
 
@@ -344,7 +348,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't add %s: %s\n",
-                                                   pos->s, strerror(errno));
+                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -362,7 +366,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't remove %s: %s\n",
-                                                   pos->s, strerror(errno));
+                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -370,7 +374,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         }
 
         if (missing_filename)
-                ret = build_id_cache__fprintf_missing(missing_filename, force, stdout);
+                ret = build_id_cache__fprintf_missing(session, stdout);
 
         if (update_name_list_str) {
                 list = strlist__new(true, update_name_list_str);
@@ -383,7 +387,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't update %s: %s\n",
-                                                   pos->s, strerror(errno));
+                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -394,5 +398,9 @@ int cmd_buildid_cache(int argc, const char **argv,
             build_id_cache__add_kcore(kcore_filename, debugdir, force))
                 pr_warning("Couldn't add %s\n", kcore_filename);
 
+out:
+        if (session)
+                perf_session__delete(session);
+
         return ret;
 }
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 9a5a035cb426..a3ce19f7aebd 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -360,7 +360,7 @@ static struct perf_tool tool = {
         .exit   = perf_event__process_exit,
         .fork   = perf_event__process_fork,
         .lost   = perf_event__process_lost,
-        .ordered_samples = true,
+        .ordered_events = true,
         .ordering_requires_timestamps = true,
 };
 
@@ -683,7 +683,7 @@ static int __cmd_diff(void)
                 d->session = perf_session__new(&d->file, false, &tool);
                 if (!d->session) {
                         pr_err("Failed to open %s\n", d->file.path);
-                        ret = -ENOMEM;
+                        ret = -1;
                         goto out_delete;
                 }
 
@@ -1143,7 +1143,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
 
         argc = parse_options(argc, argv, options, diff_usage, 0);
 
-        if (symbol__init() < 0)
+        if (symbol__init(NULL) < 0)
                 return -1;
 
         if (data_init(argc, argv) < 0)
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index 66e12f55c052..0f93f859b782 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -28,7 +28,7 @@ static int __cmd_evlist(const char *file_name, struct perf_attr_details *details
 
         session = perf_session__new(&file, 0, NULL);
         if (session == NULL)
-                return -ENOMEM;
+                return -1;
 
         evlist__for_each(session->evlist, pos)
                 perf_evsel__fprintf(pos, details, stdout);
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 0384d930480b..25d20628212e 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -103,6 +103,8 @@ static int check_emacsclient_version(void)
 
 static void exec_woman_emacs(const char *path, const char *page)
 {
+        char sbuf[STRERR_BUFSIZE];
+
         if (!check_emacsclient_version()) {
                 /* This works only with emacsclient version >= 22. */
                 struct strbuf man_page = STRBUF_INIT;
@@ -111,16 +113,19 @@ static void exec_woman_emacs(const char *path, const char *page)
                         path = "emacsclient";
                 strbuf_addf(&man_page, "(woman \"%s\")", page);
                 execlp(path, "emacsclient", "-e", man_page.buf, NULL);
-                warning("failed to exec '%s': %s", path, strerror(errno));
+                warning("failed to exec '%s': %s", path,
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
         }
 }
 
 static void exec_man_konqueror(const char *path, const char *page)
 {
         const char *display = getenv("DISPLAY");
+
         if (display && *display) {
                 struct strbuf man_page = STRBUF_INIT;
                 const char *filename = "kfmclient";
+                char sbuf[STRERR_BUFSIZE];
 
                 /* It's simpler to launch konqueror using kfmclient. */
                 if (path) {
@@ -139,24 +144,31 @@ static void exec_man_konqueror(const char *path, const char *page)
                         path = "kfmclient";
                 strbuf_addf(&man_page, "man:%s(1)", page);
                 execlp(path, filename, "newTab", man_page.buf, NULL);
-                warning("failed to exec '%s': %s", path, strerror(errno));
+                warning("failed to exec '%s': %s", path,
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
         }
 }
 
 static void exec_man_man(const char *path, const char *page)
 {
+        char sbuf[STRERR_BUFSIZE];
+
         if (!path)
                 path = "man";
         execlp(path, "man", page, NULL);
-        warning("failed to exec '%s': %s", path, strerror(errno));
+        warning("failed to exec '%s': %s", path,
+                strerror_r(errno, sbuf, sizeof(sbuf)));
 }
 
 static void exec_man_cmd(const char *cmd, const char *page)
 {
         struct strbuf shell_cmd = STRBUF_INIT;
+        char sbuf[STRERR_BUFSIZE];
+
         strbuf_addf(&shell_cmd, "%s %s", cmd, page);
         execl("/bin/sh", "sh", "-c", shell_cmd.buf, NULL);
-        warning("failed to exec '%s': %s", cmd, strerror(errno));
+        warning("failed to exec '%s': %s", cmd,
+                strerror_r(errno, sbuf, sizeof(sbuf)));
 }
 
 static void add_man_viewer(const char *name)
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 9a02807387d6..de99ca1bb942 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -23,6 +23,7 @@
 
 struct perf_inject {
         struct perf_tool        tool;
+        struct perf_session     *session;
         bool                    build_ids;
         bool                    sched_stat;
         const char              *input_name;
@@ -340,12 +341,8 @@ static int perf_evsel__check_stype(struct perf_evsel *evsel,
 
 static int __cmd_inject(struct perf_inject *inject)
 {
-        struct perf_session *session;
         int ret = -EINVAL;
-        struct perf_data_file file = {
-                .path = inject->input_name,
-                .mode = PERF_DATA_MODE_READ,
-        };
+        struct perf_session *session = inject->session;
         struct perf_data_file *file_out = &inject->output;
 
         signal(SIGINT, sig_handler);
@@ -357,16 +354,12 @@ static int __cmd_inject(struct perf_inject *inject)
                 inject->tool.tracing_data = perf_event__repipe_tracing_data;
         }
 
-        session = perf_session__new(&file, true, &inject->tool);
-        if (session == NULL)
-                return -ENOMEM;
-
         if (inject->build_ids) {
                 inject->tool.sample = perf_event__inject_buildid;
         } else if (inject->sched_stat) {
                 struct perf_evsel *evsel;
 
-                inject->tool.ordered_samples = true;
+                inject->tool.ordered_events = true;
 
                 evlist__for_each(session->evlist, evsel) {
                         const char *name = perf_evsel__name(evsel);
@@ -396,8 +389,6 @@ static int __cmd_inject(struct perf_inject *inject)
                 perf_session__write_header(session, session->evlist, file_out->fd, true);
         }
 
-        perf_session__delete(session);
-
         return ret;
 }
 
@@ -427,6 +418,11 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                         .mode = PERF_DATA_MODE_WRITE,
                 },
         };
+        struct perf_data_file file = {
+                .mode = PERF_DATA_MODE_READ,
+        };
+        int ret;
+
         const struct option options[] = {
                 OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
                             "Inject build-ids into the output stream"),
@@ -461,8 +457,17 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                 return -1;
         }
 
-        if (symbol__init() < 0)
+        file.path = inject.input_name;
+        inject.session = perf_session__new(&file, true, &inject.tool);
+        if (inject.session == NULL)
+                return -1;
+
+        if (symbol__init(&inject.session->header.env) < 0)
                 return -1;
 
-        return __cmd_inject(&inject);
+        ret = __cmd_inject(&inject);
+
+        perf_session__delete(inject.session);
+
+        return ret;
 }
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index bef3376bfaf3..f295141025bc 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -256,7 +256,9 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
 static struct perf_tool perf_kmem = {
         .sample          = process_sample_event,
         .comm            = perf_event__process_comm,
-        .ordered_samples = true,
+        .mmap            = perf_event__process_mmap,
+        .mmap2           = perf_event__process_mmap2,
+        .ordered_events  = true,
 };
 
 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
@@ -403,10 +405,9 @@ static void sort_result(void)
         __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
 }
 
-static int __cmd_kmem(void)
+static int __cmd_kmem(struct perf_session *session)
 {
         int err = -EINVAL;
-        struct perf_session *session;
         const struct perf_evsel_str_handler kmem_tracepoints[] = {
                 { "kmem:kmalloc",               perf_evsel__process_alloc_event, },
                 { "kmem:kmem_cache_alloc",      perf_evsel__process_alloc_event, },
@@ -415,34 +416,22 @@ static int __cmd_kmem(void)
                 { "kmem:kfree",                 perf_evsel__process_free_event, },
                 { "kmem:kmem_cache_free",       perf_evsel__process_free_event, },
         };
-        struct perf_data_file file = {
-                .path = input_name,
-                .mode = PERF_DATA_MODE_READ,
-        };
-
-        session = perf_session__new(&file, false, &perf_kmem);
-        if (session == NULL)
-                return -ENOMEM;
-
-        if (perf_session__create_kernel_maps(session) < 0)
-                goto out_delete;
 
         if (!perf_session__has_traces(session, "kmem record"))
-                goto out_delete;
+                goto out;
 
         if (perf_session__set_tracepoints_handlers(session, kmem_tracepoints)) {
                 pr_err("Initializing perf session tracepoint handlers failed\n");
-                return -1;
+                goto out;
         }
 
         setup_pager();
         err = perf_session__process_events(session, &perf_kmem);
         if (err != 0)
-                goto out_delete;
+                goto out;
         sort_result();
         print_result(session);
-out_delete:
-        perf_session__delete(session);
+out:
         return err;
 }
 
@@ -689,29 +678,46 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
                 NULL,
                 NULL
         };
+        struct perf_session *session;
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
+        int ret = -1;
+
         argc = parse_options_subcommand(argc, argv, kmem_options,
                                         kmem_subcommands, kmem_usage, 0);
 
         if (!argc)
                 usage_with_options(kmem_usage, kmem_options);
 
-        symbol__init();
-
         if (!strncmp(argv[0], "rec", 3)) {
+                symbol__init(NULL);
                 return __cmd_record(argc, argv);
-        } else if (!strcmp(argv[0], "stat")) {
+        }
+
+        session = perf_session__new(&file, false, &perf_kmem);
+        if (session == NULL)
+                return -1;
+
+        symbol__init(&session->header.env);
+
+        if (!strcmp(argv[0], "stat")) {
                 if (cpu__setup_cpunode_map())
-                        return -1;
+                        goto out_delete;
 
                 if (list_empty(&caller_sort))
                         setup_sorting(&caller_sort, default_sort_order);
                 if (list_empty(&alloc_sort))
                         setup_sorting(&alloc_sort, default_sort_order);
 
-                return __cmd_kmem();
+                ret = __cmd_kmem(session);
         } else
                 usage_with_options(kmem_usage, kmem_options);
 
-        return 0;
+out_delete:
+        perf_session__delete(session);
+
+        return ret;
 }
 
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 43367eb00510..d8bf2271f4ea 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -543,14 +543,12 @@ static void print_vcpu_info(struct perf_kvm_stat *kvm)
 
         pr_info("Analyze events for ");
 
-        if (kvm->live) {
-                if (kvm->opts.target.system_wide)
-                        pr_info("all VMs, ");
-                else if (kvm->opts.target.pid)
-                        pr_info("pid(s) %s, ", kvm->opts.target.pid);
-                else
-                        pr_info("dazed and confused on what is monitored, ");
-        }
+        if (kvm->opts.target.system_wide)
+                pr_info("all VMs, ");
+        else if (kvm->opts.target.pid)
+                pr_info("pid(s) %s, ", kvm->opts.target.pid);
+        else
+                pr_info("dazed and confused on what is monitored, ");
 
         if (vcpu == -1)
                 pr_info("all VCPUs:\n\n");
@@ -592,8 +590,8 @@ static void print_result(struct perf_kvm_stat *kvm)
         pr_info("%9s ", "Samples%");
 
         pr_info("%9s ", "Time%");
-        pr_info("%10s ", "Min Time");
-        pr_info("%10s ", "Max Time");
+        pr_info("%11s ", "Min Time");
+        pr_info("%11s ", "Max Time");
         pr_info("%16s ", "Avg time");
         pr_info("\n\n");
 
@@ -610,8 +608,8 @@ static void print_result(struct perf_kvm_stat *kvm)
                 pr_info("%10llu ", (unsigned long long)ecount);
                 pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100);
                 pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100);
-                pr_info("%8" PRIu64 "us ", min / 1000);
-                pr_info("%8" PRIu64 "us ", max / 1000);
+                pr_info("%9.2fus ", (double)min / 1e3);
+                pr_info("%9.2fus ", (double)max / 1e3);
                 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3,
                         kvm_event_rel_stddev(vcpu, event));
                 pr_info("\n");
@@ -732,7 +730,7 @@ static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,
                         return -1;
                 }
 
-                err = perf_session_queue_event(kvm->session, event, &sample, 0);
+                err = perf_session_queue_event(kvm->session, event, &kvm->tool, &sample, 0);
                 /*
                  * FIXME: Here we can't consume the event, as perf_session_queue_event will
                  *        point to it, and it'll get possibly overwritten by the kernel.
@@ -785,7 +783,7 @@ static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)
 
         /* flush queue after each round in which we processed events */
         if (ntotal) {
-                kvm->session->ordered_samples.next_flush = flush_time;
+                kvm->session->ordered_events.next_flush = flush_time;
                 err = kvm->tool.finished_round(&kvm->tool, NULL, kvm->session);
                 if (err) {
                         if (kvm->lost_events)
@@ -885,15 +883,11 @@ static int fd_set_nonblock(int fd)
         return 0;
 }
 
-static
-int perf_kvm__handle_stdin(struct termios *tc_now, struct termios *tc_save)
+static int perf_kvm__handle_stdin(void)
 {
         int c;
 
-        tcsetattr(0, TCSANOW, tc_now);
         c = getc(stdin);
-        tcsetattr(0, TCSAFLUSH, tc_save);
-
         if (c == 'q')
                 return 1;
 
@@ -904,7 +898,7 @@ static int kvm_events_live_report(struct perf_kvm_stat *kvm)
 {
         struct pollfd *pollfds = NULL;
         int nr_fds, nr_stdin, ret, err = -EINVAL;
-        struct termios tc, save;
+        struct termios save;
 
         /* live flag must be set first */
         kvm->live = true;
@@ -919,26 +913,14 @@ static int kvm_events_live_report(struct perf_kvm_stat *kvm)
                 goto out;
         }
 
+        set_term_quiet_input(&save);
         init_kvm_event_record(kvm);
 
-        tcgetattr(0, &save);
-        tc = save;
-        tc.c_lflag &= ~(ICANON | ECHO);
-        tc.c_cc[VMIN] = 0;
-        tc.c_cc[VTIME] = 0;
-
         signal(SIGINT, sig_handler);
         signal(SIGTERM, sig_handler);
 
-        /* copy pollfds -- need to add timerfd and stdin */
-        nr_fds = kvm->evlist->nr_fds;
-        pollfds = zalloc(sizeof(struct pollfd) * (nr_fds + 2));
-        if (!pollfds) {
-                err = -ENOMEM;
-                goto out;
-        }
-        memcpy(pollfds, kvm->evlist->pollfd,
-                sizeof(struct pollfd) * kvm->evlist->nr_fds);
+        /* use pollfds -- need to add timerfd and stdin */
+        nr_fds = kvm->evlist->pollfd.nr;
 
         /* add timer fd */
         if (perf_kvm__timerfd_create(kvm) < 0) {
@@ -946,17 +928,21 @@ static int kvm_events_live_report(struct perf_kvm_stat *kvm)
                 goto out;
         }
 
-        pollfds[nr_fds].fd = kvm->timerfd;
-        pollfds[nr_fds].events = POLLIN;
+        if (perf_evlist__add_pollfd(kvm->evlist, kvm->timerfd))
+                goto out;
+
         nr_fds++;
 
-        pollfds[nr_fds].fd = fileno(stdin);
-        pollfds[nr_fds].events = POLLIN;
+        if (perf_evlist__add_pollfd(kvm->evlist, fileno(stdin)))
+                goto out;
+
         nr_stdin = nr_fds;
         nr_fds++;
         if (fd_set_nonblock(fileno(stdin)) != 0)
                 goto out;
 
+        pollfds  = kvm->evlist->pollfd.entries;
+
         /* everything is good - enable the events and process */
         perf_evlist__enable(kvm->evlist);
 
@@ -972,7 +958,7 @@ static int kvm_events_live_report(struct perf_kvm_stat *kvm)
                         goto out;
 
                 if (pollfds[nr_stdin].revents & POLLIN)
-                        done = perf_kvm__handle_stdin(&tc, &save);
+                        done = perf_kvm__handle_stdin();
 
                 if (!rc && !done)
                         err = poll(pollfds, nr_fds, 100);
@@ -989,7 +975,7 @@ out:
         if (kvm->timerfd >= 0)
                 close(kvm->timerfd);
 
-        free(pollfds);
+        tcsetattr(0, TCSAFLUSH, &save);
         return err;
 }
 
@@ -998,6 +984,7 @@ static int kvm_live_open_events(struct perf_kvm_stat *kvm)
         int err, rc = -1;
         struct perf_evsel *pos;
         struct perf_evlist *evlist = kvm->evlist;
+        char sbuf[STRERR_BUFSIZE];
 
         perf_evlist__config(evlist, &kvm->opts);
 
@@ -1034,12 +1021,14 @@ static int kvm_live_open_events(struct perf_kvm_stat *kvm)
 
         err = perf_evlist__open(evlist);
         if (err < 0) {
-                printf("Couldn't create the events: %s\n", strerror(errno));
+                printf("Couldn't create the events: %s\n",
+                       strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out;
         }
 
         if (perf_evlist__mmap(evlist, kvm->opts.mmap_pages, false) < 0) {
-                ui__error("Failed to mmap the events: %s\n", strerror(errno));
+                ui__error("Failed to mmap the events: %s\n",
+                          strerror_r(errno, sbuf, sizeof(sbuf)));
                 perf_evlist__close(evlist);
                 goto out;
         }
@@ -1058,7 +1047,7 @@ static int read_events(struct perf_kvm_stat *kvm)
         struct perf_tool eops = {
                 .sample                 = process_sample_event,
                 .comm                   = perf_event__process_comm,
-                .ordered_samples        = true,
+                .ordered_events         = true,
         };
         struct perf_data_file file = {
                 .path = kvm->file_name,
@@ -1069,9 +1058,11 @@ static int read_events(struct perf_kvm_stat *kvm)
         kvm->session = perf_session__new(&file, false, &kvm->tool);
         if (!kvm->session) {
                 pr_err("Initializing perf session failed\n");
-                return -EINVAL;
+                return -1;
         }
 
+        symbol__init(&kvm->session->header.env);
+
         if (!perf_session__has_traces(kvm->session, "kvm record"))
                 return -EINVAL;
 
@@ -1088,8 +1079,8 @@ static int read_events(struct perf_kvm_stat *kvm)
 
 static int parse_target_str(struct perf_kvm_stat *kvm)
 {
-        if (kvm->pid_str) {
-                kvm->pid_list = intlist__new(kvm->pid_str);
+        if (kvm->opts.target.pid) {
+                kvm->pid_list = intlist__new(kvm->opts.target.pid);
                 if (kvm->pid_list == NULL) {
                         pr_err("Error parsing process id string\n");
                         return -EINVAL;
@@ -1191,7 +1182,7 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
                             "key for sorting: sample(sort by samples number)"
                             " time (sort by avg time)"),
-                OPT_STRING('p', "pid", &kvm->pid_str, "pid",
+                OPT_STRING('p', "pid", &kvm->opts.target.pid, "pid",
                            "analyze events only for given process id(s)"),
                 OPT_END()
         };
@@ -1201,8 +1192,6 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
                 NULL
         };
 
-        symbol__init();
-
         if (argc) {
                 argc = parse_options(argc, argv,
                                      kvm_events_report_options,
@@ -1212,6 +1201,9 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
                                            kvm_events_report_options);
         }
 
+        if (!kvm->opts.target.pid)
+                kvm->opts.target.system_wide = true;
+
         return kvm_events_report_vcpu(kvm);
 }
 
@@ -1311,7 +1303,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
         kvm->tool.exit   = perf_event__process_exit;
         kvm->tool.fork   = perf_event__process_fork;
         kvm->tool.lost   = process_lost_event;
-        kvm->tool.ordered_samples = true;
+        kvm->tool.ordered_events = true;
         perf_tool__fill_defaults(&kvm->tool);
 
         /* set defaults */
@@ -1322,7 +1314,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
         kvm->opts.target.uid_str = NULL;
         kvm->opts.target.uid = UINT_MAX;
 
-        symbol__init();
+        symbol__init(NULL);
         disable_buildid_cache();
 
         use_browser = 0;
@@ -1369,7 +1361,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
          */
         kvm->session = perf_session__new(&file, false, &kvm->tool);
         if (kvm->session == NULL) {
-                err = -ENOMEM;
+                err = -1;
                 goto out;
         }
         kvm->session->evlist = kvm->evlist;
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 6148afc995c6..e7ec71589da6 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -852,7 +852,7 @@ static int __cmd_report(bool display_info)
         struct perf_tool eops = {
                 .sample          = process_sample_event,
                 .comm            = perf_event__process_comm,
-                .ordered_samples = true,
+                .ordered_events  = true,
         };
         struct perf_data_file file = {
                 .path = input_name,
@@ -862,9 +862,11 @@ static int __cmd_report(bool display_info)
         session = perf_session__new(&file, false, &eops);
         if (!session) {
                 pr_err("Initializing perf session failed\n");
-                return -ENOMEM;
+                return -1;
         }
 
+        symbol__init(&session->header.env);
+
         if (!perf_session__has_traces(session, "lock record"))
                 goto out_delete;
 
@@ -974,7 +976,6 @@ int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
         unsigned int i;
         int rc = 0;
 
-        symbol__init();
         for (i = 0; i < LOCKHASH_SIZE; i++)
                 INIT_LIST_HEAD(lockhash_table + i);
 
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 4a1a6c94a5eb..24db6ffe2957 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -124,7 +124,7 @@ static int report_raw_events(struct perf_mem *mem)
                                                          &mem->tool);
 
         if (session == NULL)
-                return -ENOMEM;
+                return -1;
 
         if (mem->cpu_list) {
                 ret = perf_session__cpu_bitmap(session, mem->cpu_list,
@@ -133,7 +133,7 @@ static int report_raw_events(struct perf_mem *mem)
                         goto out_delete;
         }
 
-        if (symbol__init() < 0)
+        if (symbol__init(&session->header.env) < 0)
                 return -1;
 
         printf("# PID, TID, IP, ADDR, LOCAL WEIGHT, DSRC, SYMBOL\n");
@@ -194,7 +194,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
                         .lost           = perf_event__process_lost,
                         .fork           = perf_event__process_fork,
                         .build_id       = perf_event__process_build_id,
-                        .ordered_samples = true,
+                        .ordered_events = true,
                 },
                 .input_name              = "perf.data",
         };
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index c63fa2925075..04412b4770a2 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -290,8 +290,11 @@ static void cleanup_params(void)
 
 static void pr_err_with_code(const char *msg, int err)
 {
+        char sbuf[STRERR_BUFSIZE];
+
         pr_err("%s", msg);
-        pr_debug(" Reason: %s (Code: %d)", strerror(-err), err);
+        pr_debug(" Reason: %s (Code: %d)",
+                 strerror_r(-err, sbuf, sizeof(sbuf)), err);
         pr_err("\n");
 }
 
@@ -373,6 +376,8 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
                         "target executable name or path", opt_set_target),
         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
                     "Disable symbol demangling"),
+        OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
+                    "Enable kernel symbol demangling"),
         OPT_END()
         };
         int ret;
@@ -467,7 +472,8 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
                         usage_with_options(probe_usage, options);
                 }
 
-                ret = show_line_range(&params.line_range, params.target);
+                ret = show_line_range(&params.line_range, params.target,
+                                      params.uprobes);
                 if (ret < 0)
                         pr_err_with_code("  Error: Failed to show lines.", ret);
                 return ret;
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 4869050e7194..44c6f3d55ce7 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -65,8 +65,9 @@ static int process_synthesized_event(struct perf_tool *tool,
         return record__write(rec, event, event->header.size);
 }
 
-static int record__mmap_read(struct record *rec, struct perf_mmap *md)
+static int record__mmap_read(struct record *rec, int idx)
 {
+        struct perf_mmap *md = &rec->evlist->mmap[idx];
         unsigned int head = perf_mmap__read_head(md);
         unsigned int old = md->prev;
         unsigned char *data = md->base + page_size;
@@ -102,8 +103,7 @@ static int record__mmap_read(struct record *rec, struct perf_mmap *md)
         }
 
         md->prev = old;
-        perf_mmap__write_tail(md, old);
-
+        perf_evlist__mmap_consume(rec->evlist, idx);
 out:
         return rc;
 }
@@ -161,7 +161,7 @@ try_again:
 
         if (perf_evlist__apply_filters(evlist)) {
                 error("failed to set filter with %d (%s)\n", errno,
-                        strerror(errno));
+                        strerror_r(errno, msg, sizeof(msg)));
                 rc = -1;
                 goto out;
         }
@@ -175,7 +175,8 @@ try_again:
                                "(current value: %u)\n", opts->mmap_pages);
                         rc = -errno;
                 } else {
-                        pr_err("failed to mmap with %d (%s)\n", errno, strerror(errno));
+                        pr_err("failed to mmap with %d (%s)\n", errno,
+                                strerror_r(errno, msg, sizeof(msg)));
                         rc = -errno;
                 }
                 goto out;
@@ -244,7 +245,7 @@ static int record__mmap_read_all(struct record *rec)
 
         for (i = 0; i < rec->evlist->nr_mmaps; i++) {
                 if (rec->evlist->mmap[i].base) {
-                        if (record__mmap_read(rec, &rec->evlist->mmap[i]) != 0) {
+                        if (record__mmap_read(rec, i) != 0) {
                                 rc = -1;
                                 goto out;
                         }
@@ -307,7 +308,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         struct record_opts *opts = &rec->opts;
         struct perf_data_file *file = &rec->file;
         struct perf_session *session;
-        bool disabled = false;
+        bool disabled = false, draining = false;
 
         rec->progname = argv[0];
 
@@ -456,9 +457,9 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                 }
 
                 if (hits == rec->samples) {
-                        if (done)
+                        if (done || draining)
                                 break;
-                        err = poll(rec->evlist->pollfd, rec->evlist->nr_fds, -1);
+                        err = perf_evlist__poll(rec->evlist, -1);
                         /*
                          * Propagate error, only if there's any. Ignore positive
                          * number of returned events and interrupt error.
@@ -466,6 +467,9 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                         if (err > 0 || (err < 0 && errno == EINTR))
                                 err = 0;
                         waking++;
+
+                        if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
+                                draining = true;
                 }
 
                 /*
@@ -480,7 +484,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         }
 
         if (forks && workload_exec_errno) {
-                char msg[512];
+                char msg[STRERR_BUFSIZE];
                 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
                 pr_err("Workload failed: %s\n", emsg);
                 err = -1;
@@ -620,145 +624,56 @@ error:
         return ret;
 }
 
-#ifdef HAVE_DWARF_UNWIND_SUPPORT
-static int get_stack_size(char *str, unsigned long *_size)
-{
-        char *endptr;
-        unsigned long size;
-        unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
-
-        size = strtoul(str, &endptr, 0);
-
-        do {
-                if (*endptr)
-                        break;
-
-                size = round_up(size, sizeof(u64));
-                if (!size || size > max_size)
-                        break;
-
-                *_size = size;
-                return 0;
-
-        } while (0);
-
-        pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
-               max_size, str);
-        return -1;
-}
-#endif /* HAVE_DWARF_UNWIND_SUPPORT */
-
-int record_parse_callchain(const char *arg, struct record_opts *opts)
-{
-        char *tok, *name, *saveptr = NULL;
-        char *buf;
-        int ret = -1;
-
-        /* We need buffer that we know we can write to. */
-        buf = malloc(strlen(arg) + 1);
-        if (!buf)
-                return -ENOMEM;
-
-        strcpy(buf, arg);
-
-        tok = strtok_r((char *)buf, ",", &saveptr);
-        name = tok ? : (char *)buf;
-
-        do {
-                /* Framepointer style */
-                if (!strncmp(name, "fp", sizeof("fp"))) {
-                        if (!strtok_r(NULL, ",", &saveptr)) {
-                                opts->call_graph = CALLCHAIN_FP;
-                                ret = 0;
-                        } else
-                                pr_err("callchain: No more arguments "
-                                       "needed for -g fp\n");
-                        break;
-
-#ifdef HAVE_DWARF_UNWIND_SUPPORT
-                /* Dwarf style */
-                } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
-                        const unsigned long default_stack_dump_size = 8192;
-
-                        ret = 0;
-                        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);
-                                opts->stack_dump_size = size;
-                        }
-#endif /* HAVE_DWARF_UNWIND_SUPPORT */
-                } else {
-                        pr_err("callchain: Unknown --call-graph option "
-                               "value: %s\n", arg);
-                        break;
-                }
-
-        } while (0);
-
-        free(buf);
-        return ret;
-}
-
-static void callchain_debug(struct record_opts *opts)
+static void callchain_debug(void)
 {
         static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF" };
 
-        pr_debug("callchain: type %s\n", str[opts->call_graph]);
+        pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
 
-        if (opts->call_graph == CALLCHAIN_DWARF)
+        if (callchain_param.record_mode == CALLCHAIN_DWARF)
                 pr_debug("callchain: stack dump size %d\n",
-                         opts->stack_dump_size);
+                         callchain_param.dump_size);
 }
 
-int record_parse_callchain_opt(const struct option *opt,
+int record_parse_callchain_opt(const struct option *opt __maybe_unused,
                                const char *arg,
                                int unset)
 {
-        struct record_opts *opts = opt->value;
         int ret;
 
-        opts->call_graph_enabled = !unset;
+        callchain_param.enabled = !unset;
 
         /* --no-call-graph */
         if (unset) {
-                opts->call_graph = CALLCHAIN_NONE;
+                callchain_param.record_mode = CALLCHAIN_NONE;
                 pr_debug("callchain: disabled\n");
                 return 0;
         }
 
-        ret = record_parse_callchain(arg, opts);
+        ret = parse_callchain_record_opt(arg);
         if (!ret)
-                callchain_debug(opts);
+                callchain_debug();
 
         return ret;
 }
 
-int record_callchain_opt(const struct option *opt,
+int record_callchain_opt(const struct option *opt __maybe_unused,
                          const char *arg __maybe_unused,
                          int unset __maybe_unused)
 {
-        struct record_opts *opts = opt->value;
+        callchain_param.enabled = true;
 
-        opts->call_graph_enabled = !unset;
+        if (callchain_param.record_mode == CALLCHAIN_NONE)
+                callchain_param.record_mode = CALLCHAIN_FP;
 
-        if (opts->call_graph == CALLCHAIN_NONE)
-                opts->call_graph = CALLCHAIN_FP;
-
-        callchain_debug(opts);
+        callchain_debug();
         return 0;
 }
 
 static int perf_record_config(const char *var, const char *value, void *cb)
 {
-        struct record *rec = cb;
-
         if (!strcmp(var, "record.call-graph"))
-                return record_parse_callchain(value, &rec->opts);
+                var = "call-graph.record-mode"; /* fall-through */
 
         return perf_default_config(var, value, cb);
 }
@@ -781,6 +696,7 @@ static const char * const record_usage[] = {
  */
 static struct record record = {
         .opts = {
+                .sample_time         = true,
                 .mmap_pages          = UINT_MAX,
                 .user_freq           = UINT_MAX,
                 .user_interval       = ULLONG_MAX,
@@ -907,7 +823,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
                 usage_with_options(record_usage, record_options);
         }
 
-        symbol__init();
+        symbol__init(NULL);
 
         if (symbol_conf.kptr_restrict)
                 pr_warning(
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 21d830bafff3..ac145fae0521 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -58,17 +58,19 @@ struct report {
         const char              *symbol_filter_str;
         float                   min_percent;
         u64                     nr_entries;
+        u64                     queue_size;
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 };
 
 static int report__config(const char *var, const char *value, void *cb)
 {
+        struct report *rep = cb;
+
         if (!strcmp(var, "report.group")) {
                 symbol_conf.event_group = perf_config_bool(var, value);
                 return 0;
         }
         if (!strcmp(var, "report.percent-limit")) {
-                struct report *rep = cb;
                 rep->min_percent = strtof(value, NULL);
                 return 0;
         }
@@ -76,6 +78,10 @@ static int report__config(const char *var, const char *value, void *cb)
                 symbol_conf.cumulate_callchain = perf_config_bool(var, value);
                 return 0;
         }
+        if (!strcmp(var, "report.queue-size")) {
+                rep->queue_size = perf_config_u64(var, value);
+                return 0;
+        }
 
         return perf_default_config(var, value, cb);
 }
@@ -578,7 +584,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                         .attr            = perf_event__process_attr,
                         .tracing_data    = perf_event__process_tracing_data,
                         .build_id        = perf_event__process_build_id,
-                        .ordered_samples = true,
+                        .ordered_events  = true,
                         .ordering_requires_timestamps = true,
                 },
                 .max_stack               = PERF_MAX_STACK_DEPTH,
@@ -674,6 +680,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                    "objdump binary to use for disassembly and annotations"),
         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
                     "Disable symbol demangling"),
+        OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
+                    "Enable kernel 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),
@@ -712,14 +720,19 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
 repeat:
         session = perf_session__new(&file, false, &report.tool);
         if (session == NULL)
-                return -ENOMEM;
+                return -1;
+
+        if (report.queue_size) {
+                ordered_events__set_alloc_size(&session->ordered_events,
+                                               report.queue_size);
+        }
 
         report.session = session;
 
         has_br_stack = perf_header__has_feat(&session->header,
                                              HEADER_BRANCH_STACK);
 
-        if (branch_mode == -1 && has_br_stack) {
+        if ((branch_mode == -1 && has_br_stack) || branch_mode == 1) {
                 sort__mode = SORT_MODE__BRANCH;
                 symbol_conf.cumulate_callchain = false;
         }
@@ -787,7 +800,7 @@ repeat:
                 }
         }
 
-        if (symbol__init() < 0)
+        if (symbol__init(&session->header.env) < 0)
                 goto error;
 
         if (argc) {
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index f83c08c0dd87..9c9287fbf8e9 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -428,6 +428,7 @@ static u64 get_cpu_usage_nsec_parent(void)
 static int self_open_counters(void)
 {
         struct perf_event_attr attr;
+        char sbuf[STRERR_BUFSIZE];
         int fd;
 
         memset(&attr, 0, sizeof(attr));
@@ -440,7 +441,8 @@ static int self_open_counters(void)
 
         if (fd < 0)
                 pr_err("Error: sys_perf_event_open() syscall returned "
-                       "with %d (%s)\n", fd, strerror(errno));
+                       "with %d (%s)\n", fd,
+                       strerror_r(errno, sbuf, sizeof(sbuf)));
         return fd;
 }
 
@@ -1462,6 +1464,8 @@ static int perf_sched__read_events(struct perf_sched *sched,
                 return -1;
         }
 
+        symbol__init(&session->header.env);
+
         if (perf_session__set_tracepoints_handlers(session, handlers))
                 goto out_delete;
 
@@ -1662,7 +1666,7 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
                         .comm            = perf_event__process_comm,
                         .lost            = perf_event__process_lost,
                         .fork            = perf_sched__process_fork_event,
-                        .ordered_samples = true,
+                        .ordered_events = true,
                 },
                 .cmp_pid              = LIST_HEAD_INIT(sched.cmp_pid),
                 .sort_list            = LIST_HEAD_INIT(sched.sort_list),
@@ -1747,7 +1751,6 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
         if (!strcmp(argv[0], "script"))
                 return cmd_script(argc, argv, prefix);
 
-        symbol__init();
         if (!strncmp(argv[0], "rec", 3)) {
                 return __cmd_record(argc, argv);
         } else if (!strncmp(argv[0], "lat", 3)) {
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index f57035b89c15..b9b9e58a6c39 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -184,10 +184,6 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP",
                                             PERF_OUTPUT_IP))
                         return -EINVAL;
-
-                if (!no_callchain &&
-                    !(attr->sample_type & PERF_SAMPLE_CALLCHAIN))
-                        symbol_conf.use_callchain = false;
         }
 
         if (PRINT_FIELD(ADDR) &&
@@ -290,6 +286,19 @@ static int perf_session__check_output_opt(struct perf_session *session)
                 set_print_ip_opts(&evsel->attr);
         }
 
+        if (!no_callchain) {
+                bool use_callchain = false;
+
+                evlist__for_each(session->evlist, evsel) {
+                        if (evsel->attr.sample_type & PERF_SAMPLE_CALLCHAIN) {
+                                use_callchain = true;
+                                break;
+                        }
+                }
+                if (!use_callchain)
+                        symbol_conf.use_callchain = false;
+        }
+
         /*
          * set default for tracepoints to print symbols only
          * if callchains are present
@@ -476,6 +485,11 @@ static int default_start_script(const char *script __maybe_unused,
         return 0;
 }
 
+static int default_flush_script(void)
+{
+        return 0;
+}
+
 static int default_stop_script(void)
 {
         return 0;
@@ -489,6 +503,7 @@ static int default_generate_script(struct pevent *pevent __maybe_unused,
 
 static struct scripting_ops default_scripting_ops = {
         .start_script           = default_start_script,
+        .flush_script           = default_flush_script,
         .stop_script            = default_stop_script,
         .process_event          = process_event,
         .generate_script        = default_generate_script,
@@ -504,6 +519,11 @@ static void setup_scripting(void)
         scripting_ops = &default_scripting_ops;
 }
 
+static int flush_scripting(void)
+{
+        return scripting_ops->flush_script();
+}
+
 static int cleanup_scripting(void)
 {
         pr_debug("\nperf script stopped\n");
@@ -1471,12 +1491,13 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
         bool show_full_info = false;
         bool header = false;
         bool header_only = false;
+        bool script_started = false;
         char *rec_script_path = NULL;
         char *rep_script_path = NULL;
         struct perf_session *session;
         char *script_path = NULL;
         const char **__argv;
-        int i, j, err;
+        int i, j, err = 0;
         struct perf_script script = {
                 .tool = {
                         .sample          = process_sample_event,
@@ -1488,7 +1509,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                         .attr            = process_attr,
                         .tracing_data    = perf_event__process_tracing_data,
                         .build_id        = perf_event__process_build_id,
-                        .ordered_samples = true,
+                        .ordered_events  = true,
                         .ordering_requires_timestamps = true,
                 },
         };
@@ -1718,26 +1739,28 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                 exit(-1);
         }
 
-        if (symbol__init() < 0)
-                return -1;
         if (!script_name)
                 setup_pager();
 
         session = perf_session__new(&file, false, &script.tool);
         if (session == NULL)
-                return -ENOMEM;
+                return -1;
 
         if (header || header_only) {
                 perf_session__fprintf_info(session, stdout, show_full_info);
                 if (header_only)
-                        return 0;
+                        goto out_delete;
         }
 
+        if (symbol__init(&session->header.env) < 0)
+                goto out_delete;
+
         script.session = session;
 
         if (cpu_list) {
-                if (perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap))
-                        return -1;
+                err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
+                if (err < 0)
+                        goto out_delete;
         }
 
         if (!no_callchain)
@@ -1752,53 +1775,62 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                 if (output_set_by_user()) {
                         fprintf(stderr,
                                 "custom fields not supported for generated scripts");
-                        return -1;
+                        err = -EINVAL;
+                        goto out_delete;
                 }
 
                 input = open(file.path, O_RDONLY);      /* input_name */
                 if (input < 0) {
+                        err = -errno;
                         perror("failed to open file");
-                        return -1;
+                        goto out_delete;
                 }
 
                 err = fstat(input, &perf_stat);
                 if (err < 0) {
                         perror("failed to stat file");
-                        return -1;
+                        goto out_delete;
                 }
 
                 if (!perf_stat.st_size) {
                         fprintf(stderr, "zero-sized file, nothing to do!\n");
-                        return 0;
+                        goto out_delete;
                 }
 
                 scripting_ops = script_spec__lookup(generate_script_lang);
                 if (!scripting_ops) {
                         fprintf(stderr, "invalid language specifier");
-                        return -1;
+                        err = -ENOENT;
+                        goto out_delete;
                 }
 
                 err = scripting_ops->generate_script(session->tevent.pevent,
                                                      "perf-script");
-                goto out;
+                goto out_delete;
         }
 
         if (script_name) {
                 err = scripting_ops->start_script(script_name, argc, argv);
                 if (err)
-                        goto out;
+                        goto out_delete;
                 pr_debug("perf script started with script %s\n\n", script_name);
+                script_started = true;
         }
 
 
         err = perf_session__check_output_opt(session);
         if (err < 0)
-                goto out;
+                goto out_delete;
 
         err = __cmd_script(&script);
 
+        flush_scripting();
+
+out_delete:
         perf_session__delete(session);
-        cleanup_scripting();
+
+        if (script_started)
+                cleanup_scripting();
 out:
         return err;
 }
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 3e80aa10cfd8..b22c62f80078 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -593,7 +593,7 @@ static int __run_perf_stat(int argc, const char **argv)
 
         if (perf_evlist__apply_filters(evsel_list)) {
                 error("failed to set filter with %d (%s)\n", errno,
-                        strerror(errno));
+                        strerror_r(errno, msg, sizeof(msg)));
                 return -1;
         }
 
@@ -732,7 +732,7 @@ static void aggr_printout(struct perf_evsel *evsel, int id, int nr)
         }
 }
 
-static void nsec_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
+static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
 {
         double msecs = avg / 1e6;
         const char *fmt_v, *fmt_n;
@@ -741,7 +741,7 @@ static void nsec_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
         fmt_v = csv_output ? "%.6f%s" : "%18.6f%s";
         fmt_n = csv_output ? "%s" : "%-25s";
 
-        aggr_printout(evsel, cpu, nr);
+        aggr_printout(evsel, id, nr);
 
         scnprintf(name, sizeof(name), "%s%s",
                   perf_evsel__name(evsel), csv_output ? "" : " (msec)");
@@ -947,11 +947,12 @@ static void print_ll_cache_misses(int cpu,
         fprintf(output, " of all LL-cache hits   ");
 }
 
-static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
+static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
 {
         double total, ratio = 0.0, total2;
         double sc =  evsel->scale;
         const char *fmt;
+        int cpu = cpu_map__id_to_cpu(id);
 
         if (csv_output) {
                 fmt = sc != 1.0 ?  "%.2f%s" : "%.0f%s";
@@ -962,7 +963,7 @@ static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
                         fmt = sc != 1.0 ? "%18.2f%s" : "%18.0f%s";
         }
 
-        aggr_printout(evsel, cpu, nr);
+        aggr_printout(evsel, id, nr);
 
         if (aggr_mode == AGGR_GLOBAL)
                 cpu = 0;
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index 2f1a5220c090..35b425b6293f 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -1605,7 +1605,9 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
         int ret = -EINVAL;
 
         if (session == NULL)
-                return -ENOMEM;
+                return -1;
+
+        symbol__init(&session->header.env);
 
         (void)perf_header__process_sections(&session->header,
                                             perf_data_file__fd(session->file),
@@ -1920,7 +1922,7 @@ int cmd_timechart(int argc, const char **argv,
                         .fork            = process_fork_event,
                         .exit            = process_exit_event,
                         .sample          = process_sample_event,
-                        .ordered_samples = true,
+                        .ordered_events  = true,
                 },
                 .proc_num = 15,
                 .min_time = 1000000,
@@ -1982,8 +1984,6 @@ int cmd_timechart(int argc, const char **argv,
                 return -1;
         }
 
-        symbol__init();
-
         if (argc && !strncmp(argv[0], "rec", 3)) {
                 argc = parse_options(argc, argv, record_options, record_usage,
                                      PARSE_OPT_STOP_AT_NON_OPTION);
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 377971dc89a3..fc3d55f832ac 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -59,7 +59,7 @@
 
 #include <sys/syscall.h>
 #include <sys/ioctl.h>
-#include <sys/poll.h>
+#include <poll.h>
 #include <sys/prctl.h>
 #include <sys/wait.h>
 #include <sys/uio.h>
@@ -276,11 +276,17 @@ static void perf_top__print_sym_table(struct perf_top *top)
                 return;
         }
 
+        if (top->zero) {
+                hists__delete_entries(&top->sym_evsel->hists);
+        } else {
+                hists__decay_entries(&top->sym_evsel->hists,
+                                     top->hide_user_symbols,
+                                     top->hide_kernel_symbols);
+        }
+
         hists__collapse_resort(&top->sym_evsel->hists, NULL);
         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->print_entries - printed);
         putchar('\n');
@@ -427,18 +433,13 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
 
         if (!perf_top__key_mapped(top, c)) {
                 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
-                struct termios tc, save;
+                struct termios save;
 
                 perf_top__print_mapped_keys(top);
                 fprintf(stdout, "\nEnter selection, or unmapped key to continue: ");
                 fflush(stdout);
 
-                tcgetattr(0, &save);
-                tc = save;
-                tc.c_lflag &= ~(ICANON | ECHO);
-                tc.c_cc[VMIN] = 0;
-                tc.c_cc[VTIME] = 0;
-                tcsetattr(0, TCSANOW, &tc);
+                set_term_quiet_input(&save);
 
                 poll(&stdin_poll, 1, -1);
                 c = getc(stdin);
@@ -542,11 +543,16 @@ static void perf_top__sort_new_samples(void *arg)
         if (t->evlist->selected != NULL)
                 t->sym_evsel = t->evlist->selected;
 
+        if (t->zero) {
+                hists__delete_entries(&t->sym_evsel->hists);
+        } else {
+                hists__decay_entries(&t->sym_evsel->hists,
+                                     t->hide_user_symbols,
+                                     t->hide_kernel_symbols);
+        }
+
         hists__collapse_resort(&t->sym_evsel->hists, NULL);
         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)
@@ -577,23 +583,32 @@ static void *display_thread_tui(void *arg)
         return NULL;
 }
 
+static void display_sig(int sig __maybe_unused)
+{
+        done = 1;
+}
+
+static void display_setup_sig(void)
+{
+        signal(SIGSEGV, display_sig);
+        signal(SIGFPE,  display_sig);
+        signal(SIGINT,  display_sig);
+        signal(SIGQUIT, display_sig);
+        signal(SIGTERM, display_sig);
+}
+
 static void *display_thread(void *arg)
 {
         struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
-        struct termios tc, save;
+        struct termios save;
         struct perf_top *top = arg;
         int delay_msecs, c;
 
-        tcgetattr(0, &save);
-        tc = save;
-        tc.c_lflag &= ~(ICANON | ECHO);
-        tc.c_cc[VMIN] = 0;
-        tc.c_cc[VTIME] = 0;
-
+        display_setup_sig();
         pthread__unblock_sigwinch();
 repeat:
         delay_msecs = top->delay_secs * 1000;
-        tcsetattr(0, TCSANOW, &tc);
+        set_term_quiet_input(&save);
         /* trash return*/
         getc(stdin);
 
@@ -620,13 +635,16 @@ repeat:
                 }
         }
 
+        tcsetattr(0, TCSAFLUSH, &save);
         return NULL;
 }
 
-static int symbol_filter(struct map *map __maybe_unused, struct symbol *sym)
+static int symbol_filter(struct map *map, struct symbol *sym)
 {
         const char *name = sym->name;
 
+        if (!map->dso->kernel)
+                return 0;
         /*
          * ppc64 uses function descriptors and appends a '.' to the
          * start of every instruction address. Remove it.
@@ -876,7 +894,7 @@ try_again:
 
         if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
                 ui__error("Failed to mmap with %d (%s)\n",
-                            errno, strerror(errno));
+                            errno, strerror_r(errno, msg, sizeof(msg)));
                 goto out_err;
         }
 
@@ -911,7 +929,7 @@ static int __cmd_top(struct perf_top *top)
 
         top->session = perf_session__new(NULL, false, NULL);
         if (top->session == NULL)
-                return -ENOMEM;
+                return -1;
 
         machines__set_symbol_filter(&top->session->machines, symbol_filter);
 
@@ -946,7 +964,7 @@ static int __cmd_top(struct perf_top *top)
                 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_evlist__poll(top->evlist, 100);
 
         perf_top__mmap_read(top);
 
@@ -963,7 +981,7 @@ 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");
-                        goto out_delete;
+                        goto out_join;
                 }
         }
 
@@ -973,10 +991,12 @@ static int __cmd_top(struct perf_top *top)
                 perf_top__mmap_read(top);
 
                 if (hits == top->samples)
-                        ret = poll(top->evlist->pollfd, top->evlist->nr_fds, 100);
+                        ret = perf_evlist__poll(top->evlist, 100);
         }
 
         ret = 0;
+out_join:
+        pthread_join(thread, NULL);
 out_delete:
         perf_session__delete(top->session);
         top->session = NULL;
@@ -1000,10 +1020,8 @@ parse_callchain_opt(const struct option *opt, const char *arg, int unset)
 
 static int perf_top_config(const char *var, const char *value, void *cb)
 {
-        struct perf_top *top = cb;
-
         if (!strcmp(var, "top.call-graph"))
-                return record_parse_callchain(value, &top->record_opts);
+                var = "call-graph.record-mode"; /* fall-through */
         if (!strcmp(var, "top.children")) {
                 symbol_conf.cumulate_callchain = perf_config_bool(var, value);
                 return 0;
@@ -1122,6 +1140,8 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Interleave source code with assembly code (default)"),
         OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
                     "Display raw encoding of assembly instructions (default)"),
+        OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
+                    "Enable kernel symbol demangling"),
         OPT_STRING(0, "objdump", &objdump_path, "path",
                     "objdump binary to use for disassembly and annotations"),
         OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
@@ -1131,6 +1151,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                      "Don't show entries under that percent", parse_percent_limit),
         OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
                      "How to display percentage of filtered entries", parse_filter_percentage),
+        OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
+                   "width[,width...]",
+                   "don't try to adjust column width, use these fixed values"),
         OPT_END()
         };
         const char * const top_usage[] = {
@@ -1217,7 +1240,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         symbol_conf.priv_size = sizeof(struct annotation);
 
         symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
-        if (symbol__init() < 0)
+        if (symbol__init(NULL) < 0)
                 return -1;
 
         sort__setup_elide(stdout);
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index a6c375224f46..09bcf2393910 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -402,6 +402,31 @@ static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
 
 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
 
+static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
+                                                  struct syscall_arg *arg)
+{
+        int printed = 0, flags = arg->val;
+
+#define P_MREMAP_FLAG(n) \
+        if (flags & MREMAP_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                flags &= ~MREMAP_##n; \
+        }
+
+        P_MREMAP_FLAG(MAYMOVE);
+#ifdef MREMAP_FIXED
+        P_MREMAP_FLAG(FIXED);
+#endif
+#undef P_MREMAP_FLAG
+
+        if (flags)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
+
+        return printed;
+}
+
+#define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
+
 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
                                                       struct syscall_arg *arg)
 {
@@ -1004,6 +1029,7 @@ static struct syscall_fmt {
                              [2] = SCA_MMAP_PROT, /* prot */ }, },
         { .name     = "mremap",     .hexret = true,
           .arg_scnprintf = { [0] = SCA_HEX, /* addr */
+                             [3] = SCA_MREMAP_FLAGS, /* flags */
                              [4] = SCA_HEX, /* new_addr */ }, },
         { .name     = "munlock",    .errmsg = true,
           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
@@ -1385,7 +1411,7 @@ static int trace__tool_process(struct perf_tool *tool,
 
 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
 {
-        int err = symbol__init();
+        int err = symbol__init(NULL);
 
         if (err)
                 return err;
@@ -1669,7 +1695,7 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
                            union perf_event *event __maybe_unused,
                            struct perf_sample *sample)
 {
-        int ret;
+        long ret;
         u64 duration = 0;
         struct thread *thread;
         int id = perf_evsel__sc_tp_uint(evsel, id, sample);
@@ -1722,9 +1748,9 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
 
         if (sc->fmt == NULL) {
 signed_print:
-                fprintf(trace->output, ") = %d", ret);
+                fprintf(trace->output, ") = %ld", ret);
         } else if (ret < 0 && sc->fmt->errmsg) {
-                char bf[256];
+                char bf[STRERR_BUFSIZE];
                 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
                            *e = audit_errno_to_name(-ret);
 
@@ -1732,7 +1758,7 @@ signed_print:
         } else if (ret == 0 && sc->fmt->timeout)
                 fprintf(trace->output, ") = 0 Timeout");
         else if (sc->fmt->hexret)
-                fprintf(trace->output, ") = %#x", ret);
+                fprintf(trace->output, ") = %#lx", ret);
         else
                 goto signed_print;
 
@@ -2018,6 +2044,8 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
         int err = -1, i;
         unsigned long before;
         const bool forks = argc > 0;
+        bool draining = false;
+        char sbuf[STRERR_BUFSIZE];
 
         trace->live = true;
 
@@ -2079,7 +2107,8 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
 
         err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
         if (err < 0) {
-                fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
+                fprintf(trace->output, "Couldn't mmap the events: %s\n",
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -2143,8 +2172,12 @@ next_event:
         if (trace->nr_events == before) {
                 int timeout = done ? 100 : -1;
 
-                if (poll(evlist->pollfd, evlist->nr_fds, timeout) > 0)
+                if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
+                        if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
+                                draining = true;
+
                         goto again;
+                }
         } else {
                 goto again;
         }
@@ -2209,18 +2242,18 @@ static int trace__replay(struct trace *trace)
         trace->tool.tracing_data = perf_event__process_tracing_data;
         trace->tool.build_id      = perf_event__process_build_id;
 
-        trace->tool.ordered_samples = true;
+        trace->tool.ordered_events = true;
         trace->tool.ordering_requires_timestamps = true;
 
         /* add tid to output */
         trace->multiple_threads = true;
 
-        if (symbol__init() < 0)
-                return -1;
-
         session = perf_session__new(&file, false, &trace->tool);
         if (session == NULL)
-                return -ENOMEM;
+                return -1;
+
+        if (symbol__init(&session->header.env) < 0)
+                goto out;
 
         trace->host = &session->machines.host;
 
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index 1f67aa02d240..58f609198c6d 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -48,10 +48,6 @@ ifneq ($(ARCH),$(filter $(ARCH),x86 arm))
   NO_LIBDW_DWARF_UNWIND := 1
 endif
 
-ifeq ($(ARCH),powerpc)
-  CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX
-endif
-
 ifeq ($(LIBUNWIND_LIBS),)
   NO_LIBUNWIND := 1
 else
@@ -120,6 +116,29 @@ ifdef PARSER_DEBUG
   CFLAGS             += -DPARSER_DEBUG
 endif
 
+ifndef NO_LIBPYTHON
+  # Try different combinations to accommodate systems that only have
+  # python[2][-config] in weird combinations but always preferring
+  # python2 and python2-config as per pep-0394. If we catch a
+  # python[-config] in version 3, the version check will kill it.
+  PYTHON2 := $(if $(call get-executable,python2),python2,python)
+  override PYTHON := $(call get-executable-or-default,PYTHON,$(PYTHON2))
+  PYTHON2_CONFIG := \
+    $(if $(call get-executable,$(PYTHON)-config),$(PYTHON)-config,python-config)
+  override PYTHON_CONFIG := \
+    $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON2_CONFIG))
+
+  PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
+
+  PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
+  PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
+
+  FEATURE_CHECK_CFLAGS-libpython := $(PYTHON_EMBED_CCOPTS)
+  FEATURE_CHECK_LDFLAGS-libpython := $(PYTHON_EMBED_LDOPTS)
+  FEATURE_CHECK_CFLAGS-libpython-version := $(PYTHON_EMBED_CCOPTS)
+  FEATURE_CHECK_LDFLAGS-libpython-version := $(PYTHON_EMBED_LDOPTS)
+endif
+
 CFLAGS += -fno-omit-frame-pointer
 CFLAGS += -ggdb3
 CFLAGS += -funwind-tables
@@ -355,6 +374,12 @@ ifndef NO_LIBELF
   endif # NO_DWARF
 endif # NO_LIBELF
 
+ifeq ($(ARCH),powerpc)
+  ifndef NO_DWARF
+    CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX
+  endif
+endif
+
 ifndef NO_LIBUNWIND
   ifneq ($(feature-libunwind), 1)
     msg := $(warning No libunwind found. Please install libunwind-dev[el] >= 1.1 and/or set LIBUNWIND_DIR);
@@ -482,21 +507,14 @@ define disable-python_code
   NO_LIBPYTHON := 1
 endef
 
-override PYTHON := \
-  $(call get-executable-or-default,PYTHON,python)
-
-ifndef PYTHON
-  $(call disable-python,python interpreter)
+ifdef NO_LIBPYTHON
+  $(call disable-python)
 else
 
-  PYTHON_WORD := $(call shell-wordify,$(PYTHON))
-
-  ifdef NO_LIBPYTHON
-    $(call disable-python)
+  ifndef PYTHON
+    $(call disable-python,python interpreter)
   else
-
-    override PYTHON_CONFIG := \
-      $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
+    PYTHON_WORD := $(call shell-wordify,$(PYTHON))
 
     ifndef PYTHON_CONFIG
       $(call disable-python,python-config tool)
@@ -635,11 +653,13 @@ else
 sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
+ifndef lib
 ifeq ($(IS_X86_64),1)
 lib = lib64
 else
 lib = lib
 endif
+endif # lib
 libdir = $(prefix)/$(lib)
 
 # Shell quote (do not use $(call) to accommodate ancient setups);
diff --git a/tools/perf/config/feature-checks/Makefile b/tools/perf/config/feature-checks/Makefile
index 6088f8d8a434..72ab2984718e 100644
--- a/tools/perf/config/feature-checks/Makefile
+++ b/tools/perf/config/feature-checks/Makefile
@@ -101,25 +101,11 @@ FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
 test-libperl.bin:
         $(BUILD) $(FLAGS_PERL_EMBED)
 
-override PYTHON := python
-override PYTHON_CONFIG := python-config
-
-escape-for-shell-sq =  $(subst ','\'',$(1))
-shell-sq = '$(escape-for-shell-sq)'
-
-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)
-
 test-libpython.bin:
-        $(BUILD) $(FLAGS_PYTHON_EMBED)
+        $(BUILD)
 
 test-libpython-version.bin:
-        $(BUILD) $(FLAGS_PYTHON_EMBED)
+        $(BUILD)
 
 test-libbfd.bin:
         $(BUILD) -DPACKAGE='"perf"' -lbfd -lz -liberty -ldl
diff --git a/tools/perf/config/utilities.mak b/tools/perf/config/utilities.mak
index 4d985e0f03f5..7076a62d0ff7 100644
--- a/tools/perf/config/utilities.mak
+++ b/tools/perf/config/utilities.mak
@@ -132,7 +132,7 @@ endef
 #
 # Usage: bool-value = $(call is-absolute,path)
 #
-is-absolute = $(shell echo $(shell-sq) | grep ^/ -q && echo y)
+is-absolute = $(shell echo $(shell-sq) | grep -q ^/ && echo y)
 
 # lookup
 #
diff --git a/tools/perf/perf-with-kcore.sh b/tools/perf/perf-with-kcore.sh
new file mode 100644
index 000000000000..c7ff90a90e4e
--- /dev/null
+++ b/tools/perf/perf-with-kcore.sh
@@ -0,0 +1,259 @@
+#!/bin/bash
+# perf-with-kcore: use perf with a copy of kcore
+# Copyright (c) 2014, Intel Corporation.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+set -e
+
+usage()
+{
+        echo "Usage: perf-with-kcore <perf sub-command> <perf.data directory> [<sub-command options> [ -- <workload>]]" >&2
+        echo "       <perf sub-command> can be record, script, report or inject" >&2
+        echo "   or: perf-with-kcore fix_buildid_cache_permissions" >&2
+        exit 1
+}
+
+find_perf()
+{
+        if [ -n "$PERF" ] ; then
+                return
+        fi
+        PERF=`which perf || true`
+        if [ -z "$PERF" ] ; then
+                echo "Failed to find perf" >&2
+                exit 1
+        fi
+        if [ ! -x "$PERF" ] ; then
+                echo "Failed to find perf" >&2
+                exit 1
+        fi
+        echo "Using $PERF"
+        "$PERF" version
+}
+
+copy_kcore()
+{
+        echo "Copying kcore"
+
+        if [ $EUID -eq 0 ] ; then
+                SUDO=""
+        else
+                SUDO="sudo"
+        fi
+
+        rm -f perf.data.junk
+        ("$PERF" record -o perf.data.junk $PERF_OPTIONS -- sleep 60) >/dev/null 2>/dev/null &
+        PERF_PID=$!
+
+        # Need to make sure that perf has started
+        sleep 1
+
+        KCORE=$(($SUDO "$PERF" buildid-cache -v -f -k /proc/kcore >/dev/null) 2>&1)
+        case "$KCORE" in
+        "kcore added to build-id cache directory "*)
+                KCORE_DIR=${KCORE#"kcore added to build-id cache directory "}
+        ;;
+        *)
+                kill $PERF_PID
+                wait >/dev/null 2>/dev/null || true
+                rm perf.data.junk
+                echo "$KCORE"
+                echo "Failed to find kcore" >&2
+                exit 1
+        ;;
+        esac
+
+        kill $PERF_PID
+        wait >/dev/null 2>/dev/null || true
+        rm perf.data.junk
+
+        $SUDO cp -a "$KCORE_DIR" "$(pwd)/$PERF_DATA_DIR"
+        $SUDO rm -f "$KCORE_DIR/kcore"
+        $SUDO rm -f "$KCORE_DIR/kallsyms"
+        $SUDO rm -f "$KCORE_DIR/modules"
+        $SUDO rmdir "$KCORE_DIR"
+
+        KCORE_DIR_BASENAME=$(basename "$KCORE_DIR")
+        KCORE_DIR="$(pwd)/$PERF_DATA_DIR/$KCORE_DIR_BASENAME"
+
+        $SUDO chown $UID "$KCORE_DIR"
+        $SUDO chown $UID "$KCORE_DIR/kcore"
+        $SUDO chown $UID "$KCORE_DIR/kallsyms"
+        $SUDO chown $UID "$KCORE_DIR/modules"
+
+        $SUDO chgrp $GROUPS "$KCORE_DIR"
+        $SUDO chgrp $GROUPS "$KCORE_DIR/kcore"
+        $SUDO chgrp $GROUPS "$KCORE_DIR/kallsyms"
+        $SUDO chgrp $GROUPS "$KCORE_DIR/modules"
+
+        ln -s "$KCORE_DIR_BASENAME" "$PERF_DATA_DIR/kcore_dir"
+}
+
+fix_buildid_cache_permissions()
+{
+        if [ $EUID -ne 0 ] ; then
+                echo "This script must be run as root via sudo " >&2
+                exit 1
+        fi
+
+        if [ -z "$SUDO_USER" ] ; then
+                echo "This script must be run via sudo" >&2
+                exit 1
+        fi
+
+        USER_HOME=$(bash <<< "echo ~$SUDO_USER")
+
+        if [ "$HOME" != "$USER_HOME" ] ; then
+                echo "Fix unnecessary because root has a home: $HOME" >&2
+                exit 1
+        fi
+
+        echo "Fixing buildid cache permissions"
+
+        find "$USER_HOME/.debug" -xdev -type d          ! -user "$SUDO_USER" -ls -exec chown    "$SUDO_USER" \{\} \;
+        find "$USER_HOME/.debug" -xdev -type f -links 1 ! -user "$SUDO_USER" -ls -exec chown    "$SUDO_USER" \{\} \;
+        find "$USER_HOME/.debug" -xdev -type l          ! -user "$SUDO_USER" -ls -exec chown -h "$SUDO_USER" \{\} \;
+
+        if [ -n "$SUDO_GID" ] ; then
+                find "$USER_HOME/.debug" -xdev -type d          ! -group "$SUDO_GID" -ls -exec chgrp    "$SUDO_GID" \{\} \;
+                find "$USER_HOME/.debug" -xdev -type f -links 1 ! -group "$SUDO_GID" -ls -exec chgrp    "$SUDO_GID" \{\} \;
+                find "$USER_HOME/.debug" -xdev -type l          ! -group "$SUDO_GID" -ls -exec chgrp -h "$SUDO_GID" \{\} \;
+        fi
+
+        echo "Done"
+}
+
+check_buildid_cache_permissions()
+{
+        if [ $EUID -eq 0 ] ; then
+                return
+        fi
+
+        PERMISSIONS_OK+=$(find "$HOME/.debug" -xdev -type d          ! -user "$USER" -print -quit)
+        PERMISSIONS_OK+=$(find "$HOME/.debug" -xdev -type f -links 1 ! -user "$USER" -print -quit)
+        PERMISSIONS_OK+=$(find "$HOME/.debug" -xdev -type l          ! -user "$USER" -print -quit)
+
+        PERMISSIONS_OK+=$(find "$HOME/.debug" -xdev -type d          ! -group "$GROUPS" -print -quit)
+        PERMISSIONS_OK+=$(find "$HOME/.debug" -xdev -type f -links 1 ! -group "$GROUPS" -print -quit)
+        PERMISSIONS_OK+=$(find "$HOME/.debug" -xdev -type l          ! -group "$GROUPS" -print -quit)
+
+        if [ -n "$PERMISSIONS_OK" ] ; then
+                echo "*** WARNING *** buildid cache permissions may need fixing" >&2
+        fi
+}
+
+record()
+{
+        echo "Recording"
+
+        if [ $EUID -ne 0 ] ; then
+
+                if [ "$(cat /proc/sys/kernel/kptr_restrict)" -ne 0 ] ; then
+                        echo "*** WARNING *** /proc/sys/kernel/kptr_restrict prevents access to kernel addresses" >&2
+                fi
+
+                if echo "$PERF_OPTIONS" | grep -q ' -a \|^-a \| -a$\|^-a$\| --all-cpus \|^--all-cpus \| --all-cpus$\|^--all-cpus$' ; then
+                        echo "*** WARNING *** system-wide tracing without root access will not be able to read all necessary information from /proc" >&2
+                fi
+
+                if echo "$PERF_OPTIONS" | grep -q 'intel_pt\|intel_bts\| -I\|^-I' ; then
+                        if [ "$(cat /proc/sys/kernel/perf_event_paranoid)" -gt -1 ] ; then
+                                echo "*** WARNING *** /proc/sys/kernel/perf_event_paranoid restricts buffer size and tracepoint (sched_switch) use" >&2
+                        fi
+
+                        if echo "$PERF_OPTIONS" | grep -q ' --per-thread \|^--per-thread \| --per-thread$\|^--per-thread$' ; then
+                                true
+                        elif echo "$PERF_OPTIONS" | grep -q ' -t \|^-t \| -t$\|^-t$' ; then
+                                true
+                        elif [ ! -r /sys/kernel/debug -o ! -x /sys/kernel/debug ] ; then
+                                echo "*** WARNING *** /sys/kernel/debug permissions prevent tracepoint (sched_switch) use" >&2
+                        fi
+                fi
+        fi
+
+        if [ -z "$1" ] ; then
+                echo "Workload is required for recording" >&2
+                usage
+        fi
+
+        if [ -e "$PERF_DATA_DIR" ] ; then
+                echo "'$PERF_DATA_DIR' exists" >&2
+                exit 1
+        fi
+
+        find_perf
+
+        mkdir "$PERF_DATA_DIR"
+
+        echo "$PERF record -o $PERF_DATA_DIR/perf.data $PERF_OPTIONS -- $*"
+        "$PERF" record -o "$PERF_DATA_DIR/perf.data" $PERF_OPTIONS -- $* || true
+
+        if rmdir "$PERF_DATA_DIR" > /dev/null 2>/dev/null ; then
+                exit 1
+        fi
+
+        copy_kcore
+
+        echo "Done"
+}
+
+subcommand()
+{
+        find_perf
+        check_buildid_cache_permissions
+        echo "$PERF $PERF_SUB_COMMAND -i $PERF_DATA_DIR/perf.data --kallsyms=$PERF_DATA_DIR/kcore_dir/kallsyms $*"
+        "$PERF" $PERF_SUB_COMMAND -i "$PERF_DATA_DIR/perf.data" "--kallsyms=$PERF_DATA_DIR/kcore_dir/kallsyms" $*
+}
+
+if [ "$1" = "fix_buildid_cache_permissions" ] ; then
+        fix_buildid_cache_permissions
+        exit 0
+fi
+
+PERF_SUB_COMMAND=$1
+PERF_DATA_DIR=$2
+shift || true
+shift || true
+
+if [ -z "$PERF_SUB_COMMAND" ] ; then
+        usage
+fi
+
+if [ -z "$PERF_DATA_DIR" ] ; then
+        usage
+fi
+
+case "$PERF_SUB_COMMAND" in
+"record")
+        while [ "$1" != "--" ] ; do
+                PERF_OPTIONS+="$1 "
+                shift || break
+        done
+        if [ "$1" != "--" ] ; then
+                echo "Options and workload are required for recording" >&2
+                usage
+        fi
+        shift
+        record $*
+;;
+"script")
+        subcommand $*
+;;
+"report")
+        subcommand $*
+;;
+"inject")
+        subcommand $*
+;;
+*)
+        usage
+;;
+esac
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 2282d41879a2..452a8474d29d 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -313,6 +313,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         int status;
         struct stat st;
         const char *prefix;
+        char sbuf[STRERR_BUFSIZE];
 
         prefix = NULL;
         if (p->option & RUN_SETUP)
@@ -343,7 +344,8 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         status = 1;
         /* Check for ENOSPC and EIO errors.. */
         if (fflush(stdout)) {
-                fprintf(stderr, "write failure on standard output: %s", strerror(errno));
+                fprintf(stderr, "write failure on standard output: %s",
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out;
         }
         if (ferror(stdout)) {
@@ -351,7 +353,8 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
                 goto out;
         }
         if (fclose(stdout)) {
-                fprintf(stderr, "close failed on standard output: %s", strerror(errno));
+                fprintf(stderr, "close failed on standard output: %s",
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out;
         }
         status = 0;
@@ -466,6 +469,7 @@ void pthread__unblock_sigwinch(void)
 int main(int argc, const char **argv)
 {
         const char *cmd;
+        char sbuf[STRERR_BUFSIZE];
 
         /* The page_size is placed in util object. */
         page_size = sysconf(_SC_PAGE_SIZE);
@@ -561,7 +565,7 @@ int main(int argc, const char **argv)
         }
 
         fprintf(stderr, "Failed to run command '%s': %s\n",
-                cmd, strerror(errno));
+                cmd, strerror_r(errno, sbuf, sizeof(sbuf)));
 out:
         return 1;
 }
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 510c65f72858..220d44e44c1b 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -41,8 +41,6 @@ void pthread__unblock_sigwinch(void);
 
 struct record_opts {
         struct target target;
-        int          call_graph;
-        bool         call_graph_enabled;
         bool         group;
         bool         inherit_stat;
         bool         no_buffering;
@@ -60,7 +58,6 @@ struct record_opts {
         u64          branch_stack;
         u64          default_interval;
         u64          user_interval;
-        u16          stack_dump_size;
         bool         sample_transaction;
         unsigned     initial_delay;
 };
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 6f8b01bc6033..ac655b0700e7 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -154,6 +154,18 @@ static struct test {
                 .func = test__hists_cumulate,
         },
         {
+                .desc = "Test tracking with sched_switch",
+                .func = test__switch_tracking,
+        },
+        {
+                .desc = "Filter fds with revents mask in a fdarray",
+                .func = test__fdarray__filter,
+        },
+        {
+                .desc = "Add fd to a fdarray, making it autogrow",
+                .func = test__fdarray__add,
+        },
+        {
                 .func = NULL,
         },
 };
@@ -185,9 +197,11 @@ static bool perf_test__matches(int curr, int argc, const char *argv[])
 static int run_test(struct test *test)
 {
         int status, err = -1, child = fork();
+        char sbuf[STRERR_BUFSIZE];
 
         if (child < 0) {
-                pr_err("failed to fork test: %s\n", strerror(errno));
+                pr_err("failed to fork test: %s\n",
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
                 return -1;
         }
 
@@ -297,7 +311,7 @@ int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
         symbol_conf.sort_by_name = true;
         symbol_conf.try_vmlinux_path = true;
 
-        if (symbol__init() < 0)
+        if (symbol__init(NULL) < 0)
                 return -1;
 
         if (skip != NULL)
diff --git a/tools/perf/tests/fdarray.c b/tools/perf/tests/fdarray.c
new file mode 100644
index 000000000000..d24b837951d4
--- /dev/null
+++ b/tools/perf/tests/fdarray.c
@@ -0,0 +1,174 @@
+#include <api/fd/array.h>
+#include "util/debug.h"
+#include "tests/tests.h"
+
+static void fdarray__init_revents(struct fdarray *fda, short revents)
+{
+        int fd;
+
+        fda->nr = fda->nr_alloc;
+
+        for (fd = 0; fd < fda->nr; ++fd) {
+                fda->entries[fd].fd      = fda->nr - fd;
+                fda->entries[fd].revents = revents;
+        }
+}
+
+static int fdarray__fprintf_prefix(struct fdarray *fda, const char *prefix, FILE *fp)
+{
+        int printed = 0;
+
+        if (!verbose)
+                return 0;
+
+        printed += fprintf(fp, "\n%s: ", prefix);
+        return printed + fdarray__fprintf(fda, fp);
+}
+
+int test__fdarray__filter(void)
+{
+        int nr_fds, expected_fd[2], fd, err = TEST_FAIL;
+        struct fdarray *fda = fdarray__new(5, 5);
+
+        if (fda == NULL) {
+                pr_debug("\nfdarray__new() failed!");
+                goto out;
+        }
+
+        fdarray__init_revents(fda, POLLIN);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        if (nr_fds != fda->nr_alloc) {
+                pr_debug("\nfdarray__filter()=%d != %d shouldn't have filtered anything",
+                         nr_fds, fda->nr_alloc);
+                goto out_delete;
+        }
+
+        fdarray__init_revents(fda, POLLHUP);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        if (nr_fds != 0) {
+                pr_debug("\nfdarray__filter()=%d != %d, should have filtered all fds",
+                         nr_fds, fda->nr_alloc);
+                goto out_delete;
+        }
+
+        fdarray__init_revents(fda, POLLHUP);
+        fda->entries[2].revents = POLLIN;
+        expected_fd[0] = fda->entries[2].fd;
+
+        pr_debug("\nfiltering all but fda->entries[2]:");
+        fdarray__fprintf_prefix(fda, "before", stderr);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        fdarray__fprintf_prefix(fda, " after", stderr);
+        if (nr_fds != 1) {
+                pr_debug("\nfdarray__filter()=%d != 1, should have left just one event", nr_fds);
+                goto out_delete;
+        }
+
+        if (fda->entries[0].fd != expected_fd[0]) {
+                pr_debug("\nfda->entries[0].fd=%d != %d\n",
+                         fda->entries[0].fd, expected_fd[0]);
+                goto out_delete;
+        }
+
+        fdarray__init_revents(fda, POLLHUP);
+        fda->entries[0].revents = POLLIN;
+        expected_fd[0] = fda->entries[0].fd;
+        fda->entries[3].revents = POLLIN;
+        expected_fd[1] = fda->entries[3].fd;
+
+        pr_debug("\nfiltering all but (fda->entries[0], fda->entries[3]):");
+        fdarray__fprintf_prefix(fda, "before", stderr);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        fdarray__fprintf_prefix(fda, " after", stderr);
+        if (nr_fds != 2) {
+                pr_debug("\nfdarray__filter()=%d != 2, should have left just two events",
+                         nr_fds);
+                goto out_delete;
+        }
+
+        for (fd = 0; fd < 2; ++fd) {
+                if (fda->entries[fd].fd != expected_fd[fd]) {
+                        pr_debug("\nfda->entries[%d].fd=%d != %d\n", fd,
+                                 fda->entries[fd].fd, expected_fd[fd]);
+                        goto out_delete;
+                }
+        }
+
+        pr_debug("\n");
+
+        err = 0;
+out_delete:
+        fdarray__delete(fda);
+out:
+        return err;
+}
+
+int test__fdarray__add(void)
+{
+        int err = TEST_FAIL;
+        struct fdarray *fda = fdarray__new(2, 2);
+
+        if (fda == NULL) {
+                pr_debug("\nfdarray__new() failed!");
+                goto out;
+        }
+
+#define FDA_CHECK(_idx, _fd, _revents)                                     \
+        if (fda->entries[_idx].fd != _fd) {                                \
+                pr_debug("\n%d: fda->entries[%d](%d) != %d!",              \
+                         __LINE__, _idx, fda->entries[1].fd, _fd);         \
+                goto out_delete;                                           \
+        }                                                                  \
+        if (fda->entries[_idx].events != (_revents)) {                     \
+                pr_debug("\n%d: fda->entries[%d].revents(%d) != %d!",      \
+                         __LINE__, _idx, fda->entries[_idx].fd, _revents); \
+                goto out_delete;                                           \
+        }
+
+#define FDA_ADD(_idx, _fd, _revents, _nr)                                  \
+        if (fdarray__add(fda, _fd, _revents) < 0) {                        \
+                pr_debug("\n%d: fdarray__add(fda, %d, %d) failed!",        \
+                         __LINE__,_fd, _revents);                          \
+                goto out_delete;                                           \
+        }                                                                  \
+        if (fda->nr != _nr) {                                              \
+                pr_debug("\n%d: fdarray__add(fda, %d, %d)=%d != %d",       \
+                         __LINE__,_fd, _revents, fda->nr, _nr);            \
+                goto out_delete;                                           \
+        }                                                                  \
+        FDA_CHECK(_idx, _fd, _revents)
+
+        FDA_ADD(0, 1, POLLIN, 1);
+        FDA_ADD(1, 2, POLLERR, 2);
+
+        fdarray__fprintf_prefix(fda, "before growing array", stderr);
+
+        FDA_ADD(2, 35, POLLHUP, 3);
+
+        if (fda->entries == NULL) {
+                pr_debug("\nfdarray__add(fda, 35, POLLHUP) should have allocated fda->pollfd!");
+                goto out_delete;
+        }
+
+        fdarray__fprintf_prefix(fda, "after 3rd add", stderr);
+
+        FDA_ADD(3, 88, POLLIN | POLLOUT, 4);
+
+        fdarray__fprintf_prefix(fda, "after 4th add", stderr);
+
+        FDA_CHECK(0, 1, POLLIN);
+        FDA_CHECK(1, 2, POLLERR);
+        FDA_CHECK(2, 35, POLLHUP);
+        FDA_CHECK(3, 88, POLLIN | POLLOUT);
+
+#undef FDA_ADD
+#undef FDA_CHECK
+
+        pr_debug("\n");
+
+        err = 0;
+out_delete:
+        fdarray__delete(fda);
+out:
+        return err;
+}
diff --git a/tools/perf/tests/mmap-basic.c b/tools/perf/tests/mmap-basic.c
index 142263492f6f..9b9622a33932 100644
--- a/tools/perf/tests/mmap-basic.c
+++ b/tools/perf/tests/mmap-basic.c
@@ -31,6 +31,7 @@ int test__basic_mmap(void)
         unsigned int nr_events[nsyscalls],
                      expected_nr_events[nsyscalls], i, j;
         struct perf_evsel *evsels[nsyscalls], *evsel;
+        char sbuf[STRERR_BUFSIZE];
 
         threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
@@ -49,7 +50,7 @@ int test__basic_mmap(void)
         sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
         if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
                 pr_debug("sched_setaffinity() failed on CPU %d: %s ",
-                         cpus->map[0], strerror(errno));
+                         cpus->map[0], strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_free_cpus;
         }
 
@@ -79,7 +80,7 @@ int test__basic_mmap(void)
                 if (perf_evsel__open(evsels[i], cpus, threads) < 0) {
                         pr_debug("failed to open counter: %s, "
                                  "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                                 strerror(errno));
+                                 strerror_r(errno, sbuf, sizeof(sbuf)));
                         goto out_delete_evlist;
                 }
 
@@ -89,7 +90,7 @@ int test__basic_mmap(void)
 
         if (perf_evlist__mmap(evlist, 128, true) < 0) {
                 pr_debug("failed to mmap events: %d (%s)\n", errno,
-                         strerror(errno));
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/open-syscall-all-cpus.c b/tools/perf/tests/open-syscall-all-cpus.c
index 5fecdbd2f5f7..8fa82d1700c7 100644
--- a/tools/perf/tests/open-syscall-all-cpus.c
+++ b/tools/perf/tests/open-syscall-all-cpus.c
@@ -12,6 +12,7 @@ int test__open_syscall_event_on_all_cpus(void)
         unsigned int nr_open_calls = 111, i;
         cpu_set_t cpu_set;
         struct thread_map *threads = thread_map__new(-1, getpid(), UINT_MAX);
+        char sbuf[STRERR_BUFSIZE];
 
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
@@ -35,7 +36,7 @@ int test__open_syscall_event_on_all_cpus(void)
         if (perf_evsel__open(evsel, cpus, threads) < 0) {
                 pr_debug("failed to open counter: %s, "
                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                         strerror(errno));
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_evsel_delete;
         }
 
@@ -56,7 +57,7 @@ int test__open_syscall_event_on_all_cpus(void)
                 if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
                         pr_debug("sched_setaffinity() failed on CPU %d: %s ",
                                  cpus->map[cpu],
-                                 strerror(errno));
+                                 strerror_r(errno, sbuf, sizeof(sbuf)));
                         goto out_close_fd;
                 }
                 for (i = 0; i < ncalls; ++i) {
diff --git a/tools/perf/tests/open-syscall-tp-fields.c b/tools/perf/tests/open-syscall-tp-fields.c
index 0785b64ffd6c..127dcae0b760 100644
--- a/tools/perf/tests/open-syscall-tp-fields.c
+++ b/tools/perf/tests/open-syscall-tp-fields.c
@@ -22,6 +22,7 @@ int test__syscall_open_tp_fields(void)
         struct perf_evlist *evlist = perf_evlist__new();
         struct perf_evsel *evsel;
         int err = -1, i, nr_events = 0, nr_polls = 0;
+        char sbuf[STRERR_BUFSIZE];
 
         if (evlist == NULL) {
                 pr_debug("%s: perf_evlist__new\n", __func__);
@@ -48,13 +49,15 @@ int test__syscall_open_tp_fields(void)
 
         err = perf_evlist__open(evlist);
         if (err < 0) {
-                pr_debug("perf_evlist__open: %s\n", strerror(errno));
+                pr_debug("perf_evlist__open: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
         err = perf_evlist__mmap(evlist, UINT_MAX, false);
         if (err < 0) {
-                pr_debug("perf_evlist__mmap: %s\n", strerror(errno));
+                pr_debug("perf_evlist__mmap: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -102,7 +105,7 @@ int test__syscall_open_tp_fields(void)
                 }
 
                 if (nr_events == before)
-                        poll(evlist->pollfd, evlist->nr_fds, 10);
+                        perf_evlist__poll(evlist, 10);
 
                 if (++nr_polls > 5) {
                         pr_debug("%s: no events!\n", __func__);
diff --git a/tools/perf/tests/open-syscall.c b/tools/perf/tests/open-syscall.c
index c1dc7d25f38c..a33b2daae40f 100644
--- a/tools/perf/tests/open-syscall.c
+++ b/tools/perf/tests/open-syscall.c
@@ -9,6 +9,7 @@ int test__open_syscall_event(void)
         struct perf_evsel *evsel;
         unsigned int nr_open_calls = 111, i;
         struct thread_map *threads = thread_map__new(-1, getpid(), UINT_MAX);
+        char sbuf[STRERR_BUFSIZE];
 
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
@@ -24,7 +25,7 @@ int test__open_syscall_event(void)
         if (perf_evsel__open_per_thread(evsel, threads) < 0) {
                 pr_debug("failed to open counter: %s, "
                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                         strerror(errno));
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_evsel_delete;
         }
 
diff --git a/tools/perf/tests/perf-record.c b/tools/perf/tests/perf-record.c
index aca1a83dd13a..7a228a2a070b 100644
--- a/tools/perf/tests/perf-record.c
+++ b/tools/perf/tests/perf-record.c
@@ -59,6 +59,7 @@ int test__PERF_RECORD(void)
         int err = -1, errs = 0, i, wakeups = 0;
         u32 cpu;
         int total_events = 0, nr_events[PERF_RECORD_MAX] = { 0, };
+        char sbuf[STRERR_BUFSIZE];
 
         if (evlist == NULL || argv == NULL) {
                 pr_debug("Not enough memory to create evlist\n");
@@ -100,7 +101,8 @@ int test__PERF_RECORD(void)
 
         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));
+                pr_debug("sched__get_first_possible_cpu: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -110,7 +112,8 @@ int test__PERF_RECORD(void)
          * So that we can check perf_sample.cpu on all the samples.
          */
         if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, &cpu_mask) < 0) {
-                pr_debug("sched_setaffinity: %s\n", strerror(errno));
+                pr_debug("sched_setaffinity: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -120,7 +123,8 @@ int test__PERF_RECORD(void)
          */
         err = perf_evlist__open(evlist);
         if (err < 0) {
-                pr_debug("perf_evlist__open: %s\n", strerror(errno));
+                pr_debug("perf_evlist__open: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -131,7 +135,8 @@ 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));
+                pr_debug("perf_evlist__mmap: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -263,7 +268,7 @@ int test__PERF_RECORD(void)
                  * perf_event_attr.wakeup_events, just PERF_EVENT_SAMPLE does.
                  */
                 if (total_events == before && false)
-                        poll(evlist->pollfd, evlist->nr_fds, -1);
+                        perf_evlist__poll(evlist, -1);
 
                 sleep(1);
                 if (++wakeups > 5) {
diff --git a/tools/perf/tests/pmu.c b/tools/perf/tests/pmu.c
index 12b322fa3475..eeb68bb1972d 100644
--- a/tools/perf/tests/pmu.c
+++ b/tools/perf/tests/pmu.c
@@ -152,7 +152,7 @@ int test__pmu(void)
                 if (ret)
                         break;
 
-                ret = perf_pmu__config_terms(&formats, &attr, terms);
+                ret = perf_pmu__config_terms(&formats, &attr, terms, false);
                 if (ret)
                         break;
 
diff --git a/tools/perf/tests/rdpmc.c b/tools/perf/tests/rdpmc.c
index c04d1f268576..d31f2c4d9f64 100644
--- a/tools/perf/tests/rdpmc.c
+++ b/tools/perf/tests/rdpmc.c
@@ -100,6 +100,7 @@ static int __test__rdpmc(void)
         };
         u64 delta_sum = 0;
         struct sigaction sa;
+        char sbuf[STRERR_BUFSIZE];
 
         sigfillset(&sa.sa_mask);
         sa.sa_sigaction = segfault_handler;
@@ -109,14 +110,15 @@ static int __test__rdpmc(void)
                                  perf_event_open_cloexec_flag());
         if (fd < 0) {
                 pr_err("Error: sys_perf_event_open() syscall returned "
-                       "with %d (%s)\n", fd, strerror(errno));
+                       "with %d (%s)\n", fd,
+                       strerror_r(errno, sbuf, sizeof(sbuf)));
                 return -1;
         }
 
         addr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, fd, 0);
         if (addr == (void *)(-1)) {
                 pr_err("Error: mmap() syscall returned with (%s)\n",
-                       strerror(errno));
+                       strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_close;
         }
 
diff --git a/tools/perf/tests/sw-clock.c b/tools/perf/tests/sw-clock.c
index 983d6b8562a8..1aa21c90731b 100644
--- a/tools/perf/tests/sw-clock.c
+++ b/tools/perf/tests/sw-clock.c
@@ -22,6 +22,7 @@ static int __test__sw_clock_freq(enum perf_sw_ids clock_id)
         volatile int tmp = 0;
         u64 total_periods = 0;
         int nr_samples = 0;
+        char sbuf[STRERR_BUFSIZE];
         union perf_event *event;
         struct perf_evsel *evsel;
         struct perf_evlist *evlist;
@@ -62,14 +63,15 @@ static int __test__sw_clock_freq(enum perf_sw_ids clock_id)
 
                 err = -errno;
                 pr_debug("Couldn't open evlist: %s\nHint: check %s, using %" PRIu64 " in this test.\n",
-                         strerror(errno), knob, (u64)attr.sample_freq);
+                         strerror_r(errno, sbuf, sizeof(sbuf)),
+                         knob, (u64)attr.sample_freq);
                 goto out_delete_evlist;
         }
 
         err = perf_evlist__mmap(evlist, 128, true);
         if (err < 0) {
                 pr_debug("failed to mmap event: %d (%s)\n", errno,
-                         strerror(errno));
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/switch-tracking.c b/tools/perf/tests/switch-tracking.c
new file mode 100644
index 000000000000..cc68648c7c55
--- /dev/null
+++ b/tools/perf/tests/switch-tracking.c
@@ -0,0 +1,572 @@
+#include <sys/time.h>
+#include <sys/prctl.h>
+#include <time.h>
+#include <stdlib.h>
+
+#include "parse-events.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "tests.h"
+
+static int spin_sleep(void)
+{
+        struct timeval start, now, diff, maxtime;
+        struct timespec ts;
+        int err, i;
+
+        maxtime.tv_sec = 0;
+        maxtime.tv_usec = 50000;
+
+        err = gettimeofday(&start, NULL);
+        if (err)
+                return err;
+
+        /* Spin for 50ms */
+        while (1) {
+                for (i = 0; i < 1000; i++)
+                        barrier();
+
+                err = gettimeofday(&now, NULL);
+                if (err)
+                        return err;
+
+                timersub(&now, &start, &diff);
+                if (timercmp(&diff, &maxtime, > /* For checkpatch */))
+                        break;
+        }
+
+        ts.tv_nsec = 50 * 1000 * 1000;
+        ts.tv_sec = 0;
+
+        /* Sleep for 50ms */
+        err = nanosleep(&ts, NULL);
+        if (err == EINTR)
+                err = 0;
+
+        return err;
+}
+
+struct switch_tracking {
+        struct perf_evsel *switch_evsel;
+        struct perf_evsel *cycles_evsel;
+        pid_t *tids;
+        int nr_tids;
+        int comm_seen[4];
+        int cycles_before_comm_1;
+        int cycles_between_comm_2_and_comm_3;
+        int cycles_after_comm_4;
+};
+
+static int check_comm(struct switch_tracking *switch_tracking,
+                      union perf_event *event, const char *comm, int nr)
+{
+        if (event->header.type == PERF_RECORD_COMM &&
+            (pid_t)event->comm.pid == getpid() &&
+            (pid_t)event->comm.tid == getpid() &&
+            strcmp(event->comm.comm, comm) == 0) {
+                if (switch_tracking->comm_seen[nr]) {
+                        pr_debug("Duplicate comm event\n");
+                        return -1;
+                }
+                switch_tracking->comm_seen[nr] = 1;
+                pr_debug3("comm event: %s nr: %d\n", event->comm.comm, nr);
+                return 1;
+        }
+        return 0;
+}
+
+static int check_cpu(struct switch_tracking *switch_tracking, int cpu)
+{
+        int i, nr = cpu + 1;
+
+        if (cpu < 0)
+                return -1;
+
+        if (!switch_tracking->tids) {
+                switch_tracking->tids = calloc(nr, sizeof(pid_t));
+                if (!switch_tracking->tids)
+                        return -1;
+                for (i = 0; i < nr; i++)
+                        switch_tracking->tids[i] = -1;
+                switch_tracking->nr_tids = nr;
+                return 0;
+        }
+
+        if (cpu >= switch_tracking->nr_tids) {
+                void *addr;
+
+                addr = realloc(switch_tracking->tids, nr * sizeof(pid_t));
+                if (!addr)
+                        return -1;
+                switch_tracking->tids = addr;
+                for (i = switch_tracking->nr_tids; i < nr; i++)
+                        switch_tracking->tids[i] = -1;
+                switch_tracking->nr_tids = nr;
+                return 0;
+        }
+
+        return 0;
+}
+
+static int process_sample_event(struct perf_evlist *evlist,
+                                union perf_event *event,
+                                struct switch_tracking *switch_tracking)
+{
+        struct perf_sample sample;
+        struct perf_evsel *evsel;
+        pid_t next_tid, prev_tid;
+        int cpu, err;
+
+        if (perf_evlist__parse_sample(evlist, event, &sample)) {
+                pr_debug("perf_evlist__parse_sample failed\n");
+                return -1;
+        }
+
+        evsel = perf_evlist__id2evsel(evlist, sample.id);
+        if (evsel == switch_tracking->switch_evsel) {
+                next_tid = perf_evsel__intval(evsel, &sample, "next_pid");
+                prev_tid = perf_evsel__intval(evsel, &sample, "prev_pid");
+                cpu = sample.cpu;
+                pr_debug3("sched_switch: cpu: %d prev_tid %d next_tid %d\n",
+                          cpu, prev_tid, next_tid);
+                err = check_cpu(switch_tracking, cpu);
+                if (err)
+                        return err;
+                /*
+                 * Check for no missing sched_switch events i.e. that the
+                 * evsel->system_wide flag has worked.
+                 */
+                if (switch_tracking->tids[cpu] != -1 &&
+                    switch_tracking->tids[cpu] != prev_tid) {
+                        pr_debug("Missing sched_switch events\n");
+                        return -1;
+                }
+                switch_tracking->tids[cpu] = next_tid;
+        }
+
+        if (evsel == switch_tracking->cycles_evsel) {
+                pr_debug3("cycles event\n");
+                if (!switch_tracking->comm_seen[0])
+                        switch_tracking->cycles_before_comm_1 = 1;
+                if (switch_tracking->comm_seen[1] &&
+                    !switch_tracking->comm_seen[2])
+                        switch_tracking->cycles_between_comm_2_and_comm_3 = 1;
+                if (switch_tracking->comm_seen[3])
+                        switch_tracking->cycles_after_comm_4 = 1;
+        }
+
+        return 0;
+}
+
+static int process_event(struct perf_evlist *evlist, union perf_event *event,
+                         struct switch_tracking *switch_tracking)
+{
+        if (event->header.type == PERF_RECORD_SAMPLE)
+                return process_sample_event(evlist, event, switch_tracking);
+
+        if (event->header.type == PERF_RECORD_COMM) {
+                int err, done = 0;
+
+                err = check_comm(switch_tracking, event, "Test COMM 1", 0);
+                if (err < 0)
+                        return -1;
+                done += err;
+                err = check_comm(switch_tracking, event, "Test COMM 2", 1);
+                if (err < 0)
+                        return -1;
+                done += err;
+                err = check_comm(switch_tracking, event, "Test COMM 3", 2);
+                if (err < 0)
+                        return -1;
+                done += err;
+                err = check_comm(switch_tracking, event, "Test COMM 4", 3);
+                if (err < 0)
+                        return -1;
+                done += err;
+                if (done != 1) {
+                        pr_debug("Unexpected comm event\n");
+                        return -1;
+                }
+        }
+
+        return 0;
+}
+
+struct event_node {
+        struct list_head list;
+        union perf_event *event;
+        u64 event_time;
+};
+
+static int add_event(struct perf_evlist *evlist, struct list_head *events,
+                     union perf_event *event)
+{
+        struct perf_sample sample;
+        struct event_node *node;
+
+        node = malloc(sizeof(struct event_node));
+        if (!node) {
+                pr_debug("malloc failed\n");
+                return -1;
+        }
+        node->event = event;
+        list_add(&node->list, events);
+
+        if (perf_evlist__parse_sample(evlist, event, &sample)) {
+                pr_debug("perf_evlist__parse_sample failed\n");
+                return -1;
+        }
+
+        if (!sample.time) {
+                pr_debug("event with no time\n");
+                return -1;
+        }
+
+        node->event_time = sample.time;
+
+        return 0;
+}
+
+static void free_event_nodes(struct list_head *events)
+{
+        struct event_node *node;
+
+        while (!list_empty(events)) {
+                node = list_entry(events->next, struct event_node, list);
+                list_del(&node->list);
+                free(node);
+        }
+}
+
+static int compar(const void *a, const void *b)
+{
+        const struct event_node *nodea = a;
+        const struct event_node *nodeb = b;
+        s64 cmp = nodea->event_time - nodeb->event_time;
+
+        return cmp;
+}
+
+static int process_events(struct perf_evlist *evlist,
+                          struct switch_tracking *switch_tracking)
+{
+        union perf_event *event;
+        unsigned pos, cnt = 0;
+        LIST_HEAD(events);
+        struct event_node *events_array, *node;
+        int i, ret;
+
+        for (i = 0; i < evlist->nr_mmaps; i++) {
+                while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
+                        cnt += 1;
+                        ret = add_event(evlist, &events, event);
+                        perf_evlist__mmap_consume(evlist, i);
+                        if (ret < 0)
+                                goto out_free_nodes;
+                }
+        }
+
+        events_array = calloc(cnt, sizeof(struct event_node));
+        if (!events_array) {
+                pr_debug("calloc failed\n");
+                ret = -1;
+                goto out_free_nodes;
+        }
+
+        pos = 0;
+        list_for_each_entry(node, &events, list)
+                events_array[pos++] = *node;
+
+        qsort(events_array, cnt, sizeof(struct event_node), compar);
+
+        for (pos = 0; pos < cnt; pos++) {
+                ret = process_event(evlist, events_array[pos].event,
+                                    switch_tracking);
+                if (ret < 0)
+                        goto out_free;
+        }
+
+        ret = 0;
+out_free:
+        pr_debug("%u events recorded\n", cnt);
+        free(events_array);
+out_free_nodes:
+        free_event_nodes(&events);
+        return ret;
+}
+
+/**
+ * test__switch_tracking - test using sched_switch and tracking events.
+ *
+ * This function implements a test that checks that sched_switch events and
+ * tracking events can be recorded for a workload (current process) using the
+ * evsel->system_wide and evsel->tracking flags (respectively) with other events
+ * sometimes enabled or disabled.
+ */
+int test__switch_tracking(void)
+{
+        const char *sched_switch = "sched:sched_switch";
+        struct switch_tracking switch_tracking = { .tids = NULL, };
+        struct record_opts opts = {
+                .mmap_pages          = UINT_MAX,
+                .user_freq           = UINT_MAX,
+                .user_interval       = ULLONG_MAX,
+                .freq                = 4000,
+                .target              = {
+                        .uses_mmap   = true,
+                },
+        };
+        struct thread_map *threads = NULL;
+        struct cpu_map *cpus = NULL;
+        struct perf_evlist *evlist = NULL;
+        struct perf_evsel *evsel, *cpu_clocks_evsel, *cycles_evsel;
+        struct perf_evsel *switch_evsel, *tracking_evsel;
+        const char *comm;
+        int err = -1;
+
+        threads = thread_map__new(-1, getpid(), UINT_MAX);
+        if (!threads) {
+                pr_debug("thread_map__new failed!\n");
+                goto out_err;
+        }
+
+        cpus = cpu_map__new(NULL);
+        if (!cpus) {
+                pr_debug("cpu_map__new failed!\n");
+                goto out_err;
+        }
+
+        evlist = perf_evlist__new();
+        if (!evlist) {
+                pr_debug("perf_evlist__new failed!\n");
+                goto out_err;
+        }
+
+        perf_evlist__set_maps(evlist, cpus, threads);
+
+        /* First event */
+        err = parse_events(evlist, "cpu-clock:u");
+        if (err) {
+                pr_debug("Failed to parse event dummy:u\n");
+                goto out_err;
+        }
+
+        cpu_clocks_evsel = perf_evlist__last(evlist);
+
+        /* Second event */
+        err = parse_events(evlist, "cycles:u");
+        if (err) {
+                pr_debug("Failed to parse event cycles:u\n");
+                goto out_err;
+        }
+
+        cycles_evsel = perf_evlist__last(evlist);
+
+        /* Third event */
+        if (!perf_evlist__can_select_event(evlist, sched_switch)) {
+                fprintf(stderr, " (no sched_switch)");
+                err = 0;
+                goto out;
+        }
+
+        err = parse_events(evlist, sched_switch);
+        if (err) {
+                pr_debug("Failed to parse event %s\n", sched_switch);
+                goto out_err;
+        }
+
+        switch_evsel = perf_evlist__last(evlist);
+
+        perf_evsel__set_sample_bit(switch_evsel, CPU);
+        perf_evsel__set_sample_bit(switch_evsel, TIME);
+
+        switch_evsel->system_wide = true;
+        switch_evsel->no_aux_samples = true;
+        switch_evsel->immediate = true;
+
+        /* Test moving an event to the front */
+        if (cycles_evsel == perf_evlist__first(evlist)) {
+                pr_debug("cycles event already at front");
+                goto out_err;
+        }
+        perf_evlist__to_front(evlist, cycles_evsel);
+        if (cycles_evsel != perf_evlist__first(evlist)) {
+                pr_debug("Failed to move cycles event to front");
+                goto out_err;
+        }
+
+        perf_evsel__set_sample_bit(cycles_evsel, CPU);
+        perf_evsel__set_sample_bit(cycles_evsel, TIME);
+
+        /* Fourth event */
+        err = parse_events(evlist, "dummy:u");
+        if (err) {
+                pr_debug("Failed to parse event dummy:u\n");
+                goto out_err;
+        }
+
+        tracking_evsel = perf_evlist__last(evlist);
+
+        perf_evlist__set_tracking_event(evlist, tracking_evsel);
+
+        tracking_evsel->attr.freq = 0;
+        tracking_evsel->attr.sample_period = 1;
+
+        perf_evsel__set_sample_bit(tracking_evsel, TIME);
+
+        /* Config events */
+        perf_evlist__config(evlist, &opts);
+
+        /* Check moved event is still at the front */
+        if (cycles_evsel != perf_evlist__first(evlist)) {
+                pr_debug("Front event no longer at front");
+                goto out_err;
+        }
+
+        /* Check tracking event is tracking */
+        if (!tracking_evsel->attr.mmap || !tracking_evsel->attr.comm) {
+                pr_debug("Tracking event not tracking\n");
+                goto out_err;
+        }
+
+        /* Check non-tracking events are not tracking */
+        evlist__for_each(evlist, evsel) {
+                if (evsel != tracking_evsel) {
+                        if (evsel->attr.mmap || evsel->attr.comm) {
+                                pr_debug("Non-tracking event is tracking\n");
+                                goto out_err;
+                        }
+                }
+        }
+
+        if (perf_evlist__open(evlist) < 0) {
+                fprintf(stderr, " (not supported)");
+                err = 0;
+                goto out;
+        }
+
+        err = perf_evlist__mmap(evlist, UINT_MAX, false);
+        if (err) {
+                pr_debug("perf_evlist__mmap failed!\n");
+                goto out_err;
+        }
+
+        perf_evlist__enable(evlist);
+
+        err = perf_evlist__disable_event(evlist, cpu_clocks_evsel);
+        if (err) {
+                pr_debug("perf_evlist__disable_event failed!\n");
+                goto out_err;
+        }
+
+        err = spin_sleep();
+        if (err) {
+                pr_debug("spin_sleep failed!\n");
+                goto out_err;
+        }
+
+        comm = "Test COMM 1";
+        err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
+        if (err) {
+                pr_debug("PR_SET_NAME failed!\n");
+                goto out_err;
+        }
+
+        err = perf_evlist__disable_event(evlist, cycles_evsel);
+        if (err) {
+                pr_debug("perf_evlist__disable_event failed!\n");
+                goto out_err;
+        }
+
+        comm = "Test COMM 2";
+        err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
+        if (err) {
+                pr_debug("PR_SET_NAME failed!\n");
+                goto out_err;
+        }
+
+        err = spin_sleep();
+        if (err) {
+                pr_debug("spin_sleep failed!\n");
+                goto out_err;
+        }
+
+        comm = "Test COMM 3";
+        err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
+        if (err) {
+                pr_debug("PR_SET_NAME failed!\n");
+                goto out_err;
+        }
+
+        err = perf_evlist__enable_event(evlist, cycles_evsel);
+        if (err) {
+                pr_debug("perf_evlist__disable_event failed!\n");
+                goto out_err;
+        }
+
+        comm = "Test COMM 4";
+        err = prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0);
+        if (err) {
+                pr_debug("PR_SET_NAME failed!\n");
+                goto out_err;
+        }
+
+        err = spin_sleep();
+        if (err) {
+                pr_debug("spin_sleep failed!\n");
+                goto out_err;
+        }
+
+        perf_evlist__disable(evlist);
+
+        switch_tracking.switch_evsel = switch_evsel;
+        switch_tracking.cycles_evsel = cycles_evsel;
+
+        err = process_events(evlist, &switch_tracking);
+
+        zfree(&switch_tracking.tids);
+
+        if (err)
+                goto out_err;
+
+        /* Check all 4 comm events were seen i.e. that evsel->tracking works */
+        if (!switch_tracking.comm_seen[0] || !switch_tracking.comm_seen[1] ||
+            !switch_tracking.comm_seen[2] || !switch_tracking.comm_seen[3]) {
+                pr_debug("Missing comm events\n");
+                goto out_err;
+        }
+
+        /* Check cycles event got enabled */
+        if (!switch_tracking.cycles_before_comm_1) {
+                pr_debug("Missing cycles events\n");
+                goto out_err;
+        }
+
+        /* Check cycles event got disabled */
+        if (switch_tracking.cycles_between_comm_2_and_comm_3) {
+                pr_debug("cycles events even though event was disabled\n");
+                goto out_err;
+        }
+
+        /* Check cycles event got enabled again */
+        if (!switch_tracking.cycles_after_comm_4) {
+                pr_debug("Missing cycles events\n");
+                goto out_err;
+        }
+out:
+        if (evlist) {
+                perf_evlist__disable(evlist);
+                perf_evlist__delete(evlist);
+        } else {
+                cpu_map__delete(cpus);
+                thread_map__delete(threads);
+        }
+
+        return err;
+
+out_err:
+        err = -1;
+        goto out;
+}
diff --git a/tools/perf/tests/task-exit.c b/tools/perf/tests/task-exit.c
index 5ff3db318f12..3a8fedef83bc 100644
--- a/tools/perf/tests/task-exit.c
+++ b/tools/perf/tests/task-exit.c
@@ -42,6 +42,7 @@ int test__task_exit(void)
                 .uses_mmap      = true,
         };
         const char *argv[] = { "true", NULL };
+        char sbuf[STRERR_BUFSIZE];
 
         signal(SIGCHLD, sig_handler);
 
@@ -82,13 +83,14 @@ int test__task_exit(void)
 
         err = perf_evlist__open(evlist);
         if (err < 0) {
-                pr_debug("Couldn't open the evlist: %s\n", strerror(-err));
+                pr_debug("Couldn't open the evlist: %s\n",
+                         strerror_r(-err, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
         if (perf_evlist__mmap(evlist, 128, true) < 0) {
                 pr_debug("failed to mmap events: %d (%s)\n", errno,
-                         strerror(errno));
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -103,7 +105,7 @@ retry:
         }
 
         if (!exited || !nr_exit) {
-                poll(evlist->pollfd, evlist->nr_fds, -1);
+                perf_evlist__poll(evlist, -1);
                 goto retry;
         }
 
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index ed64790a395f..00e776a87a9c 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -48,6 +48,9 @@ int test__mmap_thread_lookup(void);
 int test__thread_mg_share(void);
 int test__hists_output(void);
 int test__hists_cumulate(void);
+int test__switch_tracking(void);
+int test__fdarray__filter(void);
+int test__fdarray__add(void);
 
 #if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index a94b11fc5e00..8f60a970404f 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -10,6 +10,7 @@
 #include "../../util/pstack.h"
 #include "../../util/sort.h"
 #include "../../util/util.h"
+#include "../../util/top.h"
 #include "../../arch/common.h"
 
 #include "../browser.h"
@@ -228,8 +229,10 @@ static void callchain_node__init_have_children(struct callchain_node *node)
 {
         struct callchain_list *chain;
 
-        list_for_each_entry(chain, &node->val, list)
+        if (!list_empty(&node->val)) {
+                chain = list_entry(node->val.prev, struct callchain_list, list);
                 chain->ms.has_children = !RB_EMPTY_ROOT(&node->rb_root);
+        }
 
         callchain_node__init_have_children_rb_tree(node);
 }
@@ -474,26 +477,87 @@ static char *callchain_list__sym_name(struct callchain_list *cl,
         return bf;
 }
 
+struct callchain_print_arg {
+        /* for hists browser */
+        off_t   row_offset;
+        bool    is_current_entry;
+
+        /* for file dump */
+        FILE    *fp;
+        int     printed;
+};
+
+typedef void (*print_callchain_entry_fn)(struct hist_browser *browser,
+                                         struct callchain_list *chain,
+                                         const char *str, int offset,
+                                         unsigned short row,
+                                         struct callchain_print_arg *arg);
+
+static void hist_browser__show_callchain_entry(struct hist_browser *browser,
+                                               struct callchain_list *chain,
+                                               const char *str, int offset,
+                                               unsigned short row,
+                                               struct callchain_print_arg *arg)
+{
+        int color, width;
+        char folded_sign = callchain_list__folded(chain);
+
+        color = HE_COLORSET_NORMAL;
+        width = browser->b.width - (offset + 2);
+        if (ui_browser__is_current_entry(&browser->b, row)) {
+                browser->selection = &chain->ms;
+                color = HE_COLORSET_SELECTED;
+                arg->is_current_entry = true;
+        }
+
+        ui_browser__set_color(&browser->b, color);
+        hist_browser__gotorc(browser, row, 0);
+        slsmg_write_nstring(" ", offset);
+        slsmg_printf("%c ", folded_sign);
+        slsmg_write_nstring(str, width);
+}
+
+static void hist_browser__fprintf_callchain_entry(struct hist_browser *b __maybe_unused,
+                                                  struct callchain_list *chain,
+                                                  const char *str, int offset,
+                                                  unsigned short row __maybe_unused,
+                                                  struct callchain_print_arg *arg)
+{
+        char folded_sign = callchain_list__folded(chain);
+
+        arg->printed += fprintf(arg->fp, "%*s%c %s\n", offset, " ",
+                                folded_sign, str);
+}
+
+typedef bool (*check_output_full_fn)(struct hist_browser *browser,
+                                     unsigned short row);
+
+static bool hist_browser__check_output_full(struct hist_browser *browser,
+                                            unsigned short row)
+{
+        return browser->b.rows == row;
+}
+
+static bool hist_browser__check_dump_full(struct hist_browser *browser __maybe_unused,
+                                          unsigned short row __maybe_unused)
+{
+        return false;
+}
+
 #define LEVEL_OFFSET_STEP 3
 
-static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browser,
-                                                     struct callchain_node *chain_node,
-                                                     u64 total, int level,
-                                                     unsigned short row,
-                                                     off_t *row_offset,
-                                                     bool *is_current_entry)
+static int hist_browser__show_callchain(struct hist_browser *browser,
+                                        struct rb_root *root, int level,
+                                        unsigned short row, u64 total,
+                                        print_callchain_entry_fn print,
+                                        struct callchain_print_arg *arg,
+                                        check_output_full_fn is_output_full)
 {
         struct rb_node *node;
-        int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
-        u64 new_total, remaining;
+        int first_row = row, offset = level * LEVEL_OFFSET_STEP;
+        u64 new_total;
 
-        if (callchain_param.mode == CHAIN_GRAPH_REL)
-                new_total = chain_node->children_hit;
-        else
-                new_total = total;
-
-        remaining = new_total;
-        node = rb_first(&chain_node->rb_root);
+        node = rb_first(root);
         while (node) {
                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
                 struct rb_node *next = rb_next(node);
@@ -503,30 +567,28 @@ static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browse
                 int first = true;
                 int extra_offset = 0;
 
-                remaining -= cumul;
-
                 list_for_each_entry(chain, &child->val, list) {
                         char bf[1024], *alloc_str;
                         const char *str;
-                        int color;
                         bool was_first = first;
 
                         if (first)
                                 first = false;
-                        else
+                        else if (level > 1)
                                 extra_offset = LEVEL_OFFSET_STEP;
 
                         folded_sign = callchain_list__folded(chain);
-                        if (*row_offset != 0) {
-                                --*row_offset;
+                        if (arg->row_offset != 0) {
+                                arg->row_offset--;
                                 goto do_next;
                         }
 
                         alloc_str = NULL;
                         str = callchain_list__sym_name(chain, bf, sizeof(bf),
                                                        browser->show_dso);
-                        if (was_first) {
-                                double percent = cumul * 100.0 / new_total;
+
+                        if (was_first && level > 1) {
+                                double percent = cumul * 100.0 / total;
 
                                 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
                                         str = "Not enough memory!";
@@ -534,22 +596,11 @@ static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browse
                                         str = alloc_str;
                         }
 
-                        color = HE_COLORSET_NORMAL;
-                        width = browser->b.width - (offset + extra_offset + 2);
-                        if (ui_browser__is_current_entry(&browser->b, row)) {
-                                browser->selection = &chain->ms;
-                                color = HE_COLORSET_SELECTED;
-                                *is_current_entry = true;
-                        }
+                        print(browser, chain, str, offset + extra_offset, row, arg);
 
-                        ui_browser__set_color(&browser->b, color);
-                        hist_browser__gotorc(browser, row, 0);
-                        slsmg_write_nstring(" ", offset + extra_offset);
-                        slsmg_printf("%c ", folded_sign);
-                        slsmg_write_nstring(str, width);
                         free(alloc_str);
 
-                        if (++row == browser->b.rows)
+                        if (is_output_full(browser, ++row))
                                 goto out;
 do_next:
                         if (folded_sign == '+')
@@ -558,89 +609,21 @@ do_next:
 
                 if (folded_sign == '-') {
                         const int new_level = level + (extra_offset ? 2 : 1);
-                        row += hist_browser__show_callchain_node_rb_tree(browser, child, new_total,
-                                                                         new_level, row, row_offset,
-                                                                         is_current_entry);
-                }
-                if (row == browser->b.rows)
-                        goto out;
-                node = next;
-        }
-out:
-        return row - first_row;
-}
-
-static int hist_browser__show_callchain_node(struct hist_browser *browser,
-                                             struct callchain_node *node,
-                                             int level, unsigned short row,
-                                             off_t *row_offset,
-                                             bool *is_current_entry)
-{
-        struct callchain_list *chain;
-        int first_row = row,
-             offset = level * LEVEL_OFFSET_STEP,
-             width = browser->b.width - offset;
-        char folded_sign = ' ';
 
-        list_for_each_entry(chain, &node->val, list) {
-                char bf[1024], *s;
-                int color;
-
-                folded_sign = callchain_list__folded(chain);
-
-                if (*row_offset != 0) {
-                        --*row_offset;
-                        continue;
-                }
+                        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                                new_total = child->children_hit;
+                        else
+                                new_total = total;
 
-                color = HE_COLORSET_NORMAL;
-                if (ui_browser__is_current_entry(&browser->b, row)) {
-                        browser->selection = &chain->ms;
-                        color = HE_COLORSET_SELECTED;
-                        *is_current_entry = true;
+                        row += hist_browser__show_callchain(browser, &child->rb_root,
+                                                            new_level, row, new_total,
+                                                            print, arg, is_output_full);
                 }
-
-                s = callchain_list__sym_name(chain, bf, sizeof(bf),
-                                             browser->show_dso);
-                hist_browser__gotorc(browser, row, 0);
-                ui_browser__set_color(&browser->b, color);
-                slsmg_write_nstring(" ", offset);
-                slsmg_printf("%c ", folded_sign);
-                slsmg_write_nstring(s, width - 2);
-
-                if (++row == browser->b.rows)
-                        goto out;
-        }
-
-        if (folded_sign == '-')
-                row += hist_browser__show_callchain_node_rb_tree(browser, node,
-                                                                 browser->hists->stats.total_period,
-                                                                 level + 1, row,
-                                                                 row_offset,
-                                                                 is_current_entry);
-out:
-        return row - first_row;
-}
-
-static int hist_browser__show_callchain(struct hist_browser *browser,
-                                        struct rb_root *chain,
-                                        int level, unsigned short row,
-                                        off_t *row_offset,
-                                        bool *is_current_entry)
-{
-        struct rb_node *nd;
-        int first_row = row;
-
-        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
-                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
-
-                row += hist_browser__show_callchain_node(browser, node, level,
-                                                         row, row_offset,
-                                                         is_current_entry);
-                if (row == browser->b.rows)
+                if (is_output_full(browser, row))
                         break;
+                node = next;
         }
-
+out:
         return row - first_row;
 }
 
@@ -653,17 +636,18 @@ struct hpp_arg {
 static int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
 {
         struct hpp_arg *arg = hpp->ptr;
-        int ret;
+        int ret, len;
         va_list args;
         double percent;
 
         va_start(args, fmt);
+        len = va_arg(args, int);
         percent = va_arg(args, double);
         va_end(args);
 
         ui_browser__set_percent_color(arg->b, percent, arg->current_entry);
 
-        ret = scnprintf(hpp->buf, hpp->size, fmt, percent);
+        ret = scnprintf(hpp->buf, hpp->size, fmt, len, percent);
         slsmg_printf("%s", hpp->buf);
 
         advance_hpp(hpp, ret);
@@ -677,12 +661,12 @@ static u64 __hpp_get_##_field(struct hist_entry *he)			\
 }                                                                       \
                                                                         \
 static int                                                              \
-hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,\
+hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
                                 struct perf_hpp *hpp,                   \
                                 struct hist_entry *he)                  \
 {                                                                       \
-        return __hpp__fmt(hpp, he, __hpp_get_##_field, " %6.2f%%",      \
-                          __hpp__slsmg_color_printf, true);             \
+        return hpp__fmt(fmt, hpp, he, __hpp_get_##_field, " %*.2f%%",   \
+                        __hpp__slsmg_color_printf, true);               \
 }
 
 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                       \
@@ -692,18 +676,20 @@ static u64 __hpp_get_acc_##_field(struct hist_entry *he)		\
 }                                                                       \
                                                                         \
 static int                                                              \
-hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,\
+hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt,               \
                                 struct perf_hpp *hpp,                   \
                                 struct hist_entry *he)                  \
 {                                                                       \
         if (!symbol_conf.cumulate_callchain) {                          \
-                int ret = scnprintf(hpp->buf, hpp->size, "%8s", "N/A"); \
+                int len = fmt->user_len ?: fmt->len;                    \
+                int ret = scnprintf(hpp->buf, hpp->size,                \
+                                    "%*s", len, "N/A");                 \
                 slsmg_printf("%s", hpp->buf);                           \
                                                                         \
                 return ret;                                             \
         }                                                               \
-        return __hpp__fmt(hpp, he, __hpp_get_acc_##_field, " %6.2f%%",  \
-                          __hpp__slsmg_color_printf, true);             \
+        return hpp__fmt(fmt, hpp, he, __hpp_get_acc_##_field,           \
+                        " %*.2f%%", __hpp__slsmg_color_printf, true);   \
 }
 
 __HPP_COLOR_PERCENT_FN(overhead, period)
@@ -812,10 +798,18 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                 --row_offset;
 
         if (folded_sign == '-' && row != browser->b.rows) {
-                printed += hist_browser__show_callchain(browser, &entry->sorted_chain,
-                                                        1, row, &row_offset,
-                                                        &current_entry);
-                if (current_entry)
+                u64 total = hists__total_period(entry->hists);
+                struct callchain_print_arg arg = {
+                        .row_offset = row_offset,
+                        .is_current_entry = current_entry,
+                };
+
+                printed += hist_browser__show_callchain(browser,
+                                        &entry->sorted_chain, 1, row, total,
+                                        hist_browser__show_callchain_entry, &arg,
+                                        hist_browser__check_output_full);
+
+                if (arg.is_current_entry)
                         browser->he_selection = entry;
         }
 
@@ -847,9 +841,6 @@ static int hists__scnprintf_headers(char *buf, size_t size, struct hists *hists)
                 if (perf_hpp__should_skip(fmt))
                         continue;
 
-                /* We need to add the length of the columns header. */
-                perf_hpp__reset_width(fmt, hists);
-
                 ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
                 if (advance_hpp_check(&dummy_hpp, ret))
                         break;
@@ -1074,113 +1065,21 @@ do_offset:
         }
 }
 
-static int hist_browser__fprintf_callchain_node_rb_tree(struct hist_browser *browser,
-                                                        struct callchain_node *chain_node,
-                                                        u64 total, int level,
-                                                        FILE *fp)
-{
-        struct rb_node *node;
-        int offset = level * LEVEL_OFFSET_STEP;
-        u64 new_total, remaining;
-        int printed = 0;
-
-        if (callchain_param.mode == CHAIN_GRAPH_REL)
-                new_total = chain_node->children_hit;
-        else
-                new_total = total;
-
-        remaining = new_total;
-        node = rb_first(&chain_node->rb_root);
-        while (node) {
-                struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
-                struct rb_node *next = rb_next(node);
-                u64 cumul = callchain_cumul_hits(child);
-                struct callchain_list *chain;
-                char folded_sign = ' ';
-                int first = true;
-                int extra_offset = 0;
-
-                remaining -= cumul;
-
-                list_for_each_entry(chain, &child->val, list) {
-                        char bf[1024], *alloc_str;
-                        const char *str;
-                        bool was_first = first;
-
-                        if (first)
-                                first = false;
-                        else
-                                extra_offset = LEVEL_OFFSET_STEP;
-
-                        folded_sign = callchain_list__folded(chain);
-
-                        alloc_str = NULL;
-                        str = callchain_list__sym_name(chain, bf, sizeof(bf),
-                                                       browser->show_dso);
-                        if (was_first) {
-                                double percent = cumul * 100.0 / new_total;
-
-                                if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
-                                        str = "Not enough memory!";
-                                else
-                                        str = alloc_str;
-                        }
-
-                        printed += fprintf(fp, "%*s%c %s\n", offset + extra_offset, " ", folded_sign, str);
-                        free(alloc_str);
-                        if (folded_sign == '+')
-                                break;
-                }
-
-                if (folded_sign == '-') {
-                        const int new_level = level + (extra_offset ? 2 : 1);
-                        printed += hist_browser__fprintf_callchain_node_rb_tree(browser, child, new_total,
-                                                                                new_level, fp);
-                }
-
-                node = next;
-        }
-
-        return printed;
-}
-
-static int hist_browser__fprintf_callchain_node(struct hist_browser *browser,
-                                                struct callchain_node *node,
-                                                int level, FILE *fp)
-{
-        struct callchain_list *chain;
-        int offset = level * LEVEL_OFFSET_STEP;
-        char folded_sign = ' ';
-        int printed = 0;
-
-        list_for_each_entry(chain, &node->val, list) {
-                char bf[1024], *s;
-
-                folded_sign = callchain_list__folded(chain);
-                s = callchain_list__sym_name(chain, bf, sizeof(bf), browser->show_dso);
-                printed += fprintf(fp, "%*s%c %s\n", offset, " ", folded_sign, s);
-        }
-
-        if (folded_sign == '-')
-                printed += hist_browser__fprintf_callchain_node_rb_tree(browser, node,
-                                                                        browser->hists->stats.total_period,
-                                                                        level + 1,  fp);
-        return printed;
-}
-
 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
-                                           struct rb_root *chain, int level, FILE *fp)
+                                           struct hist_entry *he, FILE *fp)
 {
-        struct rb_node *nd;
-        int printed = 0;
+        u64 total = hists__total_period(he->hists);
+        struct callchain_print_arg arg  = {
+                .fp = fp,
+        };
 
-        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
-                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+        if (symbol_conf.cumulate_callchain)
+                total = he->stat_acc->period;
 
-                printed += hist_browser__fprintf_callchain_node(browser, node, level, fp);
-        }
-
-        return printed;
+        hist_browser__show_callchain(browser, &he->sorted_chain, 1, 0, total,
+                                     hist_browser__fprintf_callchain_entry, &arg,
+                                     hist_browser__check_dump_full);
+        return arg.printed;
 }
 
 static int hist_browser__fprintf_entry(struct hist_browser *browser,
@@ -1219,7 +1118,7 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser,
         printed += fprintf(fp, "%s\n", rtrim(s));
 
         if (folded_sign == '-')
-                printed += hist_browser__fprintf_callchain(browser, &he->sorted_chain, 1, fp);
+                printed += hist_browser__fprintf_callchain(browser, he, fp);
 
         return printed;
 }
@@ -1498,6 +1397,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         char buf[64];
         char script_opt[64];
         int delay_secs = hbt ? hbt->refresh : 0;
+        struct perf_hpp_fmt *fmt;
 
 #define HIST_BROWSER_HELP_COMMON                                        \
         "h/?/F1        Show this window\n"                              \
@@ -1529,6 +1429,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         "P             Print histograms to perf.hist.N\n"
         "t             Zoom into current Thread\n"
         "V             Verbose (DSO names in callchains, etc)\n"
+        "z             Toggle zeroing of samples\n"
         "/             Filter symbol by name";
 
         if (browser == NULL)
@@ -1547,6 +1448,12 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 
         memset(options, 0, sizeof(options));
 
+        perf_hpp__for_each_format(fmt)
+                perf_hpp__reset_width(fmt, hists);
+
+        if (symbol_conf.col_width_list_str)
+                perf_hpp__set_user_width(symbol_conf.col_width_list_str);
+
         while (1) {
                 const struct thread *thread = NULL;
                 const struct dso *dso = NULL;
@@ -1623,6 +1530,13 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                 case 'F':
                         symbol_conf.filter_relative ^= 1;
                         continue;
+                case 'z':
+                        if (!is_report_browser(hbt)) {
+                                struct perf_top *top = hbt->arg;
+
+                                top->zero = !top->zero;
+                        }
+                        continue;
                 case K_F1:
                 case 'h':
                 case '?':
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
index 6ca60e482cdc..f3fa4258b256 100644
--- a/tools/perf/ui/gtk/hists.c
+++ b/tools/perf/ui/gtk/hists.c
@@ -11,6 +11,7 @@
 static int __percent_color_snprintf(struct perf_hpp *hpp, const char *fmt, ...)
 {
         int ret = 0;
+        int len;
         va_list args;
         double percent;
         const char *markup;
@@ -18,6 +19,7 @@ static int __percent_color_snprintf(struct perf_hpp *hpp, const char *fmt, ...)
         size_t size = hpp->size;
 
         va_start(args, fmt);
+        len = va_arg(args, int);
         percent = va_arg(args, double);
         va_end(args);
 
@@ -25,7 +27,7 @@ static int __percent_color_snprintf(struct perf_hpp *hpp, const char *fmt, ...)
         if (markup)
                 ret += scnprintf(buf, size, markup);
 
-        ret += scnprintf(buf + ret, size - ret, fmt, percent);
+        ret += scnprintf(buf + ret, size - ret, fmt, len, percent);
 
         if (markup)
                 ret += scnprintf(buf + ret, size - ret, "</span>");
@@ -39,12 +41,12 @@ static u64 he_get_##_field(struct hist_entry *he)				\
         return he->stat._field;                                                 \
 }                                                                               \
                                                                                 \
-static int perf_gtk__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
+static int perf_gtk__hpp_color_##_type(struct perf_hpp_fmt *fmt,                \
                                        struct perf_hpp *hpp,                    \
                                        struct hist_entry *he)                   \
 {                                                                               \
-        return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%",                 \
-                          __percent_color_snprintf, true);                      \
+        return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",              \
+                        __percent_color_snprintf, true);                        \
 }
 
 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                               \
@@ -57,8 +59,8 @@ static int perf_gtk__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,
                                        struct perf_hpp *hpp,                    \
                                        struct hist_entry *he)                   \
 {                                                                               \
-        return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, " %6.2f%%",         \
-                              __percent_color_snprintf, true);                  \
+        return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",      \
+                            __percent_color_snprintf, true);                    \
 }
 
 __HPP_COLOR_PERCENT_FN(overhead, period)
@@ -205,10 +207,8 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,
                 if (perf_hpp__is_sort_entry(fmt))
                         sym_col = col_idx;
 
-                fmt->header(fmt, &hpp, hists_to_evsel(hists));
-
                 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
-                                                            -1, ltrim(s),
+                                                            -1, fmt->name,
                                                             renderer, "markup",
                                                             col_idx++, NULL);
         }
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index 498adb23c02e..2af18376b077 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -15,9 +15,9 @@
         __ret;                                                  \
 })
 
-int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
-               hpp_field_fn get_field, const char *fmt,
-               hpp_snprint_fn print_fn, bool fmt_percent)
+static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
+                      hpp_field_fn get_field, const char *fmt, int len,
+                      hpp_snprint_fn print_fn, bool fmt_percent)
 {
         int ret;
         struct hists *hists = he->hists;
@@ -32,9 +32,9 @@ int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
                 if (total)
                         percent = 100.0 * get_field(he) / total;
 
-                ret = hpp__call_print_fn(hpp, print_fn, fmt, percent);
+                ret = hpp__call_print_fn(hpp, print_fn, fmt, len, percent);
         } else
-                ret = hpp__call_print_fn(hpp, print_fn, fmt, get_field(he));
+                ret = hpp__call_print_fn(hpp, print_fn, fmt, len, get_field(he));
 
         if (perf_evsel__is_group_event(evsel)) {
                 int prev_idx, idx_delta;
@@ -60,19 +60,19 @@ int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
                                  */
                                 if (fmt_percent) {
                                         ret += hpp__call_print_fn(hpp, print_fn,
-                                                                  fmt, 0.0);
+                                                                  fmt, len, 0.0);
                                 } else {
                                         ret += hpp__call_print_fn(hpp, print_fn,
-                                                                  fmt, 0ULL);
+                                                                  fmt, len, 0ULL);
                                 }
                         }
 
                         if (fmt_percent) {
-                                ret += hpp__call_print_fn(hpp, print_fn, fmt,
+                                ret += hpp__call_print_fn(hpp, print_fn, fmt, len,
                                                           100.0 * period / total);
                         } else {
                                 ret += hpp__call_print_fn(hpp, print_fn, fmt,
-                                                          period);
+                                                          len, period);
                         }
 
                         prev_idx = perf_evsel__group_idx(evsel);
@@ -86,10 +86,10 @@ int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
                          */
                         if (fmt_percent) {
                                 ret += hpp__call_print_fn(hpp, print_fn,
-                                                          fmt, 0.0);
+                                                          fmt, len, 0.0);
                         } else {
                                 ret += hpp__call_print_fn(hpp, print_fn,
-                                                          fmt, 0ULL);
+                                                          fmt, len, 0ULL);
                         }
                 }
         }
@@ -104,16 +104,35 @@ int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
         return ret;
 }
 
-int __hpp__fmt_acc(struct perf_hpp *hpp, struct hist_entry *he,
-                   hpp_field_fn get_field, const char *fmt,
-                   hpp_snprint_fn print_fn, bool fmt_percent)
+int hpp__fmt(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+             struct hist_entry *he, hpp_field_fn get_field,
+             const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
+{
+        int len = fmt->user_len ?: fmt->len;
+
+        if (symbol_conf.field_sep) {
+                return __hpp__fmt(hpp, he, get_field, fmtstr, 1,
+                                  print_fn, fmt_percent);
+        }
+
+        if (fmt_percent)
+                len -= 2; /* 2 for a space and a % sign */
+        else
+                len -= 1;
+
+        return  __hpp__fmt(hpp, he, get_field, fmtstr, len, print_fn, fmt_percent);
+}
+
+int hpp__fmt_acc(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+                 struct hist_entry *he, hpp_field_fn get_field,
+                 const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
 {
         if (!symbol_conf.cumulate_callchain) {
-                return snprintf(hpp->buf, hpp->size, "%*s",
-                                fmt_percent ? 8 : 12, "N/A");
+                int len = fmt->user_len ?: fmt->len;
+                return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A");
         }
 
-        return __hpp__fmt(hpp, he, get_field, fmt, print_fn, fmt_percent);
+        return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent);
 }
 
 static int field_cmp(u64 field_a, u64 field_b)
@@ -190,30 +209,26 @@ static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b,
         return ret;
 }
 
-#define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)           \
-static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
-                               struct perf_hpp *hpp,                    \
-                               struct perf_evsel *evsel)                \
-{                                                                       \
-        int len = _min_width;                                           \
-                                                                        \
-        if (symbol_conf.event_group)                                    \
-                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_fmt *fmt __maybe_unused,  \
-                              struct perf_hpp *hpp __maybe_unused,      \
-                              struct perf_evsel *evsel)                 \
-{                                                                       \
-        int len = _min_width;                                           \
-                                                                        \
-        if (symbol_conf.event_group)                                    \
-                len = max(len, evsel->nr_members * _unit_width);        \
-                                                                        \
-        return len;                                                     \
+static int hpp__width_fn(struct perf_hpp_fmt *fmt,
+                         struct perf_hpp *hpp __maybe_unused,
+                         struct perf_evsel *evsel)
+{
+        int len = fmt->user_len ?: fmt->len;
+
+        if (symbol_conf.event_group)
+                len = max(len, evsel->nr_members * fmt->len);
+
+        if (len < (int)strlen(fmt->name))
+                len = strlen(fmt->name);
+
+        return len;
+}
+
+static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+                          struct perf_evsel *evsel)
+{
+        int len = hpp__width_fn(fmt, hpp, evsel);
+        return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name);
 }
 
 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
@@ -221,11 +236,12 @@ static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
         va_list args;
         ssize_t ssize = hpp->size;
         double percent;
-        int ret;
+        int ret, len;
 
         va_start(args, fmt);
+        len = va_arg(args, int);
         percent = va_arg(args, double);
-        ret = value_color_snprintf(hpp->buf, hpp->size, fmt, percent);
+        ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent);
         va_end(args);
 
         return (ret >= ssize) ? (ssize - 1) : ret;
@@ -250,20 +266,19 @@ static u64 he_get_##_field(struct hist_entry *he)				\
         return he->stat._field;                                                 \
 }                                                                               \
                                                                                 \
-static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,          \
+static int hpp__color_##_type(struct perf_hpp_fmt *fmt,                         \
                               struct perf_hpp *hpp, struct hist_entry *he)      \
 {                                                                               \
-        return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%",                 \
-                          hpp_color_scnprintf, true);                           \
+        return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",              \
+                        hpp_color_scnprintf, true);                             \
 }
 
 #define __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
-static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
+static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,                         \
                               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,                        \
-                          hpp_entry_scnprintf, true);                           \
+        return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",              \
+                        hpp_entry_scnprintf, true);                             \
 }
 
 #define __HPP_SORT_FN(_type, _field)                                            \
@@ -278,20 +293,19 @@ static u64 he_get_acc_##_field(struct hist_entry *he)				\
         return he->stat_acc->_field;                                            \
 }                                                                               \
                                                                                 \
-static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,          \
+static int hpp__color_##_type(struct perf_hpp_fmt *fmt,                         \
                               struct perf_hpp *hpp, struct hist_entry *he)      \
 {                                                                               \
-        return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, " %6.2f%%",         \
-                              hpp_color_scnprintf, true);                       \
+        return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",      \
+                            hpp_color_scnprintf, true);                         \
 }
 
 #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)                               \
-static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
+static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,                         \
                               struct perf_hpp *hpp, struct hist_entry *he)      \
 {                                                                               \
-        const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%";         \
-        return __hpp__fmt_acc(hpp, he, he_get_acc_##_field, fmt,                \
-                              hpp_entry_scnprintf, true);                       \
+        return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",      \
+                            hpp_entry_scnprintf, true);                         \
 }
 
 #define __HPP_SORT_ACC_FN(_type, _field)                                        \
@@ -306,12 +320,11 @@ static u64 he_get_raw_##_field(struct hist_entry *he)				\
         return he->stat._field;                                                 \
 }                                                                               \
                                                                                 \
-static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
+static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,                         \
                               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,                    \
-                          hpp_entry_scnprintf, false);                          \
+        return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64,         \
+                        hpp_entry_scnprintf, false);                            \
 }
 
 #define __HPP_SORT_RAW_FN(_type, _field)                                        \
@@ -321,37 +334,29 @@ static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)	\
 }
 
 
-#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)                          \
+#define HPP_PERCENT_FNS(_type, _field)                                  \
 __HPP_COLOR_PERCENT_FN(_type, _field)                                   \
 __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
 __HPP_SORT_FN(_type, _field)
 
-#define HPP_PERCENT_ACC_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)                          \
+#define HPP_PERCENT_ACC_FNS(_type, _field)                              \
 __HPP_COLOR_ACC_PERCENT_FN(_type, _field)                               \
 __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)                               \
 __HPP_SORT_ACC_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)                          \
+#define HPP_RAW_FNS(_type, _field)                                      \
 __HPP_ENTRY_RAW_FN(_type, _field)                                       \
 __HPP_SORT_RAW_FN(_type, _field)
 
-__HPP_HEADER_FN(overhead_self, "Self", 8, 8)
-
-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_PERCENT_ACC_FNS(overhead_acc, "Children", period, 8, 8)
+HPP_PERCENT_FNS(overhead, period)
+HPP_PERCENT_FNS(overhead_sys, period_sys)
+HPP_PERCENT_FNS(overhead_us, period_us)
+HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys)
+HPP_PERCENT_FNS(overhead_guest_us, period_guest_us)
+HPP_PERCENT_ACC_FNS(overhead_acc, period)
 
-HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12)
-HPP_RAW_FNS(period, "Period", period, 12, 12)
+HPP_RAW_FNS(samples, nr_events)
+HPP_RAW_FNS(period, period)
 
 static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused,
                             struct hist_entry *b __maybe_unused)
@@ -359,47 +364,50 @@ static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused,
         return 0;
 }
 
-#define HPP__COLOR_PRINT_FNS(_name)                     \
+#define HPP__COLOR_PRINT_FNS(_name, _fn)                \
         {                                               \
-                .header = hpp__header_ ## _name,        \
-                .width  = hpp__width_ ## _name,         \
-                .color  = hpp__color_ ## _name,         \
-                .entry  = hpp__entry_ ## _name,         \
+                .name   = _name,                        \
+                .header = hpp__header_fn,               \
+                .width  = hpp__width_fn,                \
+                .color  = hpp__color_ ## _fn,           \
+                .entry  = hpp__entry_ ## _fn,           \
                 .cmp    = hpp__nop_cmp,                 \
                 .collapse = hpp__nop_cmp,               \
-                .sort   = hpp__sort_ ## _name,          \
+                .sort   = hpp__sort_ ## _fn,            \
         }
 
-#define HPP__COLOR_ACC_PRINT_FNS(_name)                 \
+#define HPP__COLOR_ACC_PRINT_FNS(_name, _fn)            \
         {                                               \
-                .header = hpp__header_ ## _name,        \
-                .width  = hpp__width_ ## _name,         \
-                .color  = hpp__color_ ## _name,         \
-                .entry  = hpp__entry_ ## _name,         \
+                .name   = _name,                        \
+                .header = hpp__header_fn,               \
+                .width  = hpp__width_fn,                \
+                .color  = hpp__color_ ## _fn,           \
+                .entry  = hpp__entry_ ## _fn,           \
                 .cmp    = hpp__nop_cmp,                 \
                 .collapse = hpp__nop_cmp,               \
-                .sort   = hpp__sort_ ## _name,          \
+                .sort   = hpp__sort_ ## _fn,            \
         }
 
-#define HPP__PRINT_FNS(_name)                           \
+#define HPP__PRINT_FNS(_name, _fn)                      \
         {                                               \
-                .header = hpp__header_ ## _name,        \
-                .width  = hpp__width_ ## _name,         \
-                .entry  = hpp__entry_ ## _name,         \
+                .name   = _name,                        \
+                .header = hpp__header_fn,               \
+                .width  = hpp__width_fn,                \
+                .entry  = hpp__entry_ ## _fn,           \
                 .cmp    = hpp__nop_cmp,                 \
                 .collapse = hpp__nop_cmp,               \
-                .sort   = hpp__sort_ ## _name,          \
+                .sort   = hpp__sort_ ## _fn,            \
         }
 
 struct perf_hpp_fmt perf_hpp__format[] = {
-        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__COLOR_ACC_PRINT_FNS(overhead_acc),
-        HPP__PRINT_FNS(samples),
-        HPP__PRINT_FNS(period)
+        HPP__COLOR_PRINT_FNS("Overhead", overhead),
+        HPP__COLOR_PRINT_FNS("sys", overhead_sys),
+        HPP__COLOR_PRINT_FNS("usr", overhead_us),
+        HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys),
+        HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us),
+        HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc),
+        HPP__PRINT_FNS("Samples", samples),
+        HPP__PRINT_FNS("Period", period)
 };
 
 LIST_HEAD(perf_hpp__list);
@@ -444,14 +452,12 @@ void perf_hpp__init(void)
         /*
          * If user specified field order, no need to setup default fields.
          */
-        if (field_order)
+        if (is_strict_order(field_order))
                 return;
 
         if (symbol_conf.cumulate_callchain) {
                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_ACC);
-
-                perf_hpp__format[PERF_HPP__OVERHEAD].header =
-                                                hpp__header_overhead_self;
+                perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self";
         }
 
         perf_hpp__column_enable(PERF_HPP__OVERHEAD);
@@ -513,11 +519,11 @@ void perf_hpp__column_disable(unsigned col)
 
 void perf_hpp__cancel_cumulate(void)
 {
-        if (field_order)
+        if (is_strict_order(field_order))
                 return;
 
         perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
-        perf_hpp__format[PERF_HPP__OVERHEAD].header = hpp__header_overhead;
+        perf_hpp__format[PERF_HPP__OVERHEAD].name = "Overhead";
 }
 
 void perf_hpp__setup_output_field(void)
@@ -622,3 +628,59 @@ unsigned int hists__sort_list_width(struct hists *hists)
 
         return ret;
 }
+
+void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
+{
+        int idx;
+
+        if (perf_hpp__is_sort_entry(fmt))
+                return perf_hpp__reset_sort_width(fmt, hists);
+
+        for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
+                if (fmt == &perf_hpp__format[idx])
+                        break;
+        }
+
+        if (idx == PERF_HPP__MAX_INDEX)
+                return;
+
+        switch (idx) {
+        case PERF_HPP__OVERHEAD:
+        case PERF_HPP__OVERHEAD_SYS:
+        case PERF_HPP__OVERHEAD_US:
+        case PERF_HPP__OVERHEAD_ACC:
+                fmt->len = 8;
+                break;
+
+        case PERF_HPP__OVERHEAD_GUEST_SYS:
+        case PERF_HPP__OVERHEAD_GUEST_US:
+                fmt->len = 9;
+                break;
+
+        case PERF_HPP__SAMPLES:
+        case PERF_HPP__PERIOD:
+                fmt->len = 12;
+                break;
+
+        default:
+                break;
+        }
+}
+
+void perf_hpp__set_user_width(const char *width_list_str)
+{
+        struct perf_hpp_fmt *fmt;
+        const char *ptr = width_list_str;
+
+        perf_hpp__for_each_format(fmt) {
+                char *p;
+
+                int len = strtol(ptr, &p, 10);
+                fmt->user_len = len;
+
+                if (*p == ',')
+                        ptr = p + 1;
+                else
+                        break;
+        }
+}
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index 40af0acb4fe9..15b451acbde6 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -395,10 +395,12 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
 
         init_rem_hits();
 
-
         perf_hpp__for_each_format(fmt)
                 perf_hpp__reset_width(fmt, hists);
 
+        if (symbol_conf.col_width_list_str)
+                perf_hpp__set_user_width(symbol_conf.col_width_list_str);
+
         if (!show_header)
                 goto print_entries;
 
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 809b4c50beae..36437527dbb3 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -232,9 +232,16 @@ static int mov__parse(struct ins_operands *ops)
                 return -1;
 
         target = ++s;
+        comment = strchr(s, '#');
 
-        while (s[0] != '\0' && !isspace(s[0]))
-                ++s;
+        if (comment != NULL)
+                s = comment - 1;
+        else
+                s = strchr(s, '\0') - 1;
+
+        while (s > target && isspace(s[0]))
+                --s;
+        s++;
         prev = *s;
         *s = '\0';
 
@@ -244,7 +251,6 @@ static int mov__parse(struct ins_operands *ops)
         if (ops->target.raw == NULL)
                 goto out_free_source;
 
-        comment = strchr(s, '#');
         if (comment == NULL)
                 return 0;
 
@@ -899,10 +905,8 @@ int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize)
         struct kcore_extract kce;
         bool delete_extract = false;
 
-        if (filename) {
-                snprintf(symfs_filename, sizeof(symfs_filename), "%s%s",
-                         symbol_conf.symfs, filename);
-        }
+        if (filename)
+                symbol__join_symfs(symfs_filename, filename);
 
         if (filename == NULL) {
                 if (dso->has_build_id) {
@@ -922,8 +926,7 @@ fallback:
                  * DSO is the same as when 'perf record' ran.
                  */
                 filename = (char *)dso->long_name;
-                snprintf(symfs_filename, sizeof(symfs_filename), "%s%s",
-                         symbol_conf.symfs, filename);
+                symbol__join_symfs(symfs_filename, filename);
                 free_filename = false;
         }
 
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 7b176dd02e1a..5cf9e1b5989d 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -22,6 +22,7 @@ typedef int (*config_fn_t)(const char *, const char *, void *);
 extern int perf_default_config(const char *, const char *, void *);
 extern int perf_config(config_fn_t fn, void *);
 extern int perf_config_int(const char *, const char *);
+extern u64 perf_config_u64(const char *, const char *);
 extern int perf_config_bool(const char *, const char *);
 extern int config_error_nonbool(const char *);
 extern const char *perf_config_dirname(const char *, const char *);
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 437ee09727e6..c84d3f8dcb75 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -25,77 +25,172 @@
 
 __thread struct callchain_cursor callchain_cursor;
 
-int
-parse_callchain_report_opt(const char *arg)
+#ifdef HAVE_DWARF_UNWIND_SUPPORT
+static int get_stack_size(const char *str, unsigned long *_size)
 {
-        char *tok, *tok2;
         char *endptr;
+        unsigned long size;
+        unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
 
-        symbol_conf.use_callchain = true;
+        size = strtoul(str, &endptr, 0);
 
-        if (!arg)
+        do {
+                if (*endptr)
+                        break;
+
+                size = round_up(size, sizeof(u64));
+                if (!size || size > max_size)
+                        break;
+
+                *_size = size;
                 return 0;
 
-        tok = strtok((char *)arg, ",");
-        if (!tok)
-                return -1;
+        } while (0);
 
-        /* get the output mode */
-        if (!strncmp(tok, "graph", strlen(arg))) {
-                callchain_param.mode = CHAIN_GRAPH_ABS;
+        pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
+               max_size, str);
+        return -1;
+}
+#endif /* HAVE_DWARF_UNWIND_SUPPORT */
 
-        } 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;
-        }
+int parse_callchain_record_opt(const char *arg)
+{
+        char *tok, *name, *saveptr = NULL;
+        char *buf;
+        int ret = -1;
+
+        /* We need buffer that we know we can write to. */
+        buf = malloc(strlen(arg) + 1);
+        if (!buf)
+                return -ENOMEM;
+
+        strcpy(buf, arg);
+
+        tok = strtok_r((char *)buf, ",", &saveptr);
+        name = tok ? : (char *)buf;
+
+        do {
+                /* Framepointer style */
+                if (!strncmp(name, "fp", sizeof("fp"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                callchain_param.record_mode = CALLCHAIN_FP;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                       "needed for -g fp\n");
+                        break;
 
-        /* get the min percentage */
-        tok = strtok(NULL, ",");
-        if (!tok)
-                goto setup;
+#ifdef HAVE_DWARF_UNWIND_SUPPORT
+                /* Dwarf style */
+                } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
+                        const unsigned long default_stack_dump_size = 8192;
 
-        callchain_param.min_percent = strtod(tok, &endptr);
-        if (tok == endptr)
-                return -1;
+                        ret = 0;
+                        callchain_param.record_mode = CALLCHAIN_DWARF;
+                        callchain_param.dump_size = default_stack_dump_size;
 
-        /* get the print limit */
-        tok2 = strtok(NULL, ",");
-        if (!tok2)
-                goto setup;
+                        tok = strtok_r(NULL, ",", &saveptr);
+                        if (tok) {
+                                unsigned long size = 0;
 
-        if (tok2[0] != 'c') {
-                callchain_param.print_limit = strtoul(tok2, &endptr, 0);
-                tok2 = strtok(NULL, ",");
-                if (!tok2)
-                        goto setup;
+                                ret = get_stack_size(tok, &size);
+                                callchain_param.dump_size = size;
+                        }
+#endif /* HAVE_DWARF_UNWIND_SUPPORT */
+                } else {
+                        pr_err("callchain: Unknown --call-graph option "
+                               "value: %s\n", arg);
+                        break;
+                }
+
+        } while (0);
+
+        free(buf);
+        return ret;
+}
+
+static int parse_callchain_mode(const char *value)
+{
+        if (!strncmp(value, "graph", strlen(value))) {
+                callchain_param.mode = CHAIN_GRAPH_ABS;
+                return 0;
+        }
+        if (!strncmp(value, "flat", strlen(value))) {
+                callchain_param.mode = CHAIN_FLAT;
+                return 0;
         }
+        if (!strncmp(value, "fractal", strlen(value))) {
+                callchain_param.mode = CHAIN_GRAPH_REL;
+                return 0;
+        }
+        return -1;
+}
 
-        /* get the call chain order */
-        if (!strncmp(tok2, "caller", strlen("caller")))
+static int parse_callchain_order(const char *value)
+{
+        if (!strncmp(value, "caller", strlen(value))) {
                 callchain_param.order = ORDER_CALLER;
-        else if (!strncmp(tok2, "callee", strlen("callee")))
+                return 0;
+        }
+        if (!strncmp(value, "callee", strlen(value))) {
                 callchain_param.order = ORDER_CALLEE;
-        else
-                return -1;
+                return 0;
+        }
+        return -1;
+}
 
-        /* Get the sort key */
-        tok2 = strtok(NULL, ",");
-        if (!tok2)
-                goto setup;
-        if (!strncmp(tok2, "function", strlen("function")))
+static int parse_callchain_sort_key(const char *value)
+{
+        if (!strncmp(value, "function", strlen(value))) {
                 callchain_param.key = CCKEY_FUNCTION;
-        else if (!strncmp(tok2, "address", strlen("address")))
+                return 0;
+        }
+        if (!strncmp(value, "address", strlen(value))) {
                 callchain_param.key = CCKEY_ADDRESS;
-        else
-                return -1;
-setup:
+                return 0;
+        }
+        return -1;
+}
+
+int
+parse_callchain_report_opt(const char *arg)
+{
+        char *tok;
+        char *endptr;
+        bool minpcnt_set = false;
+
+        symbol_conf.use_callchain = true;
+
+        if (!arg)
+                return 0;
+
+        while ((tok = strtok((char *)arg, ",")) != NULL) {
+                if (!strncmp(tok, "none", strlen(tok))) {
+                        callchain_param.mode = CHAIN_NONE;
+                        symbol_conf.use_callchain = false;
+                        return 0;
+                }
+
+                if (!parse_callchain_mode(tok) ||
+                    !parse_callchain_order(tok) ||
+                    !parse_callchain_sort_key(tok)) {
+                        /* parsing ok - move on to the next */
+                } else if (!minpcnt_set) {
+                        /* try to get the min percent */
+                        callchain_param.min_percent = strtod(tok, &endptr);
+                        if (tok == endptr)
+                                return -1;
+                        minpcnt_set = true;
+                } else {
+                        /* try print limit at last */
+                        callchain_param.print_limit = strtoul(tok, &endptr, 0);
+                        if (tok == endptr)
+                                return -1;
+                }
+
+                arg = NULL;
+        }
+
         if (callchain_register_param(&callchain_param) < 0) {
                 pr_err("Can't register callchain params\n");
                 return -1;
@@ -103,6 +198,47 @@ setup:
         return 0;
 }
 
+int perf_callchain_config(const char *var, const char *value)
+{
+        char *endptr;
+
+        if (prefixcmp(var, "call-graph."))
+                return 0;
+        var += sizeof("call-graph.") - 1;
+
+        if (!strcmp(var, "record-mode"))
+                return parse_callchain_record_opt(value);
+#ifdef HAVE_DWARF_UNWIND_SUPPORT
+        if (!strcmp(var, "dump-size")) {
+                unsigned long size = 0;
+                int ret;
+
+                ret = get_stack_size(value, &size);
+                callchain_param.dump_size = size;
+
+                return ret;
+        }
+#endif
+        if (!strcmp(var, "print-type"))
+                return parse_callchain_mode(value);
+        if (!strcmp(var, "order"))
+                return parse_callchain_order(value);
+        if (!strcmp(var, "sort-key"))
+                return parse_callchain_sort_key(value);
+        if (!strcmp(var, "threshold")) {
+                callchain_param.min_percent = strtod(value, &endptr);
+                if (value == endptr)
+                        return -1;
+        }
+        if (!strcmp(var, "print-limit")) {
+                callchain_param.print_limit = strtod(value, &endptr);
+                if (value == endptr)
+                        return -1;
+        }
+
+        return 0;
+}
+
 static void
 rb_insert_callchain(struct rb_root *root, struct callchain_node *chain,
                     enum chain_mode mode)
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index da43619d6173..2a1f5a46543a 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -54,6 +54,9 @@ enum chain_key {
 };
 
 struct callchain_param {
+        bool                    enabled;
+        enum perf_call_graph_mode record_mode;
+        u32                     dump_size;
         enum chain_mode         mode;
         u32                     print_limit;
         double                  min_percent;
@@ -154,7 +157,6 @@ static inline void callchain_cursor_advance(struct callchain_cursor *cursor)
 struct option;
 struct hist_entry;
 
-int record_parse_callchain(const char *arg, struct record_opts *opts);
 int record_parse_callchain_opt(const struct option *opt, const char *arg, int unset);
 int record_callchain_opt(const struct option *opt, const char *arg, int unset);
 
@@ -166,7 +168,9 @@ int fill_callchain_info(struct addr_location *al, struct callchain_cursor_node *
                         bool hide_unresolved);
 
 extern const char record_callchain_help[];
+int parse_callchain_record_opt(const char *arg);
 int parse_callchain_report_opt(const char *arg);
+int perf_callchain_config(const char *var, const char *value);
 
 static inline void callchain_cursor_snapshot(struct callchain_cursor *dest,
                                              struct callchain_cursor *src)
diff --git a/tools/perf/util/cloexec.c b/tools/perf/util/cloexec.c
index c5d05ec17220..47b78b3f0325 100644
--- a/tools/perf/util/cloexec.c
+++ b/tools/perf/util/cloexec.c
@@ -1,7 +1,9 @@
+#include <sched.h>
 #include "util.h"
 #include "../perf.h"
 #include "cloexec.h"
 #include "asm/bug.h"
+#include "debug.h"
 
 static unsigned long flag = PERF_FLAG_FD_CLOEXEC;
 
@@ -9,15 +11,30 @@ static int perf_flag_probe(void)
 {
         /* use 'safest' configuration as used in perf_evsel__fallback() */
         struct perf_event_attr attr = {
-                .type = PERF_COUNT_SW_CPU_CLOCK,
+                .type = PERF_TYPE_SOFTWARE,
                 .config = PERF_COUNT_SW_CPU_CLOCK,
+                .exclude_kernel = 1,
         };
         int fd;
         int err;
+        int cpu;
+        pid_t pid = -1;
+        char sbuf[STRERR_BUFSIZE];
 
-        /* check cloexec flag */
-        fd = sys_perf_event_open(&attr, 0, -1, -1,
-                                 PERF_FLAG_FD_CLOEXEC);
+        cpu = sched_getcpu();
+        if (cpu < 0)
+                cpu = 0;
+
+        while (1) {
+                /* check cloexec flag */
+                fd = sys_perf_event_open(&attr, pid, cpu, -1,
+                                         PERF_FLAG_FD_CLOEXEC);
+                if (fd < 0 && pid == -1 && errno == EACCES) {
+                        pid = 0;
+                        continue;
+                }
+                break;
+        }
         err = errno;
 
         if (fd >= 0) {
@@ -25,17 +42,17 @@ static int perf_flag_probe(void)
                 return 1;
         }
 
-        WARN_ONCE(err != EINVAL,
+        WARN_ONCE(err != EINVAL && err != EBUSY,
                   "perf_event_open(..., PERF_FLAG_FD_CLOEXEC) failed with unexpected error %d (%s)\n",
-                  err, strerror(err));
+                  err, strerror_r(err, sbuf, sizeof(sbuf)));
 
         /* not supported, confirm error related to PERF_FLAG_FD_CLOEXEC */
-        fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
+        fd = sys_perf_event_open(&attr, pid, cpu, -1, 0);
         err = errno;
 
-        if (WARN_ONCE(fd < 0,
+        if (WARN_ONCE(fd < 0 && err != EBUSY,
                       "perf_event_open(..., 0) failed unexpectedly with error %d (%s)\n",
-                      err, strerror(err)))
+                      err, strerror_r(err, sbuf, sizeof(sbuf))))
                 return -1;
 
         close(fd);
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index 87b8672eb413..f4654183d391 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -335,3 +335,19 @@ int percent_color_snprintf(char *bf, size_t size, const char *fmt, ...)
         va_end(args);
         return value_color_snprintf(bf, size, fmt, percent);
 }
+
+int percent_color_len_snprintf(char *bf, size_t size, const char *fmt, ...)
+{
+        va_list args;
+        int len;
+        double percent;
+        const char *color;
+
+        va_start(args, fmt);
+        len = va_arg(args, int);
+        percent = va_arg(args, double);
+        va_end(args);
+
+        color = get_percent_color(percent);
+        return color_snprintf(bf, size, color, fmt, len, percent);
+}
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 7ff30a62a132..0a594b8a0c26 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -41,6 +41,7 @@ int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...);
 int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
 int value_color_snprintf(char *bf, size_t size, const char *fmt, double value);
 int percent_color_snprintf(char *bf, size_t size, const char *fmt, ...);
+int percent_color_len_snprintf(char *bf, size_t size, const char *fmt, ...);
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
 const char *get_percent_color(double percent);
 
diff --git a/tools/perf/util/comm.c b/tools/perf/util/comm.c
index f9e777629e21..b2bb59df65e1 100644
--- a/tools/perf/util/comm.c
+++ b/tools/perf/util/comm.c
@@ -74,7 +74,7 @@ static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
         return new;
 }
 
-struct comm *comm__new(const char *str, u64 timestamp)
+struct comm *comm__new(const char *str, u64 timestamp, bool exec)
 {
         struct comm *comm = zalloc(sizeof(*comm));
 
@@ -82,6 +82,7 @@ struct comm *comm__new(const char *str, u64 timestamp)
                 return NULL;
 
         comm->start = timestamp;
+        comm->exec = exec;
 
         comm->comm_str = comm_str__findnew(str, &comm_str_root);
         if (!comm->comm_str) {
@@ -94,7 +95,7 @@ struct comm *comm__new(const char *str, u64 timestamp)
         return comm;
 }
 
-int comm__override(struct comm *comm, const char *str, u64 timestamp)
+int comm__override(struct comm *comm, const char *str, u64 timestamp, bool exec)
 {
         struct comm_str *new, *old = comm->comm_str;
 
@@ -106,6 +107,8 @@ int comm__override(struct comm *comm, const char *str, u64 timestamp)
         comm_str__put(old);
         comm->comm_str = new;
         comm->start = timestamp;
+        if (exec)
+                comm->exec = true;
 
         return 0;
 }
diff --git a/tools/perf/util/comm.h b/tools/perf/util/comm.h
index fac5bd51befc..51c10ab257f8 100644
--- a/tools/perf/util/comm.h
+++ b/tools/perf/util/comm.h
@@ -11,11 +11,13 @@ struct comm {
         struct comm_str *comm_str;
         u64 start;
         struct list_head list;
+        bool exec;
 };
 
 void comm__free(struct comm *comm);
-struct comm *comm__new(const char *str, u64 timestamp);
+struct comm *comm__new(const char *str, u64 timestamp, bool exec);
 const char *comm__str(const struct comm *comm);
-int comm__override(struct comm *comm, const char *str, u64 timestamp);
+int comm__override(struct comm *comm, const char *str, u64 timestamp,
+                   bool exec);
 
 #endif  /* __PERF_COMM_H */
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 1e5e2e5af6b1..57ff826f150b 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -222,7 +222,8 @@ static int perf_parse_file(config_fn_t fn, void *data)
         const unsigned char *bomptr = utf8_bom;
 
         for (;;) {
-                int c = get_next_char();
+                int line, c = get_next_char();
+
                 if (bomptr && *bomptr) {
                         /* We are at the file beginning; skip UTF8-encoded BOM
                          * if present. Sane editors won't put this in on their
@@ -261,8 +262,16 @@ static int perf_parse_file(config_fn_t fn, void *data)
                 if (!isalpha(c))
                         break;
                 var[baselen] = tolower(c);
-                if (get_value(fn, data, var, baselen+1) < 0)
+
+                /*
+                 * The get_value function might or might not reach the '\n',
+                 * so saving the current line number for error reporting.
+                 */
+                line = config_linenr;
+                if (get_value(fn, data, var, baselen+1) < 0) {
+                        config_linenr = line;
                         break;
+                }
         }
         die("bad config file line %d in %s", config_linenr, config_file_name);
 }
@@ -286,6 +295,21 @@ static int parse_unit_factor(const char *end, unsigned long *val)
         return 0;
 }
 
+static int perf_parse_llong(const char *value, long long *ret)
+{
+        if (value && *value) {
+                char *end;
+                long long val = strtoll(value, &end, 0);
+                unsigned long factor = 1;
+
+                if (!parse_unit_factor(end, &factor))
+                        return 0;
+                *ret = val * factor;
+                return 1;
+        }
+        return 0;
+}
+
 static int perf_parse_long(const char *value, long *ret)
 {
         if (value && *value) {
@@ -307,6 +331,15 @@ static void die_bad_config(const char *name)
         die("bad config value for '%s'", name);
 }
 
+u64 perf_config_u64(const char *name, const char *value)
+{
+        long long ret = 0;
+
+        if (!perf_parse_llong(value, &ret))
+                die_bad_config(name);
+        return (u64) ret;
+}
+
 int perf_config_int(const char *name, const char *value)
 {
         long ret = 0;
@@ -372,6 +405,9 @@ int perf_default_config(const char *var, const char *value,
         if (!prefixcmp(var, "ui."))
                 return perf_ui_config(var, value);
 
+        if (!prefixcmp(var, "call-graph."))
+                return perf_callchain_config(var, value);
+
         /* Add other config variables here. */
         return 0;
 }
diff --git a/tools/perf/util/data.c b/tools/perf/util/data.c
index 29d720cf5844..1921942fc2e0 100644
--- a/tools/perf/util/data.c
+++ b/tools/perf/util/data.c
@@ -50,12 +50,14 @@ static int open_file_read(struct perf_data_file *file)
 {
         struct stat st;
         int fd;
+        char sbuf[STRERR_BUFSIZE];
 
         fd = open(file->path, O_RDONLY);
         if (fd < 0) {
                 int err = errno;
 
-                pr_err("failed to open %s: %s", file->path, strerror(err));
+                pr_err("failed to open %s: %s", file->path,
+                        strerror_r(err, sbuf, sizeof(sbuf)));
                 if (err == ENOENT && !strcmp(file->path, "perf.data"))
                         pr_err("  (try 'perf record' first)");
                 pr_err("\n");
@@ -88,6 +90,7 @@ static int open_file_read(struct perf_data_file *file)
 static int open_file_write(struct perf_data_file *file)
 {
         int fd;
+        char sbuf[STRERR_BUFSIZE];
 
         if (check_backup(file))
                 return -1;
@@ -95,7 +98,8 @@ static int open_file_write(struct perf_data_file *file)
         fd = open(file->path, O_CREAT|O_RDWR|O_TRUNC, S_IRUSR|S_IWUSR);
 
         if (fd < 0)
-                pr_err("failed to open %s : %s\n", file->path, strerror(errno));
+                pr_err("failed to open %s : %s\n", file->path,
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
 
         return fd;
 }
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 71d419362634..ba357f3226c6 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -13,8 +13,12 @@
 #include "util.h"
 #include "target.h"
 
+#define NSECS_PER_SEC  1000000000ULL
+#define NSECS_PER_USEC 1000ULL
+
 int verbose;
 bool dump_trace = false, quiet = false;
+int debug_ordered_events;
 
 static int _eprintf(int level, int var, const char *fmt, va_list args)
 {
@@ -42,6 +46,35 @@ int eprintf(int level, int var, const char *fmt, ...)
         return ret;
 }
 
+static int __eprintf_time(u64 t, const char *fmt, va_list args)
+{
+        int ret = 0;
+        u64 secs, usecs, nsecs = t;
+
+        secs   = nsecs / NSECS_PER_SEC;
+        nsecs -= secs  * NSECS_PER_SEC;
+        usecs  = nsecs / NSECS_PER_USEC;
+
+        ret = fprintf(stderr, "[%13" PRIu64 ".%06" PRIu64 "] ",
+                      secs, usecs);
+        ret += vfprintf(stderr, fmt, args);
+        return ret;
+}
+
+int eprintf_time(int level, int var, u64 t, const char *fmt, ...)
+{
+        int ret = 0;
+        va_list args;
+
+        if (var >= level) {
+                va_start(args, fmt);
+                ret = __eprintf_time(t, fmt, args);
+                va_end(args);
+        }
+
+        return ret;
+}
+
 /*
  * Overloading libtraceevent standard info print
  * function, display with -v in perf.
@@ -110,7 +143,8 @@ static struct debug_variable {
         const char *name;
         int *ptr;
 } debug_variables[] = {
-        { .name = "verbose", .ptr = &verbose },
+        { .name = "verbose",            .ptr = &verbose },
+        { .name = "ordered-events",     .ptr = &debug_ordered_events},
         { .name = NULL, }
 };
 
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 89fb6b0f7ab2..be264d6f3b30 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -3,6 +3,7 @@
 #define __PERF_DEBUG_H
 
 #include <stdbool.h>
+#include <string.h>
 #include "event.h"
 #include "../ui/helpline.h"
 #include "../ui/progress.h"
@@ -10,6 +11,7 @@
 
 extern int verbose;
 extern bool quiet, dump_trace;
+extern int debug_ordered_events;
 
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
@@ -29,6 +31,14 @@ extern bool quiet, dump_trace;
 #define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
 
+#define pr_time_N(n, var, t, fmt, ...) \
+        eprintf_time(n, var, t, fmt, ##__VA_ARGS__)
+
+#define pr_oe_time(t, fmt, ...)  pr_time_N(1, debug_ordered_events, t, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_oe_time2(t, fmt, ...) pr_time_N(2, debug_ordered_events, t, pr_fmt(fmt), ##__VA_ARGS__)
+
+#define STRERR_BUFSIZE  128     /* For the buffer size of strerror_r */
+
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(union perf_event *event);
 
@@ -38,6 +48,7 @@ int ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));
 void pr_stat(const char *fmt, ...);
 
 int eprintf(int level, int var, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
+int eprintf_time(int level, int var, u64 t, const char *fmt, ...) __attribute__((format(printf, 4, 5)));
 
 int perf_debug_option(const char *str);
 
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index 90d02c661dd4..0247acfdfaca 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -37,6 +37,7 @@ int dso__read_binary_type_filename(const struct dso *dso,
 {
         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
         int ret = 0;
+        size_t len;
 
         switch (type) {
         case DSO_BINARY_TYPE__DEBUGLINK: {
@@ -60,26 +61,25 @@ int dso__read_binary_type_filename(const struct dso *dso,
                 break;
 
         case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
-                snprintf(filename, size, "%s/usr/lib/debug%s.debug",
-                         symbol_conf.symfs, dso->long_name);
+                len = __symbol__join_symfs(filename, size, "/usr/lib/debug");
+                snprintf(filename + len, size - len, "%s.debug", dso->long_name);
                 break;
 
         case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
-                snprintf(filename, size, "%s/usr/lib/debug%s",
-                         symbol_conf.symfs, dso->long_name);
+                len = __symbol__join_symfs(filename, size, "/usr/lib/debug");
+                snprintf(filename + len, size - len, "%s", dso->long_name);
                 break;
 
         case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
         {
                 const char *last_slash;
-                size_t len;
                 size_t dir_size;
 
                 last_slash = dso->long_name + dso->long_name_len;
                 while (last_slash != dso->long_name && *last_slash != '/')
                         last_slash--;
 
-                len = scnprintf(filename, size, "%s", symbol_conf.symfs);
+                len = __symbol__join_symfs(filename, size, "");
                 dir_size = last_slash - dso->long_name + 2;
                 if (dir_size > (size - len)) {
                         ret = -1;
@@ -100,26 +100,24 @@ int dso__read_binary_type_filename(const struct dso *dso,
                 build_id__sprintf(dso->build_id,
                                   sizeof(dso->build_id),
                                   build_id_hex);
-                snprintf(filename, size,
-                         "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
-                         symbol_conf.symfs, build_id_hex, build_id_hex + 2);
+                len = __symbol__join_symfs(filename, size, "/usr/lib/debug/.build-id/");
+                snprintf(filename + len, size - len, "%.2s/%s.debug",
+                         build_id_hex, build_id_hex + 2);
                 break;
 
         case DSO_BINARY_TYPE__VMLINUX:
         case DSO_BINARY_TYPE__GUEST_VMLINUX:
         case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
-                snprintf(filename, size, "%s%s",
-                         symbol_conf.symfs, dso->long_name);
+                __symbol__join_symfs(filename, size, dso->long_name);
                 break;
 
         case DSO_BINARY_TYPE__GUEST_KMODULE:
-                snprintf(filename, size, "%s%s%s", symbol_conf.symfs,
-                         root_dir, dso->long_name);
+                path__join3(filename, size, symbol_conf.symfs,
+                            root_dir, dso->long_name);
                 break;
 
         case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
-                snprintf(filename, size, "%s%s", symbol_conf.symfs,
-                         dso->long_name);
+                __symbol__join_symfs(filename, size, dso->long_name);
                 break;
 
         case DSO_BINARY_TYPE__KCORE:
@@ -164,13 +162,15 @@ static void close_first_dso(void);
 static int do_open(char *name)
 {
         int fd;
+        char sbuf[STRERR_BUFSIZE];
 
         do {
                 fd = open(name, O_RDONLY);
                 if (fd >= 0)
                         return fd;
 
-                pr_debug("dso open failed, mmap: %s\n", strerror(errno));
+                pr_debug("dso open failed, mmap: %s\n",
+                         strerror_r(errno, sbuf, sizeof(sbuf)));
                 if (!dso__data_open_cnt || errno != EMFILE)
                         break;
 
@@ -532,10 +532,12 @@ static ssize_t cached_read(struct dso *dso, u64 offset, u8 *data, ssize_t size)
 static int data_file_size(struct dso *dso)
 {
         struct stat st;
+        char sbuf[STRERR_BUFSIZE];
 
         if (!dso->data.file_size) {
                 if (fstat(dso->data.fd, &st)) {
-                        pr_err("dso mmap failed, fstat: %s\n", strerror(errno));
+                        pr_err("dso mmap failed, fstat: %s\n",
+                                strerror_r(errno, sbuf, sizeof(sbuf)));
                         return -1;
                 }
                 dso->data.file_size = st.st_size;
@@ -651,6 +653,65 @@ struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
         return dso;
 }
 
+/*
+ * Find a matching entry and/or link current entry to RB tree.
+ * Either one of the dso or name parameter must be non-NULL or the
+ * function will not work.
+ */
+static struct dso *dso__findlink_by_longname(struct rb_root *root,
+                                             struct dso *dso, const char *name)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node  *parent = NULL;
+
+        if (!name)
+                name = dso->long_name;
+        /*
+         * Find node with the matching name
+         */
+        while (*p) {
+                struct dso *this = rb_entry(*p, struct dso, rb_node);
+                int rc = strcmp(name, this->long_name);
+
+                parent = *p;
+                if (rc == 0) {
+                        /*
+                         * In case the new DSO is a duplicate of an existing
+                         * one, print an one-time warning & put the new entry
+                         * at the end of the list of duplicates.
+                         */
+                        if (!dso || (dso == this))
+                                return this;    /* Find matching dso */
+                        /*
+                         * The core kernel DSOs may have duplicated long name.
+                         * In this case, the short name should be different.
+                         * Comparing the short names to differentiate the DSOs.
+                         */
+                        rc = strcmp(dso->short_name, this->short_name);
+                        if (rc == 0) {
+                                pr_err("Duplicated dso name: %s\n", name);
+                                return NULL;
+                        }
+                }
+                if (rc < 0)
+                        p = &parent->rb_left;
+                else
+                        p = &parent->rb_right;
+        }
+        if (dso) {
+                /* Add new node and rebalance tree */
+                rb_link_node(&dso->rb_node, parent, p);
+                rb_insert_color(&dso->rb_node, root);
+        }
+        return NULL;
+}
+
+static inline struct dso *
+dso__find_by_longname(const struct rb_root *root, const char *name)
+{
+        return dso__findlink_by_longname((struct rb_root *)root, NULL, name);
+}
+
 void dso__set_long_name(struct dso *dso, const char *name, bool name_allocated)
 {
         if (name == NULL)
@@ -753,6 +814,7 @@ struct dso *dso__new(const char *name)
                 dso->a2l_fails = 1;
                 dso->kernel = DSO_TYPE_USER;
                 dso->needs_swap = DSO_SWAP__UNSET;
+                RB_CLEAR_NODE(&dso->rb_node);
                 INIT_LIST_HEAD(&dso->node);
                 INIT_LIST_HEAD(&dso->data.open_entry);
         }
@@ -763,6 +825,10 @@ struct dso *dso__new(const char *name)
 void dso__delete(struct dso *dso)
 {
         int i;
+
+        if (!RB_EMPTY_NODE(&dso->rb_node))
+                pr_err("DSO %s is still in rbtree when being deleted!\n",
+                       dso->long_name);
         for (i = 0; i < MAP__NR_TYPES; ++i)
                 symbols__delete(&dso->symbols[i]);
 
@@ -849,35 +915,34 @@ bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
         return have_build_id;
 }
 
-void dsos__add(struct list_head *head, struct dso *dso)
+void dsos__add(struct dsos *dsos, struct dso *dso)
 {
-        list_add_tail(&dso->node, head);
+        list_add_tail(&dso->node, &dsos->head);
+        dso__findlink_by_longname(&dsos->root, dso, NULL);
 }
 
-struct dso *dsos__find(const struct list_head *head, const char *name, bool cmp_short)
+struct dso *dsos__find(const struct dsos *dsos, const char *name,
+                       bool cmp_short)
 {
         struct dso *pos;
 
         if (cmp_short) {
-                list_for_each_entry(pos, head, node)
+                list_for_each_entry(pos, &dsos->head, node)
                         if (strcmp(pos->short_name, name) == 0)
                                 return pos;
                 return NULL;
         }
-        list_for_each_entry(pos, head, node)
-                if (strcmp(pos->long_name, name) == 0)
-                        return pos;
-        return NULL;
+        return dso__find_by_longname(&dsos->root, name);
 }
 
-struct dso *__dsos__findnew(struct list_head *head, const char *name)
+struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
 {
-        struct dso *dso = dsos__find(head, name, false);
+        struct dso *dso = dsos__find(dsos, name, false);
 
         if (!dso) {
                 dso = dso__new(name);
                 if (dso != NULL) {
-                        dsos__add(head, dso);
+                        dsos__add(dsos, dso);
                         dso__set_basename(dso);
                 }
         }
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index 5e463c0964d4..acb651acc7fd 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -90,8 +90,18 @@ struct dso_cache {
         char data[0];
 };
 
+/*
+ * DSOs are put into both a list for fast iteration and rbtree for fast
+ * long name lookup.
+ */
+struct dsos {
+        struct list_head head;
+        struct rb_root   root;  /* rbtree root sorted by long name */
+};
+
 struct dso {
         struct list_head node;
+        struct rb_node   rb_node;       /* rbtree node sorted by long name */
         struct rb_root   symbols[MAP__NR_TYPES];
         struct rb_root   symbol_names[MAP__NR_TYPES];
         void             *a2l;
@@ -224,10 +234,10 @@ struct map *dso__new_map(const char *name);
 struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
                                 const char *short_name, int dso_type);
 
-void dsos__add(struct list_head *head, struct dso *dso);
-struct dso *dsos__find(const struct list_head *head, const char *name,
+void dsos__add(struct dsos *dsos, struct dso *dso);
+struct dso *dsos__find(const struct dsos *dsos, const char *name,
                        bool cmp_short);
-struct dso *__dsos__findnew(struct list_head *head, const char *name);
+struct dso *__dsos__findnew(struct dsos *dsos, 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,
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 1398c83d896d..4af6b279e34a 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -558,13 +558,17 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
         struct map *map;
         struct kmap *kmap;
         int err;
+        union perf_event *event;
+
+        if (machine->vmlinux_maps[0] == NULL)
+                return -1;
+
         /*
          * We should get this from /sys/kernel/sections/.text, but till that is
          * available use this, and after it is use this as a fallback for older
          * kernels.
          */
-        union perf_event *event = zalloc((sizeof(event->mmap) +
-                                          machine->id_hdr_size));
+        event = zalloc((sizeof(event->mmap) + machine->id_hdr_size));
         if (event == NULL) {
                 pr_debug("Not enough memory synthesizing mmap event "
                          "for kernel modules\n");
@@ -784,9 +788,9 @@ try_again:
                  * "[vdso]" dso, but for now lets use the old trick of looking
                  * in the whole kernel symbol list.
                  */
-                if ((long long)al->addr < 0 &&
-                    cpumode == PERF_RECORD_MISC_USER &&
-                    machine && mg != &machine->kmaps) {
+                if (cpumode == PERF_RECORD_MISC_USER && machine &&
+                    mg != &machine->kmaps &&
+                    machine__kernel_ip(machine, al->addr)) {
                         mg = &machine->kmaps;
                         load_map = true;
                         goto try_again;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 94d6976180da..7eb7107731ec 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -156,6 +156,8 @@ struct perf_sample {
         u32 cpu;
         u32 raw_size;
         u64 data_src;
+        u32 flags;
+        u16 insn_len;
         void *raw_data;
         struct ip_callchain *callchain;
         struct branch_stack *branch_stack;
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 814e954c1318..3cebc9a8d52e 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -25,6 +25,9 @@
 #include <linux/bitops.h>
 #include <linux/hash.h>
 
+static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx);
+static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx);
+
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
 
@@ -37,6 +40,7 @@ void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
                 INIT_HLIST_HEAD(&evlist->heads[i]);
         INIT_LIST_HEAD(&evlist->entries);
         perf_evlist__set_maps(evlist, cpus, threads);
+        fdarray__init(&evlist->pollfd, 64);
         evlist->workload.pid = -1;
 }
 
@@ -102,7 +106,7 @@ static void perf_evlist__purge(struct perf_evlist *evlist)
 void perf_evlist__exit(struct perf_evlist *evlist)
 {
         zfree(&evlist->mmap);
-        zfree(&evlist->pollfd);
+        fdarray__exit(&evlist->pollfd);
 }
 
 void perf_evlist__delete(struct perf_evlist *evlist)
@@ -122,6 +126,7 @@ void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
 {
         list_add_tail(&entry->node, &evlist->entries);
         entry->idx = evlist->nr_entries;
+        entry->tracking = !entry->idx;
 
         if (!evlist->nr_entries++)
                 perf_evlist__set_id_pos(evlist);
@@ -265,17 +270,27 @@ int perf_evlist__add_newtp(struct perf_evlist *evlist,
         return 0;
 }
 
+static int perf_evlist__nr_threads(struct perf_evlist *evlist,
+                                   struct perf_evsel *evsel)
+{
+        if (evsel->system_wide)
+                return 1;
+        else
+                return thread_map__nr(evlist->threads);
+}
+
 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);
+        int nr_threads;
 
         for (cpu = 0; cpu < nr_cpus; cpu++) {
                 evlist__for_each(evlist, pos) {
                         if (!perf_evsel__is_group_leader(pos) || !pos->fd)
                                 continue;
+                        nr_threads = perf_evlist__nr_threads(evlist, pos);
                         for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
                                       PERF_EVENT_IOC_DISABLE, 0);
@@ -288,12 +303,13 @@ 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);
+        int nr_threads;
 
         for (cpu = 0; cpu < nr_cpus; cpu++) {
                 evlist__for_each(evlist, pos) {
                         if (!perf_evsel__is_group_leader(pos) || !pos->fd)
                                 continue;
+                        nr_threads = perf_evlist__nr_threads(evlist, pos);
                         for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
                                       PERF_EVENT_IOC_ENABLE, 0);
@@ -305,12 +321,14 @@ int perf_evlist__disable_event(struct perf_evlist *evlist,
                                struct perf_evsel *evsel)
 {
         int cpu, thread, err;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = perf_evlist__nr_threads(evlist, evsel);
 
         if (!evsel->fd)
                 return 0;
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
-                for (thread = 0; thread < evlist->threads->nr; thread++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
+                for (thread = 0; thread < nr_threads; thread++) {
                         err = ioctl(FD(evsel, cpu, thread),
                                     PERF_EVENT_IOC_DISABLE, 0);
                         if (err)
@@ -324,12 +342,14 @@ int perf_evlist__enable_event(struct perf_evlist *evlist,
                               struct perf_evsel *evsel)
 {
         int cpu, thread, err;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = perf_evlist__nr_threads(evlist, evsel);
 
         if (!evsel->fd)
                 return -EINVAL;
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
-                for (thread = 0; thread < evlist->threads->nr; thread++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
+                for (thread = 0; thread < nr_threads; thread++) {
                         err = ioctl(FD(evsel, cpu, thread),
                                     PERF_EVENT_IOC_ENABLE, 0);
                         if (err)
@@ -339,21 +359,111 @@ int perf_evlist__enable_event(struct perf_evlist *evlist,
         return 0;
 }
 
-static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
+static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,
+                                         struct perf_evsel *evsel, int cpu)
+{
+        int thread, err;
+        int nr_threads = perf_evlist__nr_threads(evlist, evsel);
+
+        if (!evsel->fd)
+                return -EINVAL;
+
+        for (thread = 0; thread < nr_threads; thread++) {
+                err = ioctl(FD(evsel, cpu, thread),
+                            PERF_EVENT_IOC_ENABLE, 0);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+
+static int perf_evlist__enable_event_thread(struct perf_evlist *evlist,
+                                            struct perf_evsel *evsel,
+                                            int thread)
+{
+        int cpu, err;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+
+        if (!evsel->fd)
+                return -EINVAL;
+
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
+                err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+
+int perf_evlist__enable_event_idx(struct perf_evlist *evlist,
+                                  struct perf_evsel *evsel, int idx)
+{
+        bool per_cpu_mmaps = !cpu_map__empty(evlist->cpus);
+
+        if (per_cpu_mmaps)
+                return perf_evlist__enable_event_cpu(evlist, evsel, idx);
+        else
+                return perf_evlist__enable_event_thread(evlist, evsel, idx);
+}
+
+int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
         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;
+        int nfds = 0;
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                if (evsel->system_wide)
+                        nfds += nr_cpus;
+                else
+                        nfds += nr_cpus * nr_threads;
+        }
+
+        if (fdarray__available_entries(&evlist->pollfd) < nfds &&
+            fdarray__grow(&evlist->pollfd, nfds) < 0)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx)
+{
+        int pos = fdarray__add(&evlist->pollfd, fd, POLLIN | POLLERR | POLLHUP);
+        /*
+         * Save the idx so that when we filter out fds POLLHUP'ed we can
+         * close the associated evlist->mmap[] entry.
+         */
+        if (pos >= 0) {
+                evlist->pollfd.priv[pos].idx = idx;
+
+                fcntl(fd, F_SETFL, O_NONBLOCK);
+        }
+
+        return pos;
+}
+
+int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
+{
+        return __perf_evlist__add_pollfd(evlist, fd, -1);
+}
+
+static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd)
+{
+        struct perf_evlist *evlist = container_of(fda, struct perf_evlist, pollfd);
+
+        perf_evlist__mmap_put(evlist, fda->priv[fd].idx);
+}
+
+int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)
+{
+        return fdarray__filter(&evlist->pollfd, revents_and_mask,
+                               perf_evlist__munmap_filtered);
 }
 
-void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
+int perf_evlist__poll(struct perf_evlist *evlist, int timeout)
 {
-        fcntl(fd, F_SETFL, O_NONBLOCK);
-        evlist->pollfd[evlist->nr_fds].fd = fd;
-        evlist->pollfd[evlist->nr_fds].events = POLLIN;
-        evlist->nr_fds++;
+        return fdarray__poll(&evlist->pollfd, timeout);
 }
 
 static void perf_evlist__id_hash(struct perf_evlist *evlist,
@@ -566,14 +676,36 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
         return event;
 }
 
+static bool perf_mmap__empty(struct perf_mmap *md)
+{
+        return perf_mmap__read_head(md) != md->prev;
+}
+
+static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx)
+{
+        ++evlist->mmap[idx].refcnt;
+}
+
+static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx)
+{
+        BUG_ON(evlist->mmap[idx].refcnt == 0);
+
+        if (--evlist->mmap[idx].refcnt == 0)
+                __perf_evlist__munmap(evlist, idx);
+}
+
 void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
 {
+        struct perf_mmap *md = &evlist->mmap[idx];
+
         if (!evlist->overwrite) {
-                struct perf_mmap *md = &evlist->mmap[idx];
                 unsigned int old = md->prev;
 
                 perf_mmap__write_tail(md, old);
         }
+
+        if (md->refcnt == 1 && perf_mmap__empty(md))
+                perf_evlist__mmap_put(evlist, idx);
 }
 
 static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
@@ -581,6 +713,7 @@ static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
         if (evlist->mmap[idx].base != NULL) {
                 munmap(evlist->mmap[idx].base, evlist->mmap_len);
                 evlist->mmap[idx].base = NULL;
+                evlist->mmap[idx].refcnt = 0;
         }
 }
 
@@ -614,6 +747,20 @@ struct mmap_params {
 static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
                                struct mmap_params *mp, int fd)
 {
+        /*
+         * The last one will be done at perf_evlist__mmap_consume(), so that we
+         * make sure we don't prevent tools from consuming every last event in
+         * the ring buffer.
+         *
+         * I.e. we can get the POLLHUP meaning that the fd doesn't exist
+         * anymore, but the last events for it are still in the ring buffer,
+         * waiting to be consumed.
+         *
+         * Tools can chose to ignore this at their own discretion, but the
+         * evlist layer can't just drop it when filtering events in
+         * perf_evlist__filter_pollfd().
+         */
+        evlist->mmap[idx].refcnt = 2;
         evlist->mmap[idx].prev = 0;
         evlist->mmap[idx].mask = mp->mask;
         evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
@@ -625,7 +772,6 @@ static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
                 return -1;
         }
 
-        perf_evlist__add_pollfd(evlist, fd);
         return 0;
 }
 
@@ -636,7 +782,12 @@ static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
         struct perf_evsel *evsel;
 
         evlist__for_each(evlist, evsel) {
-                int fd = FD(evsel, cpu, thread);
+                int fd;
+
+                if (evsel->system_wide && thread)
+                        continue;
+
+                fd = FD(evsel, cpu, thread);
 
                 if (*output == -1) {
                         *output = fd;
@@ -645,6 +796,13 @@ static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
                 } else {
                         if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
                                 return -1;
+
+                        perf_evlist__mmap_get(evlist, idx);
+                }
+
+                if (__perf_evlist__add_pollfd(evlist, fd, idx) < 0) {
+                        perf_evlist__mmap_put(evlist, idx);
+                        return -1;
                 }
 
                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
@@ -804,7 +962,7 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
                 return -ENOMEM;
 
-        if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
+        if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
                 return -ENOMEM;
 
         evlist->overwrite = overwrite;
@@ -1061,6 +1219,8 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *tar
         }
 
         if (!evlist->workload.pid) {
+                int ret;
+
                 if (pipe_output)
                         dup2(2, 1);
 
@@ -1078,8 +1238,22 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *tar
                 /*
                  * Wait until the parent tells us to go.
                  */
-                if (read(go_pipe[0], &bf, 1) == -1)
-                        perror("unable to read pipe");
+                ret = read(go_pipe[0], &bf, 1);
+                /*
+                 * The parent will ask for the execvp() to be performed by
+                 * writing exactly one byte, in workload.cork_fd, usually via
+                 * perf_evlist__start_workload().
+                 *
+                 * For cancelling the workload without actuallin running it,
+                 * the parent will just close workload.cork_fd, without writing
+                 * anything, i.e. read will return zero and we just exit()
+                 * here.
+                 */
+                if (ret != 1) {
+                        if (ret == -1)
+                                perror("unable to read pipe");
+                        exit(ret);
+                }
 
                 execvp(argv[0], (char **)argv);
 
@@ -1202,7 +1376,7 @@ int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
                                int err, char *buf, size_t size)
 {
         int printed, value;
-        char sbuf[128], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
+        char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
 
         switch (err) {
         case EACCES:
@@ -1250,3 +1424,19 @@ void perf_evlist__to_front(struct perf_evlist *evlist,
 
         list_splice(&move, &evlist->entries);
 }
+
+void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
+                                     struct perf_evsel *tracking_evsel)
+{
+        struct perf_evsel *evsel;
+
+        if (tracking_evsel->tracking)
+                return;
+
+        evlist__for_each(evlist, evsel) {
+                if (evsel != tracking_evsel)
+                        evsel->tracking = false;
+        }
+
+        tracking_evsel->tracking = true;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index f5173cd63693..bd312b01e876 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -2,6 +2,7 @@
 #define __PERF_EVLIST_H 1
 
 #include <linux/list.h>
+#include <api/fd/array.h>
 #include <stdio.h>
 #include "../perf.h"
 #include "event.h"
@@ -17,9 +18,15 @@ struct record_opts;
 #define PERF_EVLIST__HLIST_BITS 8
 #define PERF_EVLIST__HLIST_SIZE (1 << PERF_EVLIST__HLIST_BITS)
 
+/**
+ * struct perf_mmap - perf's ring buffer mmap details
+ *
+ * @refcnt - e.g. code using PERF_EVENT_IOC_SET_OUTPUT to share this
+ */
 struct perf_mmap {
         void             *base;
         int              mask;
+        int              refcnt;
         unsigned int     prev;
         char             event_copy[PERF_SAMPLE_MAX_SIZE];
 };
@@ -29,7 +36,6 @@ struct perf_evlist {
         struct hlist_head heads[PERF_EVLIST__HLIST_SIZE];
         int              nr_entries;
         int              nr_groups;
-        int              nr_fds;
         int              nr_mmaps;
         size_t           mmap_len;
         int              id_pos;
@@ -40,8 +46,8 @@ struct perf_evlist {
                 pid_t   pid;
         } workload;
         bool             overwrite;
+        struct fdarray   pollfd;
         struct perf_mmap *mmap;
-        struct pollfd    *pollfd;
         struct thread_map *threads;
         struct cpu_map    *cpus;
         struct perf_evsel *selected;
@@ -82,7 +88,11 @@ perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
                          int cpu, int thread, u64 id);
 
-void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd);
+int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd);
+int perf_evlist__alloc_pollfd(struct perf_evlist *evlist);
+int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask);
+
+int perf_evlist__poll(struct perf_evlist *evlist, int timeout);
 
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 
@@ -122,6 +132,8 @@ int perf_evlist__disable_event(struct perf_evlist *evlist,
                                struct perf_evsel *evsel);
 int perf_evlist__enable_event(struct perf_evlist *evlist,
                               struct perf_evsel *evsel);
+int perf_evlist__enable_event_idx(struct perf_evlist *evlist,
+                                  struct perf_evsel *evsel, int idx);
 
 void perf_evlist__set_selected(struct perf_evlist *evlist,
                                struct perf_evsel *evsel);
@@ -262,4 +274,7 @@ void perf_evlist__to_front(struct perf_evlist *evlist,
 #define evlist__for_each_safe(evlist, tmp, evsel) \
         __evlist__for_each_safe(&(evlist)->entries, tmp, evsel)
 
+void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
+                                     struct perf_evsel *tracking_evsel);
+
 #endif /* __PERF_EVLIST_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 21a373ebea22..e0868a901c4a 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -162,6 +162,7 @@ void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx)
 {
         evsel->idx         = idx;
+        evsel->tracking    = !idx;
         evsel->attr        = *attr;
         evsel->leader      = evsel;
         evsel->unit        = "";
@@ -502,20 +503,19 @@ int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size)
 }
 
 static void
-perf_evsel__config_callgraph(struct perf_evsel *evsel,
-                             struct record_opts *opts)
+perf_evsel__config_callgraph(struct perf_evsel *evsel)
 {
         bool function = perf_evsel__is_function_event(evsel);
         struct perf_event_attr *attr = &evsel->attr;
 
         perf_evsel__set_sample_bit(evsel, CALLCHAIN);
 
-        if (opts->call_graph == CALLCHAIN_DWARF) {
+        if (callchain_param.record_mode == CALLCHAIN_DWARF) {
                 if (!function) {
                         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->sample_stack_user = callchain_param.dump_size;
                         attr->exclude_callchain_user = 1;
                 } else {
                         pr_info("Cannot use DWARF unwind for function trace event,"
@@ -561,7 +561,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
 {
         struct perf_evsel *leader = evsel->leader;
         struct perf_event_attr *attr = &evsel->attr;
-        int track = !evsel->idx; /* only the first counter needs these */
+        int track = evsel->tracking;
         bool per_cpu = opts->target.default_per_cpu && !opts->target.per_thread;
 
         attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1;
@@ -624,8 +624,8 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
                 attr->mmap_data = track;
         }
 
-        if (opts->call_graph_enabled && !evsel->no_aux_samples)
-                perf_evsel__config_callgraph(evsel, opts);
+        if (callchain_param.enabled && !evsel->no_aux_samples)
+                perf_evsel__config_callgraph(evsel);
 
         if (target__has_cpu(&opts->target))
                 perf_evsel__set_sample_bit(evsel, CPU);
@@ -633,9 +633,12 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
         if (opts->period)
                 perf_evsel__set_sample_bit(evsel, PERIOD);
 
-        if (!perf_missing_features.sample_id_all &&
-            (opts->sample_time || !opts->no_inherit ||
-             target__has_cpu(&opts->target) || per_cpu))
+        /*
+         * When the user explicitely disabled time don't force it here.
+         */
+        if (opts->sample_time &&
+            (!perf_missing_features.sample_id_all &&
+            (!opts->no_inherit || target__has_cpu(&opts->target) || per_cpu)))
                 perf_evsel__set_sample_bit(evsel, TIME);
 
         if (opts->raw_samples && !evsel->no_aux_samples) {
@@ -692,6 +695,10 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
         int cpu, thread;
+
+        if (evsel->system_wide)
+                nthreads = 1;
+
         evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
 
         if (evsel->fd) {
@@ -710,6 +717,9 @@ static int perf_evsel__run_ioctl(struct perf_evsel *evsel, int ncpus, int nthrea
 {
         int cpu, thread;
 
+        if (evsel->system_wide)
+                nthreads = 1;
+
         for (cpu = 0; cpu < ncpus; cpu++) {
                 for (thread = 0; thread < nthreads; thread++) {
                         int fd = FD(evsel, cpu, thread),
@@ -740,6 +750,9 @@ int perf_evsel__enable(struct perf_evsel *evsel, int ncpus, int nthreads)
 
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
+        if (evsel->system_wide)
+                nthreads = 1;
+
         evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
         if (evsel->sample_id == NULL)
                 return -ENOMEM;
@@ -784,6 +797,9 @@ void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
         int cpu, thread;
 
+        if (evsel->system_wide)
+                nthreads = 1;
+
         for (cpu = 0; cpu < ncpus; cpu++)
                 for (thread = 0; thread < nthreads; ++thread) {
                         close(FD(evsel, cpu, thread));
@@ -872,6 +888,9 @@ int __perf_evsel__read(struct perf_evsel *evsel,
         int cpu, thread;
         struct perf_counts_values *aggr = &evsel->counts->aggr, count;
 
+        if (evsel->system_wide)
+                nthreads = 1;
+
         aggr->val = aggr->ena = aggr->run = 0;
 
         for (cpu = 0; cpu < ncpus; cpu++) {
@@ -994,13 +1013,18 @@ static size_t perf_event_attr__fprintf(struct perf_event_attr *attr, FILE *fp)
 static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                               struct thread_map *threads)
 {
-        int cpu, thread;
+        int cpu, thread, nthreads;
         unsigned long flags = PERF_FLAG_FD_CLOEXEC;
         int pid = -1, err;
         enum { NO_CHANGE, SET_TO_MAX, INCREASED_MAX } set_rlimit = NO_CHANGE;
 
+        if (evsel->system_wide)
+                nthreads = 1;
+        else
+                nthreads = threads->nr;
+
         if (evsel->fd == NULL &&
-            perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
+            perf_evsel__alloc_fd(evsel, cpus->nr, nthreads) < 0)
                 return -ENOMEM;
 
         if (evsel->cgrp) {
@@ -1024,10 +1048,10 @@ retry_sample_id:
 
         for (cpu = 0; cpu < cpus->nr; cpu++) {
 
-                for (thread = 0; thread < threads->nr; thread++) {
+                for (thread = 0; thread < nthreads; thread++) {
                         int group_fd;
 
-                        if (!evsel->cgrp)
+                        if (!evsel->cgrp && !evsel->system_wide)
                                 pid = threads->map[thread];
 
                         group_fd = get_group_fd(evsel, cpu, thread);
@@ -1100,7 +1124,7 @@ out_close:
                         close(FD(evsel, cpu, thread));
                         FD(evsel, cpu, thread) = -1;
                 }
-                thread = threads->nr;
+                thread = nthreads;
         } while (--cpu >= 0);
         return err;
 }
@@ -2002,6 +2026,8 @@ bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
 int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
                               int err, char *msg, size_t size)
 {
+        char sbuf[STRERR_BUFSIZE];
+
         switch (err) {
         case EPERM:
         case EACCES:
@@ -2036,13 +2062,20 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
         "No APIC? If so then you can boot the kernel with the \"lapic\" boot parameter to force-enable it.");
 #endif
                 break;
+        case EBUSY:
+                if (find_process("oprofiled"))
+                        return scnprintf(msg, size,
+        "The PMU counters are busy/taken by another profiler.\n"
+        "We found oprofile daemon running, please stop it and try again.");
+                break;
         default:
                 break;
         }
 
         return scnprintf(msg, size,
-        "The sys_perf_event_open() syscall returned with %d (%s) for event (%s).  \n"
+        "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));
+                         err, strerror_r(err, sbuf, sizeof(sbuf)),
+                         perf_evsel__name(evsel));
 }
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index d7f93ce0ebc1..7bc314be6a7b 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -85,6 +85,8 @@ struct perf_evsel {
         bool                    needs_swap;
         bool                    no_aux_samples;
         bool                    immediate;
+        bool                    system_wide;
+        bool                    tracking;
         /* parse modifier helper */
         int                     exclude_GH;
         int                     nr_members;
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 158c787ce0c4..ce0de00399da 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -214,11 +214,11 @@ static int machine__hit_all_dsos(struct machine *machine)
 {
         int err;
 
-        err = __dsos__hit_all(&machine->kernel_dsos);
+        err = __dsos__hit_all(&machine->kernel_dsos.head);
         if (err)
                 return err;
 
-        return __dsos__hit_all(&machine->user_dsos);
+        return __dsos__hit_all(&machine->user_dsos.head);
 }
 
 int dsos__hit_all(struct perf_session *session)
@@ -288,11 +288,12 @@ static int machine__write_buildid_table(struct machine *machine, int fd)
                 umisc = PERF_RECORD_MISC_GUEST_USER;
         }
 
-        err = __dsos__write_buildid_table(&machine->kernel_dsos, machine,
+        err = __dsos__write_buildid_table(&machine->kernel_dsos.head, machine,
                                           machine->pid, kmisc, fd);
         if (err == 0)
-                err = __dsos__write_buildid_table(&machine->user_dsos, machine,
-                                                  machine->pid, umisc, fd);
+                err = __dsos__write_buildid_table(&machine->user_dsos.head,
+                                                  machine, machine->pid, umisc,
+                                                  fd);
         return err;
 }
 
@@ -455,9 +456,10 @@ static int __dsos__cache_build_ids(struct list_head *head,
 
 static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
 {
-        int ret = __dsos__cache_build_ids(&machine->kernel_dsos, machine,
+        int ret = __dsos__cache_build_ids(&machine->kernel_dsos.head, machine,
                                           debugdir);
-        ret |= __dsos__cache_build_ids(&machine->user_dsos, machine, debugdir);
+        ret |= __dsos__cache_build_ids(&machine->user_dsos.head, machine,
+                                       debugdir);
         return ret;
 }
 
@@ -483,8 +485,10 @@ static int perf_session__cache_build_ids(struct perf_session *session)
 
 static bool machine__read_build_ids(struct machine *machine, bool with_hits)
 {
-        bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
-        ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
+        bool ret;
+
+        ret  = __dsos__read_build_ids(&machine->kernel_dsos.head, with_hits);
+        ret |= __dsos__read_build_ids(&machine->user_dsos.head, with_hits);
         return ret;
 }
 
@@ -1548,7 +1552,7 @@ static int __event_process_build_id(struct build_id_event *bev,
                                     struct perf_session *session)
 {
         int err = -1;
-        struct list_head *head;
+        struct dsos *dsos;
         struct machine *machine;
         u16 misc;
         struct dso *dso;
@@ -1563,22 +1567,22 @@ static int __event_process_build_id(struct build_id_event *bev,
         switch (misc) {
         case PERF_RECORD_MISC_KERNEL:
                 dso_type = DSO_TYPE_KERNEL;
-                head = &machine->kernel_dsos;
+                dsos = &machine->kernel_dsos;
                 break;
         case PERF_RECORD_MISC_GUEST_KERNEL:
                 dso_type = DSO_TYPE_GUEST_KERNEL;
-                head = &machine->kernel_dsos;
+                dsos = &machine->kernel_dsos;
                 break;
         case PERF_RECORD_MISC_USER:
         case PERF_RECORD_MISC_GUEST_USER:
                 dso_type = DSO_TYPE_USER;
-                head = &machine->user_dsos;
+                dsos = &machine->user_dsos;
                 break;
         default:
                 goto out;
         }
 
-        dso = __dsos__findnew(head, filename);
+        dso = __dsos__findnew(dsos, filename);
         if (dso != NULL) {
                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 30df6187ee02..86569fa3651d 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -277,6 +277,28 @@ void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
         }
 }
 
+void hists__delete_entries(struct hists *hists)
+{
+        struct rb_node *next = rb_first(&hists->entries);
+        struct hist_entry *n;
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, &hists->entries);
+
+                if (sort__need_collapse)
+                        rb_erase(&n->rb_node_in, &hists->entries_collapsed);
+
+                --hists->nr_entries;
+                if (!n->filtered)
+                        --hists->nr_non_filtered_entries;
+
+                hist_entry__free(n);
+        }
+}
+
 /*
  * histogram, sorted on item, collects periods
  */
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 742f49a85725..8c9c70e18cbb 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -152,6 +152,7 @@ void hists__output_resort(struct hists *hists);
 void hists__collapse_resort(struct hists *hists, struct ui_progress *prog);
 
 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel);
+void hists__delete_entries(struct hists *hists);
 void hists__output_recalc_col_len(struct hists *hists, int max_rows);
 
 u64 hists__total_period(struct hists *hists);
@@ -192,6 +193,7 @@ struct perf_hpp {
 };
 
 struct perf_hpp_fmt {
+        const char *name;
         int (*header)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
                       struct perf_evsel *evsel);
         int (*width)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
@@ -207,6 +209,8 @@ struct perf_hpp_fmt {
         struct list_head list;
         struct list_head sort_list;
         bool elide;
+        int len;
+        int user_len;
 };
 
 extern struct list_head perf_hpp__list;
@@ -261,17 +265,19 @@ static inline bool perf_hpp__should_skip(struct perf_hpp_fmt *format)
 }
 
 void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists);
+void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists);
+void perf_hpp__set_user_width(const char *width_list_str);
 
 typedef u64 (*hpp_field_fn)(struct hist_entry *he);
 typedef int (*hpp_callback_fn)(struct perf_hpp *hpp, bool front);
 typedef int (*hpp_snprint_fn)(struct perf_hpp *hpp, const char *fmt, ...);
 
-int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
-               hpp_field_fn get_field, const char *fmt,
-               hpp_snprint_fn print_fn, bool fmt_percent);
-int __hpp__fmt_acc(struct perf_hpp *hpp, struct hist_entry *he,
-                   hpp_field_fn get_field, const char *fmt,
-                   hpp_snprint_fn print_fn, bool fmt_percent);
+int hpp__fmt(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+             struct hist_entry *he, hpp_field_fn get_field,
+             const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent);
+int hpp__fmt_acc(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+                 struct hist_entry *he, hpp_field_fn get_field,
+                 const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent);
 
 static inline void advance_hpp(struct perf_hpp *hpp, int inc)
 {
diff --git a/tools/perf/util/kvm-stat.h b/tools/perf/util/kvm-stat.h
index 0b5a8cd2ee79..cf1d7913783b 100644
--- a/tools/perf/util/kvm-stat.h
+++ b/tools/perf/util/kvm-stat.h
@@ -92,7 +92,6 @@ struct perf_kvm_stat {
         u64 lost_events;
         u64 duration;
 
-        const char *pid_str;
         struct intlist *pid_list;
 
         struct rb_root result;
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 16bba9fff2c8..b7d477fbda02 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -17,8 +17,8 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
 {
         map_groups__init(&machine->kmaps);
         RB_CLEAR_NODE(&machine->rb_node);
-        INIT_LIST_HEAD(&machine->user_dsos);
-        INIT_LIST_HEAD(&machine->kernel_dsos);
+        INIT_LIST_HEAD(&machine->user_dsos.head);
+        INIT_LIST_HEAD(&machine->kernel_dsos.head);
 
         machine->threads = RB_ROOT;
         INIT_LIST_HEAD(&machine->dead_threads);
@@ -31,6 +31,8 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
 
         machine->symbol_filter = NULL;
         machine->id_hdr_size = 0;
+        machine->comm_exec = false;
+        machine->kernel_start = 0;
 
         machine->root_dir = strdup(root_dir);
         if (machine->root_dir == NULL)
@@ -70,11 +72,12 @@ out_delete:
         return NULL;
 }
 
-static void dsos__delete(struct list_head *dsos)
+static void dsos__delete(struct dsos *dsos)
 {
         struct dso *pos, *n;
 
-        list_for_each_entry_safe(pos, n, dsos, node) {
+        list_for_each_entry_safe(pos, n, &dsos->head, node) {
+                RB_CLEAR_NODE(&pos->rb_node);
                 list_del(&pos->node);
                 dso__delete(pos);
         }
@@ -179,6 +182,19 @@ void machines__set_symbol_filter(struct machines *machines,
         }
 }
 
+void machines__set_comm_exec(struct machines *machines, bool comm_exec)
+{
+        struct rb_node *nd;
+
+        machines->host.comm_exec = comm_exec;
+
+        for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
+                struct machine *machine = rb_entry(nd, struct machine, rb_node);
+
+                machine->comm_exec = comm_exec;
+        }
+}
+
 struct machine *machines__find(struct machines *machines, pid_t pid)
 {
         struct rb_node **p = &machines->guests.rb_node;
@@ -398,17 +414,31 @@ struct thread *machine__find_thread(struct machine *machine, pid_t pid,
         return __machine__findnew_thread(machine, pid, tid, false);
 }
 
+struct comm *machine__thread_exec_comm(struct machine *machine,
+                                       struct thread *thread)
+{
+        if (machine->comm_exec)
+                return thread__exec_comm(thread);
+        else
+                return thread__comm(thread);
+}
+
 int machine__process_comm_event(struct machine *machine, union perf_event *event,
                                 struct perf_sample *sample)
 {
         struct thread *thread = machine__findnew_thread(machine,
                                                         event->comm.pid,
                                                         event->comm.tid);
+        bool exec = event->header.misc & PERF_RECORD_MISC_COMM_EXEC;
+
+        if (exec)
+                machine->comm_exec = true;
 
         if (dump_trace)
                 perf_event__fprintf_comm(event, stdout);
 
-        if (thread == NULL || thread__set_comm(thread, event->comm.comm, sample->time)) {
+        if (thread == NULL ||
+            __thread__set_comm(thread, event->comm.comm, sample->time, exec)) {
                 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
                 return -1;
         }
@@ -448,23 +478,23 @@ struct map *machine__new_module(struct machine *machine, u64 start,
 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);
+        size_t ret = __dsos__fprintf(&machines->host.kernel_dsos.head, fp) +
+                     __dsos__fprintf(&machines->host.user_dsos.head, 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);
+                ret += __dsos__fprintf(&pos->kernel_dsos.head, fp);
+                ret += __dsos__fprintf(&pos->user_dsos.head, fp);
         }
 
         return ret;
 }
 
-size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
+size_t machine__fprintf_dsos_buildid(struct machine *m, 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);
+        return __dsos__fprintf_buildid(&m->kernel_dsos.head, fp, skip, parm) +
+               __dsos__fprintf_buildid(&m->user_dsos.head, fp, skip, parm);
 }
 
 size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp,
@@ -565,8 +595,8 @@ const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL};
  * Returns the name of the start symbol in *symbol_name. Pass in NULL as
  * symbol_name if it's not that important.
  */
-static u64 machine__get_kernel_start_addr(struct machine *machine,
-                                          const char **symbol_name)
+static u64 machine__get_running_kernel_start(struct machine *machine,
+                                             const char **symbol_name)
 {
         char filename[PATH_MAX];
         int i;
@@ -593,7 +623,7 @@ static u64 machine__get_kernel_start_addr(struct machine *machine,
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 {
         enum map_type type;
-        u64 start = machine__get_kernel_start_addr(machine, NULL);
+        u64 start = machine__get_running_kernel_start(machine, NULL);
 
         for (type = 0; type < MAP__NR_TYPES; ++type) {
                 struct kmap *kmap;
@@ -912,7 +942,7 @@ int machine__create_kernel_maps(struct machine *machine)
 {
         struct dso *kernel = machine__get_kernel(machine);
         const char *name;
-        u64 addr = machine__get_kernel_start_addr(machine, &name);
+        u64 addr = machine__get_running_kernel_start(machine, &name);
         if (!addr)
                 return -1;
 
@@ -965,7 +995,7 @@ static bool machine__uses_kcore(struct machine *machine)
 {
         struct dso *dso;
 
-        list_for_each_entry(dso, &machine->kernel_dsos, node) {
+        list_for_each_entry(dso, &machine->kernel_dsos.head, node) {
                 if (dso__is_kcore(dso))
                         return true;
         }
@@ -1285,6 +1315,16 @@ static void ip__resolve_data(struct machine *machine, struct thread *thread,
 
         thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr,
                                    &al);
+        if (al.map == NULL) {
+                /*
+                 * some shared data regions have execute bit set which puts
+                 * their mapping in the MAP__FUNCTION type array.
+                 * Check there as a fallback option before dropping the sample.
+                 */
+                thread__find_addr_location(thread, machine, m, MAP__FUNCTION, addr,
+                                           &al);
+        }
+
         ams->addr = addr;
         ams->al_addr = al.addr;
         ams->sym = al.sym;
@@ -1531,3 +1571,25 @@ int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
 
         return 0;
 }
+
+int machine__get_kernel_start(struct machine *machine)
+{
+        struct map *map = machine__kernel_map(machine, MAP__FUNCTION);
+        int err = 0;
+
+        /*
+         * The only addresses above 2^63 are kernel addresses of a 64-bit
+         * kernel.  Note that addresses are unsigned so that on a 32-bit system
+         * all addresses including kernel addresses are less than 2^32.  In
+         * that case (32-bit system), if the kernel mapping is unknown, all
+         * addresses will be assumed to be in user space - see
+         * machine__kernel_ip().
+         */
+        machine->kernel_start = 1ULL << 63;
+        if (map) {
+                err = map__load(map, machine->symbol_filter);
+                if (map->start)
+                        machine->kernel_start = map->start;
+        }
+        return err;
+}
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index b972824e6294..2b651a7f5d0d 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -4,6 +4,7 @@
 #include <sys/types.h>
 #include <linux/rbtree.h>
 #include "map.h"
+#include "dso.h"
 #include "event.h"
 
 struct addr_location;
@@ -26,15 +27,17 @@ struct machine {
         struct rb_node    rb_node;
         pid_t             pid;
         u16               id_hdr_size;
+        bool              comm_exec;
         char              *root_dir;
         struct rb_root    threads;
         struct list_head  dead_threads;
         struct thread     *last_match;
         struct vdso_info  *vdso_info;
-        struct list_head  user_dsos;
-        struct list_head  kernel_dsos;
+        struct dsos       user_dsos;
+        struct dsos       kernel_dsos;
         struct map_groups kmaps;
         struct map        *vmlinux_maps[MAP__NR_TYPES];
+        u64               kernel_start;
         symbol_filter_t   symbol_filter;
         pid_t             *current_tid;
 };
@@ -45,8 +48,26 @@ struct map *machine__kernel_map(struct machine *machine, enum map_type type)
         return machine->vmlinux_maps[type];
 }
 
+int machine__get_kernel_start(struct machine *machine);
+
+static inline u64 machine__kernel_start(struct machine *machine)
+{
+        if (!machine->kernel_start)
+                machine__get_kernel_start(machine);
+        return machine->kernel_start;
+}
+
+static inline bool machine__kernel_ip(struct machine *machine, u64 ip)
+{
+        u64 kernel_start = machine__kernel_start(machine);
+
+        return ip >= kernel_start;
+}
+
 struct thread *machine__find_thread(struct machine *machine, pid_t pid,
                                     pid_t tid);
+struct comm *machine__thread_exec_comm(struct machine *machine,
+                                       struct thread *thread);
 
 int machine__process_comm_event(struct machine *machine, union perf_event *event,
                                 struct perf_sample *sample);
@@ -88,6 +109,7 @@ char *machine__mmap_name(struct machine *machine, char *bf, size_t size);
 
 void machines__set_symbol_filter(struct machines *machines,
                                  symbol_filter_t symbol_filter);
+void machines__set_comm_exec(struct machines *machines, bool comm_exec);
 
 struct machine *machine__new_host(void);
 int machine__init(struct machine *machine, const char *root_dir, pid_t pid);
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 31b8905dd863..b7090596ac50 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -31,6 +31,7 @@ static inline int is_anon_memory(const char *filename)
 static inline int is_no_dso_memory(const char *filename)
 {
         return !strncmp(filename, "[stack", 6) ||
+               !strncmp(filename, "/SYSV",5)   ||
                !strcmp(filename, "[heap]");
 }
 
diff --git a/tools/perf/util/ordered-events.c b/tools/perf/util/ordered-events.c
new file mode 100644
index 000000000000..706ce1a66169
--- /dev/null
+++ b/tools/perf/util/ordered-events.c
@@ -0,0 +1,245 @@
+#include <linux/list.h>
+#include <linux/compiler.h>
+#include "ordered-events.h"
+#include "evlist.h"
+#include "session.h"
+#include "asm/bug.h"
+#include "debug.h"
+
+#define pr_N(n, fmt, ...) \
+        eprintf(n, debug_ordered_events, fmt, ##__VA_ARGS__)
+
+#define pr(fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
+
+static void queue_event(struct ordered_events *oe, struct ordered_event *new)
+{
+        struct ordered_event *last = oe->last;
+        u64 timestamp = new->timestamp;
+        struct list_head *p;
+
+        ++oe->nr_events;
+        oe->last = new;
+
+        pr_oe_time2(timestamp, "queue_event nr_events %u\n", oe->nr_events);
+
+        if (!last) {
+                list_add(&new->list, &oe->events);
+                oe->max_timestamp = timestamp;
+                return;
+        }
+
+        /*
+         * last event might point to some random place in the list as it's
+         * the last queued event. We expect that the new event is close to
+         * this.
+         */
+        if (last->timestamp <= timestamp) {
+                while (last->timestamp <= timestamp) {
+                        p = last->list.next;
+                        if (p == &oe->events) {
+                                list_add_tail(&new->list, &oe->events);
+                                oe->max_timestamp = timestamp;
+                                return;
+                        }
+                        last = list_entry(p, struct ordered_event, list);
+                }
+                list_add_tail(&new->list, &last->list);
+        } else {
+                while (last->timestamp > timestamp) {
+                        p = last->list.prev;
+                        if (p == &oe->events) {
+                                list_add(&new->list, &oe->events);
+                                return;
+                        }
+                        last = list_entry(p, struct ordered_event, list);
+                }
+                list_add(&new->list, &last->list);
+        }
+}
+
+#define MAX_SAMPLE_BUFFER       (64 * 1024 / sizeof(struct ordered_event))
+static struct ordered_event *alloc_event(struct ordered_events *oe)
+{
+        struct list_head *cache = &oe->cache;
+        struct ordered_event *new = NULL;
+
+        if (!list_empty(cache)) {
+                new = list_entry(cache->next, struct ordered_event, list);
+                list_del(&new->list);
+        } else if (oe->buffer) {
+                new = oe->buffer + oe->buffer_idx;
+                if (++oe->buffer_idx == MAX_SAMPLE_BUFFER)
+                        oe->buffer = NULL;
+        } else if (oe->cur_alloc_size < oe->max_alloc_size) {
+                size_t size = MAX_SAMPLE_BUFFER * sizeof(*new);
+
+                oe->buffer = malloc(size);
+                if (!oe->buffer)
+                        return NULL;
+
+                pr("alloc size %" PRIu64 "B (+%zu), max %" PRIu64 "B\n",
+                   oe->cur_alloc_size, size, oe->max_alloc_size);
+
+                oe->cur_alloc_size += size;
+                list_add(&oe->buffer->list, &oe->to_free);
+
+                /* First entry is abused to maintain the to_free list. */
+                oe->buffer_idx = 2;
+                new = oe->buffer + 1;
+        } else {
+                pr("allocation limit reached %" PRIu64 "B\n", oe->max_alloc_size);
+        }
+
+        return new;
+}
+
+struct ordered_event *
+ordered_events__new(struct ordered_events *oe, u64 timestamp)
+{
+        struct ordered_event *new;
+
+        new = alloc_event(oe);
+        if (new) {
+                new->timestamp = timestamp;
+                queue_event(oe, new);
+        }
+
+        return new;
+}
+
+void ordered_events__delete(struct ordered_events *oe, struct ordered_event *event)
+{
+        list_move(&event->list, &oe->cache);
+        oe->nr_events--;
+}
+
+static int __ordered_events__flush(struct perf_session *s,
+                                   struct perf_tool *tool)
+{
+        struct ordered_events *oe = &s->ordered_events;
+        struct list_head *head = &oe->events;
+        struct ordered_event *tmp, *iter;
+        struct perf_sample sample;
+        u64 limit = oe->next_flush;
+        u64 last_ts = oe->last ? oe->last->timestamp : 0ULL;
+        bool show_progress = limit == ULLONG_MAX;
+        struct ui_progress prog;
+        int ret;
+
+        if (!tool->ordered_events || !limit)
+                return 0;
+
+        if (show_progress)
+                ui_progress__init(&prog, oe->nr_events, "Processing time ordered events...");
+
+        list_for_each_entry_safe(iter, tmp, head, list) {
+                if (session_done())
+                        return 0;
+
+                if (iter->timestamp > limit)
+                        break;
+
+                ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
+                if (ret)
+                        pr_err("Can't parse sample, err = %d\n", ret);
+                else {
+                        ret = perf_session__deliver_event(s, iter->event, &sample, tool,
+                                                          iter->file_offset);
+                        if (ret)
+                                return ret;
+                }
+
+                ordered_events__delete(oe, iter);
+                oe->last_flush = iter->timestamp;
+
+                if (show_progress)
+                        ui_progress__update(&prog, 1);
+        }
+
+        if (list_empty(head))
+                oe->last = NULL;
+        else if (last_ts <= limit)
+                oe->last = list_entry(head->prev, struct ordered_event, list);
+
+        return 0;
+}
+
+int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
+                          enum oe_flush how)
+{
+        struct ordered_events *oe = &s->ordered_events;
+        static const char * const str[] = {
+                "NONE",
+                "FINAL",
+                "ROUND",
+                "HALF ",
+        };
+        int err;
+
+        switch (how) {
+        case OE_FLUSH__FINAL:
+                oe->next_flush = ULLONG_MAX;
+                break;
+
+        case OE_FLUSH__HALF:
+        {
+                struct ordered_event *first, *last;
+                struct list_head *head = &oe->events;
+
+                first = list_entry(head->next, struct ordered_event, list);
+                last = oe->last;
+
+                /* Warn if we are called before any event got allocated. */
+                if (WARN_ONCE(!last || list_empty(head), "empty queue"))
+                        return 0;
+
+                oe->next_flush  = first->timestamp;
+                oe->next_flush += (last->timestamp - first->timestamp) / 2;
+                break;
+        }
+
+        case OE_FLUSH__ROUND:
+        case OE_FLUSH__NONE:
+        default:
+                break;
+        };
+
+        pr_oe_time(oe->next_flush, "next_flush - ordered_events__flush PRE  %s, nr_events %u\n",
+                   str[how], oe->nr_events);
+        pr_oe_time(oe->max_timestamp, "max_timestamp\n");
+
+        err = __ordered_events__flush(s, tool);
+
+        if (!err) {
+                if (how == OE_FLUSH__ROUND)
+                        oe->next_flush = oe->max_timestamp;
+
+                oe->last_flush_type = how;
+        }
+
+        pr_oe_time(oe->next_flush, "next_flush - ordered_events__flush POST %s, nr_events %u\n",
+                   str[how], oe->nr_events);
+        pr_oe_time(oe->last_flush, "last_flush\n");
+
+        return err;
+}
+
+void ordered_events__init(struct ordered_events *oe)
+{
+        INIT_LIST_HEAD(&oe->events);
+        INIT_LIST_HEAD(&oe->cache);
+        INIT_LIST_HEAD(&oe->to_free);
+        oe->max_alloc_size = (u64) -1;
+        oe->cur_alloc_size = 0;
+}
+
+void ordered_events__free(struct ordered_events *oe)
+{
+        while (!list_empty(&oe->to_free)) {
+                struct ordered_event *event;
+
+                event = list_entry(oe->to_free.next, struct ordered_event, list);
+                list_del(&event->list);
+                free(event);
+        }
+}
diff --git a/tools/perf/util/ordered-events.h b/tools/perf/util/ordered-events.h
new file mode 100644
index 000000000000..3b2f20542a01
--- /dev/null
+++ b/tools/perf/util/ordered-events.h
@@ -0,0 +1,51 @@
+#ifndef __ORDERED_EVENTS_H
+#define __ORDERED_EVENTS_H
+
+#include <linux/types.h>
+#include "tool.h"
+
+struct perf_session;
+
+struct ordered_event {
+        u64                     timestamp;
+        u64                     file_offset;
+        union perf_event        *event;
+        struct list_head        list;
+};
+
+enum oe_flush {
+        OE_FLUSH__NONE,
+        OE_FLUSH__FINAL,
+        OE_FLUSH__ROUND,
+        OE_FLUSH__HALF,
+};
+
+struct ordered_events {
+        u64                     last_flush;
+        u64                     next_flush;
+        u64                     max_timestamp;
+        u64                     max_alloc_size;
+        u64                     cur_alloc_size;
+        struct list_head        events;
+        struct list_head        cache;
+        struct list_head        to_free;
+        struct ordered_event    *buffer;
+        struct ordered_event    *last;
+        int                     buffer_idx;
+        unsigned int            nr_events;
+        enum oe_flush           last_flush_type;
+};
+
+struct ordered_event *ordered_events__new(struct ordered_events *oe, u64 timestamp);
+void ordered_events__delete(struct ordered_events *oe, struct ordered_event *event);
+int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
+                          enum oe_flush how);
+void ordered_events__init(struct ordered_events *oe);
+void ordered_events__free(struct ordered_events *oe);
+
+static inline
+void ordered_events__set_alloc_size(struct ordered_events *oe, u64 size)
+{
+        oe->max_alloc_size = size;
+}
+#endif /* __ORDERED_EVENTS_H */
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 1e15df10a88c..d76aa30cb1fb 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -10,6 +10,7 @@
 #include "symbol.h"
 #include "cache.h"
 #include "header.h"
+#include "debug.h"
 #include <api/fs/debugfs.h>
 #include "parse-events-bison.h"
 #define YY_EXTRA_TYPE int
@@ -633,18 +634,28 @@ int parse_events_add_pmu(struct list_head *list, int *idx,
                          char *name, struct list_head *head_config)
 {
         struct perf_event_attr attr;
+        struct perf_pmu_info info;
         struct perf_pmu *pmu;
         struct perf_evsel *evsel;
-        const char *unit;
-        double scale;
 
         pmu = perf_pmu__find(name);
         if (!pmu)
                 return -EINVAL;
 
-        memset(&attr, 0, sizeof(attr));
+        if (pmu->default_config) {
+                memcpy(&attr, pmu->default_config,
+                       sizeof(struct perf_event_attr));
+        } else {
+                memset(&attr, 0, sizeof(attr));
+        }
+
+        if (!head_config) {
+                attr.type = pmu->type;
+                evsel = __add_event(list, idx, &attr, NULL, pmu->cpus);
+                return evsel ? 0 : -ENOMEM;
+        }
 
-        if (perf_pmu__check_alias(pmu, head_config, &unit, &scale))
+        if (perf_pmu__check_alias(pmu, head_config, &info))
                 return -EINVAL;
 
         /*
@@ -659,8 +670,8 @@ int parse_events_add_pmu(struct list_head *list, int *idx,
         evsel = __add_event(list, idx, &attr, pmu_event_name(head_config),
                             pmu->cpus);
         if (evsel) {
-                evsel->unit = unit;
-                evsel->scale = scale;
+                evsel->unit = info.unit;
+                evsel->scale = info.scale;
         }
 
         return evsel ? 0 : -ENOMEM;
@@ -973,7 +984,7 @@ int parse_filter(const struct option *opt, const char *str,
 
         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
                 fprintf(stderr,
-                        "-F option should follow a -e tracepoint option\n");
+                        "--filter option should follow a -e tracepoint option\n");
                 return -1;
         }
 
@@ -1006,9 +1017,11 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
+        char sbuf[STRERR_BUFSIZE];
 
         if (debugfs_valid_mountpoint(tracing_events_path)) {
-                printf("  [ Tracepoints not available: %s ]\n", strerror(errno));
+                printf("  [ Tracepoints not available: %s ]\n",
+                        strerror_r(errno, sbuf, sizeof(sbuf)));
                 return;
         }
 
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 0bc87ba46bf3..55fab6ad609a 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -210,6 +210,16 @@ PE_NAME '/' event_config '/'
         parse_events__free_terms($3);
         $$ = list;
 }
+|
+PE_NAME '/' '/'
+{
+        struct parse_events_evlist *data = _data;
+        struct list_head *list;
+
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_pmu(list, &data->idx, $1, NULL));
+        $$ = list;
+}
 
 value_sym:
 PE_VALUE_SYM_HW
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 7a811eb61f75..93a41ca96b8e 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -2,6 +2,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdio.h>
+#include <stdbool.h>
+#include <stdarg.h>
 #include <dirent.h>
 #include <api/fs/fs.h>
 #include <locale.h>
@@ -14,8 +16,8 @@
 
 struct perf_pmu_alias {
         char *name;
-        struct list_head terms;
-        struct list_head list;
+        struct list_head terms; /* HEAD struct parse_events_term -> list */
+        struct list_head list;  /* ELEM */
         char unit[UNIT_MAX_LEN+1];
         double scale;
 };
@@ -208,6 +210,19 @@ static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FI
         return 0;
 }
 
+static inline bool pmu_alias_info_file(char *name)
+{
+        size_t len;
+
+        len = strlen(name);
+        if (len > 5 && !strcmp(name + len - 5, ".unit"))
+                return true;
+        if (len > 6 && !strcmp(name + len - 6, ".scale"))
+                return true;
+
+        return false;
+}
+
 /*
  * Process all the sysfs attributes located under the directory
  * specified in 'dir' parameter.
@@ -216,7 +231,6 @@ static int pmu_aliases_parse(char *dir, struct list_head *head)
 {
         struct dirent *evt_ent;
         DIR *event_dir;
-        size_t len;
         int ret = 0;
 
         event_dir = opendir(dir);
@@ -232,13 +246,9 @@ static int pmu_aliases_parse(char *dir, struct list_head *head)
                         continue;
 
                 /*
-                 * skip .unit and .scale info files
-                 * parsed in perf_pmu__new_alias()
+                 * skip info files parsed in perf_pmu__new_alias()
                  */
-                len = strlen(name);
-                if (len > 5 && !strcmp(name + len - 5, ".unit"))
-                        continue;
-                if (len > 6 && !strcmp(name + len - 6, ".scale"))
+                if (pmu_alias_info_file(name))
                         continue;
 
                 snprintf(path, PATH_MAX, "%s/%s", dir, name);
@@ -387,6 +397,12 @@ static struct cpu_map *pmu_cpumask(const char *name)
         return cpus;
 }
 
+struct perf_event_attr *__attribute__((weak))
+perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
+{
+        return NULL;
+}
+
 static struct perf_pmu *pmu_lookup(const char *name)
 {
         struct perf_pmu *pmu;
@@ -421,6 +437,9 @@ static struct perf_pmu *pmu_lookup(const char *name)
         pmu->name = strdup(name);
         pmu->type = type;
         list_add_tail(&pmu->list, &pmus);
+
+        pmu->default_config = perf_pmu__get_default_config(pmu);
+
         return pmu;
 }
 
@@ -479,28 +498,24 @@ pmu_find_format(struct list_head *formats, char *name)
 }
 
 /*
- * Returns value based on the format definition (format parameter)
+ * Sets value based on the format definition (format parameter)
  * and unformated value (value parameter).
- *
- * TODO maybe optimize a little ;)
  */
-static __u64 pmu_format_value(unsigned long *format, __u64 value)
+static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
+                             bool zero)
 {
         unsigned long fbit, vbit;
-        __u64 v = 0;
 
         for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
 
                 if (!test_bit(fbit, format))
                         continue;
 
-                if (!(value & (1llu << vbit++)))
-                        continue;
-
-                v |= (1llu << fbit);
+                if (value & (1llu << vbit++))
+                        *v |= (1llu << fbit);
+                else if (zero)
+                        *v &= ~(1llu << fbit);
         }
-
-        return v;
 }
 
 /*
@@ -509,7 +524,8 @@ 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,
+                           bool zero)
 {
         struct perf_pmu_format *format;
         __u64 *vp;
@@ -548,18 +564,19 @@ static int pmu_config_term(struct list_head *formats,
          * non-hardcoded terms, here's the place to translate
          * them into value.
          */
-        *vp |= pmu_format_value(format->bits, term->val.num);
+        pmu_format_value(format->bits, term->val.num, vp, zero);
         return 0;
 }
 
 int perf_pmu__config_terms(struct list_head *formats,
                            struct perf_event_attr *attr,
-                           struct list_head *head_terms)
+                           struct list_head *head_terms,
+                           bool zero)
 {
         struct parse_events_term *term;
 
         list_for_each_entry(term, head_terms, list)
-                if (pmu_config_term(formats, attr, term))
+                if (pmu_config_term(formats, attr, term, zero))
                         return -EINVAL;
 
         return 0;
@@ -573,8 +590,10 @@ int perf_pmu__config_terms(struct list_head *formats,
 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
                      struct list_head *head_terms)
 {
+        bool zero = !!pmu->default_config;
+
         attr->type = pmu->type;
-        return perf_pmu__config_terms(&pmu->format, attr, head_terms);
+        return perf_pmu__config_terms(&pmu->format, attr, head_terms, zero);
 }
 
 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
@@ -634,7 +653,7 @@ static int check_unit_scale(struct perf_pmu_alias *alias,
  * defined for the alias
  */
 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
-                          const char **unit, double *scale)
+                          struct perf_pmu_info *info)
 {
         struct parse_events_term *term, *h;
         struct perf_pmu_alias *alias;
@@ -644,8 +663,8 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
          * Mark unit and scale as not set
          * (different from default values, see below)
          */
-        *unit   = NULL;
-        *scale  = 0.0;
+        info->unit   = NULL;
+        info->scale  = 0.0;
 
         list_for_each_entry_safe(term, h, head_terms, list) {
                 alias = pmu_find_alias(pmu, term);
@@ -655,7 +674,7 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
                 if (ret)
                         return ret;
 
-                ret = check_unit_scale(alias, unit, scale);
+                ret = check_unit_scale(alias, &info->unit, &info->scale);
                 if (ret)
                         return ret;
 
@@ -668,11 +687,11 @@ int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
          * set defaults as for evsel
          * unit cannot left to NULL
          */
-        if (*unit == NULL)
-                *unit   = "";
+        if (info->unit == NULL)
+                info->unit   = "";
 
-        if (*scale == 0.0)
-                *scale  = 1.0;
+        if (info->scale == 0.0)
+                info->scale  = 1.0;
 
         return 0;
 }
@@ -794,3 +813,39 @@ bool pmu_have_event(const char *pname, const char *name)
         }
         return false;
 }
+
+static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
+{
+        struct stat st;
+        char path[PATH_MAX];
+        const char *sysfs;
+
+        sysfs = sysfs__mountpoint();
+        if (!sysfs)
+                return NULL;
+
+        snprintf(path, PATH_MAX,
+                 "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
+
+        if (stat(path, &st) < 0)
+                return NULL;
+
+        return fopen(path, "r");
+}
+
+int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
+                        ...)
+{
+        va_list args;
+        FILE *file;
+        int ret = EOF;
+
+        va_start(args, fmt);
+        file = perf_pmu__open_file(pmu, name);
+        if (file) {
+                ret = vfscanf(file, fmt, args);
+                fclose(file);
+        }
+        va_end(args);
+        return ret;
+}
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index c14a543ce1f3..fe90a012c003 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -13,13 +13,21 @@ enum {
 
 #define PERF_PMU_FORMAT_BITS 64
 
+struct perf_event_attr;
+
 struct perf_pmu {
         char *name;
         __u32 type;
+        struct perf_event_attr *default_config;
         struct cpu_map *cpus;
-        struct list_head format;
-        struct list_head aliases;
-        struct list_head list;
+        struct list_head format;  /* HEAD struct perf_pmu_format -> list */
+        struct list_head aliases; /* HEAD struct perf_pmu_alias -> list */
+        struct list_head list;    /* ELEM */
+};
+
+struct perf_pmu_info {
+        const char *unit;
+        double scale;
 };
 
 struct perf_pmu *perf_pmu__find(const char *name);
@@ -27,9 +35,10 @@ int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
                      struct list_head *head_terms);
 int perf_pmu__config_terms(struct list_head *formats,
                            struct perf_event_attr *attr,
-                           struct list_head *head_terms);
+                           struct list_head *head_terms,
+                           bool zero);
 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
-                          const char **unit, double *scale);
+                          struct perf_pmu_info *info);
 struct list_head *perf_pmu__alias(struct perf_pmu *pmu,
                                   struct list_head *head_terms);
 int perf_pmu_wrap(void);
@@ -45,5 +54,11 @@ struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu);
 void print_pmu_events(const char *event_glob, bool name_only);
 bool pmu_have_event(const char *pname, const char *name);
 
+int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
+                        ...) __attribute__((format(scanf, 3, 4)));
+
 int perf_pmu__test(void);
+
+struct perf_event_attr *perf_pmu__get_default_config(struct perf_pmu *pmu);
+
 #endif /* __PMU_H */
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 9a0a1839a377..c150ca4343eb 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -79,7 +79,7 @@ static int init_symbol_maps(bool user_only)
         int ret;
 
         symbol_conf.sort_by_name = true;
-        ret = symbol__init();
+        ret = symbol__init(NULL);
         if (ret < 0) {
                 pr_debug("Failed to init symbol map.\n");
                 goto out;
@@ -184,7 +184,8 @@ static struct dso *kernel_get_module_dso(const char *module)
         const char *vmlinux_name;
 
         if (module) {
-                list_for_each_entry(dso, &host_machine->kernel_dsos, node) {
+                list_for_each_entry(dso, &host_machine->kernel_dsos.head,
+                                    node) {
                         if (strncmp(dso->short_name + 1, module,
                                     dso->short_name_len - 2) == 0)
                                 goto found;
@@ -258,21 +259,33 @@ static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 #ifdef HAVE_DWARF_SUPPORT
 
 /* Open new debuginfo of given module */
-static struct debuginfo *open_debuginfo(const char *module)
+static struct debuginfo *open_debuginfo(const char *module, bool silent)
 {
         const char *path = module;
+        struct debuginfo *ret;
 
         if (!module || !strchr(module, '/')) {
                 path = kernel_get_module_path(module);
                 if (!path) {
-                        pr_err("Failed to find path of %s module.\n",
-                               module ?: "kernel");
+                        if (!silent)
+                                pr_err("Failed to find path of %s module.\n",
+                                       module ?: "kernel");
                         return NULL;
                 }
         }
-        return debuginfo__new(path);
+        ret = debuginfo__new(path);
+        if (!ret && !silent) {
+                pr_warning("The %s file has no debug information.\n", path);
+                if (!module || !strtailcmp(path, ".ko"))
+                        pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
+                else
+                        pr_warning("Rebuild with -g, ");
+                pr_warning("or install an appropriate debuginfo package.\n");
+        }
+        return ret;
 }
 
+
 static int get_text_start_address(const char *exec, unsigned long *address)
 {
         Elf *elf;
@@ -333,15 +346,13 @@ static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
         pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
                  tp->module ? : "kernel");
 
-        dinfo = open_debuginfo(tp->module);
+        dinfo = open_debuginfo(tp->module, verbose == 0);
         if (dinfo) {
                 ret = debuginfo__find_probe_point(dinfo,
                                                  (unsigned long)addr, pp);
                 debuginfo__delete(dinfo);
-        } else {
-                pr_debug("Failed to open debuginfo at 0x%" PRIx64 "\n", addr);
+        } else
                 ret = -ENOENT;
-        }
 
         if (ret > 0) {
                 pp->retprobe = tp->retprobe;
@@ -457,13 +468,11 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
         struct debuginfo *dinfo;
         int ntevs, ret = 0;
 
-        dinfo = open_debuginfo(target);
+        dinfo = open_debuginfo(target, !need_dwarf);
 
         if (!dinfo) {
-                if (need_dwarf) {
-                        pr_warning("Failed to open debuginfo file.\n");
+                if (need_dwarf)
                         return -ENOENT;
-                }
                 pr_debug("Could not open debuginfo. Try to use symbols.\n");
                 return 0;
         }
@@ -565,7 +574,7 @@ static int get_real_path(const char *raw_path, const char *comp_dir,
 
 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 {
-        char buf[LINEBUF_SIZE];
+        char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
         const char *color = show_num ? "" : PERF_COLOR_BLUE;
         const char *prefix = NULL;
 
@@ -585,7 +594,8 @@ static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
         return 1;
 error:
         if (ferror(fp)) {
-                pr_warning("File read error: %s\n", strerror(errno));
+                pr_warning("File read error: %s\n",
+                           strerror_r(errno, sbuf, sizeof(sbuf)));
                 return -1;
         }
         return 0;
@@ -618,13 +628,12 @@ static int __show_line_range(struct line_range *lr, const char *module)
         FILE *fp;
         int ret;
         char *tmp;
+        char sbuf[STRERR_BUFSIZE];
 
         /* Search a line range */
-        dinfo = open_debuginfo(module);
-        if (!dinfo) {
-                pr_warning("Failed to open debuginfo file.\n");
+        dinfo = open_debuginfo(module, false);
+        if (!dinfo)
                 return -ENOENT;
-        }
 
         ret = debuginfo__find_line_range(dinfo, lr);
         debuginfo__delete(dinfo);
@@ -656,7 +665,7 @@ static int __show_line_range(struct line_range *lr, const char *module)
         fp = fopen(lr->path, "r");
         if (fp == NULL) {
                 pr_warning("Failed to open %s: %s\n", lr->path,
-                           strerror(errno));
+                           strerror_r(errno, sbuf, sizeof(sbuf)));
                 return -errno;
         }
         /* Skip to starting line number */
@@ -689,11 +698,11 @@ end:
         return ret;
 }
 
-int show_line_range(struct line_range *lr, const char *module)
+int show_line_range(struct line_range *lr, const char *module, bool user)
 {
         int ret;
 
-        ret = init_symbol_maps(false);
+        ret = init_symbol_maps(user);
         if (ret < 0)
                 return ret;
         ret = __show_line_range(lr, module);
@@ -768,13 +777,12 @@ int show_available_vars(struct perf_probe_event *pevs, int npevs,
         int i, ret = 0;
         struct debuginfo *dinfo;
 
-        ret = init_symbol_maps(false);
+        ret = init_symbol_maps(pevs->uprobes);
         if (ret < 0)
                 return ret;
 
-        dinfo = open_debuginfo(module);
+        dinfo = open_debuginfo(module, false);
         if (!dinfo) {
-                pr_warning("Failed to open debuginfo file.\n");
                 ret = -ENOENT;
                 goto out;
         }
@@ -815,7 +823,8 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 }
 
 int show_line_range(struct line_range *lr __maybe_unused,
-                    const char *module __maybe_unused)
+                    const char *module __maybe_unused,
+                    bool user __maybe_unused)
 {
         pr_warning("Debuginfo-analysis is not supported.\n");
         return -ENOSYS;
@@ -1405,8 +1414,7 @@ int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
 
         return tmp - buf;
 error:
-        pr_debug("Failed to synthesize perf probe argument: %s\n",
-                 strerror(-ret));
+        pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
         return ret;
 }
 
@@ -1455,8 +1463,7 @@ static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
 
         return buf;
 error:
-        pr_debug("Failed to synthesize perf probe point: %s\n",
-                 strerror(-ret));
+        pr_debug("Failed to synthesize perf probe point: %d\n", ret);
         free(buf);
         return NULL;
 }
@@ -1780,10 +1787,11 @@ static void clear_probe_trace_event(struct probe_trace_event *tev)
         memset(tev, 0, sizeof(*tev));
 }
 
-static void print_warn_msg(const char *file, bool is_kprobe)
+static void print_open_warning(int err, bool is_kprobe)
 {
+        char sbuf[STRERR_BUFSIZE];
 
-        if (errno == ENOENT) {
+        if (err == -ENOENT) {
                 const char *config;
 
                 if (!is_kprobe)
@@ -1791,25 +1799,43 @@ static void print_warn_msg(const char *file, bool is_kprobe)
                 else
                         config = "CONFIG_KPROBE_EVENTS";
 
-                pr_warning("%s file does not exist - please rebuild kernel"
-                                " with %s.\n", file, config);
-        } else
-                pr_warning("Failed to open %s file: %s\n", file,
-                                strerror(errno));
+                pr_warning("%cprobe_events file does not exist"
+                           " - please rebuild kernel with %s.\n",
+                           is_kprobe ? 'k' : 'u', config);
+        } else if (err == -ENOTSUP)
+                pr_warning("Debugfs is not mounted.\n");
+        else
+                pr_warning("Failed to open %cprobe_events: %s\n",
+                           is_kprobe ? 'k' : 'u',
+                           strerror_r(-err, sbuf, sizeof(sbuf)));
+}
+
+static void print_both_open_warning(int kerr, int uerr)
+{
+        /* Both kprobes and uprobes are disabled, warn it. */
+        if (kerr == -ENOTSUP && uerr == -ENOTSUP)
+                pr_warning("Debugfs is not mounted.\n");
+        else if (kerr == -ENOENT && uerr == -ENOENT)
+                pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
+                           "or/and CONFIG_UPROBE_EVENTS.\n");
+        else {
+                char sbuf[STRERR_BUFSIZE];
+                pr_warning("Failed to open kprobe events: %s.\n",
+                           strerror_r(-kerr, sbuf, sizeof(sbuf)));
+                pr_warning("Failed to open uprobe events: %s.\n",
+                           strerror_r(-uerr, sbuf, sizeof(sbuf)));
+        }
 }
 
-static int open_probe_events(const char *trace_file, bool readwrite,
-                                bool is_kprobe)
+static int open_probe_events(const char *trace_file, bool readwrite)
 {
         char buf[PATH_MAX];
         const char *__debugfs;
         int ret;
 
         __debugfs = debugfs_find_mountpoint();
-        if (__debugfs == NULL) {
-                pr_warning("Debugfs is not mounted.\n");
-                return -ENOENT;
-        }
+        if (__debugfs == NULL)
+                return -ENOTSUP;
 
         ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
         if (ret >= 0) {
@@ -1820,19 +1846,19 @@ static int open_probe_events(const char *trace_file, bool readwrite,
                         ret = open(buf, O_RDONLY, 0);
 
                 if (ret < 0)
-                        print_warn_msg(buf, is_kprobe);
+                        ret = -errno;
         }
         return ret;
 }
 
 static int open_kprobe_events(bool readwrite)
 {
-        return open_probe_events("tracing/kprobe_events", readwrite, true);
+        return open_probe_events("tracing/kprobe_events", readwrite);
 }
 
 static int open_uprobe_events(bool readwrite)
 {
-        return open_probe_events("tracing/uprobe_events", readwrite, false);
+        return open_probe_events("tracing/uprobe_events", readwrite);
 }
 
 /* Get raw string list of current kprobe_events  or uprobe_events */
@@ -1857,7 +1883,7 @@ static struct strlist *get_probe_trace_command_rawlist(int fd)
                         p[idx] = '\0';
                 ret = strlist__add(sl, buf);
                 if (ret < 0) {
-                        pr_debug("strlist__add failed: %s\n", strerror(-ret));
+                        pr_debug("strlist__add failed (%d)\n", ret);
                         strlist__delete(sl);
                         return NULL;
                 }
@@ -1916,7 +1942,7 @@ static int __show_perf_probe_events(int fd, bool is_kprobe)
 
         rawlist = get_probe_trace_command_rawlist(fd);
         if (!rawlist)
-                return -ENOENT;
+                return -ENOMEM;
 
         strlist__for_each(ent, rawlist) {
                 ret = parse_probe_trace_command(ent->s, &tev);
@@ -1940,27 +1966,34 @@ static int __show_perf_probe_events(int fd, bool is_kprobe)
 /* List up current perf-probe events */
 int show_perf_probe_events(void)
 {
-        int fd, ret;
+        int kp_fd, up_fd, ret;
 
         setup_pager();
-        fd = open_kprobe_events(false);
-
-        if (fd < 0)
-                return fd;
 
         ret = init_symbol_maps(false);
         if (ret < 0)
                 return ret;
 
-        ret = __show_perf_probe_events(fd, true);
-        close(fd);
+        kp_fd = open_kprobe_events(false);
+        if (kp_fd >= 0) {
+                ret = __show_perf_probe_events(kp_fd, true);
+                close(kp_fd);
+                if (ret < 0)
+                        goto out;
+        }
 
-        fd = open_uprobe_events(false);
-        if (fd >= 0) {
-                ret = __show_perf_probe_events(fd, false);
-                close(fd);
+        up_fd = open_uprobe_events(false);
+        if (kp_fd < 0 && up_fd < 0) {
+                print_both_open_warning(kp_fd, up_fd);
+                ret = kp_fd;
+                goto out;
         }
 
+        if (up_fd >= 0) {
+                ret = __show_perf_probe_events(up_fd, false);
+                close(up_fd);
+        }
+out:
         exit_symbol_maps();
         return ret;
 }
@@ -1976,6 +2009,8 @@ static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
 
         memset(&tev, 0, sizeof(tev));
         rawlist = get_probe_trace_command_rawlist(fd);
+        if (!rawlist)
+                return NULL;
         sl = strlist__new(true, NULL);
         strlist__for_each(ent, rawlist) {
                 ret = parse_probe_trace_command(ent->s, &tev);
@@ -2005,6 +2040,7 @@ static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
 {
         int ret = 0;
         char *buf = synthesize_probe_trace_command(tev);
+        char sbuf[STRERR_BUFSIZE];
 
         if (!buf) {
                 pr_debug("Failed to synthesize probe trace event.\n");
@@ -2016,7 +2052,7 @@ static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
                 ret = write(fd, buf, strlen(buf));
                 if (ret <= 0)
                         pr_warning("Failed to write event: %s\n",
-                                   strerror(errno));
+                                   strerror_r(errno, sbuf, sizeof(sbuf)));
         }
         free(buf);
         return ret;
@@ -2030,7 +2066,7 @@ static int get_new_event_name(char *buf, size_t len, const char *base,
         /* Try no suffix */
         ret = e_snprintf(buf, len, "%s", base);
         if (ret < 0) {
-                pr_debug("snprintf() failed: %s\n", strerror(-ret));
+                pr_debug("snprintf() failed: %d\n", ret);
                 return ret;
         }
         if (!strlist__has_entry(namelist, buf))
@@ -2046,7 +2082,7 @@ static int get_new_event_name(char *buf, size_t len, const char *base,
         for (i = 1; i < MAX_EVENT_INDEX; i++) {
                 ret = e_snprintf(buf, len, "%s_%d", base, i);
                 if (ret < 0) {
-                        pr_debug("snprintf() failed: %s\n", strerror(-ret));
+                        pr_debug("snprintf() failed: %d\n", ret);
                         return ret;
                 }
                 if (!strlist__has_entry(namelist, buf))
@@ -2075,8 +2111,11 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
         else
                 fd = open_kprobe_events(true);
 
-        if (fd < 0)
+        if (fd < 0) {
+                print_open_warning(fd, !pev->uprobes);
                 return fd;
+        }
+
         /* Get current event names */
         namelist = get_probe_trace_event_names(fd, false);
         if (!namelist) {
@@ -2408,7 +2447,8 @@ static int __del_trace_probe_event(int fd, struct str_node *ent)
         printf("Removed event: %s\n", ent->s);
         return 0;
 error:
-        pr_warning("Failed to delete event: %s\n", strerror(-ret));
+        pr_warning("Failed to delete event: %s\n",
+                   strerror_r(-ret, buf, sizeof(buf)));
         return ret;
 }
 
@@ -2449,15 +2489,18 @@ int del_perf_probe_events(struct strlist *dellist)
 
         /* Get current event names */
         kfd = open_kprobe_events(true);
-        if (kfd < 0)
-                return kfd;
+        if (kfd >= 0)
+                namelist = get_probe_trace_event_names(kfd, true);
 
-        namelist = get_probe_trace_event_names(kfd, true);
         ufd = open_uprobe_events(true);
-
         if (ufd >= 0)
                 unamelist = get_probe_trace_event_names(ufd, true);
 
+        if (kfd < 0 && ufd < 0) {
+                print_both_open_warning(kfd, ufd);
+                goto error;
+        }
+
         if (namelist == NULL && unamelist == NULL)
                 goto error;
 
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 776c9347a3b6..e01e9943139f 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -128,7 +128,8 @@ extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
                                  bool force_add);
 extern int del_perf_probe_events(struct strlist *dellist);
 extern int show_perf_probe_events(void);
-extern int show_line_range(struct line_range *lr, const char *module);
+extern int show_line_range(struct line_range *lr, const char *module,
+                           bool user);
 extern int show_available_vars(struct perf_probe_event *pevs, int npevs,
                                int max_probe_points, const char *module,
                                struct strfilter *filter, bool externs);
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index dca9145d704c..c7918f83b300 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -281,6 +281,7 @@ static int convert_variable_type(Dwarf_Die *vr_die,
         struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
         Dwarf_Die type;
         char buf[16];
+        char sbuf[STRERR_BUFSIZE];
         int bsize, boffs, total;
         int ret;
 
@@ -367,7 +368,7 @@ formatted:
                 if (ret >= 16)
                         ret = -E2BIG;
                 pr_warning("Failed to convert variable type: %s\n",
-                           strerror(-ret));
+                           strerror_r(-ret, sbuf, sizeof(sbuf)));
                 return ret;
         }
         tvar->type = strdup(buf);
@@ -608,14 +609,18 @@ static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
                 return -EINVAL;
         }
 
-        /* Get an appropriate symbol from symtab */
-        symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+        symbol = dwarf_diename(sp_die);
         if (!symbol) {
-                pr_warning("Failed to find symbol at 0x%lx\n",
-                           (unsigned long)paddr);
-                return -ENOENT;
+                /* Try to get the symbol name from symtab */
+                symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+                if (!symbol) {
+                        pr_warning("Failed to find symbol at 0x%lx\n",
+                                   (unsigned long)paddr);
+                        return -ENOENT;
+                }
+                eaddr = sym.st_value;
         }
-        tp->offset = (unsigned long)(paddr - sym.st_value);
+        tp->offset = (unsigned long)(paddr - eaddr);
         tp->address = (unsigned long)paddr;
         tp->symbol = strdup(symbol);
         if (!tp->symbol)
@@ -779,10 +784,12 @@ static int find_lazy_match_lines(struct intlist *list,
         size_t line_len;
         ssize_t len;
         int count = 0, linenum = 1;
+        char sbuf[STRERR_BUFSIZE];
 
         fp = fopen(fname, "r");
         if (!fp) {
-                pr_warning("Failed to open %s: %s\n", fname, strerror(errno));
+                pr_warning("Failed to open %s: %s\n", fname,
+                           strerror_r(errno, sbuf, sizeof(sbuf)));
                 return -errno;
         }
 
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 12aa9b0d0ba1..3dda85ca50c1 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -736,7 +736,7 @@ static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist,
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &timeout))
                 return NULL;
 
-        n = poll(evlist->pollfd, evlist->nr_fds, timeout);
+        n = perf_evlist__poll(evlist, timeout);
         if (n < 0) {
                 PyErr_SetFromErrno(PyExc_OSError);
                 return NULL;
@@ -753,9 +753,9 @@ static PyObject *pyrf_evlist__get_pollfd(struct pyrf_evlist *pevlist,
         PyObject *list = PyList_New(0);
         int i;
 
-        for (i = 0; i < evlist->nr_fds; ++i) {
+        for (i = 0; i < evlist->pollfd.nr; ++i) {
                 PyObject *file;
-                FILE *fp = fdopen(evlist->pollfd[i].fd, "r");
+                FILE *fp = fdopen(evlist->pollfd.entries[i].fd, "r");
 
                 if (fp == NULL)
                         goto free_list;
diff --git a/tools/perf/util/record.c b/tools/perf/util/record.c
index fe8079edbdc1..cf69325b985f 100644
--- a/tools/perf/util/record.c
+++ b/tools/perf/util/record.c
@@ -14,6 +14,7 @@ static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str)
         struct perf_evsel *evsel;
         unsigned long flags = perf_event_open_cloexec_flag();
         int err = -EAGAIN, fd;
+        static pid_t pid = -1;
 
         evlist = perf_evlist__new();
         if (!evlist)
@@ -24,14 +25,22 @@ static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str)
 
         evsel = perf_evlist__first(evlist);
 
-        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, flags);
-        if (fd < 0)
-                goto out_delete;
+        while (1) {
+                fd = sys_perf_event_open(&evsel->attr, pid, cpu, -1, flags);
+                if (fd < 0) {
+                        if (pid == -1 && errno == EACCES) {
+                                pid = 0;
+                                continue;
+                        }
+                        goto out_delete;
+                }
+                break;
+        }
         close(fd);
 
         fn(evsel);
 
-        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, flags);
+        fd = sys_perf_event_open(&evsel->attr, pid, cpu, -1, flags);
         if (fd < 0) {
                 if (errno == EINVAL)
                         err = -EINVAL;
@@ -47,7 +56,7 @@ out_delete:
 
 static bool perf_probe_api(setup_probe_fn_t fn)
 {
-        const char *try[] = {"cycles:u", "instructions:u", "cpu-clock", NULL};
+        const char *try[] = {"cycles:u", "instructions:u", "cpu-clock:u", NULL};
         struct cpu_map *cpus;
         int cpu, ret, i = 0;
 
@@ -106,7 +115,7 @@ void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts)
 
         evlist__for_each(evlist, evsel) {
                 perf_evsel__config(evsel, opts);
-                if (!evsel->idx && use_comm_exec)
+                if (evsel->tracking && use_comm_exec)
                         evsel->attr.comm_exec = 1;
         }
 
@@ -201,6 +210,7 @@ bool perf_evlist__can_select_event(struct perf_evlist *evlist, const char *str)
         struct perf_evsel *evsel;
         int err, fd, cpu;
         bool ret = false;
+        pid_t pid = -1;
 
         temp_evlist = perf_evlist__new();
         if (!temp_evlist)
@@ -221,12 +231,20 @@ bool perf_evlist__can_select_event(struct perf_evlist *evlist, const char *str)
                 cpu = evlist->cpus->map[0];
         }
 
-        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1,
-                                 perf_event_open_cloexec_flag());
-        if (fd >= 0) {
-                close(fd);
-                ret = true;
+        while (1) {
+                fd = sys_perf_event_open(&evsel->attr, pid, cpu, -1,
+                                         perf_event_open_cloexec_flag());
+                if (fd < 0) {
+                        if (pid == -1 && errno == EACCES) {
+                                pid = 0;
+                                continue;
+                        }
+                        goto out_delete;
+                }
+                break;
         }
+        close(fd);
+        ret = true;
 
 out_delete:
         perf_evlist__delete(temp_evlist);
diff --git a/tools/perf/util/run-command.c b/tools/perf/util/run-command.c
index da8e9b285f51..34622b53e733 100644
--- a/tools/perf/util/run-command.c
+++ b/tools/perf/util/run-command.c
@@ -1,6 +1,7 @@
 #include "cache.h"
 #include "run-command.h"
 #include "exec_cmd.h"
+#include "debug.h"
 
 static inline void close_pair(int fd[2])
 {
@@ -19,6 +20,7 @@ int start_command(struct child_process *cmd)
 {
         int need_in, need_out, need_err;
         int fdin[2], fdout[2], fderr[2];
+        char sbuf[STRERR_BUFSIZE];
 
         /*
          * In case of errors we must keep the promise to close FDs
@@ -99,7 +101,7 @@ int start_command(struct child_process *cmd)
 
                 if (cmd->dir && chdir(cmd->dir))
                         die("exec %s: cd to %s failed (%s)", cmd->argv[0],
-                            cmd->dir, strerror(errno));
+                            cmd->dir, strerror_r(errno, sbuf, sizeof(sbuf)));
                 if (cmd->env) {
                         for (; *cmd->env; cmd->env++) {
                                 if (strchr(*cmd->env, '='))
@@ -153,6 +155,8 @@ int start_command(struct child_process *cmd)
 
 static int wait_or_whine(pid_t pid)
 {
+        char sbuf[STRERR_BUFSIZE];
+
         for (;;) {
                 int status, code;
                 pid_t waiting = waitpid(pid, &status, 0);
@@ -160,7 +164,8 @@ static int wait_or_whine(pid_t pid)
                 if (waiting < 0) {
                         if (errno == EINTR)
                                 continue;
-                        error("waitpid failed (%s)", strerror(errno));
+                        error("waitpid failed (%s)",
+                              strerror_r(errno, sbuf, sizeof(sbuf)));
                         return -ERR_RUN_COMMAND_WAITPID;
                 }
                 if (waiting != pid)
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index b2dba9c0a3a1..0a01bac4ce02 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -432,6 +432,11 @@ error:
         return err;
 }
 
+static int perl_flush_script(void)
+{
+        return 0;
+}
+
 /*
  * Stop trace script
  */
@@ -633,6 +638,7 @@ static int perl_generate_script(struct pevent *pevent, const char *outfile)
 struct scripting_ops perl_scripting_ops = {
         .name = "Perl",
         .start_script = perl_start_script,
+        .flush_script = perl_flush_script,
         .stop_script = perl_stop_script,
         .process_event = perl_process_event,
         .generate_script = perl_generate_script,
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index cbce2545da45..56ba07cce549 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -73,6 +73,35 @@ static void pydict_set_item_string_decref(PyObject *dict, const char *key, PyObj
         Py_DECREF(val);
 }
 
+static PyObject *get_handler(const char *handler_name)
+{
+        PyObject *handler;
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && !PyCallable_Check(handler))
+                return NULL;
+        return handler;
+}
+
+static void call_object(PyObject *handler, PyObject *args, const char *die_msg)
+{
+        PyObject *retval;
+
+        retval = PyObject_CallObject(handler, args);
+        if (retval == NULL)
+                handler_call_die(die_msg);
+        Py_DECREF(retval);
+}
+
+static void try_call_object(const char *handler_name, PyObject *args)
+{
+        PyObject *handler;
+
+        handler = get_handler(handler_name);
+        if (handler)
+                call_object(handler, args, handler_name);
+}
+
 static void define_value(enum print_arg_type field_type,
                          const char *ev_name,
                          const char *field_name,
@@ -80,7 +109,7 @@ static void define_value(enum print_arg_type field_type,
                          const char *field_str)
 {
         const char *handler_name = "define_flag_value";
-        PyObject *handler, *t, *retval;
+        PyObject *t;
         unsigned long long value;
         unsigned n = 0;
 
@@ -98,13 +127,7 @@ static void define_value(enum print_arg_type field_type,
         PyTuple_SetItem(t, n++, PyInt_FromLong(value));
         PyTuple_SetItem(t, n++, PyString_FromString(field_str));
 
-        handler = PyDict_GetItemString(main_dict, handler_name);
-        if (handler && PyCallable_Check(handler)) {
-                retval = PyObject_CallObject(handler, t);
-                if (retval == NULL)
-                        handler_call_die(handler_name);
-                Py_DECREF(retval);
-        }
+        try_call_object(handler_name, t);
 
         Py_DECREF(t);
 }
@@ -127,7 +150,7 @@ static void define_field(enum print_arg_type field_type,
                          const char *delim)
 {
         const char *handler_name = "define_flag_field";
-        PyObject *handler, *t, *retval;
+        PyObject *t;
         unsigned n = 0;
 
         if (field_type == PRINT_SYMBOL)
@@ -145,13 +168,7 @@ static void define_field(enum print_arg_type field_type,
         if (field_type == PRINT_FLAGS)
                 PyTuple_SetItem(t, n++, PyString_FromString(delim));
 
-        handler = PyDict_GetItemString(main_dict, handler_name);
-        if (handler && PyCallable_Check(handler)) {
-                retval = PyObject_CallObject(handler, t);
-                if (retval == NULL)
-                        handler_call_die(handler_name);
-                Py_DECREF(retval);
-        }
+        try_call_object(handler_name, t);
 
         Py_DECREF(t);
 }
@@ -362,7 +379,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
                                       struct thread *thread,
                                       struct addr_location *al)
 {
-        PyObject *handler, *retval, *context, *t, *obj, *callchain;
+        PyObject *handler, *context, *t, *obj, *callchain;
         PyObject *dict = NULL;
         static char handler_name[256];
         struct format_field *field;
@@ -387,9 +404,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
 
         sprintf(handler_name, "%s__%s", event->system, event->name);
 
-        handler = PyDict_GetItemString(main_dict, handler_name);
-        if (handler && !PyCallable_Check(handler))
-                handler = NULL;
+        handler = get_handler(handler_name);
         if (!handler) {
                 dict = PyDict_New();
                 if (!dict)
@@ -450,19 +465,9 @@ static void python_process_tracepoint(struct perf_sample *sample,
                 Py_FatalError("error resizing Python tuple");
 
         if (handler) {
-                retval = PyObject_CallObject(handler, t);
-                if (retval == NULL)
-                        handler_call_die(handler_name);
-                Py_DECREF(retval);
+                call_object(handler, t, handler_name);
         } else {
-                handler = PyDict_GetItemString(main_dict, "trace_unhandled");
-                if (handler && PyCallable_Check(handler)) {
-
-                        retval = PyObject_CallObject(handler, t);
-                        if (retval == NULL)
-                                handler_call_die("trace_unhandled");
-                        Py_DECREF(retval);
-                }
+                try_call_object("trace_unhandled", t);
                 Py_DECREF(dict);
         }
 
@@ -474,7 +479,7 @@ static void python_process_general_event(struct perf_sample *sample,
                                          struct thread *thread,
                                          struct addr_location *al)
 {
-        PyObject *handler, *retval, *t, *dict, *callchain, *dict_sample;
+        PyObject *handler, *t, *dict, *callchain, *dict_sample;
         static char handler_name[64];
         unsigned n = 0;
 
@@ -496,8 +501,8 @@ static void python_process_general_event(struct perf_sample *sample,
 
         snprintf(handler_name, sizeof(handler_name), "%s", "process_event");
 
-        handler = PyDict_GetItemString(main_dict, handler_name);
-        if (!handler || !PyCallable_Check(handler))
+        handler = get_handler(handler_name);
+        if (!handler)
                 goto exit;
 
         pydict_set_item_string_decref(dict, "ev_name", PyString_FromString(perf_evsel__name(evsel)));
@@ -539,10 +544,7 @@ static void python_process_general_event(struct perf_sample *sample,
         if (_PyTuple_Resize(&t, n) == -1)
                 Py_FatalError("error resizing Python tuple");
 
-        retval = PyObject_CallObject(handler, t);
-        if (retval == NULL)
-                handler_call_die(handler_name);
-        Py_DECREF(retval);
+        call_object(handler, t, handler_name);
 exit:
         Py_DECREF(dict);
         Py_DECREF(t);
@@ -566,36 +568,24 @@ static void python_process_event(union perf_event *event __maybe_unused,
 
 static int run_start_sub(void)
 {
-        PyObject *handler, *retval;
-        int err = 0;
-
         main_module = PyImport_AddModule("__main__");
         if (main_module == NULL)
                 return -1;
         Py_INCREF(main_module);
 
         main_dict = PyModule_GetDict(main_module);
-        if (main_dict == NULL) {
-                err = -1;
+        if (main_dict == NULL)
                 goto error;
-        }
         Py_INCREF(main_dict);
 
-        handler = PyDict_GetItemString(main_dict, "trace_begin");
-        if (handler == NULL || !PyCallable_Check(handler))
-                goto out;
+        try_call_object("trace_begin", NULL);
 
-        retval = PyObject_CallObject(handler, NULL);
-        if (retval == NULL)
-                handler_call_die("trace_begin");
+        return 0;
 
-        Py_DECREF(retval);
-        return err;
 error:
         Py_XDECREF(main_dict);
         Py_XDECREF(main_module);
-out:
-        return err;
+        return -1;
 }
 
 /*
@@ -649,28 +639,23 @@ error:
         return err;
 }
 
+static int python_flush_script(void)
+{
+        return 0;
+}
+
 /*
  * Stop trace script
  */
 static int python_stop_script(void)
 {
-        PyObject *handler, *retval;
-        int err = 0;
+        try_call_object("trace_end", NULL);
 
-        handler = PyDict_GetItemString(main_dict, "trace_end");
-        if (handler == NULL || !PyCallable_Check(handler))
-                goto out;
-
-        retval = PyObject_CallObject(handler, NULL);
-        if (retval == NULL)
-                handler_call_die("trace_end");
-        Py_DECREF(retval);
-out:
         Py_XDECREF(main_dict);
         Py_XDECREF(main_module);
         Py_Finalize();
 
-        return err;
+        return 0;
 }
 
 static int python_generate_script(struct pevent *pevent, const char *outfile)
@@ -843,6 +828,7 @@ static int python_generate_script(struct pevent *pevent, const char *outfile)
 struct scripting_ops python_scripting_ops = {
         .name = "Python",
         .start_script = python_start_script,
+        .flush_script = python_flush_script,
         .stop_script = python_stop_script,
         .process_event = python_process_event,
         .generate_script = python_generate_script,
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 88dfef70c13d..883406f4b381 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -14,6 +14,7 @@
 #include "util.h"
 #include "cpumap.h"
 #include "perf_regs.h"
+#include "asm/bug.h"
 
 static int perf_session__open(struct perf_session *session)
 {
@@ -66,6 +67,25 @@ static void perf_session__destroy_kernel_maps(struct perf_session *session)
         machines__destroy_kernel_maps(&session->machines);
 }
 
+static bool perf_session__has_comm_exec(struct perf_session *session)
+{
+        struct perf_evsel *evsel;
+
+        evlist__for_each(session->evlist, evsel) {
+                if (evsel->attr.comm_exec)
+                        return true;
+        }
+
+        return false;
+}
+
+static void perf_session__set_comm_exec(struct perf_session *session)
+{
+        bool comm_exec = perf_session__has_comm_exec(session);
+
+        machines__set_comm_exec(&session->machines, comm_exec);
+}
+
 struct perf_session *perf_session__new(struct perf_data_file *file,
                                        bool repipe, struct perf_tool *tool)
 {
@@ -75,9 +95,7 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                 goto out;
 
         session->repipe = repipe;
-        INIT_LIST_HEAD(&session->ordered_samples.samples);
-        INIT_LIST_HEAD(&session->ordered_samples.sample_cache);
-        INIT_LIST_HEAD(&session->ordered_samples.to_free);
+        ordered_events__init(&session->ordered_events);
         machines__init(&session->machines);
 
         if (file) {
@@ -91,6 +109,7 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                                 goto out_close;
 
                         perf_session__set_id_hdr_size(session);
+                        perf_session__set_comm_exec(session);
                 }
         }
 
@@ -100,13 +119,13 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                  * kernel MMAP event, in perf_event__process_mmap().
                  */
                 if (perf_session__create_kernel_maps(session) < 0)
-                        goto out_delete;
+                        pr_warning("Cannot read kernel map\n");
         }
 
         if (tool && tool->ordering_requires_timestamps &&
-            tool->ordered_samples && !perf_evlist__sample_id_all(session->evlist)) {
+            tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
                 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
-                tool->ordered_samples = false;
+                tool->ordered_events = false;
         }
 
         return session;
@@ -238,7 +257,7 @@ void perf_tool__fill_defaults(struct perf_tool *tool)
         if (tool->build_id == NULL)
                 tool->build_id = process_finished_round_stub;
         if (tool->finished_round == NULL) {
-                if (tool->ordered_samples)
+                if (tool->ordered_events)
                         tool->finished_round = process_finished_round;
                 else
                         tool->finished_round = process_finished_round_stub;
@@ -444,87 +463,6 @@ static perf_event__swap_op perf_event__swap_ops[] = {
         [PERF_RECORD_HEADER_MAX]          = NULL,
 };
 
-struct sample_queue {
-        u64                     timestamp;
-        u64                     file_offset;
-        union perf_event        *event;
-        struct list_head        list;
-};
-
-static void perf_session_free_sample_buffers(struct perf_session *session)
-{
-        struct ordered_samples *os = &session->ordered_samples;
-
-        while (!list_empty(&os->to_free)) {
-                struct sample_queue *sq;
-
-                sq = list_entry(os->to_free.next, struct sample_queue, list);
-                list_del(&sq->list);
-                free(sq);
-        }
-}
-
-static int perf_session_deliver_event(struct perf_session *session,
-                                      union perf_event *event,
-                                      struct perf_sample *sample,
-                                      struct perf_tool *tool,
-                                      u64 file_offset);
-
-static int flush_sample_queue(struct perf_session *s,
-                       struct perf_tool *tool)
-{
-        struct ordered_samples *os = &s->ordered_samples;
-        struct list_head *head = &os->samples;
-        struct sample_queue *tmp, *iter;
-        struct perf_sample sample;
-        u64 limit = os->next_flush;
-        u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
-        bool show_progress = limit == ULLONG_MAX;
-        struct ui_progress prog;
-        int ret;
-
-        if (!tool->ordered_samples || !limit)
-                return 0;
-
-        if (show_progress)
-                ui_progress__init(&prog, os->nr_samples, "Processing time ordered events...");
-
-        list_for_each_entry_safe(iter, tmp, head, list) {
-                if (session_done())
-                        return 0;
-
-                if (iter->timestamp > limit)
-                        break;
-
-                ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
-                if (ret)
-                        pr_err("Can't parse sample, err = %d\n", ret);
-                else {
-                        ret = perf_session_deliver_event(s, iter->event, &sample, tool,
-                                                         iter->file_offset);
-                        if (ret)
-                                return ret;
-                }
-
-                os->last_flush = iter->timestamp;
-                list_del(&iter->list);
-                list_add(&iter->list, &os->sample_cache);
-                os->nr_samples--;
-
-                if (show_progress)
-                        ui_progress__update(&prog, 1);
-        }
-
-        if (list_empty(head)) {
-                os->last_sample = NULL;
-        } else if (last_ts <= limit) {
-                os->last_sample =
-                        list_entry(head->prev, struct sample_queue, list);
-        }
-
-        return 0;
-}
-
 /*
  * When perf record finishes a pass on every buffers, it records this pseudo
  * event.
@@ -568,99 +506,43 @@ static int process_finished_round(struct perf_tool *tool,
                                   union perf_event *event __maybe_unused,
                                   struct perf_session *session)
 {
-        int ret = flush_sample_queue(session, tool);
-        if (!ret)
-                session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
-
-        return ret;
-}
-
-/* The queue is ordered by time */
-static void __queue_event(struct sample_queue *new, struct perf_session *s)
-{
-        struct ordered_samples *os = &s->ordered_samples;
-        struct sample_queue *sample = os->last_sample;
-        u64 timestamp = new->timestamp;
-        struct list_head *p;
-
-        ++os->nr_samples;
-        os->last_sample = new;
-
-        if (!sample) {
-                list_add(&new->list, &os->samples);
-                os->max_timestamp = timestamp;
-                return;
-        }
-
-        /*
-         * last_sample might point to some random place in the list as it's
-         * the last queued event. We expect that the new event is close to
-         * this.
-         */
-        if (sample->timestamp <= timestamp) {
-                while (sample->timestamp <= timestamp) {
-                        p = sample->list.next;
-                        if (p == &os->samples) {
-                                list_add_tail(&new->list, &os->samples);
-                                os->max_timestamp = timestamp;
-                                return;
-                        }
-                        sample = list_entry(p, struct sample_queue, list);
-                }
-                list_add_tail(&new->list, &sample->list);
-        } else {
-                while (sample->timestamp > timestamp) {
-                        p = sample->list.prev;
-                        if (p == &os->samples) {
-                                list_add(&new->list, &os->samples);
-                                return;
-                        }
-                        sample = list_entry(p, struct sample_queue, list);
-                }
-                list_add(&new->list, &sample->list);
-        }
+        return ordered_events__flush(session, tool, OE_FLUSH__ROUND);
 }
 
-#define MAX_SAMPLE_BUFFER       (64 * 1024 / sizeof(struct sample_queue))
-
 int perf_session_queue_event(struct perf_session *s, union perf_event *event,
-                                    struct perf_sample *sample, u64 file_offset)
+                             struct perf_tool *tool, struct perf_sample *sample,
+                             u64 file_offset)
 {
-        struct ordered_samples *os = &s->ordered_samples;
-        struct list_head *sc = &os->sample_cache;
+        struct ordered_events *oe = &s->ordered_events;
         u64 timestamp = sample->time;
-        struct sample_queue *new;
+        struct ordered_event *new;
 
         if (!timestamp || timestamp == ~0ULL)
                 return -ETIME;
 
-        if (timestamp < s->ordered_samples.last_flush) {
-                printf("Warning: Timestamp below last timeslice flush\n");
-                return -EINVAL;
+        if (timestamp < oe->last_flush) {
+                WARN_ONCE(1, "Timestamp below last timeslice flush\n");
+
+                pr_oe_time(timestamp,      "out of order event");
+                pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
+                           oe->last_flush_type);
+
+                /* We could get out of order messages after forced flush. */
+                if (oe->last_flush_type != OE_FLUSH__HALF)
+                        return -EINVAL;
         }
 
-        if (!list_empty(sc)) {
-                new = list_entry(sc->next, struct sample_queue, list);
-                list_del(&new->list);
-        } else if (os->sample_buffer) {
-                new = os->sample_buffer + os->sample_buffer_idx;
-                if (++os->sample_buffer_idx == MAX_SAMPLE_BUFFER)
-                        os->sample_buffer = NULL;
-        } else {
-                os->sample_buffer = malloc(MAX_SAMPLE_BUFFER * sizeof(*new));
-                if (!os->sample_buffer)
-                        return -ENOMEM;
-                list_add(&os->sample_buffer->list, &os->to_free);
-                os->sample_buffer_idx = 2;
-                new = os->sample_buffer + 1;
+        new = ordered_events__new(oe, timestamp);
+        if (!new) {
+                ordered_events__flush(s, tool, OE_FLUSH__HALF);
+                new = ordered_events__new(oe, timestamp);
         }
 
-        new->timestamp = timestamp;
+        if (!new)
+                return -ENOMEM;
+
         new->file_offset = file_offset;
         new->event = event;
-
-        __queue_event(new, s);
-
         return 0;
 }
 
@@ -920,11 +802,10 @@ perf_session__deliver_sample(struct perf_session *session,
                                             &sample->read.one, machine);
 }
 
-static int perf_session_deliver_event(struct perf_session *session,
-                                      union perf_event *event,
-                                      struct perf_sample *sample,
-                                      struct perf_tool *tool,
-                                      u64 file_offset)
+int perf_session__deliver_event(struct perf_session *session,
+                                union perf_event *event,
+                                struct perf_sample *sample,
+                                struct perf_tool *tool, u64 file_offset)
 {
         struct perf_evsel *evsel;
         struct machine *machine;
@@ -1005,8 +886,10 @@ static s64 perf_session__process_user_event(struct perf_session *session,
         switch (event->header.type) {
         case PERF_RECORD_HEADER_ATTR:
                 err = tool->attr(tool, event, &session->evlist);
-                if (err == 0)
+                if (err == 0) {
                         perf_session__set_id_hdr_size(session);
+                        perf_session__set_comm_exec(session);
+                }
                 return err;
         case PERF_RECORD_HEADER_EVENT_TYPE:
                 /*
@@ -1036,6 +919,61 @@ static void event_swap(union perf_event *event, bool sample_id_all)
                 swap(event, sample_id_all);
 }
 
+int perf_session__peek_event(struct perf_session *session, off_t file_offset,
+                             void *buf, size_t buf_sz,
+                             union perf_event **event_ptr,
+                             struct perf_sample *sample)
+{
+        union perf_event *event;
+        size_t hdr_sz, rest;
+        int fd;
+
+        if (session->one_mmap && !session->header.needs_swap) {
+                event = file_offset - session->one_mmap_offset +
+                        session->one_mmap_addr;
+                goto out_parse_sample;
+        }
+
+        if (perf_data_file__is_pipe(session->file))
+                return -1;
+
+        fd = perf_data_file__fd(session->file);
+        hdr_sz = sizeof(struct perf_event_header);
+
+        if (buf_sz < hdr_sz)
+                return -1;
+
+        if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 ||
+            readn(fd, &buf, hdr_sz) != (ssize_t)hdr_sz)
+                return -1;
+
+        event = (union perf_event *)buf;
+
+        if (session->header.needs_swap)
+                perf_event_header__bswap(&event->header);
+
+        if (event->header.size < hdr_sz)
+                return -1;
+
+        rest = event->header.size - hdr_sz;
+
+        if (readn(fd, &buf, rest) != (ssize_t)rest)
+                return -1;
+
+        if (session->header.needs_swap)
+                event_swap(event, perf_evlist__sample_id_all(session->evlist));
+
+out_parse_sample:
+
+        if (sample && event->header.type < PERF_RECORD_USER_TYPE_START &&
+            perf_evlist__parse_sample(session->evlist, event, sample))
+                return -1;
+
+        *event_ptr = event;
+
+        return 0;
+}
+
 static s64 perf_session__process_event(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_tool *tool,
@@ -1062,15 +1000,15 @@ static s64 perf_session__process_event(struct perf_session *session,
         if (ret)
                 return ret;
 
-        if (tool->ordered_samples) {
-                ret = perf_session_queue_event(session, event, &sample,
+        if (tool->ordered_events) {
+                ret = perf_session_queue_event(session, event, tool, &sample,
                                                file_offset);
                 if (ret != -ETIME)
                         return ret;
         }
 
-        return perf_session_deliver_event(session, event, &sample, tool,
-                                          file_offset);
+        return perf_session__deliver_event(session, event, &sample, tool,
+                                           file_offset);
 }
 
 void perf_event_header__bswap(struct perf_event_header *hdr)
@@ -1222,12 +1160,11 @@ more:
                 goto more;
 done:
         /* do the final flush for ordered samples */
-        session->ordered_samples.next_flush = ULLONG_MAX;
-        err = flush_sample_queue(session, tool);
+        err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
 out_err:
         free(buf);
         perf_session__warn_about_errors(session, tool);
-        perf_session_free_sample_buffers(session);
+        ordered_events__free(&session->ordered_events);
         return err;
 }
 
@@ -1368,12 +1305,11 @@ more:
 
 out:
         /* do the final flush for ordered samples */
-        session->ordered_samples.next_flush = ULLONG_MAX;
-        err = flush_sample_queue(session, tool);
+        err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
 out_err:
         ui_progress__finish();
         perf_session__warn_about_errors(session, tool);
-        perf_session_free_sample_buffers(session);
+        ordered_events__free(&session->ordered_events);
         session->one_mmap = false;
         return err;
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 0321013bd9fd..ffb440462008 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -9,26 +9,13 @@
 #include "symbol.h"
 #include "thread.h"
 #include "data.h"
+#include "ordered-events.h"
 #include <linux/rbtree.h>
 #include <linux/perf_event.h>
 
-struct sample_queue;
 struct ip_callchain;
 struct thread;
 
-struct ordered_samples {
-        u64                     last_flush;
-        u64                     next_flush;
-        u64                     max_timestamp;
-        struct list_head        samples;
-        struct list_head        sample_cache;
-        struct list_head        to_free;
-        struct sample_queue     *sample_buffer;
-        struct sample_queue     *last_sample;
-        int                     sample_buffer_idx;
-        unsigned int            nr_samples;
-};
-
 struct perf_session {
         struct perf_header      header;
         struct machines         machines;
@@ -39,7 +26,7 @@ struct perf_session {
         bool                    one_mmap;
         void                    *one_mmap_addr;
         u64                     one_mmap_offset;
-        struct ordered_samples  ordered_samples;
+        struct ordered_events   ordered_events;
         struct perf_data_file   *file;
 };
 
@@ -58,6 +45,11 @@ void perf_session__delete(struct perf_session *session);
 
 void perf_event_header__bswap(struct perf_event_header *hdr);
 
+int perf_session__peek_event(struct perf_session *session, off_t file_offset,
+                             void *buf, size_t buf_sz,
+                             union perf_event **event_ptr,
+                             struct perf_sample *sample);
+
 int __perf_session__process_events(struct perf_session *session,
                                    u64 data_offset, u64 data_size, u64 size,
                                    struct perf_tool *tool);
@@ -65,10 +57,16 @@ int perf_session__process_events(struct perf_session *session,
                                  struct perf_tool *tool);
 
 int perf_session_queue_event(struct perf_session *s, union perf_event *event,
-                             struct perf_sample *sample, u64 file_offset);
+                             struct perf_tool *tool, struct perf_sample *sample,
+                             u64 file_offset);
 
 void perf_tool__fill_defaults(struct perf_tool *tool);
 
+int perf_session__deliver_event(struct perf_session *session,
+                                union perf_event *event,
+                                struct perf_sample *sample,
+                                struct perf_tool *tool, u64 file_offset);
+
 int perf_session__resolve_callchain(struct perf_session *session,
                                     struct perf_evsel *evsel,
                                     struct thread *thread,
@@ -128,5 +126,5 @@ int __perf_session__set_tracepoints_handlers(struct perf_session *session,
 
 extern volatile int session_done;
 
-#define session_done()  (*(volatile int *)(&session_done))
+#define session_done()  ACCESS_ONCE(session_done)
 #endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 14e5a039bc45..289df9d1e65a 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -70,12 +70,14 @@ static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
                                        size_t size, unsigned int width)
 {
         const char *comm = thread__comm_str(he->thread);
-        return repsep_snprintf(bf, size, "%*s:%5d", width - 6,
-                               comm ?: "", he->thread->tid);
+
+        width = max(7U, width) - 6;
+        return repsep_snprintf(bf, size, "%5d:%-*.*s", he->thread->tid,
+                               width, width, comm ?: "");
 }
 
 struct sort_entry sort_thread = {
-        .se_header      = "Command:  Pid",
+        .se_header      = "  Pid:Command",
         .se_cmp         = sort__thread_cmp,
         .se_snprintf    = hist_entry__thread_snprintf,
         .se_width_idx   = HISTC_THREAD,
@@ -106,7 +108,7 @@ sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
                                      size_t size, unsigned int width)
 {
-        return repsep_snprintf(bf, size, "%*s", width, comm__str(he->comm));
+        return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
 }
 
 struct sort_entry sort_comm = {
@@ -152,10 +154,10 @@ static int _hist_entry__dso_snprintf(struct map *map, char *bf,
         if (map && map->dso) {
                 const char *dso_name = !verbose ? map->dso->short_name :
                         map->dso->long_name;
-                return repsep_snprintf(bf, size, "%-*s", width, dso_name);
+                return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
         }
 
-        return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
+        return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
 }
 
 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
@@ -257,7 +259,10 @@ static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
                                        width - ret, "");
         }
 
-        return ret;
+        if (ret > width)
+                bf[width] = '\0';
+
+        return width;
 }
 
 static int hist_entry__sym_snprintf(struct hist_entry *he, char *bf,
@@ -302,10 +307,9 @@ sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
 }
 
 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
-                                        size_t size,
-                                        unsigned int width __maybe_unused)
+                                        size_t size, unsigned int width)
 {
-        return repsep_snprintf(bf, size, "%s", he->srcline);
+        return repsep_snprintf(bf, size, "%*.*-s", width, width, he->srcline);
 }
 
 struct sort_entry sort_srcline = {
@@ -332,7 +336,7 @@ sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
                                        size_t size, unsigned int width)
 {
-        return repsep_snprintf(bf, size, "%-*s", width,
+        return repsep_snprintf(bf, size, "%-*.*s", width, width,
                               he->parent ? he->parent->name : "[other]");
 }
 
@@ -354,7 +358,7 @@ sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
                                     size_t size, unsigned int width)
 {
-        return repsep_snprintf(bf, size, "%*d", width, he->cpu);
+        return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
 }
 
 struct sort_entry sort_cpu = {
@@ -484,7 +488,7 @@ static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
         else if (he->branch_info->flags.mispred)
                 out = "Y";
 
-        return repsep_snprintf(bf, size, "%-*s", width, out);
+        return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
 }
 
 /* --sort daddr_sym */
@@ -1194,7 +1198,7 @@ bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
         return hse_a->se == hse_b->se;
 }
 
-void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
+void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
 {
         struct hpp_sort_entry *hse;
 
@@ -1202,20 +1206,21 @@ void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
                 return;
 
         hse = container_of(fmt, struct hpp_sort_entry, hpp);
-        hists__new_col_len(hists, hse->se->se_width_idx,
-                           strlen(hse->se->se_header));
+        hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
 }
 
 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
                               struct perf_evsel *evsel)
 {
         struct hpp_sort_entry *hse;
-        size_t len;
+        size_t len = fmt->user_len;
 
         hse = container_of(fmt, struct hpp_sort_entry, hpp);
-        len = hists__col_len(&evsel->hists, hse->se->se_width_idx);
 
-        return scnprintf(hpp->buf, hpp->size, "%-*s", len, hse->se->se_header);
+        if (!len)
+                len = hists__col_len(&evsel->hists, hse->se->se_width_idx);
+
+        return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
 }
 
 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
@@ -1223,20 +1228,26 @@ static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
                              struct perf_evsel *evsel)
 {
         struct hpp_sort_entry *hse;
+        size_t len = fmt->user_len;
 
         hse = container_of(fmt, struct hpp_sort_entry, hpp);
 
-        return hists__col_len(&evsel->hists, hse->se->se_width_idx);
+        if (!len)
+                len = hists__col_len(&evsel->hists, hse->se->se_width_idx);
+
+        return len;
 }
 
 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
                              struct hist_entry *he)
 {
         struct hpp_sort_entry *hse;
-        size_t len;
+        size_t len = fmt->user_len;
 
         hse = container_of(fmt, struct hpp_sort_entry, hpp);
-        len = hists__col_len(he->hists, hse->se->se_width_idx);
+
+        if (!len)
+                len = hists__col_len(he->hists, hse->se->se_width_idx);
 
         return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
 }
@@ -1253,6 +1264,7 @@ __sort_dimension__alloc_hpp(struct sort_dimension *sd)
         }
 
         hse->se = sd->entry;
+        hse->hpp.name = sd->entry->se_header;
         hse->hpp.header = __sort__hpp_header;
         hse->hpp.width = __sort__hpp_width;
         hse->hpp.entry = __sort__hpp_entry;
@@ -1265,6 +1277,8 @@ __sort_dimension__alloc_hpp(struct sort_dimension *sd)
         INIT_LIST_HEAD(&hse->hpp.list);
         INIT_LIST_HEAD(&hse->hpp.sort_list);
         hse->hpp.elide = false;
+        hse->hpp.len = 0;
+        hse->hpp.user_len = 0;
 
         return hse;
 }
@@ -1432,14 +1446,49 @@ static const char *get_default_sort_order(void)
         return default_sort_orders[sort__mode];
 }
 
+static int setup_sort_order(void)
+{
+        char *new_sort_order;
+
+        /*
+         * Append '+'-prefixed sort order to the default sort
+         * order string.
+         */
+        if (!sort_order || is_strict_order(sort_order))
+                return 0;
+
+        if (sort_order[1] == '\0') {
+                error("Invalid --sort key: `+'");
+                return -EINVAL;
+        }
+
+        /*
+         * We allocate new sort_order string, but we never free it,
+         * because it's checked over the rest of the code.
+         */
+        if (asprintf(&new_sort_order, "%s,%s",
+                     get_default_sort_order(), sort_order + 1) < 0) {
+                error("Not enough memory to set up --sort");
+                return -ENOMEM;
+        }
+
+        sort_order = new_sort_order;
+        return 0;
+}
+
 static int __setup_sorting(void)
 {
         char *tmp, *tok, *str;
-        const char *sort_keys = sort_order;
+        const char *sort_keys;
         int ret = 0;
 
+        ret = setup_sort_order();
+        if (ret)
+                return ret;
+
+        sort_keys = sort_order;
         if (sort_keys == NULL) {
-                if (field_order) {
+                if (is_strict_order(field_order)) {
                         /*
                          * If user specified field order but no sort order,
                          * we'll honor it and not add default sort orders.
@@ -1625,23 +1674,36 @@ static void reset_dimensions(void)
                 memory_sort_dimensions[i].taken = 0;
 }
 
+bool is_strict_order(const char *order)
+{
+        return order && (*order != '+');
+}
+
 static int __setup_output_field(void)
 {
-        char *tmp, *tok, *str;
-        int ret = 0;
+        char *tmp, *tok, *str, *strp;
+        int ret = -EINVAL;
 
         if (field_order == NULL)
                 return 0;
 
         reset_dimensions();
 
-        str = strdup(field_order);
+        strp = str = strdup(field_order);
         if (str == NULL) {
                 error("Not enough memory to setup output fields");
                 return -ENOMEM;
         }
 
-        for (tok = strtok_r(str, ", ", &tmp);
+        if (!is_strict_order(field_order))
+                strp++;
+
+        if (!strlen(strp)) {
+                error("Invalid --fields key: `+'");
+                goto out;
+        }
+
+        for (tok = strtok_r(strp, ", ", &tmp);
                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
                 ret = output_field_add(tok);
                 if (ret == -EINVAL) {
@@ -1653,6 +1715,7 @@ static int __setup_output_field(void)
                 }
         }
 
+out:
         free(str);
         return ret;
 }
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 041f0c9cea2b..c03e4ff8beff 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -218,4 +218,5 @@ void perf_hpp__set_elide(int idx, bool elide);
 
 int report_parse_ignore_callees_opt(const struct option *opt, const char *arg, int unset);
 
+bool is_strict_order(const char *order);
 #endif  /* __PERF_SORT_H */
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index d75349979e65..1e23a5bfb044 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -6,6 +6,7 @@
 #include <inttypes.h>
 
 #include "symbol.h"
+#include "machine.h"
 #include "vdso.h"
 #include <symbol/kallsyms.h>
 #include "debug.h"
@@ -680,6 +681,11 @@ static u64 ref_reloc(struct kmap *kmap)
         return 0;
 }
 
+static bool want_demangle(bool is_kernel_sym)
+{
+        return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
+}
+
 int dso__load_sym(struct dso *dso, struct map *map,
                   struct symsrc *syms_ss, struct symsrc *runtime_ss,
                   symbol_filter_t filter, int kmodule)
@@ -712,6 +718,14 @@ int dso__load_sym(struct dso *dso, struct map *map,
                 symbols__delete(&dso->symbols[map->type]);
 
         if (!syms_ss->symtab) {
+                /*
+                 * If the vmlinux is stripped, fail so we will fall back
+                 * to using kallsyms. The vmlinux runtime symbols aren't
+                 * of much use.
+                 */
+                if (dso->kernel)
+                        goto out_elf_end;
+
                 syms_ss->symtab  = syms_ss->dynsym;
                 syms_ss->symshdr = syms_ss->dynshdr;
         }
@@ -736,7 +750,7 @@ int dso__load_sym(struct dso *dso, struct map *map,
         if (symstrs == NULL)
                 goto out_elf_end;
 
-        sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
+        sec_strndx = elf_getscn(runtime_ss->elf, runtime_ss->ehdr.e_shstrndx);
         if (sec_strndx == NULL)
                 goto out_elf_end;
 
@@ -916,7 +930,11 @@ int dso__load_sym(struct dso *dso, struct map *map,
                                 }
                                 curr_dso->symtab_type = dso->symtab_type;
                                 map_groups__insert(kmap->kmaps, curr_map);
-                                dsos__add(&dso->node, curr_dso);
+                                /*
+                                 * The new DSO should go to the kernel DSOS
+                                 */
+                                dsos__add(&map->groups->machine->kernel_dsos,
+                                          curr_dso);
                                 dso__set_loaded(curr_dso, map->type);
                         } else
                                 curr_dso = curr_map->dso;
@@ -938,9 +956,12 @@ new_symbol:
                  * DWARF DW_compile_unit has this, but we don't always have access
                  * to it...
                  */
-                if (symbol_conf.demangle) {
-                        demangled = bfd_demangle(NULL, elf_name,
-                                                 DMGL_PARAMS | DMGL_ANSI);
+                if (want_demangle(dso->kernel || kmodule)) {
+                        int demangle_flags = DMGL_NO_OPTS;
+                        if (verbose)
+                                demangle_flags = DMGL_PARAMS | DMGL_ANSI;
+
+                        demangled = bfd_demangle(NULL, elf_name, demangle_flags);
                         if (demangled != NULL)
                                 elf_name = demangled;
                 }
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index eb06746b06b2..be84f7a9838b 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -15,6 +15,7 @@
 #include "machine.h"
 #include "symbol.h"
 #include "strlist.h"
+#include "header.h"
 
 #include <elf.h>
 #include <limits.h>
@@ -33,6 +34,7 @@ struct symbol_conf symbol_conf = {
         .try_vmlinux_path       = true,
         .annotate_src           = true,
         .demangle               = true,
+        .demangle_kernel        = false,
         .cumulate_callchain     = true,
         .show_hist_headers      = true,
         .symfs                  = "",
@@ -523,10 +525,15 @@ struct process_kallsyms_args {
         struct dso *dso;
 };
 
+/*
+ * These are symbols in the kernel image, so make sure that
+ * sym is from a kernel DSO.
+ */
 bool symbol__is_idle(struct symbol *sym)
 {
         const char * const idle_symbols[] = {
                 "cpu_idle",
+                "cpu_startup_entry",
                 "intel_idle",
                 "default_idle",
                 "native_safe_halt",
@@ -1468,8 +1475,7 @@ int dso__load_vmlinux(struct dso *dso, struct map *map,
         if (vmlinux[0] == '/')
                 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
         else
-                snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
-                         symbol_conf.symfs, vmlinux);
+                symbol__join_symfs(symfs_vmlinux, vmlinux);
 
         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
                 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
@@ -1745,12 +1751,13 @@ static void vmlinux_path__exit(void)
         zfree(&vmlinux_path);
 }
 
-static int vmlinux_path__init(void)
+static int vmlinux_path__init(struct perf_session_env *env)
 {
         struct utsname uts;
         char bf[PATH_MAX];
+        char *kernel_version;
 
-        vmlinux_path = malloc(sizeof(char *) * 5);
+        vmlinux_path = malloc(sizeof(char *) * 6);
         if (vmlinux_path == NULL)
                 return -1;
 
@@ -1763,25 +1770,37 @@ static int vmlinux_path__init(void)
                 goto out_fail;
         ++vmlinux_path__nr_entries;
 
-        /* only try running kernel version if no symfs was given */
+        /* only try kernel version if no symfs was given */
         if (symbol_conf.symfs[0] != 0)
                 return 0;
 
-        if (uname(&uts) < 0)
-                return -1;
+        if (env) {
+                kernel_version = env->os_release;
+        } else {
+                if (uname(&uts) < 0)
+                        goto out_fail;
 
-        snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
+                kernel_version = uts.release;
+        }
+
+        snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", kernel_version);
         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
                 goto out_fail;
         ++vmlinux_path__nr_entries;
-        snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
+        snprintf(bf, sizeof(bf), "/usr/lib/debug/boot/vmlinux-%s",
+                 kernel_version);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", kernel_version);
         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
                 goto out_fail;
         ++vmlinux_path__nr_entries;
         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
-                 uts.release);
+                 kernel_version);
         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
                 goto out_fail;
@@ -1827,7 +1846,7 @@ static bool symbol__read_kptr_restrict(void)
         return value;
 }
 
-int symbol__init(void)
+int symbol__init(struct perf_session_env *env)
 {
         const char *symfs;
 
@@ -1842,7 +1861,7 @@ int symbol__init(void)
                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
                                           sizeof(struct symbol));
 
-        if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
+        if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0)
                 return -1;
 
         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index e7295e93cff9..bec4b7bd09de 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -13,6 +13,7 @@
 #include <libgen.h>
 #include "build-id.h"
 #include "event.h"
+#include "util.h"
 
 #ifdef HAVE_LIBELF_SUPPORT
 #include <libelf.h>
@@ -59,6 +60,7 @@ extern Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 #endif
 
 #ifndef DMGL_PARAMS
+#define DMGL_NO_OPTS     0              /* For readability... */
 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
 #endif
@@ -118,6 +120,7 @@ struct symbol_conf {
                         annotate_src,
                         event_group,
                         demangle,
+                        demangle_kernel,
                         filter_relative,
                         show_hist_headers;
         const char      *vmlinux_name,
@@ -143,6 +146,14 @@ struct symbol_conf {
 };
 
 extern struct symbol_conf symbol_conf;
+
+static inline int __symbol__join_symfs(char *bf, size_t size, const char *path)
+{
+        return path__join(bf, size, symbol_conf.symfs, path);
+}
+
+#define symbol__join_symfs(bf, path) __symbol__join_symfs(bf, sizeof(bf), path)
+
 extern int vmlinux_path__nr_entries;
 extern char **vmlinux_path;
 
@@ -253,7 +264,8 @@ int modules__parse(const char *filename, void *arg,
 int filename__read_debuglink(const char *filename, char *debuglink,
                              size_t size);
 
-int symbol__init(void);
+struct perf_session_env;
+int symbol__init(struct perf_session_env *env);
 void symbol__exit(void);
 void symbol__elf_init(void);
 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name);
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 12c7a253a63c..a9df7f2c6dc9 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -42,7 +42,7 @@ struct thread *thread__new(pid_t pid, pid_t tid)
                         goto err_thread;
 
                 snprintf(comm_str, 32, ":%d", tid);
-                comm = comm__new(comm_str, 0);
+                comm = comm__new(comm_str, 0, false);
                 free(comm_str);
                 if (!comm)
                         goto err_thread;
@@ -81,19 +81,33 @@ struct comm *thread__comm(const struct thread *thread)
         return list_first_entry(&thread->comm_list, struct comm, list);
 }
 
+struct comm *thread__exec_comm(const struct thread *thread)
+{
+        struct comm *comm, *last = NULL;
+
+        list_for_each_entry(comm, &thread->comm_list, list) {
+                if (comm->exec)
+                        return comm;
+                last = comm;
+        }
+
+        return last;
+}
+
 /* CHECKME: time should always be 0 if event aren't ordered */
-int thread__set_comm(struct thread *thread, const char *str, u64 timestamp)
+int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp,
+                       bool exec)
 {
         struct comm *new, *curr = thread__comm(thread);
         int err;
 
         /* Override latest entry if it had no specific time coverage */
-        if (!curr->start) {
-                err = comm__override(curr, str, timestamp);
+        if (!curr->start && !curr->exec) {
+                err = comm__override(curr, str, timestamp, exec);
                 if (err)
                         return err;
         } else {
-                new = comm__new(str, timestamp);
+                new = comm__new(str, timestamp, exec);
                 if (!new)
                         return -ENOMEM;
                 list_add(&new->list, &thread->comm_list);
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 716b7723cce2..8c75fa774706 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -38,9 +38,17 @@ static inline void thread__exited(struct thread *thread)
         thread->dead = true;
 }
 
-int thread__set_comm(struct thread *thread, const char *comm, u64 timestamp);
+int __thread__set_comm(struct thread *thread, const char *comm, u64 timestamp,
+                       bool exec);
+static inline int thread__set_comm(struct thread *thread, const char *comm,
+                                   u64 timestamp)
+{
+        return __thread__set_comm(thread, comm, timestamp, false);
+}
+
 int thread__comm_len(struct thread *thread);
 struct comm *thread__comm(const struct thread *thread);
+struct comm *thread__exec_comm(const struct thread *thread);
 const char *thread__comm_str(const struct thread *thread);
 void thread__insert_map(struct thread *thread, struct map *map);
 int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp);
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index 4385816d3d49..f11636966a0f 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -40,7 +40,7 @@ struct perf_tool {
         event_op2       tracing_data;
         event_op2       finished_round,
                         build_id;
-        bool            ordered_samples;
+        bool            ordered_events;
         bool            ordering_requires_timestamps;
 };
 
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index 57aaccc1692e..5c9bdd1591a9 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -30,6 +30,11 @@
 
 struct scripting_context *scripting_context;
 
+static int flush_script_unsupported(void)
+{
+        return 0;
+}
+
 static int stop_script_unsupported(void)
 {
         return 0;
@@ -74,6 +79,7 @@ static int python_generate_script_unsupported(struct pevent *pevent
 struct scripting_ops python_scripting_unsupported_ops = {
         .name = "Python",
         .start_script = python_start_script_unsupported,
+        .flush_script = flush_script_unsupported,
         .stop_script = stop_script_unsupported,
         .process_event = process_event_unsupported,
         .generate_script = python_generate_script_unsupported,
@@ -137,6 +143,7 @@ static int perl_generate_script_unsupported(struct pevent *pevent
 struct scripting_ops perl_scripting_unsupported_ops = {
         .name = "Perl",
         .start_script = perl_start_script_unsupported,
+        .flush_script = flush_script_unsupported,
         .stop_script = stop_script_unsupported,
         .process_event = process_event_unsupported,
         .generate_script = perl_generate_script_unsupported,
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 7b6d68688327..52aaa19e1eb1 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -64,6 +64,7 @@ struct perf_session;
 struct scripting_ops {
         const char *name;
         int (*start_script) (const char *script, int argc, const char **argv);
+        int (*flush_script) (void);
         int (*stop_script) (void);
         void (*process_event) (union perf_event *event,
                                struct perf_sample *sample,
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index e52e7461911b..24e8d871b74e 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -13,6 +13,7 @@
 #include <limits.h>
 #include <byteswap.h>
 #include <linux/kernel.h>
+#include <unistd.h>
 
 /*
  * XXX We need to find a better place for these things...
@@ -282,6 +283,18 @@ void get_term_dimensions(struct winsize *ws)
         ws->ws_col = 80;
 }
 
+void set_term_quiet_input(struct termios *old)
+{
+        struct termios tc;
+
+        tcgetattr(0, old);
+        tc = *old;
+        tc.c_lflag &= ~(ICANON | ECHO);
+        tc.c_cc[VMIN] = 0;
+        tc.c_cc[VTIME] = 0;
+        tcsetattr(0, TCSANOW, &tc);
+}
+
 static void set_tracing_events_path(const char *mountpoint)
 {
         snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
@@ -443,6 +456,7 @@ int filename__read_str(const char *filename, char **buf, size_t *sizep)
         size_t size = 0, alloc_size = 0;
         void *bf = NULL, *nbf;
         int fd, n, err = 0;
+        char sbuf[STRERR_BUFSIZE];
 
         fd = open(filename, O_RDONLY);
         if (fd < 0)
@@ -463,8 +477,8 @@ int filename__read_str(const char *filename, char **buf, size_t *sizep)
                 n = read(fd, bf + size, alloc_size - size);
                 if (n < 0) {
                         if (size) {
-                                pr_warning("read failed %d: %s\n",
-                                           errno, strerror(errno));
+                                pr_warning("read failed %d: %s\n", errno,
+                                         strerror_r(errno, sbuf, sizeof(sbuf)));
                                 err = 0;
                         } else
                                 err = -errno;
@@ -536,3 +550,39 @@ void mem_bswap_64(void *src, int byte_size)
                 ++m;
         }
 }
+
+bool find_process(const char *name)
+{
+        size_t len = strlen(name);
+        DIR *dir;
+        struct dirent *d;
+        int ret = -1;
+
+        dir = opendir(procfs__mountpoint());
+        if (!dir)
+                return -1;
+
+        /* Walk through the directory. */
+        while (ret && (d = readdir(dir)) != NULL) {
+                char path[PATH_MAX];
+                char *data;
+                size_t size;
+
+                if ((d->d_type != DT_DIR) ||
+                     !strcmp(".", d->d_name) ||
+                     !strcmp("..", d->d_name))
+                        continue;
+
+                scnprintf(path, sizeof(path), "%s/%s/comm",
+                          procfs__mountpoint(), d->d_name);
+
+                if (filename__read_str(path, &data, &size))
+                        continue;
+
+                ret = strncmp(name, data, len);
+                free(data);
+        }
+
+        closedir(dir);
+        return ret ? false : true;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 66864364ccb4..80bfdaa0e2a4 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -39,6 +39,8 @@
 
 #define _ALL_SOURCE 1
 #define _BSD_SOURCE 1
+/* glibc 2.20 deprecates _BSD_SOURCE in favour of _DEFAULT_SOURCE */
+#define _DEFAULT_SOURCE 1
 #define HAS_BOOL
 
 #include <unistd.h>
@@ -64,16 +66,18 @@
 #include <regex.h>
 #include <utime.h>
 #include <sys/wait.h>
-#include <sys/poll.h>
+#include <poll.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <inttypes.h>
+#include <linux/kernel.h>
 #include <linux/magic.h>
 #include <linux/types.h>
 #include <sys/ttydefaults.h>
 #include <api/fs/debugfs.h>
 #include <termios.h>
 #include <linux/bitops.h>
+#include <termios.h>
 
 extern const char *graph_line;
 extern const char *graph_dotted_line;
@@ -307,6 +311,7 @@ extern unsigned int page_size;
 extern int cacheline_size;
 
 void get_term_dimensions(struct winsize *ws);
+void set_term_quiet_input(struct termios *old);
 
 struct parse_tag {
         char tag;
@@ -317,6 +322,21 @@ unsigned long parse_tag_value(const char *str, struct parse_tag *tags);
 
 #define SRCLINE_UNKNOWN  ((char *) "??:0")
 
+static inline int path__join(char *bf, size_t size,
+                             const char *path1, const char *path2)
+{
+        return scnprintf(bf, size, "%s%s%s", path1, path1[0] ? "/" : "", path2);
+}
+
+static inline int path__join3(char *bf, size_t size,
+                              const char *path1, const char *path2,
+                              const char *path3)
+{
+        return scnprintf(bf, size, "%s%s%s%s%s",
+                         path1, path1[0] ? "/" : "",
+                         path2, path2[0] ? "/" : "", path3);
+}
+
 struct dso;
 
 char *get_srcline(struct dso *dso, unsigned long addr);
@@ -330,4 +350,5 @@ void mem_bswap_64(void *src, int byte_size);
 void mem_bswap_32(void *src, int byte_size);
 
 const char *get_filename_for_perf_kvm(void);
+bool find_process(const char *name);
 #endif /* GIT_COMPAT_UTIL_H */