50 files changed, 1352 insertions, 242 deletions

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__ */