183 files changed, 5059 insertions, 1607 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/string.c b/tools/perf/util/string.c
index 2553e5b55b89..d87767f76903 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -9,78 +9,48 @@
  */
 s64 perf_atoll(const char *str)
 {
-        unsigned int i;
-        s64 length = -1, unit = 1;
+        s64 length;
+        char *p;
+        char c;
 
         if (!isdigit(str[0]))
                 goto out_err;
 
-        for (i = 1; i < strlen(str); i++) {
-                switch (str[i]) {
-                case 'B':
-                case 'b':
-                        break;
-                case 'K':
-                        if (str[i + 1] != 'B')
-                                goto out_err;
-                        else
-                                goto kilo;
-                case 'k':
-                        if (str[i + 1] != 'b')
-                                goto out_err;
-kilo:
-                        unit = K;
-                        break;
-                case 'M':
-                        if (str[i + 1] != 'B')
-                                goto out_err;
-                        else
-                                goto mega;
-                case 'm':
-                        if (str[i + 1] != 'b')
+        length = strtoll(str, &p, 10);
+        switch (c = *p++) {
+                case 'b': case 'B':
+                        if (*p)
                                 goto out_err;
-mega:
-                        unit = K * K;
+                case '\0':
+                        return length;
+                default:
+                        goto out_err;
+                /* two-letter suffices */
+                case 'k': case 'K':
+                        length <<= 10;
                         break;
-                case 'G':
-                        if (str[i + 1] != 'B')
-                                goto out_err;
-                        else
-                                goto giga;
-                case 'g':
-                        if (str[i + 1] != 'b')
-                                goto out_err;
-giga:
-                        unit = K * K * K;
+                case 'm': case 'M':
+                        length <<= 20;
                         break;
-                case 'T':
-                        if (str[i + 1] != 'B')
-                                goto out_err;
-                        else
-                                goto tera;
-                case 't':
-                        if (str[i + 1] != 'b')
-                                goto out_err;
-tera:
-                        unit = K * K * K * K;
+                case 'g': case 'G':
+                        length <<= 30;
                         break;
-                case '\0':      /* only specified figures */
-                        unit = 1;
+                case 't': case 'T':
+                        length <<= 40;
                         break;
-                default:
-                        if (!isdigit(str[i]))
-                                goto out_err;
-                        break;
-                }
         }
-
-        length = atoll(str) * unit;
-        goto out;
+        /* we want the cases to match */
+        if (islower(c)) {
+                if (strcmp(p, "b") != 0)
+                        goto out_err;
+        } else {
+                if (strcmp(p, "B") != 0)
+                        goto out_err;
+        }
+        return length;
 
 out_err:
-        length = -1;
-out:
-        return length;
+        return -1;
 }
 
 /*
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 */
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 55ab700f6ba5..bf1398180785 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -194,6 +194,7 @@ my $config_bisect_check;
 
 my $patchcheck_type;
 my $patchcheck_start;
+my $patchcheck_cherry;
 my $patchcheck_end;
 
 # set when a test is something other that just building or install
@@ -320,6 +321,7 @@ my %option_map = (
 
     "PATCHCHECK_TYPE"           => \$patchcheck_type,
     "PATCHCHECK_START"          => \$patchcheck_start,
+    "PATCHCHECK_CHERRY"         => \$patchcheck_cherry,
     "PATCHCHECK_END"            => \$patchcheck_end,
 );
 
@@ -1448,6 +1450,12 @@ sub wait_for_monitor {
         }
     }
     print "** Monitor flushed **\n";
+
+    # if stop is defined but wasn't hit, return error
+    # used by reboot (which wants to see a reboot)
+    if (defined($stop) && !$booted) {
+        $bug = 1;
+    }
     return $bug;
 }
 
@@ -2336,15 +2344,17 @@ sub success {
 
 sub answer_bisect {
     for (;;) {
-        doprint "Pass or fail? [p/f]";
+        doprint "Pass, fail, or skip? [p/f/s]";
         my $ans = <STDIN>;
         chomp $ans;
         if ($ans eq "p" || $ans eq "P") {
             return 1;
         } elsif ($ans eq "f" || $ans eq "F") {
             return 0;
+        } elsif ($ans eq "s" || $ans eq "S") {
+            return -1;
         } else {
-            print "Please answer 'P' or 'F'\n";
+            print "Please answer 'p', 'f', or 's'\n";
         }
     }
 }
@@ -2726,15 +2736,17 @@ sub bisect {
     run_command "git bisect start$start_files" or
         dodie "could not start bisect";
 
-    run_command "git bisect good $good" or
-        dodie "could not set bisect good to $good";
-
-    run_git_bisect "git bisect bad $bad" or
-        dodie "could not set bisect bad to $bad";
-
     if (defined($replay)) {
         run_command "git bisect replay $replay" or
             dodie "failed to run replay";
+    } else {
+
+        run_command "git bisect good $good" or
+            dodie "could not set bisect good to $good";
+
+        run_git_bisect "git bisect bad $bad" or
+            dodie "could not set bisect bad to $bad";
+
     }
 
     if (defined($start)) {
@@ -3181,9 +3193,16 @@ sub patchcheck {
 
     my $start = $patchcheck_start;
 
+    my $cherry = $patchcheck_cherry;
+    if (!defined($cherry)) {
+        $cherry = 0;
+    }
+
     my $end = "HEAD";
     if (defined($patchcheck_end)) {
         $end = $patchcheck_end;
+    } elsif ($cherry) {
+        die "PATCHCHECK_END must be defined with PATCHCHECK_CHERRY\n";
     }
 
     # Get the true sha1's since we can use things like HEAD~3
@@ -3197,24 +3216,38 @@ sub patchcheck {
         $type = "boot";
     }
 
-    open (IN, "git log --pretty=oneline $end|") or
-        dodie "could not get git list";
+    if ($cherry) {
+        open (IN, "git cherry -v $start $end|") or
+            dodie "could not get git list";
+    } else {
+        open (IN, "git log --pretty=oneline $end|") or
+            dodie "could not get git list";
+    }
 
     my @list;
 
     while (<IN>) {
         chomp;
+        # git cherry adds a '+' we want to remove
+        s/^\+ //;
         $list[$#list+1] = $_;
         last if (/^$start/);
     }
     close(IN);
 
-    if ($list[$#list] !~ /^$start/) {
-        fail "SHA1 $start not found";
+    if (!$cherry) {
+        if ($list[$#list] !~ /^$start/) {
+            fail "SHA1 $start not found";
+        }
+
+        # go backwards in the list
+        @list = reverse @list;
     }
 
-    # go backwards in the list
-    @list = reverse @list;
+    doprint("Going to test the following commits:\n");
+    foreach my $l (@list) {
+        doprint "$l\n";
+    }
 
     my $save_clean = $noclean;
     my %ignored_warnings;
diff --git a/tools/testing/ktest/sample.conf b/tools/testing/ktest/sample.conf
index 911e45ad657a..6c58cd8bbbae 100644
--- a/tools/testing/ktest/sample.conf
+++ b/tools/testing/ktest/sample.conf
@@ -906,6 +906,16 @@
 #
 #  PATCHCHECK_END is the last patch to check (default HEAD)
 #
+#  PATCHCHECK_CHERRY if set to non zero, then git cherry will be
+#      performed against PATCHCHECK_START and PATCHCHECK_END. That is
+#
+#      git cherry ${PATCHCHECK_START} ${PATCHCHECK_END}
+#
+#      Then the changes found will be tested.
+#
+#      Note, PATCHCHECK_CHERRY requires PATCHCHECK_END to be defined.
+#      (default 0)
+#
 #  PATCHCHECK_TYPE is required and is the type of test to run:
 #      build, boot, test.
 #
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 36ff2e4c7b6f..45f145c6f843 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -14,6 +14,7 @@ TARGETS += powerpc
 TARGETS += user
 TARGETS += sysctl
 TARGETS += firmware
+TARGETS += ftrace
 
 TARGETS_HOTPLUG = cpu-hotplug
 TARGETS_HOTPLUG += memory-hotplug
diff --git a/tools/testing/selftests/ftrace/Makefile b/tools/testing/selftests/ftrace/Makefile
new file mode 100644
index 000000000000..76cc9f156267
--- /dev/null
+++ b/tools/testing/selftests/ftrace/Makefile
@@ -0,0 +1,7 @@
+all:
+
+run_tests:
+        @/bin/sh ./ftracetest || echo "ftrace selftests: [FAIL]"
+
+clean:
+        rm -rf logs/*
diff --git a/tools/testing/selftests/ftrace/README b/tools/testing/selftests/ftrace/README
new file mode 100644
index 000000000000..182e76fa4b82
--- /dev/null
+++ b/tools/testing/selftests/ftrace/README
@@ -0,0 +1,82 @@
+Linux Ftrace Testcases
+
+This is a collection of testcases for ftrace tracing feature in the Linux
+kernel. Since ftrace exports interfaces via the debugfs, we just need
+shell scripts for testing. Feel free to add new test cases.
+
+Running the ftrace testcases
+============================
+
+At first, you need to be the root user to run this script.
+To run all testcases:
+
+  $ sudo ./ftracetest
+
+To run specific testcases:
+
+  # ./ftracetest test.d/basic3.tc
+
+Or you can also run testcases under given directory:
+
+  # ./ftracetest test.d/kprobe/
+
+Contributing new testcases
+==========================
+
+Copy test.d/template to your testcase (whose filename must have *.tc
+extension) and rewrite the test description line.
+
+ * The working directory of the script is <debugfs>/tracing/.
+
+ * Take care with side effects as the tests are run with root privilege.
+
+ * The tests should not run for a long period of time (more than 1 min.)
+   These are to be unit tests.
+
+ * You can add a directory for your testcases under test.d/ if needed.
+
+ * The test cases should run on dash (busybox shell) for testing on
+   minimal cross-build environments.
+
+ * Note that the tests are run with "set -e" (errexit) option. If any
+   command fails, the test will be terminated immediately.
+
+ * The tests can return some result codes instead of pass or fail by
+   using exit_unresolved, exit_untested, exit_unsupported and exit_xfail.
+
+Result code
+===========
+
+Ftracetest supports following result codes.
+
+ * PASS: The test succeeded as expected. The test which exits with 0 is
+         counted as passed test.
+
+ * FAIL: The test failed, but was expected to succeed. The test which exits
+         with !0 is counted as failed test.
+
+ * UNRESOLVED: The test produced unclear or intermidiate results.
+             for example, the test was interrupted
+                       or the test depends on a previous test, which failed.
+                       or the test was set up incorrectly
+             The test which is in above situation, must call exit_unresolved.
+
+ * UNTESTED: The test was not run, currently just a placeholder.
+             In this case, the test must call exit_untested.
+
+ * UNSUPPORTED: The test failed because of lack of feature.
+               In this case, the test must call exit_unsupported.
+
+ * XFAIL: The test failed, and was expected to fail.
+          To return XFAIL, call exit_xfail from the test.
+
+There are some sample test scripts for result code under samples/.
+You can also run samples as below:
+
+  # ./ftracetest samples/
+
+TODO
+====
+
+ * Fancy colored output :)
+
diff --git a/tools/testing/selftests/ftrace/ftracetest b/tools/testing/selftests/ftrace/ftracetest
new file mode 100755
index 000000000000..a8f81c782856
--- /dev/null
+++ b/tools/testing/selftests/ftrace/ftracetest
@@ -0,0 +1,253 @@
+#!/bin/sh
+
+# ftracetest - Ftrace test shell scripts
+#
+# Copyright (C) Hitachi Ltd., 2014
+#  Written by Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
+#
+# Released under the terms of the GPL v2.
+
+usage() { # errno [message]
+[ "$2" ] && echo $2
+echo "Usage: ftracetest [options] [testcase(s)] [testcase-directory(s)]"
+echo " Options:"
+echo "          -h|--help  Show help message"
+echo "          -k|--keep  Keep passed test logs"
+echo "          -d|--debug Debug mode (trace all shell commands)"
+exit $1
+}
+
+errexit() { # message
+  echo "Error: $1" 1>&2
+  exit 1
+}
+
+# Ensuring user privilege
+if [ `id -u` -ne 0 ]; then
+  errexit "this must be run by root user"
+fi
+
+# Utilities
+absdir() { # file_path
+  (cd `dirname $1`; pwd)
+}
+
+abspath() {
+  echo `absdir $1`/`basename $1`
+}
+
+find_testcases() { #directory
+  echo `find $1 -name \*.tc`
+}
+
+parse_opts() { # opts
+  local OPT_TEST_CASES=
+  local OPT_TEST_DIR=
+
+  while [ "$1" ]; do
+    case "$1" in
+    --help|-h)
+      usage 0
+    ;;
+    --keep|-k)
+      KEEP_LOG=1
+      shift 1
+    ;;
+    --debug|-d)
+      DEBUG=1
+      shift 1
+    ;;
+    *.tc)
+      if [ -f "$1" ]; then
+        OPT_TEST_CASES="$OPT_TEST_CASES `abspath $1`"
+        shift 1
+      else
+        usage 1 "$1 is not a testcase"
+      fi
+      ;;
+    *)
+      if [ -d "$1" ]; then
+        OPT_TEST_DIR=`abspath $1`
+        OPT_TEST_CASES="$OPT_TEST_CASES `find_testcases $OPT_TEST_DIR`"
+        shift 1
+      else
+        usage 1 "Invalid option ($1)"
+      fi
+    ;;
+    esac
+  done
+  if [ "$OPT_TEST_CASES" ]; then
+    TEST_CASES=$OPT_TEST_CASES
+  fi
+}
+
+# Parameters
+DEBUGFS_DIR=`grep debugfs /proc/mounts | cut -f2 -d' '`
+TRACING_DIR=$DEBUGFS_DIR/tracing
+TOP_DIR=`absdir $0`
+TEST_DIR=$TOP_DIR/test.d
+TEST_CASES=`find_testcases $TEST_DIR`
+LOG_DIR=$TOP_DIR/logs/`date +%Y%m%d-%H%M%S`/
+KEEP_LOG=0
+DEBUG=0
+# Parse command-line options
+parse_opts $*
+
+[ $DEBUG -ne 0 ] && set -x
+
+# Verify parameters
+if [ -z "$DEBUGFS_DIR" -o ! -d "$TRACING_DIR" ]; then
+  errexit "No ftrace directory found"
+fi
+
+# Preparing logs
+LOG_FILE=$LOG_DIR/ftracetest.log
+mkdir -p $LOG_DIR || errexit "Failed to make a log directory: $LOG_DIR"
+date > $LOG_FILE
+prlog() { # messages
+  echo "$@" | tee -a $LOG_FILE
+}
+catlog() { #file
+  cat $1 | tee -a $LOG_FILE
+}
+prlog "=== Ftrace unit tests ==="
+
+
+# Testcase management
+# Test result codes - Dejagnu extended code
+PASS=0  # The test succeeded.
+FAIL=1  # The test failed, but was expected to succeed.
+UNRESOLVED=2  # The test produced indeterminate results. (e.g. interrupted)
+UNTESTED=3    # The test was not run, currently just a placeholder.
+UNSUPPORTED=4 # The test failed because of lack of feature.
+XFAIL=5 # The test failed, and was expected to fail.
+
+# Accumulations
+PASSED_CASES=
+FAILED_CASES=
+UNRESOLVED_CASES=
+UNTESTED_CASES=
+UNSUPPORTED_CASES=
+XFAILED_CASES=
+UNDEFINED_CASES=
+TOTAL_RESULT=0
+
+CASENO=0
+testcase() { # testfile
+  CASENO=$((CASENO+1))
+  prlog -n "[$CASENO]"`grep "^#[ \t]*description:" $1 | cut -f2 -d:`
+}
+
+eval_result() { # retval sigval
+  local retval=$2
+  if [ $2 -eq 0 ]; then
+    test $1 -ne 0 && retval=$FAIL
+  fi
+  case $retval in
+    $PASS)
+      prlog "   [PASS]"
+      PASSED_CASES="$PASSED_CASES $CASENO"
+      return 0
+    ;;
+    $FAIL)
+      prlog "   [FAIL]"
+      FAILED_CASES="$FAILED_CASES $CASENO"
+      return 1 # this is a bug.
+    ;;
+    $UNRESOLVED)
+      prlog "   [UNRESOLVED]"
+      UNRESOLVED_CASES="$UNRESOLVED_CASES $CASENO"
+      return 1 # this is a kind of bug.. something happened.
+    ;;
+    $UNTESTED)
+      prlog "   [UNTESTED]"
+      UNTESTED_CASES="$UNTESTED_CASES $CASENO"
+      return 0
+    ;;
+    $UNSUPPORTED)
+      prlog "   [UNSUPPORTED]"
+      UNSUPPORTED_CASES="$UNSUPPORTED_CASES $CASENO"
+      return 1 # this is not a bug, but the result should be reported.
+    ;;
+    $XFAIL)
+      prlog "   [XFAIL]"
+      XFAILED_CASES="$XFAILED_CASES $CASENO"
+      return 0
+    ;;
+    *)
+      prlog "   [UNDEFINED]"
+      UNDEFINED_CASES="$UNDEFINED_CASES $CASENO"
+      return 1 # this must be a test bug
+    ;;
+  esac
+}
+
+# Signal handling for result codes
+SIG_RESULT=
+SIG_BASE=36     # Use realtime signals
+SIG_PID=$$
+
+SIG_UNRESOLVED=$((SIG_BASE + UNRESOLVED))
+exit_unresolved () {
+  kill -s $SIG_UNRESOLVED $SIG_PID
+  exit 0
+}
+trap 'SIG_RESULT=$UNRESOLVED' $SIG_UNRESOLVED
+
+SIG_UNTESTED=$((SIG_BASE + UNTESTED))
+exit_untested () {
+  kill -s $SIG_UNTESTED $SIG_PID
+  exit 0
+}
+trap 'SIG_RESULT=$UNTESTED' $SIG_UNTESTED
+
+SIG_UNSUPPORTED=$((SIG_BASE + UNSUPPORTED))
+exit_unsupported () {
+  kill -s $SIG_UNSUPPORTED $SIG_PID
+  exit 0
+}
+trap 'SIG_RESULT=$UNSUPPORTED' $SIG_UNSUPPORTED
+
+SIG_XFAIL=$((SIG_BASE + XFAIL))
+exit_xfail () {
+  kill -s $SIG_XFAIL $SIG_PID
+  exit 0
+}
+trap 'SIG_RESULT=$XFAIL' $SIG_XFAIL
+
+# Run one test case
+run_test() { # testfile
+  local testname=`basename $1`
+  local testlog=`mktemp --tmpdir=$LOG_DIR ${testname}-XXXXXX.log`
+  testcase $1
+  echo "execute: "$1 > $testlog
+  SIG_RESULT=0
+  # setup PID and PPID, $$ is not updated.
+  (cd $TRACING_DIR; read PID _ < /proc/self/stat ;
+   set -e; set -x; . $1) >> $testlog 2>&1
+  eval_result $? $SIG_RESULT
+  if [ $? -eq 0 ]; then
+    # Remove test log if the test was done as it was expected.
+    [ $KEEP_LOG -eq 0 ] && rm $testlog
+  else
+    catlog $testlog
+    TOTAL_RESULT=1
+  fi
+}
+
+# Main loop
+for t in $TEST_CASES; do
+  run_test $t
+done
+
+prlog ""
+prlog "# of passed: " `echo $PASSED_CASES | wc -w`
+prlog "# of failed: " `echo $FAILED_CASES | wc -w`
+prlog "# of unresolved: " `echo $UNRESOLVED_CASES | wc -w`
+prlog "# of untested: " `echo $UNTESTED_CASES | wc -w`
+prlog "# of unsupported: " `echo $UNSUPPORTED_CASES | wc -w`
+prlog "# of xfailed: " `echo $XFAILED_CASES | wc -w`
+prlog "# of undefined(test bug): " `echo $UNDEFINED_CASES | wc -w`
+
+# if no error, return 0
+exit $TOTAL_RESULT
diff --git a/tools/testing/selftests/ftrace/samples/fail.tc b/tools/testing/selftests/ftrace/samples/fail.tc
new file mode 100644
index 000000000000..15e35b956e05
--- /dev/null
+++ b/tools/testing/selftests/ftrace/samples/fail.tc
@@ -0,0 +1,4 @@
+#!/bin/sh
+# description: failure-case example
+cat non-exist-file
+echo "this is not executed"
diff --git a/tools/testing/selftests/ftrace/samples/pass.tc b/tools/testing/selftests/ftrace/samples/pass.tc
new file mode 100644
index 000000000000..d01549370041
--- /dev/null
+++ b/tools/testing/selftests/ftrace/samples/pass.tc
@@ -0,0 +1,3 @@
+#!/bin/sh
+# description: pass-case example
+return 0
diff --git a/tools/testing/selftests/ftrace/samples/unresolved.tc b/tools/testing/selftests/ftrace/samples/unresolved.tc
new file mode 100644
index 000000000000..41e99d3358d1
--- /dev/null
+++ b/tools/testing/selftests/ftrace/samples/unresolved.tc
@@ -0,0 +1,4 @@
+#!/bin/sh
+# description: unresolved-case example
+trap exit_unresolved INT
+kill -INT $PID
diff --git a/tools/testing/selftests/ftrace/samples/unsupported.tc b/tools/testing/selftests/ftrace/samples/unsupported.tc
new file mode 100644
index 000000000000..45910ff13328
--- /dev/null
+++ b/tools/testing/selftests/ftrace/samples/unsupported.tc
@@ -0,0 +1,3 @@
+#!/bin/sh
+# description: unsupported-case example
+exit_unsupported
diff --git a/tools/testing/selftests/ftrace/samples/untested.tc b/tools/testing/selftests/ftrace/samples/untested.tc
new file mode 100644
index 000000000000..35a45946ec60
--- /dev/null
+++ b/tools/testing/selftests/ftrace/samples/untested.tc
@@ -0,0 +1,3 @@
+#!/bin/sh
+# description: untested-case example
+exit_untested
diff --git a/tools/testing/selftests/ftrace/samples/xfail.tc b/tools/testing/selftests/ftrace/samples/xfail.tc
new file mode 100644
index 000000000000..9dd395323259
--- /dev/null
+++ b/tools/testing/selftests/ftrace/samples/xfail.tc
@@ -0,0 +1,3 @@
+#!/bin/sh
+# description: xfail-case example
+cat non-exist-file || exit_xfail
diff --git a/tools/testing/selftests/ftrace/test.d/00basic/basic1.tc b/tools/testing/selftests/ftrace/test.d/00basic/basic1.tc
new file mode 100644
index 000000000000..9980ff14ae44
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/00basic/basic1.tc
@@ -0,0 +1,3 @@
+#!/bin/sh
+# description: Basic trace file check
+test -f README -a -f trace -a -f tracing_on -a -f trace_pipe
diff --git a/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc b/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc
new file mode 100644
index 000000000000..bf9a7b037924
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/00basic/basic2.tc
@@ -0,0 +1,7 @@
+#!/bin/sh
+# description: Basic test for tracers
+test -f available_tracers
+for t in `cat available_tracers`; do
+  echo $t > current_tracer
+done
+echo nop > current_tracer
diff --git a/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc b/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc
new file mode 100644
index 000000000000..bde6625d9785
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/00basic/basic3.tc
@@ -0,0 +1,8 @@
+#!/bin/sh
+# description: Basic trace clock test
+test -f trace_clock
+for c in `cat trace_clock | tr  -d \[\]`; do
+  echo $c > trace_clock
+  grep '\['$c'\]' trace_clock
+done
+echo local > trace_clock
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/add_and_remove.tc b/tools/testing/selftests/ftrace/test.d/kprobe/add_and_remove.tc
new file mode 100644
index 000000000000..1b8b665ab2b3
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/add_and_remove.tc
@@ -0,0 +1,11 @@
+#!/bin/sh
+# description: Kprobe dynamic event - adding and removing
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+echo 0 > events/enable
+echo > kprobe_events
+echo p:myevent do_fork > kprobe_events
+grep myevent kprobe_events
+test -d events/kprobes/myevent
+echo > kprobe_events
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/busy_check.tc b/tools/testing/selftests/ftrace/test.d/kprobe/busy_check.tc
new file mode 100644
index 000000000000..b55c84003587
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/busy_check.tc
@@ -0,0 +1,13 @@
+#!/bin/sh
+# description: Kprobe dynamic event - busy event check
+
+[ -f kprobe_events ] || exit_unsupported
+
+echo 0 > events/enable
+echo > kprobe_events
+echo p:myevent do_fork > kprobe_events
+test -d events/kprobes/myevent
+echo 1 > events/kprobes/myevent/enable
+echo > kprobe_events && exit 1 # this must fail
+echo 0 > events/kprobes/myevent/enable
+echo > kprobe_events # this must succeed
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args.tc
new file mode 100644
index 000000000000..a603d3f8db7b
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/kprobe_args.tc
@@ -0,0 +1,16 @@
+#!/bin/sh
+# description: Kprobe dynamic event with arguments
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+echo 0 > events/enable
+echo > kprobe_events
+echo 'p:testprobe do_fork $stack $stack0 +0($stack)' > kprobe_events
+grep testprobe kprobe_events
+test -d events/kprobes/testprobe
+echo 1 > events/kprobes/testprobe/enable
+( echo "forked")
+echo 0 > events/kprobes/testprobe/enable
+echo "-:testprobe" >> kprobe_events
+test -d events/kprobes/testprobe && exit 1 || exit 0
+
diff --git a/tools/testing/selftests/ftrace/test.d/kprobe/kretprobe_args.tc b/tools/testing/selftests/ftrace/test.d/kprobe/kretprobe_args.tc
new file mode 100644
index 000000000000..283c29e7f7c4
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/kprobe/kretprobe_args.tc
@@ -0,0 +1,15 @@
+#!/bin/sh
+# description: Kretprobe dynamic event with arguments
+
+[ -f kprobe_events ] || exit_unsupported # this is configurable
+
+echo 0 > events/enable
+echo > kprobe_events
+echo 'r:testprobe2 do_fork $retval' > kprobe_events
+grep testprobe2 kprobe_events
+test -d events/kprobes/testprobe2
+echo 1 > events/kprobes/testprobe2/enable
+( echo "forked")
+echo 0 > events/kprobes/testprobe2/enable
+echo '-:testprobe2' >> kprobe_events
+test -d events/kprobes/testprobe2 && exit 1 || exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/template b/tools/testing/selftests/ftrace/test.d/template
new file mode 100644
index 000000000000..5448f7abad5f
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/template
@@ -0,0 +1,9 @@
+#!/bin/sh
+# description: %HERE DESCRIBE WHAT THIS DOES%
+# you have to add ".tc" extention for your testcase file
+# Note that all tests are run with "errexit" option.
+
+exit 0 # Return 0 if the test is passed, otherwise return !0
+# If the test could not run because of lack of feature, call exit_unsupported
+# If the test returned unclear results, call exit_unresolved
+# If the test is a dummy, or a placeholder, call exit_untested
diff --git a/tools/testing/selftests/memfd/Makefile b/tools/testing/selftests/memfd/Makefile
index ad4ab01cd28f..b80cd10d53ba 100644
--- a/tools/testing/selftests/memfd/Makefile
+++ b/tools/testing/selftests/memfd/Makefile
@@ -1,38 +1,17 @@
-uname_M := $(shell uname -m 2>/dev/null || echo not)
-ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
-ifeq ($(ARCH),i386)
-        ARCH := x86
-endif
-ifeq ($(ARCH),x86_64)
-        ARCH := x86
-endif
-
 CFLAGS += -D_FILE_OFFSET_BITS=64
-CFLAGS += -I../../../../arch/x86/include/generated/uapi/
-CFLAGS += -I../../../../arch/x86/include/uapi/
 CFLAGS += -I../../../../include/uapi/
 CFLAGS += -I../../../../include/
 
 all:
-ifeq ($(ARCH),x86)
         gcc $(CFLAGS) memfd_test.c -o memfd_test
-else
-        echo "Not an x86 target, can't build memfd selftest"
-endif
 
 run_tests: all
-ifeq ($(ARCH),x86)
         gcc $(CFLAGS) memfd_test.c -o memfd_test
-endif
         @./memfd_test || echo "memfd_test: [FAIL]"
 
 build_fuse:
-ifeq ($(ARCH),x86)
         gcc $(CFLAGS) fuse_mnt.c `pkg-config fuse --cflags --libs` -o fuse_mnt
         gcc $(CFLAGS) fuse_test.c -o fuse_test
-else
-        echo "Not an x86 target, can't build memfd selftest"
-endif
 
 run_fuse: build_fuse
         @./run_fuse_test.sh || echo "fuse_test: [FAIL]"
diff --git a/tools/testing/selftests/memfd/memfd_test.c b/tools/testing/selftests/memfd/memfd_test.c
index 3634c909b1b0..0b9eafb7ab7b 100644
--- a/tools/testing/selftests/memfd/memfd_test.c
+++ b/tools/testing/selftests/memfd/memfd_test.c
@@ -59,9 +59,9 @@ static void mfd_fail_new(const char *name, unsigned int flags)
         }
 }
 
-static __u64 mfd_assert_get_seals(int fd)
+static unsigned int mfd_assert_get_seals(int fd)
 {
-        long r;
+        int r;
 
         r = fcntl(fd, F_GET_SEALS);
         if (r < 0) {
@@ -69,50 +69,48 @@ static __u64 mfd_assert_get_seals(int fd)
                 abort();
         }
 
-        return r;
+        return (unsigned int)r;
 }
 
-static void mfd_assert_has_seals(int fd, __u64 seals)
+static void mfd_assert_has_seals(int fd, unsigned int seals)
 {
-        __u64 s;
+        unsigned int s;
 
         s = mfd_assert_get_seals(fd);
         if (s != seals) {
-                printf("%llu != %llu = GET_SEALS(%d)\n",
-                       (unsigned long long)seals, (unsigned long long)s, fd);
+                printf("%u != %u = GET_SEALS(%d)\n", seals, s, fd);
                 abort();
         }
 }
 
-static void mfd_assert_add_seals(int fd, __u64 seals)
+static void mfd_assert_add_seals(int fd, unsigned int seals)
 {
-        long r;
-        __u64 s;
+        int r;
+        unsigned int s;
 
         s = mfd_assert_get_seals(fd);
         r = fcntl(fd, F_ADD_SEALS, seals);
         if (r < 0) {
-                printf("ADD_SEALS(%d, %llu -> %llu) failed: %m\n",
-                       fd, (unsigned long long)s, (unsigned long long)seals);
+                printf("ADD_SEALS(%d, %u -> %u) failed: %m\n", fd, s, seals);
                 abort();
         }
 }
 
-static void mfd_fail_add_seals(int fd, __u64 seals)
+static void mfd_fail_add_seals(int fd, unsigned int seals)
 {
-        long r;
-        __u64 s;
+        int r;
+        unsigned int s;
 
         r = fcntl(fd, F_GET_SEALS);
         if (r < 0)
                 s = 0;
         else
-                s = r;
+                s = (unsigned int)r;
 
         r = fcntl(fd, F_ADD_SEALS, seals);
         if (r >= 0) {
-                printf("ADD_SEALS(%d, %llu -> %llu) didn't fail as expected\n",
-                       fd, (unsigned long long)s, (unsigned long long)seals);
+                printf("ADD_SEALS(%d, %u -> %u) didn't fail as expected\n",
+                                fd, s, seals);
                 abort();
         }
 }
@@ -205,7 +203,7 @@ static void mfd_fail_open(int fd, int flags, mode_t mode)
         sprintf(buf, "/proc/self/fd/%d", fd);
         r = open(buf, flags, mode);
         if (r >= 0) {
-                printf("open(%s) didn't fail as expected\n");
+                printf("open(%s) didn't fail as expected\n", buf);
                 abort();
         }
 }
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index 74a78cedce37..f6ff90a76bd7 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -13,7 +13,7 @@ CFLAGS := -Wall -O2 -flto -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CUR
 
 export CC CFLAGS
 
-TARGETS = pmu copyloops mm tm
+TARGETS = pmu copyloops mm tm primitives
 
 endif
 
diff --git a/tools/testing/selftests/powerpc/primitives/Makefile b/tools/testing/selftests/powerpc/primitives/Makefile
new file mode 100644
index 000000000000..ea737ca01732
--- /dev/null
+++ b/tools/testing/selftests/powerpc/primitives/Makefile
@@ -0,0 +1,17 @@
+CFLAGS += -I$(CURDIR)
+
+PROGS := load_unaligned_zeropad
+
+all: $(PROGS)
+
+$(PROGS): ../harness.c
+
+run_tests: all
+        @-for PROG in $(PROGS); do \
+                ./$$PROG; \
+        done;
+
+clean:
+        rm -f $(PROGS) *.o
+
+.PHONY: all run_tests clean
diff --git a/tools/testing/selftests/powerpc/primitives/asm/asm-compat.h b/tools/testing/selftests/powerpc/primitives/asm/asm-compat.h
new file mode 120000
index 000000000000..b14255e15a25
--- /dev/null
+++ b/tools/testing/selftests/powerpc/primitives/asm/asm-compat.h
@@ -0,0 +1 @@
+../.././../../../../arch/powerpc/include/asm/asm-compat.h
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/primitives/asm/ppc-opcode.h b/tools/testing/selftests/powerpc/primitives/asm/ppc-opcode.h
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/tools/testing/selftests/powerpc/primitives/asm/ppc-opcode.h
diff --git a/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c b/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
new file mode 100644
index 000000000000..d1b647509596
--- /dev/null
+++ b/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
@@ -0,0 +1,147 @@
+/*
+ * Userspace test harness for load_unaligned_zeropad. Creates two
+ * pages and uses mprotect to prevent access to the second page and
+ * a SEGV handler that walks the exception tables and runs the fixup
+ * routine.
+ *
+ * The results are compared against a normal load that is that is
+ * performed while access to the second page is enabled via mprotect.
+ *
+ * Copyright (C) 2014 Anton Blanchard <anton@au.ibm.com>, IBM
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#define FIXUP_SECTION ".ex_fixup"
+
+#include "word-at-a-time.h"
+
+#include "utils.h"
+
+
+static int page_size;
+static char *mem_region;
+
+static int protect_region(void)
+{
+        if (mprotect(mem_region + page_size, page_size, PROT_NONE)) {
+                perror("mprotect");
+                return 1;
+        }
+
+        return 0;
+}
+
+static int unprotect_region(void)
+{
+        if (mprotect(mem_region + page_size, page_size, PROT_READ|PROT_WRITE)) {
+                perror("mprotect");
+                return 1;
+        }
+
+        return 0;
+}
+
+extern char __start___ex_table[];
+extern char __stop___ex_table[];
+
+#if defined(__powerpc64__)
+#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.gp_regs[PT_NIP]
+#elif defined(__powerpc__)
+#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.uc_regs->gregs[PT_NIP]
+#else
+#error implement UCONTEXT_NIA
+#endif
+
+static int segv_error;
+
+static void segv_handler(int signr, siginfo_t *info, void *ptr)
+{
+        ucontext_t *uc = (ucontext_t *)ptr;
+        unsigned long addr = (unsigned long)info->si_addr;
+        unsigned long *ip = &UCONTEXT_NIA(uc);
+        unsigned long *ex_p = (unsigned long *)__start___ex_table;
+
+        while (ex_p < (unsigned long *)__stop___ex_table) {
+                unsigned long insn, fixup;
+
+                insn = *ex_p++;
+                fixup = *ex_p++;
+
+                if (insn == *ip) {
+                        *ip = fixup;
+                        return;
+                }
+        }
+
+        printf("No exception table match for NIA %lx ADDR %lx\n", *ip, addr);
+        segv_error++;
+}
+
+static void setup_segv_handler(void)
+{
+        struct sigaction action;
+
+        memset(&action, 0, sizeof(action));
+        action.sa_sigaction = segv_handler;
+        action.sa_flags = SA_SIGINFO;
+        sigaction(SIGSEGV, &action, NULL);
+}
+
+static int do_one_test(char *p, int page_offset)
+{
+        unsigned long should;
+        unsigned long got;
+
+        FAIL_IF(unprotect_region());
+        should = *(unsigned long *)p;
+        FAIL_IF(protect_region());
+
+        got = load_unaligned_zeropad(p);
+
+        if (should != got)
+                printf("offset %u load_unaligned_zeropad returned 0x%lx, should be 0x%lx\n", page_offset, got, should);
+
+        return 0;
+}
+
+static int test_body(void)
+{
+        unsigned long i;
+
+        page_size = getpagesize();
+        mem_region = mmap(NULL, page_size * 2, PROT_READ|PROT_WRITE,
+                MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+
+        FAIL_IF(mem_region == MAP_FAILED);
+
+        for (i = 0; i < page_size; i++)
+                mem_region[i] = i;
+
+        memset(mem_region+page_size, 0, page_size);
+
+        setup_segv_handler();
+
+        for (i = 0; i < page_size; i++)
+                FAIL_IF(do_one_test(mem_region+i, i));
+
+        FAIL_IF(segv_error);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_body, "load_unaligned_zeropad");
+}
diff --git a/tools/testing/selftests/powerpc/primitives/word-at-a-time.h b/tools/testing/selftests/powerpc/primitives/word-at-a-time.h
new file mode 120000
index 000000000000..eb74401b591f
--- /dev/null
+++ b/tools/testing/selftests/powerpc/primitives/word-at-a-time.h
@@ -0,0 +1 @@
+../../../../../arch/powerpc/include/asm/word-at-a-time.h
\ No newline at end of file
diff --git a/tools/testing/selftests/rcutorture/bin/config2frag.sh b/tools/testing/selftests/rcutorture/bin/config2frag.sh
index 9f9ffcd427d3..56f51ae13d73 100644..100755
--- a/tools/testing/selftests/rcutorture/bin/config2frag.sh
+++ b/tools/testing/selftests/rcutorture/bin/config2frag.sh
@@ -1,5 +1,5 @@
-#!/bin/sh
-# Usage: sh config2frag.sh < .config > configfrag
+#!/bin/bash
+# Usage: config2frag.sh < .config > configfrag
 #
 # Converts the "# CONFIG_XXX is not set" to "CONFIG_XXX=n" so that the
 # resulting file becomes a legitimate Kconfig fragment.
diff --git a/tools/testing/selftests/rcutorture/bin/configcheck.sh b/tools/testing/selftests/rcutorture/bin/configcheck.sh
index d686537dd55c..eee31e261bf7 100755
--- a/tools/testing/selftests/rcutorture/bin/configcheck.sh
+++ b/tools/testing/selftests/rcutorture/bin/configcheck.sh
@@ -1,5 +1,5 @@
-#!/bin/sh
-# Usage: sh configcheck.sh .config .config-template
+#!/bin/bash
+# Usage: configcheck.sh .config .config-template
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/bin/configinit.sh b/tools/testing/selftests/rcutorture/bin/configinit.sh
index 9c3f3d39b934..15f1a17ca96e 100755
--- a/tools/testing/selftests/rcutorture/bin/configinit.sh
+++ b/tools/testing/selftests/rcutorture/bin/configinit.sh
@@ -1,6 +1,6 @@
-#!/bin/sh
+#!/bin/bash
 #
-# sh configinit.sh config-spec-file [ build output dir ]
+# Usage: configinit.sh config-spec-file [ build output dir ]
 #
 # Create a .config file from the spec file.  Run from the kernel source tree.
 # Exits with 0 if all went well, with 1 if all went well but the config
diff --git a/tools/testing/selftests/rcutorture/bin/functions.sh b/tools/testing/selftests/rcutorture/bin/functions.sh
index d01b865bb100..b325470c01b3 100644
--- a/tools/testing/selftests/rcutorture/bin/functions.sh
+++ b/tools/testing/selftests/rcutorture/bin/functions.sh
@@ -64,6 +64,26 @@ configfrag_boot_params () {
         fi
 }
 
+# configfrag_boot_cpus bootparam-string config-fragment-file config-cpus
+#
+# Decreases number of CPUs based on any maxcpus= boot parameters specified.
+configfrag_boot_cpus () {
+        local bootargs="`configfrag_boot_params "$1" "$2"`"
+        local maxcpus
+        if echo "${bootargs}" | grep -q 'maxcpus=[0-9]'
+        then
+                maxcpus="`echo "${bootargs}" | sed -e 's/^.*maxcpus=\([0-9]*\).*$/\1/'`"
+                if test "$3" -gt "$maxcpus"
+                then
+                        echo $maxcpus
+                else
+                        echo $3
+                fi
+        else
+                echo $3
+        fi
+}
+
 # configfrag_hotplug_cpu config-fragment-file
 #
 # Returns 1 if the config fragment specifies hotplug CPU.
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-build.sh b/tools/testing/selftests/rcutorture/bin/kvm-build.sh
index 7c1e56b46de4..00cb0db2643d 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-build.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-build.sh
@@ -2,7 +2,7 @@
 #
 # Build a kvm-ready Linux kernel from the tree in the current directory.
 #
-# Usage: sh kvm-build.sh config-template build-dir more-configs
+# Usage: kvm-build.sh config-template build-dir more-configs
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-recheck-lock.sh b/tools/testing/selftests/rcutorture/bin/kvm-recheck-lock.sh
index 7f1ff1a8fc4b..43f764098e50 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-recheck-lock.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-recheck-lock.sh
@@ -2,7 +2,7 @@
 #
 # Analyze a given results directory for locktorture progress.
 #
-# Usage: sh kvm-recheck-lock.sh resdir
+# Usage: kvm-recheck-lock.sh resdir
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh b/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh
index 307c4b95f325..d6cc07fc137f 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh
@@ -2,7 +2,7 @@
 #
 # Analyze a given results directory for rcutorture progress.
 #
-# Usage: sh kvm-recheck-rcu.sh resdir
+# Usage: kvm-recheck-rcu.sh resdir
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh b/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh
index 3f6c9b78d177..4f5b20f367a9 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh
@@ -4,7 +4,7 @@
 # check the build and console output for errors.  Given a directory
 # containing results directories, this recursively checks them all.
 #
-# Usage: sh kvm-recheck.sh resdir ...
+# Usage: kvm-recheck.sh resdir ...
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
index 0f69dcbf9def..f6b2b4771b78 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
@@ -6,7 +6,7 @@
 # Execute this in the source tree.  Do not run it as a background task
 # because qemu does not seem to like that much.
 #
-# Usage: sh kvm-test-1-run.sh config builddir resdir minutes qemu-args boot_args
+# Usage: kvm-test-1-run.sh config builddir resdir minutes qemu-args boot_args
 #
 # qemu-args defaults to "-nographic", along with arguments specifying the
 #                       number of CPUs and other options generated from
@@ -140,6 +140,7 @@ fi
 # Generate -smp qemu argument.
 qemu_args="-nographic $qemu_args"
 cpu_count=`configNR_CPUS.sh $config_template`
+cpu_count=`configfrag_boot_cpus "$boot_args" "$config_template" "$cpu_count"`
 vcpus=`identify_qemu_vcpus`
 if test $cpu_count -gt $vcpus
 then
@@ -214,7 +215,7 @@ then
                 fi
                 if test $kruntime -ge $((seconds + grace))
                 then
-                        echo "!!! Hang at $kruntime vs. $seconds seconds" >> $resdir/Warnings 2>&1
+                        echo "!!! PID $qemu_pid hung at $kruntime vs. $seconds seconds" >> $resdir/Warnings 2>&1
                         kill -KILL $qemu_pid
                         break
                 fi
diff --git a/tools/testing/selftests/rcutorture/bin/kvm.sh b/tools/testing/selftests/rcutorture/bin/kvm.sh
index 589e9c38413b..e527dc952eb0 100644..100755
--- a/tools/testing/selftests/rcutorture/bin/kvm.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm.sh
@@ -7,7 +7,7 @@
 # Edit the definitions below to set the locations of the various directories,
 # as well as the test duration.
 #
-# Usage: sh kvm.sh [ options ]
+# Usage: kvm.sh [ options ]
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -188,7 +188,9 @@ for CF in $configs
 do
         if test -f "$CONFIGFRAG/$kversion/$CF"
         then
-                echo $CF `configNR_CPUS.sh $CONFIGFRAG/$kversion/$CF` >> $T/cfgcpu
+                cpu_count=`configNR_CPUS.sh $CONFIGFRAG/$kversion/$CF`
+                cpu_count=`configfrag_boot_cpus "$TORTURE_BOOTARGS" "$CONFIGFRAG/$kversion/$CF" "$cpu_count"`
+                echo $CF $cpu_count >> $T/cfgcpu
         else
                 echo "The --configs file $CF does not exist, terminating."
                 exit 1
diff --git a/tools/testing/selftests/rcutorture/bin/parse-build.sh b/tools/testing/selftests/rcutorture/bin/parse-build.sh
index 543230951c38..499d1e598e42 100755
--- a/tools/testing/selftests/rcutorture/bin/parse-build.sh
+++ b/tools/testing/selftests/rcutorture/bin/parse-build.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 #
 # Check the build output from an rcutorture run for goodness.
 # The "file" is a pathname on the local system, and "title" is
@@ -6,8 +6,7 @@
 #
 # The file must contain kernel build output.
 #
-# Usage:
-#       sh parse-build.sh file title
+# Usage: parse-build.sh file title
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/bin/parse-console.sh b/tools/testing/selftests/rcutorture/bin/parse-console.sh
index 4185d4cab32e..f962ba4cf68b 100755
--- a/tools/testing/selftests/rcutorture/bin/parse-console.sh
+++ b/tools/testing/selftests/rcutorture/bin/parse-console.sh
@@ -1,11 +1,10 @@
-#!/bin/sh
+#!/bin/bash
 #
 # Check the console output from an rcutorture run for oopses.
 # The "file" is a pathname on the local system, and "title" is
 # a text string for error-message purposes.
 #
-# Usage:
-#       sh parse-console.sh file title
+# Usage: parse-console.sh file title
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -33,6 +32,10 @@ title="$2"
 
 . functions.sh
 
+if grep -Pq '\x00' < $file
+then
+        print_warning Console output contains nul bytes, old qemu still running?
+fi
 egrep 'Badness|WARNING:|Warn|BUG|===========|Call Trace:|Oops:' < $file | grep -v 'ODEBUG: ' | grep -v 'Warning: unable to open an initial console' > $T
 if test -s $T
 then
diff --git a/tools/testing/selftests/rcutorture/bin/parse-torture.sh b/tools/testing/selftests/rcutorture/bin/parse-torture.sh
index 3455560ab4e4..e3c5f0705696 100755
--- a/tools/testing/selftests/rcutorture/bin/parse-torture.sh
+++ b/tools/testing/selftests/rcutorture/bin/parse-torture.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 #
 # Check the console output from a torture run for goodness.
 # The "file" is a pathname on the local system, and "title" is
@@ -7,8 +7,7 @@
 # The file must contain torture output, but can be interspersed
 # with other dmesg text, as in console-log output.
 #
-# Usage:
-#       sh parse-torture.sh file title
+# Usage: parse-torture.sh file title
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
diff --git a/tools/testing/selftests/rcutorture/configs/lock/CFLIST b/tools/testing/selftests/rcutorture/configs/lock/CFLIST
index a061b22d1892..6910b7370761 100644
--- a/tools/testing/selftests/rcutorture/configs/lock/CFLIST
+++ b/tools/testing/selftests/rcutorture/configs/lock/CFLIST
@@ -1 +1,4 @@
 LOCK01
+LOCK02
+LOCK03
+LOCK04
\ No newline at end of file
diff --git a/tools/testing/selftests/rcutorture/configs/lock/LOCK02 b/tools/testing/selftests/rcutorture/configs/lock/LOCK02
new file mode 100644
index 000000000000..1d1da1477fc3
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/lock/LOCK02
@@ -0,0 +1,6 @@
+CONFIG_SMP=y
+CONFIG_NR_CPUS=4
+CONFIG_HOTPLUG_CPU=y
+CONFIG_PREEMPT_NONE=n
+CONFIG_PREEMPT_VOLUNTARY=n
+CONFIG_PREEMPT=y
diff --git a/tools/testing/selftests/rcutorture/configs/lock/LOCK02.boot b/tools/testing/selftests/rcutorture/configs/lock/LOCK02.boot
new file mode 100644
index 000000000000..5aa44b4f1b51
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/lock/LOCK02.boot
@@ -0,0 +1 @@
+locktorture.torture_type=mutex_lock
diff --git a/tools/testing/selftests/rcutorture/configs/lock/LOCK03 b/tools/testing/selftests/rcutorture/configs/lock/LOCK03
new file mode 100644
index 000000000000..1d1da1477fc3
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/lock/LOCK03
@@ -0,0 +1,6 @@
+CONFIG_SMP=y
+CONFIG_NR_CPUS=4
+CONFIG_HOTPLUG_CPU=y
+CONFIG_PREEMPT_NONE=n
+CONFIG_PREEMPT_VOLUNTARY=n
+CONFIG_PREEMPT=y
diff --git a/tools/testing/selftests/rcutorture/configs/lock/LOCK03.boot b/tools/testing/selftests/rcutorture/configs/lock/LOCK03.boot
new file mode 100644
index 000000000000..a67bbe0245c9
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/lock/LOCK03.boot
@@ -0,0 +1 @@
+locktorture.torture_type=rwsem_lock
diff --git a/tools/testing/selftests/rcutorture/configs/lock/LOCK04 b/tools/testing/selftests/rcutorture/configs/lock/LOCK04
new file mode 100644
index 000000000000..1d1da1477fc3
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/lock/LOCK04
@@ -0,0 +1,6 @@
+CONFIG_SMP=y
+CONFIG_NR_CPUS=4
+CONFIG_HOTPLUG_CPU=y
+CONFIG_PREEMPT_NONE=n
+CONFIG_PREEMPT_VOLUNTARY=n
+CONFIG_PREEMPT=y
diff --git a/tools/testing/selftests/rcutorture/configs/lock/LOCK04.boot b/tools/testing/selftests/rcutorture/configs/lock/LOCK04.boot
new file mode 100644
index 000000000000..48c04fe47fb4
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/lock/LOCK04.boot
@@ -0,0 +1 @@
+locktorture.torture_type=rw_lock
diff --git a/tools/testing/selftests/rcutorture/configs/lock/ver_functions.sh b/tools/testing/selftests/rcutorture/configs/lock/ver_functions.sh
index 9746ea1cd6c7..252aae618984 100644
--- a/tools/testing/selftests/rcutorture/configs/lock/ver_functions.sh
+++ b/tools/testing/selftests/rcutorture/configs/lock/ver_functions.sh
@@ -38,6 +38,6 @@ per_version_boot_params () {
         echo $1 `locktorture_param_onoff "$1" "$2"` \
                 locktorture.stat_interval=15 \
                 locktorture.shutdown_secs=$3 \
-                locktorture.locktorture_runnable=1 \
+                locktorture.torture_runnable=1 \
                 locktorture.verbose=1
 }
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/CFLIST b/tools/testing/selftests/rcutorture/configs/rcu/CFLIST
index cd3d29cb0a47..a3a1a05a2b5c 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/CFLIST
+++ b/tools/testing/selftests/rcutorture/configs/rcu/CFLIST
@@ -11,3 +11,6 @@ SRCU-N
 SRCU-P
 TINY01
 TINY02
+TASKS01
+TASKS02
+TASKS03
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TASKS01 b/tools/testing/selftests/rcutorture/configs/rcu/TASKS01
new file mode 100644
index 000000000000..97f0a0b27ef7
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TASKS01
@@ -0,0 +1,9 @@
+CONFIG_SMP=y
+CONFIG_NR_CPUS=2
+CONFIG_HOTPLUG_CPU=y
+CONFIG_PREEMPT_NONE=n
+CONFIG_PREEMPT_VOLUNTARY=n
+CONFIG_PREEMPT=y
+CONFIG_DEBUG_LOCK_ALLOC=y
+CONFIG_PROVE_RCU=y
+CONFIG_TASKS_RCU=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TASKS01.boot b/tools/testing/selftests/rcutorture/configs/rcu/TASKS01.boot
new file mode 100644
index 000000000000..cd2a188eeb6d
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TASKS01.boot
@@ -0,0 +1 @@
+rcutorture.torture_type=tasks
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TASKS02 b/tools/testing/selftests/rcutorture/configs/rcu/TASKS02
new file mode 100644
index 000000000000..696d2ea74d13
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TASKS02
@@ -0,0 +1,5 @@
+CONFIG_SMP=n
+CONFIG_PREEMPT_NONE=y
+CONFIG_PREEMPT_VOLUNTARY=n
+CONFIG_PREEMPT=n
+CONFIG_TASKS_RCU=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TASKS02.boot b/tools/testing/selftests/rcutorture/configs/rcu/TASKS02.boot
new file mode 100644
index 000000000000..cd2a188eeb6d
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TASKS02.boot
@@ -0,0 +1 @@
+rcutorture.torture_type=tasks
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TASKS03 b/tools/testing/selftests/rcutorture/configs/rcu/TASKS03
new file mode 100644
index 000000000000..9c60da5b5d1d
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TASKS03
@@ -0,0 +1,13 @@
+CONFIG_SMP=y
+CONFIG_NR_CPUS=2
+CONFIG_HOTPLUG_CPU=n
+CONFIG_SUSPEND=n
+CONFIG_HIBERNATION=n
+CONFIG_PREEMPT_NONE=n
+CONFIG_PREEMPT_VOLUNTARY=n
+CONFIG_PREEMPT=y
+CONFIG_TASKS_RCU=y
+CONFIG_HZ_PERIODIC=n
+CONFIG_NO_HZ_IDLE=n
+CONFIG_NO_HZ_FULL=y
+CONFIG_NO_HZ_FULL_ALL=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TASKS03.boot b/tools/testing/selftests/rcutorture/configs/rcu/TASKS03.boot
new file mode 100644
index 000000000000..cd2a188eeb6d
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TASKS03.boot
@@ -0,0 +1 @@
+rcutorture.torture_type=tasks
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE01 b/tools/testing/selftests/rcutorture/configs/rcu/TREE01
index 063b7079c621..38e3895759dd 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE01
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE01
@@ -1,5 +1,4 @@
 CONFIG_SMP=y
-CONFIG_NR_CPUS=8
 CONFIG_PREEMPT_NONE=n
 CONFIG_PREEMPT_VOLUNTARY=n
 CONFIG_PREEMPT=y
@@ -10,8 +9,7 @@ CONFIG_NO_HZ_FULL=n
 CONFIG_RCU_FAST_NO_HZ=y
 CONFIG_RCU_TRACE=y
 CONFIG_HOTPLUG_CPU=y
-CONFIG_RCU_FANOUT=8
-CONFIG_RCU_FANOUT_EXACT=n
+CONFIG_MAXSMP=y
 CONFIG_RCU_NOCB_CPU=y
 CONFIG_RCU_NOCB_CPU_ZERO=y
 CONFIG_DEBUG_LOCK_ALLOC=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE01.boot b/tools/testing/selftests/rcutorture/configs/rcu/TREE01.boot
index 0fc8a3428938..adc3abc82fb8 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE01.boot
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE01.boot
@@ -1 +1 @@
-rcutorture.torture_type=rcu_bh
+rcutorture.torture_type=rcu_bh maxcpus=8
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE07 b/tools/testing/selftests/rcutorture/configs/rcu/TREE07
index ab6225506909..8f1017666aa7 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE07
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE07
@@ -1,5 +1,6 @@
 CONFIG_SMP=y
 CONFIG_NR_CPUS=16
+CONFIG_CPUMASK_OFFSTACK=y
 CONFIG_PREEMPT_NONE=y
 CONFIG_PREEMPT_VOLUNTARY=n
 CONFIG_PREEMPT=n
@@ -7,7 +8,7 @@ CONFIG_PREEMPT=n
 CONFIG_HZ_PERIODIC=n
 CONFIG_NO_HZ_IDLE=n
 CONFIG_NO_HZ_FULL=y
-CONFIG_NO_HZ_FULL_ALL=y
+CONFIG_NO_HZ_FULL_ALL=n
 CONFIG_NO_HZ_FULL_SYSIDLE=y
 CONFIG_RCU_FAST_NO_HZ=n
 CONFIG_RCU_TRACE=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE07.boot b/tools/testing/selftests/rcutorture/configs/rcu/TREE07.boot
new file mode 100644
index 000000000000..d44609937503
--- /dev/null
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE07.boot
@@ -0,0 +1 @@
+nohz_full=2-9
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/ver_functions.sh b/tools/testing/selftests/rcutorture/configs/rcu/ver_functions.sh
index 8977d8d31b19..ffb85ed786fa 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/ver_functions.sh
+++ b/tools/testing/selftests/rcutorture/configs/rcu/ver_functions.sh
@@ -51,7 +51,7 @@ per_version_boot_params () {
                 `rcutorture_param_n_barrier_cbs "$1"` \
                 rcutorture.stat_interval=15 \
                 rcutorture.shutdown_secs=$3 \
-                rcutorture.rcutorture_runnable=1 \
+                rcutorture.torture_runnable=1 \
                 rcutorture.test_no_idle_hz=1 \
                 rcutorture.verbose=1
 }
diff --git a/tools/testing/selftests/rcutorture/doc/initrd.txt b/tools/testing/selftests/rcutorture/doc/initrd.txt
index 49d134c25c04..4170e714f044 100644
--- a/tools/testing/selftests/rcutorture/doc/initrd.txt
+++ b/tools/testing/selftests/rcutorture/doc/initrd.txt
@@ -6,6 +6,7 @@ this case.  There are probably much better ways of doing this.
 That said, here are the commands:
 
 ------------------------------------------------------------------------
+cd tools/testing/selftests/rcutorture
 zcat /initrd.img > /tmp/initrd.img.zcat
 mkdir initrd
 cd initrd
diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile
index 3f94e1afd6cf..4c4b1f631ecf 100644
--- a/tools/testing/selftests/vm/Makefile
+++ b/tools/testing/selftests/vm/Makefile
@@ -3,6 +3,7 @@
 CC = $(CROSS_COMPILE)gcc
 CFLAGS = -Wall
 BINARIES = hugepage-mmap hugepage-shm map_hugetlb thuge-gen hugetlbfstest
+BINARIES += transhuge-stress
 
 all: $(BINARIES)
 %: %.c
diff --git a/tools/testing/selftests/vm/transhuge-stress.c b/tools/testing/selftests/vm/transhuge-stress.c
new file mode 100644
index 000000000000..fd7f1b4a96f9
--- /dev/null
+++ b/tools/testing/selftests/vm/transhuge-stress.c
@@ -0,0 +1,144 @@
+/*
+ * Stress test for transparent huge pages, memory compaction and migration.
+ *
+ * Authors: Konstantin Khlebnikov <koct9i@gmail.com>
+ *
+ * This is free and unencumbered software released into the public domain.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <err.h>
+#include <time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#define PAGE_SHIFT 12
+#define HPAGE_SHIFT 21
+
+#define PAGE_SIZE (1 << PAGE_SHIFT)
+#define HPAGE_SIZE (1 << HPAGE_SHIFT)
+
+#define PAGEMAP_PRESENT(ent)    (((ent) & (1ull << 63)) != 0)
+#define PAGEMAP_PFN(ent)        ((ent) & ((1ull << 55) - 1))
+
+int pagemap_fd;
+
+int64_t allocate_transhuge(void *ptr)
+{
+        uint64_t ent[2];
+
+        /* drop pmd */
+        if (mmap(ptr, HPAGE_SIZE, PROT_READ | PROT_WRITE,
+                                MAP_FIXED | MAP_ANONYMOUS |
+                                MAP_NORESERVE | MAP_PRIVATE, -1, 0) != ptr)
+                errx(2, "mmap transhuge");
+
+        if (madvise(ptr, HPAGE_SIZE, MADV_HUGEPAGE))
+                err(2, "MADV_HUGEPAGE");
+
+        /* allocate transparent huge page */
+        *(volatile void **)ptr = ptr;
+
+        if (pread(pagemap_fd, ent, sizeof(ent),
+                        (uintptr_t)ptr >> (PAGE_SHIFT - 3)) != sizeof(ent))
+                err(2, "read pagemap");
+
+        if (PAGEMAP_PRESENT(ent[0]) && PAGEMAP_PRESENT(ent[1]) &&
+            PAGEMAP_PFN(ent[0]) + 1 == PAGEMAP_PFN(ent[1]) &&
+            !(PAGEMAP_PFN(ent[0]) & ((1 << (HPAGE_SHIFT - PAGE_SHIFT)) - 1)))
+                return PAGEMAP_PFN(ent[0]);
+
+        return -1;
+}
+
+int main(int argc, char **argv)
+{
+        size_t ram, len;
+        void *ptr, *p;
+        struct timespec a, b;
+        double s;
+        uint8_t *map;
+        size_t map_len;
+
+        ram = sysconf(_SC_PHYS_PAGES);
+        if (ram > SIZE_MAX / sysconf(_SC_PAGESIZE) / 4)
+                ram = SIZE_MAX / 4;
+        else
+                ram *= sysconf(_SC_PAGESIZE);
+
+        if (argc == 1)
+                len = ram;
+        else if (!strcmp(argv[1], "-h"))
+                errx(1, "usage: %s [size in MiB]", argv[0]);
+        else
+                len = atoll(argv[1]) << 20;
+
+        warnx("allocate %zd transhuge pages, using %zd MiB virtual memory"
+              " and %zd MiB of ram", len >> HPAGE_SHIFT, len >> 20,
+              len >> (20 + HPAGE_SHIFT - PAGE_SHIFT - 1));
+
+        pagemap_fd = open("/proc/self/pagemap", O_RDONLY);
+        if (pagemap_fd < 0)
+                err(2, "open pagemap");
+
+        len -= len % HPAGE_SIZE;
+        ptr = mmap(NULL, len + HPAGE_SIZE, PROT_READ | PROT_WRITE,
+                        MAP_ANONYMOUS | MAP_NORESERVE | MAP_PRIVATE, -1, 0);
+        if (ptr == MAP_FAILED)
+                err(2, "initial mmap");
+        ptr += HPAGE_SIZE - (uintptr_t)ptr % HPAGE_SIZE;
+
+        if (madvise(ptr, len, MADV_HUGEPAGE))
+                err(2, "MADV_HUGEPAGE");
+
+        map_len = ram >> (HPAGE_SHIFT - 1);
+        map = malloc(map_len);
+        if (!map)
+                errx(2, "map malloc");
+
+        while (1) {
+                int nr_succeed = 0, nr_failed = 0, nr_pages = 0;
+
+                memset(map, 0, map_len);
+
+                clock_gettime(CLOCK_MONOTONIC, &a);
+                for (p = ptr; p < ptr + len; p += HPAGE_SIZE) {
+                        int64_t pfn;
+
+                        pfn = allocate_transhuge(p);
+
+                        if (pfn < 0) {
+                                nr_failed++;
+                        } else {
+                                size_t idx = pfn >> (HPAGE_SHIFT - PAGE_SHIFT);
+
+                                nr_succeed++;
+                                if (idx >= map_len) {
+                                        map = realloc(map, idx + 1);
+                                        if (!map)
+                                                errx(2, "map realloc");
+                                        memset(map + map_len, 0, idx + 1 - map_len);
+                                        map_len = idx + 1;
+                                }
+                                if (!map[idx])
+                                        nr_pages++;
+                                map[idx] = 1;
+                        }
+
+                        /* split transhuge page, keep last page */
+                        if (madvise(p, HPAGE_SIZE - PAGE_SIZE, MADV_DONTNEED))
+                                err(2, "MADV_DONTNEED");
+                }
+                clock_gettime(CLOCK_MONOTONIC, &b);
+                s = b.tv_sec - a.tv_sec + (b.tv_nsec - a.tv_nsec) / 1000000000.;
+
+                warnx("%.3f s/loop, %.3f ms/page, %10.3f MiB/s\t"
+                      "%4d succeed, %4d failed, %4d different pages",
+                      s, s * 1000 / (len >> HPAGE_SHIFT), len / s / (1 << 20),
+                      nr_succeed, nr_failed, nr_pages);
+        }
+}
diff --git a/tools/vm/page-types.c b/tools/vm/page-types.c
index c4d6d2e20e0d..264fbc297e0b 100644
--- a/tools/vm/page-types.c
+++ b/tools/vm/page-types.c
@@ -132,6 +132,7 @@ static const char * const page_flag_names[] = {
         [KPF_NOPAGE]            = "n:nopage",
         [KPF_KSM]               = "x:ksm",
         [KPF_THP]               = "t:thp",
+        [KPF_BALLOON]           = "o:balloon",
 
         [KPF_RESERVED]          = "r:reserved",
         [KPF_MLOCKED]           = "m:mlocked",