207 files changed, 8396 insertions, 1766 deletions

diff --git a/tools/hv/hv_fcopy_daemon.c b/tools/hv/hv_fcopy_daemon.c
index fba1c75aa484..8f96b3ee0724 100644
--- a/tools/hv/hv_fcopy_daemon.c
+++ b/tools/hv/hv_fcopy_daemon.c
@@ -88,7 +88,8 @@ static int hv_start_fcopy(struct hv_start_fcopy *smsg)
                 }
         }
 
-        target_fd = open(target_fname, O_RDWR | O_CREAT | O_CLOEXEC, 0744);
+        target_fd = open(target_fname,
+                         O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0744);
         if (target_fd == -1) {
                 syslog(LOG_INFO, "Open Failed: %s", strerror(errno));
                 goto done;
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 93825a17dcce..cf3a44bf1ec3 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -2395,7 +2395,7 @@ process_flags(struct event_format *event, struct print_arg *arg, char **tok)
 {
         struct print_arg *field;
         enum event_type type;
-        char *token;
+        char *token = NULL;
 
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_FLAGS;
@@ -2448,7 +2448,7 @@ process_symbols(struct event_format *event, struct print_arg *arg, char **tok)
 {
         struct print_arg *field;
         enum event_type type;
-        char *token;
+        char *token = NULL;
 
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_SYMBOL;
@@ -2487,7 +2487,7 @@ process_hex(struct event_format *event, struct print_arg *arg, char **tok)
 {
         struct print_arg *field;
         enum event_type type;
-        char *token;
+        char *token = NULL;
 
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_HEX;
diff --git a/tools/lib/traceevent/plugin_cfg80211.c b/tools/lib/traceevent/plugin_cfg80211.c
index c066b25905f8..4592d8438318 100644
--- a/tools/lib/traceevent/plugin_cfg80211.c
+++ b/tools/lib/traceevent/plugin_cfg80211.c
@@ -5,8 +5,7 @@
 #include "event-parse.h"
 
 static unsigned long long
-process___le16_to_cpup(struct trace_seq *s,
-                       unsigned long long *args)
+process___le16_to_cpup(struct trace_seq *s, unsigned long long *args)
 {
         uint16_t *val = (uint16_t *) (unsigned long) args[0];
         return val ? (long long) le16toh(*val) : 0;
diff --git a/tools/lib/traceevent/plugin_jbd2.c b/tools/lib/traceevent/plugin_jbd2.c
index 0db714c721be..5c23d5bd27ce 100644
--- a/tools/lib/traceevent/plugin_jbd2.c
+++ b/tools/lib/traceevent/plugin_jbd2.c
@@ -30,8 +30,7 @@
 #define MINOR(dev)      ((unsigned int) ((dev) & MINORMASK))
 
 static unsigned long long
-process_jbd2_dev_to_name(struct trace_seq *s,
-                         unsigned long long *args)
+process_jbd2_dev_to_name(struct trace_seq *s, unsigned long long *args)
 {
         unsigned int dev = args[0];
 
@@ -40,8 +39,7 @@ process_jbd2_dev_to_name(struct trace_seq *s,
 }
 
 static unsigned long long
-process_jiffies_to_msecs(struct trace_seq *s,
-                         unsigned long long *args)
+process_jiffies_to_msecs(struct trace_seq *s, unsigned long long *args)
 {
         unsigned long long jiffies = args[0];
 
diff --git a/tools/lib/traceevent/plugin_kvm.c b/tools/lib/traceevent/plugin_kvm.c
index 9e0e8c61b43b..88fe83dff7cd 100644
--- a/tools/lib/traceevent/plugin_kvm.c
+++ b/tools/lib/traceevent/plugin_kvm.c
@@ -240,25 +240,38 @@ static const char *find_exit_reason(unsigned isa, int val)
         for (i = 0; strings[i].val >= 0; i++)
                 if (strings[i].val == val)
                         break;
-        if (strings[i].str)
-                return strings[i].str;
-        return "UNKNOWN";
+
+        return strings[i].str;
 }
 
-static int kvm_exit_handler(struct trace_seq *s, struct pevent_record *record,
-                            struct event_format *event, void *context)
+static int print_exit_reason(struct trace_seq *s, struct pevent_record *record,
+                             struct event_format *event, const char *field)
 {
         unsigned long long isa;
         unsigned long long val;
-        unsigned long long info1 = 0, info2 = 0;
+        const char *reason;
 
-        if (pevent_get_field_val(s, event, "exit_reason", record, &val, 1) < 0)
+        if (pevent_get_field_val(s, event, field, record, &val, 1) < 0)
                 return -1;
 
         if (pevent_get_field_val(s, event, "isa", record, &isa, 0) < 0)
                 isa = 1;
 
-        trace_seq_printf(s, "reason %s", find_exit_reason(isa, val));
+        reason = find_exit_reason(isa, val);
+        if (reason)
+                trace_seq_printf(s, "reason %s", reason);
+        else
+                trace_seq_printf(s, "reason UNKNOWN (%llu)", val);
+        return 0;
+}
+
+static int kvm_exit_handler(struct trace_seq *s, struct pevent_record *record,
+                            struct event_format *event, void *context)
+{
+        unsigned long long info1 = 0, info2 = 0;
+
+        if (print_exit_reason(s, record, event, "exit_reason") < 0)
+                return -1;
 
         pevent_print_num_field(s, " rip 0x%lx", event, "guest_rip", record, 1);
 
@@ -313,6 +326,29 @@ static int kvm_emulate_insn_handler(struct trace_seq *s,
         return 0;
 }
 
+
+static int kvm_nested_vmexit_inject_handler(struct trace_seq *s, struct pevent_record *record,
+                                            struct event_format *event, void *context)
+{
+        if (print_exit_reason(s, record, event, "exit_code") < 0)
+                return -1;
+
+        pevent_print_num_field(s, " info1 %llx", event, "exit_info1", record, 1);
+        pevent_print_num_field(s, " info2 %llx", event, "exit_info2", record, 1);
+        pevent_print_num_field(s, " int_info %llx", event, "exit_int_info", record, 1);
+        pevent_print_num_field(s, " int_info_err %llx", event, "exit_int_info_err", record, 1);
+
+        return 0;
+}
+
+static int kvm_nested_vmexit_handler(struct trace_seq *s, struct pevent_record *record,
+                                     struct event_format *event, void *context)
+{
+        pevent_print_num_field(s, "rip %llx ", event, "rip", record, 1);
+
+        return kvm_nested_vmexit_inject_handler(s, record, event, context);
+}
+
 union kvm_mmu_page_role {
         unsigned word;
         struct {
@@ -409,6 +445,12 @@ int PEVENT_PLUGIN_LOADER(struct pevent *pevent)
         pevent_register_event_handler(pevent, -1, "kvm", "kvm_emulate_insn",
                                       kvm_emulate_insn_handler, NULL);
 
+        pevent_register_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit",
+                                      kvm_nested_vmexit_handler, NULL);
+
+        pevent_register_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit_inject",
+                                      kvm_nested_vmexit_inject_handler, NULL);
+
         pevent_register_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_get_page",
                                       kvm_mmu_get_page_handler, NULL);
 
@@ -443,6 +485,12 @@ void PEVENT_PLUGIN_UNLOADER(struct pevent *pevent)
         pevent_unregister_event_handler(pevent, -1, "kvm", "kvm_emulate_insn",
                                         kvm_emulate_insn_handler, NULL);
 
+        pevent_unregister_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit",
+                                        kvm_nested_vmexit_handler, NULL);
+
+        pevent_unregister_event_handler(pevent, -1, "kvm", "kvm_nested_vmexit_inject",
+                                        kvm_nested_vmexit_inject_handler, NULL);
+
         pevent_unregister_event_handler(pevent, -1, "kvmmmu", "kvm_mmu_get_page",
                                         kvm_mmu_get_page_handler, NULL);
 
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index 4464ad770d51..f6480cbf309b 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -16,6 +16,10 @@ This 'perf bench' command is a general framework for benchmark suites.
 
 COMMON OPTIONS
 --------------
+-r::
+--repeat=::
+Specify amount of times to repeat the run (default 10).
+
 -f::
 --format=::
 Specify format style.
diff --git a/tools/perf/Documentation/perf-inject.txt b/tools/perf/Documentation/perf-inject.txt
index a00a34276c54..dc7442cf3d7f 100644
--- a/tools/perf/Documentation/perf-inject.txt
+++ b/tools/perf/Documentation/perf-inject.txt
@@ -41,6 +41,9 @@ OPTIONS
         tasks slept. sched_switch contains a callchain where a task slept and
         sched_stat contains a timeslice how long a task slept.
 
+--kallsyms=<file>::
+        kallsyms pathname
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-report[1], linkperf:perf-archive[1]
diff --git a/tools/perf/Documentation/perf-kvm.txt b/tools/perf/Documentation/perf-kvm.txt
index 52276a6d2b75..6e689dc89a2f 100644
--- a/tools/perf/Documentation/perf-kvm.txt
+++ b/tools/perf/Documentation/perf-kvm.txt
@@ -51,9 +51,9 @@ There are a couple of variants of perf kvm:
   'perf kvm stat <command>' to run a command and gather performance counter
   statistics.
   Especially, perf 'kvm stat record/report' generates a statistical analysis
-  of KVM events. Currently, vmexit, mmio and ioport events are supported.
-  'perf kvm stat record <command>' records kvm events and the events between
-  start and end <command>.
+  of KVM events. Currently, vmexit, mmio (x86 only) and ioport (x86 only)
+  events are supported. 'perf kvm stat record <command>' records kvm events
+  and the events between start and end <command>.
   And this command produces a file which contains tracing results of kvm
   events.
 
@@ -103,8 +103,8 @@ STAT REPORT OPTIONS
        analyze events which occures on this vcpu. (default: all vcpus)
 
 --event=<value>::
-       event to be analyzed. Possible values: vmexit, mmio, ioport.
-       (default: vmexit)
+       event to be analyzed. Possible values: vmexit, mmio (x86 only),
+       ioport (x86 only). (default: vmexit)
 -k::
 --key=<value>::
        Sorting key. Possible values: sample (default, sort by samples
@@ -138,7 +138,8 @@ STAT LIVE OPTIONS
 
 
 --event=<value>::
-       event to be analyzed. Possible values: vmexit, mmio, ioport.
+       event to be analyzed. Possible values: vmexit,
+       mmio (x86 only), ioport (x86 only).
        (default: vmexit)
 
 -k::
@@ -147,7 +148,8 @@ STAT LIVE OPTIONS
        number), time (sort by average time).
 
 --duration=<value>::
-       Show events other than HLT that take longer than duration usecs.
+       Show events other than HLT (x86 only) or Wait state (s390 only)
+       that take longer than duration usecs.
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-timechart.txt b/tools/perf/Documentation/perf-timechart.txt
index 5e0f986dff38..df98d1c82688 100644
--- a/tools/perf/Documentation/perf-timechart.txt
+++ b/tools/perf/Documentation/perf-timechart.txt
@@ -15,10 +15,20 @@ DESCRIPTION
 There are two variants of perf timechart:
 
   'perf timechart record <command>' to record the system level events
-  of an arbitrary workload.
+  of an arbitrary workload. By default timechart records only scheduler
+  and CPU events (task switches, running times, CPU power states, etc),
+  but it's possible to record IO (disk, network) activity using -I argument.
 
   'perf timechart' to turn a trace into a Scalable Vector Graphics file,
-  that can be viewed with popular SVG viewers such as 'Inkscape'.
+  that can be viewed with popular SVG viewers such as 'Inkscape'. Depending
+  on the events in the perf.data file, timechart will contain scheduler/cpu
+  events or IO events.
+
+  In IO mode, every bar has two charts: upper and lower.
+  Upper bar shows incoming events (disk reads, ingress network packets).
+  Lower bar shows outgoing events (disk writes, egress network packets).
+  There are also poll bars which show how much time application spent
+  in poll/epoll/select syscalls.
 
 TIMECHART OPTIONS
 -----------------
@@ -54,6 +64,19 @@ TIMECHART OPTIONS
         duration or tasks with given name. If number is given it's interpreted
         as number of nanoseconds. If non-numeric string is given it's
         interpreted as task name.
+--io-skip-eagain::
+        Don't draw EAGAIN IO events.
+--io-min-time=<nsecs>::
+        Draw small events as if they lasted min-time. Useful when you need
+        to see very small and fast IO. It's possible to specify ms or us
+        suffix to specify time in milliseconds or microseconds.
+        Default value is 1ms.
+--io-merge-dist=<nsecs>::
+        Merge events that are merge-dist nanoseconds apart.
+        Reduces number of figures on the SVG and makes it more render-friendly.
+        It's possible to specify ms or us suffix to specify time in
+        milliseconds or microseconds.
+        Default value is 1us.
 
 RECORD OPTIONS
 --------------
@@ -63,6 +86,9 @@ RECORD OPTIONS
 -T::
 --tasks-only::
         Record only tasks-related events
+-I::
+--io-only::
+        Record only io-related events
 -g::
 --callchain::
         Do call-graph (stack chain/backtrace) recording
@@ -87,6 +113,14 @@ Record system-wide timechart:
 
   $ perf timechart --highlight gcc
 
+Record system-wide IO events:
+
+  $ perf timechart record -I
+
+  then generate timechart:
+
+  $ perf timechart
+
 SEE ALSO
 --------
 linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index fae38d9a44a4..02aac831bdd9 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -107,6 +107,52 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
         Show tool stats such as number of times fd->pathname was discovered thru
         hooking the open syscall return + vfs_getname or via reading /proc/pid/fd, etc.
 
+-F=[all|min|maj]::
+--pf=[all|min|maj]::
+        Trace pagefaults. Optionally, you can specify whether you want minor,
+        major or all pagefaults. Default value is maj.
+
+--syscalls::
+        Trace system calls. This options is enabled by default.
+
+PAGEFAULTS
+----------
+
+When tracing pagefaults, the format of the trace is as follows:
+
+<min|maj>fault [<ip.symbol>+<ip.offset>] => <addr.dso@addr.offset> (<map type><addr level>).
+
+- min/maj indicates whether fault event is minor or major;
+- ip.symbol shows symbol for instruction pointer (the code that generated the
+  fault); if no debug symbols available, perf trace will print raw IP;
+- addr.dso shows DSO for the faulted address;
+- map type is either 'd' for non-executable maps or 'x' for executable maps;
+- addr level is either 'k' for kernel dso or '.' for user dso.
+
+For symbols resolution you may need to install debugging symbols.
+
+Please be aware that duration is currently always 0 and doesn't reflect actual
+time it took for fault to be handled!
+
+When --verbose specified, perf trace tries to print all available information
+for both IP and fault address in the form of dso@symbol+offset.
+
+EXAMPLES
+--------
+
+Trace only major pagefaults:
+
+ $ perf trace --no-syscalls -F
+
+Trace syscalls, major and minor pagefaults:
+
+ $ perf trace -F all
+
+  1416.547 ( 0.000 ms): python/20235 majfault [CRYPTO_push_info_+0x0] => /lib/x86_64-linux-gnu/libcrypto.so.1.0.0@0x61be0 (x.)
+
+  As you can see, there was major pagefault in python process, from
+  CRYPTO_push_info_ routine which faulted somewhere in libcrypto.so.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script[1]
diff --git a/tools/perf/Documentation/perf.txt b/tools/perf/Documentation/perf.txt
index 0eeb247dc7d2..d240bb2e5b22 100644
--- a/tools/perf/Documentation/perf.txt
+++ b/tools/perf/Documentation/perf.txt
@@ -8,7 +8,15 @@ perf - Performance analysis tools for Linux
 SYNOPSIS
 --------
 [verse]
-'perf' [--version] [--help] COMMAND [ARGS]
+'perf' [--version] [--help] [OPTIONS] COMMAND [ARGS]
+
+OPTIONS
+-------
+--debug::
+        Setup debug variable (just verbose for now) in value
+        range (0, 10). Use like:
+          --debug verbose   # sets verbose = 1
+          --debug verbose=2 # sets verbose = 2
 
 DESCRIPTION
 -----------
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index 45da209b6ed3..344c4d3d0a4a 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -37,3 +37,6 @@ arch/x86/include/asm/kvm_host.h
 arch/x86/include/uapi/asm/svm.h
 arch/x86/include/uapi/asm/vmx.h
 arch/x86/include/uapi/asm/kvm.h
+arch/x86/include/uapi/asm/kvm_perf.h
+arch/s390/include/uapi/asm/sie.h
+arch/s390/include/uapi/asm/kvm_perf.h
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index 9670a16fa577..2240974b7745 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -295,11 +295,13 @@ LIB_H += util/intlist.h
 LIB_H += util/perf_regs.h
 LIB_H += util/unwind.h
 LIB_H += util/vdso.h
+LIB_H += util/tsc.h
 LIB_H += ui/helpline.h
 LIB_H += ui/progress.h
 LIB_H += ui/util.h
 LIB_H += ui/ui.h
 LIB_H += util/data.h
+LIB_H += util/kvm-stat.h
 
 LIB_OBJS += $(OUTPUT)util/abspath.o
 LIB_OBJS += $(OUTPUT)util/alias.o
@@ -373,6 +375,8 @@ LIB_OBJS += $(OUTPUT)util/stat.o
 LIB_OBJS += $(OUTPUT)util/record.o
 LIB_OBJS += $(OUTPUT)util/srcline.o
 LIB_OBJS += $(OUTPUT)util/data.o
+LIB_OBJS += $(OUTPUT)util/tsc.o
+LIB_OBJS += $(OUTPUT)util/cloexec.o
 
 LIB_OBJS += $(OUTPUT)ui/setup.o
 LIB_OBJS += $(OUTPUT)ui/helpline.o
diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
index 744e629797be..b92219b1900d 100644
--- a/tools/perf/arch/powerpc/Makefile
+++ b/tools/perf/arch/powerpc/Makefile
@@ -3,3 +3,4 @@ PERF_HAVE_DWARF_REGS := 1
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.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/header.c b/tools/perf/arch/powerpc/util/header.c
index 2f7073d107fd..6c1b8a75db09 100644
--- a/tools/perf/arch/powerpc/util/header.c
+++ b/tools/perf/arch/powerpc/util/header.c
@@ -5,9 +5,7 @@
 #include <string.h>
 
 #include "../../util/header.h"
-
-#define __stringify_1(x)        #x
-#define __stringify(x)          __stringify_1(x)
+#include "../../util/util.h"
 
 #define mfspr(rn)       ({unsigned long rval; \
                          asm volatile("mfspr %0," __stringify(rn) \
diff --git a/tools/perf/arch/powerpc/util/skip-callchain-idx.c b/tools/perf/arch/powerpc/util/skip-callchain-idx.c
new file mode 100644
index 000000000000..a7c23a4b3778
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/skip-callchain-idx.c
@@ -0,0 +1,266 @@
+/*
+ * Use DWARF Debug information to skip unnecessary callchain entries.
+ *
+ * Copyright (C) 2014 Sukadev Bhattiprolu, IBM Corporation.
+ * Copyright (C) 2014 Ulrich Weigand, IBM Corporation.
+ *
+ * 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 <inttypes.h>
+#include <dwarf.h>
+#include <elfutils/libdwfl.h>
+
+#include "util/thread.h"
+#include "util/callchain.h"
+
+/*
+ * When saving the callchain on Power, the kernel conservatively saves
+ * excess entries in the callchain. A few of these entries are needed
+ * in some cases but not others. If the unnecessary entries are not
+ * ignored, we end up with duplicate arcs in the call-graphs. Use
+ * DWARF debug information to skip over any unnecessary callchain
+ * entries.
+ *
+ * See function header for arch_adjust_callchain() below for more details.
+ *
+ * The libdwfl code in this file is based on code from elfutils
+ * (libdwfl/argp-std.c, libdwfl/tests/addrcfi.c, etc).
+ */
+static char *debuginfo_path;
+
+static const Dwfl_Callbacks offline_callbacks = {
+        .debuginfo_path = &debuginfo_path,
+        .find_debuginfo = dwfl_standard_find_debuginfo,
+        .section_address = dwfl_offline_section_address,
+};
+
+
+/*
+ * Use the DWARF expression for the Call-frame-address and determine
+ * if return address is in LR and if a new frame was allocated.
+ */
+static int check_return_reg(int ra_regno, Dwarf_Frame *frame)
+{
+        Dwarf_Op ops_mem[2];
+        Dwarf_Op dummy;
+        Dwarf_Op *ops = &dummy;
+        size_t nops;
+        int result;
+
+        result = dwarf_frame_register(frame, ra_regno, ops_mem, &ops, &nops);
+        if (result < 0) {
+                pr_debug("dwarf_frame_register() %s\n", dwarf_errmsg(-1));
+                return -1;
+        }
+
+        /*
+         * Check if return address is on the stack.
+         */
+        if (nops != 0 || ops != NULL)
+                return 0;
+
+        /*
+         * Return address is in LR. Check if a frame was allocated
+         * but not-yet used.
+         */
+        result = dwarf_frame_cfa(frame, &ops, &nops);
+        if (result < 0) {
+                pr_debug("dwarf_frame_cfa() returns %d, %s\n", result,
+                                        dwarf_errmsg(-1));
+                return -1;
+        }
+
+        /*
+         * If call frame address is in r1, no new frame was allocated.
+         */
+        if (nops == 1 && ops[0].atom == DW_OP_bregx && ops[0].number == 1 &&
+                                ops[0].number2 == 0)
+                return 1;
+
+        /*
+         * A new frame was allocated but has not yet been used.
+         */
+        return 2;
+}
+
+/*
+ * Get the DWARF frame from the .eh_frame section.
+ */
+static Dwarf_Frame *get_eh_frame(Dwfl_Module *mod, Dwarf_Addr pc)
+{
+        int             result;
+        Dwarf_Addr      bias;
+        Dwarf_CFI       *cfi;
+        Dwarf_Frame     *frame;
+
+        cfi = dwfl_module_eh_cfi(mod, &bias);
+        if (!cfi) {
+                pr_debug("%s(): no CFI - %s\n", __func__, dwfl_errmsg(-1));
+                return NULL;
+        }
+
+        result = dwarf_cfi_addrframe(cfi, pc, &frame);
+        if (result) {
+                pr_debug("%s(): %s\n", __func__, dwfl_errmsg(-1));
+                return NULL;
+        }
+
+        return frame;
+}
+
+/*
+ * Get the DWARF frame from the .debug_frame section.
+ */
+static Dwarf_Frame *get_dwarf_frame(Dwfl_Module *mod, Dwarf_Addr pc)
+{
+        Dwarf_CFI       *cfi;
+        Dwarf_Addr      bias;
+        Dwarf_Frame     *frame;
+        int             result;
+
+        cfi = dwfl_module_dwarf_cfi(mod, &bias);
+        if (!cfi) {
+                pr_debug("%s(): no CFI - %s\n", __func__, dwfl_errmsg(-1));
+                return NULL;
+        }
+
+        result = dwarf_cfi_addrframe(cfi, pc, &frame);
+        if (result) {
+                pr_debug("%s(): %s\n", __func__, dwfl_errmsg(-1));
+                return NULL;
+        }
+
+        return frame;
+}
+
+/*
+ * Return:
+ *      0 if return address for the program counter @pc is on stack
+ *      1 if return address is in LR and no new stack frame was allocated
+ *      2 if return address is in LR and a new frame was allocated (but not
+ *              yet used)
+ *      -1 in case of errors
+ */
+static int check_return_addr(const char *exec_file, Dwarf_Addr pc)
+{
+        int             rc = -1;
+        Dwfl            *dwfl;
+        Dwfl_Module     *mod;
+        Dwarf_Frame     *frame;
+        int             ra_regno;
+        Dwarf_Addr      start = pc;
+        Dwarf_Addr      end = pc;
+        bool            signalp;
+
+        dwfl = dwfl_begin(&offline_callbacks);
+        if (!dwfl) {
+                pr_debug("dwfl_begin() failed: %s\n", dwarf_errmsg(-1));
+                return -1;
+        }
+
+        if (dwfl_report_offline(dwfl, "",  exec_file, -1) == NULL) {
+                pr_debug("dwfl_report_offline() failed %s\n", dwarf_errmsg(-1));
+                goto out;
+        }
+
+        mod = dwfl_addrmodule(dwfl, pc);
+        if (!mod) {
+                pr_debug("dwfl_addrmodule() failed, %s\n", dwarf_errmsg(-1));
+                goto out;
+        }
+
+        /*
+         * To work with split debug info files (eg: glibc), check both
+         * .eh_frame and .debug_frame sections of the ELF header.
+         */
+        frame = get_eh_frame(mod, pc);
+        if (!frame) {
+                frame = get_dwarf_frame(mod, pc);
+                if (!frame)
+                        goto out;
+        }
+
+        ra_regno = dwarf_frame_info(frame, &start, &end, &signalp);
+        if (ra_regno < 0) {
+                pr_debug("Return address register unavailable: %s\n",
+                                dwarf_errmsg(-1));
+                goto out;
+        }
+
+        rc = check_return_reg(ra_regno, frame);
+
+out:
+        dwfl_end(dwfl);
+        return rc;
+}
+
+/*
+ * The callchain saved by the kernel always includes the link register (LR).
+ *
+ *      0:      PERF_CONTEXT_USER
+ *      1:      Program counter (Next instruction pointer)
+ *      2:      LR value
+ *      3:      Caller's caller
+ *      4:      ...
+ *
+ * The value in LR is only needed when it holds a return address. If the
+ * return address is on the stack, we should ignore the LR value.
+ *
+ * Further, when the return address is in the LR, if a new frame was just
+ * allocated but the LR was not saved into it, then the LR contains the
+ * caller, slot 4: contains the caller's caller and the contents of slot 3:
+ * (chain->ips[3]) is undefined and must be ignored.
+ *
+ * Use DWARF debug information to determine if any entries need to be skipped.
+ *
+ * Return:
+ *      index:  of callchain entry that needs to be ignored (if any)
+ *      -1      if no entry needs to be ignored or in case of errors
+ */
+int arch_skip_callchain_idx(struct machine *machine, struct thread *thread,
+                                struct ip_callchain *chain)
+{
+        struct addr_location al;
+        struct dso *dso = NULL;
+        int rc;
+        u64 ip;
+        u64 skip_slot = -1;
+
+        if (chain->nr < 3)
+                return skip_slot;
+
+        ip = chain->ips[2];
+
+        thread__find_addr_location(thread, machine, PERF_RECORD_MISC_USER,
+                        MAP__FUNCTION, ip, &al);
+
+        if (al.map)
+                dso = al.map->dso;
+
+        if (!dso) {
+                pr_debug("%" PRIx64 " dso is NULL\n", ip);
+                return skip_slot;
+        }
+
+        rc = check_return_addr(dso->long_name, ip);
+
+        pr_debug("DSO %s, nr %" PRIx64 ", ip 0x%" PRIx64 "rc %d\n",
+                                dso->long_name, chain->nr, ip, rc);
+
+        if (rc == 0) {
+                /*
+                 * Return address on stack. Ignore LR value in callchain
+                 */
+                skip_slot = 2;
+        } else if (rc == 2) {
+                /*
+                 * New frame allocated but return address still in LR.
+                 * Ignore the caller's caller entry in callchain.
+                 */
+                skip_slot = 3;
+        }
+        return skip_slot;
+}
diff --git a/tools/perf/arch/s390/Makefile b/tools/perf/arch/s390/Makefile
index 15130b50dfe3..798ac7379c5f 100644
--- a/tools/perf/arch/s390/Makefile
+++ b/tools/perf/arch/s390/Makefile
@@ -2,3 +2,6 @@ ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
+HAVE_KVM_STAT_SUPPORT := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/kvm-stat.o
diff --git a/tools/perf/arch/s390/util/header.c b/tools/perf/arch/s390/util/header.c
new file mode 100644
index 000000000000..9fa6c3e5782c
--- /dev/null
+++ b/tools/perf/arch/s390/util/header.c
@@ -0,0 +1,28 @@
+/*
+ * Implementation of get_cpuid().
+ *
+ * Copyright 2014 IBM Corp.
+ * Author(s): Alexander Yarygin <yarygin@linux.vnet.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (version 2 only)
+ * as published by the Free Software Foundation.
+ */
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../../util/header.h"
+
+int get_cpuid(char *buffer, size_t sz)
+{
+        const char *cpuid = "IBM/S390";
+
+        if (strlen(cpuid) + 1 > sz)
+                return -1;
+
+        strcpy(buffer, cpuid);
+        return 0;
+}
diff --git a/tools/perf/arch/s390/util/kvm-stat.c b/tools/perf/arch/s390/util/kvm-stat.c
new file mode 100644
index 000000000000..a5dbc07ec9dc
--- /dev/null
+++ b/tools/perf/arch/s390/util/kvm-stat.c
@@ -0,0 +1,105 @@
+/*
+ * Arch specific functions for perf kvm stat.
+ *
+ * Copyright 2014 IBM Corp.
+ * Author(s): Alexander Yarygin <yarygin@linux.vnet.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (version 2 only)
+ * as published by the Free Software Foundation.
+ */
+
+#include "../../util/kvm-stat.h"
+#include <asm/kvm_perf.h>
+
+define_exit_reasons_table(sie_exit_reasons, sie_intercept_code);
+define_exit_reasons_table(sie_icpt_insn_codes, icpt_insn_codes);
+define_exit_reasons_table(sie_sigp_order_codes, sigp_order_codes);
+define_exit_reasons_table(sie_diagnose_codes, diagnose_codes);
+define_exit_reasons_table(sie_icpt_prog_codes, icpt_prog_codes);
+
+static void event_icpt_insn_get_key(struct perf_evsel *evsel,
+                                    struct perf_sample *sample,
+                                    struct event_key *key)
+{
+        unsigned long insn;
+
+        insn = perf_evsel__intval(evsel, sample, "instruction");
+        key->key = icpt_insn_decoder(insn);
+        key->exit_reasons = sie_icpt_insn_codes;
+}
+
+static void event_sigp_get_key(struct perf_evsel *evsel,
+                               struct perf_sample *sample,
+                               struct event_key *key)
+{
+        key->key = perf_evsel__intval(evsel, sample, "order_code");
+        key->exit_reasons = sie_sigp_order_codes;
+}
+
+static void event_diag_get_key(struct perf_evsel *evsel,
+                               struct perf_sample *sample,
+                               struct event_key *key)
+{
+        key->key = perf_evsel__intval(evsel, sample, "code");
+        key->exit_reasons = sie_diagnose_codes;
+}
+
+static void event_icpt_prog_get_key(struct perf_evsel *evsel,
+                                    struct perf_sample *sample,
+                                    struct event_key *key)
+{
+        key->key = perf_evsel__intval(evsel, sample, "code");
+        key->exit_reasons = sie_icpt_prog_codes;
+}
+
+static struct child_event_ops child_events[] = {
+        { .name = "kvm:kvm_s390_intercept_instruction",
+          .get_key = event_icpt_insn_get_key },
+        { .name = "kvm:kvm_s390_handle_sigp",
+          .get_key = event_sigp_get_key },
+        { .name = "kvm:kvm_s390_handle_diag",
+          .get_key = event_diag_get_key },
+        { .name = "kvm:kvm_s390_intercept_prog",
+          .get_key = event_icpt_prog_get_key },
+        { NULL, NULL },
+};
+
+static struct kvm_events_ops exit_events = {
+        .is_begin_event = exit_event_begin,
+        .is_end_event = exit_event_end,
+        .child_ops = child_events,
+        .decode_key = exit_event_decode_key,
+        .name = "VM-EXIT"
+};
+
+const char * const kvm_events_tp[] = {
+        "kvm:kvm_s390_sie_enter",
+        "kvm:kvm_s390_sie_exit",
+        "kvm:kvm_s390_intercept_instruction",
+        "kvm:kvm_s390_handle_sigp",
+        "kvm:kvm_s390_handle_diag",
+        "kvm:kvm_s390_intercept_prog",
+        NULL,
+};
+
+struct kvm_reg_events_ops kvm_reg_events_ops[] = {
+        { .name = "vmexit", .ops = &exit_events },
+        { NULL, NULL },
+};
+
+const char * const kvm_skip_events[] = {
+        "Wait state",
+        NULL,
+};
+
+int cpu_isa_init(struct perf_kvm_stat *kvm, const char *cpuid)
+{
+        if (strstr(cpuid, "IBM/S390")) {
+                kvm->exit_reasons = sie_exit_reasons;
+                kvm->exit_reasons_isa = "SIE";
+        } else
+                return -ENOTSUP;
+
+        return 0;
+}
diff --git a/tools/perf/arch/x86/Makefile b/tools/perf/arch/x86/Makefile
index 1641542e3636..9b21881db52f 100644
--- a/tools/perf/arch/x86/Makefile
+++ b/tools/perf/arch/x86/Makefile
@@ -15,3 +15,5 @@ endif
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/tsc.o
 LIB_H += arch/$(ARCH)/util/tsc.h
+HAVE_KVM_STAT_SUPPORT := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/kvm-stat.o
diff --git a/tools/perf/arch/x86/tests/dwarf-unwind.c b/tools/perf/arch/x86/tests/dwarf-unwind.c
index 9f89f899ccc7..d8bbf7ad1681 100644
--- a/tools/perf/arch/x86/tests/dwarf-unwind.c
+++ b/tools/perf/arch/x86/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/x86/util/kvm-stat.c b/tools/perf/arch/x86/util/kvm-stat.c
new file mode 100644
index 000000000000..14e4e668fad7
--- /dev/null
+++ b/tools/perf/arch/x86/util/kvm-stat.c
@@ -0,0 +1,156 @@
+#include "../../util/kvm-stat.h"
+#include <asm/kvm_perf.h>
+
+define_exit_reasons_table(vmx_exit_reasons, VMX_EXIT_REASONS);
+define_exit_reasons_table(svm_exit_reasons, SVM_EXIT_REASONS);
+
+static struct kvm_events_ops exit_events = {
+        .is_begin_event = exit_event_begin,
+        .is_end_event = exit_event_end,
+        .decode_key = exit_event_decode_key,
+        .name = "VM-EXIT"
+};
+
+/*
+ * For the mmio events, we treat:
+ * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry
+ * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...).
+ */
+static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample,
+                               struct event_key *key)
+{
+        key->key  = perf_evsel__intval(evsel, sample, "gpa");
+        key->info = perf_evsel__intval(evsel, sample, "type");
+}
+
+#define KVM_TRACE_MMIO_READ_UNSATISFIED 0
+#define KVM_TRACE_MMIO_READ 1
+#define KVM_TRACE_MMIO_WRITE 2
+
+static bool mmio_event_begin(struct perf_evsel *evsel,
+                             struct perf_sample *sample, struct event_key *key)
+{
+        /* MMIO read begin event in kernel. */
+        if (kvm_exit_event(evsel))
+                return true;
+
+        /* MMIO write begin event in kernel. */
+        if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
+            perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) {
+                mmio_event_get_key(evsel, sample, key);
+                return true;
+        }
+
+        return false;
+}
+
+static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample,
+                           struct event_key *key)
+{
+        /* MMIO write end event in kernel. */
+        if (kvm_entry_event(evsel))
+                return true;
+
+        /* MMIO read end event in kernel.*/
+        if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
+            perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) {
+                mmio_event_get_key(evsel, sample, key);
+                return true;
+        }
+
+        return false;
+}
+
+static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
+                                  struct event_key *key,
+                                  char *decode)
+{
+        scnprintf(decode, DECODE_STR_LEN, "%#lx:%s",
+                  (unsigned long)key->key,
+                  key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R");
+}
+
+static struct kvm_events_ops mmio_events = {
+        .is_begin_event = mmio_event_begin,
+        .is_end_event = mmio_event_end,
+        .decode_key = mmio_event_decode_key,
+        .name = "MMIO Access"
+};
+
+ /* The time of emulation pio access is from kvm_pio to kvm_entry. */
+static void ioport_event_get_key(struct perf_evsel *evsel,
+                                 struct perf_sample *sample,
+                                 struct event_key *key)
+{
+        key->key  = perf_evsel__intval(evsel, sample, "port");
+        key->info = perf_evsel__intval(evsel, sample, "rw");
+}
+
+static bool ioport_event_begin(struct perf_evsel *evsel,
+                               struct perf_sample *sample,
+                               struct event_key *key)
+{
+        if (!strcmp(evsel->name, "kvm:kvm_pio")) {
+                ioport_event_get_key(evsel, sample, key);
+                return true;
+        }
+
+        return false;
+}
+
+static bool ioport_event_end(struct perf_evsel *evsel,
+                             struct perf_sample *sample __maybe_unused,
+                             struct event_key *key __maybe_unused)
+{
+        return kvm_entry_event(evsel);
+}
+
+static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
+                                    struct event_key *key,
+                                    char *decode)
+{
+        scnprintf(decode, DECODE_STR_LEN, "%#llx:%s",
+                  (unsigned long long)key->key,
+                  key->info ? "POUT" : "PIN");
+}
+
+static struct kvm_events_ops ioport_events = {
+        .is_begin_event = ioport_event_begin,
+        .is_end_event = ioport_event_end,
+        .decode_key = ioport_event_decode_key,
+        .name = "IO Port Access"
+};
+
+const char * const kvm_events_tp[] = {
+        "kvm:kvm_entry",
+        "kvm:kvm_exit",
+        "kvm:kvm_mmio",
+        "kvm:kvm_pio",
+        NULL,
+};
+
+struct kvm_reg_events_ops kvm_reg_events_ops[] = {
+        { .name = "vmexit", .ops = &exit_events },
+        { .name = "mmio", .ops = &mmio_events },
+        { .name = "ioport", .ops = &ioport_events },
+        { NULL, NULL },
+};
+
+const char * const kvm_skip_events[] = {
+        "HLT",
+        NULL,
+};
+
+int cpu_isa_init(struct perf_kvm_stat *kvm, const char *cpuid)
+{
+        if (strstr(cpuid, "Intel")) {
+                kvm->exit_reasons = vmx_exit_reasons;
+                kvm->exit_reasons_isa = "VMX";
+        } else if (strstr(cpuid, "AMD")) {
+                kvm->exit_reasons = svm_exit_reasons;
+                kvm->exit_reasons_isa = "SVM";
+        } else
+                return -ENOTSUP;
+
+        return 0;
+}
diff --git a/tools/perf/arch/x86/util/tsc.c b/tools/perf/arch/x86/util/tsc.c
index 40021fa3129b..fd2868490d00 100644
--- a/tools/perf/arch/x86/util/tsc.c
+++ b/tools/perf/arch/x86/util/tsc.c
@@ -6,29 +6,9 @@
 #include "../../perf.h"
 #include <linux/types.h>
 #include "../../util/debug.h"
+#include "../../util/tsc.h"
 #include "tsc.h"
 
-u64 perf_time_to_tsc(u64 ns, struct perf_tsc_conversion *tc)
-{
-        u64 t, quot, rem;
-
-        t = ns - tc->time_zero;
-        quot = t / tc->time_mult;
-        rem  = t % tc->time_mult;
-        return (quot << tc->time_shift) +
-               (rem << tc->time_shift) / tc->time_mult;
-}
-
-u64 tsc_to_perf_time(u64 cyc, struct perf_tsc_conversion *tc)
-{
-        u64 quot, rem;
-
-        quot = cyc >> tc->time_shift;
-        rem  = cyc & ((1 << tc->time_shift) - 1);
-        return tc->time_zero + quot * tc->time_mult +
-               ((rem * tc->time_mult) >> tc->time_shift);
-}
-
 int perf_read_tsc_conversion(const struct perf_event_mmap_page *pc,
                              struct perf_tsc_conversion *tc)
 {
@@ -57,3 +37,12 @@ int perf_read_tsc_conversion(const struct perf_event_mmap_page *pc,
 
         return 0;
 }
+
+u64 rdtsc(void)
+{
+        unsigned int low, high;
+
+        asm volatile("rdtsc" : "=a" (low), "=d" (high));
+
+        return low | ((u64)high) << 32;
+}
diff --git a/tools/perf/arch/x86/util/tsc.h b/tools/perf/arch/x86/util/tsc.h
index 2affe0366b59..2edc4d31065c 100644
--- a/tools/perf/arch/x86/util/tsc.h
+++ b/tools/perf/arch/x86/util/tsc.h
@@ -14,7 +14,4 @@ struct perf_event_mmap_page;
 int perf_read_tsc_conversion(const struct perf_event_mmap_page *pc,
                              struct perf_tsc_conversion *tc);
 
-u64 perf_time_to_tsc(u64 ns, struct perf_tsc_conversion *tc);
-u64 tsc_to_perf_time(u64 cyc, struct perf_tsc_conversion *tc);
-
 #endif /* TOOLS_PERF_ARCH_X86_UTIL_TSC_H__ */
diff --git a/tools/perf/arch/x86/util/unwind-libunwind.c b/tools/perf/arch/x86/util/unwind-libunwind.c
index 3261f68c6a7c..db25e93d989c 100644
--- a/tools/perf/arch/x86/util/unwind-libunwind.c
+++ b/tools/perf/arch/x86/util/unwind-libunwind.c
@@ -3,6 +3,7 @@
 #include <libunwind.h>
 #include "perf_regs.h"
 #include "../../util/unwind.h"
+#include "../../util/debug.h"
 
 #ifdef HAVE_ARCH_X86_64_SUPPORT
 int libunwind__arch_reg_id(int regnum)
diff --git a/tools/perf/bench/bench.h b/tools/perf/bench/bench.h
index eba46709b279..3c4dd44d45cb 100644
--- a/tools/perf/bench/bench.h
+++ b/tools/perf/bench/bench.h
@@ -43,5 +43,6 @@ extern int bench_futex_requeue(int argc, const char **argv, const char *prefix);
 #define BENCH_FORMAT_UNKNOWN            -1
 
 extern int bench_format;
+extern unsigned int bench_repeat;
 
 #endif
diff --git a/tools/perf/bench/futex-requeue.c b/tools/perf/bench/futex-requeue.c
index a16255876f1d..732403bfd31a 100644
--- a/tools/perf/bench/futex-requeue.c
+++ b/tools/perf/bench/futex-requeue.c
@@ -29,13 +29,6 @@ static u_int32_t futex1 = 0, futex2 = 0;
  */
 static unsigned int nrequeue = 1;
 
-/*
- * There can be significant variance from run to run,
- * the more repeats, the more exact the overall avg and
- * the better idea of the futex latency.
- */
-static unsigned int repeat = 10;
-
 static pthread_t *worker;
 static bool done = 0, silent = 0;
 static pthread_mutex_t thread_lock;
@@ -46,7 +39,6 @@ static unsigned int ncpus, threads_starting, nthreads = 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_UINTEGER('r', "repeat",   &repeat,   "Specify amount of times to repeat the run"),
         OPT_BOOLEAN( 's', "silent",   &silent,   "Silent mode: do not display data/details"),
         OPT_END()
 };
@@ -146,7 +138,7 @@ int bench_futex_requeue(int argc, const char **argv,
         pthread_cond_init(&thread_parent, NULL);
         pthread_cond_init(&thread_worker, NULL);
 
-        for (j = 0; j < repeat && !done; j++) {
+        for (j = 0; j < bench_repeat && !done; j++) {
                 unsigned int nrequeued = 0;
                 struct timeval start, end, runtime;
 
diff --git a/tools/perf/bench/futex-wake.c b/tools/perf/bench/futex-wake.c
index d096169b161e..50022cbce87e 100644
--- a/tools/perf/bench/futex-wake.c
+++ b/tools/perf/bench/futex-wake.c
@@ -30,15 +30,8 @@ static u_int32_t futex1 = 0;
  */
 static unsigned int nwakes = 1;
 
-/*
- * There can be significant variance from run to run,
- * the more repeats, the more exact the overall avg and
- * the better idea of the futex latency.
- */
-static unsigned int repeat = 10;
-
 pthread_t *worker;
-static bool done = 0, silent = 0;
+static bool done = false, silent = false;
 static pthread_mutex_t thread_lock;
 static pthread_cond_t thread_parent, thread_worker;
 static struct stats waketime_stats, wakeup_stats;
@@ -47,7 +40,6 @@ static unsigned int ncpus, threads_starting, nthreads = 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_UINTEGER('r', "repeat",  &repeat,   "Specify amount of times to repeat the run"),
         OPT_BOOLEAN( 's', "silent",  &silent,   "Silent mode: do not display data/details"),
         OPT_END()
 };
@@ -149,7 +141,7 @@ int bench_futex_wake(int argc, const char **argv,
         pthread_cond_init(&thread_parent, NULL);
         pthread_cond_init(&thread_worker, NULL);
 
-        for (j = 0; j < repeat && !done; j++) {
+        for (j = 0; j < bench_repeat && !done; j++) {
                 unsigned int nwoken = 0;
                 struct timeval start, end, runtime;
 
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 5ce71d3b72cf..2465141b554b 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -10,6 +10,7 @@
 #include "../util/util.h"
 #include "../util/parse-options.h"
 #include "../util/header.h"
+#include "../util/cloexec.h"
 #include "bench.h"
 #include "mem-memcpy-arch.h"
 
@@ -83,7 +84,8 @@ static struct perf_event_attr cycle_attr = {
 
 static void init_cycle(void)
 {
-        cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, 0);
+        cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1,
+                                       perf_event_open_cloexec_flag());
 
         if (cycle_fd < 0 && errno == ENOSYS)
                 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
@@ -189,6 +191,11 @@ int bench_mem_memcpy(int argc, const char **argv,
         argc = parse_options(argc, argv, options,
                              bench_mem_memcpy_usage, 0);
 
+        if (no_prefault && only_prefault) {
+                fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
+                return 1;
+        }
+
         if (use_cycle)
                 init_cycle();
 
diff --git a/tools/perf/bench/mem-memset.c b/tools/perf/bench/mem-memset.c
index 9af79d2b18e5..75fc3e65fb2a 100644
--- a/tools/perf/bench/mem-memset.c
+++ b/tools/perf/bench/mem-memset.c
@@ -10,6 +10,7 @@
 #include "../util/util.h"
 #include "../util/parse-options.h"
 #include "../util/header.h"
+#include "../util/cloexec.h"
 #include "bench.h"
 #include "mem-memset-arch.h"
 
@@ -83,7 +84,8 @@ static struct perf_event_attr cycle_attr = {
 
 static void init_cycle(void)
 {
-        cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, 0);
+        cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1,
+                                       perf_event_open_cloexec_flag());
 
         if (cycle_fd < 0 && errno == ENOSYS)
                 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
@@ -181,6 +183,11 @@ int bench_mem_memset(int argc, const char **argv,
         argc = parse_options(argc, argv, options,
                              bench_mem_memset_usage, 0);
 
+        if (no_prefault && only_prefault) {
+                fprintf(stderr, "Invalid options: -o and -n are mutually exclusive\n");
+                return 1;
+        }
+
         if (use_cycle)
                 init_cycle();
 
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index cc1190a0849b..52a56599a543 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -28,6 +28,7 @@
 #include <sys/time.h>
 #include <sys/poll.h>
 #include <limits.h>
+#include <err.h>
 
 #define DATASIZE 100
 
@@ -50,12 +51,6 @@ struct receiver_context {
         int wakefd;
 };
 
-static void barf(const char *msg)
-{
-        fprintf(stderr, "%s (error: %s)\n", msg, strerror(errno));
-        exit(1);
-}
-
 static void fdpair(int fds[2])
 {
         if (use_pipes) {
@@ -66,7 +61,7 @@ static void fdpair(int fds[2])
                         return;
         }
 
-        barf(use_pipes ? "pipe()" : "socketpair()");
+        err(EXIT_FAILURE, use_pipes ? "pipe()" : "socketpair()");
 }
 
 /* Block until we're ready to go */
@@ -77,11 +72,11 @@ static void ready(int ready_out, int wakefd)
 
         /* Tell them we're ready. */
         if (write(ready_out, &dummy, 1) != 1)
-                barf("CLIENT: ready write");
+                err(EXIT_FAILURE, "CLIENT: ready write");
 
         /* Wait for "GO" signal */
         if (poll(&pollfd, 1, -1) != 1)
-                barf("poll");
+                err(EXIT_FAILURE, "poll");
 }
 
 /* Sender sprays loops messages down each file descriptor */
@@ -101,7 +96,7 @@ again:
                         ret = write(ctx->out_fds[j], data + done,
                                     sizeof(data)-done);
                         if (ret < 0)
-                                barf("SENDER: write");
+                                err(EXIT_FAILURE, "SENDER: write");
                         done += ret;
                         if (done < DATASIZE)
                                 goto again;
@@ -131,7 +126,7 @@ static void *receiver(struct receiver_context* ctx)
 again:
                 ret = read(ctx->in_fds[0], data + done, DATASIZE - done);
                 if (ret < 0)
-                        barf("SERVER: read");
+                        err(EXIT_FAILURE, "SERVER: read");
                 done += ret;
                 if (done < DATASIZE)
                         goto again;
@@ -144,14 +139,14 @@ static pthread_t create_worker(void *ctx, void *(*func)(void *))
 {
         pthread_attr_t attr;
         pthread_t childid;
-        int err;
+        int ret;
 
         if (!thread_mode) {
                 /* process mode */
                 /* Fork the receiver. */
                 switch (fork()) {
                 case -1:
-                        barf("fork()");
+                        err(EXIT_FAILURE, "fork()");
                         break;
                 case 0:
                         (*func) (ctx);
@@ -165,19 +160,17 @@ static pthread_t create_worker(void *ctx, void *(*func)(void *))
         }
 
         if (pthread_attr_init(&attr) != 0)
-                barf("pthread_attr_init:");
+                err(EXIT_FAILURE, "pthread_attr_init:");
 
 #ifndef __ia64__
         if (pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN) != 0)
-                barf("pthread_attr_setstacksize");
+                err(EXIT_FAILURE, "pthread_attr_setstacksize");
 #endif
 
-        err = pthread_create(&childid, &attr, func, ctx);
-        if (err != 0) {
-                fprintf(stderr, "pthread_create failed: %s (%d)\n",
-                        strerror(err), err);
-                exit(-1);
-        }
+        ret = pthread_create(&childid, &attr, func, ctx);
+        if (ret != 0)
+                err(EXIT_FAILURE, "pthread_create failed");
+
         return childid;
 }
 
@@ -207,14 +200,14 @@ static unsigned int group(pthread_t *pth,
                         + num_fds * sizeof(int));
 
         if (!snd_ctx)
-                barf("malloc()");
+                err(EXIT_FAILURE, "malloc()");
 
         for (i = 0; i < num_fds; i++) {
                 int fds[2];
                 struct receiver_context *ctx = malloc(sizeof(*ctx));
 
                 if (!ctx)
-                        barf("malloc()");
+                        err(EXIT_FAILURE, "malloc()");
 
 
                 /* Create the pipe between client and server */
@@ -281,7 +274,7 @@ int bench_sched_messaging(int argc, const char **argv,
 
         pth_tab = malloc(num_fds * 2 * num_groups * sizeof(pthread_t));
         if (!pth_tab)
-                barf("main:malloc()");
+                err(EXIT_FAILURE, "main:malloc()");
 
         fdpair(readyfds);
         fdpair(wakefds);
@@ -294,13 +287,13 @@ int bench_sched_messaging(int argc, const char **argv,
         /* Wait for everyone to be ready */
         for (i = 0; i < total_children; i++)
                 if (read(readyfds[0], &dummy, 1) != 1)
-                        barf("Reading for readyfds");
+                        err(EXIT_FAILURE, "Reading for readyfds");
 
         gettimeofday(&start, NULL);
 
         /* Kick them off */
         if (write(wakefds[1], &dummy, 1) != 1)
-                barf("Writing to start them");
+                err(EXIT_FAILURE, "Writing to start them");
 
         /* Reap them all */
         for (i = 0; i < total_children; i++)
@@ -332,5 +325,7 @@ int bench_sched_messaging(int argc, const char **argv,
                 break;
         }
 
+        free(pth_tab);
+
         return 0;
 }
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index 1e6e77710545..b9a56fa83330 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -104,9 +104,11 @@ static const char *bench_format_str;
 
 /* Output/formatting style, exported to benchmark modules: */
 int bench_format = BENCH_FORMAT_DEFAULT;
+unsigned int bench_repeat = 10; /* default number of times to repeat the run */
 
 static const struct option bench_options[] = {
         OPT_STRING('f', "format", &bench_format_str, "default", "Specify format style"),
+        OPT_UINTEGER('r', "repeat",  &bench_repeat,   "Specify amount of times to repeat the run"),
         OPT_END()
 };
 
@@ -226,6 +228,11 @@ int cmd_bench(int argc, const char **argv, const char *prefix __maybe_unused)
                 goto end;
         }
 
+        if (bench_repeat == 0) {
+                printf("Invalid repeat option: Must specify a positive value\n");
+                goto end;
+        }
+
         if (argc < 1) {
                 print_usage();
                 goto end;
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index b22dbb16f877..2a2c78f80876 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -125,7 +125,8 @@ static int build_id_cache__kcore_existing(const char *from_dir, char *to_dir,
         return ret;
 }
 
-static int build_id_cache__add_kcore(const char *filename, const char *debugdir)
+static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
+                                     bool force)
 {
         char dir[32], sbuildid[BUILD_ID_SIZE * 2 + 1];
         char from_dir[PATH_MAX], to_dir[PATH_MAX];
@@ -144,7 +145,8 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir)
         scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s",
                   debugdir, sbuildid);
 
-        if (!build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
+        if (!force &&
+            !build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
                 pr_debug("same kcore found in %s\n", to_dir);
                 return 0;
         }
@@ -389,7 +391,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         }
 
         if (kcore_filename &&
-            build_id_cache__add_kcore(kcore_filename, debugdir))
+            build_id_cache__add_kcore(kcore_filename, debugdir, force))
                 pr_warning("Couldn't add %s\n", kcore_filename);
 
         return ret;
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index c99e0de7e54a..66e12f55c052 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -15,6 +15,7 @@
 #include "util/parse-options.h"
 #include "util/session.h"
 #include "util/data.h"
+#include "util/debug.h"
 
 static int __cmd_evlist(const char *file_name, struct perf_attr_details *details)
 {
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 178b88ae3d2f..0384d930480b 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -11,6 +11,7 @@
 #include "util/parse-options.h"
 #include "util/run-command.h"
 #include "util/help.h"
+#include "util/debug.h"
 
 static struct man_viewer_list {
         struct man_viewer_list *next;
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 16c7c11ad06e..9a02807387d6 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -389,6 +389,9 @@ static int __cmd_inject(struct perf_inject *inject)
         ret = perf_session__process_events(session, &inject->tool);
 
         if (!file_out->is_pipe) {
+                if (inject->build_ids)
+                        perf_header__set_feat(&session->header,
+                                              HEADER_BUILD_ID);
                 session->header.data_size = inject->bytes_written;
                 perf_session__write_header(session, session->evlist, file_out->fd, true);
         }
@@ -436,6 +439,8 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                             "where and how long tasks slept"),
                 OPT_INCR('v', "verbose", &verbose,
                          "be more verbose (show build ids, etc)"),
+                OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
+                           "kallsyms pathname"),
                 OPT_END()
         };
         const char * const inject_usage[] = {
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 0f1e5a2f6ad7..43367eb00510 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -29,114 +29,25 @@
 #include <pthread.h>
 #include <math.h>
 
-#if defined(__i386__) || defined(__x86_64__)
-#include <asm/svm.h>
-#include <asm/vmx.h>
-#include <asm/kvm.h>
-
-struct event_key {
-        #define INVALID_KEY     (~0ULL)
-        u64 key;
-        int info;
-};
-
-struct kvm_event_stats {
-        u64 time;
-        struct stats stats;
-};
-
-struct kvm_event {
-        struct list_head hash_entry;
-        struct rb_node rb;
-
-        struct event_key key;
-
-        struct kvm_event_stats total;
-
-        #define DEFAULT_VCPU_NUM 8
-        int max_vcpu;
-        struct kvm_event_stats *vcpu;
-};
-
-typedef int (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int);
-
-struct kvm_event_key {
-        const char *name;
-        key_cmp_fun key;
-};
-
-
-struct perf_kvm_stat;
-
-struct kvm_events_ops {
-        bool (*is_begin_event)(struct perf_evsel *evsel,
-                               struct perf_sample *sample,
-                               struct event_key *key);
-        bool (*is_end_event)(struct perf_evsel *evsel,
-                             struct perf_sample *sample, struct event_key *key);
-        void (*decode_key)(struct perf_kvm_stat *kvm, struct event_key *key,
-                           char decode[20]);
-        const char *name;
-};
-
-struct exit_reasons_table {
-        unsigned long exit_code;
-        const char *reason;
-};
+#ifdef HAVE_KVM_STAT_SUPPORT
+#include <asm/kvm_perf.h>
+#include "util/kvm-stat.h"
 
-#define EVENTS_BITS             12
-#define EVENTS_CACHE_SIZE       (1UL << EVENTS_BITS)
-
-struct perf_kvm_stat {
-        struct perf_tool    tool;
-        struct record_opts  opts;
-        struct perf_evlist  *evlist;
-        struct perf_session *session;
-
-        const char *file_name;
-        const char *report_event;
-        const char *sort_key;
-        int trace_vcpu;
-
-        struct exit_reasons_table *exit_reasons;
-        int exit_reasons_size;
-        const char *exit_reasons_isa;
-
-        struct kvm_events_ops *events_ops;
-        key_cmp_fun compare;
-        struct list_head kvm_events_cache[EVENTS_CACHE_SIZE];
-
-        u64 total_time;
-        u64 total_count;
-        u64 lost_events;
-        u64 duration;
-
-        const char *pid_str;
-        struct intlist *pid_list;
-
-        struct rb_root result;
-
-        int timerfd;
-        unsigned int display_time;
-        bool live;
-};
-
-
-static void exit_event_get_key(struct perf_evsel *evsel,
-                               struct perf_sample *sample,
-                               struct event_key *key)
+void exit_event_get_key(struct perf_evsel *evsel,
+                        struct perf_sample *sample,
+                        struct event_key *key)
 {
         key->info = 0;
-        key->key = perf_evsel__intval(evsel, sample, "exit_reason");
+        key->key = perf_evsel__intval(evsel, sample, KVM_EXIT_REASON);
 }
 
-static bool kvm_exit_event(struct perf_evsel *evsel)
+bool kvm_exit_event(struct perf_evsel *evsel)
 {
-        return !strcmp(evsel->name, "kvm:kvm_exit");
+        return !strcmp(evsel->name, KVM_EXIT_TRACE);
 }
 
-static bool exit_event_begin(struct perf_evsel *evsel,
-                             struct perf_sample *sample, struct event_key *key)
+bool exit_event_begin(struct perf_evsel *evsel,
+                      struct perf_sample *sample, struct event_key *key)
 {
         if (kvm_exit_event(evsel)) {
                 exit_event_get_key(evsel, sample, key);
@@ -146,32 +57,23 @@ static bool exit_event_begin(struct perf_evsel *evsel,
         return false;
 }
 
-static bool kvm_entry_event(struct perf_evsel *evsel)
+bool kvm_entry_event(struct perf_evsel *evsel)
 {
-        return !strcmp(evsel->name, "kvm:kvm_entry");
+        return !strcmp(evsel->name, KVM_ENTRY_TRACE);
 }
 
-static bool exit_event_end(struct perf_evsel *evsel,
-                           struct perf_sample *sample __maybe_unused,
-                           struct event_key *key __maybe_unused)
+bool exit_event_end(struct perf_evsel *evsel,
+                    struct perf_sample *sample __maybe_unused,
+                    struct event_key *key __maybe_unused)
 {
         return kvm_entry_event(evsel);
 }
 
-static struct exit_reasons_table vmx_exit_reasons[] = {
-        VMX_EXIT_REASONS
-};
-
-static struct exit_reasons_table svm_exit_reasons[] = {
-        SVM_EXIT_REASONS
-};
-
-static const char *get_exit_reason(struct perf_kvm_stat *kvm, u64 exit_code)
+static const char *get_exit_reason(struct perf_kvm_stat *kvm,
+                                   struct exit_reasons_table *tbl,
+                                   u64 exit_code)
 {
-        int i = kvm->exit_reasons_size;
-        struct exit_reasons_table *tbl = kvm->exit_reasons;
-
-        while (i--) {
+        while (tbl->reason != NULL) {
                 if (tbl->exit_code == exit_code)
                         return tbl->reason;
                 tbl++;
@@ -182,148 +84,30 @@ static const char *get_exit_reason(struct perf_kvm_stat *kvm, u64 exit_code)
         return "UNKNOWN";
 }
 
-static void exit_event_decode_key(struct perf_kvm_stat *kvm,
-                                  struct event_key *key,
-                                  char decode[20])
+void exit_event_decode_key(struct perf_kvm_stat *kvm,
+                           struct event_key *key,
+                           char *decode)
 {
-        const char *exit_reason = get_exit_reason(kvm, key->key);
+        const char *exit_reason = get_exit_reason(kvm, key->exit_reasons,
+                                                  key->key);
 
-        scnprintf(decode, 20, "%s", exit_reason);
+        scnprintf(decode, DECODE_STR_LEN, "%s", exit_reason);
 }
 
-static struct kvm_events_ops exit_events = {
-        .is_begin_event = exit_event_begin,
-        .is_end_event = exit_event_end,
-        .decode_key = exit_event_decode_key,
-        .name = "VM-EXIT"
-};
-
-/*
- * For the mmio events, we treat:
- * the time of MMIO write: kvm_mmio(KVM_TRACE_MMIO_WRITE...) -> kvm_entry
- * the time of MMIO read: kvm_exit -> kvm_mmio(KVM_TRACE_MMIO_READ...).
- */
-static void mmio_event_get_key(struct perf_evsel *evsel, struct perf_sample *sample,
-                               struct event_key *key)
-{
-        key->key  = perf_evsel__intval(evsel, sample, "gpa");
-        key->info = perf_evsel__intval(evsel, sample, "type");
-}
-
-#define KVM_TRACE_MMIO_READ_UNSATISFIED 0
-#define KVM_TRACE_MMIO_READ 1
-#define KVM_TRACE_MMIO_WRITE 2
-
-static bool mmio_event_begin(struct perf_evsel *evsel,
-                             struct perf_sample *sample, struct event_key *key)
-{
-        /* MMIO read begin event in kernel. */
-        if (kvm_exit_event(evsel))
-                return true;
-
-        /* MMIO write begin event in kernel. */
-        if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
-            perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_WRITE) {
-                mmio_event_get_key(evsel, sample, key);
-                return true;
-        }
-
-        return false;
-}
-
-static bool mmio_event_end(struct perf_evsel *evsel, struct perf_sample *sample,
-                           struct event_key *key)
-{
-        /* MMIO write end event in kernel. */
-        if (kvm_entry_event(evsel))
-                return true;
-
-        /* MMIO read end event in kernel.*/
-        if (!strcmp(evsel->name, "kvm:kvm_mmio") &&
-            perf_evsel__intval(evsel, sample, "type") == KVM_TRACE_MMIO_READ) {
-                mmio_event_get_key(evsel, sample, key);
-                return true;
-        }
-
-        return false;
-}
-
-static void mmio_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
-                                  struct event_key *key,
-                                  char decode[20])
-{
-        scnprintf(decode, 20, "%#lx:%s", (unsigned long)key->key,
-                                key->info == KVM_TRACE_MMIO_WRITE ? "W" : "R");
-}
-
-static struct kvm_events_ops mmio_events = {
-        .is_begin_event = mmio_event_begin,
-        .is_end_event = mmio_event_end,
-        .decode_key = mmio_event_decode_key,
-        .name = "MMIO Access"
-};
-
- /* The time of emulation pio access is from kvm_pio to kvm_entry. */
-static void ioport_event_get_key(struct perf_evsel *evsel,
-                                 struct perf_sample *sample,
-                                 struct event_key *key)
+static bool register_kvm_events_ops(struct perf_kvm_stat *kvm)
 {
-        key->key  = perf_evsel__intval(evsel, sample, "port");
-        key->info = perf_evsel__intval(evsel, sample, "rw");
-}
+        struct kvm_reg_events_ops *events_ops = kvm_reg_events_ops;
 
-static bool ioport_event_begin(struct perf_evsel *evsel,
-                               struct perf_sample *sample,
-                               struct event_key *key)
-{
-        if (!strcmp(evsel->name, "kvm:kvm_pio")) {
-                ioport_event_get_key(evsel, sample, key);
-                return true;
+        for (events_ops = kvm_reg_events_ops; events_ops->name; events_ops++) {
+                if (!strcmp(events_ops->name, kvm->report_event)) {
+                        kvm->events_ops = events_ops->ops;
+                        return true;
+                }
         }
 
         return false;
 }
 
-static bool ioport_event_end(struct perf_evsel *evsel,
-                             struct perf_sample *sample __maybe_unused,
-                             struct event_key *key __maybe_unused)
-{
-        return kvm_entry_event(evsel);
-}
-
-static void ioport_event_decode_key(struct perf_kvm_stat *kvm __maybe_unused,
-                                    struct event_key *key,
-                                    char decode[20])
-{
-        scnprintf(decode, 20, "%#llx:%s", (unsigned long long)key->key,
-                                key->info ? "POUT" : "PIN");
-}
-
-static struct kvm_events_ops ioport_events = {
-        .is_begin_event = ioport_event_begin,
-        .is_end_event = ioport_event_end,
-        .decode_key = ioport_event_decode_key,
-        .name = "IO Port Access"
-};
-
-static bool register_kvm_events_ops(struct perf_kvm_stat *kvm)
-{
-        bool ret = true;
-
-        if (!strcmp(kvm->report_event, "vmexit"))
-                kvm->events_ops = &exit_events;
-        else if (!strcmp(kvm->report_event, "mmio"))
-                kvm->events_ops = &mmio_events;
-        else if (!strcmp(kvm->report_event, "ioport"))
-                kvm->events_ops = &ioport_events;
-        else {
-                pr_err("Unknown report event:%s\n", kvm->report_event);
-                ret = false;
-        }
-
-        return ret;
-}
-
 struct vcpu_event_record {
         int vcpu_id;
         u64 start_time;
@@ -477,6 +261,54 @@ static bool update_kvm_event(struct kvm_event *event, int vcpu_id,
         return true;
 }
 
+static bool is_child_event(struct perf_kvm_stat *kvm,
+                           struct perf_evsel *evsel,
+                           struct perf_sample *sample,
+                           struct event_key *key)
+{
+        struct child_event_ops *child_ops;
+
+        child_ops = kvm->events_ops->child_ops;
+
+        if (!child_ops)
+                return false;
+
+        for (; child_ops->name; child_ops++) {
+                if (!strcmp(evsel->name, child_ops->name)) {
+                        child_ops->get_key(evsel, sample, key);
+                        return true;
+                }
+        }
+
+        return false;
+}
+
+static bool handle_child_event(struct perf_kvm_stat *kvm,
+                               struct vcpu_event_record *vcpu_record,
+                               struct event_key *key,
+                               struct perf_sample *sample __maybe_unused)
+{
+        struct kvm_event *event = NULL;
+
+        if (key->key != INVALID_KEY)
+                event = find_create_kvm_event(kvm, key);
+
+        vcpu_record->last_event = event;
+
+        return true;
+}
+
+static bool skip_event(const char *event)
+{
+        const char * const *skip_events;
+
+        for (skip_events = kvm_skip_events; *skip_events; skip_events++)
+                if (!strcmp(event, *skip_events))
+                        return true;
+
+        return false;
+}
+
 static bool handle_end_event(struct perf_kvm_stat *kvm,
                              struct vcpu_event_record *vcpu_record,
                              struct event_key *key,
@@ -525,10 +357,10 @@ static bool handle_end_event(struct perf_kvm_stat *kvm,
         time_diff = sample->time - time_begin;
 
         if (kvm->duration && time_diff > kvm->duration) {
-                char decode[32];
+                char decode[DECODE_STR_LEN];
 
                 kvm->events_ops->decode_key(kvm, &event->key, decode);
-                if (strcmp(decode, "HLT")) {
+                if (!skip_event(decode)) {
                         pr_info("%" PRIu64 " VM %d, vcpu %d: %s event took %" PRIu64 "usec\n",
                                  sample->time, sample->pid, vcpu_record->vcpu_id,
                                  decode, time_diff/1000);
@@ -553,7 +385,7 @@ struct vcpu_event_record *per_vcpu_record(struct thread *thread,
                         return NULL;
                 }
 
-                vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, "vcpu_id");
+                vcpu_record->vcpu_id = perf_evsel__intval(evsel, sample, VCPU_ID);
                 thread->priv = vcpu_record;
         }
 
@@ -566,7 +398,8 @@ static bool handle_kvm_event(struct perf_kvm_stat *kvm,
                              struct perf_sample *sample)
 {
         struct vcpu_event_record *vcpu_record;
-        struct event_key key = {.key = INVALID_KEY};
+        struct event_key key = { .key = INVALID_KEY,
+                                 .exit_reasons = kvm->exit_reasons };
 
         vcpu_record = per_vcpu_record(thread, evsel, sample);
         if (!vcpu_record)
@@ -580,6 +413,9 @@ static bool handle_kvm_event(struct perf_kvm_stat *kvm,
         if (kvm->events_ops->is_begin_event(evsel, sample, &key))
                 return handle_begin_event(kvm, vcpu_record, &key, sample->time);
 
+        if (is_child_event(kvm, evsel, sample, &key))
+                return handle_child_event(kvm, vcpu_record, &key, sample);
+
         if (kvm->events_ops->is_end_event(evsel, sample, &key))
                 return handle_end_event(kvm, vcpu_record, &key, sample);
 
@@ -740,7 +576,7 @@ static void show_timeofday(void)
 
 static void print_result(struct perf_kvm_stat *kvm)
 {
-        char decode[20];
+        char decode[DECODE_STR_LEN];
         struct kvm_event *event;
         int vcpu = kvm->trace_vcpu;
 
@@ -751,7 +587,7 @@ static void print_result(struct perf_kvm_stat *kvm)
 
         pr_info("\n\n");
         print_vcpu_info(kvm);
-        pr_info("%20s ", kvm->events_ops->name);
+        pr_info("%*s ", DECODE_STR_LEN, kvm->events_ops->name);
         pr_info("%10s ", "Samples");
         pr_info("%9s ", "Samples%");
 
@@ -770,7 +606,7 @@ static void print_result(struct perf_kvm_stat *kvm)
                 min = get_event_min(event, vcpu);
 
                 kvm->events_ops->decode_key(kvm, &event->key, decode);
-                pr_info("%20s ", decode);
+                pr_info("%*s ", DECODE_STR_LEN, decode);
                 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);
@@ -839,34 +675,28 @@ static int process_sample_event(struct perf_tool *tool,
 static int cpu_isa_config(struct perf_kvm_stat *kvm)
 {
         char buf[64], *cpuid;
-        int err, isa;
+        int err;
 
         if (kvm->live) {
                 err = get_cpuid(buf, sizeof(buf));
                 if (err != 0) {
-                        pr_err("Failed to look up CPU type (Intel or AMD)\n");
+                        pr_err("Failed to look up CPU type\n");
                         return err;
                 }
                 cpuid = buf;
         } else
                 cpuid = kvm->session->header.env.cpuid;
 
-        if (strstr(cpuid, "Intel"))
-                isa = 1;
-        else if (strstr(cpuid, "AMD"))
-                isa = 0;
-        else {
-                pr_err("CPU %s is not supported.\n", cpuid);
-                return -ENOTSUP;
+        if (!cpuid) {
+                pr_err("Failed to look up CPU type\n");
+                return -EINVAL;
         }
 
-        if (isa == 1) {
-                kvm->exit_reasons = vmx_exit_reasons;
-                kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons);
-                kvm->exit_reasons_isa = "VMX";
-        }
+        err = cpu_isa_init(kvm, cpuid);
+        if (err == -ENOTSUP)
+                pr_err("CPU %s is not supported.\n", cpuid);
 
-        return 0;
+        return err;
 }
 
 static bool verify_vcpu(int vcpu)
@@ -1300,13 +1130,6 @@ exit:
         return ret;
 }
 
-static const char * const kvm_events_tp[] = {
-        "kvm:kvm_entry",
-        "kvm:kvm_exit",
-        "kvm:kvm_mmio",
-        "kvm:kvm_pio",
-};
-
 #define STRDUP_FAIL_EXIT(s)             \
         ({      char *_p;               \
         _p = strdup(s);         \
@@ -1318,7 +1141,7 @@ static const char * const kvm_events_tp[] = {
 static int
 kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
 {
-        unsigned int rec_argc, i, j;
+        unsigned int rec_argc, i, j, events_tp_size;
         const char **rec_argv;
         const char * const record_args[] = {
                 "record",
@@ -1326,9 +1149,14 @@ kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
                 "-m", "1024",
                 "-c", "1",
         };
+        const char * const *events_tp;
+        events_tp_size = 0;
+
+        for (events_tp = kvm_events_tp; *events_tp; events_tp++)
+                events_tp_size++;
 
         rec_argc = ARRAY_SIZE(record_args) + argc + 2 +
-                   2 * ARRAY_SIZE(kvm_events_tp);
+                   2 * events_tp_size;
         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 
         if (rec_argv == NULL)
@@ -1337,7 +1165,7 @@ kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
         for (i = 0; i < ARRAY_SIZE(record_args); i++)
                 rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]);
 
-        for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
+        for (j = 0; j < events_tp_size; j++) {
                 rec_argv[i++] = "-e";
                 rec_argv[i++] = STRDUP_FAIL_EXIT(kvm_events_tp[j]);
         }
@@ -1356,7 +1184,8 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
 {
         const struct option kvm_events_report_options[] = {
                 OPT_STRING(0, "event", &kvm->report_event, "report event",
-                            "event for reporting: vmexit, mmio, ioport"),
+                           "event for reporting: vmexit, "
+                           "mmio (x86 only), ioport (x86 only)"),
                 OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
                             "vcpu id to report"),
                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
@@ -1391,16 +1220,16 @@ static struct perf_evlist *kvm_live_event_list(void)
 {
         struct perf_evlist *evlist;
         char *tp, *name, *sys;
-        unsigned int j;
         int err = -1;
+        const char * const *events_tp;
 
         evlist = perf_evlist__new();
         if (evlist == NULL)
                 return NULL;
 
-        for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
+        for (events_tp = kvm_events_tp; *events_tp; events_tp++) {
 
-                tp = strdup(kvm_events_tp[j]);
+                tp = strdup(*events_tp);
                 if (tp == NULL)
                         goto out;
 
@@ -1409,7 +1238,7 @@ static struct perf_evlist *kvm_live_event_list(void)
                 name = strchr(tp, ':');
                 if (name == NULL) {
                         pr_err("Error parsing %s tracepoint: subsystem delimiter not found\n",
-                                kvm_events_tp[j]);
+                               *events_tp);
                         free(tp);
                         goto out;
                 }
@@ -1417,7 +1246,7 @@ static struct perf_evlist *kvm_live_event_list(void)
                 name++;
 
                 if (perf_evlist__add_newtp(evlist, sys, name, NULL)) {
-                        pr_err("Failed to add %s tracepoint to the list\n", kvm_events_tp[j]);
+                        pr_err("Failed to add %s tracepoint to the list\n", *events_tp);
                         free(tp);
                         goto out;
                 }
@@ -1462,7 +1291,9 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
                         "key for sorting: sample(sort by samples number)"
                         " time (sort by avg time)"),
                 OPT_U64(0, "duration", &kvm->duration,
-                    "show events other than HALT that take longer than duration usecs"),
+                        "show events other than"
+                        " HLT (x86 only) or Wait state (s390 only)"
+                        " that take longer than duration usecs"),
                 OPT_END()
         };
         const char * const live_usage[] = {
@@ -1585,9 +1416,6 @@ static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
                 .report_event   = "vmexit",
                 .sort_key       = "sample",
 
-                .exit_reasons = svm_exit_reasons,
-                .exit_reasons_size = ARRAY_SIZE(svm_exit_reasons),
-                .exit_reasons_isa = "SVM",
         };
 
         if (argc == 1) {
@@ -1609,7 +1437,7 @@ static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
 perf_stat:
         return cmd_stat(argc, argv, NULL);
 }
-#endif
+#endif /* HAVE_KVM_STAT_SUPPORT */
 
 static int __cmd_record(const char *file_name, int argc, const char **argv)
 {
@@ -1726,7 +1554,7 @@ int cmd_kvm(int argc, const char **argv, const char *prefix __maybe_unused)
                 return cmd_top(argc, argv, NULL);
         else if (!strncmp(argv[0], "buildid-list", 12))
                 return __cmd_buildid_list(file_name, argc, argv);
-#if defined(__i386__) || defined(__x86_64__)
+#ifdef HAVE_KVM_STAT_SUPPORT
         else if (!strncmp(argv[0], "stat", 4))
                 return kvm_cmd_stat(file_name, argc, argv);
 #endif
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 378b85b731a7..4869050e7194 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -238,6 +238,7 @@ static struct perf_event_header finished_round_event = {
 
 static int record__mmap_read_all(struct record *rec)
 {
+        u64 bytes_written = rec->bytes_written;
         int i;
         int rc = 0;
 
@@ -250,7 +251,11 @@ static int record__mmap_read_all(struct record *rec)
                 }
         }
 
-        if (perf_header__has_feat(&rec->session->header, HEADER_TRACING_DATA))
+        /*
+         * Mark the round finished in case we wrote
+         * at least one event.
+         */
+        if (bytes_written != rec->bytes_written)
                 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
 
 out:
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index c38d06c04775..f83c08c0dd87 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -10,6 +10,7 @@
 #include "util/header.h"
 #include "util/session.h"
 #include "util/tool.h"
+#include "util/cloexec.h"
 
 #include "util/parse-options.h"
 #include "util/trace-event.h"
@@ -434,7 +435,8 @@ static int self_open_counters(void)
         attr.type = PERF_TYPE_SOFTWARE;
         attr.config = PERF_COUNT_SW_TASK_CLOCK;
 
-        fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
+        fd = sys_perf_event_open(&attr, 0, -1, -1,
+                                 perf_event_open_cloexec_flag());
 
         if (fd < 0)
                 pr_err("Error: sys_perf_event_open() syscall returned "
@@ -935,8 +937,8 @@ static int latency_switch_event(struct perf_sched *sched,
                 return -1;
         }
 
-        sched_out = machine__findnew_thread(machine, 0, prev_pid);
-        sched_in = machine__findnew_thread(machine, 0, next_pid);
+        sched_out = machine__findnew_thread(machine, -1, prev_pid);
+        sched_in = machine__findnew_thread(machine, -1, next_pid);
 
         out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);
         if (!out_events) {
@@ -979,7 +981,7 @@ static int latency_runtime_event(struct perf_sched *sched,
 {
         const u32 pid      = perf_evsel__intval(evsel, sample, "pid");
         const u64 runtime  = perf_evsel__intval(evsel, sample, "runtime");
-        struct thread *thread = machine__findnew_thread(machine, 0, pid);
+        struct thread *thread = machine__findnew_thread(machine, -1, pid);
         struct work_atoms *atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);
         u64 timestamp = sample->time;
         int cpu = sample->cpu;
@@ -1012,7 +1014,7 @@ static int latency_wakeup_event(struct perf_sched *sched,
         struct thread *wakee;
         u64 timestamp = sample->time;
 
-        wakee = machine__findnew_thread(machine, 0, pid);
+        wakee = machine__findnew_thread(machine, -1, pid);
         atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);
         if (!atoms) {
                 if (thread_atoms_insert(sched, wakee))
@@ -1072,7 +1074,7 @@ static int latency_migrate_task_event(struct perf_sched *sched,
         if (sched->profile_cpu == -1)
                 return 0;
 
-        migrant = machine__findnew_thread(machine, 0, pid);
+        migrant = machine__findnew_thread(machine, -1, pid);
         atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);
         if (!atoms) {
                 if (thread_atoms_insert(sched, migrant))
@@ -1290,7 +1292,7 @@ static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
                 return -1;
         }
 
-        sched_in = machine__findnew_thread(machine, 0, next_pid);
+        sched_in = machine__findnew_thread(machine, -1, next_pid);
 
         sched->curr_thread[this_cpu] = sched_in;
 
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 9e9c91f5b7fa..f57035b89c15 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -358,27 +358,6 @@ static void print_sample_start(struct perf_sample *sample,
         }
 }
 
-static bool is_bts_event(struct perf_event_attr *attr)
-{
-        return ((attr->type == PERF_TYPE_HARDWARE) &&
-                (attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) &&
-                (attr->sample_period == 1));
-}
-
-static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
-{
-        if ((attr->type == PERF_TYPE_SOFTWARE) &&
-            ((attr->config == PERF_COUNT_SW_PAGE_FAULTS) ||
-             (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN) ||
-             (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
-                return true;
-
-        if (is_bts_event(attr))
-                return true;
-
-        return false;
-}
-
 static void print_sample_addr(union perf_event *event,
                           struct perf_sample *sample,
                           struct machine *machine,
@@ -386,24 +365,13 @@ static void print_sample_addr(union perf_event *event,
                           struct perf_event_attr *attr)
 {
         struct addr_location al;
-        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
         printf("%16" PRIx64, sample->addr);
 
         if (!sample_addr_correlates_sym(attr))
                 return;
 
-        thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
-                              sample->addr, &al);
-        if (!al.map)
-                thread__find_addr_map(thread, machine, cpumode, MAP__VARIABLE,
-                                      sample->addr, &al);
-
-        al.cpu = sample->cpu;
-        al.sym = NULL;
-
-        if (al.map)
-                al.sym = map__find_symbol(al.map, al.addr, NULL);
+        perf_event__preprocess_sample_addr(event, sample, machine, thread, &al);
 
         if (PRINT_FIELD(SYM)) {
                 printf(" ");
@@ -427,25 +395,35 @@ static void print_sample_bts(union perf_event *event,
                              struct addr_location *al)
 {
         struct perf_event_attr *attr = &evsel->attr;
+        bool print_srcline_last = false;
 
         /* print branch_from information */
         if (PRINT_FIELD(IP)) {
-                if (!symbol_conf.use_callchain)
-                        printf(" ");
-                else
+                unsigned int print_opts = output[attr->type].print_ip_opts;
+
+                if (symbol_conf.use_callchain && sample->callchain) {
                         printf("\n");
-                perf_evsel__print_ip(evsel, sample, al,
-                                     output[attr->type].print_ip_opts,
+                } else {
+                        printf(" ");
+                        if (print_opts & PRINT_IP_OPT_SRCLINE) {
+                                print_srcline_last = true;
+                                print_opts &= ~PRINT_IP_OPT_SRCLINE;
+                        }
+                }
+                perf_evsel__print_ip(evsel, sample, al, print_opts,
                                      PERF_MAX_STACK_DEPTH);
         }
 
-        printf(" => ");
-
         /* print branch_to information */
         if (PRINT_FIELD(ADDR) ||
             ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
-             !output[attr->type].user_set))
+             !output[attr->type].user_set)) {
+                printf(" => ");
                 print_sample_addr(event, sample, al->machine, thread, attr);
+        }
+
+        if (print_srcline_last)
+                map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);
 
         printf("\n");
 }
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 65a151e36067..3e80aa10cfd8 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -184,7 +184,7 @@ static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel)
 static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
 {
         evsel->priv = zalloc(sizeof(struct perf_stat));
-        if (evsel == NULL)
+        if (evsel->priv == NULL)
                 return -ENOMEM;
         perf_evsel__reset_stat_priv(evsel);
         return 0;
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index 74db2568b867..2f1a5220c090 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -37,6 +37,7 @@
 #include "util/svghelper.h"
 #include "util/tool.h"
 #include "util/data.h"
+#include "util/debug.h"
 
 #define SUPPORT_OLD_POWER_EVENTS 1
 #define PWR_EVENT_EXIT -1
@@ -60,10 +61,17 @@ struct timechart {
                                 tasks_only,
                                 with_backtrace,
                                 topology;
+        /* IO related settings */
+        u64                     io_events;
+        bool                    io_only,
+                                skip_eagain;
+        u64                     min_time,
+                                merge_dist;
 };
 
 struct per_pidcomm;
 struct cpu_sample;
+struct io_sample;
 
 /*
  * Datastructure layout:
@@ -84,6 +92,7 @@ struct per_pid {
         u64             start_time;
         u64             end_time;
         u64             total_time;
+        u64             total_bytes;
         int             display;
 
         struct per_pidcomm *all;
@@ -97,6 +106,8 @@ struct per_pidcomm {
         u64             start_time;
         u64             end_time;
         u64             total_time;
+        u64             max_bytes;
+        u64             total_bytes;
 
         int             Y;
         int             display;
@@ -107,6 +118,7 @@ struct per_pidcomm {
         char            *comm;
 
         struct cpu_sample *samples;
+        struct io_sample  *io_samples;
 };
 
 struct sample_wrapper {
@@ -131,6 +143,27 @@ struct cpu_sample {
         const char *backtrace;
 };
 
+enum {
+        IOTYPE_READ,
+        IOTYPE_WRITE,
+        IOTYPE_SYNC,
+        IOTYPE_TX,
+        IOTYPE_RX,
+        IOTYPE_POLL,
+};
+
+struct io_sample {
+        struct io_sample *next;
+
+        u64 start_time;
+        u64 end_time;
+        u64 bytes;
+        int type;
+        int fd;
+        int err;
+        int merges;
+};
+
 #define CSTATE 1
 #define PSTATE 2
 
@@ -213,7 +246,7 @@ static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
                 pid_set_comm(tchart, pid, pp->current->comm);
 
         p->start_time = timestamp;
-        if (p->current) {
+        if (p->current && !p->current->start_time) {
                 p->current->start_time = timestamp;
                 p->current->state_since = timestamp;
         }
@@ -682,6 +715,249 @@ static void end_sample_processing(struct timechart *tchart)
         }
 }
 
+static int pid_begin_io_sample(struct timechart *tchart, int pid, int type,
+                               u64 start, int fd)
+{
+        struct per_pid *p = find_create_pid(tchart, pid);
+        struct per_pidcomm *c = p->current;
+        struct io_sample *sample;
+        struct io_sample *prev;
+
+        if (!c) {
+                c = zalloc(sizeof(*c));
+                if (!c)
+                        return -ENOMEM;
+                p->current = c;
+                c->next = p->all;
+                p->all = c;
+        }
+
+        prev = c->io_samples;
+
+        if (prev && prev->start_time && !prev->end_time) {
+                pr_warning("Skip invalid start event: "
+                           "previous event already started!\n");
+
+                /* remove previous event that has been started,
+                 * we are not sure we will ever get an end for it */
+                c->io_samples = prev->next;
+                free(prev);
+                return 0;
+        }
+
+        sample = zalloc(sizeof(*sample));
+        if (!sample)
+                return -ENOMEM;
+        sample->start_time = start;
+        sample->type = type;
+        sample->fd = fd;
+        sample->next = c->io_samples;
+        c->io_samples = sample;
+
+        if (c->start_time == 0 || c->start_time > start)
+                c->start_time = start;
+
+        return 0;
+}
+
+static int pid_end_io_sample(struct timechart *tchart, int pid, int type,
+                             u64 end, long ret)
+{
+        struct per_pid *p = find_create_pid(tchart, pid);
+        struct per_pidcomm *c = p->current;
+        struct io_sample *sample, *prev;
+
+        if (!c) {
+                pr_warning("Invalid pidcomm!\n");
+                return -1;
+        }
+
+        sample = c->io_samples;
+
+        if (!sample) /* skip partially captured events */
+                return 0;
+
+        if (sample->end_time) {
+                pr_warning("Skip invalid end event: "
+                           "previous event already ended!\n");
+                return 0;
+        }
+
+        if (sample->type != type) {
+                pr_warning("Skip invalid end event: invalid event type!\n");
+                return 0;
+        }
+
+        sample->end_time = end;
+        prev = sample->next;
+
+        /* we want to be able to see small and fast transfers, so make them
+         * at least min_time long, but don't overlap them */
+        if (sample->end_time - sample->start_time < tchart->min_time)
+                sample->end_time = sample->start_time + tchart->min_time;
+        if (prev && sample->start_time < prev->end_time) {
+                if (prev->err) /* try to make errors more visible */
+                        sample->start_time = prev->end_time;
+                else
+                        prev->end_time = sample->start_time;
+        }
+
+        if (ret < 0) {
+                sample->err = ret;
+        } else if (type == IOTYPE_READ || type == IOTYPE_WRITE ||
+                   type == IOTYPE_TX || type == IOTYPE_RX) {
+
+                if ((u64)ret > c->max_bytes)
+                        c->max_bytes = ret;
+
+                c->total_bytes += ret;
+                p->total_bytes += ret;
+                sample->bytes = ret;
+        }
+
+        /* merge two requests to make svg smaller and render-friendly */
+        if (prev &&
+            prev->type == sample->type &&
+            prev->err == sample->err &&
+            prev->fd == sample->fd &&
+            prev->end_time + tchart->merge_dist >= sample->start_time) {
+
+                sample->bytes += prev->bytes;
+                sample->merges += prev->merges + 1;
+
+                sample->start_time = prev->start_time;
+                sample->next = prev->next;
+                free(prev);
+
+                if (!sample->err && sample->bytes > c->max_bytes)
+                        c->max_bytes = sample->bytes;
+        }
+
+        tchart->io_events++;
+
+        return 0;
+}
+
+static int
+process_enter_read(struct timechart *tchart,
+                   struct perf_evsel *evsel,
+                   struct perf_sample *sample)
+{
+        long fd = perf_evsel__intval(evsel, sample, "fd");
+        return pid_begin_io_sample(tchart, sample->tid, IOTYPE_READ,
+                                   sample->time, fd);
+}
+
+static int
+process_exit_read(struct timechart *tchart,
+                  struct perf_evsel *evsel,
+                  struct perf_sample *sample)
+{
+        long ret = perf_evsel__intval(evsel, sample, "ret");
+        return pid_end_io_sample(tchart, sample->tid, IOTYPE_READ,
+                                 sample->time, ret);
+}
+
+static int
+process_enter_write(struct timechart *tchart,
+                    struct perf_evsel *evsel,
+                    struct perf_sample *sample)
+{
+        long fd = perf_evsel__intval(evsel, sample, "fd");
+        return pid_begin_io_sample(tchart, sample->tid, IOTYPE_WRITE,
+                                   sample->time, fd);
+}
+
+static int
+process_exit_write(struct timechart *tchart,
+                   struct perf_evsel *evsel,
+                   struct perf_sample *sample)
+{
+        long ret = perf_evsel__intval(evsel, sample, "ret");
+        return pid_end_io_sample(tchart, sample->tid, IOTYPE_WRITE,
+                                 sample->time, ret);
+}
+
+static int
+process_enter_sync(struct timechart *tchart,
+                   struct perf_evsel *evsel,
+                   struct perf_sample *sample)
+{
+        long fd = perf_evsel__intval(evsel, sample, "fd");
+        return pid_begin_io_sample(tchart, sample->tid, IOTYPE_SYNC,
+                                   sample->time, fd);
+}
+
+static int
+process_exit_sync(struct timechart *tchart,
+                  struct perf_evsel *evsel,
+                  struct perf_sample *sample)
+{
+        long ret = perf_evsel__intval(evsel, sample, "ret");
+        return pid_end_io_sample(tchart, sample->tid, IOTYPE_SYNC,
+                                 sample->time, ret);
+}
+
+static int
+process_enter_tx(struct timechart *tchart,
+                 struct perf_evsel *evsel,
+                 struct perf_sample *sample)
+{
+        long fd = perf_evsel__intval(evsel, sample, "fd");
+        return pid_begin_io_sample(tchart, sample->tid, IOTYPE_TX,
+                                   sample->time, fd);
+}
+
+static int
+process_exit_tx(struct timechart *tchart,
+                struct perf_evsel *evsel,
+                struct perf_sample *sample)
+{
+        long ret = perf_evsel__intval(evsel, sample, "ret");
+        return pid_end_io_sample(tchart, sample->tid, IOTYPE_TX,
+                                 sample->time, ret);
+}
+
+static int
+process_enter_rx(struct timechart *tchart,
+                 struct perf_evsel *evsel,
+                 struct perf_sample *sample)
+{
+        long fd = perf_evsel__intval(evsel, sample, "fd");
+        return pid_begin_io_sample(tchart, sample->tid, IOTYPE_RX,
+                                   sample->time, fd);
+}
+
+static int
+process_exit_rx(struct timechart *tchart,
+                struct perf_evsel *evsel,
+                struct perf_sample *sample)
+{
+        long ret = perf_evsel__intval(evsel, sample, "ret");
+        return pid_end_io_sample(tchart, sample->tid, IOTYPE_RX,
+                                 sample->time, ret);
+}
+
+static int
+process_enter_poll(struct timechart *tchart,
+                   struct perf_evsel *evsel,
+                   struct perf_sample *sample)
+{
+        long fd = perf_evsel__intval(evsel, sample, "fd");
+        return pid_begin_io_sample(tchart, sample->tid, IOTYPE_POLL,
+                                   sample->time, fd);
+}
+
+static int
+process_exit_poll(struct timechart *tchart,
+                  struct perf_evsel *evsel,
+                  struct perf_sample *sample)
+{
+        long ret = perf_evsel__intval(evsel, sample, "ret");
+        return pid_end_io_sample(tchart, sample->tid, IOTYPE_POLL,
+                                 sample->time, ret);
+}
+
 /*
  * Sort the pid datastructure
  */
@@ -852,6 +1128,121 @@ static void draw_cpu_usage(struct timechart *tchart)
         }
 }
 
+static void draw_io_bars(struct timechart *tchart)
+{
+        const char *suf;
+        double bytes;
+        char comm[256];
+        struct per_pid *p;
+        struct per_pidcomm *c;
+        struct io_sample *sample;
+        int Y = 1;
+
+        p = tchart->all_data;
+        while (p) {
+                c = p->all;
+                while (c) {
+                        if (!c->display) {
+                                c->Y = 0;
+                                c = c->next;
+                                continue;
+                        }
+
+                        svg_box(Y, c->start_time, c->end_time, "process3");
+                        sample = c->io_samples;
+                        for (sample = c->io_samples; sample; sample = sample->next) {
+                                double h = (double)sample->bytes / c->max_bytes;
+
+                                if (tchart->skip_eagain &&
+                                    sample->err == -EAGAIN)
+                                        continue;
+
+                                if (sample->err)
+                                        h = 1;
+
+                                if (sample->type == IOTYPE_SYNC)
+                                        svg_fbox(Y,
+                                                sample->start_time,
+                                                sample->end_time,
+                                                1,
+                                                sample->err ? "error" : "sync",
+                                                sample->fd,
+                                                sample->err,
+                                                sample->merges);
+                                else if (sample->type == IOTYPE_POLL)
+                                        svg_fbox(Y,
+                                                sample->start_time,
+                                                sample->end_time,
+                                                1,
+                                                sample->err ? "error" : "poll",
+                                                sample->fd,
+                                                sample->err,
+                                                sample->merges);
+                                else if (sample->type == IOTYPE_READ)
+                                        svg_ubox(Y,
+                                                sample->start_time,
+                                                sample->end_time,
+                                                h,
+                                                sample->err ? "error" : "disk",
+                                                sample->fd,
+                                                sample->err,
+                                                sample->merges);
+                                else if (sample->type == IOTYPE_WRITE)
+                                        svg_lbox(Y,
+                                                sample->start_time,
+                                                sample->end_time,
+                                                h,
+                                                sample->err ? "error" : "disk",
+                                                sample->fd,
+                                                sample->err,
+                                                sample->merges);
+                                else if (sample->type == IOTYPE_RX)
+                                        svg_ubox(Y,
+                                                sample->start_time,
+                                                sample->end_time,
+                                                h,
+                                                sample->err ? "error" : "net",
+                                                sample->fd,
+                                                sample->err,
+                                                sample->merges);
+                                else if (sample->type == IOTYPE_TX)
+                                        svg_lbox(Y,
+                                                sample->start_time,
+                                                sample->end_time,
+                                                h,
+                                                sample->err ? "error" : "net",
+                                                sample->fd,
+                                                sample->err,
+                                                sample->merges);
+                        }
+
+                        suf = "";
+                        bytes = c->total_bytes;
+                        if (bytes > 1024) {
+                                bytes = bytes / 1024;
+                                suf = "K";
+                        }
+                        if (bytes > 1024) {
+                                bytes = bytes / 1024;
+                                suf = "M";
+                        }
+                        if (bytes > 1024) {
+                                bytes = bytes / 1024;
+                                suf = "G";
+                        }
+
+
+                        sprintf(comm, "%s:%i (%3.1f %sbytes)", c->comm ?: "", p->pid, bytes, suf);
+                        svg_text(Y, c->start_time, comm);
+
+                        c->Y = Y;
+                        Y++;
+                        c = c->next;
+                }
+                p = p->next;
+        }
+}
+
 static void draw_process_bars(struct timechart *tchart)
 {
         struct per_pid *p;
@@ -987,9 +1378,6 @@ static int determine_display_tasks(struct timechart *tchart, u64 threshold)
         struct per_pidcomm *c;
         int count = 0;
 
-        if (process_filter)
-                return determine_display_tasks_filtered(tchart);
-
         p = tchart->all_data;
         while (p) {
                 p->display = 0;
@@ -1025,15 +1413,46 @@ static int determine_display_tasks(struct timechart *tchart, u64 threshold)
         return count;
 }
 
+static int determine_display_io_tasks(struct timechart *timechart, u64 threshold)
+{
+        struct per_pid *p;
+        struct per_pidcomm *c;
+        int count = 0;
+
+        p = timechart->all_data;
+        while (p) {
+                /* no exit marker, task kept running to the end */
+                if (p->end_time == 0)
+                        p->end_time = timechart->last_time;
 
+                c = p->all;
 
+                while (c) {
+                        c->display = 0;
+
+                        if (c->total_bytes >= threshold) {
+                                c->display = 1;
+                                count++;
+                        }
+
+                        if (c->end_time == 0)
+                                c->end_time = timechart->last_time;
+
+                        c = c->next;
+                }
+                p = p->next;
+        }
+        return count;
+}
+
+#define BYTES_THRESH (1 * 1024 * 1024)
 #define TIME_THRESH 10000000
 
 static void write_svg_file(struct timechart *tchart, const char *filename)
 {
         u64 i;
         int count;
-        int thresh = TIME_THRESH;
+        int thresh = tchart->io_events ? BYTES_THRESH : TIME_THRESH;
 
         if (tchart->power_only)
                 tchart->proc_num = 0;
@@ -1041,28 +1460,43 @@ static void write_svg_file(struct timechart *tchart, const char *filename)
         /* We'd like to show at least proc_num tasks;
          * be less picky if we have fewer */
         do {
-                count = determine_display_tasks(tchart, thresh);
+                if (process_filter)
+                        count = determine_display_tasks_filtered(tchart);
+                else if (tchart->io_events)
+                        count = determine_display_io_tasks(tchart, thresh);
+                else
+                        count = determine_display_tasks(tchart, thresh);
                 thresh /= 10;
         } while (!process_filter && thresh && count < tchart->proc_num);
 
         if (!tchart->proc_num)
                 count = 0;
 
-        open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
+        if (tchart->io_events) {
+                open_svg(filename, 0, count, tchart->first_time, tchart->last_time);
 
-        svg_time_grid();
-        svg_legenda();
+                svg_time_grid(0.5);
+                svg_io_legenda();
+
+                draw_io_bars(tchart);
+        } else {
+                open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
 
-        for (i = 0; i < tchart->numcpus; i++)
-                svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
+                svg_time_grid(0);
 
-        draw_cpu_usage(tchart);
-        if (tchart->proc_num)
-                draw_process_bars(tchart);
-        if (!tchart->tasks_only)
-                draw_c_p_states(tchart);
-        if (tchart->proc_num)
-                draw_wakeups(tchart);
+                svg_legenda();
+
+                for (i = 0; i < tchart->numcpus; i++)
+                        svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
+
+                draw_cpu_usage(tchart);
+                if (tchart->proc_num)
+                        draw_process_bars(tchart);
+                if (!tchart->tasks_only)
+                        draw_c_p_states(tchart);
+                if (tchart->proc_num)
+                        draw_wakeups(tchart);
+        }
 
         svg_close();
 }
@@ -1110,6 +1544,56 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
                 { "power:power_end",            process_sample_power_end },
                 { "power:power_frequency",      process_sample_power_frequency },
 #endif
+
+                { "syscalls:sys_enter_read",            process_enter_read },
+                { "syscalls:sys_enter_pread64",         process_enter_read },
+                { "syscalls:sys_enter_readv",           process_enter_read },
+                { "syscalls:sys_enter_preadv",          process_enter_read },
+                { "syscalls:sys_enter_write",           process_enter_write },
+                { "syscalls:sys_enter_pwrite64",        process_enter_write },
+                { "syscalls:sys_enter_writev",          process_enter_write },
+                { "syscalls:sys_enter_pwritev",         process_enter_write },
+                { "syscalls:sys_enter_sync",            process_enter_sync },
+                { "syscalls:sys_enter_sync_file_range", process_enter_sync },
+                { "syscalls:sys_enter_fsync",           process_enter_sync },
+                { "syscalls:sys_enter_msync",           process_enter_sync },
+                { "syscalls:sys_enter_recvfrom",        process_enter_rx },
+                { "syscalls:sys_enter_recvmmsg",        process_enter_rx },
+                { "syscalls:sys_enter_recvmsg",         process_enter_rx },
+                { "syscalls:sys_enter_sendto",          process_enter_tx },
+                { "syscalls:sys_enter_sendmsg",         process_enter_tx },
+                { "syscalls:sys_enter_sendmmsg",        process_enter_tx },
+                { "syscalls:sys_enter_epoll_pwait",     process_enter_poll },
+                { "syscalls:sys_enter_epoll_wait",      process_enter_poll },
+                { "syscalls:sys_enter_poll",            process_enter_poll },
+                { "syscalls:sys_enter_ppoll",           process_enter_poll },
+                { "syscalls:sys_enter_pselect6",        process_enter_poll },
+                { "syscalls:sys_enter_select",          process_enter_poll },
+
+                { "syscalls:sys_exit_read",             process_exit_read },
+                { "syscalls:sys_exit_pread64",          process_exit_read },
+                { "syscalls:sys_exit_readv",            process_exit_read },
+                { "syscalls:sys_exit_preadv",           process_exit_read },
+                { "syscalls:sys_exit_write",            process_exit_write },
+                { "syscalls:sys_exit_pwrite64",         process_exit_write },
+                { "syscalls:sys_exit_writev",           process_exit_write },
+                { "syscalls:sys_exit_pwritev",          process_exit_write },
+                { "syscalls:sys_exit_sync",             process_exit_sync },
+                { "syscalls:sys_exit_sync_file_range",  process_exit_sync },
+                { "syscalls:sys_exit_fsync",            process_exit_sync },
+                { "syscalls:sys_exit_msync",            process_exit_sync },
+                { "syscalls:sys_exit_recvfrom",         process_exit_rx },
+                { "syscalls:sys_exit_recvmmsg",         process_exit_rx },
+                { "syscalls:sys_exit_recvmsg",          process_exit_rx },
+                { "syscalls:sys_exit_sendto",           process_exit_tx },
+                { "syscalls:sys_exit_sendmsg",          process_exit_tx },
+                { "syscalls:sys_exit_sendmmsg",         process_exit_tx },
+                { "syscalls:sys_exit_epoll_pwait",      process_exit_poll },
+                { "syscalls:sys_exit_epoll_wait",       process_exit_poll },
+                { "syscalls:sys_exit_poll",             process_exit_poll },
+                { "syscalls:sys_exit_ppoll",            process_exit_poll },
+                { "syscalls:sys_exit_pselect6",         process_exit_poll },
+                { "syscalls:sys_exit_select",           process_exit_poll },
         };
         struct perf_data_file file = {
                 .path = input_name,
@@ -1154,6 +1638,139 @@ out_delete:
         return ret;
 }
 
+static int timechart__io_record(int argc, const char **argv)
+{
+        unsigned int rec_argc, i;
+        const char **rec_argv;
+        const char **p;
+        char *filter = NULL;
+
+        const char * const common_args[] = {
+                "record", "-a", "-R", "-c", "1",
+        };
+        unsigned int common_args_nr = ARRAY_SIZE(common_args);
+
+        const char * const disk_events[] = {
+                "syscalls:sys_enter_read",
+                "syscalls:sys_enter_pread64",
+                "syscalls:sys_enter_readv",
+                "syscalls:sys_enter_preadv",
+                "syscalls:sys_enter_write",
+                "syscalls:sys_enter_pwrite64",
+                "syscalls:sys_enter_writev",
+                "syscalls:sys_enter_pwritev",
+                "syscalls:sys_enter_sync",
+                "syscalls:sys_enter_sync_file_range",
+                "syscalls:sys_enter_fsync",
+                "syscalls:sys_enter_msync",
+
+                "syscalls:sys_exit_read",
+                "syscalls:sys_exit_pread64",
+                "syscalls:sys_exit_readv",
+                "syscalls:sys_exit_preadv",
+                "syscalls:sys_exit_write",
+                "syscalls:sys_exit_pwrite64",
+                "syscalls:sys_exit_writev",
+                "syscalls:sys_exit_pwritev",
+                "syscalls:sys_exit_sync",
+                "syscalls:sys_exit_sync_file_range",
+                "syscalls:sys_exit_fsync",
+                "syscalls:sys_exit_msync",
+        };
+        unsigned int disk_events_nr = ARRAY_SIZE(disk_events);
+
+        const char * const net_events[] = {
+                "syscalls:sys_enter_recvfrom",
+                "syscalls:sys_enter_recvmmsg",
+                "syscalls:sys_enter_recvmsg",
+                "syscalls:sys_enter_sendto",
+                "syscalls:sys_enter_sendmsg",
+                "syscalls:sys_enter_sendmmsg",
+
+                "syscalls:sys_exit_recvfrom",
+                "syscalls:sys_exit_recvmmsg",
+                "syscalls:sys_exit_recvmsg",
+                "syscalls:sys_exit_sendto",
+                "syscalls:sys_exit_sendmsg",
+                "syscalls:sys_exit_sendmmsg",
+        };
+        unsigned int net_events_nr = ARRAY_SIZE(net_events);
+
+        const char * const poll_events[] = {
+                "syscalls:sys_enter_epoll_pwait",
+                "syscalls:sys_enter_epoll_wait",
+                "syscalls:sys_enter_poll",
+                "syscalls:sys_enter_ppoll",
+                "syscalls:sys_enter_pselect6",
+                "syscalls:sys_enter_select",
+
+                "syscalls:sys_exit_epoll_pwait",
+                "syscalls:sys_exit_epoll_wait",
+                "syscalls:sys_exit_poll",
+                "syscalls:sys_exit_ppoll",
+                "syscalls:sys_exit_pselect6",
+                "syscalls:sys_exit_select",
+        };
+        unsigned int poll_events_nr = ARRAY_SIZE(poll_events);
+
+        rec_argc = common_args_nr +
+                disk_events_nr * 4 +
+                net_events_nr * 4 +
+                poll_events_nr * 4 +
+                argc;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+
+        if (rec_argv == NULL)
+                return -ENOMEM;
+
+        if (asprintf(&filter, "common_pid != %d", getpid()) < 0)
+                return -ENOMEM;
+
+        p = rec_argv;
+        for (i = 0; i < common_args_nr; i++)
+                *p++ = strdup(common_args[i]);
+
+        for (i = 0; i < disk_events_nr; i++) {
+                if (!is_valid_tracepoint(disk_events[i])) {
+                        rec_argc -= 4;
+                        continue;
+                }
+
+                *p++ = "-e";
+                *p++ = strdup(disk_events[i]);
+                *p++ = "--filter";
+                *p++ = filter;
+        }
+        for (i = 0; i < net_events_nr; i++) {
+                if (!is_valid_tracepoint(net_events[i])) {
+                        rec_argc -= 4;
+                        continue;
+                }
+
+                *p++ = "-e";
+                *p++ = strdup(net_events[i]);
+                *p++ = "--filter";
+                *p++ = filter;
+        }
+        for (i = 0; i < poll_events_nr; i++) {
+                if (!is_valid_tracepoint(poll_events[i])) {
+                        rec_argc -= 4;
+                        continue;
+                }
+
+                *p++ = "-e";
+                *p++ = strdup(poll_events[i]);
+                *p++ = "--filter";
+                *p++ = filter;
+        }
+
+        for (i = 0; i < (unsigned int)argc; i++)
+                *p++ = argv[i];
+
+        return cmd_record(rec_argc, rec_argv, NULL);
+}
+
+
 static int timechart__record(struct timechart *tchart, int argc, const char **argv)
 {
         unsigned int rec_argc, i, j;
@@ -1270,6 +1887,30 @@ parse_highlight(const struct option *opt __maybe_unused, const char *arg,
         return 0;
 }
 
+static int
+parse_time(const struct option *opt, const char *arg, int __maybe_unused unset)
+{
+        char unit = 'n';
+        u64 *value = opt->value;
+
+        if (sscanf(arg, "%" PRIu64 "%cs", value, &unit) > 0) {
+                switch (unit) {
+                case 'm':
+                        *value *= 1000000;
+                        break;
+                case 'u':
+                        *value *= 1000;
+                        break;
+                case 'n':
+                        break;
+                default:
+                        return -1;
+                }
+        }
+
+        return 0;
+}
+
 int cmd_timechart(int argc, const char **argv,
                   const char *prefix __maybe_unused)
 {
@@ -1282,6 +1923,8 @@ int cmd_timechart(int argc, const char **argv,
                         .ordered_samples = true,
                 },
                 .proc_num = 15,
+                .min_time = 1000000,
+                .merge_dist = 1000,
         };
         const char *output_name = "output.svg";
         const struct option timechart_options[] = {
@@ -1303,6 +1946,14 @@ int cmd_timechart(int argc, const char **argv,
                     "min. number of tasks to print"),
         OPT_BOOLEAN('t', "topology", &tchart.topology,
                     "sort CPUs according to topology"),
+        OPT_BOOLEAN(0, "io-skip-eagain", &tchart.skip_eagain,
+                    "skip EAGAIN errors"),
+        OPT_CALLBACK(0, "io-min-time", &tchart.min_time, "time",
+                     "all IO faster than min-time will visually appear longer",
+                     parse_time),
+        OPT_CALLBACK(0, "io-merge-dist", &tchart.merge_dist, "time",
+                     "merge events that are merge-dist us apart",
+                     parse_time),
         OPT_END()
         };
         const char * const timechart_usage[] = {
@@ -1314,6 +1965,8 @@ int cmd_timechart(int argc, const char **argv,
         OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
         OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
                     "output processes data only"),
+        OPT_BOOLEAN('I', "io-only", &tchart.io_only,
+                    "record only IO data"),
         OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
         OPT_END()
         };
@@ -1340,7 +1993,10 @@ int cmd_timechart(int argc, const char **argv,
                         return -1;
                 }
 
-                return timechart__record(&tchart, argc, argv);
+                if (tchart.io_only)
+                        return timechart__io_record(argc, argv);
+                else
+                        return timechart__record(&tchart, argc, argv);
         } else if (argc)
                 usage_with_options(timechart_usage, timechart_options);
 
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index f954c26de231..a6c375224f46 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -1108,6 +1108,7 @@ struct syscall {
         struct event_format *tp_format;
         const char          *name;
         bool                filtered;
+        bool                is_exit;
         struct syscall_fmt  *fmt;
         size_t              (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
         void                **arg_parm;
@@ -1132,6 +1133,7 @@ struct thread_trace {
         u64               exit_time;
         bool              entry_pending;
         unsigned long     nr_events;
+        unsigned long     pfmaj, pfmin;
         char              *entry_str;
         double            runtime_ms;
         struct {
@@ -1177,6 +1179,9 @@ fail:
         return NULL;
 }
 
+#define TRACE_PFMAJ             (1 << 0)
+#define TRACE_PFMIN             (1 << 1)
+
 struct trace {
         struct perf_tool        tool;
         struct {
@@ -1211,6 +1216,8 @@ struct trace {
         bool                    summary_only;
         bool                    show_comm;
         bool                    show_tool_stats;
+        bool                    trace_syscalls;
+        int                     trace_pgfaults;
 };
 
 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
@@ -1276,11 +1283,11 @@ static const char *thread__fd_path(struct thread *thread, int fd,
         if (fd < 0)
                 return NULL;
 
-        if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL))
+        if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
                 if (!trace->live)
                         return NULL;
                 ++trace->stats.proc_getname;
-                if (thread__read_fd_path(thread, fd)) {
+                if (thread__read_fd_path(thread, fd))
                         return NULL;
         }
 
@@ -1473,6 +1480,8 @@ static int trace__read_syscall_info(struct trace *trace, int id)
         if (sc->tp_format == NULL)
                 return -1;
 
+        sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
+
         return syscall__set_arg_fmts(sc);
 }
 
@@ -1535,6 +1544,7 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 }
 
 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
+                                  union perf_event *event,
                                   struct perf_sample *sample);
 
 static struct syscall *trace__syscall_info(struct trace *trace,
@@ -1607,6 +1617,7 @@ static void thread__update_stats(struct thread_trace *ttrace,
 }
 
 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
+                            union perf_event *event __maybe_unused,
                             struct perf_sample *sample)
 {
         char *msg;
@@ -1629,7 +1640,6 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                 return -1;
 
         args = perf_evsel__sc_tp_ptr(evsel, args, sample);
-        ttrace = thread->priv;
 
         if (ttrace->entry_str == NULL) {
                 ttrace->entry_str = malloc(1024);
@@ -1644,7 +1654,7 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
         printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
                                            args, trace, thread);
 
-        if (!strcmp(sc->name, "exit_group") || !strcmp(sc->name, "exit")) {
+        if (sc->is_exit) {
                 if (!trace->duration_filter && !trace->summary_only) {
                         trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
                         fprintf(trace->output, "%-70s\n", ttrace->entry_str);
@@ -1656,6 +1666,7 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
 }
 
 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
+                           union perf_event *event __maybe_unused,
                            struct perf_sample *sample)
 {
         int ret;
@@ -1687,8 +1698,6 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
                 ++trace->stats.vfs_getname;
         }
 
-        ttrace = thread->priv;
-
         ttrace->exit_time = sample->time;
 
         if (ttrace->entry_time) {
@@ -1735,6 +1744,7 @@ out:
 }
 
 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
+                              union perf_event *event __maybe_unused,
                               struct perf_sample *sample)
 {
         trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
@@ -1742,6 +1752,7 @@ static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
 }
 
 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
+                                     union perf_event *event __maybe_unused,
                                      struct perf_sample *sample)
 {
         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
@@ -1768,6 +1779,80 @@ out_dump:
         return 0;
 }
 
+static void print_location(FILE *f, struct perf_sample *sample,
+                           struct addr_location *al,
+                           bool print_dso, bool print_sym)
+{
+
+        if ((verbose || print_dso) && al->map)
+                fprintf(f, "%s@", al->map->dso->long_name);
+
+        if ((verbose || print_sym) && al->sym)
+                fprintf(f, "%s+0x%" PRIx64, al->sym->name,
+                        al->addr - al->sym->start);
+        else if (al->map)
+                fprintf(f, "0x%" PRIx64, al->addr);
+        else
+                fprintf(f, "0x%" PRIx64, sample->addr);
+}
+
+static int trace__pgfault(struct trace *trace,
+                          struct perf_evsel *evsel,
+                          union perf_event *event,
+                          struct perf_sample *sample)
+{
+        struct thread *thread;
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct addr_location al;
+        char map_type = 'd';
+        struct thread_trace *ttrace;
+
+        thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
+        ttrace = thread__trace(thread, trace->output);
+        if (ttrace == NULL)
+                return -1;
+
+        if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
+                ttrace->pfmaj++;
+        else
+                ttrace->pfmin++;
+
+        if (trace->summary_only)
+                return 0;
+
+        thread__find_addr_location(thread, trace->host, cpumode, MAP__FUNCTION,
+                              sample->ip, &al);
+
+        trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
+
+        fprintf(trace->output, "%sfault [",
+                evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
+                "maj" : "min");
+
+        print_location(trace->output, sample, &al, false, true);
+
+        fprintf(trace->output, "] => ");
+
+        thread__find_addr_location(thread, trace->host, cpumode, MAP__VARIABLE,
+                                   sample->addr, &al);
+
+        if (!al.map) {
+                thread__find_addr_location(thread, trace->host, cpumode,
+                                           MAP__FUNCTION, sample->addr, &al);
+
+                if (al.map)
+                        map_type = 'x';
+                else
+                        map_type = '?';
+        }
+
+        print_location(trace->output, sample, &al, true, false);
+
+        fprintf(trace->output, " (%c%c)\n", map_type, al.level);
+
+        return 0;
+}
+
 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
 {
         if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
@@ -1781,7 +1866,7 @@ static bool skip_sample(struct trace *trace, struct perf_sample *sample)
 }
 
 static int trace__process_sample(struct perf_tool *tool,
-                                 union perf_event *event __maybe_unused,
+                                 union perf_event *event,
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel,
                                  struct machine *machine __maybe_unused)
@@ -1799,7 +1884,7 @@ static int trace__process_sample(struct perf_tool *tool,
 
         if (handler) {
                 ++trace->nr_events;
-                handler(trace, evsel, sample);
+                handler(trace, evsel, event, sample);
         }
 
         return err;
@@ -1826,7 +1911,7 @@ static int parse_target_str(struct trace *trace)
         return 0;
 }
 
-static int trace__record(int argc, const char **argv)
+static int trace__record(struct trace *trace, int argc, const char **argv)
 {
         unsigned int rec_argc, i, j;
         const char **rec_argv;
@@ -1835,34 +1920,54 @@ static int trace__record(int argc, const char **argv)
                 "-R",
                 "-m", "1024",
                 "-c", "1",
-                "-e",
         };
 
+        const char * const sc_args[] = { "-e", };
+        unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
+        const char * const majpf_args[] = { "-e", "major-faults" };
+        unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
+        const char * const minpf_args[] = { "-e", "minor-faults" };
+        unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
+
         /* +1 is for the event string below */
-        rec_argc = ARRAY_SIZE(record_args) + 1 + argc;
+        rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
+                majpf_args_nr + minpf_args_nr + argc;
         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 
         if (rec_argv == NULL)
                 return -ENOMEM;
 
+        j = 0;
         for (i = 0; i < ARRAY_SIZE(record_args); i++)
-                rec_argv[i] = record_args[i];
-
-        /* event string may be different for older kernels - e.g., RHEL6 */
-        if (is_valid_tracepoint("raw_syscalls:sys_enter"))
-                rec_argv[i] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
-        else if (is_valid_tracepoint("syscalls:sys_enter"))
-                rec_argv[i] = "syscalls:sys_enter,syscalls:sys_exit";
-        else {
-                pr_err("Neither raw_syscalls nor syscalls events exist.\n");
-                return -1;
+                rec_argv[j++] = record_args[i];
+
+        if (trace->trace_syscalls) {
+                for (i = 0; i < sc_args_nr; i++)
+                        rec_argv[j++] = sc_args[i];
+
+                /* event string may be different for older kernels - e.g., RHEL6 */
+                if (is_valid_tracepoint("raw_syscalls:sys_enter"))
+                        rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
+                else if (is_valid_tracepoint("syscalls:sys_enter"))
+                        rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
+                else {
+                        pr_err("Neither raw_syscalls nor syscalls events exist.\n");
+                        return -1;
+                }
         }
-        i++;
 
-        for (j = 0; j < (unsigned int)argc; j++, i++)
-                rec_argv[i] = argv[j];
+        if (trace->trace_pgfaults & TRACE_PFMAJ)
+                for (i = 0; i < majpf_args_nr; i++)
+                        rec_argv[j++] = majpf_args[i];
+
+        if (trace->trace_pgfaults & TRACE_PFMIN)
+                for (i = 0; i < minpf_args_nr; i++)
+                        rec_argv[j++] = minpf_args[i];
+
+        for (i = 0; i < (unsigned int)argc; i++)
+                rec_argv[j++] = argv[i];
 
-        return cmd_record(i, rec_argv, NULL);
+        return cmd_record(j, rec_argv, NULL);
 }
 
 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
@@ -1882,6 +1987,30 @@ static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
         perf_evlist__add(evlist, evsel);
 }
 
+static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
+                                    u64 config)
+{
+        struct perf_evsel *evsel;
+        struct perf_event_attr attr = {
+                .type = PERF_TYPE_SOFTWARE,
+                .mmap_data = 1,
+        };
+
+        attr.config = config;
+        attr.sample_period = 1;
+
+        event_attr_init(&attr);
+
+        evsel = perf_evsel__new(&attr);
+        if (!evsel)
+                return -ENOMEM;
+
+        evsel->handler = trace__pgfault;
+        perf_evlist__add(evlist, evsel);
+
+        return 0;
+}
+
 static int trace__run(struct trace *trace, int argc, const char **argv)
 {
         struct perf_evlist *evlist = perf_evlist__new();
@@ -1897,10 +2026,21 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
                 goto out;
         }
 
-        if (perf_evlist__add_syscall_newtp(evlist, trace__sys_enter, trace__sys_exit))
+        if (trace->trace_syscalls &&
+            perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
+                                           trace__sys_exit))
                 goto out_error_tp;
 
-        perf_evlist__add_vfs_getname(evlist);
+        if (trace->trace_syscalls)
+                perf_evlist__add_vfs_getname(evlist);
+
+        if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
+            perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ))
+                goto out_error_tp;
+
+        if ((trace->trace_pgfaults & TRACE_PFMIN) &&
+            perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
+                goto out_error_tp;
 
         if (trace->sched &&
                 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
@@ -1982,7 +2122,8 @@ again:
                                 goto next_event;
                         }
 
-                        if (sample.raw_data == NULL) {
+                        if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
+                            sample.raw_data == NULL) {
                                 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
                                        perf_evsel__name(evsel), sample.tid,
                                        sample.cpu, sample.raw_size);
@@ -1990,7 +2131,7 @@ again:
                         }
 
                         handler = evsel->handler;
-                        handler(trace, evsel, &sample);
+                        handler(trace, evsel, event, &sample);
 next_event:
                         perf_evlist__mmap_consume(evlist, i);
 
@@ -2093,13 +2234,10 @@ static int trace__replay(struct trace *trace)
         if (evsel == NULL)
                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
                                                              "syscalls:sys_enter");
-        if (evsel == NULL) {
-                pr_err("Data file does not have raw_syscalls:sys_enter event\n");
-                goto out;
-        }
 
-        if (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
-            perf_evsel__init_sc_tp_ptr_field(evsel, args)) {
+        if (evsel &&
+            (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
+            perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
                 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
                 goto out;
         }
@@ -2109,15 +2247,19 @@ static int trace__replay(struct trace *trace)
         if (evsel == NULL)
                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
                                                              "syscalls:sys_exit");
-        if (evsel == NULL) {
-                pr_err("Data file does not have raw_syscalls:sys_exit event\n");
+        if (evsel &&
+            (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
+            perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
+                pr_err("Error during initialize raw_syscalls:sys_exit event\n");
                 goto out;
         }
 
-        if (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
-            perf_evsel__init_sc_tp_uint_field(evsel, ret)) {
-                pr_err("Error during initialize raw_syscalls:sys_exit event\n");
-                goto out;
+        evlist__for_each(session->evlist, evsel) {
+                if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
+                    (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
+                     evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
+                     evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
+                        evsel->handler = trace__pgfault;
         }
 
         err = parse_target_str(trace);
@@ -2217,6 +2359,10 @@ static int trace__fprintf_one_thread(struct thread *thread, void *priv)
         printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
         printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
         printed += fprintf(fp, "%.1f%%", ratio);
+        if (ttrace->pfmaj)
+                printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
+        if (ttrace->pfmin)
+                printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
         printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
         printed += thread__dump_stats(ttrace, trace, fp);
 
@@ -2264,6 +2410,23 @@ static int trace__open_output(struct trace *trace, const char *filename)
         return trace->output == NULL ? -errno : 0;
 }
 
+static int parse_pagefaults(const struct option *opt, const char *str,
+                            int unset __maybe_unused)
+{
+        int *trace_pgfaults = opt->value;
+
+        if (strcmp(str, "all") == 0)
+                *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
+        else if (strcmp(str, "maj") == 0)
+                *trace_pgfaults |= TRACE_PFMAJ;
+        else if (strcmp(str, "min") == 0)
+                *trace_pgfaults |= TRACE_PFMIN;
+        else
+                return -1;
+
+        return 0;
+}
+
 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         const char * const trace_usage[] = {
@@ -2293,6 +2456,7 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
                 },
                 .output = stdout,
                 .show_comm = true,
+                .trace_syscalls = true,
         };
         const char *output_name = NULL;
         const char *ev_qualifier_str = NULL;
@@ -2330,20 +2494,34 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show only syscall summary with statistics"),
         OPT_BOOLEAN('S', "with-summary", &trace.summary,
                     "Show all syscalls and summary with statistics"),
+        OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
+                     "Trace pagefaults", parse_pagefaults, "maj"),
+        OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
         OPT_END()
         };
         int err;
         char bf[BUFSIZ];
 
-        if ((argc > 1) && (strcmp(argv[1], "record") == 0))
-                return trace__record(argc-2, &argv[2]);
+        argc = parse_options(argc, argv, trace_options, trace_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
 
-        argc = parse_options(argc, argv, trace_options, trace_usage, 0);
+        if (trace.trace_pgfaults) {
+                trace.opts.sample_address = true;
+                trace.opts.sample_time = true;
+        }
+
+        if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
+                return trace__record(&trace, argc-1, &argv[1]);
 
         /* summary_only implies summary option, but don't overwrite summary if set */
         if (trace.summary_only)
                 trace.summary = trace.summary_only;
 
+        if (!trace.trace_syscalls && !trace.trace_pgfaults) {
+                pr_err("Please specify something to trace.\n");
+                return -1;
+        }
+
         if (output_name != NULL) {
                 err = trace__open_output(&trace, output_name);
                 if (err < 0) {
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index f30ac5e5d271..1f67aa02d240 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -48,6 +48,10 @@ 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
@@ -160,6 +164,7 @@ CORE_FEATURE_TESTS =			\
         backtrace                       \
         dwarf                           \
         fortify-source                  \
+        sync-compare-and-swap           \
         glibc                           \
         gtk2                            \
         gtk2-infobar                    \
@@ -195,6 +200,7 @@ LIB_FEATURE_TESTS =			\
 VF_FEATURE_TESTS =                      \
         backtrace                       \
         fortify-source                  \
+        sync-compare-and-swap           \
         gtk2-infobar                    \
         libelf-getphdrnum               \
         libelf-mmap                     \
@@ -268,6 +274,10 @@ CFLAGS += -I$(LIB_INCLUDE)
 
 CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
 
+ifeq ($(feature-sync-compare-and-swap), 1)
+  CFLAGS += -DHAVE_SYNC_COMPARE_AND_SWAP_SUPPORT
+endif
+
 ifndef NO_BIONIC
   $(call feature_check,bionic)
   ifeq ($(feature-bionic), 1)
@@ -590,6 +600,10 @@ ifndef NO_LIBNUMA
   endif
 endif
 
+ifdef HAVE_KVM_STAT_SUPPORT
+    CFLAGS += -DHAVE_KVM_STAT_SUPPORT
+endif
+
 # Among the variables below, these:
 #   perfexecdir
 #   template_dir
diff --git a/tools/perf/config/feature-checks/Makefile b/tools/perf/config/feature-checks/Makefile
index 64c84e5f0514..6088f8d8a434 100644
--- a/tools/perf/config/feature-checks/Makefile
+++ b/tools/perf/config/feature-checks/Makefile
@@ -5,6 +5,7 @@ FILES=					\
         test-bionic.bin                 \
         test-dwarf.bin                  \
         test-fortify-source.bin         \
+        test-sync-compare-and-swap.bin  \
         test-glibc.bin                  \
         test-gtk2.bin                   \
         test-gtk2-infobar.bin           \
@@ -141,6 +142,9 @@ test-timerfd.bin:
 test-libdw-dwarf-unwind.bin:
         $(BUILD)
 
+test-sync-compare-and-swap.bin:
+        $(BUILD) -Werror
+
 -include *.d
 
 ###############################
diff --git a/tools/perf/config/feature-checks/test-all.c b/tools/perf/config/feature-checks/test-all.c
index fe5c1e5c952f..a7d022e161c0 100644
--- a/tools/perf/config/feature-checks/test-all.c
+++ b/tools/perf/config/feature-checks/test-all.c
@@ -89,6 +89,10 @@
 # include "test-libdw-dwarf-unwind.c"
 #undef main
 
+#define main main_test_sync_compare_and_swap
+# include "test-sync-compare-and-swap.c"
+#undef main
+
 int main(int argc, char *argv[])
 {
         main_test_libpython();
@@ -111,6 +115,7 @@ int main(int argc, char *argv[])
         main_test_timerfd();
         main_test_stackprotector_all();
         main_test_libdw_dwarf_unwind();
+        main_test_sync_compare_and_swap(argc, argv);
 
         return 0;
 }
diff --git a/tools/perf/config/feature-checks/test-sync-compare-and-swap.c b/tools/perf/config/feature-checks/test-sync-compare-and-swap.c
new file mode 100644
index 000000000000..c34d4ca4af56
--- /dev/null
+++ b/tools/perf/config/feature-checks/test-sync-compare-and-swap.c
@@ -0,0 +1,14 @@
+#include <stdint.h>
+
+volatile uint64_t x;
+
+int main(int argc, char *argv[])
+{
+        uint64_t old, new = argc;
+
+        argv = argv;
+        do {
+                old = __sync_val_compare_and_swap(&x, 0, 0);
+        } while (!__sync_bool_compare_and_swap(&x, old, new));
+        return old == new;
+}
diff --git a/tools/perf/perf-sys.h b/tools/perf/perf-sys.h
index 5268a1481d23..937e4324ad94 100644
--- a/tools/perf/perf-sys.h
+++ b/tools/perf/perf-sys.h
@@ -54,6 +54,7 @@
 #define mb()            asm volatile("bcr 15,0" ::: "memory")
 #define wmb()           asm volatile("bcr 15,0" ::: "memory")
 #define rmb()           asm volatile("bcr 15,0" ::: "memory")
+#define CPUINFO_PROC    "vendor_id"
 #endif
 
 #ifdef __sh__
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 95c58fc15284..2282d41879a2 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -13,11 +13,12 @@
 #include "util/quote.h"
 #include "util/run-command.h"
 #include "util/parse-events.h"
+#include "util/debug.h"
 #include <api/fs/debugfs.h>
 #include <pthread.h>
 
 const char perf_usage_string[] =
-        "perf [--version] [--help] COMMAND [ARGS]";
+        "perf [--version] [--help] [OPTIONS] COMMAND [ARGS]";
 
 const char perf_more_info_string[] =
         "See 'perf help COMMAND' for more information on a specific command.";
@@ -212,6 +213,16 @@ static int handle_options(const char ***argv, int *argc, int *envchanged)
                                 printf("%s ", p->cmd);
                         }
                         exit(0);
+                } else if (!strcmp(cmd, "--debug")) {
+                        if (*argc < 2) {
+                                fprintf(stderr, "No variable specified for --debug.\n");
+                                usage(perf_usage_string);
+                        }
+                        if (perf_debug_option((*argv)[1]))
+                                usage(perf_usage_string);
+
+                        (*argv)++;
+                        (*argc)--;
                 } else {
                         fprintf(stderr, "Unknown option: %s\n", cmd);
                         usage(perf_usage_string);
diff --git a/tools/perf/scripts/perl/bin/failed-syscalls-record b/tools/perf/scripts/perl/bin/failed-syscalls-record
index 8104895a7b67..74685f318379 100644
--- a/tools/perf/scripts/perl/bin/failed-syscalls-record
+++ b/tools/perf/scripts/perl/bin/failed-syscalls-record
@@ -1,2 +1,3 @@
 #!/bin/bash
-perf record -e raw_syscalls:sys_exit $@
+(perf record -e raw_syscalls:sys_exit $@ || \
+ perf record -e syscalls:sys_exit $@) 2> /dev/null
diff --git a/tools/perf/scripts/perl/failed-syscalls.pl b/tools/perf/scripts/perl/failed-syscalls.pl
index 94bc25a347eb..55e7ae4c5c88 100644
--- a/tools/perf/scripts/perl/failed-syscalls.pl
+++ b/tools/perf/scripts/perl/failed-syscalls.pl
@@ -26,6 +26,11 @@ sub raw_syscalls::sys_exit
         }
 }
 
+sub syscalls::sys_exit
+{
+        raw_syscalls::sys_exit(@_)
+}
+
 sub trace_end
 {
     printf("\nfailed syscalls by comm:\n\n");
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
index de7211e4fa47..38dfb720fb6f 100644
--- a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
@@ -107,12 +107,13 @@ def taskState(state):
 
 class EventHeaders:
         def __init__(self, common_cpu, common_secs, common_nsecs,
-                     common_pid, common_comm):
+                     common_pid, common_comm, common_callchain):
                 self.cpu = common_cpu
                 self.secs = common_secs
                 self.nsecs = common_nsecs
                 self.pid = common_pid
                 self.comm = common_comm
+                self.callchain = common_callchain
 
         def ts(self):
                 return (self.secs * (10 ** 9)) + self.nsecs
diff --git a/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
index 8104895a7b67..74685f318379 100644
--- a/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
+++ b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
@@ -1,2 +1,3 @@
 #!/bin/bash
-perf record -e raw_syscalls:sys_exit $@
+(perf record -e raw_syscalls:sys_exit $@ || \
+ perf record -e syscalls:sys_exit $@) 2> /dev/null
diff --git a/tools/perf/scripts/python/bin/sctop-record b/tools/perf/scripts/python/bin/sctop-record
index 4efbfaa7f6a5..d6940841e54f 100644
--- a/tools/perf/scripts/python/bin/sctop-record
+++ b/tools/perf/scripts/python/bin/sctop-record
@@ -1,2 +1,3 @@
 #!/bin/bash
-perf record -e raw_syscalls:sys_enter $@
+(perf record -e raw_syscalls:sys_enter $@ || \
+ perf record -e syscalls:sys_enter $@) 2> /dev/null
diff --git a/tools/perf/scripts/python/bin/syscall-counts-by-pid-record b/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
index 4efbfaa7f6a5..d6940841e54f 100644
--- a/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
+++ b/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
@@ -1,2 +1,3 @@
 #!/bin/bash
-perf record -e raw_syscalls:sys_enter $@
+(perf record -e raw_syscalls:sys_enter $@ || \
+ perf record -e syscalls:sys_enter $@) 2> /dev/null
diff --git a/tools/perf/scripts/python/bin/syscall-counts-record b/tools/perf/scripts/python/bin/syscall-counts-record
index 4efbfaa7f6a5..d6940841e54f 100644
--- a/tools/perf/scripts/python/bin/syscall-counts-record
+++ b/tools/perf/scripts/python/bin/syscall-counts-record
@@ -1,2 +1,3 @@
 #!/bin/bash
-perf record -e raw_syscalls:sys_enter $@
+(perf record -e raw_syscalls:sys_enter $@ || \
+ perf record -e syscalls:sys_enter $@) 2> /dev/null
diff --git a/tools/perf/scripts/python/check-perf-trace.py b/tools/perf/scripts/python/check-perf-trace.py
index 4647a7694cf6..334599c6032c 100644
--- a/tools/perf/scripts/python/check-perf-trace.py
+++ b/tools/perf/scripts/python/check-perf-trace.py
@@ -27,7 +27,7 @@ def trace_end():
 
 def irq__softirq_entry(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        vec):
+        common_callchain, vec):
                 print_header(event_name, common_cpu, common_secs, common_nsecs,
                         common_pid, common_comm)
 
@@ -38,7 +38,7 @@ def irq__softirq_entry(event_name, context, common_cpu,
 
 def kmem__kmalloc(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        call_site, ptr, bytes_req, bytes_alloc,
+        common_callchain, call_site, ptr, bytes_req, bytes_alloc,
         gfp_flags):
                 print_header(event_name, common_cpu, common_secs, common_nsecs,
                         common_pid, common_comm)
diff --git a/tools/perf/scripts/python/failed-syscalls-by-pid.py b/tools/perf/scripts/python/failed-syscalls-by-pid.py
index 85805fac4116..cafeff3d74db 100644
--- a/tools/perf/scripts/python/failed-syscalls-by-pid.py
+++ b/tools/perf/scripts/python/failed-syscalls-by-pid.py
@@ -39,7 +39,7 @@ def trace_end():
 
 def raw_syscalls__sys_exit(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        id, ret):
+        common_callchain, id, ret):
         if (for_comm and common_comm != for_comm) or \
            (for_pid  and common_pid  != for_pid ):
                 return
@@ -50,6 +50,11 @@ def raw_syscalls__sys_exit(event_name, context, common_cpu,
                 except TypeError:
                         syscalls[common_comm][common_pid][id][ret] = 1
 
+def syscalls__sys_exit(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, ret):
+        raw_syscalls__sys_exit(**locals())
+
 def print_error_totals():
     if for_comm is not None:
             print "\nsyscall errors for %s:\n\n" % (for_comm),
diff --git a/tools/perf/scripts/python/futex-contention.py b/tools/perf/scripts/python/futex-contention.py
index 11e70a388d41..0f5cf437b602 100644
--- a/tools/perf/scripts/python/futex-contention.py
+++ b/tools/perf/scripts/python/futex-contention.py
@@ -21,7 +21,7 @@ thread_blocktime = {}
 lock_waits = {} # long-lived stats on (tid,lock) blockage elapsed time
 process_names = {} # long-lived pid-to-execname mapping
 
-def syscalls__sys_enter_futex(event, ctxt, cpu, s, ns, tid, comm,
+def syscalls__sys_enter_futex(event, ctxt, cpu, s, ns, tid, comm, callchain,
                               nr, uaddr, op, val, utime, uaddr2, val3):
         cmd = op & FUTEX_CMD_MASK
         if cmd != FUTEX_WAIT:
@@ -31,7 +31,7 @@ def syscalls__sys_enter_futex(event, ctxt, cpu, s, ns, tid, comm,
         thread_thislock[tid] = uaddr
         thread_blocktime[tid] = nsecs(s, ns)
 
-def syscalls__sys_exit_futex(event, ctxt, cpu, s, ns, tid, comm,
+def syscalls__sys_exit_futex(event, ctxt, cpu, s, ns, tid, comm, callchain,
                              nr, ret):
         if thread_blocktime.has_key(tid):
                 elapsed = nsecs(s, ns) - thread_blocktime[tid]
diff --git a/tools/perf/scripts/python/net_dropmonitor.py b/tools/perf/scripts/python/net_dropmonitor.py
index b5740599aabd..0b6ce8c253e8 100755
--- a/tools/perf/scripts/python/net_dropmonitor.py
+++ b/tools/perf/scripts/python/net_dropmonitor.py
@@ -66,7 +66,7 @@ def trace_end():
         print_drop_table()
 
 # called from perf, when it finds a correspoinding event
-def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm,
+def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm, callchain,
                    skbaddr, location, protocol):
         slocation = str(location)
         try:
diff --git a/tools/perf/scripts/python/netdev-times.py b/tools/perf/scripts/python/netdev-times.py
index 9aa0a32972e8..4d21ef2d601d 100644
--- a/tools/perf/scripts/python/netdev-times.py
+++ b/tools/perf/scripts/python/netdev-times.py
@@ -224,75 +224,75 @@ def trace_end():
                         (len(rx_skb_list), of_count_rx_skb_list)
 
 # called from perf, when it finds a correspoinding event
-def irq__softirq_entry(name, context, cpu, sec, nsec, pid, comm, vec):
+def irq__softirq_entry(name, context, cpu, sec, nsec, pid, comm, callchain, vec):
         if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
                 return
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
         all_event_list.append(event_info)
 
-def irq__softirq_exit(name, context, cpu, sec, nsec, pid, comm, vec):
+def irq__softirq_exit(name, context, cpu, sec, nsec, pid, comm, callchain, vec):
         if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
                 return
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
         all_event_list.append(event_info)
 
-def irq__softirq_raise(name, context, cpu, sec, nsec, pid, comm, vec):
+def irq__softirq_raise(name, context, cpu, sec, nsec, pid, comm, callchain, vec):
         if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
                 return
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
         all_event_list.append(event_info)
 
 def irq__irq_handler_entry(name, context, cpu, sec, nsec, pid, comm,
-                        irq, irq_name):
+                        callchain, irq, irq_name):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         irq, irq_name)
         all_event_list.append(event_info)
 
-def irq__irq_handler_exit(name, context, cpu, sec, nsec, pid, comm, irq, ret):
+def irq__irq_handler_exit(name, context, cpu, sec, nsec, pid, comm, callchain, irq, ret):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, irq, ret)
         all_event_list.append(event_info)
 
-def napi__napi_poll(name, context, cpu, sec, nsec, pid, comm, napi, dev_name):
+def napi__napi_poll(name, context, cpu, sec, nsec, pid, comm, callchain, napi, dev_name):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         napi, dev_name)
         all_event_list.append(event_info)
 
-def net__netif_receive_skb(name, context, cpu, sec, nsec, pid, comm, skbaddr,
+def net__netif_receive_skb(name, context, cpu, sec, nsec, pid, comm, callchain, skbaddr,
                         skblen, dev_name):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr, skblen, dev_name)
         all_event_list.append(event_info)
 
-def net__netif_rx(name, context, cpu, sec, nsec, pid, comm, skbaddr,
+def net__netif_rx(name, context, cpu, sec, nsec, pid, comm, callchain, skbaddr,
                         skblen, dev_name):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr, skblen, dev_name)
         all_event_list.append(event_info)
 
-def net__net_dev_queue(name, context, cpu, sec, nsec, pid, comm,
+def net__net_dev_queue(name, context, cpu, sec, nsec, pid, comm, callchain,
                         skbaddr, skblen, dev_name):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr, skblen, dev_name)
         all_event_list.append(event_info)
 
-def net__net_dev_xmit(name, context, cpu, sec, nsec, pid, comm,
+def net__net_dev_xmit(name, context, cpu, sec, nsec, pid, comm, callchain,
                         skbaddr, skblen, rc, dev_name):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr, skblen, rc ,dev_name)
         all_event_list.append(event_info)
 
-def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm,
+def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm, callchain,
                         skbaddr, protocol, location):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr, protocol, location)
         all_event_list.append(event_info)
 
-def skb__consume_skb(name, context, cpu, sec, nsec, pid, comm, skbaddr):
+def skb__consume_skb(name, context, cpu, sec, nsec, pid, comm, callchain, skbaddr):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr)
         all_event_list.append(event_info)
 
-def skb__skb_copy_datagram_iovec(name, context, cpu, sec, nsec, pid, comm,
+def skb__skb_copy_datagram_iovec(name, context, cpu, sec, nsec, pid, comm, callchain,
         skbaddr, skblen):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
                         skbaddr, skblen)
diff --git a/tools/perf/scripts/python/sched-migration.py b/tools/perf/scripts/python/sched-migration.py
index 74d55ec08aed..de66cb3b72c9 100644
--- a/tools/perf/scripts/python/sched-migration.py
+++ b/tools/perf/scripts/python/sched-migration.py
@@ -369,93 +369,92 @@ def trace_end():
 
 def sched__sched_stat_runtime(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, runtime, vruntime):
+        common_callchain, comm, pid, runtime, vruntime):
         pass
 
 def sched__sched_stat_iowait(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, delay):
+        common_callchain, comm, pid, delay):
         pass
 
 def sched__sched_stat_sleep(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, delay):
+        common_callchain, comm, pid, delay):
         pass
 
 def sched__sched_stat_wait(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, delay):
+        common_callchain, comm, pid, delay):
         pass
 
 def sched__sched_process_fork(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        parent_comm, parent_pid, child_comm, child_pid):
+        common_callchain, parent_comm, parent_pid, child_comm, child_pid):
         pass
 
 def sched__sched_process_wait(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio):
+        common_callchain, comm, pid, prio):
         pass
 
 def sched__sched_process_exit(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio):
+        common_callchain, comm, pid, prio):
         pass
 
 def sched__sched_process_free(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio):
+        common_callchain, comm, pid, prio):
         pass
 
 def sched__sched_migrate_task(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio, orig_cpu,
+        common_callchain, comm, pid, prio, orig_cpu,
         dest_cpu):
         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
-                                common_pid, common_comm)
+                                common_pid, common_comm, common_callchain)
         parser.migrate(headers, pid, prio, orig_cpu, dest_cpu)
 
 def sched__sched_switch(event_name, context, common_cpu,
-        common_secs, common_nsecs, common_pid, common_comm,
+        common_secs, common_nsecs, common_pid, common_comm, common_callchain,
         prev_comm, prev_pid, prev_prio, prev_state,
         next_comm, next_pid, next_prio):
 
         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
-                                common_pid, common_comm)
+                                common_pid, common_comm, common_callchain)
         parser.sched_switch(headers, prev_comm, prev_pid, prev_prio, prev_state,
                          next_comm, next_pid, next_prio)
 
 def sched__sched_wakeup_new(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio, success,
+        common_callchain, comm, pid, prio, success,
         target_cpu):
         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
-                                common_pid, common_comm)
+                                common_pid, common_comm, common_callchain)
         parser.wake_up(headers, comm, pid, success, target_cpu, 1)
 
 def sched__sched_wakeup(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio, success,
+        common_callchain, comm, pid, prio, success,
         target_cpu):
         headers = EventHeaders(common_cpu, common_secs, common_nsecs,
-                                common_pid, common_comm)
+                                common_pid, common_comm, common_callchain)
         parser.wake_up(headers, comm, pid, success, target_cpu, 0)
 
 def sched__sched_wait_task(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid, prio):
+        common_callchain, comm, pid, prio):
         pass
 
 def sched__sched_kthread_stop_ret(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        ret):
+        common_callchain, ret):
         pass
 
 def sched__sched_kthread_stop(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        comm, pid):
+        common_callchain, comm, pid):
         pass
 
-def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
-                common_pid, common_comm):
+def trace_unhandled(event_name, context, event_fields_dict):
         pass
diff --git a/tools/perf/scripts/python/sctop.py b/tools/perf/scripts/python/sctop.py
index 42c267e292fa..61621b93affb 100644
--- a/tools/perf/scripts/python/sctop.py
+++ b/tools/perf/scripts/python/sctop.py
@@ -44,7 +44,7 @@ def trace_begin():
 
 def raw_syscalls__sys_enter(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        id, args):
+        common_callchain, id, args):
         if for_comm is not None:
                 if common_comm != for_comm:
                         return
@@ -53,6 +53,11 @@ def raw_syscalls__sys_enter(event_name, context, common_cpu,
         except TypeError:
                 syscalls[id] = 1
 
+def syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        raw_syscalls__sys_enter(**locals())
+
 def print_syscall_totals(interval):
         while 1:
                 clear_term()
diff --git a/tools/perf/scripts/python/syscall-counts-by-pid.py b/tools/perf/scripts/python/syscall-counts-by-pid.py
index c64d1c55d745..daf314cc5dd3 100644
--- a/tools/perf/scripts/python/syscall-counts-by-pid.py
+++ b/tools/perf/scripts/python/syscall-counts-by-pid.py
@@ -38,7 +38,7 @@ def trace_end():
 
 def raw_syscalls__sys_enter(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        id, args):
+        common_callchain, id, args):
 
         if (for_comm and common_comm != for_comm) or \
            (for_pid  and common_pid  != for_pid ):
@@ -48,6 +48,11 @@ def raw_syscalls__sys_enter(event_name, context, common_cpu,
         except TypeError:
                 syscalls[common_comm][common_pid][id] = 1
 
+def syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        raw_syscalls__sys_enter(**locals())
+
 def print_syscall_totals():
     if for_comm is not None:
             print "\nsyscall events for %s:\n\n" % (for_comm),
diff --git a/tools/perf/scripts/python/syscall-counts.py b/tools/perf/scripts/python/syscall-counts.py
index b435d3f188e8..e66a7730aeb5 100644
--- a/tools/perf/scripts/python/syscall-counts.py
+++ b/tools/perf/scripts/python/syscall-counts.py
@@ -35,7 +35,7 @@ def trace_end():
 
 def raw_syscalls__sys_enter(event_name, context, common_cpu,
         common_secs, common_nsecs, common_pid, common_comm,
-        id, args):
+        common_callchain, id, args):
         if for_comm is not None:
                 if common_comm != for_comm:
                         return
@@ -44,6 +44,11 @@ def raw_syscalls__sys_enter(event_name, context, common_cpu,
         except TypeError:
                 syscalls[id] = 1
 
+def syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        raw_syscalls__sys_enter(**locals())
+
 def print_syscall_totals():
     if for_comm is not None:
             print "\nsyscall events for %s:\n\n" % (for_comm),
diff --git a/tools/perf/tests/attr/base-record b/tools/perf/tests/attr/base-record
index e9bd6391f2ae..f710b92ccff6 100644
--- a/tools/perf/tests/attr/base-record
+++ b/tools/perf/tests/attr/base-record
@@ -1,7 +1,8 @@
 [event]
 fd=1
 group_fd=-1
-flags=0
+# 0 or PERF_FLAG_FD_CLOEXEC flag
+flags=0|8
 cpu=*
 type=0|1
 size=96
diff --git a/tools/perf/tests/attr/base-stat b/tools/perf/tests/attr/base-stat
index 91cd48b399f3..dc3ada2470c0 100644
--- a/tools/perf/tests/attr/base-stat
+++ b/tools/perf/tests/attr/base-stat
@@ -1,7 +1,8 @@
 [event]
 fd=1
 group_fd=-1
-flags=0
+# 0 or PERF_FLAG_FD_CLOEXEC flag
+flags=0|8
 cpu=*
 type=0
 size=96
diff --git a/tools/perf/tests/bp_signal.c b/tools/perf/tests/bp_signal.c
index aba095489193..a02b035fd5aa 100644
--- a/tools/perf/tests/bp_signal.c
+++ b/tools/perf/tests/bp_signal.c
@@ -25,6 +25,7 @@
 #include "tests.h"
 #include "debug.h"
 #include "perf.h"
+#include "cloexec.h"
 
 static int fd1;
 static int fd2;
@@ -78,7 +79,8 @@ static int bp_event(void *fn, int setup_signal)
         pe.exclude_kernel = 1;
         pe.exclude_hv = 1;
 
-        fd = sys_perf_event_open(&pe, 0, -1, -1, 0);
+        fd = sys_perf_event_open(&pe, 0, -1, -1,
+                                 perf_event_open_cloexec_flag());
         if (fd < 0) {
                 pr_debug("failed opening event %llx\n", pe.config);
                 return TEST_FAIL;
diff --git a/tools/perf/tests/bp_signal_overflow.c b/tools/perf/tests/bp_signal_overflow.c
index 44ac82179708..e76537724491 100644
--- a/tools/perf/tests/bp_signal_overflow.c
+++ b/tools/perf/tests/bp_signal_overflow.c
@@ -24,6 +24,7 @@
 #include "tests.h"
 #include "debug.h"
 #include "perf.h"
+#include "cloexec.h"
 
 static int overflows;
 
@@ -91,7 +92,8 @@ int test__bp_signal_overflow(void)
         pe.exclude_kernel = 1;
         pe.exclude_hv = 1;
 
-        fd = sys_perf_event_open(&pe, 0, -1, -1, 0);
+        fd = sys_perf_event_open(&pe, 0, -1, -1,
+                                 perf_event_open_cloexec_flag());
         if (fd < 0) {
                 pr_debug("failed opening event %llx\n", pe.config);
                 return TEST_FAIL;
diff --git a/tools/perf/tests/dso-data.c b/tools/perf/tests/dso-data.c
index 630808cd7cc2..caaf37f079b1 100644
--- a/tools/perf/tests/dso-data.c
+++ b/tools/perf/tests/dso-data.c
@@ -10,6 +10,7 @@
 #include "machine.h"
 #include "symbol.h"
 #include "tests.h"
+#include "debug.h"
 
 static char *test_file(int size)
 {
diff --git a/tools/perf/tests/evsel-roundtrip-name.c b/tools/perf/tests/evsel-roundtrip-name.c
index 465cdbc345cf..b8d8341b383e 100644
--- a/tools/perf/tests/evsel-roundtrip-name.c
+++ b/tools/perf/tests/evsel-roundtrip-name.c
@@ -2,6 +2,7 @@
 #include "evsel.h"
 #include "parse-events.h"
 #include "tests.h"
+#include "debug.h"
 
 static int perf_evsel__roundtrip_cache_name_test(void)
 {
diff --git a/tools/perf/tests/evsel-tp-sched.c b/tools/perf/tests/evsel-tp-sched.c
index 35d7fdb2328d..52162425c969 100644
--- a/tools/perf/tests/evsel-tp-sched.c
+++ b/tools/perf/tests/evsel-tp-sched.c
@@ -1,6 +1,7 @@
 #include <traceevent/event-parse.h>
 #include "evsel.h"
 #include "tests.h"
+#include "debug.h"
 
 static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
                                   int size, bool should_be_signed)
diff --git a/tools/perf/tests/open-syscall-tp-fields.c b/tools/perf/tests/open-syscall-tp-fields.c
index c505ef2af245..0785b64ffd6c 100644
--- a/tools/perf/tests/open-syscall-tp-fields.c
+++ b/tools/perf/tests/open-syscall-tp-fields.c
@@ -3,6 +3,7 @@
 #include "evsel.h"
 #include "thread_map.h"
 #include "tests.h"
+#include "debug.h"
 
 int test__syscall_open_tp_fields(void)
 {
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index deba66955f8c..5941927a4b7f 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -5,6 +5,7 @@
 #include <api/fs/fs.h>
 #include <api/fs/debugfs.h>
 #include "tests.h"
+#include "debug.h"
 #include <linux/hw_breakpoint.h>
 
 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
diff --git a/tools/perf/tests/parse-no-sample-id-all.c b/tools/perf/tests/parse-no-sample-id-all.c
index 905019f9b740..2c63ea658541 100644
--- a/tools/perf/tests/parse-no-sample-id-all.c
+++ b/tools/perf/tests/parse-no-sample-id-all.c
@@ -7,6 +7,7 @@
 #include "evlist.h"
 #include "header.h"
 #include "util.h"
+#include "debug.h"
 
 static int process_event(struct perf_evlist **pevlist, union perf_event *event)
 {
diff --git a/tools/perf/tests/perf-time-to-tsc.c b/tools/perf/tests/perf-time-to-tsc.c
index 3b7cd4d32dcb..f238442b238a 100644
--- a/tools/perf/tests/perf-time-to-tsc.c
+++ b/tools/perf/tests/perf-time-to-tsc.c
@@ -8,10 +8,9 @@
 #include "evsel.h"
 #include "thread_map.h"
 #include "cpumap.h"
+#include "tsc.h"
 #include "tests.h"
 
-#include "../arch/x86/util/tsc.h"
-
 #define CHECK__(x) {                            \
         while ((x) < 0) {                       \
                 pr_debug(#x " failed!\n");      \
@@ -26,15 +25,6 @@
         }                                       \
 }
 
-static u64 rdtsc(void)
-{
-        unsigned int low, high;
-
-        asm volatile("rdtsc" : "=a" (low), "=d" (high));
-
-        return low | ((u64)high) << 32;
-}
-
 /**
  * test__perf_time_to_tsc - test converting perf time to TSC.
  *
diff --git a/tools/perf/tests/rdpmc.c b/tools/perf/tests/rdpmc.c
index e59143fd9e71..c04d1f268576 100644
--- a/tools/perf/tests/rdpmc.c
+++ b/tools/perf/tests/rdpmc.c
@@ -6,6 +6,7 @@
 #include "perf.h"
 #include "debug.h"
 #include "tests.h"
+#include "cloexec.h"
 
 #if defined(__x86_64__) || defined(__i386__)
 
@@ -104,7 +105,8 @@ static int __test__rdpmc(void)
         sa.sa_sigaction = segfault_handler;
         sigaction(SIGSEGV, &sa, NULL);
 
-        fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
+        fd = sys_perf_event_open(&attr, 0, -1, -1,
+                                 perf_event_open_cloexec_flag());
         if (fd < 0) {
                 pr_err("Error: sys_perf_event_open() syscall returned "
                        "with %d (%s)\n", fd, strerror(errno));
diff --git a/tools/perf/tests/sample-parsing.c b/tools/perf/tests/sample-parsing.c
index 7ae8d17db3d9..ca292f9a4ae2 100644
--- a/tools/perf/tests/sample-parsing.c
+++ b/tools/perf/tests/sample-parsing.c
@@ -4,6 +4,7 @@
 #include "util.h"
 #include "event.h"
 #include "evsel.h"
+#include "debug.h"
 
 #include "tests.h"
 
diff --git a/tools/perf/tests/thread-mg-share.c b/tools/perf/tests/thread-mg-share.c
index 2b2e0dbe114f..b028499dd3cf 100644
--- a/tools/perf/tests/thread-mg-share.c
+++ b/tools/perf/tests/thread-mg-share.c
@@ -2,6 +2,7 @@
 #include "machine.h"
 #include "thread.h"
 #include "map.h"
+#include "debug.h"
 
 int test__thread_mg_share(void)
 {
diff --git a/tools/perf/ui/browser.c b/tools/perf/ui/browser.c
index 3ccf6e14f89b..6680fa5cb9dd 100644
--- a/tools/perf/ui/browser.c
+++ b/tools/perf/ui/browser.c
@@ -150,7 +150,7 @@ unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)
         while (nd != NULL) {
                 ui_browser__gotorc(browser, row, 0);
                 browser->write(browser, nd, row);
-                if (++row == browser->height)
+                if (++row == browser->rows)
                         break;
                 nd = rb_next(nd);
         }
@@ -166,7 +166,7 @@ bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)
 void ui_browser__refresh_dimensions(struct ui_browser *browser)
 {
         browser->width = SLtt_Screen_Cols - 1;
-        browser->height = SLtt_Screen_Rows - 2;
+        browser->height = browser->rows = SLtt_Screen_Rows - 2;
         browser->y = 1;
         browser->x = 0;
 }
@@ -250,7 +250,10 @@ int ui_browser__show(struct ui_browser *browser, const char *title,
         int err;
         va_list ap;
 
-        ui_browser__refresh_dimensions(browser);
+        if (browser->refresh_dimensions == NULL)
+                browser->refresh_dimensions = ui_browser__refresh_dimensions;
+
+        browser->refresh_dimensions(browser);
 
         pthread_mutex_lock(&ui__lock);
         __ui_browser__show_title(browser, title);
@@ -279,7 +282,7 @@ static void ui_browser__scrollbar_set(struct ui_browser *browser)
 {
         int height = browser->height, h = 0, pct = 0,
             col = browser->width,
-            row = browser->y - 1;
+            row = 0;
 
         if (browser->nr_entries > 1) {
                 pct = ((browser->index * (browser->height - 1)) /
@@ -367,7 +370,7 @@ int ui_browser__run(struct ui_browser *browser, int delay_secs)
 
                 if (key == K_RESIZE) {
                         ui__refresh_dimensions(false);
-                        ui_browser__refresh_dimensions(browser);
+                        browser->refresh_dimensions(browser);
                         __ui_browser__show_title(browser, browser->title);
                         ui_helpline__puts(browser->helpline);
                         continue;
@@ -389,7 +392,7 @@ int ui_browser__run(struct ui_browser *browser, int delay_secs)
                         if (browser->index == browser->nr_entries - 1)
                                 break;
                         ++browser->index;
-                        if (browser->index == browser->top_idx + browser->height) {
+                        if (browser->index == browser->top_idx + browser->rows) {
                                 ++browser->top_idx;
                                 browser->seek(browser, +1, SEEK_CUR);
                         }
@@ -405,10 +408,10 @@ int ui_browser__run(struct ui_browser *browser, int delay_secs)
                         break;
                 case K_PGDN:
                 case ' ':
-                        if (browser->top_idx + browser->height > browser->nr_entries - 1)
+                        if (browser->top_idx + browser->rows > browser->nr_entries - 1)
                                 break;
 
-                        offset = browser->height;
+                        offset = browser->rows;
                         if (browser->index + offset > browser->nr_entries - 1)
                                 offset = browser->nr_entries - 1 - browser->index;
                         browser->index += offset;
@@ -419,10 +422,10 @@ int ui_browser__run(struct ui_browser *browser, int delay_secs)
                         if (browser->top_idx == 0)
                                 break;
 
-                        if (browser->top_idx < browser->height)
+                        if (browser->top_idx < browser->rows)
                                 offset = browser->top_idx;
                         else
-                                offset = browser->height;
+                                offset = browser->rows;
 
                         browser->index -= offset;
                         browser->top_idx -= offset;
@@ -432,7 +435,7 @@ int ui_browser__run(struct ui_browser *browser, int delay_secs)
                         ui_browser__reset_index(browser);
                         break;
                 case K_END:
-                        offset = browser->height - 1;
+                        offset = browser->rows - 1;
                         if (offset >= browser->nr_entries)
                                 offset = browser->nr_entries - 1;
 
@@ -462,7 +465,7 @@ unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
                 if (!browser->filter || !browser->filter(browser, pos)) {
                         ui_browser__gotorc(browser, row, 0);
                         browser->write(browser, pos, row);
-                        if (++row == browser->height)
+                        if (++row == browser->rows)
                                 break;
                 }
         }
@@ -587,7 +590,7 @@ unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
                 if (!browser->filter || !browser->filter(browser, *pos)) {
                         ui_browser__gotorc(browser, row, 0);
                         browser->write(browser, pos, row);
-                        if (++row == browser->height)
+                        if (++row == browser->rows)
                                 break;
                 }
 
@@ -623,7 +626,7 @@ static void __ui_browser__line_arrow_up(struct ui_browser *browser,
 
         SLsmg_set_char_set(1);
 
-        if (start < browser->top_idx + browser->height) {
+        if (start < browser->top_idx + browser->rows) {
                 row = start - browser->top_idx;
                 ui_browser__gotorc(browser, row, column);
                 SLsmg_write_char(SLSMG_LLCORN_CHAR);
@@ -633,7 +636,7 @@ static void __ui_browser__line_arrow_up(struct ui_browser *browser,
                 if (row-- == 0)
                         goto out;
         } else
-                row = browser->height - 1;
+                row = browser->rows - 1;
 
         if (end > browser->top_idx)
                 end_row = end - browser->top_idx;
@@ -675,8 +678,8 @@ static void __ui_browser__line_arrow_down(struct ui_browser *browser,
         } else
                 row = 0;
 
-        if (end >= browser->top_idx + browser->height)
-                end_row = browser->height - 1;
+        if (end >= browser->top_idx + browser->rows)
+                end_row = browser->rows - 1;
         else
                 end_row = end - browser->top_idx;
 
@@ -684,7 +687,7 @@ static void __ui_browser__line_arrow_down(struct ui_browser *browser,
         SLsmg_draw_vline(end_row - row + 1);
 
         ui_browser__gotorc(browser, end_row, column);
-        if (end < browser->top_idx + browser->height) {
+        if (end < browser->top_idx + browser->rows) {
                 SLsmg_write_char(SLSMG_LLCORN_CHAR);
                 ui_browser__gotorc(browser, end_row, column + 1);
                 SLsmg_write_char(SLSMG_HLINE_CHAR);
diff --git a/tools/perf/ui/browser.h b/tools/perf/ui/browser.h
index 03d4d6295f10..92ae72113965 100644
--- a/tools/perf/ui/browser.h
+++ b/tools/perf/ui/browser.h
@@ -14,11 +14,12 @@
 struct ui_browser {
         u64           index, top_idx;
         void          *top, *entries;
-        u16           y, x, width, height;
+        u16           y, x, width, height, rows;
         int           current_color;
         void          *priv;
         const char    *title;
         char          *helpline;
+        void          (*refresh_dimensions)(struct ui_browser *browser);
         unsigned int  (*refresh)(struct ui_browser *browser);
         void          (*write)(struct ui_browser *browser, void *entry, int row);
         void          (*seek)(struct ui_browser *browser, off_t offset, int whence);
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 04a229aa5c0f..a94b11fc5e00 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -26,6 +26,7 @@ struct hist_browser {
         struct map_symbol   *selection;
         int                  print_seq;
         bool                 show_dso;
+        bool                 show_headers;
         float                min_pcnt;
         u64                  nr_non_filtered_entries;
         u64                  nr_callchain_rows;
@@ -33,8 +34,7 @@ struct hist_browser {
 
 extern void hist_browser__init_hpp(void);
 
-static int hists__browser_title(struct hists *hists, char *bf, size_t size,
-                                const char *ev_name);
+static int hists__browser_title(struct hists *hists, char *bf, size_t size);
 static void hist_browser__update_nr_entries(struct hist_browser *hb);
 
 static struct rb_node *hists__filter_entries(struct rb_node *nd,
@@ -57,11 +57,42 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb)
         return nr_entries + hb->nr_callchain_rows;
 }
 
-static void hist_browser__refresh_dimensions(struct hist_browser *browser)
+static void hist_browser__update_rows(struct hist_browser *hb)
 {
+        struct ui_browser *browser = &hb->b;
+        u16 header_offset = hb->show_headers ? 1 : 0, index_row;
+
+        browser->rows = browser->height - header_offset;
+        /*
+         * Verify if we were at the last line and that line isn't
+         * visibe because we now show the header line(s).
+         */
+        index_row = browser->index - browser->top_idx;
+        if (index_row >= browser->rows)
+                browser->index -= index_row - browser->rows + 1;
+}
+
+static void hist_browser__refresh_dimensions(struct ui_browser *browser)
+{
+        struct hist_browser *hb = container_of(browser, struct hist_browser, b);
+
         /* 3 == +/- toggle symbol before actual hist_entry rendering */
-        browser->b.width = 3 + (hists__sort_list_width(browser->hists) +
-                             sizeof("[k]"));
+        browser->width = 3 + (hists__sort_list_width(hb->hists) + sizeof("[k]"));
+        /*
+         * FIXME: Just keeping existing behaviour, but this really should be
+         *        before updating browser->width, as it will invalidate the
+         *        calculation above. Fix this and the fallout in another
+         *        changeset.
+         */
+        ui_browser__refresh_dimensions(browser);
+        hist_browser__update_rows(hb);
+}
+
+static void hist_browser__gotorc(struct hist_browser *browser, int row, int column)
+{
+        u16 header_offset = browser->show_headers ? 1 : 0;
+
+        ui_browser__gotorc(&browser->b, row + header_offset, column);
 }
 
 static void hist_browser__reset(struct hist_browser *browser)
@@ -74,7 +105,7 @@ static void hist_browser__reset(struct hist_browser *browser)
 
         hist_browser__update_nr_entries(browser);
         browser->b.nr_entries = hist_browser__nr_entries(browser);
-        hist_browser__refresh_dimensions(browser);
+        hist_browser__refresh_dimensions(&browser->b);
         ui_browser__reset_index(&browser->b);
 }
 
@@ -346,7 +377,7 @@ static void ui_browser__warn_lost_events(struct ui_browser *browser)
                 "Or reduce the sampling frequency.");
 }
 
-static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
+static int hist_browser__run(struct hist_browser *browser,
                              struct hist_browser_timer *hbt)
 {
         int key;
@@ -356,8 +387,7 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
         browser->b.entries = &browser->hists->entries;
         browser->b.nr_entries = hist_browser__nr_entries(browser);
 
-        hist_browser__refresh_dimensions(browser);
-        hists__browser_title(browser->hists, title, sizeof(title), ev_name);
+        hists__browser_title(browser->hists, title, sizeof(title));
 
         if (ui_browser__show(&browser->b, title,
                              "Press '?' for help on key bindings") < 0)
@@ -384,7 +414,7 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                                 ui_browser__warn_lost_events(&browser->b);
                         }
 
-                        hists__browser_title(browser->hists, title, sizeof(title), ev_name);
+                        hists__browser_title(browser->hists, title, sizeof(title));
                         ui_browser__show_title(&browser->b, title);
                         continue;
                 }
@@ -393,10 +423,10 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                         struct hist_entry *h = rb_entry(browser->b.top,
                                                         struct hist_entry, rb_node);
                         ui_helpline__pop();
-                        ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
+                        ui_helpline__fpush("%d: nr_ent=(%d,%d), rows=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
                                            seq++, browser->b.nr_entries,
                                            browser->hists->nr_entries,
-                                           browser->b.height,
+                                           browser->b.rows,
                                            browser->b.index,
                                            browser->b.top_idx,
                                            h->row_offset, h->nr_rows);
@@ -410,6 +440,10 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                         /* Expand the whole world. */
                         hist_browser__set_folding(browser, true);
                         break;
+                case 'H':
+                        browser->show_headers = !browser->show_headers;
+                        hist_browser__update_rows(browser);
+                        break;
                 case K_ENTER:
                         if (hist_browser__toggle_fold(browser))
                                 break;
@@ -509,13 +543,13 @@ static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browse
                         }
 
                         ui_browser__set_color(&browser->b, color);
-                        ui_browser__gotorc(&browser->b, row, 0);
+                        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.height)
+                        if (++row == browser->b.rows)
                                 goto out;
 do_next:
                         if (folded_sign == '+')
@@ -528,7 +562,7 @@ do_next:
                                                                          new_level, row, row_offset,
                                                                          is_current_entry);
                 }
-                if (row == browser->b.height)
+                if (row == browser->b.rows)
                         goto out;
                 node = next;
         }
@@ -568,13 +602,13 @@ static int hist_browser__show_callchain_node(struct hist_browser *browser,
 
                 s = callchain_list__sym_name(chain, bf, sizeof(bf),
                                              browser->show_dso);
-                ui_browser__gotorc(&browser->b, row, 0);
+                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.height)
+                if (++row == browser->b.rows)
                         goto out;
         }
 
@@ -603,7 +637,7 @@ static int hist_browser__show_callchain(struct hist_browser *browser,
                 row += hist_browser__show_callchain_node(browser, node, level,
                                                          row, row_offset,
                                                          is_current_entry);
-                if (row == browser->b.height)
+                if (row == browser->b.rows)
                         break;
         }
 
@@ -733,7 +767,7 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                         .ptr            = &arg,
                 };
 
-                ui_browser__gotorc(&browser->b, row, 0);
+                hist_browser__gotorc(browser, row, 0);
 
                 perf_hpp__for_each_format(fmt) {
                         if (perf_hpp__should_skip(fmt))
@@ -777,7 +811,7 @@ static int hist_browser__show_entry(struct hist_browser *browser,
         } else
                 --row_offset;
 
-        if (folded_sign == '-' && row != browser->b.height) {
+        if (folded_sign == '-' && row != browser->b.rows) {
                 printed += hist_browser__show_callchain(browser, &entry->sorted_chain,
                                                         1, row, &row_offset,
                                                         &current_entry);
@@ -788,6 +822,56 @@ static int hist_browser__show_entry(struct hist_browser *browser,
         return printed;
 }
 
+static int advance_hpp_check(struct perf_hpp *hpp, int inc)
+{
+        advance_hpp(hpp, inc);
+        return hpp->size <= 0;
+}
+
+static int hists__scnprintf_headers(char *buf, size_t size, struct hists *hists)
+{
+        struct perf_hpp dummy_hpp = {
+                .buf    = buf,
+                .size   = size,
+        };
+        struct perf_hpp_fmt *fmt;
+        size_t ret = 0;
+
+        if (symbol_conf.use_callchain) {
+                ret = scnprintf(buf, size, "  ");
+                if (advance_hpp_check(&dummy_hpp, ret))
+                        return ret;
+        }
+
+        perf_hpp__for_each_format(fmt) {
+                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;
+
+                ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
+                if (advance_hpp_check(&dummy_hpp, ret))
+                        break;
+        }
+
+        return ret;
+}
+
+static void hist_browser__show_headers(struct hist_browser *browser)
+{
+        char headers[1024];
+
+        hists__scnprintf_headers(headers, sizeof(headers), browser->hists);
+        ui_browser__gotorc(&browser->b, 0, 0);
+        ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
+        slsmg_write_nstring(headers, browser->b.width + 1);
+}
+
 static void ui_browser__hists_init_top(struct ui_browser *browser)
 {
         if (browser->top == NULL) {
@@ -801,9 +885,15 @@ static void ui_browser__hists_init_top(struct ui_browser *browser)
 static unsigned int hist_browser__refresh(struct ui_browser *browser)
 {
         unsigned row = 0;
+        u16 header_offset = 0;
         struct rb_node *nd;
         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
 
+        if (hb->show_headers) {
+                hist_browser__show_headers(hb);
+                header_offset = 1;
+        }
+
         ui_browser__hists_init_top(browser);
 
         for (nd = browser->top; nd; nd = rb_next(nd)) {
@@ -818,11 +908,11 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
                         continue;
 
                 row += hist_browser__show_entry(hb, h, row);
-                if (row == browser->height)
+                if (row == browser->rows)
                         break;
         }
 
-        return row;
+        return row + header_offset;
 }
 
 static struct rb_node *hists__filter_entries(struct rb_node *nd,
@@ -1191,8 +1281,10 @@ static struct hist_browser *hist_browser__new(struct hists *hists)
         if (browser) {
                 browser->hists = hists;
                 browser->b.refresh = hist_browser__refresh;
+                browser->b.refresh_dimensions = hist_browser__refresh_dimensions;
                 browser->b.seek = ui_browser__hists_seek;
                 browser->b.use_navkeypressed = true;
+                browser->show_headers = symbol_conf.show_hist_headers;
         }
 
         return browser;
@@ -1213,8 +1305,7 @@ static struct thread *hist_browser__selected_thread(struct hist_browser *browser
         return browser->he_selection->thread;
 }
 
-static int hists__browser_title(struct hists *hists, char *bf, size_t size,
-                                const char *ev_name)
+static int hists__browser_title(struct hists *hists, char *bf, size_t size)
 {
         char unit;
         int printed;
@@ -1223,6 +1314,7 @@ static int hists__browser_title(struct hists *hists, char *bf, size_t size,
         unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
         u64 nr_events = hists->stats.total_period;
         struct perf_evsel *evsel = hists_to_evsel(hists);
+        const char *ev_name = perf_evsel__name(evsel);
         char buf[512];
         size_t buflen = sizeof(buf);
 
@@ -1390,7 +1482,7 @@ static void hist_browser__update_nr_entries(struct hist_browser *hb)
 }
 
 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
-                                    const char *helpline, const char *ev_name,
+                                    const char *helpline,
                                     bool left_exits,
                                     struct hist_browser_timer *hbt,
                                     float min_pcnt,
@@ -1422,6 +1514,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         "d             Zoom into current DSO\n"                         \
         "E             Expand all callchains\n"                         \
         "F             Toggle percentage of filtered entries\n"         \
+        "H             Display column headers\n"                        \
 
         /* help messages are sorted by lexical order of the hotkey */
         const char report_help[] = HIST_BROWSER_HELP_COMMON
@@ -1465,7 +1558,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 
                 nr_options = 0;
 
-                key = hist_browser__run(browser, ev_name, hbt);
+                key = hist_browser__run(browser, hbt);
 
                 if (browser->he_selection != NULL) {
                         thread = hist_browser__selected_thread(browser);
@@ -1843,7 +1936,7 @@ static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
 {
         struct perf_evlist *evlist = menu->b.priv;
         struct perf_evsel *pos;
-        const char *ev_name, *title = "Available samples";
+        const char *title = "Available samples";
         int delay_secs = hbt ? hbt->refresh : 0;
         int key;
 
@@ -1876,9 +1969,8 @@ browse_hists:
                          */
                         if (hbt)
                                 hbt->timer(hbt->arg);
-                        ev_name = perf_evsel__name(pos);
                         key = perf_evsel__hists_browse(pos, nr_events, help,
-                                                       ev_name, true, hbt,
+                                                       true, hbt,
                                                        menu->min_pcnt,
                                                        menu->env);
                         ui_browser__show_title(&menu->b, title);
@@ -1982,10 +2074,9 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
 single_entry:
         if (nr_entries == 1) {
                 struct perf_evsel *first = perf_evlist__first(evlist);
-                const char *ev_name = perf_evsel__name(first);
 
                 return perf_evsel__hists_browse(first, nr_entries, help,
-                                                ev_name, false, hbt, min_pcnt,
+                                                false, hbt, min_pcnt,
                                                 env);
         }
 
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index 90122abd3721..40af0acb4fe9 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -479,7 +479,7 @@ print_entries:
 
                 if (h->ms.map == NULL && verbose > 1) {
                         __map_groups__fprintf_maps(h->thread->mg,
-                                                   MAP__FUNCTION, verbose, fp);
+                                                   MAP__FUNCTION, fp);
                         fprintf(fp, "%.10s end\n", graph_dotted_line);
                 }
         }
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 48b6d3f50012..437ee09727e6 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -626,7 +626,7 @@ int sample__resolve_callchain(struct perf_sample *sample, struct symbol **parent
 
 int hist_entry__append_callchain(struct hist_entry *he, struct perf_sample *sample)
 {
-        if (!symbol_conf.use_callchain)
+        if (!symbol_conf.use_callchain || sample->callchain == NULL)
                 return 0;
         return callchain_append(he->callchain, &callchain_cursor, sample->period);
 }
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 8f84423a75da..da43619d6173 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -176,4 +176,17 @@ static inline void callchain_cursor_snapshot(struct callchain_cursor *dest,
         dest->first = src->curr;
         dest->nr -= src->pos;
 }
+
+#ifdef HAVE_SKIP_CALLCHAIN_IDX
+extern int arch_skip_callchain_idx(struct machine *machine,
+                        struct thread *thread, struct ip_callchain *chain);
+#else
+static inline int arch_skip_callchain_idx(struct machine *machine __maybe_unused,
+                        struct thread *thread __maybe_unused,
+                        struct ip_callchain *chain __maybe_unused)
+{
+        return -1;
+}
+#endif
+
 #endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/cloexec.c b/tools/perf/util/cloexec.c
new file mode 100644
index 000000000000..c5d05ec17220
--- /dev/null
+++ b/tools/perf/util/cloexec.c
@@ -0,0 +1,57 @@
+#include "util.h"
+#include "../perf.h"
+#include "cloexec.h"
+#include "asm/bug.h"
+
+static unsigned long flag = PERF_FLAG_FD_CLOEXEC;
+
+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,
+                .config = PERF_COUNT_SW_CPU_CLOCK,
+        };
+        int fd;
+        int err;
+
+        /* check cloexec flag */
+        fd = sys_perf_event_open(&attr, 0, -1, -1,
+                                 PERF_FLAG_FD_CLOEXEC);
+        err = errno;
+
+        if (fd >= 0) {
+                close(fd);
+                return 1;
+        }
+
+        WARN_ONCE(err != EINVAL,
+                  "perf_event_open(..., PERF_FLAG_FD_CLOEXEC) failed with unexpected error %d (%s)\n",
+                  err, strerror(err));
+
+        /* not supported, confirm error related to PERF_FLAG_FD_CLOEXEC */
+        fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
+        err = errno;
+
+        if (WARN_ONCE(fd < 0,
+                      "perf_event_open(..., 0) failed unexpectedly with error %d (%s)\n",
+                      err, strerror(err)))
+                return -1;
+
+        close(fd);
+
+        return 0;
+}
+
+unsigned long perf_event_open_cloexec_flag(void)
+{
+        static bool probed;
+
+        if (!probed) {
+                if (perf_flag_probe() <= 0)
+                        flag = 0;
+                probed = true;
+        }
+
+        return flag;
+}
diff --git a/tools/perf/util/cloexec.h b/tools/perf/util/cloexec.h
new file mode 100644
index 000000000000..94a5a7d829d5
--- /dev/null
+++ b/tools/perf/util/cloexec.h
@@ -0,0 +1,6 @@
+#ifndef __PERF_CLOEXEC_H
+#define __PERF_CLOEXEC_H
+
+unsigned long perf_event_open_cloexec_flag(void);
+
+#endif /* __PERF_CLOEXEC_H */
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 24519e14ac56..1e5e2e5af6b1 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -350,6 +350,16 @@ static int perf_default_core_config(const char *var __maybe_unused,
         return 0;
 }
 
+static int perf_ui_config(const char *var, const char *value)
+{
+        /* Add other config variables here. */
+        if (!strcmp(var, "ui.show-headers")) {
+                symbol_conf.show_hist_headers = perf_config_bool(var, value);
+                return 0;
+        }
+        return 0;
+}
+
 int perf_default_config(const char *var, const char *value,
                         void *dummy __maybe_unused)
 {
@@ -359,6 +369,9 @@ int perf_default_config(const char *var, const char *value,
         if (!prefixcmp(var, "hist."))
                 return perf_hist_config(var, value);
 
+        if (!prefixcmp(var, "ui."))
+                return perf_ui_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 55de44ecebef..29d720cf5844 100644
--- a/tools/perf/util/data.c
+++ b/tools/perf/util/data.c
@@ -7,6 +7,7 @@
 
 #include "data.h"
 #include "util.h"
+#include "debug.h"
 
 static bool check_pipe(struct perf_data_file *file)
 {
@@ -65,7 +66,7 @@ static int open_file_read(struct perf_data_file *file)
                 goto out_close;
 
         if (!file->force && st.st_uid && (st.st_uid != geteuid())) {
-                pr_err("file %s not owned by current user or root\n",
+                pr_err("File %s not owned by current user or root (use -f to override)\n",
                        file->path);
                 goto out_close;
         }
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 299b55586502..71d419362634 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -16,11 +16,11 @@
 int verbose;
 bool dump_trace = false, quiet = false;
 
-static int _eprintf(int level, const char *fmt, va_list args)
+static int _eprintf(int level, int var, const char *fmt, va_list args)
 {
         int ret = 0;
 
-        if (verbose >= level) {
+        if (var >= level) {
                 if (use_browser >= 1)
                         ui_helpline__vshow(fmt, args);
                 else
@@ -30,13 +30,13 @@ static int _eprintf(int level, const char *fmt, va_list args)
         return ret;
 }
 
-int eprintf(int level, const char *fmt, ...)
+int eprintf(int level, int var, const char *fmt, ...)
 {
         va_list args;
         int ret;
 
         va_start(args, fmt);
-        ret = _eprintf(level, fmt, args);
+        ret = _eprintf(level, var, fmt, args);
         va_end(args);
 
         return ret;
@@ -51,9 +51,9 @@ void pr_stat(const char *fmt, ...)
         va_list args;
 
         va_start(args, fmt);
-        _eprintf(1, fmt, args);
+        _eprintf(1, verbose, fmt, args);
         va_end(args);
-        eprintf(1, "\n");
+        eprintf(1, verbose, "\n");
 }
 
 int dump_printf(const char *fmt, ...)
@@ -105,3 +105,47 @@ void trace_event(union perf_event *event)
         }
         printf(".\n");
 }
+
+static struct debug_variable {
+        const char *name;
+        int *ptr;
+} debug_variables[] = {
+        { .name = "verbose", .ptr = &verbose },
+        { .name = NULL, }
+};
+
+int perf_debug_option(const char *str)
+{
+        struct debug_variable *var = &debug_variables[0];
+        char *vstr, *s = strdup(str);
+        int v = 1;
+
+        vstr = strchr(s, '=');
+        if (vstr)
+                *vstr++ = 0;
+
+        while (var->name) {
+                if (!strcmp(s, var->name))
+                        break;
+                var++;
+        }
+
+        if (!var->name) {
+                pr_err("Unknown debug variable name '%s'\n", s);
+                free(s);
+                return -1;
+        }
+
+        if (vstr) {
+                v = atoi(vstr);
+                /*
+                 * Allow only values in range (0, 10),
+                 * otherwise set 0.
+                 */
+                v = (v < 0) || (v > 10) ? 0 : v;
+        }
+
+        *var->ptr = v;
+        free(s);
+        return 0;
+}
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 443694c36b03..89fb6b0f7ab2 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -11,6 +11,24 @@
 extern int verbose;
 extern bool quiet, dump_trace;
 
+#ifndef pr_fmt
+#define pr_fmt(fmt) fmt
+#endif
+
+#define pr_err(fmt, ...) \
+        eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_warning(fmt, ...) \
+        eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_info(fmt, ...) \
+        eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug(fmt, ...) \
+        eprintf(1, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debugN(n, fmt, ...) \
+        eprintf(n, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
+
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(union perf_event *event);
 
@@ -19,4 +37,8 @@ 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 perf_debug_option(const char *str);
+
 #endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index 819f10414f08..90d02c661dd4 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -216,7 +216,7 @@ static int open_dso(struct dso *dso, struct machine *machine)
 {
         int fd = __open_dso(dso, machine);
 
-        if (fd > 0) {
+        if (fd >= 0) {
                 dso__list_add(dso);
                 /*
                  * Check if we crossed the allowed number
@@ -331,26 +331,44 @@ int dso__data_fd(struct dso *dso, struct machine *machine)
         };
         int i = 0;
 
+        if (dso->data.status == DSO_DATA_STATUS_ERROR)
+                return -1;
+
         if (dso->data.fd >= 0)
-                return dso->data.fd;
+                goto out;
 
         if (dso->binary_type != DSO_BINARY_TYPE__NOT_FOUND) {
                 dso->data.fd = open_dso(dso, machine);
-                return dso->data.fd;
+                goto out;
         }
 
         do {
-                int fd;
-
                 dso->binary_type = binary_type_data[i++];
 
-                fd = open_dso(dso, machine);
-                if (fd >= 0)
-                        return dso->data.fd = fd;
+                dso->data.fd = open_dso(dso, machine);
+                if (dso->data.fd >= 0)
+                        goto out;
 
         } while (dso->binary_type != DSO_BINARY_TYPE__NOT_FOUND);
+out:
+        if (dso->data.fd >= 0)
+                dso->data.status = DSO_DATA_STATUS_OK;
+        else
+                dso->data.status = DSO_DATA_STATUS_ERROR;
 
-        return -EINVAL;
+        return dso->data.fd;
+}
+
+bool dso__data_status_seen(struct dso *dso, enum dso_data_status_seen by)
+{
+        u32 flag = 1 << by;
+
+        if (dso->data.status_seen & flag)
+                return true;
+
+        dso->data.status_seen |= flag;
+
+        return false;
 }
 
 static void
@@ -526,6 +544,28 @@ static int data_file_size(struct dso *dso)
         return 0;
 }
 
+/**
+ * dso__data_size - Return dso data size
+ * @dso: dso object
+ * @machine: machine object
+ *
+ * Return: dso data size
+ */
+off_t dso__data_size(struct dso *dso, struct machine *machine)
+{
+        int fd;
+
+        fd = dso__data_fd(dso, machine);
+        if (fd < 0)
+                return fd;
+
+        if (data_file_size(dso))
+                return -1;
+
+        /* For now just estimate dso data size is close to file size */
+        return dso->data.file_size;
+}
+
 static ssize_t data_read_offset(struct dso *dso, u64 offset,
                                 u8 *data, ssize_t size)
 {
@@ -701,8 +741,10 @@ struct dso *dso__new(const char *name)
                         dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
                 dso->data.cache = RB_ROOT;
                 dso->data.fd = -1;
+                dso->data.status = DSO_DATA_STATUS_UNKNOWN;
                 dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND;
                 dso->binary_type = DSO_BINARY_TYPE__NOT_FOUND;
+                dso->is_64_bit = (sizeof(void *) == 8);
                 dso->loaded = 0;
                 dso->rel = 0;
                 dso->sorted_by_name = 0;
@@ -898,3 +940,14 @@ size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
 
         return ret;
 }
+
+enum dso_type dso__type(struct dso *dso, struct machine *machine)
+{
+        int fd;
+
+        fd = dso__data_fd(dso, machine);
+        if (fd < 0)
+                return DSO__TYPE_UNKNOWN;
+
+        return dso__type_fd(fd);
+}
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index ad553ba257bf..5e463c0964d4 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -5,6 +5,7 @@
 #include <linux/rbtree.h>
 #include <stdbool.h>
 #include <linux/types.h>
+#include <linux/bitops.h>
 #include "map.h"
 #include "build-id.h"
 
@@ -40,6 +41,23 @@ enum dso_swap_type {
         DSO_SWAP__YES,
 };
 
+enum dso_data_status {
+        DSO_DATA_STATUS_ERROR   = -1,
+        DSO_DATA_STATUS_UNKNOWN = 0,
+        DSO_DATA_STATUS_OK      = 1,
+};
+
+enum dso_data_status_seen {
+        DSO_DATA_STATUS_SEEN_ITRACE,
+};
+
+enum dso_type {
+        DSO__TYPE_UNKNOWN,
+        DSO__TYPE_64BIT,
+        DSO__TYPE_32BIT,
+        DSO__TYPE_X32BIT,
+};
+
 #define DSO__SWAP(dso, type, val)                       \
 ({                                                      \
         type ____r = val;                               \
@@ -90,6 +108,7 @@ struct dso {
         u8               annotate_warned:1;
         u8               short_name_allocated:1;
         u8               long_name_allocated:1;
+        u8               is_64_bit:1;
         u8               sorted_by_name;
         u8               loaded;
         u8               rel;
@@ -103,6 +122,8 @@ struct dso {
         struct {
                 struct rb_root   cache;
                 int              fd;
+                int              status;
+                u32              status_seen;
                 size_t           file_size;
                 struct list_head open_entry;
         } data;
@@ -153,6 +174,7 @@ int dso__read_binary_type_filename(const struct dso *dso, enum dso_binary_type t
  * The dso__data_* external interface provides following functions:
  *   dso__data_fd
  *   dso__data_close
+ *   dso__data_size
  *   dso__data_read_offset
  *   dso__data_read_addr
  *
@@ -190,11 +212,13 @@ int dso__read_binary_type_filename(const struct dso *dso, enum dso_binary_type t
 int dso__data_fd(struct dso *dso, struct machine *machine);
 void dso__data_close(struct dso *dso);
 
+off_t dso__data_size(struct dso *dso, struct machine *machine);
 ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine,
                               u64 offset, u8 *data, ssize_t size);
 ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
                             struct machine *machine, u64 addr,
                             u8 *data, ssize_t size);
+bool dso__data_status_seen(struct dso *dso, enum dso_data_status_seen by);
 
 struct map *dso__new_map(const char *name);
 struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
@@ -229,4 +253,6 @@ static inline bool dso__is_kcore(struct dso *dso)
 
 void dso__free_a2l(struct dso *dso);
 
+enum dso_type dso__type(struct dso *dso, struct machine *machine);
+
 #endif /* __PERF_DSO */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index d0281bdfa582..1398c83d896d 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -603,7 +603,14 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
 
 size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
 {
-        return fprintf(fp, ": %s:%d\n", event->comm.comm, event->comm.tid);
+        const char *s;
+
+        if (event->header.misc & PERF_RECORD_MISC_COMM_EXEC)
+                s = " exec";
+        else
+                s = "";
+
+        return fprintf(fp, "%s: %s:%d\n", s, event->comm.comm, event->comm.tid);
 }
 
 int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
@@ -781,6 +788,7 @@ try_again:
                     cpumode == PERF_RECORD_MISC_USER &&
                     machine && mg != &machine->kmaps) {
                         mg = &machine->kmaps;
+                        load_map = true;
                         goto try_again;
                 }
         } else {
@@ -866,3 +874,45 @@ int perf_event__preprocess_sample(const union perf_event *event,
 
         return 0;
 }
+
+bool is_bts_event(struct perf_event_attr *attr)
+{
+        return attr->type == PERF_TYPE_HARDWARE &&
+               (attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) &&
+               attr->sample_period == 1;
+}
+
+bool sample_addr_correlates_sym(struct perf_event_attr *attr)
+{
+        if (attr->type == PERF_TYPE_SOFTWARE &&
+            (attr->config == PERF_COUNT_SW_PAGE_FAULTS ||
+             attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
+             attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ))
+                return true;
+
+        if (is_bts_event(attr))
+                return true;
+
+        return false;
+}
+
+void perf_event__preprocess_sample_addr(union perf_event *event,
+                                        struct perf_sample *sample,
+                                        struct machine *machine,
+                                        struct thread *thread,
+                                        struct addr_location *al)
+{
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
+                              sample->addr, al);
+        if (!al->map)
+                thread__find_addr_map(thread, machine, cpumode, MAP__VARIABLE,
+                                      sample->addr, al);
+
+        al->cpu = sample->cpu;
+        al->sym = NULL;
+
+        if (al->map)
+                al->sym = map__find_symbol(al->map, al->addr, NULL);
+}
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index e5dd40addb30..94d6976180da 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -288,6 +288,16 @@ int perf_event__preprocess_sample(const union perf_event *event,
                                   struct addr_location *al,
                                   struct perf_sample *sample);
 
+struct thread;
+
+bool is_bts_event(struct perf_event_attr *attr);
+bool sample_addr_correlates_sym(struct perf_event_attr *attr);
+void perf_event__preprocess_sample_addr(union perf_event *event,
+                                        struct perf_sample *sample,
+                                        struct machine *machine,
+                                        struct thread *thread,
+                                        struct addr_location *al);
+
 const char *perf_event__name(unsigned int id);
 
 size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 59ef2802fcf6..814e954c1318 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -606,12 +606,17 @@ static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
         return evlist->mmap != NULL ? 0 : -ENOMEM;
 }
 
-static int __perf_evlist__mmap(struct perf_evlist *evlist,
-                               int idx, int prot, int mask, int fd)
+struct mmap_params {
+        int prot;
+        int mask;
+};
+
+static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
+                               struct mmap_params *mp, int fd)
 {
         evlist->mmap[idx].prev = 0;
-        evlist->mmap[idx].mask = mask;
-        evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
+        evlist->mmap[idx].mask = mp->mask;
+        evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
                                       MAP_SHARED, fd, 0);
         if (evlist->mmap[idx].base == MAP_FAILED) {
                 pr_debug2("failed to mmap perf event ring buffer, error %d\n",
@@ -625,8 +630,8 @@ static int __perf_evlist__mmap(struct perf_evlist *evlist,
 }
 
 static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
-                                       int prot, int mask, int cpu, int thread,
-                                       int *output)
+                                       struct mmap_params *mp, int cpu,
+                                       int thread, int *output)
 {
         struct perf_evsel *evsel;
 
@@ -635,8 +640,7 @@ static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
 
                 if (*output == -1) {
                         *output = fd;
-                        if (__perf_evlist__mmap(evlist, idx, prot, mask,
-                                                *output) < 0)
+                        if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)
                                 return -1;
                 } else {
                         if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
@@ -651,8 +655,8 @@ static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
         return 0;
 }
 
-static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot,
-                                     int mask)
+static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
+                                     struct mmap_params *mp)
 {
         int cpu, thread;
         int nr_cpus = cpu_map__nr(evlist->cpus);
@@ -663,8 +667,8 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot,
                 int output = -1;
 
                 for (thread = 0; thread < nr_threads; thread++) {
-                        if (perf_evlist__mmap_per_evsel(evlist, cpu, prot, mask,
-                                                        cpu, thread, &output))
+                        if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
+                                                        thread, &output))
                                 goto out_unmap;
                 }
         }
@@ -677,8 +681,8 @@ out_unmap:
         return -1;
 }
 
-static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot,
-                                        int mask)
+static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
+                                        struct mmap_params *mp)
 {
         int thread;
         int nr_threads = thread_map__nr(evlist->threads);
@@ -687,8 +691,8 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot,
         for (thread = 0; thread < nr_threads; thread++) {
                 int output = -1;
 
-                if (perf_evlist__mmap_per_evsel(evlist, thread, prot, mask, 0,
-                                                thread, &output))
+                if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
+                                                &output))
                         goto out_unmap;
         }
 
@@ -793,7 +797,9 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         struct perf_evsel *evsel;
         const struct cpu_map *cpus = evlist->cpus;
         const struct thread_map *threads = evlist->threads;
-        int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), mask;
+        struct mmap_params mp = {
+                .prot = PROT_READ | (overwrite ? 0 : PROT_WRITE),
+        };
 
         if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
                 return -ENOMEM;
@@ -804,7 +810,7 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         evlist->overwrite = overwrite;
         evlist->mmap_len = perf_evlist__mmap_size(pages);
         pr_debug("mmap size %zuB\n", evlist->mmap_len);
-        mask = evlist->mmap_len - page_size - 1;
+        mp.mask = evlist->mmap_len - page_size - 1;
 
         evlist__for_each(evlist, evsel) {
                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
@@ -814,9 +820,9 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         }
 
         if (cpu_map__empty(cpus))
-                return perf_evlist__mmap_per_thread(evlist, prot, mask);
+                return perf_evlist__mmap_per_thread(evlist, &mp);
 
-        return perf_evlist__mmap_per_cpu(evlist, prot, mask);
+        return perf_evlist__mmap_per_cpu(evlist, &mp);
 }
 
 int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
@@ -1214,10 +1220,11 @@ int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
                                              "For your workloads it needs to be <= 1\nHint:\t");
                 }
                 printed += scnprintf(buf + printed, size - printed,
-                                     "For system wide tracing it needs to be set to -1");
+                                     "For system wide tracing it needs to be set to -1.\n");
 
                 printed += scnprintf(buf + printed, size - printed,
-                                    ".\nHint:\tThe current value is %d.", value);
+                                    "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
+                                    "Hint:\tThe current value is %d.", value);
                 break;
         default:
                 scnprintf(buf, size, "%s", emsg);
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 8606175fe1e8..21a373ebea22 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -29,6 +29,7 @@ static struct {
         bool sample_id_all;
         bool exclude_guest;
         bool mmap2;
+        bool cloexec;
 } perf_missing_features;
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
@@ -623,7 +624,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
                 attr->mmap_data = track;
         }
 
-        if (opts->call_graph_enabled)
+        if (opts->call_graph_enabled && !evsel->no_aux_samples)
                 perf_evsel__config_callgraph(evsel, opts);
 
         if (target__has_cpu(&opts->target))
@@ -637,7 +638,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
              target__has_cpu(&opts->target) || per_cpu))
                 perf_evsel__set_sample_bit(evsel, TIME);
 
-        if (opts->raw_samples) {
+        if (opts->raw_samples && !evsel->no_aux_samples) {
                 perf_evsel__set_sample_bit(evsel, TIME);
                 perf_evsel__set_sample_bit(evsel, RAW);
                 perf_evsel__set_sample_bit(evsel, CPU);
@@ -650,7 +651,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
                 attr->watermark = 0;
                 attr->wakeup_events = 1;
         }
-        if (opts->branch_stack) {
+        if (opts->branch_stack && !evsel->no_aux_samples) {
                 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
                 attr->branch_sample_type = opts->branch_stack;
         }
@@ -681,6 +682,11 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
         if (target__none(&opts->target) && perf_evsel__is_group_leader(evsel) &&
                 !opts->initial_delay)
                 attr->enable_on_exec = 1;
+
+        if (evsel->immediate) {
+                attr->disabled = 0;
+                attr->enable_on_exec = 0;
+        }
 }
 
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
@@ -960,6 +966,7 @@ static size_t perf_event_attr__fprintf(struct perf_event_attr *attr, FILE *fp)
         ret += PRINT_ATTR2(exclude_user, exclude_kernel);
         ret += PRINT_ATTR2(exclude_hv, exclude_idle);
         ret += PRINT_ATTR2(mmap, comm);
+        ret += PRINT_ATTR2(mmap2, comm_exec);
         ret += PRINT_ATTR2(freq, inherit_stat);
         ret += PRINT_ATTR2(enable_on_exec, task);
         ret += PRINT_ATTR2(watermark, precise_ip);
@@ -967,7 +974,6 @@ static size_t perf_event_attr__fprintf(struct perf_event_attr *attr, FILE *fp)
         ret += PRINT_ATTR2(exclude_host, exclude_guest);
         ret += PRINT_ATTR2N("excl.callchain_kern", exclude_callchain_kernel,
                             "excl.callchain_user", exclude_callchain_user);
-        ret += PRINT_ATTR_U32(mmap2);
 
         ret += PRINT_ATTR_U32(wakeup_events);
         ret += PRINT_ATTR_U32(wakeup_watermark);
@@ -989,7 +995,7 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                               struct thread_map *threads)
 {
         int cpu, thread;
-        unsigned long flags = 0;
+        unsigned long flags = PERF_FLAG_FD_CLOEXEC;
         int pid = -1, err;
         enum { NO_CHANGE, SET_TO_MAX, INCREASED_MAX } set_rlimit = NO_CHANGE;
 
@@ -998,11 +1004,13 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                 return -ENOMEM;
 
         if (evsel->cgrp) {
-                flags = PERF_FLAG_PID_CGROUP;
+                flags |= PERF_FLAG_PID_CGROUP;
                 pid = evsel->cgrp->fd;
         }
 
 fallback_missing_features:
+        if (perf_missing_features.cloexec)
+                flags &= ~(unsigned long)PERF_FLAG_FD_CLOEXEC;
         if (perf_missing_features.mmap2)
                 evsel->attr.mmap2 = 0;
         if (perf_missing_features.exclude_guest)
@@ -1071,7 +1079,10 @@ try_fallback:
         if (err != -EINVAL || cpu > 0 || thread > 0)
                 goto out_close;
 
-        if (!perf_missing_features.mmap2 && evsel->attr.mmap2) {
+        if (!perf_missing_features.cloexec && (flags & PERF_FLAG_FD_CLOEXEC)) {
+                perf_missing_features.cloexec = true;
+                goto fallback_missing_features;
+        } else if (!perf_missing_features.mmap2 && evsel->attr.mmap2) {
                 perf_missing_features.mmap2 = true;
                 goto fallback_missing_features;
         } else if (!perf_missing_features.exclude_guest &&
@@ -1940,6 +1951,7 @@ int perf_evsel__fprintf(struct perf_evsel *evsel,
                 if_print(mmap);
                 if_print(mmap2);
                 if_print(comm);
+                if_print(comm_exec);
                 if_print(freq);
                 if_print(inherit_stat);
                 if_print(enable_on_exec);
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index a52e9a5bb2d0..d7f93ce0ebc1 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -83,6 +83,8 @@ struct perf_evsel {
         int                     is_pos;
         bool                    supported;
         bool                    needs_swap;
+        bool                    no_aux_samples;
+        bool                    immediate;
         /* parse modifier helper */
         int                     exclude_GH;
         int                     nr_members;
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 893f8e2df928..158c787ce0c4 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -200,6 +200,47 @@ static int write_buildid(const char *name, size_t name_len, u8 *build_id,
         return write_padded(fd, name, name_len + 1, len);
 }
 
+static int __dsos__hit_all(struct list_head *head)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, head, node)
+                pos->hit = true;
+
+        return 0;
+}
+
+static int machine__hit_all_dsos(struct machine *machine)
+{
+        int err;
+
+        err = __dsos__hit_all(&machine->kernel_dsos);
+        if (err)
+                return err;
+
+        return __dsos__hit_all(&machine->user_dsos);
+}
+
+int dsos__hit_all(struct perf_session *session)
+{
+        struct rb_node *nd;
+        int err;
+
+        err = machine__hit_all_dsos(&session->machines.host);
+        if (err)
+                return err;
+
+        for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+
+                err = machine__hit_all_dsos(pos);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
 static int __dsos__write_buildid_table(struct list_head *head,
                                        struct machine *machine,
                                        pid_t pid, u16 misc, int fd)
@@ -215,9 +256,9 @@ static int __dsos__write_buildid_table(struct list_head *head,
                 if (!pos->hit)
                         continue;
 
-                if (is_vdso_map(pos->short_name)) {
-                        name = (char *) VDSO__MAP_NAME;
-                        name_len = sizeof(VDSO__MAP_NAME) + 1;
+                if (dso__is_vdso(pos)) {
+                        name = pos->short_name;
+                        name_len = pos->short_name_len + 1;
                 } else if (dso__is_kcore(pos)) {
                         machine__mmap_name(machine, nm, sizeof(nm));
                         name = nm;
@@ -298,7 +339,7 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
 
         len = scnprintf(filename, size, "%s%s%s",
                        debugdir, slash ? "/" : "",
-                       is_vdso ? VDSO__MAP_NAME : realname);
+                       is_vdso ? DSO__NAME_VDSO : realname);
         if (mkdir_p(filename, 0755))
                 goto out_free;
 
@@ -386,7 +427,7 @@ static int dso__cache_build_id(struct dso *dso, struct machine *machine,
                                const char *debugdir)
 {
         bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
-        bool is_vdso = is_vdso_map(dso->short_name);
+        bool is_vdso = dso__is_vdso(dso);
         const char *name = dso->long_name;
         char nm[PATH_MAX];
 
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index d08cfe499404..8f5cbaea64a5 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -151,6 +151,8 @@ int perf_event__process_build_id(struct perf_tool *tool,
                                  struct perf_session *session);
 bool is_perf_magic(u64 magic);
 
+int dsos__hit_all(struct perf_session *session);
+
 /*
  * arch specific callback
  */
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index 9844c31b7c2b..09e8e7aea7c6 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -94,27 +94,6 @@ static inline int scnprintf(char * buf, size_t size, const char * fmt, ...)
         return (i >= ssize) ? (ssize - 1) : i;
 }
 
-int eprintf(int level,
-            const char *fmt, ...) __attribute__((format(printf, 2, 3)));
-
-#ifndef pr_fmt
-#define pr_fmt(fmt) fmt
-#endif
-
-#define pr_err(fmt, ...) \
-        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_warning(fmt, ...) \
-        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_info(fmt, ...) \
-        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_debug(fmt, ...) \
-        eprintf(1, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_debugN(n, fmt, ...) \
-        eprintf(n, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
-
 /*
  * This looks more complex than it should be. But we need to
  * get the type for the ~ right in round_down (it needs to be
diff --git a/tools/perf/util/kvm-stat.h b/tools/perf/util/kvm-stat.h
new file mode 100644
index 000000000000..0b5a8cd2ee79
--- /dev/null
+++ b/tools/perf/util/kvm-stat.h
@@ -0,0 +1,140 @@
+#ifndef __PERF_KVM_STAT_H
+#define __PERF_KVM_STAT_H
+
+#include "../perf.h"
+#include "evsel.h"
+#include "evlist.h"
+#include "session.h"
+#include "tool.h"
+#include "stat.h"
+
+struct event_key {
+        #define INVALID_KEY     (~0ULL)
+        u64 key;
+        int info;
+        struct exit_reasons_table *exit_reasons;
+};
+
+struct kvm_event_stats {
+        u64 time;
+        struct stats stats;
+};
+
+struct kvm_event {
+        struct list_head hash_entry;
+        struct rb_node rb;
+
+        struct event_key key;
+
+        struct kvm_event_stats total;
+
+        #define DEFAULT_VCPU_NUM 8
+        int max_vcpu;
+        struct kvm_event_stats *vcpu;
+};
+
+typedef int (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int);
+
+struct kvm_event_key {
+        const char *name;
+        key_cmp_fun key;
+};
+
+struct perf_kvm_stat;
+
+struct child_event_ops {
+        void (*get_key)(struct perf_evsel *evsel,
+                        struct perf_sample *sample,
+                        struct event_key *key);
+        const char *name;
+};
+
+struct kvm_events_ops {
+        bool (*is_begin_event)(struct perf_evsel *evsel,
+                               struct perf_sample *sample,
+                               struct event_key *key);
+        bool (*is_end_event)(struct perf_evsel *evsel,
+                             struct perf_sample *sample, struct event_key *key);
+        struct child_event_ops *child_ops;
+        void (*decode_key)(struct perf_kvm_stat *kvm, struct event_key *key,
+                           char *decode);
+        const char *name;
+};
+
+struct exit_reasons_table {
+        unsigned long exit_code;
+        const char *reason;
+};
+
+#define EVENTS_BITS             12
+#define EVENTS_CACHE_SIZE       (1UL << EVENTS_BITS)
+
+struct perf_kvm_stat {
+        struct perf_tool    tool;
+        struct record_opts  opts;
+        struct perf_evlist  *evlist;
+        struct perf_session *session;
+
+        const char *file_name;
+        const char *report_event;
+        const char *sort_key;
+        int trace_vcpu;
+
+        struct exit_reasons_table *exit_reasons;
+        const char *exit_reasons_isa;
+
+        struct kvm_events_ops *events_ops;
+        key_cmp_fun compare;
+        struct list_head kvm_events_cache[EVENTS_CACHE_SIZE];
+
+        u64 total_time;
+        u64 total_count;
+        u64 lost_events;
+        u64 duration;
+
+        const char *pid_str;
+        struct intlist *pid_list;
+
+        struct rb_root result;
+
+        int timerfd;
+        unsigned int display_time;
+        bool live;
+};
+
+struct kvm_reg_events_ops {
+        const char *name;
+        struct kvm_events_ops *ops;
+};
+
+void exit_event_get_key(struct perf_evsel *evsel,
+                        struct perf_sample *sample,
+                        struct event_key *key);
+bool exit_event_begin(struct perf_evsel *evsel,
+                      struct perf_sample *sample,
+                      struct event_key *key);
+bool exit_event_end(struct perf_evsel *evsel,
+                    struct perf_sample *sample,
+                    struct event_key *key);
+void exit_event_decode_key(struct perf_kvm_stat *kvm,
+                           struct event_key *key,
+                           char *decode);
+
+bool kvm_exit_event(struct perf_evsel *evsel);
+bool kvm_entry_event(struct perf_evsel *evsel);
+
+#define define_exit_reasons_table(name, symbols)        \
+        static struct exit_reasons_table name[] = {     \
+                symbols, { -1, NULL }                   \
+        }
+
+/*
+ * arch specific callbacks and data structures
+ */
+int cpu_isa_init(struct perf_kvm_stat *kvm, const char *cpuid);
+
+extern const char * const kvm_events_tp[];
+extern struct kvm_reg_events_ops kvm_reg_events_ops[];
+extern const char * const kvm_skip_events[];
+
+#endif /* __PERF_KVM_STAT_H */
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index c73e1fc12e53..16bba9fff2c8 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -8,6 +8,7 @@
 #include "sort.h"
 #include "strlist.h"
 #include "thread.h"
+#include "vdso.h"
 #include <stdbool.h>
 #include <symbol/kallsyms.h>
 #include "unwind.h"
@@ -23,6 +24,8 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
         INIT_LIST_HEAD(&machine->dead_threads);
         machine->last_match = NULL;
 
+        machine->vdso_info = NULL;
+
         machine->kmaps.machine = machine;
         machine->pid = pid;
 
@@ -34,7 +37,7 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
                 return -ENOMEM;
 
         if (pid != HOST_KERNEL_ID) {
-                struct thread *thread = machine__findnew_thread(machine, 0,
+                struct thread *thread = machine__findnew_thread(machine, -1,
                                                                 pid);
                 char comm[64];
 
@@ -45,6 +48,8 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
                 thread__set_comm(thread, comm, 0);
         }
 
+        machine->current_tid = NULL;
+
         return 0;
 }
 
@@ -103,7 +108,9 @@ void machine__exit(struct machine *machine)
         map_groups__exit(&machine->kmaps);
         dsos__delete(&machine->user_dsos);
         dsos__delete(&machine->kernel_dsos);
+        vdso__exit(machine);
         zfree(&machine->root_dir);
+        zfree(&machine->current_tid);
 }
 
 void machine__delete(struct machine *machine)
@@ -272,6 +279,52 @@ void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
         return;
 }
 
+static void machine__update_thread_pid(struct machine *machine,
+                                       struct thread *th, pid_t pid)
+{
+        struct thread *leader;
+
+        if (pid == th->pid_ || pid == -1 || th->pid_ != -1)
+                return;
+
+        th->pid_ = pid;
+
+        if (th->pid_ == th->tid)
+                return;
+
+        leader = machine__findnew_thread(machine, th->pid_, th->pid_);
+        if (!leader)
+                goto out_err;
+
+        if (!leader->mg)
+                leader->mg = map_groups__new();
+
+        if (!leader->mg)
+                goto out_err;
+
+        if (th->mg == leader->mg)
+                return;
+
+        if (th->mg) {
+                /*
+                 * Maps are created from MMAP events which provide the pid and
+                 * tid.  Consequently there never should be any maps on a thread
+                 * with an unknown pid.  Just print an error if there are.
+                 */
+                if (!map_groups__empty(th->mg))
+                        pr_err("Discarding thread maps for %d:%d\n",
+                               th->pid_, th->tid);
+                map_groups__delete(th->mg);
+        }
+
+        th->mg = map_groups__get(leader->mg);
+
+        return;
+
+out_err:
+        pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid);
+}
+
 static struct thread *__machine__findnew_thread(struct machine *machine,
                                                 pid_t pid, pid_t tid,
                                                 bool create)
@@ -285,10 +338,10 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
          * so most of the time we dont have to look up
          * the full rbtree:
          */
-        if (machine->last_match && machine->last_match->tid == tid) {
-                if (pid && pid != machine->last_match->pid_)
-                        machine->last_match->pid_ = pid;
-                return machine->last_match;
+        th = machine->last_match;
+        if (th && th->tid == tid) {
+                machine__update_thread_pid(machine, th, pid);
+                return th;
         }
 
         while (*p != NULL) {
@@ -297,8 +350,7 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
 
                 if (th->tid == tid) {
                         machine->last_match = th;
-                        if (pid && pid != th->pid_)
-                                th->pid_ = pid;
+                        machine__update_thread_pid(machine, th, pid);
                         return th;
                 }
 
@@ -325,8 +377,10 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
                  * within thread__init_map_groups to find the thread
                  * leader and that would screwed the rb tree.
                  */
-                if (thread__init_map_groups(th, machine))
+                if (thread__init_map_groups(th, machine)) {
+                        thread__delete(th);
                         return NULL;
+                }
         }
 
         return th;
@@ -1045,14 +1099,14 @@ int machine__process_mmap2_event(struct machine *machine,
         else
                 type = MAP__FUNCTION;
 
-        map = map__new(&machine->user_dsos, event->mmap2.start,
+        map = map__new(machine, event->mmap2.start,
                         event->mmap2.len, event->mmap2.pgoff,
                         event->mmap2.pid, event->mmap2.maj,
                         event->mmap2.min, event->mmap2.ino,
                         event->mmap2.ino_generation,
                         event->mmap2.prot,
                         event->mmap2.flags,
-                        event->mmap2.filename, type);
+                        event->mmap2.filename, type, thread);
 
         if (map == NULL)
                 goto out_problem;
@@ -1095,11 +1149,11 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         else
                 type = MAP__FUNCTION;
 
-        map = map__new(&machine->user_dsos, event->mmap.start,
+        map = map__new(machine, event->mmap.start,
                         event->mmap.len, event->mmap.pgoff,
                         event->mmap.pid, 0, 0, 0, 0, 0, 0,
                         event->mmap.filename,
-                        type);
+                        type, thread);
 
         if (map == NULL)
                 goto out_problem;
@@ -1281,7 +1335,9 @@ static int machine__resolve_callchain_sample(struct machine *machine,
         u8 cpumode = PERF_RECORD_MISC_USER;
         int chain_nr = min(max_stack, (int)chain->nr);
         int i;
+        int j;
         int err;
+        int skip_idx __maybe_unused;
 
         callchain_cursor_reset(&callchain_cursor);
 
@@ -1290,14 +1346,26 @@ static int machine__resolve_callchain_sample(struct machine *machine,
                 return 0;
         }
 
+        /*
+         * Based on DWARF debug information, some architectures skip
+         * a callchain entry saved by the kernel.
+         */
+        skip_idx = arch_skip_callchain_idx(machine, thread, chain);
+
         for (i = 0; i < chain_nr; i++) {
                 u64 ip;
                 struct addr_location al;
 
                 if (callchain_param.order == ORDER_CALLEE)
-                        ip = chain->ips[i];
+                        j = i;
                 else
-                        ip = chain->ips[chain->nr - i - 1];
+                        j = chain->nr - i - 1;
+
+#ifdef HAVE_SKIP_CALLCHAIN_IDX
+                if (j == skip_idx)
+                        continue;
+#endif
+                ip = chain->ips[j];
 
                 if (ip >= PERF_CONTEXT_MAX) {
                         switch (ip) {
@@ -1420,3 +1488,46 @@ int __machine__synthesize_threads(struct machine *machine, struct perf_tool *too
         /* command specified */
         return 0;
 }
+
+pid_t machine__get_current_tid(struct machine *machine, int cpu)
+{
+        if (cpu < 0 || cpu >= MAX_NR_CPUS || !machine->current_tid)
+                return -1;
+
+        return machine->current_tid[cpu];
+}
+
+int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
+                             pid_t tid)
+{
+        struct thread *thread;
+
+        if (cpu < 0)
+                return -EINVAL;
+
+        if (!machine->current_tid) {
+                int i;
+
+                machine->current_tid = calloc(MAX_NR_CPUS, sizeof(pid_t));
+                if (!machine->current_tid)
+                        return -ENOMEM;
+                for (i = 0; i < MAX_NR_CPUS; i++)
+                        machine->current_tid[i] = -1;
+        }
+
+        if (cpu >= MAX_NR_CPUS) {
+                pr_err("Requested CPU %d too large. ", cpu);
+                pr_err("Consider raising MAX_NR_CPUS\n");
+                return -EINVAL;
+        }
+
+        machine->current_tid[cpu] = tid;
+
+        thread = machine__findnew_thread(machine, pid, tid);
+        if (!thread)
+                return -ENOMEM;
+
+        thread->cpu = cpu;
+
+        return 0;
+}
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index c8c74a119398..b972824e6294 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -20,6 +20,8 @@ union perf_event;
 
 extern const char *ref_reloc_sym_names[];
 
+struct vdso_info;
+
 struct machine {
         struct rb_node    rb_node;
         pid_t             pid;
@@ -28,11 +30,13 @@ struct machine {
         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 map_groups kmaps;
         struct map        *vmlinux_maps[MAP__NR_TYPES];
         symbol_filter_t   symbol_filter;
+        pid_t             *current_tid;
 };
 
 static inline
@@ -191,4 +195,8 @@ int machine__synthesize_threads(struct machine *machine, struct target *target,
                                              perf_event__process, data_mmap);
 }
 
+pid_t machine__get_current_tid(struct machine *machine, int cpu);
+int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
+                             pid_t tid);
+
 #endif /* __PERF_MACHINE_H */
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 25c571f4cba6..31b8905dd863 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -12,6 +12,8 @@
 #include "vdso.h"
 #include "build-id.h"
 #include "util.h"
+#include "debug.h"
+#include "machine.h"
 #include <linux/string.h>
 
 const char *map_type__name[MAP__NR_TYPES] = {
@@ -136,10 +138,10 @@ void map__init(struct map *map, enum map_type type,
         map->erange_warned = false;
 }
 
-struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
+struct map *map__new(struct machine *machine, u64 start, u64 len,
                      u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino,
                      u64 ino_gen, u32 prot, u32 flags, char *filename,
-                     enum map_type type)
+                     enum map_type type, struct thread *thread)
 {
         struct map *map = malloc(sizeof(*map));
 
@@ -172,9 +174,9 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
 
                 if (vdso) {
                         pgoff = 0;
-                        dso = vdso__dso_findnew(dsos__list);
+                        dso = vdso__dso_findnew(machine, thread);
                 } else
-                        dso = __dsos__findnew(dsos__list, filename);
+                        dso = __dsos__findnew(&machine->user_dsos, filename);
 
                 if (dso == NULL)
                         goto out_delete;
@@ -454,6 +456,20 @@ void map_groups__exit(struct map_groups *mg)
         }
 }
 
+bool map_groups__empty(struct map_groups *mg)
+{
+        int i;
+
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                if (maps__first(&mg->maps[i]))
+                        return false;
+                if (!list_empty(&mg->removed_maps[i]))
+                        return false;
+        }
+
+        return true;
+}
+
 struct map_groups *map_groups__new(void)
 {
         struct map_groups *mg = malloc(sizeof(*mg));
@@ -554,8 +570,8 @@ int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter)
         return ams->sym ? 0 : -1;
 }
 
-size_t __map_groups__fprintf_maps(struct map_groups *mg,
-                                  enum map_type type, int verbose, FILE *fp)
+size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type,
+                                  FILE *fp)
 {
         size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
         struct rb_node *nd;
@@ -573,17 +589,16 @@ size_t __map_groups__fprintf_maps(struct map_groups *mg,
         return printed;
 }
 
-size_t map_groups__fprintf_maps(struct map_groups *mg, int verbose, FILE *fp)
+static size_t map_groups__fprintf_maps(struct map_groups *mg, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_maps(mg, i, verbose, fp);
+                printed += __map_groups__fprintf_maps(mg, i, fp);
         return printed;
 }
 
 static size_t __map_groups__fprintf_removed_maps(struct map_groups *mg,
-                                                 enum map_type type,
-                                                 int verbose, FILE *fp)
+                                                 enum map_type type, FILE *fp)
 {
         struct map *pos;
         size_t printed = 0;
@@ -600,23 +615,23 @@ static size_t __map_groups__fprintf_removed_maps(struct map_groups *mg,
 }
 
 static size_t map_groups__fprintf_removed_maps(struct map_groups *mg,
-                                               int verbose, FILE *fp)
+                                               FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_removed_maps(mg, i, verbose, fp);
+                printed += __map_groups__fprintf_removed_maps(mg, i, fp);
         return printed;
 }
 
-size_t map_groups__fprintf(struct map_groups *mg, int verbose, FILE *fp)
+size_t map_groups__fprintf(struct map_groups *mg, FILE *fp)
 {
-        size_t printed = map_groups__fprintf_maps(mg, verbose, fp);
+        size_t printed = map_groups__fprintf_maps(mg, fp);
         printed += fprintf(fp, "Removed maps:\n");
-        return printed + map_groups__fprintf_removed_maps(mg, verbose, fp);
+        return printed + map_groups__fprintf_removed_maps(mg, fp);
 }
 
 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
-                                   int verbose, FILE *fp)
+                                   FILE *fp)
 {
         struct rb_root *root = &mg->maps[map->type];
         struct rb_node *next = rb_first(root);
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 7758c72522ef..2f83954af050 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -66,6 +66,7 @@ struct map_groups {
 
 struct map_groups *map_groups__new(void);
 void map_groups__delete(struct map_groups *mg);
+bool map_groups__empty(struct map_groups *mg);
 
 static inline struct map_groups *map_groups__get(struct map_groups *mg)
 {
@@ -103,6 +104,7 @@ u64 map__rip_2objdump(struct map *map, u64 rip);
 u64 map__objdump_2mem(struct map *map, u64 ip);
 
 struct symbol;
+struct thread;
 
 /* map__for_each_symbol - iterate over the symbols in the given map
  *
@@ -118,10 +120,10 @@ typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
 
 void map__init(struct map *map, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso);
-struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
+struct map *map__new(struct machine *machine, u64 start, u64 len,
                      u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino,
                      u64 ino_gen, u32 prot, u32 flags,
-                     char *filename, enum map_type type);
+                     char *filename, enum map_type type, struct thread *thread);
 struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 void map__delete(struct map *map);
 struct map *map__clone(struct map *map);
@@ -141,8 +143,8 @@ void map__fixup_end(struct map *map);
 
 void map__reloc_vmlinux(struct map *map);
 
-size_t __map_groups__fprintf_maps(struct map_groups *mg,
-                                  enum map_type type, int verbose, FILE *fp);
+size_t __map_groups__fprintf_maps(struct map_groups *mg, enum map_type type,
+                                  FILE *fp);
 void maps__insert(struct rb_root *maps, struct map *map);
 void maps__remove(struct rb_root *maps, struct map *map);
 struct map *maps__find(struct rb_root *maps, u64 addr);
@@ -152,8 +154,7 @@ void map_groups__init(struct map_groups *mg);
 void map_groups__exit(struct map_groups *mg);
 int map_groups__clone(struct map_groups *mg,
                       struct map_groups *parent, enum map_type type);
-size_t map_groups__fprintf(struct map_groups *mg, int verbose, FILE *fp);
-size_t map_groups__fprintf_maps(struct map_groups *mg, int verbose, FILE *fp);
+size_t map_groups__fprintf(struct map_groups *mg, FILE *fp);
 
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps, const char *symbol_name,
                                      u64 addr);
@@ -210,7 +211,7 @@ struct symbol *map_groups__find_function_by_name(struct map_groups *mg,
 }
 
 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
-                                   int verbose, FILE *fp);
+                                   FILE *fp);
 
 struct map *map_groups__find_by_name(struct map_groups *mg,
                                      enum map_type type, const char *name);
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index d8dac8ac5f37..b59ba858e73d 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -98,6 +98,7 @@ struct option {
         parse_opt_cb *callback;
         intptr_t defval;
         bool *set;
+        void *data;
 };
 
 #define check_vtype(v, type) ( BUILD_BUG_ON_ZERO(!__builtin_types_compatible_p(typeof(v), type)) + v )
@@ -131,6 +132,10 @@ struct option {
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l),\
         .value = (v), (a), .help = (h), .callback = (f), .defval = (intptr_t)d,\
         .flags = PARSE_OPT_LASTARG_DEFAULT | PARSE_OPT_NOARG}
+#define OPT_CALLBACK_OPTARG(s, l, v, d, a, h, f) \
+        { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), \
+          .value = (v), (a), .help = (h), .callback = (f), \
+          .flags = PARSE_OPT_OPTARG, .data = (d) }
 
 /* parse_options() will filter out the processed options and leave the
  * non-option argments in argv[].
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 98e304766416..dca9145d704c 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -26,7 +26,6 @@
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
-#include <getopt.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
diff --git a/tools/perf/util/pstack.c b/tools/perf/util/pstack.c
index daa17aeb6c63..a126e6cc6e73 100644
--- a/tools/perf/util/pstack.c
+++ b/tools/perf/util/pstack.c
@@ -6,6 +6,7 @@
 
 #include "util.h"
 #include "pstack.h"
+#include "debug.h"
 #include <linux/kernel.h>
 #include <stdlib.h>
 
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 122669c18ff4..12aa9b0d0ba1 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -14,12 +14,12 @@
  */
 int verbose;
 
-int eprintf(int level, const char *fmt, ...)
+int eprintf(int level, int var, const char *fmt, ...)
 {
         va_list args;
         int ret = 0;
 
-        if (verbose >= level) {
+        if (var >= level) {
                 va_start(args, fmt);
                 ret = vfprintf(stderr, fmt, args);
                 va_end(args);
diff --git a/tools/perf/util/record.c b/tools/perf/util/record.c
index 049e0a09ccd3..fe8079edbdc1 100644
--- a/tools/perf/util/record.c
+++ b/tools/perf/util/record.c
@@ -4,6 +4,7 @@
 #include "parse-events.h"
 #include <api/fs/fs.h>
 #include "util.h"
+#include "cloexec.h"
 
 typedef void (*setup_probe_fn_t)(struct perf_evsel *evsel);
 
@@ -11,6 +12,7 @@ static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str)
 {
         struct perf_evlist *evlist;
         struct perf_evsel *evsel;
+        unsigned long flags = perf_event_open_cloexec_flag();
         int err = -EAGAIN, fd;
 
         evlist = perf_evlist__new();
@@ -22,14 +24,14 @@ 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, 0);
+        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, flags);
         if (fd < 0)
                 goto out_delete;
         close(fd);
 
         fn(evsel);
 
-        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, 0);
+        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, flags);
         if (fd < 0) {
                 if (errno == EINVAL)
                         err = -EINVAL;
@@ -69,15 +71,26 @@ static void perf_probe_sample_identifier(struct perf_evsel *evsel)
         evsel->attr.sample_type |= PERF_SAMPLE_IDENTIFIER;
 }
 
+static void perf_probe_comm_exec(struct perf_evsel *evsel)
+{
+        evsel->attr.comm_exec = 1;
+}
+
 bool perf_can_sample_identifier(void)
 {
         return perf_probe_api(perf_probe_sample_identifier);
 }
 
+static bool perf_can_comm_exec(void)
+{
+        return perf_probe_api(perf_probe_comm_exec);
+}
+
 void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts)
 {
         struct perf_evsel *evsel;
         bool use_sample_identifier = false;
+        bool use_comm_exec;
 
         /*
          * Set the evsel leader links before we configure attributes,
@@ -89,8 +102,13 @@ void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts)
         if (evlist->cpus->map[0] < 0)
                 opts->no_inherit = true;
 
-        evlist__for_each(evlist, evsel)
+        use_comm_exec = perf_can_comm_exec();
+
+        evlist__for_each(evlist, evsel) {
                 perf_evsel__config(evsel, opts);
+                if (!evsel->idx && use_comm_exec)
+                        evsel->attr.comm_exec = 1;
+        }
 
         if (evlist->nr_entries > 1) {
                 struct perf_evsel *first = perf_evlist__first(evlist);
@@ -203,7 +221,8 @@ 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, 0);
+        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1,
+                                 perf_event_open_cloexec_flag());
         if (fd >= 0) {
                 close(fd);
                 ret = true;
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index af7da565a750..b2dba9c0a3a1 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -34,6 +34,7 @@
 #include "../event.h"
 #include "../trace-event.h"
 #include "../evsel.h"
+#include "../debug.h"
 
 void boot_Perf__Trace__Context(pTHX_ CV *cv);
 void boot_DynaLoader(pTHX_ CV *cv);
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 1c419321f707..cbce2545da45 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -27,11 +27,13 @@
 #include <errno.h>
 
 #include "../../perf.h"
+#include "../debug.h"
 #include "../evsel.h"
 #include "../util.h"
 #include "../event.h"
 #include "../thread.h"
 #include "../trace-event.h"
+#include "../machine.h"
 
 PyMODINIT_FUNC initperf_trace_context(void);
 
@@ -50,10 +52,14 @@ static int zero_flag_atom;
 
 static PyObject *main_module, *main_dict;
 
+static void handler_call_die(const char *handler_name) NORETURN;
 static void handler_call_die(const char *handler_name)
 {
         PyErr_Print();
         Py_FatalError("problem in Python trace event handler");
+        // Py_FatalError does not return
+        // but we have to make the compiler happy
+        abort();
 }
 
 /*
@@ -97,6 +103,7 @@ static void define_value(enum print_arg_type field_type,
                 retval = PyObject_CallObject(handler, t);
                 if (retval == NULL)
                         handler_call_die(handler_name);
+                Py_DECREF(retval);
         }
 
         Py_DECREF(t);
@@ -143,6 +150,7 @@ static void define_field(enum print_arg_type field_type,
                 retval = PyObject_CallObject(handler, t);
                 if (retval == NULL)
                         handler_call_die(handler_name);
+                Py_DECREF(retval);
         }
 
         Py_DECREF(t);
@@ -231,15 +239,133 @@ static inline struct event_format *find_cache_event(struct perf_evsel *evsel)
         return event;
 }
 
+static PyObject *get_field_numeric_entry(struct event_format *event,
+                struct format_field *field, void *data)
+{
+        bool is_array = field->flags & FIELD_IS_ARRAY;
+        PyObject *obj, *list = NULL;
+        unsigned long long val;
+        unsigned int item_size, n_items, i;
+
+        if (is_array) {
+                list = PyList_New(field->arraylen);
+                item_size = field->size / field->arraylen;
+                n_items = field->arraylen;
+        } else {
+                item_size = field->size;
+                n_items = 1;
+        }
+
+        for (i = 0; i < n_items; i++) {
+
+                val = read_size(event, data + field->offset + i * item_size,
+                                item_size);
+                if (field->flags & FIELD_IS_SIGNED) {
+                        if ((long long)val >= LONG_MIN &&
+                                        (long long)val <= LONG_MAX)
+                                obj = PyInt_FromLong(val);
+                        else
+                                obj = PyLong_FromLongLong(val);
+                } else {
+                        if (val <= LONG_MAX)
+                                obj = PyInt_FromLong(val);
+                        else
+                                obj = PyLong_FromUnsignedLongLong(val);
+                }
+                if (is_array)
+                        PyList_SET_ITEM(list, i, obj);
+        }
+        if (is_array)
+                obj = list;
+        return obj;
+}
+
+
+static PyObject *python_process_callchain(struct perf_sample *sample,
+                                         struct perf_evsel *evsel,
+                                         struct addr_location *al)
+{
+        PyObject *pylist;
+
+        pylist = PyList_New(0);
+        if (!pylist)
+                Py_FatalError("couldn't create Python list");
+
+        if (!symbol_conf.use_callchain || !sample->callchain)
+                goto exit;
+
+        if (machine__resolve_callchain(al->machine, evsel, al->thread,
+                                           sample, NULL, NULL,
+                                           PERF_MAX_STACK_DEPTH) != 0) {
+                pr_err("Failed to resolve callchain. Skipping\n");
+                goto exit;
+        }
+        callchain_cursor_commit(&callchain_cursor);
+
+
+        while (1) {
+                PyObject *pyelem;
+                struct callchain_cursor_node *node;
+                node = callchain_cursor_current(&callchain_cursor);
+                if (!node)
+                        break;
+
+                pyelem = PyDict_New();
+                if (!pyelem)
+                        Py_FatalError("couldn't create Python dictionary");
+
+
+                pydict_set_item_string_decref(pyelem, "ip",
+                                PyLong_FromUnsignedLongLong(node->ip));
+
+                if (node->sym) {
+                        PyObject *pysym  = PyDict_New();
+                        if (!pysym)
+                                Py_FatalError("couldn't create Python dictionary");
+                        pydict_set_item_string_decref(pysym, "start",
+                                        PyLong_FromUnsignedLongLong(node->sym->start));
+                        pydict_set_item_string_decref(pysym, "end",
+                                        PyLong_FromUnsignedLongLong(node->sym->end));
+                        pydict_set_item_string_decref(pysym, "binding",
+                                        PyInt_FromLong(node->sym->binding));
+                        pydict_set_item_string_decref(pysym, "name",
+                                        PyString_FromStringAndSize(node->sym->name,
+                                                        node->sym->namelen));
+                        pydict_set_item_string_decref(pyelem, "sym", pysym);
+                }
+
+                if (node->map) {
+                        struct map *map = node->map;
+                        const char *dsoname = "[unknown]";
+                        if (map && map->dso && (map->dso->name || map->dso->long_name)) {
+                                if (symbol_conf.show_kernel_path && map->dso->long_name)
+                                        dsoname = map->dso->long_name;
+                                else if (map->dso->name)
+                                        dsoname = map->dso->name;
+                        }
+                        pydict_set_item_string_decref(pyelem, "dso",
+                                        PyString_FromString(dsoname));
+                }
+
+                callchain_cursor_advance(&callchain_cursor);
+                PyList_Append(pylist, pyelem);
+                Py_DECREF(pyelem);
+        }
+
+exit:
+        return pylist;
+}
+
+
 static void python_process_tracepoint(struct perf_sample *sample,
                                       struct perf_evsel *evsel,
                                       struct thread *thread,
                                       struct addr_location *al)
 {
-        PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
+        PyObject *handler, *retval, *context, *t, *obj, *callchain;
+        PyObject *dict = NULL;
         static char handler_name[256];
         struct format_field *field;
-        unsigned long long val;
         unsigned long s, ns;
         struct event_format *event;
         unsigned n = 0;
@@ -280,18 +406,23 @@ static void python_process_tracepoint(struct perf_sample *sample,
         PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
         PyTuple_SetItem(t, n++, context);
 
+        /* ip unwinding */
+        callchain = python_process_callchain(sample, evsel, al);
+
         if (handler) {
                 PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
                 PyTuple_SetItem(t, n++, PyInt_FromLong(s));
                 PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
                 PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
                 PyTuple_SetItem(t, n++, PyString_FromString(comm));
+                PyTuple_SetItem(t, n++, callchain);
         } else {
                 pydict_set_item_string_decref(dict, "common_cpu", PyInt_FromLong(cpu));
                 pydict_set_item_string_decref(dict, "common_s", PyInt_FromLong(s));
                 pydict_set_item_string_decref(dict, "common_ns", PyInt_FromLong(ns));
                 pydict_set_item_string_decref(dict, "common_pid", PyInt_FromLong(pid));
                 pydict_set_item_string_decref(dict, "common_comm", PyString_FromString(comm));
+                pydict_set_item_string_decref(dict, "common_callchain", callchain);
         }
         for (field = event->format.fields; field; field = field->next) {
                 if (field->flags & FIELD_IS_STRING) {
@@ -303,20 +434,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
                                 offset = field->offset;
                         obj = PyString_FromString((char *)data + offset);
                 } else { /* FIELD_IS_NUMERIC */
-                        val = read_size(event, data + field->offset,
-                                        field->size);
-                        if (field->flags & FIELD_IS_SIGNED) {
-                                if ((long long)val >= LONG_MIN &&
-                                    (long long)val <= LONG_MAX)
-                                        obj = PyInt_FromLong(val);
-                                else
-                                        obj = PyLong_FromLongLong(val);
-                        } else {
-                                if (val <= LONG_MAX)
-                                        obj = PyInt_FromLong(val);
-                                else
-                                        obj = PyLong_FromUnsignedLongLong(val);
-                        }
+                        obj = get_field_numeric_entry(event, field, data);
                 }
                 if (handler)
                         PyTuple_SetItem(t, n++, obj);
@@ -324,6 +442,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
                         pydict_set_item_string_decref(dict, field->name, obj);
 
         }
+
         if (!handler)
                 PyTuple_SetItem(t, n++, dict);
 
@@ -334,6 +453,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
                 retval = PyObject_CallObject(handler, t);
                 if (retval == NULL)
                         handler_call_die(handler_name);
+                Py_DECREF(retval);
         } else {
                 handler = PyDict_GetItemString(main_dict, "trace_unhandled");
                 if (handler && PyCallable_Check(handler)) {
@@ -341,6 +461,7 @@ static void python_process_tracepoint(struct perf_sample *sample,
                         retval = PyObject_CallObject(handler, t);
                         if (retval == NULL)
                                 handler_call_die("trace_unhandled");
+                        Py_DECREF(retval);
                 }
                 Py_DECREF(dict);
         }
@@ -353,7 +474,7 @@ static void python_process_general_event(struct perf_sample *sample,
                                          struct thread *thread,
                                          struct addr_location *al)
 {
-        PyObject *handler, *retval, *t, *dict;
+        PyObject *handler, *retval, *t, *dict, *callchain, *dict_sample;
         static char handler_name[64];
         unsigned n = 0;
 
@@ -369,6 +490,10 @@ static void python_process_general_event(struct perf_sample *sample,
         if (!dict)
                 Py_FatalError("couldn't create Python dictionary");
 
+        dict_sample = PyDict_New();
+        if (!dict_sample)
+                Py_FatalError("couldn't create Python dictionary");
+
         snprintf(handler_name, sizeof(handler_name), "%s", "process_event");
 
         handler = PyDict_GetItemString(main_dict, handler_name);
@@ -378,8 +503,21 @@ static void python_process_general_event(struct perf_sample *sample,
         pydict_set_item_string_decref(dict, "ev_name", PyString_FromString(perf_evsel__name(evsel)));
         pydict_set_item_string_decref(dict, "attr", PyString_FromStringAndSize(
                         (const char *)&evsel->attr, sizeof(evsel->attr)));
-        pydict_set_item_string_decref(dict, "sample", PyString_FromStringAndSize(
-                        (const char *)sample, sizeof(*sample)));
+
+        pydict_set_item_string_decref(dict_sample, "pid",
+                        PyInt_FromLong(sample->pid));
+        pydict_set_item_string_decref(dict_sample, "tid",
+                        PyInt_FromLong(sample->tid));
+        pydict_set_item_string_decref(dict_sample, "cpu",
+                        PyInt_FromLong(sample->cpu));
+        pydict_set_item_string_decref(dict_sample, "ip",
+                        PyLong_FromUnsignedLongLong(sample->ip));
+        pydict_set_item_string_decref(dict_sample, "time",
+                        PyLong_FromUnsignedLongLong(sample->time));
+        pydict_set_item_string_decref(dict_sample, "period",
+                        PyLong_FromUnsignedLongLong(sample->period));
+        pydict_set_item_string_decref(dict, "sample", dict_sample);
+
         pydict_set_item_string_decref(dict, "raw_buf", PyString_FromStringAndSize(
                         (const char *)sample->raw_data, sample->raw_size));
         pydict_set_item_string_decref(dict, "comm",
@@ -393,6 +531,10 @@ static void python_process_general_event(struct perf_sample *sample,
                         PyString_FromString(al->sym->name));
         }
 
+        /* ip unwinding */
+        callchain = python_process_callchain(sample, evsel, al);
+        pydict_set_item_string_decref(dict, "callchain", callchain);
+
         PyTuple_SetItem(t, n++, dict);
         if (_PyTuple_Resize(&t, n) == -1)
                 Py_FatalError("error resizing Python tuple");
@@ -400,6 +542,7 @@ static void python_process_general_event(struct perf_sample *sample,
         retval = PyObject_CallObject(handler, t);
         if (retval == NULL)
                 handler_call_die(handler_name);
+        Py_DECREF(retval);
 exit:
         Py_DECREF(dict);
         Py_DECREF(t);
@@ -521,8 +664,7 @@ static int python_stop_script(void)
         retval = PyObject_CallObject(handler, NULL);
         if (retval == NULL)
                 handler_call_die("trace_end");
-        else
-                Py_DECREF(retval);
+        Py_DECREF(retval);
 out:
         Py_XDECREF(main_dict);
         Py_XDECREF(main_module);
@@ -589,6 +731,7 @@ static int python_generate_script(struct pevent *pevent, const char *outfile)
                 fprintf(ofp, "common_nsecs, ");
                 fprintf(ofp, "common_pid, ");
                 fprintf(ofp, "common_comm,\n\t");
+                fprintf(ofp, "common_callchain, ");
 
                 not_first = 0;
                 count = 0;
@@ -632,7 +775,7 @@ static int python_generate_script(struct pevent *pevent, const char *outfile)
                                 fprintf(ofp, "%%u");
                 }
 
-                fprintf(ofp, "\\n\" %% \\\n\t\t(");
+                fprintf(ofp, "\" %% \\\n\t\t(");
 
                 not_first = 0;
                 count = 0;
@@ -668,7 +811,15 @@ static int python_generate_script(struct pevent *pevent, const char *outfile)
                                 fprintf(ofp, "%s", f->name);
                 }
 
-                fprintf(ofp, "),\n\n");
+                fprintf(ofp, ")\n\n");
+
+                fprintf(ofp, "\t\tfor node in common_callchain:");
+                fprintf(ofp, "\n\t\t\tif 'sym' in node:");
+                fprintf(ofp, "\n\t\t\t\tprint \"\\t[%%x] %%s\" %% (node['ip'], node['sym']['name'])");
+                fprintf(ofp, "\n\t\t\telse:");
+                fprintf(ofp, "\n\t\t\t\tprint \"\t[%%x]\" %% (node['ip'])\n\n");
+                fprintf(ofp, "\t\tprint \"\\n\"\n\n");
+
         }
 
         fprintf(ofp, "def trace_unhandled(event_name, context, "
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 64a186edc7be..88dfef70c13d 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -14,7 +14,6 @@
 #include "util.h"
 #include "cpumap.h"
 #include "perf_regs.h"
-#include "vdso.h"
 
 static int perf_session__open(struct perf_session *session)
 {
@@ -156,7 +155,6 @@ void perf_session__delete(struct perf_session *session)
         if (session->file)
                 perf_data_file__close(session->file);
         free(session);
-        vdso__exit();
 }
 
 static int process_event_synth_tracing_data_stub(struct perf_tool *tool
@@ -511,6 +509,7 @@ static int flush_sample_queue(struct perf_session *s,
                 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);
@@ -523,8 +522,6 @@ static int flush_sample_queue(struct perf_session *s,
                         list_entry(head->prev, struct sample_queue, list);
         }
 
-        os->nr_samples = 0;
-
         return 0;
 }
 
@@ -994,8 +991,10 @@ static int perf_session_deliver_event(struct perf_session *session,
         }
 }
 
-static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
-                                            struct perf_tool *tool, u64 file_offset)
+static s64 perf_session__process_user_event(struct perf_session *session,
+                                            union perf_event *event,
+                                            struct perf_tool *tool,
+                                            u64 file_offset)
 {
         int fd = perf_data_file__fd(session->file);
         int err;
@@ -1037,7 +1036,7 @@ static void event_swap(union perf_event *event, bool sample_id_all)
                 swap(event, sample_id_all);
 }
 
-static int perf_session__process_event(struct perf_session *session,
+static s64 perf_session__process_event(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_tool *tool,
                                        u64 file_offset)
@@ -1083,13 +1082,14 @@ void perf_event_header__bswap(struct perf_event_header *hdr)
 
 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
 {
-        return machine__findnew_thread(&session->machines.host, 0, pid);
+        return machine__findnew_thread(&session->machines.host, -1, pid);
 }
 
 static struct thread *perf_session__register_idle_thread(struct perf_session *session)
 {
-        struct thread *thread = perf_session__findnew(session, 0);
+        struct thread *thread;
 
+        thread = machine__findnew_thread(&session->machines.host, 0, 0);
         if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
                 pr_err("problem inserting idle task.\n");
                 thread = NULL;
@@ -1147,7 +1147,7 @@ static int __perf_session__process_pipe_events(struct perf_session *session,
         union perf_event *event;
         uint32_t size, cur_size = 0;
         void *buf = NULL;
-        int skip = 0;
+        s64 skip = 0;
         u64 head;
         ssize_t err;
         void *p;
@@ -1276,13 +1276,13 @@ int __perf_session__process_events(struct perf_session *session,
                                    u64 file_size, struct perf_tool *tool)
 {
         int fd = perf_data_file__fd(session->file);
-        u64 head, page_offset, file_offset, file_pos;
+        u64 head, page_offset, file_offset, file_pos, size;
         int err, mmap_prot, mmap_flags, map_idx = 0;
         size_t  mmap_size;
         char *buf, *mmaps[NUM_MMAPS];
         union perf_event *event;
-        uint32_t size;
         struct ui_progress prog;
+        s64 skip;
 
         perf_tool__fill_defaults(tool);
 
@@ -1296,8 +1296,10 @@ int __perf_session__process_events(struct perf_session *session,
         ui_progress__init(&prog, file_size, "Processing events...");
 
         mmap_size = MMAP_SIZE;
-        if (mmap_size > file_size)
+        if (mmap_size > file_size) {
                 mmap_size = file_size;
+                session->one_mmap = true;
+        }
 
         memset(mmaps, 0, sizeof(mmaps));
 
@@ -1319,6 +1321,10 @@ remap:
         mmaps[map_idx] = buf;
         map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
         file_pos = file_offset + head;
+        if (session->one_mmap) {
+                session->one_mmap_addr = buf;
+                session->one_mmap_offset = file_offset;
+        }
 
 more:
         event = fetch_mmaped_event(session, head, mmap_size, buf);
@@ -1337,7 +1343,8 @@ more:
         size = event->header.size;
 
         if (size < sizeof(struct perf_event_header) ||
-            perf_session__process_event(session, event, tool, file_pos) < 0) {
+            (skip = perf_session__process_event(session, event, tool, file_pos))
+                                                                        < 0) {
                 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                        file_offset + head, event->header.size,
                        event->header.type);
@@ -1345,6 +1352,9 @@ more:
                 goto out_err;
         }
 
+        if (skip)
+                size += skip;
+
         head += size;
         file_pos += size;
 
@@ -1364,6 +1374,7 @@ out_err:
         ui_progress__finish();
         perf_session__warn_about_errors(session, tool);
         perf_session_free_sample_buffers(session);
+        session->one_mmap = false;
         return err;
 }
 
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 3140f8ae6148..0321013bd9fd 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -36,6 +36,9 @@ struct perf_session {
         struct trace_event      tevent;
         struct events_stats     stats;
         bool                    repipe;
+        bool                    one_mmap;
+        void                    *one_mmap_addr;
+        u64                     one_mmap_offset;
         struct ordered_samples  ordered_samples;
         struct perf_data_file   *file;
 };
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 1ec57dd82284..14e5a039bc45 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1215,7 +1215,7 @@ static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
         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);
+        return scnprintf(hpp->buf, hpp->size, "%-*s", len, hse->se->se_header);
 }
 
 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
diff --git a/tools/perf/util/svghelper.c b/tools/perf/util/svghelper.c
index 6a0a13d07a28..283d3e73e2f2 100644
--- a/tools/perf/util/svghelper.c
+++ b/tools/perf/util/svghelper.c
@@ -30,6 +30,7 @@ static u64 turbo_frequency, max_freq;
 
 #define SLOT_MULT 30.0
 #define SLOT_HEIGHT 25.0
+#define SLOT_HALF (SLOT_HEIGHT / 2)
 
 int svg_page_width = 1000;
 u64 svg_highlight;
@@ -114,8 +115,14 @@ void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
         fprintf(svgfile, "      rect          { stroke-width: 1; }\n");
         fprintf(svgfile, "      rect.process  { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:1;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.process2 { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.process3 { fill:rgb(180,180,180); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.sample   { fill:rgb(  0,  0,255); fill-opacity:0.8; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.sample_hi{ fill:rgb(255,128,  0); fill-opacity:0.8; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.error    { fill:rgb(255,  0,  0); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.net      { fill:rgb(  0,128,  0); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.disk     { fill:rgb(  0,  0,255); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.sync     { fill:rgb(128,128,  0); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.poll     { fill:rgb(  0,128,128); fill-opacity:0.2; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.blocked  { fill:rgb(255,  0,  0); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.waiting  { fill:rgb(224,214,  0); fill-opacity:0.8; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.WAITING  { fill:rgb(255,214, 48); fill-opacity:0.6; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
@@ -132,12 +139,81 @@ void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
         fprintf(svgfile, "    ]]>\n   </style>\n</defs>\n");
 }
 
+static double normalize_height(double height)
+{
+        if (height < 0.25)
+                return 0.25;
+        else if (height < 0.50)
+                return 0.50;
+        else if (height < 0.75)
+                return 0.75;
+        else
+                return 0.100;
+}
+
+void svg_ubox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges)
+{
+        double w = time2pixels(end) - time2pixels(start);
+        height = normalize_height(height);
+
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<g>\n");
+        fprintf(svgfile, "<title>fd=%d error=%d merges=%d</title>\n", fd, err, merges);
+        fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
+                time2pixels(start),
+                w,
+                Yslot * SLOT_MULT,
+                SLOT_HALF * height,
+                type);
+        fprintf(svgfile, "</g>\n");
+}
+
+void svg_lbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges)
+{
+        double w = time2pixels(end) - time2pixels(start);
+        height = normalize_height(height);
+
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<g>\n");
+        fprintf(svgfile, "<title>fd=%d error=%d merges=%d</title>\n", fd, err, merges);
+        fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
+                time2pixels(start),
+                w,
+                Yslot * SLOT_MULT + SLOT_HEIGHT - SLOT_HALF * height,
+                SLOT_HALF * height,
+                type);
+        fprintf(svgfile, "</g>\n");
+}
+
+void svg_fbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges)
+{
+        double w = time2pixels(end) - time2pixels(start);
+        height = normalize_height(height);
+
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<g>\n");
+        fprintf(svgfile, "<title>fd=%d error=%d merges=%d</title>\n", fd, err, merges);
+        fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
+                time2pixels(start),
+                w,
+                Yslot * SLOT_MULT + SLOT_HEIGHT - SLOT_HEIGHT * height,
+                SLOT_HEIGHT * height,
+                type);
+        fprintf(svgfile, "</g>\n");
+}
+
 void svg_box(int Yslot, u64 start, u64 end, const char *type)
 {
         if (!svgfile)
                 return;
 
-        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
+        fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
                 time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT, type);
 }
 
@@ -174,7 +250,7 @@ void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
                 cpu, time_to_string(end - start));
         if (backtrace)
                 fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
-        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
+        fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
                 time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT,
                 type);
 
@@ -186,7 +262,7 @@ void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
         text_size = round_text_size(text_size);
 
         if (text_size > MIN_TEXT_SIZE)
-                fprintf(svgfile, "<text x=\"%1.8f\" y=\"%1.8f\" font-size=\"%1.8fpt\">%i</text>\n",
+                fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\" font-size=\"%.8fpt\">%i</text>\n",
                         time2pixels(start), Yslot *  SLOT_MULT + SLOT_HEIGHT - 1, text_size,  cpu + 1);
 
         fprintf(svgfile, "</g>\n");
@@ -202,10 +278,10 @@ static char *time_to_string(u64 duration)
                 return text;
 
         if (duration < 1000 * 1000) { /* less than 1 msec */
-                sprintf(text, "%4.1f us", duration / 1000.0);
+                sprintf(text, "%.1f us", duration / 1000.0);
                 return text;
         }
-        sprintf(text, "%4.1f ms", duration / 1000.0 / 1000);
+        sprintf(text, "%.1f ms", duration / 1000.0 / 1000);
 
         return text;
 }
@@ -233,14 +309,14 @@ void svg_waiting(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
 
         font_size = round_text_size(font_size);
 
-        fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
+        fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
         fprintf(svgfile, "<title>#%d waiting %s</title>\n", cpu, time_to_string(end - start));
         if (backtrace)
                 fprintf(svgfile, "<desc>Waiting on:\n%s</desc>\n", backtrace);
-        fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
+        fprintf(svgfile, "<rect x=\"0\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
                 time2pixels(end)-time2pixels(start), SLOT_HEIGHT, style);
         if (font_size > MIN_TEXT_SIZE)
-                fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%1.8fpt\"> %s</text>\n",
+                fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%.8fpt\"> %s</text>\n",
                         font_size, text);
         fprintf(svgfile, "</g>\n");
 }
@@ -289,16 +365,16 @@ void svg_cpu_box(int cpu, u64 __max_freq, u64 __turbo_freq)
 
         fprintf(svgfile, "<g>\n");
 
-        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"cpu\"/>\n",
+        fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"cpu\"/>\n",
                 time2pixels(first_time),
                 time2pixels(last_time)-time2pixels(first_time),
                 cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
 
         sprintf(cpu_string, "CPU %i", (int)cpu);
-        fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
+        fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\">%s</text>\n",
                 10+time2pixels(first_time), cpu2y(cpu) + SLOT_HEIGHT/2, cpu_string);
 
-        fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\" font-size=\"1.25pt\">%s</text>\n",
+        fprintf(svgfile, "<text transform=\"translate(%.8f,%.8f)\" font-size=\"1.25pt\">%s</text>\n",
                 10+time2pixels(first_time), cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - 4, cpu_model());
 
         fprintf(svgfile, "</g>\n");
@@ -319,11 +395,11 @@ void svg_process(int cpu, u64 start, u64 end, int pid, const char *name, const c
         else
                 type = "sample";
 
-        fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), cpu2y(cpu));
+        fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\">\n", time2pixels(start), cpu2y(cpu));
         fprintf(svgfile, "<title>%d %s running %s</title>\n", pid, name, time_to_string(end - start));
         if (backtrace)
                 fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
-        fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
+        fprintf(svgfile, "<rect x=\"0\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
                 time2pixels(end)-time2pixels(start), SLOT_MULT+SLOT_HEIGHT, type);
         width = time2pixels(end)-time2pixels(start);
         if (width > 6)
@@ -332,7 +408,7 @@ void svg_process(int cpu, u64 start, u64 end, int pid, const char *name, const c
         width = round_text_size(width);
 
         if (width > MIN_TEXT_SIZE)
-                fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%3.8fpt\">%s</text>\n",
+                fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%.8fpt\">%s</text>\n",
                         width, name);
 
         fprintf(svgfile, "</g>\n");
@@ -353,7 +429,7 @@ void svg_cstate(int cpu, u64 start, u64 end, int type)
                 type = 6;
         sprintf(style, "c%i", type);
 
-        fprintf(svgfile, "<rect class=\"%s\" x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\"/>\n",
+        fprintf(svgfile, "<rect class=\"%s\" x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\"/>\n",
                 style,
                 time2pixels(start), time2pixels(end)-time2pixels(start),
                 cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
@@ -365,7 +441,7 @@ void svg_cstate(int cpu, u64 start, u64 end, int type)
         width = round_text_size(width);
 
         if (width > MIN_TEXT_SIZE)
-                fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"%3.8fpt\">C%i</text>\n",
+                fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\" font-size=\"%.8fpt\">C%i</text>\n",
                         time2pixels(start), cpu2y(cpu)+width, width, type);
 
         fprintf(svgfile, "</g>\n");
@@ -407,9 +483,9 @@ void svg_pstate(int cpu, u64 start, u64 end, u64 freq)
         if (max_freq)
                 height = freq * 1.0 / max_freq * (SLOT_HEIGHT + SLOT_MULT);
         height = 1 + cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - height;
-        fprintf(svgfile, "<line x1=\"%4.8f\" x2=\"%4.8f\" y1=\"%4.1f\" y2=\"%4.1f\" class=\"pstate\"/>\n",
+        fprintf(svgfile, "<line x1=\"%.8f\" x2=\"%.8f\" y1=\"%.1f\" y2=\"%.1f\" class=\"pstate\"/>\n",
                 time2pixels(start), time2pixels(end), height, height);
-        fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"0.25pt\">%s</text>\n",
+        fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\" font-size=\"0.25pt\">%s</text>\n",
                 time2pixels(start), height+0.9, HzToHuman(freq));
 
         fprintf(svgfile, "</g>\n");
@@ -435,32 +511,32 @@ void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc
 
         if (row1 < row2) {
                 if (row1) {
-                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                        fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
                                 time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
                         if (desc2)
-                                fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &gt;</text></g>\n",
+                                fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &gt;</text></g>\n",
                                         time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_HEIGHT/48, desc2);
                 }
                 if (row2) {
-                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                        fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
                                 time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32,  time2pixels(start), row2 * SLOT_MULT);
                         if (desc1)
-                                fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &gt;</text></g>\n",
+                                fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &gt;</text></g>\n",
                                         time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, desc1);
                 }
         } else {
                 if (row2) {
-                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                        fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
                                 time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
                         if (desc1)
-                                fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &lt;</text></g>\n",
+                                fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &lt;</text></g>\n",
                                         time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/48, desc1);
                 }
                 if (row1) {
-                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                        fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
                                 time2pixels(start), row1 * SLOT_MULT - SLOT_MULT/32,  time2pixels(start), row1 * SLOT_MULT);
                         if (desc2)
-                                fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &lt;</text></g>\n",
+                                fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s &lt;</text></g>\n",
                                         time2pixels(start), row1 * SLOT_MULT - SLOT_HEIGHT/32, desc2);
                 }
         }
@@ -468,7 +544,7 @@ void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc
         if (row2 > row1)
                 height += SLOT_HEIGHT;
         if (row1)
-                fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(32,255,32)\"/>\n",
+                fprintf(svgfile, "<circle  cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\"  style=\"fill:rgb(32,255,32)\"/>\n",
                         time2pixels(start), height);
 
         fprintf(svgfile, "</g>\n");
@@ -488,16 +564,16 @@ void svg_wakeline(u64 start, int row1, int row2, const char *backtrace)
                 fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
 
         if (row1 < row2)
-                fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
                         time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row2 * SLOT_MULT);
         else
-                fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
                         time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row1 * SLOT_MULT);
 
         height = row1 * SLOT_MULT;
         if (row2 > row1)
                 height += SLOT_HEIGHT;
-        fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(32,255,32)\"/>\n",
+        fprintf(svgfile, "<circle  cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\"  style=\"fill:rgb(32,255,32)\"/>\n",
                         time2pixels(start), height);
 
         fprintf(svgfile, "</g>\n");
@@ -515,9 +591,9 @@ void svg_interrupt(u64 start, int row, const char *backtrace)
         if (backtrace)
                 fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
 
-        fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(255,128,128)\"/>\n",
+        fprintf(svgfile, "<circle  cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\"  style=\"fill:rgb(255,128,128)\"/>\n",
                         time2pixels(start), row * SLOT_MULT);
-        fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(255,128,128)\"/>\n",
+        fprintf(svgfile, "<circle  cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\"  style=\"fill:rgb(255,128,128)\"/>\n",
                         time2pixels(start), row * SLOT_MULT + SLOT_HEIGHT);
 
         fprintf(svgfile, "</g>\n");
@@ -528,7 +604,7 @@ void svg_text(int Yslot, u64 start, const char *text)
         if (!svgfile)
                 return;
 
-        fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
+        fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\">%s</text>\n",
                 time2pixels(start), Yslot * SLOT_MULT+SLOT_HEIGHT/2, text);
 }
 
@@ -537,12 +613,26 @@ static void svg_legenda_box(int X, const char *text, const char *style)
         double boxsize;
         boxsize = SLOT_HEIGHT / 2;
 
-        fprintf(svgfile, "<rect x=\"%i\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
+        fprintf(svgfile, "<rect x=\"%i\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
                 X, boxsize, boxsize, style);
-        fprintf(svgfile, "<text transform=\"translate(%4.8f, %4.8f)\" font-size=\"%4.8fpt\">%s</text>\n",
+        fprintf(svgfile, "<text transform=\"translate(%.8f, %.8f)\" font-size=\"%.8fpt\">%s</text>\n",
                 X + boxsize + 5, boxsize, 0.8 * boxsize, text);
 }
 
+void svg_io_legenda(void)
+{
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<g>\n");
+        svg_legenda_box(0,      "Disk", "disk");
+        svg_legenda_box(100,    "Network", "net");
+        svg_legenda_box(200,    "Sync", "sync");
+        svg_legenda_box(300,    "Poll", "poll");
+        svg_legenda_box(400,    "Error", "error");
+        fprintf(svgfile, "</g>\n");
+}
+
 void svg_legenda(void)
 {
         if (!svgfile)
@@ -559,7 +649,7 @@ void svg_legenda(void)
         fprintf(svgfile, "</g>\n");
 }
 
-void svg_time_grid(void)
+void svg_time_grid(double min_thickness)
 {
         u64 i;
 
@@ -579,8 +669,10 @@ void svg_time_grid(void)
                         color = 128;
                 }
 
-                fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%" PRIu64 "\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%1.3f\"/>\n",
-                        time2pixels(i), SLOT_MULT/2, time2pixels(i), total_height, color, color, color, thickness);
+                if (thickness >= min_thickness)
+                        fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%" PRIu64 "\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%.3f\"/>\n",
+                                time2pixels(i), SLOT_MULT/2, time2pixels(i),
+                                total_height, color, color, color, thickness);
 
                 i += 10000000;
         }
diff --git a/tools/perf/util/svghelper.h b/tools/perf/util/svghelper.h
index e3aff5332e30..9292a5291445 100644
--- a/tools/perf/util/svghelper.h
+++ b/tools/perf/util/svghelper.h
@@ -4,6 +4,9 @@
 #include <linux/types.h>
 
 extern void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end);
+extern void svg_ubox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges);
+extern void svg_lbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges);
+extern void svg_fbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges);
 extern void svg_box(int Yslot, u64 start, u64 end, const char *type);
 extern void svg_blocked(int Yslot, int cpu, u64 start, u64 end, const char *backtrace);
 extern void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace);
@@ -16,7 +19,8 @@ extern void svg_cstate(int cpu, u64 start, u64 end, int type);
 extern void svg_pstate(int cpu, u64 start, u64 end, u64 freq);
 
 
-extern void svg_time_grid(void);
+extern void svg_time_grid(double min_thickness);
+extern void svg_io_legenda(void);
 extern void svg_legenda(void);
 extern void svg_wakeline(u64 start, int row1, int row2, const char *backtrace);
 extern void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc2, const char *backtrace);
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 6864661a79dd..d75349979e65 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -49,7 +49,8 @@ static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 
 static inline int elf_sym__is_function(const GElf_Sym *sym)
 {
-        return elf_sym__type(sym) == STT_FUNC &&
+        return (elf_sym__type(sym) == STT_FUNC ||
+                elf_sym__type(sym) == STT_GNU_IFUNC) &&
                sym->st_name != 0 &&
                sym->st_shndx != SHN_UNDEF;
 }
@@ -598,6 +599,8 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
                         goto out_elf_end;
         }
 
+        ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
+
         ss->symtab = elf_section_by_name(elf, &ehdr, &ss->symshdr, ".symtab",
                         NULL);
         if (ss->symshdr.sh_type != SHT_SYMTAB)
@@ -619,7 +622,7 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
                 GElf_Shdr shdr;
                 ss->adjust_symbols = (ehdr.e_type == ET_EXEC ||
                                 ehdr.e_type == ET_REL ||
-                                is_vdso_map(dso->short_name) ||
+                                dso__is_vdso(dso) ||
                                 elf_section_by_name(elf, &ehdr, &shdr,
                                                      ".gnu.prelink_undo",
                                                      NULL) != NULL);
@@ -698,6 +701,7 @@ int dso__load_sym(struct dso *dso, struct map *map,
         bool remap_kernel = false, adjust_kernel_syms = false;
 
         dso->symtab_type = syms_ss->type;
+        dso->is_64_bit = syms_ss->is_64_bit;
         dso->rel = syms_ss->ehdr.e_type == ET_REL;
 
         /*
@@ -1024,6 +1028,39 @@ int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
         return err;
 }
 
+enum dso_type dso__type_fd(int fd)
+{
+        enum dso_type dso_type = DSO__TYPE_UNKNOWN;
+        GElf_Ehdr ehdr;
+        Elf_Kind ek;
+        Elf *elf;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL)
+                goto out;
+
+        ek = elf_kind(elf);
+        if (ek != ELF_K_ELF)
+                goto out_end;
+
+        if (gelf_getclass(elf) == ELFCLASS64) {
+                dso_type = DSO__TYPE_64BIT;
+                goto out_end;
+        }
+
+        if (gelf_getehdr(elf, &ehdr) == NULL)
+                goto out_end;
+
+        if (ehdr.e_machine == EM_X86_64)
+                dso_type = DSO__TYPE_X32BIT;
+        else
+                dso_type = DSO__TYPE_32BIT;
+out_end:
+        elf_end(elf);
+out:
+        return dso_type;
+}
+
 static int copy_bytes(int from, off_t from_offs, int to, off_t to_offs, u64 len)
 {
         ssize_t r;
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index bd15f490d04f..c9541fea9514 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -288,6 +288,44 @@ int dso__synthesize_plt_symbols(struct dso *dso __maybe_unused,
         return 0;
 }
 
+static int fd__is_64_bit(int fd)
+{
+        u8 e_ident[EI_NIDENT];
+
+        if (lseek(fd, 0, SEEK_SET))
+                return -1;
+
+        if (readn(fd, e_ident, sizeof(e_ident)) != sizeof(e_ident))
+                return -1;
+
+        if (memcmp(e_ident, ELFMAG, SELFMAG) ||
+            e_ident[EI_VERSION] != EV_CURRENT)
+                return -1;
+
+        return e_ident[EI_CLASS] == ELFCLASS64;
+}
+
+enum dso_type dso__type_fd(int fd)
+{
+        Elf64_Ehdr ehdr;
+        int ret;
+
+        ret = fd__is_64_bit(fd);
+        if (ret < 0)
+                return DSO__TYPE_UNKNOWN;
+
+        if (ret)
+                return DSO__TYPE_64BIT;
+
+        if (readn(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
+                return DSO__TYPE_UNKNOWN;
+
+        if (ehdr.e_machine == EM_X86_64)
+                return DSO__TYPE_X32BIT;
+
+        return DSO__TYPE_32BIT;
+}
+
 int dso__load_sym(struct dso *dso, struct map *map __maybe_unused,
                   struct symsrc *ss,
                   struct symsrc *runtime_ss __maybe_unused,
@@ -295,6 +333,11 @@ int dso__load_sym(struct dso *dso, struct map *map __maybe_unused,
                   int kmodule __maybe_unused)
 {
         unsigned char *build_id[BUILD_ID_SIZE];
+        int ret;
+
+        ret = fd__is_64_bit(ss->fd);
+        if (ret >= 0)
+                dso->is_64_bit = ret;
 
         if (filename__read_build_id(ss->name, build_id, BUILD_ID_SIZE) > 0) {
                 dso__set_build_id(dso, build_id);
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 7b9096f29cdb..eb06746b06b2 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -34,6 +34,7 @@ struct symbol_conf symbol_conf = {
         .annotate_src           = true,
         .demangle               = true,
         .cumulate_callchain     = true,
+        .show_hist_headers      = true,
         .symfs                  = "",
 };
 
@@ -341,6 +342,16 @@ static struct symbol *symbols__first(struct rb_root *symbols)
         return NULL;
 }
 
+static struct symbol *symbols__next(struct symbol *sym)
+{
+        struct rb_node *n = rb_next(&sym->rb_node);
+
+        if (n)
+                return rb_entry(n, struct symbol, rb_node);
+
+        return NULL;
+}
+
 struct symbol_name_rb_node {
         struct rb_node  rb_node;
         struct symbol   sym;
@@ -411,11 +422,16 @@ struct symbol *dso__find_symbol(struct dso *dso,
         return symbols__find(&dso->symbols[type], addr);
 }
 
-static struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
+struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
 {
         return symbols__first(&dso->symbols[type]);
 }
 
+struct symbol *dso__next_symbol(struct symbol *sym)
+{
+        return symbols__next(sym);
+}
+
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
                                         const char *name)
 {
@@ -1064,6 +1080,7 @@ static int dso__load_kcore(struct dso *dso, struct map *map,
                               &is_64_bit);
         if (err)
                 goto out_err;
+        dso->is_64_bit = is_64_bit;
 
         if (list_empty(&md.maps)) {
                 err = -EINVAL;
@@ -1662,6 +1679,7 @@ do_kallsyms:
         free(kallsyms_allocated_filename);
 
         if (err > 0 && !dso__is_kcore(dso)) {
+                dso->binary_type = DSO_BINARY_TYPE__KALLSYMS;
                 dso__set_long_name(dso, "[kernel.kallsyms]", false);
                 map__fixup_start(map);
                 map__fixup_end(map);
@@ -1709,6 +1727,7 @@ static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
         if (err > 0)
                 pr_debug("Using %s for symbols\n", kallsyms_filename);
         if (err > 0 && !dso__is_kcore(dso)) {
+                dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
                 machine__mmap_name(machine, path, sizeof(path));
                 dso__set_long_name(dso, strdup(path), true);
                 map__fixup_start(map);
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 615c752dd767..e7295e93cff9 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -118,7 +118,8 @@ struct symbol_conf {
                         annotate_src,
                         event_group,
                         demangle,
-                        filter_relative;
+                        filter_relative,
+                        show_hist_headers;
         const char      *vmlinux_name,
                         *kallsyms_name,
                         *source_prefix,
@@ -215,6 +216,7 @@ struct symsrc {
         GElf_Shdr dynshdr;
 
         bool adjust_symbols;
+        bool is_64_bit;
 #endif
 };
 
@@ -238,6 +240,11 @@ struct symbol *dso__find_symbol(struct dso *dso, enum map_type type,
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
                                         const char *name);
 
+struct symbol *dso__first_symbol(struct dso *dso, enum map_type type);
+struct symbol *dso__next_symbol(struct symbol *sym);
+
+enum dso_type dso__type_fd(int fd);
+
 int filename__read_build_id(const char *filename, void *bf, size_t size);
 int sysfs__read_build_id(const char *filename, void *bf, size_t size);
 int modules__parse(const char *filename, void *arg,
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 2fde0d5e40b5..12c7a253a63c 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -13,7 +13,7 @@ int thread__init_map_groups(struct thread *thread, struct machine *machine)
         struct thread *leader;
         pid_t pid = thread->pid_;
 
-        if (pid == thread->tid) {
+        if (pid == thread->tid || pid == -1) {
                 thread->mg = map_groups__new();
         } else {
                 leader = machine__findnew_thread(machine, pid, pid);
@@ -34,6 +34,7 @@ struct thread *thread__new(pid_t pid, pid_t tid)
                 thread->pid_ = pid;
                 thread->tid = tid;
                 thread->ppid = -1;
+                thread->cpu = -1;
                 INIT_LIST_HEAD(&thread->comm_list);
 
                 comm_str = malloc(32);
@@ -60,8 +61,10 @@ void thread__delete(struct thread *thread)
 {
         struct comm *comm, *tmp;
 
-        map_groups__put(thread->mg);
-        thread->mg = NULL;
+        if (thread->mg) {
+                map_groups__put(thread->mg);
+                thread->mg = NULL;
+        }
         list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) {
                 list_del(&comm->list);
                 comm__free(comm);
@@ -127,12 +130,12 @@ int thread__comm_len(struct thread *thread)
 size_t thread__fprintf(struct thread *thread, FILE *fp)
 {
         return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) +
-               map_groups__fprintf(thread->mg, verbose, fp);
+               map_groups__fprintf(thread->mg, fp);
 }
 
 void thread__insert_map(struct thread *thread, struct map *map)
 {
-        map_groups__fixup_overlappings(thread->mg, map, verbose, stderr);
+        map_groups__fixup_overlappings(thread->mg, map, stderr);
         map_groups__insert(thread->mg, map);
 }
 
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 3c0c2724f82c..716b7723cce2 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -17,6 +17,7 @@ struct thread {
         pid_t                   pid_; /* Not all tools update this */
         pid_t                   tid;
         pid_t                   ppid;
+        int                     cpu;
         char                    shortname[3];
         bool                    comm_set;
         bool                    dead; /* if set thread has exited */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 7e6fcfe8b438..eb72716017ac 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -40,6 +40,7 @@
 #include "trace-event.h"
 #include <api/fs/debugfs.h>
 #include "evsel.h"
+#include "debug.h"
 
 #define VERSION "0.5"
 
@@ -191,12 +192,10 @@ static int copy_event_system(const char *sys, struct tracepoint_path *tps)
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
-                format = malloc(strlen(sys) + strlen(dent->d_name) + 10);
-                if (!format) {
+                if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
                         err = -ENOMEM;
                         goto out;
                 }
-                sprintf(format, "%s/%s/format", sys, dent->d_name);
                 ret = stat(format, &st);
                 free(format);
                 if (ret < 0)
@@ -217,12 +216,10 @@ static int copy_event_system(const char *sys, struct tracepoint_path *tps)
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
-                format = malloc(strlen(sys) + strlen(dent->d_name) + 10);
-                if (!format) {
+                if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
                         err = -ENOMEM;
                         goto out;
                 }
-                sprintf(format, "%s/%s/format", sys, dent->d_name);
                 ret = stat(format, &st);
 
                 if (ret >= 0) {
@@ -317,12 +314,10 @@ static int record_event_files(struct tracepoint_path *tps)
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
                         continue;
-                sys = malloc(strlen(path) + strlen(dent->d_name) + 2);
-                if (!sys) {
+                if (asprintf(&sys, "%s/%s", path, dent->d_name) < 0) {
                         err = -ENOMEM;
                         goto out;
                 }
-                sprintf(sys, "%s/%s", path, dent->d_name);
                 ret = stat(sys, &st);
                 if (ret >= 0) {
                         ssize_t size = strlen(dent->d_name) + 1;
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index e113e180c48f..54d9e9b548a8 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -22,7 +22,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <getopt.h>
 #include <stdarg.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -36,6 +35,7 @@
 #include "../perf.h"
 #include "util.h"
 #include "trace-event.h"
+#include "debug.h"
 
 static int input_fd;
 
diff --git a/tools/perf/util/tsc.c b/tools/perf/util/tsc.c
new file mode 100644
index 000000000000..4d4210d4e13d
--- /dev/null
+++ b/tools/perf/util/tsc.c
@@ -0,0 +1,30 @@
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+#include "tsc.h"
+
+u64 perf_time_to_tsc(u64 ns, struct perf_tsc_conversion *tc)
+{
+        u64 t, quot, rem;
+
+        t = ns - tc->time_zero;
+        quot = t / tc->time_mult;
+        rem  = t % tc->time_mult;
+        return (quot << tc->time_shift) +
+               (rem << tc->time_shift) / tc->time_mult;
+}
+
+u64 tsc_to_perf_time(u64 cyc, struct perf_tsc_conversion *tc)
+{
+        u64 quot, rem;
+
+        quot = cyc >> tc->time_shift;
+        rem  = cyc & ((1 << tc->time_shift) - 1);
+        return tc->time_zero + quot * tc->time_mult +
+               ((rem * tc->time_mult) >> tc->time_shift);
+}
+
+u64 __weak rdtsc(void)
+{
+        return 0;
+}
diff --git a/tools/perf/util/tsc.h b/tools/perf/util/tsc.h
new file mode 100644
index 000000000000..a8b78f1b3243
--- /dev/null
+++ b/tools/perf/util/tsc.h
@@ -0,0 +1,12 @@
+#ifndef __PERF_TSC_H
+#define __PERF_TSC_H
+
+#include <linux/types.h>
+
+#include "../arch/x86/util/tsc.h"
+
+u64 perf_time_to_tsc(u64 ns, struct perf_tsc_conversion *tc);
+u64 tsc_to_perf_time(u64 cyc, struct perf_tsc_conversion *tc);
+u64 rdtsc(void);
+
+#endif
diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c
index 5ec80a575b50..7419768c38b1 100644
--- a/tools/perf/util/unwind-libdw.c
+++ b/tools/perf/util/unwind-libdw.c
@@ -3,6 +3,7 @@
 #include <elfutils/libdwfl.h>
 #include <inttypes.h>
 #include <errno.h>
+#include "debug.h"
 #include "unwind.h"
 #include "unwind-libdw.h"
 #include "machine.h"
diff --git a/tools/perf/util/unwind-libunwind.c b/tools/perf/util/unwind-libunwind.c
index 25578b98f5c5..92b56db52471 100644
--- a/tools/perf/util/unwind-libunwind.c
+++ b/tools/perf/util/unwind-libunwind.c
@@ -30,6 +30,7 @@
 #include "unwind.h"
 #include "symbol.h"
 #include "util.h"
+#include "debug.h"
 
 extern int
 UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 95aefa78bb07..e52e7461911b 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -1,5 +1,6 @@
 #include "../perf.h"
 #include "util.h"
+#include "debug.h"
 #include <api/fs/fs.h>
 #include <sys/mman.h>
 #ifdef HAVE_BACKTRACE_SUPPORT
@@ -333,12 +334,9 @@ const char *find_tracing_dir(void)
         if (!debugfs)
                 return NULL;
 
-        tracing = malloc(strlen(debugfs) + 9);
-        if (!tracing)
+        if (asprintf(&tracing, "%s/tracing", debugfs) < 0)
                 return NULL;
 
-        sprintf(tracing, "%s/tracing", debugfs);
-
         tracing_found = 1;
         return tracing;
 }
@@ -352,11 +350,9 @@ char *get_tracing_file(const char *name)
         if (!tracing)
                 return NULL;
 
-        file = malloc(strlen(tracing) + strlen(name) + 2);
-        if (!file)
+        if (asprintf(&file, "%s/%s", tracing, name) < 0)
                 return NULL;
 
-        sprintf(file, "%s/%s", tracing, name);
         return file;
 }
 
diff --git a/tools/perf/util/vdso.c b/tools/perf/util/vdso.c
index 0ddb3b8a89ec..adca69384fcc 100644
--- a/tools/perf/util/vdso.c
+++ b/tools/perf/util/vdso.c
@@ -11,10 +11,34 @@
 #include "vdso.h"
 #include "util.h"
 #include "symbol.h"
+#include "machine.h"
 #include "linux/string.h"
+#include "debug.h"
 
-static bool vdso_found;
-static char vdso_file[] = "/tmp/perf-vdso.so-XXXXXX";
+#define VDSO__TEMP_FILE_NAME "/tmp/perf-vdso.so-XXXXXX"
+
+struct vdso_file {
+        bool found;
+        bool error;
+        char temp_file_name[sizeof(VDSO__TEMP_FILE_NAME)];
+        const char *dso_name;
+};
+
+struct vdso_info {
+        struct vdso_file vdso;
+};
+
+static struct vdso_info *vdso_info__new(void)
+{
+        static const struct vdso_info vdso_info_init = {
+                .vdso    = {
+                        .temp_file_name = VDSO__TEMP_FILE_NAME,
+                        .dso_name = DSO__NAME_VDSO,
+                },
+        };
+
+        return memdup(&vdso_info_init, sizeof(vdso_info_init));
+}
 
 static int find_vdso_map(void **start, void **end)
 {
@@ -47,7 +71,7 @@ static int find_vdso_map(void **start, void **end)
         return !found;
 }
 
-static char *get_file(void)
+static char *get_file(struct vdso_file *vdso_file)
 {
         char *vdso = NULL;
         char *buf = NULL;
@@ -55,10 +79,10 @@ static char *get_file(void)
         size_t size;
         int fd;
 
-        if (vdso_found)
-                return vdso_file;
+        if (vdso_file->found)
+                return vdso_file->temp_file_name;
 
-        if (find_vdso_map(&start, &end))
+        if (vdso_file->error || find_vdso_map(&start, &end))
                 return NULL;
 
         size = end - start;
@@ -67,45 +91,78 @@ static char *get_file(void)
         if (!buf)
                 return NULL;
 
-        fd = mkstemp(vdso_file);
+        fd = mkstemp(vdso_file->temp_file_name);
         if (fd < 0)
                 goto out;
 
         if (size == (size_t) write(fd, buf, size))
-                vdso = vdso_file;
+                vdso = vdso_file->temp_file_name;
 
         close(fd);
 
  out:
         free(buf);
 
-        vdso_found = (vdso != NULL);
+        vdso_file->found = (vdso != NULL);
+        vdso_file->error = !vdso_file->found;
         return vdso;
 }
 
-void vdso__exit(void)
+void vdso__exit(struct machine *machine)
 {
-        if (vdso_found)
-                unlink(vdso_file);
+        struct vdso_info *vdso_info = machine->vdso_info;
+
+        if (!vdso_info)
+                return;
+
+        if (vdso_info->vdso.found)
+                unlink(vdso_info->vdso.temp_file_name);
+
+        zfree(&machine->vdso_info);
 }
 
-struct dso *vdso__dso_findnew(struct list_head *head)
+static struct dso *vdso__new(struct machine *machine, const char *short_name,
+                             const char *long_name)
 {
-        struct dso *dso = dsos__find(head, VDSO__MAP_NAME, true);
+        struct dso *dso;
 
+        dso = dso__new(short_name);
+        if (dso != NULL) {
+                dsos__add(&machine->user_dsos, dso);
+                dso__set_long_name(dso, long_name, false);
+        }
+
+        return dso;
+}
+
+struct dso *vdso__dso_findnew(struct machine *machine,
+                              struct thread *thread __maybe_unused)
+{
+        struct vdso_info *vdso_info;
+        struct dso *dso;
+
+        if (!machine->vdso_info)
+                machine->vdso_info = vdso_info__new();
+
+        vdso_info = machine->vdso_info;
+        if (!vdso_info)
+                return NULL;
+
+        dso = dsos__find(&machine->user_dsos, DSO__NAME_VDSO, true);
         if (!dso) {
                 char *file;
 
-                file = get_file();
+                file = get_file(&vdso_info->vdso);
                 if (!file)
                         return NULL;
 
-                dso = dso__new(VDSO__MAP_NAME);
-                if (dso != NULL) {
-                        dsos__add(head, dso);
-                        dso__set_long_name(dso, file, false);
-                }
+                dso = vdso__new(machine, DSO__NAME_VDSO, file);
         }
 
         return dso;
 }
+
+bool dso__is_vdso(struct dso *dso)
+{
+        return !strcmp(dso->short_name, DSO__NAME_VDSO);
+}
diff --git a/tools/perf/util/vdso.h b/tools/perf/util/vdso.h
index 0f76e7caf6f8..af9d6929a215 100644
--- a/tools/perf/util/vdso.h
+++ b/tools/perf/util/vdso.h
@@ -7,12 +7,21 @@
 
 #define VDSO__MAP_NAME "[vdso]"
 
+#define DSO__NAME_VDSO "[vdso]"
+
 static inline bool is_vdso_map(const char *filename)
 {
         return !strcmp(filename, VDSO__MAP_NAME);
 }
 
-struct dso *vdso__dso_findnew(struct list_head *head);
-void vdso__exit(void);
+struct dso;
+
+bool dso__is_vdso(struct dso *dso);
+
+struct machine;
+struct thread;
+
+struct dso *vdso__dso_findnew(struct machine *machine, struct thread *thread);
+void vdso__exit(struct machine *machine);
 
 #endif /* __PERF_VDSO__ */
diff --git a/tools/power/acpi/Makefile b/tools/power/acpi/Makefile
index e5a3c4be2a10..3d1537b93c64 100644
--- a/tools/power/acpi/Makefile
+++ b/tools/power/acpi/Makefile
@@ -108,13 +108,18 @@ DUMP_OBJS = \
         apmain.o\
         osunixdir.o\
         osunixmap.o\
+        osunixxf.o\
         tbprint.o\
         tbxfroot.o\
         utbuffer.o\
+        utdebug.o\
         utexcep.o\
+        utglobal.o\
         utmath.o\
+        utprint.o\
         utstring.o\
         utxferror.o\
+        oslibcfs.o\
         oslinuxtbl.o\
         cmfsize.o\
         getopt.o
diff --git a/tools/power/acpi/common/cmfsize.c b/tools/power/acpi/common/cmfsize.c
index 5140e5edae1f..f4b953354ff7 100644
--- a/tools/power/acpi/common/cmfsize.c
+++ b/tools/power/acpi/common/cmfsize.c
@@ -58,44 +58,46 @@ ACPI_MODULE_NAME("cmfsize")
  * RETURN:      File Size. On error, -1 (ACPI_UINT32_MAX)
  *
  * DESCRIPTION: Get the size of a file. Uses seek-to-EOF. File must be open.
- *              Does not disturb the current file pointer. Uses perror for
- *              error messages.
+ *              Does not disturb the current file pointer.
  *
  ******************************************************************************/
-u32 cm_get_file_size(FILE * file)
+u32 cm_get_file_size(ACPI_FILE file)
 {
         long file_size;
         long current_offset;
+        acpi_status status;
 
         /* Save the current file pointer, seek to EOF to obtain file size */
 
-        current_offset = ftell(file);
+        current_offset = acpi_os_get_file_offset(file);
         if (current_offset < 0) {
                 goto offset_error;
         }
 
-        if (fseek(file, 0, SEEK_END)) {
+        status = acpi_os_set_file_offset(file, 0, ACPI_FILE_END);
+        if (ACPI_FAILURE(status)) {
                 goto seek_error;
         }
 
-        file_size = ftell(file);
+        file_size = acpi_os_get_file_offset(file);
         if (file_size < 0) {
                 goto offset_error;
         }
 
         /* Restore original file pointer */
 
-        if (fseek(file, current_offset, SEEK_SET)) {
+        status = acpi_os_set_file_offset(file, current_offset, ACPI_FILE_BEGIN);
+        if (ACPI_FAILURE(status)) {
                 goto seek_error;
         }
 
         return ((u32)file_size);
 
 offset_error:
-        perror("Could not get file offset");
+        acpi_log_error("Could not get file offset");
         return (ACPI_UINT32_MAX);
 
 seek_error:
-        perror("Could not seek file");
+        acpi_log_error("Could not set file offset");
         return (ACPI_UINT32_MAX);
 }
diff --git a/tools/power/acpi/common/getopt.c b/tools/power/acpi/common/getopt.c
index a302f52e4fd3..2f0f34a36db4 100644
--- a/tools/power/acpi/common/getopt.c
+++ b/tools/power/acpi/common/getopt.c
@@ -51,14 +51,12 @@
  *    "f|"      - Option has required single-char sub-options
  */
 
-#include <stdio.h>
-#include <string.h>
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "acapps.h"
 
 #define ACPI_OPTION_ERROR(msg, badchar) \
-        if (acpi_gbl_opterr) {fprintf (stderr, "%s%c\n", msg, badchar);}
+        if (acpi_gbl_opterr) {acpi_log_error ("%s%c\n", msg, badchar);}
 
 int acpi_gbl_opterr = 1;
 int acpi_gbl_optind = 1;
@@ -113,7 +111,7 @@ int acpi_getopt_argument(int argc, char **argv)
  * PARAMETERS:  argc, argv          - from main
  *              opts                - options info list
  *
- * RETURN:      Option character or EOF
+ * RETURN:      Option character or ACPI_OPT_END
  *
  * DESCRIPTION: Get the next option
  *
@@ -128,10 +126,10 @@ int acpi_getopt(int argc, char **argv, char *opts)
                 if (acpi_gbl_optind >= argc ||
                     argv[acpi_gbl_optind][0] != '-' ||
                     argv[acpi_gbl_optind][1] == '\0') {
-                        return (EOF);
-                } else if (strcmp(argv[acpi_gbl_optind], "--") == 0) {
+                        return (ACPI_OPT_END);
+                } else if (ACPI_STRCMP(argv[acpi_gbl_optind], "--") == 0) {
                         acpi_gbl_optind++;
-                        return (EOF);
+                        return (ACPI_OPT_END);
                 }
         }
 
@@ -142,7 +140,7 @@ int acpi_getopt(int argc, char **argv, char *opts)
         /* Make sure that the option is legal */
 
         if (current_char == ':' ||
-            (opts_ptr = strchr(opts, current_char)) == NULL) {
+            (opts_ptr = ACPI_STRCHR(opts, current_char)) == NULL) {
                 ACPI_OPTION_ERROR("Illegal option: -", current_char);
 
                 if (argv[acpi_gbl_optind][++current_char_ptr] == '\0') {
diff --git a/tools/power/acpi/os_specific/service_layers/oslibcfs.c b/tools/power/acpi/os_specific/service_layers/oslibcfs.c
new file mode 100644
index 000000000000..c13ff9c51d74
--- /dev/null
+++ b/tools/power/acpi/os_specific/service_layers/oslibcfs.c
@@ -0,0 +1,214 @@
+/******************************************************************************
+ *
+ * Module Name: oslibcfs - C library OSL for file I/O
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <acpi/acpi.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#define _COMPONENT          ACPI_OS_SERVICES
+ACPI_MODULE_NAME("oslibcfs")
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_os_open_file
+ *
+ * PARAMETERS:  path                - File path
+ *              modes               - File operation type
+ *
+ * RETURN:      File descriptor.
+ *
+ * DESCRIPTION: Open a file for reading (ACPI_FILE_READING) or/and writing
+ *              (ACPI_FILE_WRITING).
+ *
+ ******************************************************************************/
+ACPI_FILE acpi_os_open_file(const char *path, u8 modes)
+{
+        ACPI_FILE file;
+        u32 i = 0;
+        char modes_str[4];
+
+        if (modes & ACPI_FILE_READING) {
+                modes_str[i++] = 'r';
+        }
+        if (modes & ACPI_FILE_WRITING) {
+                modes_str[i++] = 'w';
+        }
+        if (modes & ACPI_FILE_BINARY) {
+                modes_str[i++] = 'b';
+        }
+
+        modes_str[i++] = '\0';
+
+        file = fopen(path, modes_str);
+        if (!file) {
+                perror("Could not open file");
+        }
+
+        return (file);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_os_close_file
+ *
+ * PARAMETERS:  file                - An open file descriptor
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Close a file opened via acpi_os_open_file.
+ *
+ ******************************************************************************/
+
+void acpi_os_close_file(ACPI_FILE file)
+{
+        fclose(file);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_os_read_file
+ *
+ * PARAMETERS:  file                - An open file descriptor
+ *              buffer              - Data buffer
+ *              size                - Data block size
+ *              count               - Number of data blocks
+ *
+ * RETURN:      Number of bytes actually read.
+ *
+ * DESCRIPTION: Read from a file.
+ *
+ ******************************************************************************/
+
+int
+acpi_os_read_file(ACPI_FILE file, void *buffer, acpi_size size, acpi_size count)
+{
+        int length;
+
+        length = fread(buffer, size, count, file);
+        if (length < 0) {
+                perror("Error reading file");
+        }
+
+        return (length);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_os_write_file
+ *
+ * PARAMETERS:  file                - An open file descriptor
+ *              buffer              - Data buffer
+ *              size                - Data block size
+ *              count               - Number of data blocks
+ *
+ * RETURN:      Number of bytes actually written.
+ *
+ * DESCRIPTION: Write to a file.
+ *
+ ******************************************************************************/
+
+int
+acpi_os_write_file(ACPI_FILE file,
+                   void *buffer, acpi_size size, acpi_size count)
+{
+        int length;
+
+        length = fwrite(buffer, size, count, file);
+        if (length < 0) {
+                perror("Error writing file");
+        }
+
+        return (length);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_os_get_file_offset
+ *
+ * PARAMETERS:  file                - An open file descriptor
+ *
+ * RETURN:      Current file pointer position.
+ *
+ * DESCRIPTION: Get current file offset.
+ *
+ ******************************************************************************/
+
+long acpi_os_get_file_offset(ACPI_FILE file)
+{
+        long offset;
+
+        offset = ftell(file);
+        return (offset);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_os_set_file_offset
+ *
+ * PARAMETERS:  file                - An open file descriptor
+ *              offset              - New file offset
+ *              from                - From begin/end of file
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Set current file offset.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_os_set_file_offset(ACPI_FILE file, long offset, u8 from)
+{
+        int ret = 0;
+
+        if (from == ACPI_FILE_BEGIN) {
+                ret = fseek(file, offset, SEEK_SET);
+        }
+        if (from == ACPI_FILE_END) {
+                ret = fseek(file, offset, SEEK_END);
+        }
+
+        if (ret < 0) {
+                return (AE_ERROR);
+        } else {
+                return (AE_OK);
+        }
+}
diff --git a/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c b/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
index 28c52008e854..0dc2485dedf5 100644
--- a/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
+++ b/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
@@ -77,6 +77,9 @@ osl_map_table(acpi_size address,
 
 static void osl_unmap_table(struct acpi_table_header *table);
 
+static acpi_physical_address
+osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword);
+
 static acpi_physical_address osl_find_rsdp_via_efi(void);
 
 static acpi_status osl_load_rsdp(void);
@@ -417,6 +420,38 @@ acpi_os_get_table_by_index(u32 index,
 
 /******************************************************************************
  *
+ * FUNCTION:    osl_find_rsdp_via_efi_by_keyword
+ *
+ * PARAMETERS:  keyword         - Character string indicating ACPI GUID version
+ *                                in the EFI table
+ *
+ * RETURN:      RSDP address if found
+ *
+ * DESCRIPTION: Find RSDP address via EFI using keyword indicating the ACPI
+ *              GUID version.
+ *
+ *****************************************************************************/
+
+static acpi_physical_address
+osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword)
+{
+        char buffer[80];
+        unsigned long long address = 0;
+        char format[32];
+
+        snprintf(format, 32, "%s=%s", keyword, "%llx");
+        fseek(file, 0, SEEK_SET);
+        while (fgets(buffer, 80, file)) {
+                if (sscanf(buffer, format, &address) == 1) {
+                        break;
+                }
+        }
+
+        return ((acpi_physical_address) (address));
+}
+
+/******************************************************************************
+ *
  * FUNCTION:    osl_find_rsdp_via_efi
  *
  * PARAMETERS:  None
@@ -430,20 +465,19 @@ acpi_os_get_table_by_index(u32 index,
 static acpi_physical_address osl_find_rsdp_via_efi(void)
 {
         FILE *file;
-        char buffer[80];
-        unsigned long address = 0;
+        acpi_physical_address address = 0;
 
         file = fopen(EFI_SYSTAB, "r");
         if (file) {
-                while (fgets(buffer, 80, file)) {
-                        if (sscanf(buffer, "ACPI20=0x%lx", &address) == 1) {
-                                break;
-                        }
+                address = osl_find_rsdp_via_efi_by_keyword(file, "ACPI20");
+                if (!address) {
+                        address =
+                            osl_find_rsdp_via_efi_by_keyword(file, "ACPI");
                 }
                 fclose(file);
         }
 
-        return ((acpi_physical_address) (address));
+        return (address);
 }
 
 /******************************************************************************
diff --git a/tools/power/acpi/os_specific/service_layers/osunixxf.c b/tools/power/acpi/os_specific/service_layers/osunixxf.c
new file mode 100644
index 000000000000..60b58cd18410
--- /dev/null
+++ b/tools/power/acpi/os_specific/service_layers/osunixxf.c
@@ -0,0 +1,1311 @@
+/******************************************************************************
+ *
+ * Module Name: osunixxf - UNIX OSL interfaces
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+/*
+ * These interfaces are required in order to compile the ASL compiler and the
+ * various ACPICA tools under Linux or other Unix-like system.
+ */
+#include <acpi/acpi.h>
+#include "accommon.h"
+#include "amlcode.h"
+#include "acparser.h"
+#include "acdebug.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <semaphore.h>
+#include <pthread.h>
+#include <errno.h>
+
+#define _COMPONENT          ACPI_OS_SERVICES
+ACPI_MODULE_NAME("osunixxf")
+
+u8 acpi_gbl_debug_timeout = FALSE;
+
+/* Upcalls to acpi_exec */
+
+void
+ae_table_override(struct acpi_table_header *existing_table,
+                  struct acpi_table_header **new_table);
+
+typedef void *(*PTHREAD_CALLBACK) (void *);
+
+/* Buffer used by acpi_os_vprintf */
+
+#define ACPI_VPRINTF_BUFFER_SIZE    512
+#define _ASCII_NEWLINE              '\n'
+
+/* Terminal support for acpi_exec only */
+
+#ifdef ACPI_EXEC_APP
+#include <termios.h>
+
+struct termios original_term_attributes;
+int term_attributes_were_set = 0;
+
+acpi_status acpi_ut_read_line(char *buffer, u32 buffer_length, u32 *bytes_read);
+
+static void os_enter_line_edit_mode(void);
+
+static void os_exit_line_edit_mode(void);
+
+/******************************************************************************
+ *
+ * FUNCTION:    os_enter_line_edit_mode, os_exit_line_edit_mode
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Enter/Exit the raw character input mode for the terminal.
+ *
+ * Interactive line-editing support for the AML debugger. Used with the
+ * common/acgetline module.
+ *
+ * readline() is not used because of non-portability. It is not available
+ * on all systems, and if it is, often the package must be manually installed.
+ *
+ * Therefore, we use the POSIX tcgetattr/tcsetattr and do the minimal line
+ * editing that we need in acpi_os_get_line.
+ *
+ * If the POSIX tcgetattr/tcsetattr interfaces are unavailable, these
+ * calls will also work:
+ *     For os_enter_line_edit_mode: system ("stty cbreak -echo")
+ *     For os_exit_line_edit_mode: system ("stty cooked echo")
+ *
+ *****************************************************************************/
+
+static void os_enter_line_edit_mode(void)
+{
+        struct termios local_term_attributes;
+
+        /* Get and keep the original attributes */
+
+        if (tcgetattr(STDIN_FILENO, &original_term_attributes)) {
+                fprintf(stderr, "Could not get terminal attributes!\n");
+                return;
+        }
+
+        /* Set the new attributes to enable raw character input */
+
+        memcpy(&local_term_attributes, &original_term_attributes,
+               sizeof(struct termios));
+
+        local_term_attributes.c_lflag &= ~(ICANON | ECHO);
+        local_term_attributes.c_cc[VMIN] = 1;
+        local_term_attributes.c_cc[VTIME] = 0;
+
+        if (tcsetattr(STDIN_FILENO, TCSANOW, &local_term_attributes)) {
+                fprintf(stderr, "Could not set terminal attributes!\n");
+                return;
+        }
+
+        term_attributes_were_set = 1;
+}
+
+static void os_exit_line_edit_mode(void)
+{
+
+        if (!term_attributes_were_set) {
+                return;
+        }
+
+        /* Set terminal attributes back to the original values */
+
+        if (tcsetattr(STDIN_FILENO, TCSANOW, &original_term_attributes)) {
+                fprintf(stderr, "Could not restore terminal attributes!\n");
+        }
+}
+
+#else
+
+/* These functions are not needed for other ACPICA utilities */
+
+#define os_enter_line_edit_mode()
+#define os_exit_line_edit_mode()
+#endif
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_initialize, acpi_os_terminate
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Initialize and terminate this module.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_initialize(void)
+{
+        acpi_status status;
+
+        acpi_gbl_output_file = stdout;
+
+        os_enter_line_edit_mode();
+
+        status = acpi_os_create_lock(&acpi_gbl_print_lock);
+        if (ACPI_FAILURE(status)) {
+                return (status);
+        }
+
+        return (AE_OK);
+}
+
+acpi_status acpi_os_terminate(void)
+{
+
+        os_exit_line_edit_mode();
+        return (AE_OK);
+}
+
+#ifndef ACPI_USE_NATIVE_RSDP_POINTER
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_get_root_pointer
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      RSDP physical address
+ *
+ * DESCRIPTION: Gets the ACPI root pointer (RSDP)
+ *
+ *****************************************************************************/
+
+acpi_physical_address acpi_os_get_root_pointer(void)
+{
+
+        return (0);
+}
+#endif
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_predefined_override
+ *
+ * PARAMETERS:  init_val            - Initial value of the predefined object
+ *              new_val             - The new value for the object
+ *
+ * RETURN:      Status, pointer to value. Null pointer returned if not
+ *              overriding.
+ *
+ * DESCRIPTION: Allow the OS to override predefined names
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_predefined_override(const struct acpi_predefined_names * init_val,
+                            acpi_string * new_val)
+{
+
+        if (!init_val || !new_val) {
+                return (AE_BAD_PARAMETER);
+        }
+
+        *new_val = NULL;
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_table_override
+ *
+ * PARAMETERS:  existing_table      - Header of current table (probably
+ *                                    firmware)
+ *              new_table           - Where an entire new table is returned.
+ *
+ * RETURN:      Status, pointer to new table. Null pointer returned if no
+ *              table is available to override
+ *
+ * DESCRIPTION: Return a different version of a table if one is available
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_table_override(struct acpi_table_header * existing_table,
+                       struct acpi_table_header ** new_table)
+{
+
+        if (!existing_table || !new_table) {
+                return (AE_BAD_PARAMETER);
+        }
+
+        *new_table = NULL;
+
+#ifdef ACPI_EXEC_APP
+
+        ae_table_override(existing_table, new_table);
+        return (AE_OK);
+#else
+
+        return (AE_NO_ACPI_TABLES);
+#endif
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_physical_table_override
+ *
+ * PARAMETERS:  existing_table      - Header of current table (probably firmware)
+ *              new_address         - Where new table address is returned
+ *                                    (Physical address)
+ *              new_table_length    - Where new table length is returned
+ *
+ * RETURN:      Status, address/length of new table. Null pointer returned
+ *              if no table is available to override.
+ *
+ * DESCRIPTION: Returns AE_SUPPORT, function not used in user space.
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_physical_table_override(struct acpi_table_header * existing_table,
+                                acpi_physical_address * new_address,
+                                u32 *new_table_length)
+{
+
+        return (AE_SUPPORT);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_redirect_output
+ *
+ * PARAMETERS:  destination         - An open file handle/pointer
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Causes redirect of acpi_os_printf and acpi_os_vprintf
+ *
+ *****************************************************************************/
+
+void acpi_os_redirect_output(void *destination)
+{
+
+        acpi_gbl_output_file = destination;
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_printf
+ *
+ * PARAMETERS:  fmt, ...            - Standard printf format
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Formatted output. Note: very similar to acpi_os_vprintf
+ *              (performance), changes should be tracked in both functions.
+ *
+ *****************************************************************************/
+
+void ACPI_INTERNAL_VAR_XFACE acpi_os_printf(const char *fmt, ...)
+{
+        va_list args;
+        u8 flags;
+
+        flags = acpi_gbl_db_output_flags;
+        if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
+
+                /* Output is directable to either a file (if open) or the console */
+
+                if (acpi_gbl_debug_file) {
+
+                        /* Output file is open, send the output there */
+
+                        va_start(args, fmt);
+                        vfprintf(acpi_gbl_debug_file, fmt, args);
+                        va_end(args);
+                } else {
+                        /* No redirection, send output to console (once only!) */
+
+                        flags |= ACPI_DB_CONSOLE_OUTPUT;
+                }
+        }
+
+        if (flags & ACPI_DB_CONSOLE_OUTPUT) {
+                va_start(args, fmt);
+                vfprintf(acpi_gbl_output_file, fmt, args);
+                va_end(args);
+        }
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_vprintf
+ *
+ * PARAMETERS:  fmt                 - Standard printf format
+ *              args                - Argument list
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Formatted output with argument list pointer. Note: very
+ *              similar to acpi_os_printf, changes should be tracked in both
+ *              functions.
+ *
+ *****************************************************************************/
+
+void acpi_os_vprintf(const char *fmt, va_list args)
+{
+        u8 flags;
+        char buffer[ACPI_VPRINTF_BUFFER_SIZE];
+
+        /*
+         * We build the output string in a local buffer because we may be
+         * outputting the buffer twice. Using vfprintf is problematic because
+         * some implementations modify the args pointer/structure during
+         * execution. Thus, we use the local buffer for portability.
+         *
+         * Note: Since this module is intended for use by the various ACPICA
+         * utilities/applications, we can safely declare the buffer on the stack.
+         * Also, This function is used for relatively small error messages only.
+         */
+        vsnprintf(buffer, ACPI_VPRINTF_BUFFER_SIZE, fmt, args);
+
+        flags = acpi_gbl_db_output_flags;
+        if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
+
+                /* Output is directable to either a file (if open) or the console */
+
+                if (acpi_gbl_debug_file) {
+
+                        /* Output file is open, send the output there */
+
+                        fputs(buffer, acpi_gbl_debug_file);
+                } else {
+                        /* No redirection, send output to console (once only!) */
+
+                        flags |= ACPI_DB_CONSOLE_OUTPUT;
+                }
+        }
+
+        if (flags & ACPI_DB_CONSOLE_OUTPUT) {
+                fputs(buffer, acpi_gbl_output_file);
+        }
+}
+
+#ifndef ACPI_EXEC_APP
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_get_line
+ *
+ * PARAMETERS:  buffer              - Where to return the command line
+ *              buffer_length       - Maximum length of Buffer
+ *              bytes_read          - Where the actual byte count is returned
+ *
+ * RETURN:      Status and actual bytes read
+ *
+ * DESCRIPTION: Get the next input line from the terminal. NOTE: For the
+ *              acpi_exec utility, we use the acgetline module instead to
+ *              provide line-editing and history support.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read)
+{
+        int input_char;
+        u32 end_of_line;
+
+        /* Standard acpi_os_get_line for all utilities except acpi_exec */
+
+        for (end_of_line = 0;; end_of_line++) {
+                if (end_of_line >= buffer_length) {
+                        return (AE_BUFFER_OVERFLOW);
+                }
+
+                if ((input_char = getchar()) == EOF) {
+                        return (AE_ERROR);
+                }
+
+                if (!input_char || input_char == _ASCII_NEWLINE) {
+                        break;
+                }
+
+                buffer[end_of_line] = (char)input_char;
+        }
+
+        /* Null terminate the buffer */
+
+        buffer[end_of_line] = 0;
+
+        /* Return the number of bytes in the string */
+
+        if (bytes_read) {
+                *bytes_read = end_of_line;
+        }
+
+        return (AE_OK);
+}
+#endif
+
+#ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_map_memory
+ *
+ * PARAMETERS:  where               - Physical address of memory to be mapped
+ *              length              - How much memory to map
+ *
+ * RETURN:      Pointer to mapped memory. Null on error.
+ *
+ * DESCRIPTION: Map physical memory into caller's address space
+ *
+ *****************************************************************************/
+
+void *acpi_os_map_memory(acpi_physical_address where, acpi_size length)
+{
+
+        return (ACPI_TO_POINTER((acpi_size) where));
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_unmap_memory
+ *
+ * PARAMETERS:  where               - Logical address of memory to be unmapped
+ *              length              - How much memory to unmap
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Delete a previously created mapping. Where and Length must
+ *              correspond to a previous mapping exactly.
+ *
+ *****************************************************************************/
+
+void acpi_os_unmap_memory(void *where, acpi_size length)
+{
+
+        return;
+}
+#endif
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_allocate
+ *
+ * PARAMETERS:  size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
+ *
+ *****************************************************************************/
+
+void *acpi_os_allocate(acpi_size size)
+{
+        void *mem;
+
+        mem = (void *)malloc((size_t) size);
+        return (mem);
+}
+
+#ifdef USE_NATIVE_ALLOCATE_ZEROED
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_allocate_zeroed
+ *
+ * PARAMETERS:  size                - Amount to allocate, in bytes
+ *
+ * RETURN:      Pointer to the new allocation. Null on error.
+ *
+ * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
+ *
+ *****************************************************************************/
+
+void *acpi_os_allocate_zeroed(acpi_size size)
+{
+        void *mem;
+
+        mem = (void *)calloc(1, (size_t) size);
+        return (mem);
+}
+#endif
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_free
+ *
+ * PARAMETERS:  mem                 - Pointer to previously allocated memory
+ *
+ * RETURN:      None.
+ *
+ * DESCRIPTION: Free memory allocated via acpi_os_allocate
+ *
+ *****************************************************************************/
+
+void acpi_os_free(void *mem)
+{
+
+        free(mem);
+}
+
+#ifdef ACPI_SINGLE_THREADED
+/******************************************************************************
+ *
+ * FUNCTION:    Semaphore stub functions
+ *
+ * DESCRIPTION: Stub functions used for single-thread applications that do
+ *              not require semaphore synchronization. Full implementations
+ *              of these functions appear after the stubs.
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_create_semaphore(u32 max_units,
+                         u32 initial_units, acpi_handle * out_handle)
+{
+        *out_handle = (acpi_handle) 1;
+        return (AE_OK);
+}
+
+acpi_status acpi_os_delete_semaphore(acpi_handle handle)
+{
+        return (AE_OK);
+}
+
+acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
+{
+        return (AE_OK);
+}
+
+acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
+{
+        return (AE_OK);
+}
+
+#else
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_create_semaphore
+ *
+ * PARAMETERS:  initial_units       - Units to be assigned to the new semaphore
+ *              out_handle          - Where a handle will be returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Create an OS semaphore
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_create_semaphore(u32 max_units,
+                         u32 initial_units, acpi_handle * out_handle)
+{
+        sem_t *sem;
+
+        if (!out_handle) {
+                return (AE_BAD_PARAMETER);
+        }
+#ifdef __APPLE__
+        {
+                char *semaphore_name = tmpnam(NULL);
+
+                sem =
+                    sem_open(semaphore_name, O_EXCL | O_CREAT, 0755,
+                             initial_units);
+                if (!sem) {
+                        return (AE_NO_MEMORY);
+                }
+                sem_unlink(semaphore_name);     /* This just deletes the name */
+        }
+
+#else
+        sem = acpi_os_allocate(sizeof(sem_t));
+        if (!sem) {
+                return (AE_NO_MEMORY);
+        }
+
+        if (sem_init(sem, 0, initial_units) == -1) {
+                acpi_os_free(sem);
+                return (AE_BAD_PARAMETER);
+        }
+#endif
+
+        *out_handle = (acpi_handle) sem;
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_delete_semaphore
+ *
+ * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Delete an OS semaphore
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_delete_semaphore(acpi_handle handle)
+{
+        sem_t *sem = (sem_t *) handle;
+
+        if (!sem) {
+                return (AE_BAD_PARAMETER);
+        }
+
+        if (sem_destroy(sem) == -1) {
+                return (AE_BAD_PARAMETER);
+        }
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_wait_semaphore
+ *
+ * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
+ *              units               - How many units to wait for
+ *              msec_timeout        - How long to wait (milliseconds)
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Wait for units
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 msec_timeout)
+{
+        acpi_status status = AE_OK;
+        sem_t *sem = (sem_t *) handle;
+#ifndef ACPI_USE_ALTERNATE_TIMEOUT
+        struct timespec time;
+        int ret_val;
+#endif
+
+        if (!sem) {
+                return (AE_BAD_PARAMETER);
+        }
+
+        switch (msec_timeout) {
+                /*
+                 * No Wait:
+                 * --------
+                 * A zero timeout value indicates that we shouldn't wait - just
+                 * acquire the semaphore if available otherwise return AE_TIME
+                 * (a.k.a. 'would block').
+                 */
+        case 0:
+
+                if (sem_trywait(sem) == -1) {
+                        status = (AE_TIME);
+                }
+                break;
+
+                /* Wait Indefinitely */
+
+        case ACPI_WAIT_FOREVER:
+
+                if (sem_wait(sem)) {
+                        status = (AE_TIME);
+                }
+                break;
+
+                /* Wait with msec_timeout */
+
+        default:
+
+#ifdef ACPI_USE_ALTERNATE_TIMEOUT
+                /*
+                 * Alternate timeout mechanism for environments where
+                 * sem_timedwait is not available or does not work properly.
+                 */
+                while (msec_timeout) {
+                        if (sem_trywait(sem) == 0) {
+
+                                /* Got the semaphore */
+                                return (AE_OK);
+                        }
+
+                        if (msec_timeout >= 10) {
+                                msec_timeout -= 10;
+                                usleep(10 * ACPI_USEC_PER_MSEC);        /* ten milliseconds */
+                        } else {
+                                msec_timeout--;
+                                usleep(ACPI_USEC_PER_MSEC);     /* one millisecond */
+                        }
+                }
+                status = (AE_TIME);
+#else
+                /*
+                 * The interface to sem_timedwait is an absolute time, so we need to
+                 * get the current time, then add in the millisecond Timeout value.
+                 */
+                if (clock_gettime(CLOCK_REALTIME, &time) == -1) {
+                        perror("clock_gettime");
+                        return (AE_TIME);
+                }
+
+                time.tv_sec += (msec_timeout / ACPI_MSEC_PER_SEC);
+                time.tv_nsec +=
+                    ((msec_timeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC);
+
+                /* Handle nanosecond overflow (field must be less than one second) */
+
+                if (time.tv_nsec >= ACPI_NSEC_PER_SEC) {
+                        time.tv_sec += (time.tv_nsec / ACPI_NSEC_PER_SEC);
+                        time.tv_nsec = (time.tv_nsec % ACPI_NSEC_PER_SEC);
+                }
+
+                while (((ret_val = sem_timedwait(sem, &time)) == -1)
+                       && (errno == EINTR)) {
+                        continue;
+                }
+
+                if (ret_val != 0) {
+                        if (errno != ETIMEDOUT) {
+                                perror("sem_timedwait");
+                        }
+                        status = (AE_TIME);
+                }
+#endif
+                break;
+        }
+
+        return (status);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_signal_semaphore
+ *
+ * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
+ *              units               - Number of units to send
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Send units
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
+{
+        sem_t *sem = (sem_t *) handle;
+
+        if (!sem) {
+                return (AE_BAD_PARAMETER);
+        }
+
+        if (sem_post(sem) == -1) {
+                return (AE_LIMIT);
+        }
+
+        return (AE_OK);
+}
+
+#endif                          /* ACPI_SINGLE_THREADED */
+
+/******************************************************************************
+ *
+ * FUNCTION:    Spinlock interfaces
+ *
+ * DESCRIPTION: Map these interfaces to semaphore interfaces
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_create_lock(acpi_spinlock * out_handle)
+{
+
+        return (acpi_os_create_semaphore(1, 1, out_handle));
+}
+
+void acpi_os_delete_lock(acpi_spinlock handle)
+{
+        acpi_os_delete_semaphore(handle);
+}
+
+acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle)
+{
+        acpi_os_wait_semaphore(handle, 1, 0xFFFF);
+        return (0);
+}
+
+void acpi_os_release_lock(acpi_spinlock handle, acpi_cpu_flags flags)
+{
+        acpi_os_signal_semaphore(handle, 1);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_install_interrupt_handler
+ *
+ * PARAMETERS:  interrupt_number    - Level handler should respond to.
+ *              isr                 - Address of the ACPI interrupt handler
+ *              except_ptr          - Where status is returned
+ *
+ * RETURN:      Handle to the newly installed handler.
+ *
+ * DESCRIPTION: Install an interrupt handler. Used to install the ACPI
+ *              OS-independent handler.
+ *
+ *****************************************************************************/
+
+u32
+acpi_os_install_interrupt_handler(u32 interrupt_number,
+                                  acpi_osd_handler service_routine,
+                                  void *context)
+{
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_remove_interrupt_handler
+ *
+ * PARAMETERS:  handle              - Returned when handler was installed
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Uninstalls an interrupt handler.
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_remove_interrupt_handler(u32 interrupt_number,
+                                 acpi_osd_handler service_routine)
+{
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_stall
+ *
+ * PARAMETERS:  microseconds        - Time to sleep
+ *
+ * RETURN:      Blocks until sleep is completed.
+ *
+ * DESCRIPTION: Sleep at microsecond granularity
+ *
+ *****************************************************************************/
+
+void acpi_os_stall(u32 microseconds)
+{
+
+        if (microseconds) {
+                usleep(microseconds);
+        }
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_sleep
+ *
+ * PARAMETERS:  milliseconds        - Time to sleep
+ *
+ * RETURN:      Blocks until sleep is completed.
+ *
+ * DESCRIPTION: Sleep at millisecond granularity
+ *
+ *****************************************************************************/
+
+void acpi_os_sleep(u64 milliseconds)
+{
+
+        /* Sleep for whole seconds */
+
+        sleep(milliseconds / ACPI_MSEC_PER_SEC);
+
+        /*
+         * Sleep for remaining microseconds.
+         * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second).
+         */
+        usleep((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_get_timer
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Current time in 100 nanosecond units
+ *
+ * DESCRIPTION: Get the current system time
+ *
+ *****************************************************************************/
+
+u64 acpi_os_get_timer(void)
+{
+        struct timeval time;
+
+        /* This timer has sufficient resolution for user-space application code */
+
+        gettimeofday(&time, NULL);
+
+        /* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */
+
+        return (((u64)time.tv_sec * ACPI_100NSEC_PER_SEC) +
+                ((u64)time.tv_usec * ACPI_100NSEC_PER_USEC));
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_read_pci_configuration
+ *
+ * PARAMETERS:  pci_id              - Seg/Bus/Dev
+ *              pci_register        - Device Register
+ *              value               - Buffer where value is placed
+ *              width               - Number of bits
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Read data from PCI configuration space
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id,
+                               u32 pci_register, u64 *value, u32 width)
+{
+
+        *value = 0;
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_write_pci_configuration
+ *
+ * PARAMETERS:  pci_id              - Seg/Bus/Dev
+ *              pci_register        - Device Register
+ *              value               - Value to be written
+ *              width               - Number of bits
+ *
+ * RETURN:      Status.
+ *
+ * DESCRIPTION: Write data to PCI configuration space
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id,
+                                u32 pci_register, u64 value, u32 width)
+{
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_read_port
+ *
+ * PARAMETERS:  address             - Address of I/O port/register to read
+ *              value               - Where value is placed
+ *              width               - Number of bits
+ *
+ * RETURN:      Value read from port
+ *
+ * DESCRIPTION: Read data from an I/O port or register
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_read_port(acpi_io_address address, u32 *value, u32 width)
+{
+
+        switch (width) {
+        case 8:
+
+                *value = 0xFF;
+                break;
+
+        case 16:
+
+                *value = 0xFFFF;
+                break;
+
+        case 32:
+
+                *value = 0xFFFFFFFF;
+                break;
+
+        default:
+
+                return (AE_BAD_PARAMETER);
+        }
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_write_port
+ *
+ * PARAMETERS:  address             - Address of I/O port/register to write
+ *              value               - Value to write
+ *              width               - Number of bits
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Write data to an I/O port or register
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width)
+{
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_read_memory
+ *
+ * PARAMETERS:  address             - Physical Memory Address to read
+ *              value               - Where value is placed
+ *              width               - Number of bits (8,16,32, or 64)
+ *
+ * RETURN:      Value read from physical memory address. Always returned
+ *              as a 64-bit integer, regardless of the read width.
+ *
+ * DESCRIPTION: Read data from a physical memory address
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width)
+{
+
+        switch (width) {
+        case 8:
+        case 16:
+        case 32:
+        case 64:
+
+                *value = 0;
+                break;
+
+        default:
+
+                return (AE_BAD_PARAMETER);
+        }
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_write_memory
+ *
+ * PARAMETERS:  address             - Physical Memory Address to write
+ *              value               - Value to write
+ *              width               - Number of bits (8,16,32, or 64)
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Write data to a physical memory address
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_write_memory(acpi_physical_address address, u64 value, u32 width)
+{
+
+        return (AE_OK);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_readable
+ *
+ * PARAMETERS:  pointer             - Area to be verified
+ *              length              - Size of area
+ *
+ * RETURN:      TRUE if readable for entire length
+ *
+ * DESCRIPTION: Verify that a pointer is valid for reading
+ *
+ *****************************************************************************/
+
+u8 acpi_os_readable(void *pointer, acpi_size length)
+{
+
+        return (TRUE);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_writable
+ *
+ * PARAMETERS:  pointer             - Area to be verified
+ *              length              - Size of area
+ *
+ * RETURN:      TRUE if writable for entire length
+ *
+ * DESCRIPTION: Verify that a pointer is valid for writing
+ *
+ *****************************************************************************/
+
+u8 acpi_os_writable(void *pointer, acpi_size length)
+{
+
+        return (TRUE);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_signal
+ *
+ * PARAMETERS:  function            - ACPI A signal function code
+ *              info                - Pointer to function-dependent structure
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Miscellaneous functions. Example implementation only.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_os_signal(u32 function, void *info)
+{
+
+        switch (function) {
+        case ACPI_SIGNAL_FATAL:
+
+                break;
+
+        case ACPI_SIGNAL_BREAKPOINT:
+
+                break;
+
+        default:
+
+                break;
+        }
+
+        return (AE_OK);
+}
+
+/* Optional multi-thread support */
+
+#ifndef ACPI_SINGLE_THREADED
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_get_thread_id
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Id of the running thread
+ *
+ * DESCRIPTION: Get the ID of the current (running) thread
+ *
+ *****************************************************************************/
+
+acpi_thread_id acpi_os_get_thread_id(void)
+{
+        pthread_t thread;
+
+        thread = pthread_self();
+        return (ACPI_CAST_PTHREAD_T(thread));
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_execute
+ *
+ * PARAMETERS:  type                - Type of execution
+ *              function            - Address of the function to execute
+ *              context             - Passed as a parameter to the function
+ *
+ * RETURN:      Status.
+ *
+ * DESCRIPTION: Execute a new thread
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_os_execute(acpi_execute_type type,
+                acpi_osd_exec_callback function, void *context)
+{
+        pthread_t thread;
+        int ret;
+
+        ret =
+            pthread_create(&thread, NULL, (PTHREAD_CALLBACK) function, context);
+        if (ret) {
+                acpi_os_printf("Create thread failed");
+        }
+        return (0);
+}
+
+#else                           /* ACPI_SINGLE_THREADED */
+acpi_thread_id acpi_os_get_thread_id(void)
+{
+        return (1);
+}
+
+acpi_status
+acpi_os_execute(acpi_execute_type type,
+                acpi_osd_exec_callback function, void *context)
+{
+
+        function(context);
+
+        return (AE_OK);
+}
+
+#endif                          /* ACPI_SINGLE_THREADED */
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_os_wait_events_complete
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Wait for all asynchronous events to complete. This
+ *              implementation does nothing.
+ *
+ *****************************************************************************/
+
+void acpi_os_wait_events_complete(void)
+{
+        return;
+}
diff --git a/tools/power/acpi/tools/acpidump/acpidump.h b/tools/power/acpi/tools/acpidump/acpidump.h
index 46f519597fe5..a2d37d610639 100644
--- a/tools/power/acpi/tools/acpidump/acpidump.h
+++ b/tools/power/acpi/tools/acpidump/acpidump.h
@@ -47,7 +47,6 @@
 #ifdef _DECLARE_GLOBALS
 #define EXTERN
 #define INIT_GLOBAL(a,b)        a=b
-#define DEFINE_ACPI_GLOBALS     1
 #else
 #define EXTERN                  extern
 #define INIT_GLOBAL(a,b)        a
@@ -69,7 +68,7 @@ EXTERN u8 INIT_GLOBAL(gbl_verbose_mode, FALSE);
 EXTERN u8 INIT_GLOBAL(gbl_binary_mode, FALSE);
 EXTERN u8 INIT_GLOBAL(gbl_dump_customized_tables, FALSE);
 EXTERN u8 INIT_GLOBAL(gbl_do_not_dump_xsdt, FALSE);
-EXTERN FILE INIT_GLOBAL(*gbl_output_file, NULL);
+EXTERN ACPI_FILE INIT_GLOBAL(gbl_output_file, NULL);
 EXTERN char INIT_GLOBAL(*gbl_output_filename, NULL);
 EXTERN u64 INIT_GLOBAL(gbl_rsdp_base, 0);
 
diff --git a/tools/power/acpi/tools/acpidump/apdump.c b/tools/power/acpi/tools/acpidump/apdump.c
index 3cac12378366..53cee781e24e 100644
--- a/tools/power/acpi/tools/acpidump/apdump.c
+++ b/tools/power/acpi/tools/acpidump/apdump.c
@@ -69,17 +69,16 @@ u8 ap_is_valid_header(struct acpi_table_header *table)
                 /* Make sure signature is all ASCII and a valid ACPI name */
 
                 if (!acpi_ut_valid_acpi_name(table->signature)) {
-                        fprintf(stderr,
-                                "Table signature (0x%8.8X) is invalid\n",
-                                *(u32 *)table->signature);
+                        acpi_log_error("Table signature (0x%8.8X) is invalid\n",
+                                       *(u32 *)table->signature);
                         return (FALSE);
                 }
 
                 /* Check for minimum table length */
 
                 if (table->length < sizeof(struct acpi_table_header)) {
-                        fprintf(stderr, "Table length (0x%8.8X) is invalid\n",
-                                table->length);
+                        acpi_log_error("Table length (0x%8.8X) is invalid\n",
+                                       table->length);
                         return (FALSE);
                 }
         }
@@ -116,8 +115,8 @@ u8 ap_is_valid_checksum(struct acpi_table_header *table)
         }
 
         if (ACPI_FAILURE(status)) {
-                fprintf(stderr, "%4.4s: Warning: wrong checksum in table\n",
-                        table->signature);
+                acpi_log_error("%4.4s: Warning: wrong checksum in table\n",
+                               table->signature);
         }
 
         return (AE_OK);
@@ -196,12 +195,13 @@ ap_dump_table_buffer(struct acpi_table_header *table,
          * Note: simplest to just always emit a 64-bit address. acpi_xtract
          * utility can handle this.
          */
-        printf("%4.4s @ 0x%8.8X%8.8X\n", table->signature,
-               ACPI_FORMAT_UINT64(address));
+        acpi_ut_file_printf(gbl_output_file, "%4.4s @ 0x%8.8X%8.8X\n",
+                            table->signature, ACPI_FORMAT_UINT64(address));
 
-        acpi_ut_dump_buffer(ACPI_CAST_PTR(u8, table), table_length,
-                            DB_BYTE_DISPLAY, 0);
-        printf("\n");
+        acpi_ut_dump_buffer_to_file(gbl_output_file,
+                                    ACPI_CAST_PTR(u8, table), table_length,
+                                    DB_BYTE_DISPLAY, 0);
+        acpi_ut_file_printf(gbl_output_file, "\n");
         return (0);
 }
 
@@ -239,20 +239,20 @@ int ap_dump_all_tables(void)
                         if (status == AE_LIMIT) {
                                 return (0);
                         } else if (i == 0) {
-                                fprintf(stderr,
-                                        "Could not get ACPI tables, %s\n",
-                                        acpi_format_exception(status));
+                                acpi_log_error
+                                    ("Could not get ACPI tables, %s\n",
+                                     acpi_format_exception(status));
                                 return (-1);
                         } else {
-                                fprintf(stderr,
-                                        "Could not get ACPI table at index %u, %s\n",
-                                        i, acpi_format_exception(status));
+                                acpi_log_error
+                                    ("Could not get ACPI table at index %u, %s\n",
+                                     i, acpi_format_exception(status));
                                 continue;
                         }
                 }
 
                 table_status = ap_dump_table_buffer(table, instance, address);
-                free(table);
+                ACPI_FREE(table);
 
                 if (table_status) {
                         break;
@@ -288,22 +288,22 @@ int ap_dump_table_by_address(char *ascii_address)
 
         status = acpi_ut_strtoul64(ascii_address, 0, &long_address);
         if (ACPI_FAILURE(status)) {
-                fprintf(stderr, "%s: Could not convert to a physical address\n",
-                        ascii_address);
+                acpi_log_error("%s: Could not convert to a physical address\n",
+                               ascii_address);
                 return (-1);
         }
 
         address = (acpi_physical_address) long_address;
         status = acpi_os_get_table_by_address(address, &table);
         if (ACPI_FAILURE(status)) {
-                fprintf(stderr, "Could not get table at 0x%8.8X%8.8X, %s\n",
-                        ACPI_FORMAT_UINT64(address),
-                        acpi_format_exception(status));
+                acpi_log_error("Could not get table at 0x%8.8X%8.8X, %s\n",
+                               ACPI_FORMAT_UINT64(address),
+                               acpi_format_exception(status));
                 return (-1);
         }
 
         table_status = ap_dump_table_buffer(table, 0, address);
-        free(table);
+        ACPI_FREE(table);
         return (table_status);
 }
 
@@ -329,24 +329,24 @@ int ap_dump_table_by_name(char *signature)
         acpi_status status;
         int table_status;
 
-        if (strlen(signature) != ACPI_NAME_SIZE) {
-                fprintf(stderr,
-                        "Invalid table signature [%s]: must be exactly 4 characters\n",
-                        signature);
+        if (ACPI_STRLEN(signature) != ACPI_NAME_SIZE) {
+                acpi_log_error
+                    ("Invalid table signature [%s]: must be exactly 4 characters\n",
+                     signature);
                 return (-1);
         }
 
         /* Table signatures are expected to be uppercase */
 
-        strcpy(local_signature, signature);
+        ACPI_STRCPY(local_signature, signature);
         acpi_ut_strupr(local_signature);
 
         /* To be friendly, handle tables whose signatures do not match the name */
 
         if (ACPI_COMPARE_NAME(local_signature, "FADT")) {
-                strcpy(local_signature, ACPI_SIG_FADT);
+                ACPI_STRCPY(local_signature, ACPI_SIG_FADT);
         } else if (ACPI_COMPARE_NAME(local_signature, "MADT")) {
-                strcpy(local_signature, ACPI_SIG_MADT);
+                ACPI_STRCPY(local_signature, ACPI_SIG_MADT);
         }
 
         /* Dump all instances of this signature (to handle multiple SSDTs) */
@@ -362,14 +362,14 @@ int ap_dump_table_by_name(char *signature)
                                 return (0);
                         }
 
-                        fprintf(stderr,
-                                "Could not get ACPI table with signature [%s], %s\n",
-                                local_signature, acpi_format_exception(status));
+                        acpi_log_error
+                            ("Could not get ACPI table with signature [%s], %s\n",
+                             local_signature, acpi_format_exception(status));
                         return (-1);
                 }
 
                 table_status = ap_dump_table_buffer(table, instance, address);
-                free(table);
+                ACPI_FREE(table);
 
                 if (table_status) {
                         break;
@@ -409,43 +409,21 @@ int ap_dump_table_from_file(char *pathname)
         /* File must be at least as long as the table length */
 
         if (table->length > file_size) {
-                fprintf(stderr,
-                        "Table length (0x%X) is too large for input file (0x%X) %s\n",
-                        table->length, file_size, pathname);
+                acpi_log_error
+                    ("Table length (0x%X) is too large for input file (0x%X) %s\n",
+                     table->length, file_size, pathname);
                 goto exit;
         }
 
         if (gbl_verbose_mode) {
-                fprintf(stderr,
-                        "Input file:  %s contains table [%4.4s], 0x%X (%u) bytes\n",
-                        pathname, table->signature, file_size, file_size);
+                acpi_log_error
+                    ("Input file:  %s contains table [%4.4s], 0x%X (%u) bytes\n",
+                     pathname, table->signature, file_size, file_size);
         }
 
         table_status = ap_dump_table_buffer(table, 0, 0);
 
 exit:
-        free(table);
+        ACPI_FREE(table);
         return (table_status);
 }
-
-/******************************************************************************
- *
- * FUNCTION:    acpi_os* print functions
- *
- * DESCRIPTION: Used for linkage with ACPICA modules
- *
- ******************************************************************************/
-
-void ACPI_INTERNAL_VAR_XFACE acpi_os_printf(const char *fmt, ...)
-{
-        va_list args;
-
-        va_start(args, fmt);
-        vfprintf(stdout, fmt, args);
-        va_end(args);
-}
-
-void acpi_os_vprintf(const char *fmt, va_list args)
-{
-        vfprintf(stdout, fmt, args);
-}
diff --git a/tools/power/acpi/tools/acpidump/apfiles.c b/tools/power/acpi/tools/acpidump/apfiles.c
index 4488accc010b..d470046a6d81 100644
--- a/tools/power/acpi/tools/acpidump/apfiles.c
+++ b/tools/power/acpi/tools/acpidump/apfiles.c
@@ -44,6 +44,27 @@
 #include "acpidump.h"
 #include "acapps.h"
 
+/* Local prototypes */
+
+static int ap_is_existing_file(char *pathname);
+
+static int ap_is_existing_file(char *pathname)
+{
+#ifndef _GNU_EFI
+        struct stat stat_info;
+
+        if (!stat(pathname, &stat_info)) {
+                acpi_log_error("Target path already exists, overwrite? [y|n] ");
+
+                if (getchar() != 'y') {
+                        return (-1);
+                }
+        }
+#endif
+
+        return 0;
+}
+
 /******************************************************************************
  *
  * FUNCTION:    ap_open_output_file
@@ -59,25 +80,19 @@
 
 int ap_open_output_file(char *pathname)
 {
-        struct stat stat_info;
-        FILE *file;
+        ACPI_FILE file;
 
         /* If file exists, prompt for overwrite */
 
-        if (!stat(pathname, &stat_info)) {
-                fprintf(stderr,
-                        "Target path already exists, overwrite? [y|n] ");
-
-                if (getchar() != 'y') {
-                        return (-1);
-                }
+        if (ap_is_existing_file(pathname) != 0) {
+                return (-1);
         }
 
         /* Point stdout to the file */
 
-        file = freopen(pathname, "w", stdout);
+        file = acpi_os_open_file(pathname, ACPI_FILE_WRITING);
         if (!file) {
-                perror("Could not open output file");
+                acpi_log_error("Could not open output file: %s\n", pathname);
                 return (-1);
         }
 
@@ -106,7 +121,7 @@ int ap_write_to_binary_file(struct acpi_table_header *table, u32 instance)
 {
         char filename[ACPI_NAME_SIZE + 16];
         char instance_str[16];
-        FILE *file;
+        ACPI_FILE file;
         size_t actual;
         u32 table_length;
 
@@ -130,35 +145,37 @@ int ap_write_to_binary_file(struct acpi_table_header *table, u32 instance)
         /* Handle multiple SSDts - create different filenames for each */
 
         if (instance > 0) {
-                sprintf(instance_str, "%u", instance);
-                strcat(filename, instance_str);
+                acpi_ut_snprintf(instance_str, sizeof(instance_str), "%u",
+                                 instance);
+                ACPI_STRCAT(filename, instance_str);
         }
 
-        strcat(filename, ACPI_TABLE_FILE_SUFFIX);
+        ACPI_STRCAT(filename, ACPI_TABLE_FILE_SUFFIX);
 
         if (gbl_verbose_mode) {
-                fprintf(stderr,
-                        "Writing [%4.4s] to binary file: %s 0x%X (%u) bytes\n",
-                        table->signature, filename, table->length,
-                        table->length);
+                acpi_log_error
+                    ("Writing [%4.4s] to binary file: %s 0x%X (%u) bytes\n",
+                     table->signature, filename, table->length, table->length);
         }
 
         /* Open the file and dump the entire table in binary mode */
 
-        file = fopen(filename, "wb");
+        file = acpi_os_open_file(filename,
+                                 ACPI_FILE_WRITING | ACPI_FILE_BINARY);
         if (!file) {
-                perror("Could not open output file");
+                acpi_log_error("Could not open output file: %s\n", filename);
                 return (-1);
         }
 
-        actual = fwrite(table, 1, table_length, file);
+        actual = acpi_os_write_file(file, table, 1, table_length);
         if (actual != table_length) {
-                perror("Error writing binary output file");
-                fclose(file);
+                acpi_log_error("Error writing binary output file: %s\n",
+                               filename);
+                acpi_os_close_file(file);
                 return (-1);
         }
 
-        fclose(file);
+        acpi_os_close_file(file);
         return (0);
 }
 
@@ -179,15 +196,16 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
                                                  u32 *out_file_size)
 {
         struct acpi_table_header *buffer = NULL;
-        FILE *file;
+        ACPI_FILE file;
         u32 file_size;
         size_t actual;
 
         /* Must use binary mode */
 
-        file = fopen(pathname, "rb");
+        file =
+            acpi_os_open_file(pathname, ACPI_FILE_READING | ACPI_FILE_BINARY);
         if (!file) {
-                perror("Could not open input file");
+                acpi_log_error("Could not open input file: %s\n", pathname);
                 return (NULL);
         }
 
@@ -195,27 +213,25 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
 
         file_size = cm_get_file_size(file);
         if (file_size == ACPI_UINT32_MAX) {
-                fprintf(stderr,
-                        "Could not get input file size: %s\n", pathname);
+                acpi_log_error("Could not get input file size: %s\n", pathname);
                 goto cleanup;
         }
 
         /* Allocate a buffer for the entire file */
 
-        buffer = calloc(1, file_size);
+        buffer = ACPI_ALLOCATE_ZEROED(file_size);
         if (!buffer) {
-                fprintf(stderr,
-                        "Could not allocate file buffer of size: %u\n",
-                        file_size);
+                acpi_log_error("Could not allocate file buffer of size: %u\n",
+                               file_size);
                 goto cleanup;
         }
 
         /* Read the entire file */
 
-        actual = fread(buffer, 1, file_size, file);
+        actual = acpi_os_read_file(file, buffer, 1, file_size);
         if (actual != file_size) {
-                fprintf(stderr, "Could not read input file: %s\n", pathname);
-                free(buffer);
+                acpi_log_error("Could not read input file: %s\n", pathname);
+                ACPI_FREE(buffer);
                 buffer = NULL;
                 goto cleanup;
         }
@@ -223,6 +239,6 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
         *out_file_size = file_size;
 
 cleanup:
-        fclose(file);
+        acpi_os_close_file(file);
         return (buffer);
 }
diff --git a/tools/power/acpi/tools/acpidump/apmain.c b/tools/power/acpi/tools/acpidump/apmain.c
index 51e8d638db18..853b4da22c3e 100644
--- a/tools/power/acpi/tools/acpidump/apmain.c
+++ b/tools/power/acpi/tools/acpidump/apmain.c
@@ -72,7 +72,7 @@ static void ap_display_usage(void);
 
 static int ap_do_options(int argc, char **argv);
 
-static void ap_insert_action(char *argument, u32 to_be_done);
+static int ap_insert_action(char *argument, u32 to_be_done);
 
 /* Table for deferred actions from command line options */
 
@@ -104,7 +104,7 @@ static void ap_display_usage(void)
         ACPI_OPTION("-v", "Display version information");
         ACPI_OPTION("-z", "Verbose mode");
 
-        printf("\nTable Options:\n");
+        ACPI_USAGE_TEXT("\nTable Options:\n");
 
         ACPI_OPTION("-a <Address>", "Get table via a physical address");
         ACPI_OPTION("-f <BinaryFile>", "Get table via a binary file");
@@ -112,9 +112,9 @@ static void ap_display_usage(void)
         ACPI_OPTION("-x", "Do not use but dump XSDT");
         ACPI_OPTION("-x -x", "Do not use or dump XSDT");
 
-        printf("\n"
-               "Invocation without parameters dumps all available tables\n"
-               "Multiple mixed instances of -a, -f, and -n are supported\n\n");
+        ACPI_USAGE_TEXT("\n"
+                        "Invocation without parameters dumps all available tables\n"
+                        "Multiple mixed instances of -a, -f, and -n are supported\n\n");
 }
 
 /******************************************************************************
@@ -124,13 +124,13 @@ static void ap_display_usage(void)
  * PARAMETERS:  argument            - Pointer to the argument for this action
  *              to_be_done          - What to do to process this action
  *
- * RETURN:      None. Exits program if action table becomes full.
+ * RETURN:      Status
  *
  * DESCRIPTION: Add an action item to the action table
  *
  ******************************************************************************/
 
-static void ap_insert_action(char *argument, u32 to_be_done)
+static int ap_insert_action(char *argument, u32 to_be_done)
 {
 
         /* Insert action and check for table overflow */
@@ -140,10 +140,12 @@ static void ap_insert_action(char *argument, u32 to_be_done)
 
         current_action++;
         if (current_action > AP_MAX_ACTIONS) {
-                fprintf(stderr, "Too many table options (max %u)\n",
-                        AP_MAX_ACTIONS);
-                exit(-1);
+                acpi_log_error("Too many table options (max %u)\n",
+                               AP_MAX_ACTIONS);
+                return (-1);
         }
+
+        return (0);
 }
 
 /******************************************************************************
@@ -166,7 +168,8 @@ static int ap_do_options(int argc, char **argv)
 
         /* Command line options */
 
-        while ((j = acpi_getopt(argc, argv, AP_SUPPORTED_OPTIONS)) != EOF)
+        while ((j =
+                acpi_getopt(argc, argv, AP_SUPPORTED_OPTIONS)) != ACPI_OPT_END)
                 switch (j) {
                         /*
                          * Global options
@@ -185,12 +188,12 @@ static int ap_do_options(int argc, char **argv)
                 case '?':
 
                         ap_display_usage();
-                        exit(0);
+                        return (1);
 
                 case 'o':       /* Redirect output to a single file */
 
                         if (ap_open_output_file(acpi_gbl_optarg)) {
-                                exit(-1);
+                                return (-1);
                         }
                         continue;
 
@@ -200,10 +203,10 @@ static int ap_do_options(int argc, char **argv)
                             acpi_ut_strtoul64(acpi_gbl_optarg, 0,
                                               &gbl_rsdp_base);
                         if (ACPI_FAILURE(status)) {
-                                fprintf(stderr,
-                                        "%s: Could not convert to a physical address\n",
-                                        acpi_gbl_optarg);
-                                exit(-1);
+                                acpi_log_error
+                                    ("%s: Could not convert to a physical address\n",
+                                     acpi_gbl_optarg);
+                                return (-1);
                         }
                         continue;
 
@@ -223,13 +226,13 @@ static int ap_do_options(int argc, char **argv)
 
                 case 'v':       /* Revision/version */
 
-                        printf(ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
-                        exit(0);
+                        acpi_os_printf(ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
+                        return (1);
 
                 case 'z':       /* Verbose mode */
 
                         gbl_verbose_mode = TRUE;
-                        fprintf(stderr, ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
+                        acpi_log_error(ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
                         continue;
 
                         /*
@@ -237,32 +240,40 @@ static int ap_do_options(int argc, char **argv)
                          */
                 case 'a':       /* Get table by physical address */
 
-                        ap_insert_action(acpi_gbl_optarg,
-                                         AP_DUMP_TABLE_BY_ADDRESS);
+                        if (ap_insert_action
+                            (acpi_gbl_optarg, AP_DUMP_TABLE_BY_ADDRESS)) {
+                                return (-1);
+                        }
                         break;
 
                 case 'f':       /* Get table from a file */
 
-                        ap_insert_action(acpi_gbl_optarg,
-                                         AP_DUMP_TABLE_BY_FILE);
+                        if (ap_insert_action
+                            (acpi_gbl_optarg, AP_DUMP_TABLE_BY_FILE)) {
+                                return (-1);
+                        }
                         break;
 
                 case 'n':       /* Get table by input name (signature) */
 
-                        ap_insert_action(acpi_gbl_optarg,
-                                         AP_DUMP_TABLE_BY_NAME);
+                        if (ap_insert_action
+                            (acpi_gbl_optarg, AP_DUMP_TABLE_BY_NAME)) {
+                                return (-1);
+                        }
                         break;
 
                 default:
 
                         ap_display_usage();
-                        exit(-1);
+                        return (-1);
                 }
 
         /* If there are no actions, this means "get/dump all tables" */
 
         if (current_action == 0) {
-                ap_insert_action(NULL, AP_DUMP_ALL_TABLES);
+                if (ap_insert_action(NULL, AP_DUMP_ALL_TABLES)) {
+                        return (-1);
+                }
         }
 
         return (0);
@@ -280,7 +291,11 @@ static int ap_do_options(int argc, char **argv)
  *
  ******************************************************************************/
 
+#ifndef _GNU_EFI
 int ACPI_SYSTEM_XFACE main(int argc, char *argv[])
+#else
+int ACPI_SYSTEM_XFACE acpi_main(int argc, char *argv[])
+#endif
 {
         int status = 0;
         struct ap_dump_action *action;
@@ -288,11 +303,17 @@ int ACPI_SYSTEM_XFACE main(int argc, char *argv[])
         u32 i;
 
         ACPI_DEBUG_INITIALIZE();        /* For debug version only */
+        acpi_os_initialize();
+        gbl_output_file = ACPI_FILE_OUT;
 
         /* Process command line options */
 
-        if (ap_do_options(argc, argv)) {
-                return (-1);
+        status = ap_do_options(argc, argv);
+        if (status > 0) {
+                return (0);
+        }
+        if (status < 0) {
+                return (status);
         }
 
         /* Get/dump ACPI table(s) as requested */
@@ -322,9 +343,8 @@ int ACPI_SYSTEM_XFACE main(int argc, char *argv[])
 
                 default:
 
-                        fprintf(stderr,
-                                "Internal error, invalid action: 0x%X\n",
-                                action->to_be_done);
+                        acpi_log_error("Internal error, invalid action: 0x%X\n",
+                                       action->to_be_done);
                         return (-1);
                 }
 
@@ -333,18 +353,18 @@ int ACPI_SYSTEM_XFACE main(int argc, char *argv[])
                 }
         }
 
-        if (gbl_output_file) {
+        if (gbl_output_filename) {
                 if (gbl_verbose_mode) {
 
                         /* Summary for the output file */
 
                         file_size = cm_get_file_size(gbl_output_file);
-                        fprintf(stderr,
-                                "Output file %s contains 0x%X (%u) bytes\n\n",
-                                gbl_output_filename, file_size, file_size);
+                        acpi_log_error
+                            ("Output file %s contains 0x%X (%u) bytes\n\n",
+                             gbl_output_filename, file_size, file_size);
                 }
 
-                fclose(gbl_output_file);
+                acpi_os_close_file(gbl_output_file);
         }
 
         return (status);
diff --git a/tools/power/cpupower/bench/parse.c b/tools/power/cpupower/bench/parse.c
index 543bba14ae2c..f503fb53824e 100644
--- a/tools/power/cpupower/bench/parse.c
+++ b/tools/power/cpupower/bench/parse.c
@@ -158,14 +158,15 @@ struct config *prepare_default_config()
 int prepare_config(const char *path, struct config *config)
 {
         size_t len = 0;
-        char *opt, *val, *line = NULL;
-        FILE *configfile = fopen(path, "r");
+        char opt[16], val[32], *line = NULL;
+        FILE *configfile;
 
         if (config == NULL) {
                 fprintf(stderr, "error: config is NULL\n");
                 return 1;
         }
 
+        configfile = fopen(path, "r");
         if (configfile == NULL) {
                 perror("fopen");
                 fprintf(stderr, "error: unable to read configfile\n");
@@ -174,52 +175,54 @@ int prepare_config(const char *path, struct config *config)
         }
 
         while (getline(&line, &len, configfile) != -1) {
-                if (line[0] == '#' || line[0] == ' ')
+                if (line[0] == '#' || line[0] == ' ' || line[0] == '\n')
                         continue;
 
-                sscanf(line, "%as = %as", &opt, &val);
+                if (sscanf(line, "%14s = %30s", opt, val) < 2)
+                        continue;
 
                 dprintf("parsing: %s -> %s\n", opt, val);
 
-                if (strncmp("sleep", opt, strlen(opt)) == 0)
+                if (strcmp("sleep", opt) == 0)
                         sscanf(val, "%li", &config->sleep);
 
-                else if (strncmp("load", opt, strlen(opt)) == 0)
+                else if (strcmp("load", opt) == 0)
                         sscanf(val, "%li", &config->load);
 
-                else if (strncmp("load_step", opt, strlen(opt)) == 0)
+                else if (strcmp("load_step", opt) == 0)
                         sscanf(val, "%li", &config->load_step);
 
-                else if (strncmp("sleep_step", opt, strlen(opt)) == 0)
+                else if (strcmp("sleep_step", opt) == 0)
                         sscanf(val, "%li", &config->sleep_step);
 
-                else if (strncmp("cycles", opt, strlen(opt)) == 0)
+                else if (strcmp("cycles", opt) == 0)
                         sscanf(val, "%u", &config->cycles);
 
-                else if (strncmp("rounds", opt, strlen(opt)) == 0)
+                else if (strcmp("rounds", opt) == 0)
                         sscanf(val, "%u", &config->rounds);
 
-                else if (strncmp("verbose", opt, strlen(opt)) == 0)
+                else if (strcmp("verbose", opt) == 0)
                         sscanf(val, "%u", &config->verbose);
 
-                else if (strncmp("output", opt, strlen(opt)) == 0)
+                else if (strcmp("output", opt) == 0)
                         config->output = prepare_output(val); 
 
-                else if (strncmp("cpu", opt, strlen(opt)) == 0)
+                else if (strcmp("cpu", opt) == 0)
                         sscanf(val, "%u", &config->cpu);
 
-                else if (strncmp("governor", opt, 14) == 0)
-                        strncpy(config->governor, val, 14);
+                else if (strcmp("governor", opt) == 0) {
+                        strncpy(config->governor, val,
+                                        sizeof(config->governor));
+                        config->governor[sizeof(config->governor) - 1] = '\0';
+                }
 
-                else if (strncmp("priority", opt, strlen(opt)) == 0) {
+                else if (strcmp("priority", opt) == 0) {
                         if (string_to_prio(val) != SCHED_ERR)
                                 config->prio = string_to_prio(val);
                 }
         }
 
         free(line);
-        free(opt);
-        free(val);
 
         return 0;
 }
diff --git a/tools/power/cpupower/utils/cpufreq-set.c b/tools/power/cpupower/utils/cpufreq-set.c
index a416de80c55e..f656e585ed45 100644
--- a/tools/power/cpupower/utils/cpufreq-set.c
+++ b/tools/power/cpupower/utils/cpufreq-set.c
@@ -320,12 +320,11 @@ int cmd_freq_set(int argc, char **argv)
 
                 printf(_("Setting cpu: %d\n"), cpu);
                 ret = do_one_cpu(cpu, &new_pol, freq, policychange);
-                if (ret)
-                        break;
+                if (ret) {
+                        print_error();
+                        return ret;
+                }
         }
 
-        if (ret)
-                print_error();
-
-        return ret;
+        return 0;
 }
diff --git a/tools/power/cpupower/utils/helpers/sysfs.c b/tools/power/cpupower/utils/helpers/sysfs.c
index 851c7a16ca49..09afe5d87f2b 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.c
+++ b/tools/power/cpupower/utils/helpers/sysfs.c
@@ -81,7 +81,7 @@ int sysfs_is_cpu_online(unsigned int cpu)
         close(fd);
 
         value = strtoull(linebuf, &endp, 0);
-        if (value > 1 || value < 0)
+        if (value > 1)
                 return -EINVAL;
 
         return value;
diff --git a/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c b/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c
index 5650ab5a2c20..90a8c4f071e7 100644
--- a/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c
+++ b/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c
@@ -237,7 +237,7 @@ static int init_maxfreq_mode(void)
         unsigned long long hwcr;
         unsigned long min;
 
-        if (!cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC)
+        if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC))
                 goto use_sysfs;
 
         if (cpupower_cpu_info.vendor == X86_VENDOR_AMD) {
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 40631569a0fd..55ab700f6ba5 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -72,7 +72,7 @@ my %default = (
     "IGNORE_UNUSED"             => 0,
 );
 
-my $ktest_config;
+my $ktest_config = "ktest.conf";
 my $version;
 my $have_version = 0;
 my $machine;
@@ -149,7 +149,6 @@ my $bisect_ret_abort;
 my $bisect_ret_default;
 my $in_patchcheck = 0;
 my $run_test;
-my $redirect;
 my $buildlog;
 my $testlog;
 my $dmesg;
@@ -522,7 +521,7 @@ sub read_ync {
     return read_prompt 1, $prompt;
 }
 
-sub get_ktest_config {
+sub get_mandatory_config {
     my ($config) = @_;
     my $ans;
 
@@ -553,29 +552,29 @@ sub get_ktest_config {
     }
 }
 
-sub get_ktest_configs {
-    get_ktest_config("MACHINE");
-    get_ktest_config("BUILD_DIR");
-    get_ktest_config("OUTPUT_DIR");
+sub get_mandatory_configs {
+    get_mandatory_config("MACHINE");
+    get_mandatory_config("BUILD_DIR");
+    get_mandatory_config("OUTPUT_DIR");
 
     if ($newconfig) {
-        get_ktest_config("BUILD_OPTIONS");
+        get_mandatory_config("BUILD_OPTIONS");
     }
 
     # options required for other than just building a kernel
     if (!$buildonly) {
-        get_ktest_config("POWER_CYCLE");
-        get_ktest_config("CONSOLE");
+        get_mandatory_config("POWER_CYCLE");
+        get_mandatory_config("CONSOLE");
     }
 
     # options required for install and more
     if ($buildonly != 1) {
-        get_ktest_config("SSH_USER");
-        get_ktest_config("BUILD_TARGET");
-        get_ktest_config("TARGET_IMAGE");
+        get_mandatory_config("SSH_USER");
+        get_mandatory_config("BUILD_TARGET");
+        get_mandatory_config("TARGET_IMAGE");
     }
 
-    get_ktest_config("LOCALVERSION");
+    get_mandatory_config("LOCALVERSION");
 
     return if ($buildonly);
 
@@ -583,7 +582,7 @@ sub get_ktest_configs {
 
     if (!defined($rtype)) {
         if (!defined($opt{"GRUB_MENU"})) {
-            get_ktest_config("REBOOT_TYPE");
+            get_mandatory_config("REBOOT_TYPE");
             $rtype = $entered_configs{"REBOOT_TYPE"};
         } else {
             $rtype = "grub";
@@ -591,16 +590,16 @@ sub get_ktest_configs {
     }
 
     if ($rtype eq "grub") {
-        get_ktest_config("GRUB_MENU");
+        get_mandatory_config("GRUB_MENU");
     }
 
     if ($rtype eq "grub2") {
-        get_ktest_config("GRUB_MENU");
-        get_ktest_config("GRUB_FILE");
+        get_mandatory_config("GRUB_MENU");
+        get_mandatory_config("GRUB_FILE");
     }
 
     if ($rtype eq "syslinux") {
-        get_ktest_config("SYSLINUX_LABEL");
+        get_mandatory_config("SYSLINUX_LABEL");
     }
 }
 
@@ -1090,7 +1089,7 @@ sub read_config {
     $test_case = __read_config $config, \$test_num;
 
     # make sure we have all mandatory configs
-    get_ktest_configs;
+    get_mandatory_configs;
 
     # was a test specified?
     if (!$test_case) {
@@ -1529,7 +1528,7 @@ sub fail {
 }
 
 sub run_command {
-    my ($command) = @_;
+    my ($command, $redirect) = @_;
     my $dolog = 0;
     my $dord = 0;
     my $pid;
@@ -2265,9 +2264,7 @@ sub build {
     # Run old config regardless, to enforce min configurations
     make_oldconfig;
 
-    $redirect = "$buildlog";
-    my $build_ret = run_command "$make $build_options";
-    undef $redirect;
+    my $build_ret = run_command "$make $build_options", $buildlog;
 
     if (defined($post_build)) {
         # Because a post build may change the kernel version
@@ -2360,9 +2357,7 @@ sub child_run_test {
     $poweroff_on_error = 0;
     $die_on_failure = 1;
 
-    $redirect = "$testlog";
-    run_command $run_test or $failed = 1;
-    undef $redirect;
+    run_command $run_test, $testlog or $failed = 1;
 
     exit $failed;
 }
@@ -2789,12 +2784,17 @@ my %dependency;
 sub assign_configs {
     my ($hash, $config) = @_;
 
+    doprint "Reading configs from $config\n";
+
     open (IN, $config)
         or dodie "Failed to read $config";
 
     while (<IN>) {
+        chomp;
         if (/^((CONFIG\S*)=.*)/) {
             ${$hash}{$2} = $1;
+        } elsif (/^(# (CONFIG\S*) is not set)/) {
+            ${$hash}{$2} = $1;
         }
     }
 
@@ -2807,27 +2807,6 @@ sub process_config_ignore {
     assign_configs \%config_ignore, $config;
 }
 
-sub read_current_config {
-    my ($config_ref) = @_;
-
-    %{$config_ref} = ();
-    undef %{$config_ref};
-
-    my @key = keys %{$config_ref};
-    if ($#key >= 0) {
-        print "did not delete!\n";
-        exit;
-    }
-    open (IN, "$output_config");
-
-    while (<IN>) {
-        if (/^(CONFIG\S+)=(.*)/) {
-            ${$config_ref}{$1} = $2;
-        }
-    }
-    close(IN);
-}
-
 sub get_dependencies {
     my ($config) = @_;
 
@@ -2846,53 +2825,97 @@ sub get_dependencies {
     return @deps;
 }
 
+sub save_config {
+    my ($pc, $file) = @_;
+
+    my %configs = %{$pc};
+
+    doprint "Saving configs into $file\n";
+
+    open(OUT, ">$file") or dodie "Can not write to $file";
+
+    foreach my $config (keys %configs) {
+        print OUT "$configs{$config}\n";
+    }
+    close(OUT);
+}
+
 sub create_config {
-    my @configs = @_;
+    my ($name, $pc) = @_;
 
-    open(OUT, ">$output_config") or dodie "Can not write to $output_config";
+    doprint "Creating old config from $name configs\n";
 
-    foreach my $config (@configs) {
-        print OUT "$config_set{$config}\n";
-        my @deps = get_dependencies $config;
-        foreach my $dep (@deps) {
-            print OUT "$config_set{$dep}\n";
+    save_config $pc, $output_config;
+
+    make_oldconfig;
+}
+
+# compare two config hashes, and return configs with different vals.
+# It returns B's config values, but you can use A to see what A was.
+sub diff_config_vals {
+    my ($pa, $pb) = @_;
+
+    # crappy Perl way to pass in hashes.
+    my %a = %{$pa};
+    my %b = %{$pb};
+
+    my %ret;
+
+    foreach my $item (keys %a) {
+        if (defined($b{$item}) && $b{$item} ne $a{$item}) {
+            $ret{$item} = $b{$item};
         }
     }
 
-    # turn off configs to keep off
-    foreach my $config (keys %config_off) {
-        print OUT "# $config is not set\n";
-    }
+    return %ret;
+}
 
-    # turn off configs that should be off for now
-    foreach my $config (@config_off_tmp) {
-        print OUT "# $config is not set\n";
-    }
+# compare two config hashes and return the configs in B but not A
+sub diff_configs {
+    my ($pa, $pb) = @_;
+
+    my %ret;
+
+    # crappy Perl way to pass in hashes.
+    my %a = %{$pa};
+    my %b = %{$pb};
 
-    foreach my $config (keys %config_ignore) {
-        print OUT "$config_ignore{$config}\n";
+    foreach my $item (keys %b) {
+        if (!defined($a{$item})) {
+            $ret{$item} = $b{$item};
+        }
     }
-    close(OUT);
 
-    make_oldconfig;
+    return %ret;
 }
 
+# return if two configs are equal or not
+# 0 is equal +1 b has something a does not
+# +1 if a and b have a different item.
+# -1 if a has something b does not
 sub compare_configs {
-    my (%a, %b) = @_;
+    my ($pa, $pb) = @_;
 
-    foreach my $item (keys %a) {
-        if (!defined($b{$item})) {
-            print "diff $item\n";
+    my %ret;
+
+    # crappy Perl way to pass in hashes.
+    my %a = %{$pa};
+    my %b = %{$pb};
+
+    foreach my $item (keys %b) {
+        if (!defined($a{$item})) {
+            return 1;
+        }
+        if ($a{$item} ne $b{$item}) {
             return 1;
         }
-        delete $b{$item};
     }
 
-    my @keys = keys %b;
-    if ($#keys) {
-        print "diff2 $keys[0]\n";
+    foreach my $item (keys %a) {
+        if (!defined($b{$item})) {
+            return -1;
+        }
     }
-    return -1 if ($#keys >= 0);
 
     return 0;
 }
@@ -2900,24 +2923,13 @@ sub compare_configs {
 sub run_config_bisect_test {
     my ($type) = @_;
 
-    return run_bisect_test $type, "oldconfig";
-}
+    my $ret = run_bisect_test $type, "oldconfig";
 
-sub process_passed {
-    my (%configs) = @_;
-
-    doprint "These configs had no failure: (Enabling them for further compiles)\n";
-    # Passed! All these configs are part of a good compile.
-    # Add them to the min options.
-    foreach my $config (keys %configs) {
-        if (defined($config_list{$config})) {
-            doprint " removing $config\n";
-            $config_ignore{$config} = $config_list{$config};
-            delete $config_list{$config};
-        }
+    if ($bisect_manual) {
+        $ret = answer_bisect;
     }
-    doprint "config copied to $outputdir/config_good\n";
-    run_command "cp -f $output_config $outputdir/config_good";
+
+    return $ret;
 }
 
 sub process_failed {
@@ -2928,253 +2940,225 @@ sub process_failed {
     doprint "***************************************\n\n";
 }
 
-sub run_config_bisect {
+# used for config bisecting
+my $good_config;
+my $bad_config;
 
-    my @start_list = keys %config_list;
+sub process_new_config {
+    my ($tc, $nc, $gc, $bc) = @_;
 
-    if ($#start_list < 0) {
-        doprint "No more configs to test!!!\n";
-        return -1;
+    my %tmp_config = %{$tc};
+    my %good_configs = %{$gc};
+    my %bad_configs = %{$bc};
+
+    my %new_configs;
+
+    my $runtest = 1;
+    my $ret;
+
+    create_config "tmp_configs", \%tmp_config;
+    assign_configs \%new_configs, $output_config;
+
+    $ret = compare_configs \%new_configs, \%bad_configs;
+    if (!$ret) {
+        doprint "New config equals bad config, try next test\n";
+        $runtest = 0;
+    }
+
+    if ($runtest) {
+        $ret = compare_configs \%new_configs, \%good_configs;
+        if (!$ret) {
+            doprint "New config equals good config, try next test\n";
+            $runtest = 0;
+        }
     }
 
-    doprint "***** RUN TEST ***\n";
+    %{$nc} = %new_configs;
+
+    return $runtest;
+}
+
+sub run_config_bisect {
+    my ($pgood, $pbad) = @_;
+
     my $type = $config_bisect_type;
+
+    my %good_configs = %{$pgood};
+    my %bad_configs = %{$pbad};
+
+    my %diff_configs = diff_config_vals \%good_configs, \%bad_configs;
+    my %b_configs = diff_configs \%good_configs, \%bad_configs;
+    my %g_configs = diff_configs \%bad_configs, \%good_configs;
+
+    my @diff_arr = keys %diff_configs;
+    my $len_diff = $#diff_arr + 1;
+
+    my @b_arr = keys %b_configs;
+    my $len_b = $#b_arr + 1;
+
+    my @g_arr = keys %g_configs;
+    my $len_g = $#g_arr + 1;
+
+    my $runtest = 1;
+    my %new_configs;
     my $ret;
-    my %current_config;
 
-    my $count = $#start_list + 1;
-    doprint "  $count configs to test\n";
+    # First, lets get it down to a single subset.
+    # Is the problem with a difference in values?
+    # Is the problem with a missing config?
+    # Is the problem with a config that breaks things?
 
-    my $half = int($#start_list / 2);
+    # Enable all of one set and see if we get a new bad
+    # or good config.
 
-    do {
-        my @tophalf = @start_list[0 .. $half];
+    # first set the good config to the bad values.
 
-        # keep the bottom half off
-        if ($half < $#start_list) {
-            @config_off_tmp = @start_list[$half + 1 .. $#start_list];
-        } else {
-            @config_off_tmp = ();
-        }
+    doprint "d=$len_diff g=$len_g b=$len_b\n";
 
-        create_config @tophalf;
-        read_current_config \%current_config;
-
-        $count = $#tophalf + 1;
-        doprint "Testing $count configs\n";
-        my $found = 0;
-        # make sure we test something
-        foreach my $config (@tophalf) {
-            if (defined($current_config{$config})) {
-                logit " $config\n";
-                $found = 1;
-            }
-        }
-        if (!$found) {
-            # try the other half
-            doprint "Top half produced no set configs, trying bottom half\n";
-
-            # keep the top half off
-            @config_off_tmp = @tophalf;
-            @tophalf = @start_list[$half + 1 .. $#start_list];
-
-            create_config @tophalf;
-            read_current_config \%current_config;
-            foreach my $config (@tophalf) {
-                if (defined($current_config{$config})) {
-                    logit " $config\n";
-                    $found = 1;
-                }
-            }
-            if (!$found) {
-                doprint "Failed: Can't make new config with current configs\n";
-                foreach my $config (@start_list) {
-                    doprint "  CONFIG: $config\n";
-                }
-                return -1;
+    # first lets enable things in bad config that are enabled in good config
+
+    if ($len_diff > 0) {
+        if ($len_b > 0 || $len_g > 0) {
+            my %tmp_config = %bad_configs;
+
+            doprint "Set tmp config to be bad config with good config values\n";
+            foreach my $item (@diff_arr) {
+                $tmp_config{$item} = $good_configs{$item};
             }
-            $count = $#tophalf + 1;
-            doprint "Testing $count configs\n";
-        }
 
-        $ret = run_config_bisect_test $type;
-        if ($bisect_manual) {
-            $ret = answer_bisect;
-        }
-        if ($ret) {
-            process_passed %current_config;
-            return 0;
+            $runtest = process_new_config \%tmp_config, \%new_configs,
+                            \%good_configs, \%bad_configs;
         }
+    }
 
-        doprint "This config had a failure.\n";
-        doprint "Removing these configs that were not set in this config:\n";
-        doprint "config copied to $outputdir/config_bad\n";
-        run_command "cp -f $output_config $outputdir/config_bad";
+    if (!$runtest && $len_diff > 0) {
 
-        # A config exists in this group that was bad.
-        foreach my $config (keys %config_list) {
-            if (!defined($current_config{$config})) {
-                doprint " removing $config\n";
-                delete $config_list{$config};
-            }
+        if ($len_diff == 1) {
+            process_failed $diff_arr[0];
+            return 1;
         }
+        my %tmp_config = %bad_configs;
 
-        @start_list = @tophalf;
+        my $half = int($#diff_arr / 2);
+        my @tophalf = @diff_arr[0 .. $half];
 
-        if ($#start_list == 0) {
-            process_failed $start_list[0];
-            return 1;
+        doprint "Settings bisect with top half:\n";
+        doprint "Set tmp config to be bad config with some good config values\n";
+        foreach my $item (@tophalf) {
+            $tmp_config{$item} = $good_configs{$item};
         }
 
-        # remove half the configs we are looking at and see if
-        # they are good.
-        $half = int($#start_list / 2);
-    } while ($#start_list > 0);
+        $runtest = process_new_config \%tmp_config, \%new_configs,
+                            \%good_configs, \%bad_configs;
 
-    # we found a single config, try it again unless we are running manually
+        if (!$runtest) {
+            my %tmp_config = %bad_configs;
 
-    if ($bisect_manual) {
-        process_failed $start_list[0];
-        return 1;
-    }
+            doprint "Try bottom half\n";
 
-    my @tophalf = @start_list[0 .. 0];
+            my @bottomhalf = @diff_arr[$half+1 .. $#diff_arr];
 
-    $ret = run_config_bisect_test $type;
-    if ($ret) {
-        process_passed %current_config;
+            foreach my $item (@bottomhalf) {
+                $tmp_config{$item} = $good_configs{$item};
+            }
+
+            $runtest = process_new_config \%tmp_config, \%new_configs,
+                            \%good_configs, \%bad_configs;
+        }
+    }
+
+    if ($runtest) {
+        $ret = run_config_bisect_test $type;
+        if ($ret) {
+            doprint "NEW GOOD CONFIG\n";
+            %good_configs = %new_configs;
+            run_command "mv $good_config ${good_config}.last";
+            save_config \%good_configs, $good_config;
+            %{$pgood} = %good_configs;
+        } else {
+            doprint "NEW BAD CONFIG\n";
+            %bad_configs = %new_configs;
+            run_command "mv $bad_config ${bad_config}.last";
+            save_config \%bad_configs, $bad_config;
+            %{$pbad} = %bad_configs;
+        }
         return 0;
     }
 
-    process_failed $start_list[0];
-    return 1;
+    fail "Hmm, need to do a mix match?\n";
+    return -1;
 }
 
 sub config_bisect {
     my ($i) = @_;
 
-    my $start_config = $config_bisect;
+    my $type = $config_bisect_type;
+    my $ret;
 
-    my $tmpconfig = "$tmpdir/use_config";
+    $bad_config = $config_bisect;
 
     if (defined($config_bisect_good)) {
-        process_config_ignore $config_bisect_good;
-    }
-
-    # Make the file with the bad config and the min config
-    if (defined($minconfig)) {
-        # read the min config for things to ignore
-        run_command "cp $minconfig $tmpconfig" or
-            dodie "failed to copy $minconfig to $tmpconfig";
+        $good_config = $config_bisect_good;
+    } elsif (defined($minconfig)) {
+        $good_config = $minconfig;
     } else {
-        unlink $tmpconfig;
-    }
-
-    if (-f $tmpconfig) {
-        load_force_config($tmpconfig);
-        process_config_ignore $tmpconfig;
-    }
-
-    # now process the start config
-    run_command "cp $start_config $output_config" or
-        dodie "failed to copy $start_config to $output_config";
-
-    # read directly what we want to check
-    my %config_check;
-    open (IN, $output_config)
-        or dodie "failed to open $output_config";
-
-    while (<IN>) {
-        if (/^((CONFIG\S*)=.*)/) {
-            $config_check{$2} = $1;
+        doprint "No config specified, checking if defconfig works";
+        $ret = run_bisect_test $type, "defconfig";
+        if (!$ret) {
+            fail "Have no good config to compare with, please set CONFIG_BISECT_GOOD";
+            return 1;
         }
+        $good_config = $output_config;
     }
-    close(IN);
 
-    # Now run oldconfig with the minconfig
-    make_oldconfig;
+    # we don't want min configs to cause issues here.
+    doprint "Disabling 'MIN_CONFIG' for this test\n";
+    undef $minconfig;
 
-    # check to see what we lost (or gained)
-    open (IN, $output_config)
-        or dodie "Failed to read $start_config";
+    my %good_configs;
+    my %bad_configs;
+    my %tmp_configs;
 
-    my %removed_configs;
-    my %added_configs;
+    doprint "Run good configs through make oldconfig\n";
+    assign_configs \%tmp_configs, $good_config;
+    create_config "$good_config", \%tmp_configs;
+    assign_configs \%good_configs, $output_config;
 
-    while (<IN>) {
-        if (/^((CONFIG\S*)=.*)/) {
-            # save off all options
-            $config_set{$2} = $1;
-            if (defined($config_check{$2})) {
-                if (defined($config_ignore{$2})) {
-                    $removed_configs{$2} = $1;
-                } else {
-                    $config_list{$2} = $1;
-                }
-            } elsif (!defined($config_ignore{$2})) {
-                $added_configs{$2} = $1;
-                $config_list{$2} = $1;
-            }
-        } elsif (/^# ((CONFIG\S*).*)/) {
-            # Keep these configs disabled
-            $config_set{$2} = $1;
-            $config_off{$2} = $1;
-        }
-    }
-    close(IN);
+    doprint "Run bad configs through make oldconfig\n";
+    assign_configs \%tmp_configs, $bad_config;
+    create_config "$bad_config", \%tmp_configs;
+    assign_configs \%bad_configs, $output_config;
 
-    my @confs = keys %removed_configs;
-    if ($#confs >= 0) {
-        doprint "Configs overridden by default configs and removed from check:\n";
-        foreach my $config (@confs) {
-            doprint " $config\n";
-        }
-    }
-    @confs = keys %added_configs;
-    if ($#confs >= 0) {
-        doprint "Configs appearing in make oldconfig and added:\n";
-        foreach my $config (@confs) {
-            doprint " $config\n";
-        }
-    }
+    $good_config = "$tmpdir/good_config";
+    $bad_config = "$tmpdir/bad_config";
+
+    save_config \%good_configs, $good_config;
+    save_config \%bad_configs, $bad_config;
 
-    my %config_test;
-    my $once = 0;
 
-    @config_off_tmp = ();
+    if (defined($config_bisect_check) && $config_bisect_check ne "0") {
+        if ($config_bisect_check ne "good") {
+            doprint "Testing bad config\n";
 
-    # Sometimes kconfig does weird things. We must make sure
-    # that the config we autocreate has everything we need
-    # to test, otherwise we may miss testing configs, or
-    # may not be able to create a new config.
-    # Here we create a config with everything set.
-    create_config (keys %config_list);
-    read_current_config \%config_test;
-    foreach my $config (keys %config_list) {
-        if (!defined($config_test{$config})) {
-            if (!$once) {
-                $once = 1;
-                doprint "Configs not produced by kconfig (will not be checked):\n";
+            $ret = run_bisect_test $type, "useconfig:$bad_config";
+            if ($ret) {
+                fail "Bad config succeeded when expected to fail!";
+                return 0;
             }
-            doprint "  $config\n";
-            delete $config_list{$config};
         }
-    }
-    my $ret;
+        if ($config_bisect_check ne "bad") {
+            doprint "Testing good config\n";
 
-    if (defined($config_bisect_check) && $config_bisect_check) {
-        doprint " Checking to make sure bad config with min config fails\n";
-        create_config keys %config_list;
-        $ret = run_config_bisect_test $config_bisect_type;
-        if ($ret) {
-            doprint " FAILED! Bad config with min config boots fine\n";
-            return -1;
+            $ret = run_bisect_test $type, "useconfig:$good_config";
+            if (!$ret) {
+                fail "Good config failed when expected to succeed!";
+                return 0;
+            }
         }
-        doprint " Bad config with min config fails as expected\n";
     }
 
     do {
-        $ret = run_config_bisect;
+        $ret = run_config_bisect \%good_configs, \%bad_configs;
     } while (!$ret);
 
     return $ret if ($ret < 0);
@@ -3455,29 +3439,6 @@ sub read_depends {
     read_kconfig($kconfig);
 }
 
-sub read_config_list {
-    my ($config) = @_;
-
-    open (IN, $config)
-        or dodie "Failed to read $config";
-
-    while (<IN>) {
-        if (/^((CONFIG\S*)=.*)/) {
-            if (!defined($config_ignore{$2})) {
-                $config_list{$2} = $1;
-            }
-        }
-    }
-
-    close(IN);
-}
-
-sub read_output_config {
-    my ($config) = @_;
-
-    assign_configs \%config_ignore, $config;
-}
-
 sub make_new_config {
     my @configs = @_;
 
@@ -3863,7 +3824,7 @@ sub make_warnings_file {
     success $i;
 }
 
-$#ARGV < 1 or die "ktest.pl version: $VERSION\n   usage: ktest.pl config-file\n";
+$#ARGV < 1 or die "ktest.pl version: $VERSION\n   usage: ktest.pl [config-file]\n";
 
 if ($#ARGV == 0) {
     $ktest_config = $ARGV[0];
@@ -3873,8 +3834,6 @@ if ($#ARGV == 0) {
             exit 0;
         }
     }
-} else {
-    $ktest_config = "ktest.conf";
 }
 
 if (! -f $ktest_config) {
diff --git a/tools/testing/ktest/sample.conf b/tools/testing/ktest/sample.conf
index 172eec4517fb..911e45ad657a 100644
--- a/tools/testing/ktest/sample.conf
+++ b/tools/testing/ktest/sample.conf
@@ -1098,49 +1098,35 @@
 #
 #  The way it works is this:
 #
-#   First it finds a config to work with. Since a different version, or
-#   MIN_CONFIG may cause different dependecies, it must run through this
-#   preparation.
+#   You can specify a good config with CONFIG_BISECT_GOOD, otherwise it
+#   will use the MIN_CONFIG, and if that's not specified, it will use
+#   the config that comes with "make defconfig".
 #
-#   Overwrites any config set in the bad config with a config set in
-#   either the MIN_CONFIG or ADD_CONFIG. Thus, make sure these configs
-#   are minimal and do not disable configs you want to test:
-#   (ie.  # CONFIG_FOO is not set).
+#   It runs both the good and bad configs through a make oldconfig to
+#   make sure that they are set up for the kernel that is checked out.
 #
-#   An oldconfig is run on the bad config and any new config that
-#   appears will be added to the configs to test.
+#   It then reads the configs that are set, as well as the ones that are
+#   not set for both the good and bad configs, and then compares them.
+#   It will set half of the good configs within the bad config (note,
+#   "set" means to make the bad config match the good config, a config
+#   in the good config that is off, will be turned off in the bad
+#   config. That is considered a "set").
 #
-#   Finally, it generates a config with the above result and runs it
-#   again through make oldconfig to produce a config that should be
-#   satisfied by kconfig.
+#   It tests this new config and if it works, it becomes the new good
+#   config, otherwise it becomes the new bad config. It continues this
+#   process until there's only one config left and it will report that
+#   config.
 #
-#   Then it starts the bisect.
+#   The "bad config" can also be a config that is needed to boot but was
+#   disabled because it depended on something that wasn't set.
 #
-#   The configs to test are cut in half. If all the configs in this
-#   half depend on a config in the other half, then the other half
-#   is tested instead. If no configs are enabled by either half, then
-#   this means a circular dependency exists and the test fails.
+#   During this process, it saves the current good and bad configs in
+#   ${TMP_DIR}/good_config and ${TMP_DIR}/bad_config respectively.
+#   If you stop the test, you can copy them to a new location to
+#   reuse them again.
 #
-#   A config is created with the test half, and the bisect test is run.
-#
-#   If the bisect succeeds, then all configs in the generated config
-#   are removed from the configs to test and added to the configs that
-#   will be enabled for all builds (they will be enabled, but not be part
-#   of the configs to examine).
-#
-#   If the bisect fails, then all test configs that were not enabled by
-#   the config file are removed from the test. These configs will not
-#   be enabled in future tests. Since current config failed, we consider
-#   this to be a subset of the config that we started with.
-#
-#   When we are down to one config, it is considered the bad config.
-#
-#   Note, the config chosen may not be the true bad config. Due to
-#   dependencies and selections of the kbuild system, mulitple
-#   configs may be needed to cause a failure. If you disable the
-#   config that was found and restart the test, if the test fails
-#   again, it is recommended to rerun the config_bisect with a new
-#   bad config without the found config enabled.
+#   Although the MIN_CONFIG may be the config it starts with, the
+#   MIN_CONFIG is ignored.
 #
 #  The option BUILD_TYPE will be ignored.
 #
@@ -1160,13 +1146,16 @@
 # CONFIG_BISECT_GOOD (optional)
 #  If you have a good config to start with, then you
 #  can specify it with CONFIG_BISECT_GOOD. Otherwise
-#  the MIN_CONFIG is the base.
+#  the MIN_CONFIG is the base, if MIN_CONFIG is not set
+#  It will build a config with "make defconfig"
 #
 # CONFIG_BISECT_CHECK (optional)
 #  Set this to 1 if you want to confirm that the config ktest
 #  generates (the bad config with the min config) is still bad.
 #  It may be that the min config fixes what broke the bad config
 #  and the test will not return a result.
+#  Set it to "good" to test only the good config and set it
+#  to "bad" to only test the bad config.
 #
 # Example:
 #   TEST_START
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index e66e710cc595..36ff2e4c7b6f 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -2,8 +2,10 @@ TARGETS = breakpoints
 TARGETS += cpu-hotplug
 TARGETS += efivarfs
 TARGETS += kcmp
+TARGETS += memfd
 TARGETS += memory-hotplug
 TARGETS += mqueue
+TARGETS += mount
 TARGETS += net
 TARGETS += ptrace
 TARGETS += timers
@@ -11,6 +13,10 @@ TARGETS += vm
 TARGETS += powerpc
 TARGETS += user
 TARGETS += sysctl
+TARGETS += firmware
+
+TARGETS_HOTPLUG = cpu-hotplug
+TARGETS_HOTPLUG += memory-hotplug
 
 all:
         for TARGET in $(TARGETS); do \
@@ -22,6 +28,21 @@ run_tests: all
                 make -C $$TARGET run_tests; \
         done;
 
+hotplug:
+        for TARGET in $(TARGETS_HOTPLUG); do \
+                make -C $$TARGET; \
+        done;
+
+run_hotplug: hotplug
+        for TARGET in $(TARGETS_HOTPLUG); do \
+                make -C $$TARGET run_full_test; \
+        done;
+
+clean_hotplug:
+        for TARGET in $(TARGETS_HOTPLUG); do \
+                make -C $$TARGET clean; \
+        done;
+
 clean:
         for TARGET in $(TARGETS); do \
                 make -C $$TARGET clean; \
diff --git a/tools/testing/selftests/README.txt b/tools/testing/selftests/README.txt
index 5e2faf9c55d3..2660d5ff9179 100644
--- a/tools/testing/selftests/README.txt
+++ b/tools/testing/selftests/README.txt
@@ -4,8 +4,15 @@ The kernel contains a set of "self tests" under the tools/testing/selftests/
 directory. These are intended to be small unit tests to exercise individual
 code paths in the kernel.
 
-Running the selftests
-=====================
+On some systems, hot-plug tests could hang forever waiting for cpu and
+memory to be ready to be offlined. A special hot-plug target is created
+to run full range of hot-plug tests. In default mode, hot-plug tests run
+in safe mode with a limited scope. In limited mode, cpu-hotplug test is
+run on a single cpu as opposed to all hotplug capable cpus, and memory
+hotplug test is run on 2% of hotplug capable memory instead of 10%.
+
+Running the selftests (hotplug tests are run in limited mode)
+=============================================================
 
 To build the tests:
 
@@ -18,14 +25,26 @@ To run the tests:
 
 - note that some tests will require root privileges.
 
-
-To run only tests targetted for a single subsystem:
+To run only tests targeted for a single subsystem: (including
+hotplug targets in limited mode)
 
   $  make -C tools/testing/selftests TARGETS=cpu-hotplug run_tests
 
 See the top-level tools/testing/selftests/Makefile for the list of all possible
 targets.
 
+Running the full range hotplug selftests
+========================================
+
+To build the tests:
+
+  $ make -C tools/testing/selftests hotplug
+
+To run the tests:
+
+  $ make -C tools/testing/selftests run_hotplug
+
+- note that some tests will require root privileges.
 
 Contributing new tests
 ======================
diff --git a/tools/testing/selftests/cpu-hotplug/Makefile b/tools/testing/selftests/cpu-hotplug/Makefile
index 790c23a9db44..e9c28d8dc84b 100644
--- a/tools/testing/selftests/cpu-hotplug/Makefile
+++ b/tools/testing/selftests/cpu-hotplug/Makefile
@@ -3,4 +3,7 @@ all:
 run_tests:
         @/bin/bash ./on-off-test.sh || echo "cpu-hotplug selftests: [FAIL]"
 
+run_full_test:
+        @/bin/bash ./on-off-test.sh -a || echo "cpu-hotplug selftests: [FAIL]"
+
 clean:
diff --git a/tools/testing/selftests/cpu-hotplug/on-off-test.sh b/tools/testing/selftests/cpu-hotplug/on-off-test.sh
index bdde7cf428bb..98b1d6565f2c 100644
--- a/tools/testing/selftests/cpu-hotplug/on-off-test.sh
+++ b/tools/testing/selftests/cpu-hotplug/on-off-test.sh
@@ -11,6 +11,8 @@ prerequisite()
                 exit 0
         fi
 
+        taskset -p 01 $$
+
         SYSFS=`mount -t sysfs | head -1 | awk '{ print $3 }'`
 
         if [ ! -d "$SYSFS" ]; then
@@ -22,6 +24,19 @@ prerequisite()
                 echo $msg cpu hotplug is not supported >&2
                 exit 0
         fi
+
+        echo "CPU online/offline summary:"
+        online_cpus=`cat $SYSFS/devices/system/cpu/online`
+        online_max=${online_cpus##*-}
+        echo -e "\t Cpus in online state: $online_cpus"
+
+        offline_cpus=`cat $SYSFS/devices/system/cpu/offline`
+        if [[ "a$offline_cpus" = "a" ]]; then
+                offline_cpus=0
+        else
+                offline_max=${offline_cpus##*-}
+        fi
+        echo -e "\t Cpus in offline state: $offline_cpus"
 }
 
 #
@@ -113,15 +128,25 @@ offline_cpu_expect_fail()
 }
 
 error=-12
+allcpus=0
 priority=0
+online_cpus=0
+online_max=0
+offline_cpus=0
+offline_max=0
 
-while getopts e:hp: opt; do
+while getopts e:ahp: opt; do
         case $opt in
         e)
                 error=$OPTARG
                 ;;
+        a)
+                allcpus=1
+                ;;
         h)
-                echo "Usage $0 [ -e errno ] [ -p notifier-priority ]"
+                echo "Usage $0 [ -a ] [ -e errno ] [ -p notifier-priority ]"
+                echo -e "\t default offline one cpu"
+                echo -e "\t run with -a option to offline all cpus"
                 exit
                 ;;
         p)
@@ -138,6 +163,29 @@ fi
 prerequisite
 
 #
+# Safe test (default) - offline and online one cpu
+#
+if [ $allcpus -eq 0 ]; then
+        echo "Limited scope test: one hotplug cpu"
+        echo -e "\t (leaves cpu in the original state):"
+        echo -e "\t online to offline to online: cpu $online_max"
+        offline_cpu_expect_success $online_max
+        online_cpu_expect_success $online_max
+
+        if [[ $offline_cpus -gt 0 ]]; then
+                echo -e "\t offline to online to offline: cpu $offline_max"
+                online_cpu_expect_success $offline_max
+                offline_cpu_expect_success $offline_max
+        fi
+        exit 0
+else
+        echo "Full scope test: all hotplug cpus"
+        echo -e "\t online all offline cpus"
+        echo -e "\t offline all online cpus"
+        echo -e "\t online all offline cpus"
+fi
+
+#
 # Online all hot-pluggable CPUs
 #
 for cpu in `hotplaggable_offline_cpus`; do
diff --git a/tools/testing/selftests/firmware/Makefile b/tools/testing/selftests/firmware/Makefile
new file mode 100644
index 000000000000..e23cce0bbc3a
--- /dev/null
+++ b/tools/testing/selftests/firmware/Makefile
@@ -0,0 +1,27 @@
+# Makefile for firmware loading selftests
+
+# No binaries, but make sure arg-less "make" doesn't trigger "run_tests"
+all:
+
+fw_filesystem:
+        @if /bin/sh ./fw_filesystem.sh ; then \
+                echo "fw_filesystem: ok"; \
+        else \
+                echo "fw_filesystem: [FAIL]"; \
+                exit 1; \
+        fi
+
+fw_userhelper:
+        @if /bin/sh ./fw_userhelper.sh ; then \
+                echo "fw_userhelper: ok"; \
+        else \
+                echo "fw_userhelper: [FAIL]"; \
+                exit 1; \
+        fi
+
+run_tests: all fw_filesystem fw_userhelper
+
+# Nothing to clean up.
+clean:
+
+.PHONY: all clean run_tests fw_filesystem fw_userhelper
diff --git a/tools/testing/selftests/firmware/fw_filesystem.sh b/tools/testing/selftests/firmware/fw_filesystem.sh
new file mode 100644
index 000000000000..3fc6c10c2479
--- /dev/null
+++ b/tools/testing/selftests/firmware/fw_filesystem.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+# This validates that the kernel will load firmware out of its list of
+# firmware locations on disk. Since the user helper does similar work,
+# we reset the custom load directory to a location the user helper doesn't
+# know so we can be sure we're not accidentally testing the user helper.
+set -e
+
+modprobe test_firmware
+
+DIR=/sys/devices/virtual/misc/test_firmware
+
+OLD_TIMEOUT=$(cat /sys/class/firmware/timeout)
+OLD_FWPATH=$(cat /sys/module/firmware_class/parameters/path)
+
+FWPATH=$(mktemp -d)
+FW="$FWPATH/test-firmware.bin"
+
+test_finish()
+{
+        echo "$OLD_TIMEOUT" >/sys/class/firmware/timeout
+        echo -n "$OLD_PATH" >/sys/module/firmware_class/parameters/path
+        rm -f "$FW"
+        rmdir "$FWPATH"
+}
+
+trap "test_finish" EXIT
+
+# Turn down the timeout so failures don't take so long.
+echo 1 >/sys/class/firmware/timeout
+# Set the kernel search path.
+echo -n "$FWPATH" >/sys/module/firmware_class/parameters/path
+
+# This is an unlikely real-world firmware content. :)
+echo "ABCD0123" >"$FW"
+
+NAME=$(basename "$FW")
+
+# Request a firmware that doesn't exist, it should fail.
+echo -n "nope-$NAME" >"$DIR"/trigger_request
+if diff -q "$FW" /dev/test_firmware >/dev/null ; then
+        echo "$0: firmware was not expected to match" >&2
+        exit 1
+else
+        echo "$0: timeout works"
+fi
+
+# This should succeed via kernel load or will fail after 1 second after
+# being handed over to the user helper, which won't find the fw either.
+if ! echo -n "$NAME" >"$DIR"/trigger_request ; then
+        echo "$0: could not trigger request" >&2
+        exit 1
+fi
+
+# Verify the contents are what we expect.
+if ! diff -q "$FW" /dev/test_firmware >/dev/null ; then
+        echo "$0: firmware was not loaded" >&2
+        exit 1
+else
+        echo "$0: filesystem loading works"
+fi
+
+exit 0
diff --git a/tools/testing/selftests/firmware/fw_userhelper.sh b/tools/testing/selftests/firmware/fw_userhelper.sh
new file mode 100644
index 000000000000..6efbade12139
--- /dev/null
+++ b/tools/testing/selftests/firmware/fw_userhelper.sh
@@ -0,0 +1,89 @@
+#!/bin/sh
+# This validates that the kernel will fall back to using the user helper
+# to load firmware it can't find on disk itself. We must request a firmware
+# that the kernel won't find, and any installed helper (e.g. udev) also
+# won't find so that we can do the load ourself manually.
+set -e
+
+modprobe test_firmware
+
+DIR=/sys/devices/virtual/misc/test_firmware
+
+OLD_TIMEOUT=$(cat /sys/class/firmware/timeout)
+
+FWPATH=$(mktemp -d)
+FW="$FWPATH/test-firmware.bin"
+
+test_finish()
+{
+        echo "$OLD_TIMEOUT" >/sys/class/firmware/timeout
+        rm -f "$FW"
+        rmdir "$FWPATH"
+}
+
+load_fw()
+{
+        local name="$1"
+        local file="$2"
+
+        # This will block until our load (below) has finished.
+        echo -n "$name" >"$DIR"/trigger_request &
+
+        # Give kernel a chance to react.
+        local timeout=10
+        while [ ! -e "$DIR"/"$name"/loading ]; do
+                sleep 0.1
+                timeout=$(( $timeout - 1 ))
+                if [ "$timeout" -eq 0 ]; then
+                        echo "$0: firmware interface never appeared" >&2
+                        exit 1
+                fi
+        done
+
+        echo 1 >"$DIR"/"$name"/loading
+        cat "$file" >"$DIR"/"$name"/data
+        echo 0 >"$DIR"/"$name"/loading
+
+        # Wait for request to finish.
+        wait
+}
+
+trap "test_finish" EXIT
+
+# This is an unlikely real-world firmware content. :)
+echo "ABCD0123" >"$FW"
+NAME=$(basename "$FW")
+
+# Test failure when doing nothing (timeout works).
+echo 1 >/sys/class/firmware/timeout
+echo -n "$NAME" >"$DIR"/trigger_request
+if diff -q "$FW" /dev/test_firmware >/dev/null ; then
+        echo "$0: firmware was not expected to match" >&2
+        exit 1
+else
+        echo "$0: timeout works"
+fi
+
+# Put timeout high enough for us to do work but not so long that failures
+# slow down this test too much.
+echo 4 >/sys/class/firmware/timeout
+
+# Load this script instead of the desired firmware.
+load_fw "$NAME" "$0"
+if diff -q "$FW" /dev/test_firmware >/dev/null ; then
+        echo "$0: firmware was not expected to match" >&2
+        exit 1
+else
+        echo "$0: firmware comparison works"
+fi
+
+# Do a proper load, which should work correctly.
+load_fw "$NAME" "$FW"
+if ! diff -q "$FW" /dev/test_firmware >/dev/null ; then
+        echo "$0: firmware was not loaded" >&2
+        exit 1
+else
+        echo "$0: user helper firmware loading works"
+fi
+
+exit 0
diff --git a/tools/testing/selftests/kcmp/kcmp_test.c b/tools/testing/selftests/kcmp/kcmp_test.c
index fa4f1b37e045..dbba4084869c 100644
--- a/tools/testing/selftests/kcmp/kcmp_test.c
+++ b/tools/testing/selftests/kcmp/kcmp_test.c
@@ -81,7 +81,7 @@ int main(int argc, char **argv)
                 /* Compare with self */
                 ret = sys_kcmp(pid1, pid1, KCMP_VM, 0, 0);
                 if (ret) {
-                        printf("FAIL: 0 expected but %li returned (%s)\n",
+                        printf("FAIL: 0 expected but %d returned (%s)\n",
                                 ret, strerror(errno));
                         ret = -1;
                 } else
diff --git a/tools/testing/selftests/memfd/.gitignore b/tools/testing/selftests/memfd/.gitignore
new file mode 100644
index 000000000000..afe87c40ac80
--- /dev/null
+++ b/tools/testing/selftests/memfd/.gitignore
@@ -0,0 +1,4 @@
+fuse_mnt
+fuse_test
+memfd_test
+memfd-test-file
diff --git a/tools/testing/selftests/memfd/Makefile b/tools/testing/selftests/memfd/Makefile
new file mode 100644
index 000000000000..6816c491c5ff
--- /dev/null
+++ b/tools/testing/selftests/memfd/Makefile
@@ -0,0 +1,41 @@
+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]"
+
+clean:
+        $(RM) memfd_test fuse_test
diff --git a/tools/testing/selftests/memfd/fuse_mnt.c b/tools/testing/selftests/memfd/fuse_mnt.c
new file mode 100644
index 000000000000..feacf1280fcd
--- /dev/null
+++ b/tools/testing/selftests/memfd/fuse_mnt.c
@@ -0,0 +1,110 @@
+/*
+ * memfd test file-system
+ * This file uses FUSE to create a dummy file-system with only one file /memfd.
+ * This file is read-only and takes 1s per read.
+ *
+ * This file-system is used by the memfd test-cases to force the kernel to pin
+ * pages during reads(). Due to the 1s delay of this file-system, this is a
+ * nice way to test race-conditions against get_user_pages() in the kernel.
+ *
+ * We use direct_io==1 to force the kernel to use direct-IO for this
+ * file-system.
+ */
+
+#define FUSE_USE_VERSION 26
+
+#include <fuse.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+static const char memfd_content[] = "memfd-example-content";
+static const char memfd_path[] = "/memfd";
+
+static int memfd_getattr(const char *path, struct stat *st)
+{
+        memset(st, 0, sizeof(*st));
+
+        if (!strcmp(path, "/")) {
+                st->st_mode = S_IFDIR | 0755;
+                st->st_nlink = 2;
+        } else if (!strcmp(path, memfd_path)) {
+                st->st_mode = S_IFREG | 0444;
+                st->st_nlink = 1;
+                st->st_size = strlen(memfd_content);
+        } else {
+                return -ENOENT;
+        }
+
+        return 0;
+}
+
+static int memfd_readdir(const char *path,
+                         void *buf,
+                         fuse_fill_dir_t filler,
+                         off_t offset,
+                         struct fuse_file_info *fi)
+{
+        if (strcmp(path, "/"))
+                return -ENOENT;
+
+        filler(buf, ".", NULL, 0);
+        filler(buf, "..", NULL, 0);
+        filler(buf, memfd_path + 1, NULL, 0);
+
+        return 0;
+}
+
+static int memfd_open(const char *path, struct fuse_file_info *fi)
+{
+        if (strcmp(path, memfd_path))
+                return -ENOENT;
+
+        if ((fi->flags & 3) != O_RDONLY)
+                return -EACCES;
+
+        /* force direct-IO */
+        fi->direct_io = 1;
+
+        return 0;
+}
+
+static int memfd_read(const char *path,
+                      char *buf,
+                      size_t size,
+                      off_t offset,
+                      struct fuse_file_info *fi)
+{
+        size_t len;
+
+        if (strcmp(path, memfd_path) != 0)
+                return -ENOENT;
+
+        sleep(1);
+
+        len = strlen(memfd_content);
+        if (offset < len) {
+                if (offset + size > len)
+                        size = len - offset;
+
+                memcpy(buf, memfd_content + offset, size);
+        } else {
+                size = 0;
+        }
+
+        return size;
+}
+
+static struct fuse_operations memfd_ops = {
+        .getattr        = memfd_getattr,
+        .readdir        = memfd_readdir,
+        .open           = memfd_open,
+        .read           = memfd_read,
+};
+
+int main(int argc, char *argv[])
+{
+        return fuse_main(argc, argv, &memfd_ops, NULL);
+}
diff --git a/tools/testing/selftests/memfd/fuse_test.c b/tools/testing/selftests/memfd/fuse_test.c
new file mode 100644
index 000000000000..67908b18f035
--- /dev/null
+++ b/tools/testing/selftests/memfd/fuse_test.c
@@ -0,0 +1,311 @@
+/*
+ * memfd GUP test-case
+ * This tests memfd interactions with get_user_pages(). We require the
+ * fuse_mnt.c program to provide a fake direct-IO FUSE mount-point for us. This
+ * file-system delays _all_ reads by 1s and forces direct-IO. This means, any
+ * read() on files in that file-system will pin the receive-buffer pages for at
+ * least 1s via get_user_pages().
+ *
+ * We use this trick to race ADD_SEALS against a write on a memfd object. The
+ * ADD_SEALS must fail if the memfd pages are still pinned. Note that we use
+ * the read() syscall with our memory-mapped memfd object as receive buffer to
+ * force the kernel to write into our memfd object.
+ */
+
+#define _GNU_SOURCE
+#define __EXPORTED_HEADERS__
+
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <linux/falloc.h>
+#include <linux/fcntl.h>
+#include <linux/memfd.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define MFD_DEF_SIZE 8192
+#define STACK_SIZE 65535
+
+static int sys_memfd_create(const char *name,
+                            unsigned int flags)
+{
+        return syscall(__NR_memfd_create, name, flags);
+}
+
+static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags)
+{
+        int r, fd;
+
+        fd = sys_memfd_create(name, flags);
+        if (fd < 0) {
+                printf("memfd_create(\"%s\", %u) failed: %m\n",
+                       name, flags);
+                abort();
+        }
+
+        r = ftruncate(fd, sz);
+        if (r < 0) {
+                printf("ftruncate(%llu) failed: %m\n", (unsigned long long)sz);
+                abort();
+        }
+
+        return fd;
+}
+
+static __u64 mfd_assert_get_seals(int fd)
+{
+        long r;
+
+        r = fcntl(fd, F_GET_SEALS);
+        if (r < 0) {
+                printf("GET_SEALS(%d) failed: %m\n", fd);
+                abort();
+        }
+
+        return r;
+}
+
+static void mfd_assert_has_seals(int fd, __u64 seals)
+{
+        __u64 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);
+                abort();
+        }
+}
+
+static void mfd_assert_add_seals(int fd, __u64 seals)
+{
+        long r;
+        __u64 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);
+                abort();
+        }
+}
+
+static int mfd_busy_add_seals(int fd, __u64 seals)
+{
+        long r;
+        __u64 s;
+
+        r = fcntl(fd, F_GET_SEALS);
+        if (r < 0)
+                s = 0;
+        else
+                s = r;
+
+        r = fcntl(fd, F_ADD_SEALS, seals);
+        if (r < 0 && errno != EBUSY) {
+                printf("ADD_SEALS(%d, %llu -> %llu) didn't fail as expected with EBUSY: %m\n",
+                       fd, (unsigned long long)s, (unsigned long long)seals);
+                abort();
+        }
+
+        return r;
+}
+
+static void *mfd_assert_mmap_shared(int fd)
+{
+        void *p;
+
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+
+        return p;
+}
+
+static void *mfd_assert_mmap_private(int fd)
+{
+        void *p;
+
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_PRIVATE,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+
+        return p;
+}
+
+static int global_mfd = -1;
+static void *global_p = NULL;
+
+static int sealing_thread_fn(void *arg)
+{
+        int sig, r;
+
+        /*
+         * This thread first waits 200ms so any pending operation in the parent
+         * is correctly started. After that, it tries to seal @global_mfd as
+         * SEAL_WRITE. This _must_ fail as the parent thread has a read() into
+         * that memory mapped object still ongoing.
+         * We then wait one more second and try sealing again. This time it
+         * must succeed as there shouldn't be anyone else pinning the pages.
+         */
+
+        /* wait 200ms for FUSE-request to be active */
+        usleep(200000);
+
+        /* unmount mapping before sealing to avoid i_mmap_writable failures */
+        munmap(global_p, MFD_DEF_SIZE);
+
+        /* Try sealing the global file; expect EBUSY or success. Current
+         * kernels will never succeed, but in the future, kernels might
+         * implement page-replacements or other fancy ways to avoid racing
+         * writes. */
+        r = mfd_busy_add_seals(global_mfd, F_SEAL_WRITE);
+        if (r >= 0) {
+                printf("HURRAY! This kernel fixed GUP races!\n");
+        } else {
+                /* wait 1s more so the FUSE-request is done */
+                sleep(1);
+
+                /* try sealing the global file again */
+                mfd_assert_add_seals(global_mfd, F_SEAL_WRITE);
+        }
+
+        return 0;
+}
+
+static pid_t spawn_sealing_thread(void)
+{
+        uint8_t *stack;
+        pid_t pid;
+
+        stack = malloc(STACK_SIZE);
+        if (!stack) {
+                printf("malloc(STACK_SIZE) failed: %m\n");
+                abort();
+        }
+
+        pid = clone(sealing_thread_fn,
+                    stack + STACK_SIZE,
+                    SIGCHLD | CLONE_FILES | CLONE_FS | CLONE_VM,
+                    NULL);
+        if (pid < 0) {
+                printf("clone() failed: %m\n");
+                abort();
+        }
+
+        return pid;
+}
+
+static void join_sealing_thread(pid_t pid)
+{
+        waitpid(pid, NULL, 0);
+}
+
+int main(int argc, char **argv)
+{
+        static const char zero[MFD_DEF_SIZE];
+        int fd, mfd, r;
+        void *p;
+        int was_sealed;
+        pid_t pid;
+
+        if (argc < 2) {
+                printf("error: please pass path to file in fuse_mnt mount-point\n");
+                abort();
+        }
+
+        /* open FUSE memfd file for GUP testing */
+        printf("opening: %s\n", argv[1]);
+        fd = open(argv[1], O_RDONLY | O_CLOEXEC);
+        if (fd < 0) {
+                printf("cannot open(\"%s\"): %m\n", argv[1]);
+                abort();
+        }
+
+        /* create new memfd-object */
+        mfd = mfd_assert_new("kern_memfd_fuse",
+                             MFD_DEF_SIZE,
+                             MFD_CLOEXEC | MFD_ALLOW_SEALING);
+
+        /* mmap memfd-object for writing */
+        p = mfd_assert_mmap_shared(mfd);
+
+        /* pass mfd+mapping to a separate sealing-thread which tries to seal
+         * the memfd objects with SEAL_WRITE while we write into it */
+        global_mfd = mfd;
+        global_p = p;
+        pid = spawn_sealing_thread();
+
+        /* Use read() on the FUSE file to read into our memory-mapped memfd
+         * object. This races the other thread which tries to seal the
+         * memfd-object.
+         * If @fd is on the memfd-fake-FUSE-FS, the read() is delayed by 1s.
+         * This guarantees that the receive-buffer is pinned for 1s until the
+         * data is written into it. The racing ADD_SEALS should thus fail as
+         * the pages are still pinned. */
+        r = read(fd, p, MFD_DEF_SIZE);
+        if (r < 0) {
+                printf("read() failed: %m\n");
+                abort();
+        } else if (!r) {
+                printf("unexpected EOF on read()\n");
+                abort();
+        }
+
+        was_sealed = mfd_assert_get_seals(mfd) & F_SEAL_WRITE;
+
+        /* Wait for sealing-thread to finish and verify that it
+         * successfully sealed the file after the second try. */
+        join_sealing_thread(pid);
+        mfd_assert_has_seals(mfd, F_SEAL_WRITE);
+
+        /* *IF* the memfd-object was sealed at the time our read() returned,
+         * then the kernel did a page-replacement or canceled the read() (or
+         * whatever magic it did..). In that case, the memfd object is still
+         * all zero.
+         * In case the memfd-object was *not* sealed, the read() was successfull
+         * and the memfd object must *not* be all zero.
+         * Note that in real scenarios, there might be a mixture of both, but
+         * in this test-cases, we have explicit 200ms delays which should be
+         * enough to avoid any in-flight writes. */
+
+        p = mfd_assert_mmap_private(mfd);
+        if (was_sealed && memcmp(p, zero, MFD_DEF_SIZE)) {
+                printf("memfd sealed during read() but data not discarded\n");
+                abort();
+        } else if (!was_sealed && !memcmp(p, zero, MFD_DEF_SIZE)) {
+                printf("memfd sealed after read() but data discarded\n");
+                abort();
+        }
+
+        close(mfd);
+        close(fd);
+
+        printf("fuse: DONE\n");
+
+        return 0;
+}
diff --git a/tools/testing/selftests/memfd/memfd_test.c b/tools/testing/selftests/memfd/memfd_test.c
new file mode 100644
index 000000000000..3634c909b1b0
--- /dev/null
+++ b/tools/testing/selftests/memfd/memfd_test.c
@@ -0,0 +1,913 @@
+#define _GNU_SOURCE
+#define __EXPORTED_HEADERS__
+
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <linux/falloc.h>
+#include <linux/fcntl.h>
+#include <linux/memfd.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#define MFD_DEF_SIZE 8192
+#define STACK_SIZE 65535
+
+static int sys_memfd_create(const char *name,
+                            unsigned int flags)
+{
+        return syscall(__NR_memfd_create, name, flags);
+}
+
+static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags)
+{
+        int r, fd;
+
+        fd = sys_memfd_create(name, flags);
+        if (fd < 0) {
+                printf("memfd_create(\"%s\", %u) failed: %m\n",
+                       name, flags);
+                abort();
+        }
+
+        r = ftruncate(fd, sz);
+        if (r < 0) {
+                printf("ftruncate(%llu) failed: %m\n", (unsigned long long)sz);
+                abort();
+        }
+
+        return fd;
+}
+
+static void mfd_fail_new(const char *name, unsigned int flags)
+{
+        int r;
+
+        r = sys_memfd_create(name, flags);
+        if (r >= 0) {
+                printf("memfd_create(\"%s\", %u) succeeded, but failure expected\n",
+                       name, flags);
+                close(r);
+                abort();
+        }
+}
+
+static __u64 mfd_assert_get_seals(int fd)
+{
+        long r;
+
+        r = fcntl(fd, F_GET_SEALS);
+        if (r < 0) {
+                printf("GET_SEALS(%d) failed: %m\n", fd);
+                abort();
+        }
+
+        return r;
+}
+
+static void mfd_assert_has_seals(int fd, __u64 seals)
+{
+        __u64 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);
+                abort();
+        }
+}
+
+static void mfd_assert_add_seals(int fd, __u64 seals)
+{
+        long r;
+        __u64 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);
+                abort();
+        }
+}
+
+static void mfd_fail_add_seals(int fd, __u64 seals)
+{
+        long r;
+        __u64 s;
+
+        r = fcntl(fd, F_GET_SEALS);
+        if (r < 0)
+                s = 0;
+        else
+                s = 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);
+                abort();
+        }
+}
+
+static void mfd_assert_size(int fd, size_t size)
+{
+        struct stat st;
+        int r;
+
+        r = fstat(fd, &st);
+        if (r < 0) {
+                printf("fstat(%d) failed: %m\n", fd);
+                abort();
+        } else if (st.st_size != size) {
+                printf("wrong file size %lld, but expected %lld\n",
+                       (long long)st.st_size, (long long)size);
+                abort();
+        }
+}
+
+static int mfd_assert_dup(int fd)
+{
+        int r;
+
+        r = dup(fd);
+        if (r < 0) {
+                printf("dup(%d) failed: %m\n", fd);
+                abort();
+        }
+
+        return r;
+}
+
+static void *mfd_assert_mmap_shared(int fd)
+{
+        void *p;
+
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+
+        return p;
+}
+
+static void *mfd_assert_mmap_private(int fd)
+{
+        void *p;
+
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ,
+                 MAP_PRIVATE,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+
+        return p;
+}
+
+static int mfd_assert_open(int fd, int flags, mode_t mode)
+{
+        char buf[512];
+        int r;
+
+        sprintf(buf, "/proc/self/fd/%d", fd);
+        r = open(buf, flags, mode);
+        if (r < 0) {
+                printf("open(%s) failed: %m\n", buf);
+                abort();
+        }
+
+        return r;
+}
+
+static void mfd_fail_open(int fd, int flags, mode_t mode)
+{
+        char buf[512];
+        int r;
+
+        sprintf(buf, "/proc/self/fd/%d", fd);
+        r = open(buf, flags, mode);
+        if (r >= 0) {
+                printf("open(%s) didn't fail as expected\n");
+                abort();
+        }
+}
+
+static void mfd_assert_read(int fd)
+{
+        char buf[16];
+        void *p;
+        ssize_t l;
+
+        l = read(fd, buf, sizeof(buf));
+        if (l != sizeof(buf)) {
+                printf("read() failed: %m\n");
+                abort();
+        }
+
+        /* verify PROT_READ *is* allowed */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ,
+                 MAP_PRIVATE,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+        munmap(p, MFD_DEF_SIZE);
+
+        /* verify MAP_PRIVATE is *always* allowed (even writable) */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_PRIVATE,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+        munmap(p, MFD_DEF_SIZE);
+}
+
+static void mfd_assert_write(int fd)
+{
+        ssize_t l;
+        void *p;
+        int r;
+
+        /* verify write() succeeds */
+        l = write(fd, "\0\0\0\0", 4);
+        if (l != 4) {
+                printf("write() failed: %m\n");
+                abort();
+        }
+
+        /* verify PROT_READ | PROT_WRITE is allowed */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+        *(char *)p = 0;
+        munmap(p, MFD_DEF_SIZE);
+
+        /* verify PROT_WRITE is allowed */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_WRITE,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+        *(char *)p = 0;
+        munmap(p, MFD_DEF_SIZE);
+
+        /* verify PROT_READ with MAP_SHARED is allowed and a following
+         * mprotect(PROT_WRITE) allows writing */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p == MAP_FAILED) {
+                printf("mmap() failed: %m\n");
+                abort();
+        }
+
+        r = mprotect(p, MFD_DEF_SIZE, PROT_READ | PROT_WRITE);
+        if (r < 0) {
+                printf("mprotect() failed: %m\n");
+                abort();
+        }
+
+        *(char *)p = 0;
+        munmap(p, MFD_DEF_SIZE);
+
+        /* verify PUNCH_HOLE works */
+        r = fallocate(fd,
+                      FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
+                      0,
+                      MFD_DEF_SIZE);
+        if (r < 0) {
+                printf("fallocate(PUNCH_HOLE) failed: %m\n");
+                abort();
+        }
+}
+
+static void mfd_fail_write(int fd)
+{
+        ssize_t l;
+        void *p;
+        int r;
+
+        /* verify write() fails */
+        l = write(fd, "data", 4);
+        if (l != -EPERM) {
+                printf("expected EPERM on write(), but got %d: %m\n", (int)l);
+                abort();
+        }
+
+        /* verify PROT_READ | PROT_WRITE is not allowed */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ | PROT_WRITE,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p != MAP_FAILED) {
+                printf("mmap() didn't fail as expected\n");
+                abort();
+        }
+
+        /* verify PROT_WRITE is not allowed */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_WRITE,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p != MAP_FAILED) {
+                printf("mmap() didn't fail as expected\n");
+                abort();
+        }
+
+        /* Verify PROT_READ with MAP_SHARED with a following mprotect is not
+         * allowed. Note that for r/w the kernel already prevents the mmap. */
+        p = mmap(NULL,
+                 MFD_DEF_SIZE,
+                 PROT_READ,
+                 MAP_SHARED,
+                 fd,
+                 0);
+        if (p != MAP_FAILED) {
+                r = mprotect(p, MFD_DEF_SIZE, PROT_READ | PROT_WRITE);
+                if (r >= 0) {
+                        printf("mmap()+mprotect() didn't fail as expected\n");
+                        abort();
+                }
+        }
+
+        /* verify PUNCH_HOLE fails */
+        r = fallocate(fd,
+                      FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
+                      0,
+                      MFD_DEF_SIZE);
+        if (r >= 0) {
+                printf("fallocate(PUNCH_HOLE) didn't fail as expected\n");
+                abort();
+        }
+}
+
+static void mfd_assert_shrink(int fd)
+{
+        int r, fd2;
+
+        r = ftruncate(fd, MFD_DEF_SIZE / 2);
+        if (r < 0) {
+                printf("ftruncate(SHRINK) failed: %m\n");
+                abort();
+        }
+
+        mfd_assert_size(fd, MFD_DEF_SIZE / 2);
+
+        fd2 = mfd_assert_open(fd,
+                              O_RDWR | O_CREAT | O_TRUNC,
+                              S_IRUSR | S_IWUSR);
+        close(fd2);
+
+        mfd_assert_size(fd, 0);
+}
+
+static void mfd_fail_shrink(int fd)
+{
+        int r;
+
+        r = ftruncate(fd, MFD_DEF_SIZE / 2);
+        if (r >= 0) {
+                printf("ftruncate(SHRINK) didn't fail as expected\n");
+                abort();
+        }
+
+        mfd_fail_open(fd,
+                      O_RDWR | O_CREAT | O_TRUNC,
+                      S_IRUSR | S_IWUSR);
+}
+
+static void mfd_assert_grow(int fd)
+{
+        int r;
+
+        r = ftruncate(fd, MFD_DEF_SIZE * 2);
+        if (r < 0) {
+                printf("ftruncate(GROW) failed: %m\n");
+                abort();
+        }
+
+        mfd_assert_size(fd, MFD_DEF_SIZE * 2);
+
+        r = fallocate(fd,
+                      0,
+                      0,
+                      MFD_DEF_SIZE * 4);
+        if (r < 0) {
+                printf("fallocate(ALLOC) failed: %m\n");
+                abort();
+        }
+
+        mfd_assert_size(fd, MFD_DEF_SIZE * 4);
+}
+
+static void mfd_fail_grow(int fd)
+{
+        int r;
+
+        r = ftruncate(fd, MFD_DEF_SIZE * 2);
+        if (r >= 0) {
+                printf("ftruncate(GROW) didn't fail as expected\n");
+                abort();
+        }
+
+        r = fallocate(fd,
+                      0,
+                      0,
+                      MFD_DEF_SIZE * 4);
+        if (r >= 0) {
+                printf("fallocate(ALLOC) didn't fail as expected\n");
+                abort();
+        }
+}
+
+static void mfd_assert_grow_write(int fd)
+{
+        static char buf[MFD_DEF_SIZE * 8];
+        ssize_t l;
+
+        l = pwrite(fd, buf, sizeof(buf), 0);
+        if (l != sizeof(buf)) {
+                printf("pwrite() failed: %m\n");
+                abort();
+        }
+
+        mfd_assert_size(fd, MFD_DEF_SIZE * 8);
+}
+
+static void mfd_fail_grow_write(int fd)
+{
+        static char buf[MFD_DEF_SIZE * 8];
+        ssize_t l;
+
+        l = pwrite(fd, buf, sizeof(buf), 0);
+        if (l == sizeof(buf)) {
+                printf("pwrite() didn't fail as expected\n");
+                abort();
+        }
+}
+
+static int idle_thread_fn(void *arg)
+{
+        sigset_t set;
+        int sig;
+
+        /* dummy waiter; SIGTERM terminates us anyway */
+        sigemptyset(&set);
+        sigaddset(&set, SIGTERM);
+        sigwait(&set, &sig);
+
+        return 0;
+}
+
+static pid_t spawn_idle_thread(unsigned int flags)
+{
+        uint8_t *stack;
+        pid_t pid;
+
+        stack = malloc(STACK_SIZE);
+        if (!stack) {
+                printf("malloc(STACK_SIZE) failed: %m\n");
+                abort();
+        }
+
+        pid = clone(idle_thread_fn,
+                    stack + STACK_SIZE,
+                    SIGCHLD | flags,
+                    NULL);
+        if (pid < 0) {
+                printf("clone() failed: %m\n");
+                abort();
+        }
+
+        return pid;
+}
+
+static void join_idle_thread(pid_t pid)
+{
+        kill(pid, SIGTERM);
+        waitpid(pid, NULL, 0);
+}
+
+/*
+ * Test memfd_create() syscall
+ * Verify syscall-argument validation, including name checks, flag validation
+ * and more.
+ */
+static void test_create(void)
+{
+        char buf[2048];
+        int fd;
+
+        /* test NULL name */
+        mfd_fail_new(NULL, 0);
+
+        /* test over-long name (not zero-terminated) */
+        memset(buf, 0xff, sizeof(buf));
+        mfd_fail_new(buf, 0);
+
+        /* test over-long zero-terminated name */
+        memset(buf, 0xff, sizeof(buf));
+        buf[sizeof(buf) - 1] = 0;
+        mfd_fail_new(buf, 0);
+
+        /* verify "" is a valid name */
+        fd = mfd_assert_new("", 0, 0);
+        close(fd);
+
+        /* verify invalid O_* open flags */
+        mfd_fail_new("", 0x0100);
+        mfd_fail_new("", ~MFD_CLOEXEC);
+        mfd_fail_new("", ~MFD_ALLOW_SEALING);
+        mfd_fail_new("", ~0);
+        mfd_fail_new("", 0x80000000U);
+
+        /* verify MFD_CLOEXEC is allowed */
+        fd = mfd_assert_new("", 0, MFD_CLOEXEC);
+        close(fd);
+
+        /* verify MFD_ALLOW_SEALING is allowed */
+        fd = mfd_assert_new("", 0, MFD_ALLOW_SEALING);
+        close(fd);
+
+        /* verify MFD_ALLOW_SEALING | MFD_CLOEXEC is allowed */
+        fd = mfd_assert_new("", 0, MFD_ALLOW_SEALING | MFD_CLOEXEC);
+        close(fd);
+}
+
+/*
+ * Test basic sealing
+ * A very basic sealing test to see whether setting/retrieving seals works.
+ */
+static void test_basic(void)
+{
+        int fd;
+
+        fd = mfd_assert_new("kern_memfd_basic",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+
+        /* add basic seals */
+        mfd_assert_has_seals(fd, 0);
+        mfd_assert_add_seals(fd, F_SEAL_SHRINK |
+                                 F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_SHRINK |
+                                 F_SEAL_WRITE);
+
+        /* add them again */
+        mfd_assert_add_seals(fd, F_SEAL_SHRINK |
+                                 F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_SHRINK |
+                                 F_SEAL_WRITE);
+
+        /* add more seals and seal against sealing */
+        mfd_assert_add_seals(fd, F_SEAL_GROW | F_SEAL_SEAL);
+        mfd_assert_has_seals(fd, F_SEAL_SHRINK |
+                                 F_SEAL_GROW |
+                                 F_SEAL_WRITE |
+                                 F_SEAL_SEAL);
+
+        /* verify that sealing no longer works */
+        mfd_fail_add_seals(fd, F_SEAL_GROW);
+        mfd_fail_add_seals(fd, 0);
+
+        close(fd);
+
+        /* verify sealing does not work without MFD_ALLOW_SEALING */
+        fd = mfd_assert_new("kern_memfd_basic",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC);
+        mfd_assert_has_seals(fd, F_SEAL_SEAL);
+        mfd_fail_add_seals(fd, F_SEAL_SHRINK |
+                               F_SEAL_GROW |
+                               F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_SEAL);
+        close(fd);
+}
+
+/*
+ * Test SEAL_WRITE
+ * Test whether SEAL_WRITE actually prevents modifications.
+ */
+static void test_seal_write(void)
+{
+        int fd;
+
+        fd = mfd_assert_new("kern_memfd_seal_write",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+        mfd_assert_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE);
+
+        mfd_assert_read(fd);
+        mfd_fail_write(fd);
+        mfd_assert_shrink(fd);
+        mfd_assert_grow(fd);
+        mfd_fail_grow_write(fd);
+
+        close(fd);
+}
+
+/*
+ * Test SEAL_SHRINK
+ * Test whether SEAL_SHRINK actually prevents shrinking
+ */
+static void test_seal_shrink(void)
+{
+        int fd;
+
+        fd = mfd_assert_new("kern_memfd_seal_shrink",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+        mfd_assert_add_seals(fd, F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd, F_SEAL_SHRINK);
+
+        mfd_assert_read(fd);
+        mfd_assert_write(fd);
+        mfd_fail_shrink(fd);
+        mfd_assert_grow(fd);
+        mfd_assert_grow_write(fd);
+
+        close(fd);
+}
+
+/*
+ * Test SEAL_GROW
+ * Test whether SEAL_GROW actually prevents growing
+ */
+static void test_seal_grow(void)
+{
+        int fd;
+
+        fd = mfd_assert_new("kern_memfd_seal_grow",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+        mfd_assert_add_seals(fd, F_SEAL_GROW);
+        mfd_assert_has_seals(fd, F_SEAL_GROW);
+
+        mfd_assert_read(fd);
+        mfd_assert_write(fd);
+        mfd_assert_shrink(fd);
+        mfd_fail_grow(fd);
+        mfd_fail_grow_write(fd);
+
+        close(fd);
+}
+
+/*
+ * Test SEAL_SHRINK | SEAL_GROW
+ * Test whether SEAL_SHRINK | SEAL_GROW actually prevents resizing
+ */
+static void test_seal_resize(void)
+{
+        int fd;
+
+        fd = mfd_assert_new("kern_memfd_seal_resize",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+        mfd_assert_add_seals(fd, F_SEAL_SHRINK | F_SEAL_GROW);
+        mfd_assert_has_seals(fd, F_SEAL_SHRINK | F_SEAL_GROW);
+
+        mfd_assert_read(fd);
+        mfd_assert_write(fd);
+        mfd_fail_shrink(fd);
+        mfd_fail_grow(fd);
+        mfd_fail_grow_write(fd);
+
+        close(fd);
+}
+
+/*
+ * Test sharing via dup()
+ * Test that seals are shared between dupped FDs and they're all equal.
+ */
+static void test_share_dup(void)
+{
+        int fd, fd2;
+
+        fd = mfd_assert_new("kern_memfd_share_dup",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+
+        fd2 = mfd_assert_dup(fd);
+        mfd_assert_has_seals(fd2, 0);
+
+        mfd_assert_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE);
+
+        mfd_assert_add_seals(fd2, F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK);
+
+        mfd_assert_add_seals(fd, F_SEAL_SEAL);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL);
+
+        mfd_fail_add_seals(fd, F_SEAL_GROW);
+        mfd_fail_add_seals(fd2, F_SEAL_GROW);
+        mfd_fail_add_seals(fd, F_SEAL_SEAL);
+        mfd_fail_add_seals(fd2, F_SEAL_SEAL);
+
+        close(fd2);
+
+        mfd_fail_add_seals(fd, F_SEAL_GROW);
+        close(fd);
+}
+
+/*
+ * Test sealing with active mmap()s
+ * Modifying seals is only allowed if no other mmap() refs exist.
+ */
+static void test_share_mmap(void)
+{
+        int fd;
+        void *p;
+
+        fd = mfd_assert_new("kern_memfd_share_mmap",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+
+        /* shared/writable ref prevents sealing WRITE, but allows others */
+        p = mfd_assert_mmap_shared(fd);
+        mfd_fail_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, 0);
+        mfd_assert_add_seals(fd, F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd, F_SEAL_SHRINK);
+        munmap(p, MFD_DEF_SIZE);
+
+        /* readable ref allows sealing */
+        p = mfd_assert_mmap_private(fd);
+        mfd_assert_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK);
+        munmap(p, MFD_DEF_SIZE);
+
+        close(fd);
+}
+
+/*
+ * Test sealing with open(/proc/self/fd/%d)
+ * Via /proc we can get access to a separate file-context for the same memfd.
+ * This is *not* like dup(), but like a real separate open(). Make sure the
+ * semantics are as expected and we correctly check for RDONLY / WRONLY / RDWR.
+ */
+static void test_share_open(void)
+{
+        int fd, fd2;
+
+        fd = mfd_assert_new("kern_memfd_share_open",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+
+        fd2 = mfd_assert_open(fd, O_RDWR, 0);
+        mfd_assert_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE);
+
+        mfd_assert_add_seals(fd2, F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK);
+
+        close(fd);
+        fd = mfd_assert_open(fd2, O_RDONLY, 0);
+
+        mfd_fail_add_seals(fd, F_SEAL_SEAL);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK);
+
+        close(fd2);
+        fd2 = mfd_assert_open(fd, O_RDWR, 0);
+
+        mfd_assert_add_seals(fd2, F_SEAL_SEAL);
+        mfd_assert_has_seals(fd, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL);
+        mfd_assert_has_seals(fd2, F_SEAL_WRITE | F_SEAL_SHRINK | F_SEAL_SEAL);
+
+        close(fd2);
+        close(fd);
+}
+
+/*
+ * Test sharing via fork()
+ * Test whether seal-modifications work as expected with forked childs.
+ */
+static void test_share_fork(void)
+{
+        int fd;
+        pid_t pid;
+
+        fd = mfd_assert_new("kern_memfd_share_fork",
+                            MFD_DEF_SIZE,
+                            MFD_CLOEXEC | MFD_ALLOW_SEALING);
+        mfd_assert_has_seals(fd, 0);
+
+        pid = spawn_idle_thread(0);
+        mfd_assert_add_seals(fd, F_SEAL_SEAL);
+        mfd_assert_has_seals(fd, F_SEAL_SEAL);
+
+        mfd_fail_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_SEAL);
+
+        join_idle_thread(pid);
+
+        mfd_fail_add_seals(fd, F_SEAL_WRITE);
+        mfd_assert_has_seals(fd, F_SEAL_SEAL);
+
+        close(fd);
+}
+
+int main(int argc, char **argv)
+{
+        pid_t pid;
+
+        printf("memfd: CREATE\n");
+        test_create();
+        printf("memfd: BASIC\n");
+        test_basic();
+
+        printf("memfd: SEAL-WRITE\n");
+        test_seal_write();
+        printf("memfd: SEAL-SHRINK\n");
+        test_seal_shrink();
+        printf("memfd: SEAL-GROW\n");
+        test_seal_grow();
+        printf("memfd: SEAL-RESIZE\n");
+        test_seal_resize();
+
+        printf("memfd: SHARE-DUP\n");
+        test_share_dup();
+        printf("memfd: SHARE-MMAP\n");
+        test_share_mmap();
+        printf("memfd: SHARE-OPEN\n");
+        test_share_open();
+        printf("memfd: SHARE-FORK\n");
+        test_share_fork();
+
+        /* Run test-suite in a multi-threaded environment with a shared
+         * file-table. */
+        pid = spawn_idle_thread(CLONE_FILES | CLONE_FS | CLONE_VM);
+        printf("memfd: SHARE-DUP (shared file-table)\n");
+        test_share_dup();
+        printf("memfd: SHARE-MMAP (shared file-table)\n");
+        test_share_mmap();
+        printf("memfd: SHARE-OPEN (shared file-table)\n");
+        test_share_open();
+        printf("memfd: SHARE-FORK (shared file-table)\n");
+        test_share_fork();
+        join_idle_thread(pid);
+
+        printf("memfd: DONE\n");
+
+        return 0;
+}
diff --git a/tools/testing/selftests/memfd/run_fuse_test.sh b/tools/testing/selftests/memfd/run_fuse_test.sh
new file mode 100644
index 000000000000..69b930e1e041
--- /dev/null
+++ b/tools/testing/selftests/memfd/run_fuse_test.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+if test -d "./mnt" ; then
+        fusermount -u ./mnt
+        rmdir ./mnt
+fi
+
+set -e
+
+mkdir mnt
+./fuse_mnt ./mnt
+./fuse_test ./mnt/memfd
+fusermount -u ./mnt
+rmdir ./mnt
diff --git a/tools/testing/selftests/memory-hotplug/Makefile b/tools/testing/selftests/memory-hotplug/Makefile
index 058c76f5d102..d46b8d489cd2 100644
--- a/tools/testing/selftests/memory-hotplug/Makefile
+++ b/tools/testing/selftests/memory-hotplug/Makefile
@@ -1,6 +1,9 @@
 all:
 
 run_tests:
+        @/bin/bash ./on-off-test.sh -r 2 || echo "memory-hotplug selftests: [FAIL]"
+
+run_full_test:
         @/bin/bash ./on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
 
 clean:
diff --git a/tools/testing/selftests/memory-hotplug/on-off-test.sh b/tools/testing/selftests/memory-hotplug/on-off-test.sh
index a2816f631542..6cddde0b96f8 100644
--- a/tools/testing/selftests/memory-hotplug/on-off-test.sh
+++ b/tools/testing/selftests/memory-hotplug/on-off-test.sh
@@ -142,10 +142,16 @@ fi
 
 prerequisite
 
+echo "Test scope: $ratio% hotplug memory"
+echo -e "\t online all hotplug memory in offline state"
+echo -e "\t offline $ratio% hotplug memory in online state"
+echo -e "\t online all hotplug memory in offline state"
+
 #
 # Online all hot-pluggable memory
 #
 for memory in `hotplaggable_offline_memory`; do
+        echo offline-online $memory
         online_memory_expect_success $memory
 done
 
@@ -154,6 +160,7 @@ done
 #
 for memory in `hotpluggable_online_memory`; do
         if [ $((RANDOM % 100)) -lt $ratio ]; then
+                echo online-offline $memory
                 offline_memory_expect_success $memory
         fi
 done
@@ -162,6 +169,7 @@ done
 # Online all hot-pluggable memory again
 #
 for memory in `hotplaggable_offline_memory`; do
+        echo offline-online $memory
         online_memory_expect_success $memory
 done
 
diff --git a/tools/testing/selftests/mount/Makefile b/tools/testing/selftests/mount/Makefile
new file mode 100644
index 000000000000..337d853c2b72
--- /dev/null
+++ b/tools/testing/selftests/mount/Makefile
@@ -0,0 +1,17 @@
+# Makefile for mount selftests.
+
+all: unprivileged-remount-test
+
+unprivileged-remount-test: unprivileged-remount-test.c
+        gcc -Wall -O2 unprivileged-remount-test.c -o unprivileged-remount-test
+
+# Allow specific tests to be selected.
+test_unprivileged_remount: unprivileged-remount-test
+        @if [ -f /proc/self/uid_map ] ; then ./unprivileged-remount-test ; fi
+
+run_tests: all test_unprivileged_remount
+
+clean:
+        rm -f unprivileged-remount-test
+
+.PHONY: all test_unprivileged_remount
diff --git a/tools/testing/selftests/mount/unprivileged-remount-test.c b/tools/testing/selftests/mount/unprivileged-remount-test.c
new file mode 100644
index 000000000000..1b3ff2fda4d0
--- /dev/null
+++ b/tools/testing/selftests/mount/unprivileged-remount-test.c
@@ -0,0 +1,242 @@
+#define _GNU_SOURCE
+#include <sched.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/mount.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <grp.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+#ifndef CLONE_NEWNS
+# define CLONE_NEWNS 0x00020000
+#endif
+#ifndef CLONE_NEWUTS
+# define CLONE_NEWUTS 0x04000000
+#endif
+#ifndef CLONE_NEWIPC
+# define CLONE_NEWIPC 0x08000000
+#endif
+#ifndef CLONE_NEWNET
+# define CLONE_NEWNET 0x40000000
+#endif
+#ifndef CLONE_NEWUSER
+# define CLONE_NEWUSER 0x10000000
+#endif
+#ifndef CLONE_NEWPID
+# define CLONE_NEWPID 0x20000000
+#endif
+
+#ifndef MS_RELATIME
+#define MS_RELATIME (1 << 21)
+#endif
+#ifndef MS_STRICTATIME
+#define MS_STRICTATIME (1 << 24)
+#endif
+
+static void die(char *fmt, ...)
+{
+        va_list ap;
+        va_start(ap, fmt);
+        vfprintf(stderr, fmt, ap);
+        va_end(ap);
+        exit(EXIT_FAILURE);
+}
+
+static void write_file(char *filename, char *fmt, ...)
+{
+        char buf[4096];
+        int fd;
+        ssize_t written;
+        int buf_len;
+        va_list ap;
+
+        va_start(ap, fmt);
+        buf_len = vsnprintf(buf, sizeof(buf), fmt, ap);
+        va_end(ap);
+        if (buf_len < 0) {
+                die("vsnprintf failed: %s\n",
+                    strerror(errno));
+        }
+        if (buf_len >= sizeof(buf)) {
+                die("vsnprintf output truncated\n");
+        }
+
+        fd = open(filename, O_WRONLY);
+        if (fd < 0) {
+                die("open of %s failed: %s\n",
+                    filename, strerror(errno));
+        }
+        written = write(fd, buf, buf_len);
+        if (written != buf_len) {
+                if (written >= 0) {
+                        die("short write to %s\n", filename);
+                } else {
+                        die("write to %s failed: %s\n",
+                                filename, strerror(errno));
+                }
+        }
+        if (close(fd) != 0) {
+                die("close of %s failed: %s\n",
+                        filename, strerror(errno));
+        }
+}
+
+static void create_and_enter_userns(void)
+{
+        uid_t uid;
+        gid_t gid;
+
+        uid = getuid();
+        gid = getgid();
+
+        if (unshare(CLONE_NEWUSER) !=0) {
+                die("unshare(CLONE_NEWUSER) failed: %s\n",
+                        strerror(errno));
+        }
+
+        write_file("/proc/self/uid_map", "0 %d 1", uid);
+        write_file("/proc/self/gid_map", "0 %d 1", gid);
+
+        if (setgroups(0, NULL) != 0) {
+                die("setgroups failed: %s\n",
+                        strerror(errno));
+        }
+        if (setgid(0) != 0) {
+                die ("setgid(0) failed %s\n",
+                        strerror(errno));
+        }
+        if (setuid(0) != 0) {
+                die("setuid(0) failed %s\n",
+                        strerror(errno));
+        }
+}
+
+static
+bool test_unpriv_remount(int mount_flags, int remount_flags, int invalid_flags)
+{
+        pid_t child;
+
+        child = fork();
+        if (child == -1) {
+                die("fork failed: %s\n",
+                        strerror(errno));
+        }
+        if (child != 0) { /* parent */
+                pid_t pid;
+                int status;
+                pid = waitpid(child, &status, 0);
+                if (pid == -1) {
+                        die("waitpid failed: %s\n",
+                                strerror(errno));
+                }
+                if (pid != child) {
+                        die("waited for %d got %d\n",
+                                child, pid);
+                }
+                if (!WIFEXITED(status)) {
+                        die("child did not terminate cleanly\n");
+                }
+                return WEXITSTATUS(status) == EXIT_SUCCESS ? true : false;
+        }
+
+        create_and_enter_userns();
+        if (unshare(CLONE_NEWNS) != 0) {
+                die("unshare(CLONE_NEWNS) failed: %s\n",
+                        strerror(errno));
+        }
+
+        if (mount("testing", "/tmp", "ramfs", mount_flags, NULL) != 0) {
+                die("mount of /tmp failed: %s\n",
+                        strerror(errno));
+        }
+
+        create_and_enter_userns();
+
+        if (unshare(CLONE_NEWNS) != 0) {
+                die("unshare(CLONE_NEWNS) failed: %s\n",
+                        strerror(errno));
+        }
+
+        if (mount("/tmp", "/tmp", "none",
+                  MS_REMOUNT | MS_BIND | remount_flags, NULL) != 0) {
+                /* system("cat /proc/self/mounts"); */
+                die("remount of /tmp failed: %s\n",
+                    strerror(errno));
+        }
+
+        if (mount("/tmp", "/tmp", "none",
+                  MS_REMOUNT | MS_BIND | invalid_flags, NULL) == 0) {
+                /* system("cat /proc/self/mounts"); */
+                die("remount of /tmp with invalid flags "
+                    "succeeded unexpectedly\n");
+        }
+        exit(EXIT_SUCCESS);
+}
+
+static bool test_unpriv_remount_simple(int mount_flags)
+{
+        return test_unpriv_remount(mount_flags, mount_flags, 0);
+}
+
+static bool test_unpriv_remount_atime(int mount_flags, int invalid_flags)
+{
+        return test_unpriv_remount(mount_flags, mount_flags, invalid_flags);
+}
+
+int main(int argc, char **argv)
+{
+        if (!test_unpriv_remount_simple(MS_RDONLY|MS_NODEV)) {
+                die("MS_RDONLY malfunctions\n");
+        }
+        if (!test_unpriv_remount_simple(MS_NODEV)) {
+                die("MS_NODEV malfunctions\n");
+        }
+        if (!test_unpriv_remount_simple(MS_NOSUID|MS_NODEV)) {
+                die("MS_NOSUID malfunctions\n");
+        }
+        if (!test_unpriv_remount_simple(MS_NOEXEC|MS_NODEV)) {
+                die("MS_NOEXEC malfunctions\n");
+        }
+        if (!test_unpriv_remount_atime(MS_RELATIME|MS_NODEV,
+                                       MS_NOATIME|MS_NODEV))
+        {
+                die("MS_RELATIME malfunctions\n");
+        }
+        if (!test_unpriv_remount_atime(MS_STRICTATIME|MS_NODEV,
+                                       MS_NOATIME|MS_NODEV))
+        {
+                die("MS_STRICTATIME malfunctions\n");
+        }
+        if (!test_unpriv_remount_atime(MS_NOATIME|MS_NODEV,
+                                       MS_STRICTATIME|MS_NODEV))
+        {
+                die("MS_RELATIME malfunctions\n");
+        }
+        if (!test_unpriv_remount_atime(MS_RELATIME|MS_NODIRATIME|MS_NODEV,
+                                       MS_NOATIME|MS_NODEV))
+        {
+                die("MS_RELATIME malfunctions\n");
+        }
+        if (!test_unpriv_remount_atime(MS_STRICTATIME|MS_NODIRATIME|MS_NODEV,
+                                       MS_NOATIME|MS_NODEV))
+        {
+                die("MS_RELATIME malfunctions\n");
+        }
+        if (!test_unpriv_remount_atime(MS_NOATIME|MS_NODIRATIME|MS_NODEV,
+                                       MS_STRICTATIME|MS_NODEV))
+        {
+                die("MS_RELATIME malfunctions\n");
+        }
+        if (!test_unpriv_remount(MS_STRICTATIME|MS_NODEV, MS_NODEV,
+                                 MS_NOATIME|MS_NODEV))
+        {
+                die("Default atime malfunctions\n");
+        }
+        return EXIT_SUCCESS;
+}
diff --git a/tools/testing/selftests/mqueue/Makefile b/tools/testing/selftests/mqueue/Makefile
index 218a122c7951..8056e2e68fa4 100644
--- a/tools/testing/selftests/mqueue/Makefile
+++ b/tools/testing/selftests/mqueue/Makefile
@@ -1,6 +1,6 @@
 all:
-        gcc -O2 -lrt mq_open_tests.c -o mq_open_tests
-        gcc -O2 -lrt -lpthread -lpopt -o mq_perf_tests mq_perf_tests.c
+        gcc -O2 mq_open_tests.c -o mq_open_tests -lrt
+        gcc -O2 -o mq_perf_tests mq_perf_tests.c -lrt -lpthread -lpopt
 
 run_tests:
         @./mq_open_tests /test1 || echo "mq_open_tests: [FAIL]"
diff --git a/tools/testing/selftests/mqueue/mq_open_tests.c b/tools/testing/selftests/mqueue/mq_open_tests.c
index 711cc2923047..9c1a5d359055 100644
--- a/tools/testing/selftests/mqueue/mq_open_tests.c
+++ b/tools/testing/selftests/mqueue/mq_open_tests.c
@@ -80,7 +80,8 @@ void shutdown(int exit_val, char *err_cause, int line_no)
         if (in_shutdown++)
                 return;
 
-        seteuid(0);
+        if (seteuid(0) == -1)
+                perror("seteuid() failed");
 
         if (queue != -1)
                 if (mq_close(queue))
@@ -292,8 +293,10 @@ int main(int argc, char *argv[])
         /* Tell the user our initial state */
         printf("\nInitial system state:\n");
         printf("\tUsing queue path:\t\t%s\n", queue_path);
-        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", saved_limits.rlim_cur);
-        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", saved_limits.rlim_max);
+        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n",
+                (long) saved_limits.rlim_cur);
+        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n",
+                (long) saved_limits.rlim_max);
         printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
         printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
         if (default_settings) {
@@ -308,8 +311,8 @@ int main(int argc, char *argv[])
         validate_current_settings();
 
         printf("Adjusted system state for testing:\n");
-        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", cur_limits.rlim_cur);
-        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", cur_limits.rlim_max);
+        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n", (long) cur_limits.rlim_cur);
+        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n", (long) cur_limits.rlim_max);
         printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
         printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
         if (default_settings) {
@@ -454,7 +457,12 @@ int main(int argc, char *argv[])
         else
                 printf("Queue open with total size > 2GB when euid = 0 "
                        "failed:\t\t\tPASS\n");
-        seteuid(99);
+
+        if (seteuid(99) == -1) {
+                perror("seteuid() failed");
+                exit(1);
+        }
+
         attr.mq_maxmsg = cur_max_msgs;
         attr.mq_msgsize = cur_max_msgsize;
         if (test_queue_fail(&attr, &result))
diff --git a/tools/testing/selftests/mqueue/mq_perf_tests.c b/tools/testing/selftests/mqueue/mq_perf_tests.c
index 2fadd4b97045..94dae65eea41 100644
--- a/tools/testing/selftests/mqueue/mq_perf_tests.c
+++ b/tools/testing/selftests/mqueue/mq_perf_tests.c
@@ -296,9 +296,9 @@ static inline void open_queue(struct mq_attr *attr)
         printf("\n\tQueue %s created:\n", queue_path);
         printf("\t\tmq_flags:\t\t\t%s\n", result.mq_flags & O_NONBLOCK ?
                "O_NONBLOCK" : "(null)");
-        printf("\t\tmq_maxmsg:\t\t\t%d\n", result.mq_maxmsg);
-        printf("\t\tmq_msgsize:\t\t\t%d\n", result.mq_msgsize);
-        printf("\t\tmq_curmsgs:\t\t\t%d\n", result.mq_curmsgs);
+        printf("\t\tmq_maxmsg:\t\t\t%lu\n", result.mq_maxmsg);
+        printf("\t\tmq_msgsize:\t\t\t%lu\n", result.mq_msgsize);
+        printf("\t\tmq_curmsgs:\t\t\t%lu\n", result.mq_curmsgs);
 }
 
 void *fake_cont_thread(void *arg)
@@ -440,7 +440,7 @@ void *perf_test_thread(void *arg)
                 shutdown(2, "clock_getres()", __LINE__);
 
         printf("\t\tMax priorities:\t\t\t%d\n", mq_prio_max);
-        printf("\t\tClock resolution:\t\t%d nsec%s\n", res.tv_nsec,
+        printf("\t\tClock resolution:\t\t%lu nsec%s\n", res.tv_nsec,
                res.tv_nsec > 1 ? "s" : "");
 
 
@@ -454,20 +454,20 @@ void *perf_test_thread(void *arg)
         recv_total.tv_nsec = 0;
         for (i = 0; i < TEST1_LOOPS; i++)
                 do_send_recv();
-        printf("\t\tSend msg:\t\t\t%d.%ds total time\n",
+        printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
                send_total.tv_sec, send_total.tv_nsec);
         nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
                  send_total.tv_nsec) / TEST1_LOOPS;
-        printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
-        printf("\t\tRecv msg:\t\t\t%d.%ds total time\n",
+        printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
+        printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
                recv_total.tv_sec, recv_total.tv_nsec);
         nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
                 recv_total.tv_nsec) / TEST1_LOOPS;
-        printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
+        printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
 
 
         for (cur_test = test2; cur_test->desc != NULL; cur_test++) {
-                printf(cur_test->desc);
+                printf("%s:\n", cur_test->desc);
                 printf("\t\t(%d iterations)\n", TEST2_LOOPS);
                 prio_out = 0;
                 send_total.tv_sec = 0;
@@ -493,16 +493,16 @@ void *perf_test_thread(void *arg)
                         cur_test->func(&prio_out);
                 }
                 printf("done.\n");
-                printf("\t\tSend msg:\t\t\t%d.%ds total time\n",
+                printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
                        send_total.tv_sec, send_total.tv_nsec);
                 nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
                          send_total.tv_nsec) / TEST2_LOOPS;
-                printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
-                printf("\t\tRecv msg:\t\t\t%d.%ds total time\n",
+                printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
+                printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
                        recv_total.tv_sec, recv_total.tv_nsec);
                 nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
                         recv_total.tv_nsec) / TEST2_LOOPS;
-                printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
+                printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
                 printf("\t\tDraining queue...");
                 fflush(stdout);
                 clock_gettime(clock, &start);
@@ -653,8 +653,10 @@ int main(int argc, char *argv[])
         /* Tell the user our initial state */
         printf("\nInitial system state:\n");
         printf("\tUsing queue path:\t\t\t%s\n", queue_path);
-        printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%d\n", saved_limits.rlim_cur);
-        printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%d\n", saved_limits.rlim_max);
+        printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
+                (long) saved_limits.rlim_cur);
+        printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
+                (long) saved_limits.rlim_max);
         printf("\tMaximum Message Size:\t\t\t%d\n", saved_max_msgsize);
         printf("\tMaximum Queue Size:\t\t\t%d\n", saved_max_msgs);
         printf("\tNice value:\t\t\t\t%d\n", cur_nice);
@@ -667,10 +669,10 @@ int main(int argc, char *argv[])
                 printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t(unlimited)\n");
                 printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t(unlimited)\n");
         } else {
-                printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%d\n",
-                       cur_limits.rlim_cur);
-                printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%d\n",
-                       cur_limits.rlim_max);
+                printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
+                       (long) cur_limits.rlim_cur);
+                printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
+                       (long) cur_limits.rlim_max);
         }
         printf("\tMaximum Message Size:\t\t\t%d\n", cur_max_msgsize);
         printf("\tMaximum Queue Size:\t\t\t%d\n", cur_max_msgs);
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index 54833a791a44..74a78cedce37 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -17,10 +17,10 @@ TARGETS = pmu copyloops mm tm
 
 endif
 
-all:
-        @for TARGET in $(TARGETS); do \
-                $(MAKE) -C $$TARGET all; \
-        done;
+all: $(TARGETS)
+
+$(TARGETS):
+        $(MAKE) -k -C $@ all
 
 run_tests: all
         @for TARGET in $(TARGETS); do \
@@ -36,4 +36,4 @@ clean:
 tags:
         find . -name '*.c' -o -name '*.h' | xargs ctags
 
-.PHONY: all run_tests clean tags
+.PHONY: all run_tests clean tags $(TARGETS)
diff --git a/tools/testing/selftests/powerpc/pmu/Makefile b/tools/testing/selftests/powerpc/pmu/Makefile
index b9ff0db42c79..c9f4263906a5 100644
--- a/tools/testing/selftests/powerpc/pmu/Makefile
+++ b/tools/testing/selftests/powerpc/pmu/Makefile
@@ -1,10 +1,12 @@
 noarg:
         $(MAKE) -C ../
 
-PROGS := count_instructions
-EXTRA_SOURCES := ../harness.c event.c
+PROGS := count_instructions l3_bank_test per_event_excludes
+EXTRA_SOURCES := ../harness.c event.c lib.c
 
-all: $(PROGS) sub_all
+SUB_TARGETS = ebb
+
+all: $(PROGS) $(SUB_TARGETS)
 
 $(PROGS): $(EXTRA_SOURCES)
 
@@ -20,13 +22,8 @@ run_tests: all sub_run_tests
 clean: sub_clean
         rm -f $(PROGS) loop.o
 
-
-SUB_TARGETS = ebb
-
-sub_all:
-        @for TARGET in $(SUB_TARGETS); do \
-                $(MAKE) -C $$TARGET all; \
-        done;
+$(SUB_TARGETS):
+        $(MAKE) -k -C $@ all
 
 sub_run_tests: all
         @for TARGET in $(SUB_TARGETS); do \
@@ -38,4 +35,4 @@ sub_clean:
                 $(MAKE) -C $$TARGET clean; \
         done;
 
-.PHONY: all run_tests clean sub_all sub_run_tests sub_clean
+.PHONY: all run_tests clean sub_run_tests sub_clean $(SUB_TARGETS)
diff --git a/tools/testing/selftests/powerpc/pmu/count_instructions.c b/tools/testing/selftests/powerpc/pmu/count_instructions.c
index 312b4f0fd27c..4622117b24c0 100644
--- a/tools/testing/selftests/powerpc/pmu/count_instructions.c
+++ b/tools/testing/selftests/powerpc/pmu/count_instructions.c
@@ -12,6 +12,7 @@
 
 #include "event.h"
 #include "utils.h"
+#include "lib.h"
 
 extern void thirty_two_instruction_loop(u64 loops);
 
@@ -90,7 +91,7 @@ static u64 determine_overhead(struct event *events)
         return overhead;
 }
 
-static int count_instructions(void)
+static int test_body(void)
 {
         struct event events[2];
         u64 overhead;
@@ -111,17 +112,23 @@ static int count_instructions(void)
         overhead = determine_overhead(events);
         printf("Overhead of null loop: %llu instructions\n", overhead);
 
-        /* Run for 1M instructions */
-        FAIL_IF(do_count_loop(events, 0x100000, overhead, true));
+        /* Run for 1Mi instructions */
+        FAIL_IF(do_count_loop(events, 1000000, overhead, true));
+
+        /* Run for 10Mi instructions */
+        FAIL_IF(do_count_loop(events, 10000000, overhead, true));
+
+        /* Run for 100Mi instructions */
+        FAIL_IF(do_count_loop(events, 100000000, overhead, true));
 
-        /* Run for 10M instructions */
-        FAIL_IF(do_count_loop(events, 0xa00000, overhead, true));
+        /* Run for 1Bi instructions */
+        FAIL_IF(do_count_loop(events, 1000000000, overhead, true));
 
-        /* Run for 100M instructions */
-        FAIL_IF(do_count_loop(events, 0x6400000, overhead, true));
+        /* Run for 16Bi instructions */
+        FAIL_IF(do_count_loop(events, 16000000000, overhead, true));
 
-        /* Run for 1G instructions */
-        FAIL_IF(do_count_loop(events, 0x40000000, overhead, true));
+        /* Run for 64Bi instructions */
+        FAIL_IF(do_count_loop(events, 64000000000, overhead, true));
 
         event_close(&events[0]);
         event_close(&events[1]);
@@ -129,6 +136,11 @@ static int count_instructions(void)
         return 0;
 }
 
+static int count_instructions(void)
+{
+        return eat_cpu(test_body);
+}
+
 int main(void)
 {
         return test_harness(count_instructions, "count_instructions");
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/Makefile b/tools/testing/selftests/powerpc/pmu/ebb/Makefile
index edbba2affc2c..3dc4332698cb 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/Makefile
+++ b/tools/testing/selftests/powerpc/pmu/ebb/Makefile
@@ -13,11 +13,12 @@ PROGS := reg_access_test event_attributes_test cycles_test	\
          close_clears_pmcc_test instruction_count_test          \
          fork_cleanup_test ebb_on_child_test                    \
          ebb_on_willing_child_test back_to_back_ebbs_test       \
-         lost_exception_test no_handler_test
+         lost_exception_test no_handler_test                    \
+         cycles_with_mmcr2_test
 
 all: $(PROGS)
 
-$(PROGS): ../../harness.c ../event.c ../lib.c ebb.c ebb_handler.S trace.c
+$(PROGS): ../../harness.c ../event.c ../lib.c ebb.c ebb_handler.S trace.c busy_loop.S
 
 instruction_count_test: ../loop.S
 
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/busy_loop.S b/tools/testing/selftests/powerpc/pmu/ebb/busy_loop.S
new file mode 100644
index 000000000000..c7e4093f1cd3
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/ebb/busy_loop.S
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2014, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <ppc-asm.h>
+
+        .text
+
+FUNC_START(core_busy_loop)
+        stdu    %r1, -168(%r1)
+        std     r14, 160(%r1)
+        std     r15, 152(%r1)
+        std     r16, 144(%r1)
+        std     r17, 136(%r1)
+        std     r18, 128(%r1)
+        std     r19, 120(%r1)
+        std     r20, 112(%r1)
+        std     r21, 104(%r1)
+        std     r22, 96(%r1)
+        std     r23, 88(%r1)
+        std     r24, 80(%r1)
+        std     r25, 72(%r1)
+        std     r26, 64(%r1)
+        std     r27, 56(%r1)
+        std     r28, 48(%r1)
+        std     r29, 40(%r1)
+        std     r30, 32(%r1)
+        std     r31, 24(%r1)
+
+        li       r3, 0x3030
+        std      r3, -96(%r1)
+        li       r4, 0x4040
+        std      r4, -104(%r1)
+        li       r5, 0x5050
+        std      r5, -112(%r1)
+        li       r6, 0x6060
+        std      r6, -120(%r1)
+        li       r7, 0x7070
+        std      r7, -128(%r1)
+        li       r8, 0x0808
+        std      r8, -136(%r1)
+        li       r9, 0x0909
+        std      r9, -144(%r1)
+        li      r10, 0x1010
+        std     r10, -152(%r1)
+        li      r11, 0x1111
+        std     r11, -160(%r1)
+        li      r14, 0x1414
+        std     r14, -168(%r1)
+        li      r15, 0x1515
+        std     r15, -176(%r1)
+        li      r16, 0x1616
+        std     r16, -184(%r1)
+        li      r17, 0x1717
+        std     r17, -192(%r1)
+        li      r18, 0x1818
+        std     r18, -200(%r1)
+        li      r19, 0x1919
+        std     r19, -208(%r1)
+        li      r20, 0x2020
+        std     r20, -216(%r1)
+        li      r21, 0x2121
+        std     r21, -224(%r1)
+        li      r22, 0x2222
+        std     r22, -232(%r1)
+        li      r23, 0x2323
+        std     r23, -240(%r1)
+        li      r24, 0x2424
+        std     r24, -248(%r1)
+        li      r25, 0x2525
+        std     r25, -256(%r1)
+        li      r26, 0x2626
+        std     r26, -264(%r1)
+        li      r27, 0x2727
+        std     r27, -272(%r1)
+        li      r28, 0x2828
+        std     r28, -280(%r1)
+        li      r29, 0x2929
+        std     r29, -288(%r1)
+        li      r30, 0x3030
+        li      r31, 0x3131
+
+        li      r3, 0
+0:      addi    r3, r3, 1
+        cmpwi   r3, 100
+        blt     0b
+
+        /* Return 1 (fail) unless we get through all the checks */
+        li      r3, 1
+
+        /* Check none of our registers have been corrupted */
+        cmpwi   r4,  0x4040
+        bne     1f
+        cmpwi   r5,  0x5050
+        bne     1f
+        cmpwi   r6,  0x6060
+        bne     1f
+        cmpwi   r7,  0x7070
+        bne     1f
+        cmpwi   r8,  0x0808
+        bne     1f
+        cmpwi   r9,  0x0909
+        bne     1f
+        cmpwi   r10, 0x1010
+        bne     1f
+        cmpwi   r11, 0x1111
+        bne     1f
+        cmpwi   r14, 0x1414
+        bne     1f
+        cmpwi   r15, 0x1515
+        bne     1f
+        cmpwi   r16, 0x1616
+        bne     1f
+        cmpwi   r17, 0x1717
+        bne     1f
+        cmpwi   r18, 0x1818
+        bne     1f
+        cmpwi   r19, 0x1919
+        bne     1f
+        cmpwi   r20, 0x2020
+        bne     1f
+        cmpwi   r21, 0x2121
+        bne     1f
+        cmpwi   r22, 0x2222
+        bne     1f
+        cmpwi   r23, 0x2323
+        bne     1f
+        cmpwi   r24, 0x2424
+        bne     1f
+        cmpwi   r25, 0x2525
+        bne     1f
+        cmpwi   r26, 0x2626
+        bne     1f
+        cmpwi   r27, 0x2727
+        bne     1f
+        cmpwi   r28, 0x2828
+        bne     1f
+        cmpwi   r29, 0x2929
+        bne     1f
+        cmpwi   r30, 0x3030
+        bne     1f
+        cmpwi   r31, 0x3131
+        bne     1f
+
+        /* Load junk into all our registers before we reload them from the stack. */
+        li      r3,  0xde
+        li      r4,  0xad
+        li      r5,  0xbe
+        li      r6,  0xef
+        li      r7,  0xde
+        li      r8,  0xad
+        li      r9,  0xbe
+        li      r10, 0xef
+        li      r11, 0xde
+        li      r14, 0xad
+        li      r15, 0xbe
+        li      r16, 0xef
+        li      r17, 0xde
+        li      r18, 0xad
+        li      r19, 0xbe
+        li      r20, 0xef
+        li      r21, 0xde
+        li      r22, 0xad
+        li      r23, 0xbe
+        li      r24, 0xef
+        li      r25, 0xde
+        li      r26, 0xad
+        li      r27, 0xbe
+        li      r28, 0xef
+        li      r29, 0xdd
+
+        ld      r3,     -96(%r1)
+        cmpwi   r3,  0x3030
+        bne     1f
+        ld      r4,     -104(%r1)
+        cmpwi   r4,  0x4040
+        bne     1f
+        ld      r5,     -112(%r1)
+        cmpwi   r5,  0x5050
+        bne     1f
+        ld      r6,     -120(%r1)
+        cmpwi   r6,  0x6060
+        bne     1f
+        ld      r7,     -128(%r1)
+        cmpwi   r7,  0x7070
+        bne     1f
+        ld      r8,     -136(%r1)
+        cmpwi   r8,  0x0808
+        bne     1f
+        ld      r9,     -144(%r1)
+        cmpwi   r9,  0x0909
+        bne     1f
+        ld      r10, -152(%r1)
+        cmpwi   r10, 0x1010
+        bne     1f
+        ld      r11, -160(%r1)
+        cmpwi   r11, 0x1111
+        bne     1f
+        ld      r14, -168(%r1)
+        cmpwi   r14, 0x1414
+        bne     1f
+        ld      r15, -176(%r1)
+        cmpwi   r15, 0x1515
+        bne     1f
+        ld      r16, -184(%r1)
+        cmpwi   r16, 0x1616
+        bne     1f
+        ld      r17, -192(%r1)
+        cmpwi   r17, 0x1717
+        bne     1f
+        ld      r18, -200(%r1)
+        cmpwi   r18, 0x1818
+        bne     1f
+        ld      r19, -208(%r1)
+        cmpwi   r19, 0x1919
+        bne     1f
+        ld      r20, -216(%r1)
+        cmpwi   r20, 0x2020
+        bne     1f
+        ld      r21, -224(%r1)
+        cmpwi   r21, 0x2121
+        bne     1f
+        ld      r22, -232(%r1)
+        cmpwi   r22, 0x2222
+        bne     1f
+        ld      r23, -240(%r1)
+        cmpwi   r23, 0x2323
+        bne     1f
+        ld      r24, -248(%r1)
+        cmpwi   r24, 0x2424
+        bne     1f
+        ld      r25, -256(%r1)
+        cmpwi   r25, 0x2525
+        bne     1f
+        ld      r26, -264(%r1)
+        cmpwi   r26, 0x2626
+        bne     1f
+        ld      r27, -272(%r1)
+        cmpwi   r27, 0x2727
+        bne     1f
+        ld      r28, -280(%r1)
+        cmpwi   r28, 0x2828
+        bne     1f
+        ld      r29, -288(%r1)
+        cmpwi   r29, 0x2929
+        bne     1f
+
+        /* Load 0 (success) to return */
+        li      r3, 0
+
+1:      ld      r14, 160(%r1)
+        ld      r15, 152(%r1)
+        ld      r16, 144(%r1)
+        ld      r17, 136(%r1)
+        ld      r18, 128(%r1)
+        ld      r19, 120(%r1)
+        ld      r20, 112(%r1)
+        ld      r21, 104(%r1)
+        ld      r22, 96(%r1)
+        ld      r23, 88(%r1)
+        ld      r24, 80(%r1)
+        ld      r25, 72(%r1)
+        ld      r26, 64(%r1)
+        ld      r27, 56(%r1)
+        ld      r28, 48(%r1)
+        ld      r29, 40(%r1)
+        ld      r30, 32(%r1)
+        ld      r31, 24(%r1)
+        addi    %r1, %r1, 168
+        blr
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/cycles_with_mmcr2_test.c b/tools/testing/selftests/powerpc/pmu/ebb/cycles_with_mmcr2_test.c
new file mode 100644
index 000000000000..d43029b0800c
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/ebb/cycles_with_mmcr2_test.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2014, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "ebb.h"
+
+
+/*
+ * Test of counting cycles while manipulating the user accessible bits in MMCR2.
+ */
+
+/* We use two values because the first freezes PMC1 and so we would get no EBBs */
+#define MMCR2_EXPECTED_1 0x4020100804020000UL /* (FC1P|FC2P|FC3P|FC4P|FC5P|FC6P) */
+#define MMCR2_EXPECTED_2 0x0020100804020000UL /* (     FC2P|FC3P|FC4P|FC5P|FC6P) */
+
+
+int cycles_with_mmcr2(void)
+{
+        struct event event;
+        uint64_t val, expected[2], actual;
+        int i;
+        bool bad_mmcr2;
+
+        event_init_named(&event, 0x1001e, "cycles");
+        event_leader_ebb_init(&event);
+
+        event.attr.exclude_kernel = 1;
+        event.attr.exclude_hv = 1;
+        event.attr.exclude_idle = 1;
+
+        FAIL_IF(event_open(&event));
+
+        ebb_enable_pmc_counting(1);
+        setup_ebb_handler(standard_ebb_callee);
+        ebb_global_enable();
+
+        FAIL_IF(ebb_event_enable(&event));
+
+        mtspr(SPRN_PMC1, pmc_sample_period(sample_period));
+
+        /* XXX Set of MMCR2 must be after enable */
+        expected[0] = MMCR2_EXPECTED_1;
+        expected[1] = MMCR2_EXPECTED_2;
+        i = 0;
+        bad_mmcr2 = false;
+
+        /* Make sure we loop until we take at least one EBB */
+        while ((ebb_state.stats.ebb_count < 20 && !bad_mmcr2) ||
+                ebb_state.stats.ebb_count < 1)
+        {
+                mtspr(SPRN_MMCR2, expected[i % 2]);
+
+                FAIL_IF(core_busy_loop());
+
+                val = mfspr(SPRN_MMCR2);
+                if (val != expected[i % 2]) {
+                        bad_mmcr2 = true;
+                        actual = val;
+                }
+
+                i++;
+        }
+
+        ebb_global_disable();
+        ebb_freeze_pmcs();
+
+        count_pmc(1, sample_period);
+
+        dump_ebb_state();
+
+        event_close(&event);
+
+        FAIL_IF(ebb_state.stats.ebb_count == 0);
+
+        if (bad_mmcr2)
+                printf("Bad MMCR2 value seen is 0x%lx\n", actual);
+
+        FAIL_IF(bad_mmcr2);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(cycles_with_mmcr2, "cycles_with_mmcr2");
+}
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/ebb.c b/tools/testing/selftests/powerpc/pmu/ebb/ebb.c
index 1b46be94b64c..d7a72ce696b5 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/ebb.c
+++ b/tools/testing/selftests/powerpc/pmu/ebb/ebb.c
@@ -224,6 +224,7 @@ void dump_ebb_hw_state(void)
 
         printf("HW state:\n"            \
                "MMCR0 0x%016x %s\n"     \
+               "MMCR2 0x%016lx\n"       \
                "EBBHR 0x%016lx\n"       \
                "BESCR 0x%016llx %s\n"   \
                "PMC1  0x%016lx\n"       \
@@ -233,10 +234,11 @@ void dump_ebb_hw_state(void)
                "PMC5  0x%016lx\n"       \
                "PMC6  0x%016lx\n"       \
                "SIAR  0x%016lx\n",
-               mmcr0, decode_mmcr0(mmcr0), mfspr(SPRN_EBBHR), bescr,
-               decode_bescr(bescr), mfspr(SPRN_PMC1), mfspr(SPRN_PMC2),
-               mfspr(SPRN_PMC3), mfspr(SPRN_PMC4), mfspr(SPRN_PMC5),
-               mfspr(SPRN_PMC6), mfspr(SPRN_SIAR));
+               mmcr0, decode_mmcr0(mmcr0), mfspr(SPRN_MMCR2),
+               mfspr(SPRN_EBBHR), bescr, decode_bescr(bescr),
+               mfspr(SPRN_PMC1), mfspr(SPRN_PMC2), mfspr(SPRN_PMC3),
+               mfspr(SPRN_PMC4), mfspr(SPRN_PMC5), mfspr(SPRN_PMC6),
+               mfspr(SPRN_SIAR));
 }
 
 void dump_ebb_state(void)
@@ -335,257 +337,6 @@ void event_leader_ebb_init(struct event *e)
         e->attr.pinned = 1;
 }
 
-int core_busy_loop(void)
-{
-        int rc;
-
-        asm volatile (
-                "li  3,  0x3030\n"
-                "std 3,  -96(1)\n"
-                "li  4,  0x4040\n"
-                "std 4,  -104(1)\n"
-                "li  5,  0x5050\n"
-                "std 5,  -112(1)\n"
-                "li  6,  0x6060\n"
-                "std 6,  -120(1)\n"
-                "li  7,  0x7070\n"
-                "std 7,  -128(1)\n"
-                "li  8,  0x0808\n"
-                "std 8,  -136(1)\n"
-                "li  9,  0x0909\n"
-                "std 9,  -144(1)\n"
-                "li  10, 0x1010\n"
-                "std 10, -152(1)\n"
-                "li  11, 0x1111\n"
-                "std 11, -160(1)\n"
-                "li  14, 0x1414\n"
-                "std 14, -168(1)\n"
-                "li  15, 0x1515\n"
-                "std 15, -176(1)\n"
-                "li  16, 0x1616\n"
-                "std 16, -184(1)\n"
-                "li  17, 0x1717\n"
-                "std 17, -192(1)\n"
-                "li  18, 0x1818\n"
-                "std 18, -200(1)\n"
-                "li  19, 0x1919\n"
-                "std 19, -208(1)\n"
-                "li  20, 0x2020\n"
-                "std 20, -216(1)\n"
-                "li  21, 0x2121\n"
-                "std 21, -224(1)\n"
-                "li  22, 0x2222\n"
-                "std 22, -232(1)\n"
-                "li  23, 0x2323\n"
-                "std 23, -240(1)\n"
-                "li  24, 0x2424\n"
-                "std 24, -248(1)\n"
-                "li  25, 0x2525\n"
-                "std 25, -256(1)\n"
-                "li  26, 0x2626\n"
-                "std 26, -264(1)\n"
-                "li  27, 0x2727\n"
-                "std 27, -272(1)\n"
-                "li  28, 0x2828\n"
-                "std 28, -280(1)\n"
-                "li  29, 0x2929\n"
-                "std 29, -288(1)\n"
-                "li  30, 0x3030\n"
-                "li  31, 0x3131\n"
-
-                "li    3,  0\n"
-                "0: "
-                "addi  3, 3, 1\n"
-                "cmpwi 3, 100\n"
-                "blt   0b\n"
-
-                /* Return 1 (fail) unless we get through all the checks */
-                "li     0, 1\n"
-
-                /* Check none of our registers have been corrupted */
-                "cmpwi  4,  0x4040\n"
-                "bne    1f\n"
-                "cmpwi  5,  0x5050\n"
-                "bne    1f\n"
-                "cmpwi  6,  0x6060\n"
-                "bne    1f\n"
-                "cmpwi  7,  0x7070\n"
-                "bne    1f\n"
-                "cmpwi  8,  0x0808\n"
-                "bne    1f\n"
-                "cmpwi  9,  0x0909\n"
-                "bne    1f\n"
-                "cmpwi  10, 0x1010\n"
-                "bne    1f\n"
-                "cmpwi  11, 0x1111\n"
-                "bne    1f\n"
-                "cmpwi  14, 0x1414\n"
-                "bne    1f\n"
-                "cmpwi  15, 0x1515\n"
-                "bne    1f\n"
-                "cmpwi  16, 0x1616\n"
-                "bne    1f\n"
-                "cmpwi  17, 0x1717\n"
-                "bne    1f\n"
-                "cmpwi  18, 0x1818\n"
-                "bne    1f\n"
-                "cmpwi  19, 0x1919\n"
-                "bne    1f\n"
-                "cmpwi  20, 0x2020\n"
-                "bne    1f\n"
-                "cmpwi  21, 0x2121\n"
-                "bne    1f\n"
-                "cmpwi  22, 0x2222\n"
-                "bne    1f\n"
-                "cmpwi  23, 0x2323\n"
-                "bne    1f\n"
-                "cmpwi  24, 0x2424\n"
-                "bne    1f\n"
-                "cmpwi  25, 0x2525\n"
-                "bne    1f\n"
-                "cmpwi  26, 0x2626\n"
-                "bne    1f\n"
-                "cmpwi  27, 0x2727\n"
-                "bne    1f\n"
-                "cmpwi  28, 0x2828\n"
-                "bne    1f\n"
-                "cmpwi  29, 0x2929\n"
-                "bne    1f\n"
-                "cmpwi  30, 0x3030\n"
-                "bne    1f\n"
-                "cmpwi  31, 0x3131\n"
-                "bne    1f\n"
-
-                /* Load junk into all our registers before we reload them from the stack. */
-                "li  3,  0xde\n"
-                "li  4,  0xad\n"
-                "li  5,  0xbe\n"
-                "li  6,  0xef\n"
-                "li  7,  0xde\n"
-                "li  8,  0xad\n"
-                "li  9,  0xbe\n"
-                "li  10, 0xef\n"
-                "li  11, 0xde\n"
-                "li  14, 0xad\n"
-                "li  15, 0xbe\n"
-                "li  16, 0xef\n"
-                "li  17, 0xde\n"
-                "li  18, 0xad\n"
-                "li  19, 0xbe\n"
-                "li  20, 0xef\n"
-                "li  21, 0xde\n"
-                "li  22, 0xad\n"
-                "li  23, 0xbe\n"
-                "li  24, 0xef\n"
-                "li  25, 0xde\n"
-                "li  26, 0xad\n"
-                "li  27, 0xbe\n"
-                "li  28, 0xef\n"
-                "li  29, 0xdd\n"
-
-                "ld     3,  -96(1)\n"
-                "cmpwi  3,  0x3030\n"
-                "bne    1f\n"
-                "ld     4,  -104(1)\n"
-                "cmpwi  4,  0x4040\n"
-                "bne    1f\n"
-                "ld     5,  -112(1)\n"
-                "cmpwi  5,  0x5050\n"
-                "bne    1f\n"
-                "ld     6,  -120(1)\n"
-                "cmpwi  6,  0x6060\n"
-                "bne    1f\n"
-                "ld     7,  -128(1)\n"
-                "cmpwi  7,  0x7070\n"
-                "bne    1f\n"
-                "ld     8,  -136(1)\n"
-                "cmpwi  8,  0x0808\n"
-                "bne    1f\n"
-                "ld     9,  -144(1)\n"
-                "cmpwi  9,  0x0909\n"
-                "bne    1f\n"
-                "ld     10, -152(1)\n"
-                "cmpwi  10, 0x1010\n"
-                "bne    1f\n"
-                "ld     11, -160(1)\n"
-                "cmpwi  11, 0x1111\n"
-                "bne    1f\n"
-                "ld     14, -168(1)\n"
-                "cmpwi  14, 0x1414\n"
-                "bne    1f\n"
-                "ld     15, -176(1)\n"
-                "cmpwi  15, 0x1515\n"
-                "bne    1f\n"
-                "ld     16, -184(1)\n"
-                "cmpwi  16, 0x1616\n"
-                "bne    1f\n"
-                "ld     17, -192(1)\n"
-                "cmpwi  17, 0x1717\n"
-                "bne    1f\n"
-                "ld     18, -200(1)\n"
-                "cmpwi  18, 0x1818\n"
-                "bne    1f\n"
-                "ld     19, -208(1)\n"
-                "cmpwi  19, 0x1919\n"
-                "bne    1f\n"
-                "ld     20, -216(1)\n"
-                "cmpwi  20, 0x2020\n"
-                "bne    1f\n"
-                "ld     21, -224(1)\n"
-                "cmpwi  21, 0x2121\n"
-                "bne    1f\n"
-                "ld     22, -232(1)\n"
-                "cmpwi  22, 0x2222\n"
-                "bne    1f\n"
-                "ld     23, -240(1)\n"
-                "cmpwi  23, 0x2323\n"
-                "bne    1f\n"
-                "ld     24, -248(1)\n"
-                "cmpwi  24, 0x2424\n"
-                "bne    1f\n"
-                "ld     25, -256(1)\n"
-                "cmpwi  25, 0x2525\n"
-                "bne    1f\n"
-                "ld     26, -264(1)\n"
-                "cmpwi  26, 0x2626\n"
-                "bne    1f\n"
-                "ld     27, -272(1)\n"
-                "cmpwi  27, 0x2727\n"
-                "bne    1f\n"
-                "ld     28, -280(1)\n"
-                "cmpwi  28, 0x2828\n"
-                "bne    1f\n"
-                "ld     29, -288(1)\n"
-                "cmpwi  29, 0x2929\n"
-                "bne    1f\n"
-
-                /* Load 0 (success) to return */
-                "li     0, 0\n"
-
-                "1:     mr %0, 0\n"
-
-                : "=r" (rc)
-                : /* no inputs */
-                : "3", "4", "5", "6", "7", "8", "9", "10", "11", "14",
-                  "15", "16", "17", "18", "19", "20", "21", "22", "23",
-                   "24", "25", "26", "27", "28", "29", "30", "31",
-                   "memory"
-        );
-
-        return rc;
-}
-
-int core_busy_loop_with_freeze(void)
-{
-        int rc;
-
-        mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) & ~MMCR0_FC);
-        rc = core_busy_loop();
-        mtspr(SPRN_MMCR0, mfspr(SPRN_MMCR0) |  MMCR0_FC);
-
-        return rc;
-}
-
 int ebb_child(union pipe read_pipe, union pipe write_pipe)
 {
         struct event event;
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/ebb.h b/tools/testing/selftests/powerpc/pmu/ebb/ebb.h
index e62bde05bf78..e44eee5d97ca 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/ebb.h
+++ b/tools/testing/selftests/powerpc/pmu/ebb/ebb.h
@@ -70,7 +70,6 @@ int ebb_check_mmcr0(void);
 extern u64 sample_period;
 
 int core_busy_loop(void);
-int core_busy_loop_with_freeze(void);
 int ebb_child(union pipe read_pipe, union pipe write_pipe);
 int catch_sigill(void (*func)(void));
 void write_pmc1(void);
diff --git a/tools/testing/selftests/powerpc/pmu/l3_bank_test.c b/tools/testing/selftests/powerpc/pmu/l3_bank_test.c
new file mode 100644
index 000000000000..77472f31441e
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/l3_bank_test.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2014, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "event.h"
+#include "utils.h"
+
+#define MALLOC_SIZE     (0x10000 * 10)  /* Ought to be enough .. */
+
+/*
+ * Tests that the L3 bank handling is correct. We fixed it in commit e9aaac1.
+ */
+static int l3_bank_test(void)
+{
+        struct event event;
+        char *p;
+        int i;
+
+        p = malloc(MALLOC_SIZE);
+        FAIL_IF(!p);
+
+        event_init(&event, 0x84918F);
+
+        FAIL_IF(event_open(&event));
+
+        for (i = 0; i < MALLOC_SIZE; i += 0x10000)
+                p[i] = i;
+
+        event_read(&event);
+        event_report(&event);
+
+        FAIL_IF(event.result.running == 0);
+        FAIL_IF(event.result.enabled == 0);
+
+        event_close(&event);
+        free(p);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(l3_bank_test, "l3_bank_test");
+}
diff --git a/tools/testing/selftests/powerpc/pmu/lib.c b/tools/testing/selftests/powerpc/pmu/lib.c
index 0f6a4731d546..9768dea37bf3 100644
--- a/tools/testing/selftests/powerpc/pmu/lib.c
+++ b/tools/testing/selftests/powerpc/pmu/lib.c
@@ -5,10 +5,15 @@
 
 #define _GNU_SOURCE     /* For CPU_ZERO etc. */
 
+#include <elf.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <link.h>
 #include <sched.h>
 #include <setjmp.h>
 #include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <sys/wait.h>
 
 #include "utils.h"
@@ -177,8 +182,8 @@ struct addr_range libc, vdso;
 
 int parse_proc_maps(void)
 {
+        unsigned long start, end;
         char execute, name[128];
-        uint64_t start, end;
         FILE *f;
         int rc;
 
@@ -250,3 +255,46 @@ out_close:
 out:
         return rc;
 }
+
+static char auxv[4096];
+
+void *get_auxv_entry(int type)
+{
+        ElfW(auxv_t) *p;
+        void *result;
+        ssize_t num;
+        int fd;
+
+        fd = open("/proc/self/auxv", O_RDONLY);
+        if (fd == -1) {
+                perror("open");
+                return NULL;
+        }
+
+        result = NULL;
+
+        num = read(fd, auxv, sizeof(auxv));
+        if (num < 0) {
+                perror("read");
+                goto out;
+        }
+
+        if (num > sizeof(auxv)) {
+                printf("Overflowed auxv buffer\n");
+                goto out;
+        }
+
+        p = (ElfW(auxv_t) *)auxv;
+
+        while (p->a_type != AT_NULL) {
+                if (p->a_type == type) {
+                        result = (void *)p->a_un.a_val;
+                        break;
+                }
+
+                p++;
+        }
+out:
+        close(fd);
+        return result;
+}
diff --git a/tools/testing/selftests/powerpc/pmu/lib.h b/tools/testing/selftests/powerpc/pmu/lib.h
index ca5d72ae3be6..0f0339c8a6f6 100644
--- a/tools/testing/selftests/powerpc/pmu/lib.h
+++ b/tools/testing/selftests/powerpc/pmu/lib.h
@@ -29,6 +29,7 @@ extern int notify_parent(union pipe write_pipe);
 extern int notify_parent_of_error(union pipe write_pipe);
 extern pid_t eat_cpu(int (test_function)(void));
 extern bool require_paranoia_below(int level);
+extern void *get_auxv_entry(int type);
 
 struct addr_range {
         uint64_t first, last;
diff --git a/tools/testing/selftests/powerpc/pmu/per_event_excludes.c b/tools/testing/selftests/powerpc/pmu/per_event_excludes.c
new file mode 100644
index 000000000000..fddbbc9cae2f
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/per_event_excludes.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2014, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#define _GNU_SOURCE
+
+#include <elf.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/prctl.h>
+
+#include "event.h"
+#include "lib.h"
+#include "utils.h"
+
+/*
+ * Test that per-event excludes work.
+ */
+
+static int per_event_excludes(void)
+{
+        struct event *e, events[4];
+        char *platform;
+        int i;
+
+        platform = (char *)get_auxv_entry(AT_BASE_PLATFORM);
+        FAIL_IF(!platform);
+        SKIP_IF(strcmp(platform, "power8") != 0);
+
+        /*
+         * We need to create the events disabled, otherwise the running/enabled
+         * counts don't match up.
+         */
+        e = &events[0];
+        event_init_opts(e, PERF_COUNT_HW_INSTRUCTIONS,
+                        PERF_TYPE_HARDWARE, "instructions");
+        e->attr.disabled = 1;
+
+        e = &events[1];
+        event_init_opts(e, PERF_COUNT_HW_INSTRUCTIONS,
+                        PERF_TYPE_HARDWARE, "instructions(k)");
+        e->attr.disabled = 1;
+        e->attr.exclude_user = 1;
+        e->attr.exclude_hv = 1;
+
+        e = &events[2];
+        event_init_opts(e, PERF_COUNT_HW_INSTRUCTIONS,
+                        PERF_TYPE_HARDWARE, "instructions(h)");
+        e->attr.disabled = 1;
+        e->attr.exclude_user = 1;
+        e->attr.exclude_kernel = 1;
+
+        e = &events[3];
+        event_init_opts(e, PERF_COUNT_HW_INSTRUCTIONS,
+                        PERF_TYPE_HARDWARE, "instructions(u)");
+        e->attr.disabled = 1;
+        e->attr.exclude_hv = 1;
+        e->attr.exclude_kernel = 1;
+
+        FAIL_IF(event_open(&events[0]));
+
+        /*
+         * The open here will fail if we don't have per event exclude support,
+         * because the second event has an incompatible set of exclude settings
+         * and we're asking for the events to be in a group.
+         */
+        for (i = 1; i < 4; i++)
+                FAIL_IF(event_open_with_group(&events[i], events[0].fd));
+
+        /*
+         * Even though the above will fail without per-event excludes we keep
+         * testing in order to be thorough.
+         */
+        prctl(PR_TASK_PERF_EVENTS_ENABLE);
+
+        /* Spin for a while */
+        for (i = 0; i < INT_MAX; i++)
+                asm volatile("" : : : "memory");
+
+        prctl(PR_TASK_PERF_EVENTS_DISABLE);
+
+        for (i = 0; i < 4; i++) {
+                FAIL_IF(event_read(&events[i]));
+                event_report(&events[i]);
+        }
+
+        /*
+         * We should see that all events have enabled == running. That
+         * shows that they were all on the PMU at once.
+         */
+        for (i = 0; i < 4; i++)
+                FAIL_IF(events[i].result.running != events[i].result.enabled);
+
+        /*
+         * We can also check that the result for instructions is >= all the
+         * other counts. That's because it is counting all instructions while
+         * the others are counting a subset.
+         */
+        for (i = 1; i < 4; i++)
+                FAIL_IF(events[0].result.value < events[i].result.value);
+
+        for (i = 0; i < 4; i++)
+                event_close(&events[i]);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(per_event_excludes, "per_event_excludes");
+}
diff --git a/tools/testing/selftests/ptrace/peeksiginfo.c b/tools/testing/selftests/ptrace/peeksiginfo.c
index d46558b1f58d..c34cd8ac8aaa 100644
--- a/tools/testing/selftests/ptrace/peeksiginfo.c
+++ b/tools/testing/selftests/ptrace/peeksiginfo.c
@@ -31,6 +31,10 @@ static int sys_ptrace(int request, pid_t pid, void *addr, void *data)
 #define TEST_SICODE_PRIV        -1
 #define TEST_SICODE_SHARE       -2
 
+#ifndef PAGE_SIZE
+#define PAGE_SIZE sysconf(_SC_PAGESIZE)
+#endif
+
 #define err(fmt, ...)                                           \
                 fprintf(stderr,                                 \
                         "Error (%s:%d): " fmt,                  \
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh b/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh
index ee1f6cae3d70..3f6c9b78d177 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-recheck.sh
@@ -54,10 +54,16 @@ do
                         if test -f "$i/qemu-cmd"
                         then
                                 print_bug qemu failed
+                                echo "   $i"
+                        elif test -f "$i/buildonly"
+                        then
+                                echo Build-only run, no boot/test
+                                configcheck.sh $i/.config $i/ConfigFragment
+                                parse-build.sh $i/Make.out $configfile
                         else
                                 print_bug Build failed
+                                echo "   $i"
                         fi
-                        echo "   $i"
                 fi
         done
 done
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 27e544e29510..0f69dcbf9def 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
@@ -42,6 +42,7 @@ grace=120
 
 T=/tmp/kvm-test-1-run.sh.$$
 trap 'rm -rf $T' 0
+touch $T
 
 . $KVM/bin/functions.sh
 . $KVPATH/ver_functions.sh
@@ -131,7 +132,10 @@ boot_args=$6
 
 cd $KVM
 kstarttime=`awk 'BEGIN { print systime() }' < /dev/null`
-echo ' ---' `date`: Starting kernel
+if test -z "$TORTURE_BUILDONLY"
+then
+        echo ' ---' `date`: Starting kernel
+fi
 
 # Generate -smp qemu argument.
 qemu_args="-nographic $qemu_args"
@@ -157,12 +161,13 @@ boot_args="`configfrag_boot_params "$boot_args" "$config_template"`"
 # Generate kernel-version-specific boot parameters
 boot_args="`per_version_boot_params "$boot_args" $builddir/.config $seconds`"
 
-echo $QEMU $qemu_args -m 512 -kernel $builddir/$BOOT_IMAGE -append \"$qemu_append $boot_args\" > $resdir/qemu-cmd
 if test -n "$TORTURE_BUILDONLY"
 then
         echo Build-only run specified, boot/test omitted.
+        touch $resdir/buildonly
         exit 0
 fi
+echo $QEMU $qemu_args -m 512 -kernel $builddir/$BOOT_IMAGE -append \"$qemu_append $boot_args\" > $resdir/qemu-cmd
 ( $QEMU $qemu_args -m 512 -kernel $builddir/$BOOT_IMAGE -append "$qemu_append $boot_args"; echo $? > $resdir/qemu-retval ) &
 qemu_pid=$!
 commandcompleted=0
diff --git a/tools/testing/selftests/rcutorture/bin/kvm.sh b/tools/testing/selftests/rcutorture/bin/kvm.sh
index 40285c58653e..589e9c38413b 100644
--- a/tools/testing/selftests/rcutorture/bin/kvm.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm.sh
@@ -340,12 +340,18 @@ function dump(first, pastlast)
         for (j = 1; j < jn; j++) {
                 builddir=KVM "/b" j
                 print "rm -f " builddir ".ready"
-                print "echo ----", cfr[j], cpusr[j] ovf ": Starting kernel. `date`";
-                print "echo ----", cfr[j], cpusr[j] ovf ": Starting kernel. `date` >> " rd "/log";
+                print "if test -z \"$TORTURE_BUILDONLY\""
+                print "then"
+                print "\techo ----", cfr[j], cpusr[j] ovf ": Starting kernel. `date`";
+                print "\techo ----", cfr[j], cpusr[j] ovf ": Starting kernel. `date` >> " rd "/log";
+                print "fi"
         }
         print "wait"
-        print "echo ---- All kernel runs complete. `date`";
-        print "echo ---- All kernel runs complete. `date` >> " rd "/log";
+        print "if test -z \"$TORTURE_BUILDONLY\""
+        print "then"
+        print "\techo ---- All kernel runs complete. `date`";
+        print "\techo ---- All kernel runs complete. `date` >> " rd "/log";
+        print "fi"
         for (j = 1; j < jn; j++) {
                 builddir=KVM "/b" j
                 print "echo ----", cfr[j], cpusr[j] ovf ": Build/run results:";
@@ -385,10 +391,7 @@ echo
 echo
 echo " --- `date` Test summary:"
 echo Results directory: $resdir/$ds
-if test -z "$TORTURE_BUILDONLY"
-then
-        kvm-recheck.sh $resdir/$ds
-fi
+kvm-recheck.sh $resdir/$ds
 ___EOF___
 
 if test "$dryrun" = script
@@ -403,7 +406,7 @@ then
                 sed -e 's/:.*$//' -e 's/^echo //'
         exit 0
 else
-        # Not a dryru, so run the script.
+        # Not a dryrun, so run the script.
         sh $T/script
 fi
 
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE01 b/tools/testing/selftests/rcutorture/configs/rcu/TREE01
index 9c827ec59a97..063b7079c621 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE01
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE01
@@ -15,7 +15,6 @@ CONFIG_RCU_FANOUT_EXACT=n
 CONFIG_RCU_NOCB_CPU=y
 CONFIG_RCU_NOCB_CPU_ZERO=y
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_RCU_BOOST=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE02 b/tools/testing/selftests/rcutorture/configs/rcu/TREE02
index 1a777b5f68b5..ea119ba2f7d4 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE02
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE02
@@ -18,7 +18,6 @@ CONFIG_RCU_FANOUT_EXACT=n
 CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=y
 CONFIG_PROVE_LOCKING=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=y
 CONFIG_RCU_BOOST=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE02-T b/tools/testing/selftests/rcutorture/configs/rcu/TREE02-T
index 61c8d9ce5bb2..19cf9485f48a 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE02-T
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE02-T
@@ -18,7 +18,6 @@ CONFIG_RCU_FANOUT_EXACT=n
 CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=y
 CONFIG_PROVE_LOCKING=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=y
 CONFIG_RCU_BOOST=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE03 b/tools/testing/selftests/rcutorture/configs/rcu/TREE03
index c1f111c1561b..f4567fb3e332 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE03
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE03
@@ -14,7 +14,6 @@ CONFIG_RCU_FANOUT_LEAF=4
 CONFIG_RCU_FANOUT_EXACT=n
 CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_RCU_BOOST=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE04 b/tools/testing/selftests/rcutorture/configs/rcu/TREE04
index 7dbd27ce17a4..0a262fbb0c12 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE04
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE04
@@ -18,7 +18,6 @@ CONFIG_RCU_FANOUT_LEAF=2
 CONFIG_RCU_FANOUT_EXACT=n
 CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=y
 CONFIG_RCU_CPU_STALL_VERBOSE=y
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE05 b/tools/testing/selftests/rcutorture/configs/rcu/TREE05
index d0f32e574743..3a06b97e9a73 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE05
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE05
@@ -18,7 +18,6 @@ CONFIG_RCU_NOCB_CPU_NONE=y
 CONFIG_DEBUG_LOCK_ALLOC=y
 CONFIG_PROVE_LOCKING=y
 CONFIG_PROVE_RCU=y
-CONFIG_PROVE_RCU_DELAY=y
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE06 b/tools/testing/selftests/rcutorture/configs/rcu/TREE06
index 2e477dfb9c57..8f084cca91bf 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE06
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE06
@@ -19,7 +19,6 @@ CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=y
 CONFIG_PROVE_LOCKING=y
 CONFIG_PROVE_RCU=y
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE07 b/tools/testing/selftests/rcutorture/configs/rcu/TREE07
index 042f86ef362a..ab6225506909 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE07
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE07
@@ -17,7 +17,6 @@ CONFIG_RCU_FANOUT_LEAF=2
 CONFIG_RCU_FANOUT_EXACT=n
 CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=y
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE08 b/tools/testing/selftests/rcutorture/configs/rcu/TREE08
index 3438cee1e3c5..69a2e255bf98 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE08
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE08
@@ -18,7 +18,6 @@ CONFIG_RCU_FANOUT_LEAF=2
 CONFIG_RCU_NOCB_CPU=y
 CONFIG_RCU_NOCB_CPU_ALL=y
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_RCU_BOOST=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE08-T b/tools/testing/selftests/rcutorture/configs/rcu/TREE08-T
index bf4523d3e44c..a0f32fb8f17e 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE08-T
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE08-T
@@ -18,7 +18,6 @@ CONFIG_RCU_FANOUT_LEAF=2
 CONFIG_RCU_NOCB_CPU=y
 CONFIG_RCU_NOCB_CPU_ALL=y
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_RCU_BOOST=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/TREE09 b/tools/testing/selftests/rcutorture/configs/rcu/TREE09
index 81e4f7c0bf0b..b7a62a540ad1 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/TREE09
+++ b/tools/testing/selftests/rcutorture/configs/rcu/TREE09
@@ -13,7 +13,6 @@ CONFIG_SUSPEND=n
 CONFIG_HIBERNATION=n
 CONFIG_RCU_NOCB_CPU=n
 CONFIG_DEBUG_LOCK_ALLOC=n
-CONFIG_PROVE_RCU_DELAY=n
 CONFIG_RCU_CPU_STALL_INFO=n
 CONFIG_RCU_CPU_STALL_VERBOSE=n
 CONFIG_RCU_BOOST=n
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/v0.0/P5-U-T-NH-sd-SMP-hp b/tools/testing/selftests/rcutorture/configs/rcu/v0.0/P5-U-T-NH-sd-SMP-hp
index ef624ce73d8e..a55c00877fe4 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/v0.0/P5-U-T-NH-sd-SMP-hp
+++ b/tools/testing/selftests/rcutorture/configs/rcu/v0.0/P5-U-T-NH-sd-SMP-hp
@@ -13,7 +13,6 @@ CONFIG_PREEMPT_VOLUNTARY=n
 CONFIG_PREEMPT=y
 #CHECK#CONFIG_TREE_PREEMPT_RCU=y
 CONFIG_DEBUG_KERNEL=y
-CONFIG_PROVE_RCU_DELAY=y
 CONFIG_DEBUG_OBJECTS=y
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=y
 CONFIG_RT_MUTEXES=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/v3.12/P5-U-T-NH-sd-SMP-hp b/tools/testing/selftests/rcutorture/configs/rcu/v3.12/P5-U-T-NH-sd-SMP-hp
index ef624ce73d8e..a55c00877fe4 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/v3.12/P5-U-T-NH-sd-SMP-hp
+++ b/tools/testing/selftests/rcutorture/configs/rcu/v3.12/P5-U-T-NH-sd-SMP-hp
@@ -13,7 +13,6 @@ CONFIG_PREEMPT_VOLUNTARY=n
 CONFIG_PREEMPT=y
 #CHECK#CONFIG_TREE_PREEMPT_RCU=y
 CONFIG_DEBUG_KERNEL=y
-CONFIG_PROVE_RCU_DELAY=y
 CONFIG_DEBUG_OBJECTS=y
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=y
 CONFIG_RT_MUTEXES=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/v3.3/P5-U-T-NH-sd-SMP-hp b/tools/testing/selftests/rcutorture/configs/rcu/v3.3/P5-U-T-NH-sd-SMP-hp
index ef624ce73d8e..a55c00877fe4 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/v3.3/P5-U-T-NH-sd-SMP-hp
+++ b/tools/testing/selftests/rcutorture/configs/rcu/v3.3/P5-U-T-NH-sd-SMP-hp
@@ -13,7 +13,6 @@ CONFIG_PREEMPT_VOLUNTARY=n
 CONFIG_PREEMPT=y
 #CHECK#CONFIG_TREE_PREEMPT_RCU=y
 CONFIG_DEBUG_KERNEL=y
-CONFIG_PROVE_RCU_DELAY=y
 CONFIG_DEBUG_OBJECTS=y
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=y
 CONFIG_RT_MUTEXES=y
diff --git a/tools/testing/selftests/rcutorture/configs/rcu/v3.5/P5-U-T-NH-sd-SMP-hp b/tools/testing/selftests/rcutorture/configs/rcu/v3.5/P5-U-T-NH-sd-SMP-hp
index ef624ce73d8e..a55c00877fe4 100644
--- a/tools/testing/selftests/rcutorture/configs/rcu/v3.5/P5-U-T-NH-sd-SMP-hp
+++ b/tools/testing/selftests/rcutorture/configs/rcu/v3.5/P5-U-T-NH-sd-SMP-hp
@@ -13,7 +13,6 @@ CONFIG_PREEMPT_VOLUNTARY=n
 CONFIG_PREEMPT=y
 #CHECK#CONFIG_TREE_PREEMPT_RCU=y
 CONFIG_DEBUG_KERNEL=y
-CONFIG_PROVE_RCU_DELAY=y
 CONFIG_DEBUG_OBJECTS=y
 CONFIG_DEBUG_OBJECTS_RCU_HEAD=y
 CONFIG_RT_MUTEXES=y
diff --git a/tools/testing/selftests/rcutorture/doc/TREE_RCU-kconfig.txt b/tools/testing/selftests/rcutorture/doc/TREE_RCU-kconfig.txt
index adbb76cffb49..3e588db86a17 100644
--- a/tools/testing/selftests/rcutorture/doc/TREE_RCU-kconfig.txt
+++ b/tools/testing/selftests/rcutorture/doc/TREE_RCU-kconfig.txt
@@ -14,7 +14,6 @@ CONFIG_NO_HZ_FULL_SYSIDLE -- Do one.
 CONFIG_PREEMPT -- Do half.  (First three and #8.)
 CONFIG_PROVE_LOCKING -- Do all but two, covering CONFIG_PROVE_RCU and not.
 CONFIG_PROVE_RCU -- Do all but one under CONFIG_PROVE_LOCKING.
-CONFIG_PROVE_RCU_DELAY -- Do one.
 CONFIG_RCU_BOOST -- one of TREE_PREEMPT_RCU.
 CONFIG_RCU_BOOST_PRIO -- set to 2 for _BOOST testing.
 CONFIG_RCU_CPU_STALL_INFO -- do one with and without _VERBOSE.
diff --git a/tools/time/udelay_test.sh b/tools/time/udelay_test.sh
new file mode 100755
index 000000000000..12d46b926917
--- /dev/null
+++ b/tools/time/udelay_test.sh
@@ -0,0 +1,66 @@
+#!/bin/bash
+
+# udelay() test script
+#
+# Test is executed by writing and reading to /sys/kernel/debug/udelay_test
+# and exercises a variety of delays to ensure that udelay() is delaying
+# at least as long as requested (as compared to ktime).
+#
+# Copyright (C) 2014 Google, Inc.
+#
+# This software is licensed under the terms of the GNU General Public
+# License version 2, as published by the Free Software Foundation, and
+# may be copied, distributed, and modified under those terms.
+#
+# This program is distributed in the hope that 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.
+
+MODULE_NAME=udelay_test
+UDELAY_PATH=/sys/kernel/debug/udelay_test
+
+setup()
+{
+        /sbin/modprobe -q $MODULE_NAME
+        tmp_file=`mktemp`
+}
+
+test_one()
+{
+        delay=$1
+        echo $delay > $UDELAY_PATH
+        tee -a $tmp_file < $UDELAY_PATH
+}
+
+cleanup()
+{
+        if [ -f $tmp_file ]; then
+                rm $tmp_file
+        fi
+        /sbin/modprobe -q -r $MODULE_NAME
+}
+
+trap cleanup EXIT
+setup
+
+# Delay for a variety of times.
+# 1..200, 200..500 (by 10), 500..2000 (by 100)
+for (( delay = 1; delay < 200; delay += 1 )); do
+        test_one $delay
+done
+for (( delay = 200; delay < 500; delay += 10 )); do
+        test_one $delay
+done
+for (( delay = 500; delay <= 2000; delay += 100 )); do
+        test_one $delay
+done
+
+# Search for failures
+count=`grep -c FAIL $tmp_file`
+if [ $? -eq "0" ]; then
+        echo "ERROR: $count delays failed to delay long enough"
+        retcode=1
+fi
+
+exit $retcode
diff --git a/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c b/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c
index 87216a0c4a8b..af4b0508be77 100644
--- a/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c
+++ b/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c
@@ -1,3 +1,30 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+
 #define _BSD_SOURCE /* for endian.h */
 
 #include <endian.h>
@@ -27,7 +54,9 @@
 /******************** Descriptors and Strings *******************************/
 
 static const struct {
-        struct usb_functionfs_descs_head header;
+        struct usb_functionfs_descs_head_v2 header;
+        __le32 fs_count;
+        __le32 hs_count;
         struct {
                 struct usb_interface_descriptor intf;
                 struct usb_endpoint_descriptor_no_audio bulk_sink;
@@ -35,11 +64,12 @@ static const struct {
         } __attribute__ ((__packed__)) fs_descs, hs_descs;
 } __attribute__ ((__packed__)) descriptors = {
         .header = {
-                .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),
+                .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),
+                .flags = htole32(FUNCTIONFS_HAS_FS_DESC |
+                                     FUNCTIONFS_HAS_HS_DESC),
                 .length = htole32(sizeof(descriptors)),
-                .fs_count = 3,
-                .hs_count = 3,
         },
+        .fs_count = htole32(3),
         .fs_descs = {
                 .intf = {
                         .bLength = sizeof(descriptors.fs_descs.intf),
@@ -61,6 +91,7 @@ static const struct {
                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
                 },
         },
+        .hs_count = htole32(3),
         .hs_descs = {
                 .intf = {
                         .bLength = sizeof(descriptors.hs_descs.intf),
diff --git a/tools/usb/ffs-aio-example/multibuff/host_app/test.c b/tools/usb/ffs-aio-example/multibuff/host_app/test.c
index b0ad8747d03f..daa3abe6bebd 100644
--- a/tools/usb/ffs-aio-example/multibuff/host_app/test.c
+++ b/tools/usb/ffs-aio-example/multibuff/host_app/test.c
@@ -1,3 +1,30 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+
 #include <libusb.h>
 #include <stdio.h>
 #include <string.h>
diff --git a/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c b/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
index f558664a3317..adc310a6d489 100644
--- a/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
+++ b/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
@@ -1,3 +1,30 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+
 #define _BSD_SOURCE /* for endian.h */
 
 #include <endian.h>
@@ -25,7 +52,9 @@
 /******************** Descriptors and Strings *******************************/
 
 static const struct {
-        struct usb_functionfs_descs_head header;
+        struct usb_functionfs_descs_head_v2 header;
+        __le32 fs_count;
+        __le32 hs_count;
         struct {
                 struct usb_interface_descriptor intf;
                 struct usb_endpoint_descriptor_no_audio bulk_sink;
@@ -33,11 +62,12 @@ static const struct {
         } __attribute__ ((__packed__)) fs_descs, hs_descs;
 } __attribute__ ((__packed__)) descriptors = {
         .header = {
-                .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),
+                .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2),
+                .flags = htole32(FUNCTIONFS_HAS_FS_DESC |
+                                     FUNCTIONFS_HAS_HS_DESC),
                 .length = htole32(sizeof(descriptors)),
-                .fs_count = 3,
-                .hs_count = 3,
         },
+        .fs_count = htole32(3),
         .fs_descs = {
                 .intf = {
                         .bLength = sizeof(descriptors.fs_descs.intf),
@@ -59,6 +89,7 @@ static const struct {
                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
                 },
         },
+        .hs_count = htole32(3),
         .hs_descs = {
                 .intf = {
                         .bLength = sizeof(descriptors.hs_descs.intf),
diff --git a/tools/usb/ffs-aio-example/simple/host_app/test.c b/tools/usb/ffs-aio-example/simple/host_app/test.c
index 64b6a57d8ca3..acd6332811f3 100644
--- a/tools/usb/ffs-aio-example/simple/host_app/test.c
+++ b/tools/usb/ffs-aio-example/simple/host_app/test.c
@@ -1,3 +1,30 @@
+/*
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * For more information, please refer to <http://unlicense.org/>
+ */
+
 #include <libusb.h>
 #include <stdio.h>
 #include <string.h>