Merge branch 'fix/asoc' into for-linus

47 files changed, 1892 insertions, 1018 deletions

diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 119e996035c8..011ed2676604 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -25,17 +25,17 @@ int symbol__annotate_init(struct map *map __used, struct symbol *sym)
         return 0;
 }
 
-int symbol__alloc_hist(struct symbol *sym, int nevents)
+int symbol__alloc_hist(struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
         size_t sizeof_sym_hist = (sizeof(struct sym_hist) +
                                   (sym->end - sym->start) * sizeof(u64));
 
-        notes->src = zalloc(sizeof(*notes->src) + nevents * sizeof_sym_hist);
+        notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist);
         if (notes->src == NULL)
                 return -1;
         notes->src->sizeof_sym_hist = sizeof_sym_hist;
-        notes->src->nr_histograms   = nevents;
+        notes->src->nr_histograms   = symbol_conf.nr_events;
         INIT_LIST_HEAD(&notes->src->source);
         return 0;
 }
@@ -334,7 +334,7 @@ fallback:
                  disassembler_style ? "-M " : "",
                  disassembler_style ? disassembler_style : "",
                  map__rip_2objdump(map, sym->start),
-                 map__rip_2objdump(map, sym->end),
+                 map__rip_2objdump(map, sym->end+1),
                  symbol_conf.annotate_asm_raw ? "" : "--no-show-raw",
                  symbol_conf.annotate_src ? "-S" : "",
                  symfs_filename, filename);
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index d9072523d342..efa5dc82bfae 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -72,7 +72,7 @@ static inline struct annotation *symbol__annotation(struct symbol *sym)
 
 int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
                              int evidx, u64 addr);
-int symbol__alloc_hist(struct symbol *sym, int nevents);
+int symbol__alloc_hist(struct symbol *sym);
 void symbol__annotate_zero_histograms(struct symbol *sym);
 
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize);
@@ -99,8 +99,7 @@ static inline int symbol__tui_annotate(struct symbol *sym __used,
 }
 #else
 int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
-                         int nr_events, void(*timer)(void *arg), void *arg,
-                         int delay_secs);
+                         void(*timer)(void *arg), void *arg, int delay_secs);
 #endif
 
 extern const char       *disassembler_style;
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index a91cd99f26ea..dff9c7a725f4 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -13,15 +13,18 @@
 #include "symbol.h"
 #include <linux/kernel.h>
 #include "debug.h"
+#include "session.h"
+#include "tool.h"
 
-static int build_id__mark_dso_hit(union perf_event *event,
+static int build_id__mark_dso_hit(struct perf_tool *tool __used,
+                                  union perf_event *event,
                                   struct perf_sample *sample __used,
                                   struct perf_evsel *evsel __used,
-                                  struct perf_session *session)
+                                  struct machine *machine)
 {
         struct addr_location al;
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        struct thread *thread = perf_session__findnew(session, event->ip.pid);
+        struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
 
         if (thread == NULL) {
                 pr_err("problem processing %d event, skipping it.\n",
@@ -29,8 +32,8 @@ static int build_id__mark_dso_hit(union perf_event *event,
                 return -1;
         }
 
-        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
-                              event->ip.pid, event->ip.ip, &al);
+        thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
+                              event->ip.ip, &al);
 
         if (al.map != NULL)
                 al.map->dso->hit = 1;
@@ -38,25 +41,26 @@ static int build_id__mark_dso_hit(union perf_event *event,
         return 0;
 }
 
-static int perf_event__exit_del_thread(union perf_event *event,
+static int perf_event__exit_del_thread(struct perf_tool *tool __used,
+                                       union perf_event *event,
                                        struct perf_sample *sample __used,
-                                       struct perf_session *session)
+                                       struct machine *machine)
 {
-        struct thread *thread = perf_session__findnew(session, event->fork.tid);
+        struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
 
         dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
                     event->fork.ppid, event->fork.ptid);
 
         if (thread) {
-                rb_erase(&thread->rb_node, &session->threads);
-                session->last_match = NULL;
+                rb_erase(&thread->rb_node, &machine->threads);
+                machine->last_match = NULL;
                 thread__delete(thread);
         }
 
         return 0;
 }
 
-struct perf_event_ops build_id__mark_dso_hit_ops = {
+struct perf_tool build_id__mark_dso_hit_ops = {
         .sample = build_id__mark_dso_hit,
         .mmap   = perf_event__process_mmap,
         .fork   = perf_event__process_task,
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 5dafb00eaa06..a993ba87d996 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -3,7 +3,7 @@
 
 #include "session.h"
 
-extern struct perf_event_ops build_id__mark_dso_hit_ops;
+extern struct perf_tool build_id__mark_dso_hit_ops;
 
 char *dso__build_id_filename(struct dso *self, char *bf, size_t size);
 
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 9b4ff16cac96..7f9c0f1ae3a9 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -101,6 +101,9 @@ int callchain_append(struct callchain_root *root,
 int callchain_merge(struct callchain_cursor *cursor,
                     struct callchain_root *dst, struct callchain_root *src);
 
+struct ip_callchain;
+union perf_event;
+
 bool ip_callchain__valid(struct ip_callchain *chain,
                          const union perf_event *event);
 /*
diff --git a/tools/perf/util/cgroup.c b/tools/perf/util/cgroup.c
index 96bee5c46008..dbe2f16b1a1a 100644
--- a/tools/perf/util/cgroup.c
+++ b/tools/perf/util/cgroup.c
@@ -3,7 +3,6 @@
 #include "parse-options.h"
 #include "evsel.h"
 #include "cgroup.h"
-#include "debugfs.h" /* MAX_PATH, STR() */
 #include "evlist.h"
 
 int nr_cgroups;
@@ -12,7 +11,7 @@ static int
 cgroupfs_find_mountpoint(char *buf, size_t maxlen)
 {
         FILE *fp;
-        char mountpoint[MAX_PATH+1], tokens[MAX_PATH+1], type[MAX_PATH+1];
+        char mountpoint[PATH_MAX + 1], tokens[PATH_MAX + 1], type[PATH_MAX + 1];
         char *token, *saved_ptr = NULL;
         int found = 0;
 
@@ -25,8 +24,8 @@ cgroupfs_find_mountpoint(char *buf, size_t maxlen)
          * and inspect every cgroupfs mount point to find one that has
          * perf_event subsystem
          */
-        while (fscanf(fp, "%*s %"STR(MAX_PATH)"s %"STR(MAX_PATH)"s %"
-                                STR(MAX_PATH)"s %*d %*d\n",
+        while (fscanf(fp, "%*s %"STR(PATH_MAX)"s %"STR(PATH_MAX)"s %"
+                                STR(PATH_MAX)"s %*d %*d\n",
                                 mountpoint, type, tokens) == 3) {
 
                 if (!strcmp(type, "cgroup")) {
@@ -57,15 +56,15 @@ cgroupfs_find_mountpoint(char *buf, size_t maxlen)
 
 static int open_cgroup(char *name)
 {
-        char path[MAX_PATH+1];
-        char mnt[MAX_PATH+1];
+        char path[PATH_MAX + 1];
+        char mnt[PATH_MAX + 1];
         int fd;
 
 
-        if (cgroupfs_find_mountpoint(mnt, MAX_PATH+1))
+        if (cgroupfs_find_mountpoint(mnt, PATH_MAX + 1))
                 return -1;
 
-        snprintf(path, MAX_PATH, "%s/%s", mnt, name);
+        snprintf(path, PATH_MAX, "%s/%s", mnt, name);
 
         fd = open(path, O_RDONLY);
         if (fd == -1)
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 80d9598db31a..0deac6a14b65 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -1,5 +1,8 @@
 /*
- * GIT - The information manager from hell
+ * config.c
+ *
+ * Helper functions for parsing config items.
+ * Originally copied from GIT source.
  *
  * Copyright (C) Linus Torvalds, 2005
  * Copyright (C) Johannes Schindelin, 2005
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
index a88fefc0cc0a..ffc35e748e89 100644
--- a/tools/perf/util/debugfs.c
+++ b/tools/perf/util/debugfs.c
@@ -2,8 +2,12 @@
 #include "debugfs.h"
 #include "cache.h"
 
+#include <linux/kernel.h>
+#include <sys/mount.h>
+
 static int debugfs_premounted;
-static char debugfs_mountpoint[MAX_PATH+1];
+char debugfs_mountpoint[PATH_MAX + 1] = "/sys/kernel/debug";
+char tracing_events_path[PATH_MAX + 1] = "/sys/kernel/debug/tracing/events";
 
 static const char *debugfs_known_mountpoints[] = {
         "/sys/kernel/debug/",
@@ -62,11 +66,9 @@ const char *debugfs_find_mountpoint(void)
         /* give up and parse /proc/mounts */
         fp = fopen("/proc/mounts", "r");
         if (fp == NULL)
-                die("Can't open /proc/mounts for read");
+                return NULL;
 
-        while (fscanf(fp, "%*s %"
-                      STR(MAX_PATH)
-                      "s %99s %*s %*d %*d\n",
+        while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
                       debugfs_mountpoint, type) == 2) {
                 if (strcmp(type, "debugfs") == 0)
                         break;
@@ -106,6 +108,12 @@ int debugfs_valid_entry(const char *path)
         return 0;
 }
 
+static void debugfs_set_tracing_events_path(const char *mountpoint)
+{
+        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
+                 mountpoint, "tracing/events");
+}
+
 /* mount the debugfs somewhere if it's not mounted */
 
 char *debugfs_mount(const char *mountpoint)
@@ -113,7 +121,7 @@ char *debugfs_mount(const char *mountpoint)
         /* see if it's already mounted */
         if (debugfs_find_mountpoint()) {
                 debugfs_premounted = 1;
-                return debugfs_mountpoint;
+                goto out;
         }
 
         /* if not mounted and no argument */
@@ -129,12 +137,19 @@ char *debugfs_mount(const char *mountpoint)
                 return NULL;
 
         /* save the mountpoint */
-        strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
         debugfs_found = 1;
-
+        strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
+out:
+        debugfs_set_tracing_events_path(debugfs_mountpoint);
         return debugfs_mountpoint;
 }
 
+void debugfs_set_path(const char *mountpoint)
+{
+        snprintf(debugfs_mountpoint, sizeof(debugfs_mountpoint), "%s", mountpoint);
+        debugfs_set_tracing_events_path(mountpoint);
+}
+
 /* umount the debugfs */
 
 int debugfs_umount(void)
@@ -158,7 +173,7 @@ int debugfs_umount(void)
 
 int debugfs_write(const char *entry, const char *value)
 {
-        char path[MAX_PATH+1];
+        char path[PATH_MAX + 1];
         int ret, count;
         int fd;
 
@@ -203,7 +218,7 @@ int debugfs_write(const char *entry, const char *value)
  */
 int debugfs_read(const char *entry, char *buffer, size_t size)
 {
-        char path[MAX_PATH+1];
+        char path[PATH_MAX + 1];
         int ret;
         int fd;
 
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
index 83a02879745f..4a878f735eb0 100644
--- a/tools/perf/util/debugfs.h
+++ b/tools/perf/util/debugfs.h
@@ -1,25 +1,18 @@
 #ifndef __DEBUGFS_H__
 #define __DEBUGFS_H__
 
-#include <sys/mount.h>
+const char *debugfs_find_mountpoint(void);
+int debugfs_valid_mountpoint(const char *debugfs);
+int debugfs_valid_entry(const char *path);
+char *debugfs_mount(const char *mountpoint);
+int debugfs_umount(void);
+void debugfs_set_path(const char *mountpoint);
+int debugfs_write(const char *entry, const char *value);
+int debugfs_read(const char *entry, char *buffer, size_t size);
+void debugfs_force_cleanup(void);
+int debugfs_make_path(const char *element, char *buffer, int size);
 
-#ifndef MAX_PATH
-# define MAX_PATH 256
-#endif
-
-#ifndef STR
-# define _STR(x) #x
-# define STR(x) _STR(x)
-#endif
-
-extern const char *debugfs_find_mountpoint(void);
-extern int debugfs_valid_mountpoint(const char *debugfs);
-extern int debugfs_valid_entry(const char *path);
-extern char *debugfs_mount(const char *mountpoint);
-extern int debugfs_umount(void);
-extern int debugfs_write(const char *entry, const char *value);
-extern int debugfs_read(const char *entry, char *buffer, size_t size);
-extern void debugfs_force_cleanup(void);
-extern int debugfs_make_path(const char *element, char *buffer, int size);
+extern char debugfs_mountpoint[];
+extern char tracing_events_path[];
 
 #endif /* __DEBUGFS_H__ */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 437f8ca679a0..73ddaf06b8e7 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -1,7 +1,6 @@
 #include <linux/types.h>
 #include "event.h"
 #include "debug.h"
-#include "session.h"
 #include "sort.h"
 #include "string.h"
 #include "strlist.h"
@@ -44,36 +43,27 @@ static struct perf_sample synth_sample = {
         .period    = 1,
 };
 
-static pid_t perf_event__synthesize_comm(union perf_event *event, pid_t pid,
-                                         int full, perf_event__handler_t process,
-                                         struct perf_session *session)
+static pid_t perf_event__get_comm_tgid(pid_t pid, char *comm, size_t len)
 {
         char filename[PATH_MAX];
         char bf[BUFSIZ];
         FILE *fp;
         size_t size = 0;
-        DIR *tasks;
-        struct dirent dirent, *next;
-        pid_t tgid = 0;
+        pid_t tgid = -1;
 
         snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
 
         fp = fopen(filename, "r");
         if (fp == NULL) {
-out_race:
-                /*
-                 * We raced with a task exiting - just return:
-                 */
                 pr_debug("couldn't open %s\n", filename);
                 return 0;
         }
 
-        memset(&event->comm, 0, sizeof(event->comm));
-
-        while (!event->comm.comm[0] || !event->comm.pid) {
+        while (!comm[0] || (tgid < 0)) {
                 if (fgets(bf, sizeof(bf), fp) == NULL) {
-                        pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
-                        goto out;
+                        pr_warning("couldn't get COMM and pgid, malformed %s\n",
+                                   filename);
+                        break;
                 }
 
                 if (memcmp(bf, "Name:", 5) == 0) {
@@ -81,33 +71,65 @@ out_race:
                         while (*name && isspace(*name))
                                 ++name;
                         size = strlen(name) - 1;
-                        memcpy(event->comm.comm, name, size++);
+                        if (size >= len)
+                                size = len - 1;
+                        memcpy(comm, name, size);
+
                 } else if (memcmp(bf, "Tgid:", 5) == 0) {
                         char *tgids = bf + 5;
                         while (*tgids && isspace(*tgids))
                                 ++tgids;
-                        tgid = event->comm.pid = atoi(tgids);
+                        tgid = atoi(tgids);
                 }
         }
 
+        fclose(fp);
+
+        return tgid;
+}
+
+static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
+                                         union perf_event *event, pid_t pid,
+                                         int full,
+                                         perf_event__handler_t process,
+                                         struct machine *machine)
+{
+        char filename[PATH_MAX];
+        size_t size;
+        DIR *tasks;
+        struct dirent dirent, *next;
+        pid_t tgid;
+
+        memset(&event->comm, 0, sizeof(event->comm));
+
+        tgid = perf_event__get_comm_tgid(pid, event->comm.comm,
+                                         sizeof(event->comm.comm));
+        if (tgid < 0)
+                goto out;
+
+        event->comm.pid = tgid;
         event->comm.header.type = PERF_RECORD_COMM;
+
+        size = strlen(event->comm.comm) + 1;
         size = ALIGN(size, sizeof(u64));
-        memset(event->comm.comm + size, 0, session->id_hdr_size);
+        memset(event->comm.comm + size, 0, machine->id_hdr_size);
         event->comm.header.size = (sizeof(event->comm) -
                                 (sizeof(event->comm.comm) - size) +
-                                session->id_hdr_size);
+                                machine->id_hdr_size);
         if (!full) {
                 event->comm.tid = pid;
 
-                process(event, &synth_sample, session);
+                process(tool, event, &synth_sample, machine);
                 goto out;
         }
 
         snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
 
         tasks = opendir(filename);
-        if (tasks == NULL)
-                goto out_race;
+        if (tasks == NULL) {
+                pr_debug("couldn't open %s\n", filename);
+                return 0;
+        }
 
         while (!readdir_r(tasks, &dirent, &next) && next) {
                 char *end;
@@ -115,22 +137,32 @@ out_race:
                 if (*end)
                         continue;
 
+                /* already have tgid; jut want to update the comm */
+                (void) perf_event__get_comm_tgid(pid, event->comm.comm,
+                                         sizeof(event->comm.comm));
+
+                size = strlen(event->comm.comm) + 1;
+                size = ALIGN(size, sizeof(u64));
+                memset(event->comm.comm + size, 0, machine->id_hdr_size);
+                event->comm.header.size = (sizeof(event->comm) -
+                                          (sizeof(event->comm.comm) - size) +
+                                          machine->id_hdr_size);
+
                 event->comm.tid = pid;
 
-                process(event, &synth_sample, session);
+                process(tool, event, &synth_sample, machine);
         }
 
         closedir(tasks);
 out:
-        fclose(fp);
-
         return tgid;
 }
 
-static int perf_event__synthesize_mmap_events(union perf_event *event,
+static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
+                                              union perf_event *event,
                                               pid_t pid, pid_t tgid,
                                               perf_event__handler_t process,
-                                              struct perf_session *session)
+                                              struct machine *machine)
 {
         char filename[PATH_MAX];
         FILE *fp;
@@ -193,12 +225,12 @@ static int perf_event__synthesize_mmap_events(union perf_event *event,
                         event->mmap.len -= event->mmap.start;
                         event->mmap.header.size = (sizeof(event->mmap) -
                                                 (sizeof(event->mmap.filename) - size));
-                        memset(event->mmap.filename + size, 0, session->id_hdr_size);
-                        event->mmap.header.size += session->id_hdr_size;
+                        memset(event->mmap.filename + size, 0, machine->id_hdr_size);
+                        event->mmap.header.size += machine->id_hdr_size;
                         event->mmap.pid = tgid;
                         event->mmap.tid = pid;
 
-                        process(event, &synth_sample, session);
+                        process(tool, event, &synth_sample, machine);
                 }
         }
 
@@ -206,14 +238,14 @@ static int perf_event__synthesize_mmap_events(union perf_event *event,
         return 0;
 }
 
-int perf_event__synthesize_modules(perf_event__handler_t process,
-                                   struct perf_session *session,
+int perf_event__synthesize_modules(struct perf_tool *tool,
+                                   perf_event__handler_t process,
                                    struct machine *machine)
 {
         struct rb_node *nd;
         struct map_groups *kmaps = &machine->kmaps;
         union perf_event *event = zalloc((sizeof(event->mmap) +
-                                          session->id_hdr_size));
+                                          machine->id_hdr_size));
         if (event == NULL) {
                 pr_debug("Not enough memory synthesizing mmap event "
                          "for kernel modules\n");
@@ -243,15 +275,15 @@ int perf_event__synthesize_modules(perf_event__handler_t process,
                 event->mmap.header.type = PERF_RECORD_MMAP;
                 event->mmap.header.size = (sizeof(event->mmap) -
                                         (sizeof(event->mmap.filename) - size));
-                memset(event->mmap.filename + size, 0, session->id_hdr_size);
-                event->mmap.header.size += session->id_hdr_size;
+                memset(event->mmap.filename + size, 0, machine->id_hdr_size);
+                event->mmap.header.size += machine->id_hdr_size;
                 event->mmap.start = pos->start;
                 event->mmap.len   = pos->end - pos->start;
                 event->mmap.pid   = machine->pid;
 
                 memcpy(event->mmap.filename, pos->dso->long_name,
                        pos->dso->long_name_len + 1);
-                process(event, &synth_sample, session);
+                process(tool, event, &synth_sample, machine);
         }
 
         free(event);
@@ -260,40 +292,69 @@ int perf_event__synthesize_modules(perf_event__handler_t process,
 
 static int __event__synthesize_thread(union perf_event *comm_event,
                                       union perf_event *mmap_event,
-                                      pid_t pid, perf_event__handler_t process,
-                                      struct perf_session *session)
+                                      pid_t pid, int full,
+                                          perf_event__handler_t process,
+                                      struct perf_tool *tool,
+                                      struct machine *machine)
 {
-        pid_t tgid = perf_event__synthesize_comm(comm_event, pid, 1, process,
-                                            session);
+        pid_t tgid = perf_event__synthesize_comm(tool, comm_event, pid, full,
+                                                 process, machine);
         if (tgid == -1)
                 return -1;
-        return perf_event__synthesize_mmap_events(mmap_event, pid, tgid,
-                                             process, session);
+        return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
+                                                  process, machine);
 }
 
-int perf_event__synthesize_thread_map(struct thread_map *threads,
+int perf_event__synthesize_thread_map(struct perf_tool *tool,
+                                      struct thread_map *threads,
                                       perf_event__handler_t process,
-                                      struct perf_session *session)
+                                      struct machine *machine)
 {
         union perf_event *comm_event, *mmap_event;
-        int err = -1, thread;
+        int err = -1, thread, j;
 
-        comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
+        comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size);
         if (comm_event == NULL)
                 goto out;
 
-        mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size);
+        mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size);
         if (mmap_event == NULL)
                 goto out_free_comm;
 
         err = 0;
         for (thread = 0; thread < threads->nr; ++thread) {
                 if (__event__synthesize_thread(comm_event, mmap_event,
-                                               threads->map[thread],
-                                               process, session)) {
+                                               threads->map[thread], 0,
+                                               process, tool, machine)) {
                         err = -1;
                         break;
                 }
+
+                /*
+                 * comm.pid is set to thread group id by
+                 * perf_event__synthesize_comm
+                 */
+                if ((int) comm_event->comm.pid != threads->map[thread]) {
+                        bool need_leader = true;
+
+                        /* is thread group leader in thread_map? */
+                        for (j = 0; j < threads->nr; ++j) {
+                                if ((int) comm_event->comm.pid == threads->map[j]) {
+                                        need_leader = false;
+                                        break;
+                                }
+                        }
+
+                        /* if not, generate events for it */
+                        if (need_leader &&
+                            __event__synthesize_thread(comm_event,
+                                                      mmap_event,
+                                                      comm_event->comm.pid, 0,
+                                                      process, tool, machine)) {
+                                err = -1;
+                                break;
+                        }
+                }
         }
         free(mmap_event);
 out_free_comm:
@@ -302,19 +363,20 @@ out:
         return err;
 }
 
-int perf_event__synthesize_threads(perf_event__handler_t process,
-                                   struct perf_session *session)
+int perf_event__synthesize_threads(struct perf_tool *tool,
+                                   perf_event__handler_t process,
+                                   struct machine *machine)
 {
         DIR *proc;
         struct dirent dirent, *next;
         union perf_event *comm_event, *mmap_event;
         int err = -1;
 
-        comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
+        comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size);
         if (comm_event == NULL)
                 goto out;
 
-        mmap_event = malloc(sizeof(mmap_event->mmap) + session->id_hdr_size);
+        mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size);
         if (mmap_event == NULL)
                 goto out_free_comm;
 
@@ -329,8 +391,8 @@ int perf_event__synthesize_threads(perf_event__handler_t process,
                 if (*end) /* only interested in proper numerical dirents */
                         continue;
 
-                __event__synthesize_thread(comm_event, mmap_event, pid,
-                                           process, session);
+                __event__synthesize_thread(comm_event, mmap_event, pid, 1,
+                                           process, tool, machine);
         }
 
         closedir(proc);
@@ -365,8 +427,8 @@ static int find_symbol_cb(void *arg, const char *name, char type,
         return 1;
 }
 
-int perf_event__synthesize_kernel_mmap(perf_event__handler_t process,
-                                       struct perf_session *session,
+int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
+                                       perf_event__handler_t process,
                                        struct machine *machine,
                                        const char *symbol_name)
 {
@@ -383,7 +445,7 @@ int perf_event__synthesize_kernel_mmap(perf_event__handler_t process,
          */
         struct process_symbol_args args = { .name = symbol_name, };
         union perf_event *event = zalloc((sizeof(event->mmap) +
-                                          session->id_hdr_size));
+                                          machine->id_hdr_size));
         if (event == NULL) {
                 pr_debug("Not enough memory synthesizing mmap event "
                          "for kernel modules\n");
@@ -417,25 +479,32 @@ int perf_event__synthesize_kernel_mmap(perf_event__handler_t process,
         size = ALIGN(size, sizeof(u64));
         event->mmap.header.type = PERF_RECORD_MMAP;
         event->mmap.header.size = (sizeof(event->mmap) -
-                        (sizeof(event->mmap.filename) - size) + session->id_hdr_size);
+                        (sizeof(event->mmap.filename) - size) + machine->id_hdr_size);
         event->mmap.pgoff = args.start;
         event->mmap.start = map->start;
         event->mmap.len   = map->end - event->mmap.start;
         event->mmap.pid   = machine->pid;
 
-        err = process(event, &synth_sample, session);
+        err = process(tool, event, &synth_sample, machine);
         free(event);
 
         return err;
 }
 
-int perf_event__process_comm(union perf_event *event,
+size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
+{
+        return fprintf(fp, ": %s:%d\n", event->comm.comm, event->comm.tid);
+}
+
+int perf_event__process_comm(struct perf_tool *tool __used,
+                             union perf_event *event,
                              struct perf_sample *sample __used,
-                             struct perf_session *session)
+                             struct machine *machine)
 {
-        struct thread *thread = perf_session__findnew(session, event->comm.tid);
+        struct thread *thread = machine__findnew_thread(machine, event->comm.tid);
 
-        dump_printf(": %s:%d\n", event->comm.comm, event->comm.tid);
+        if (dump_trace)
+                perf_event__fprintf_comm(event, stdout);
 
         if (thread == NULL || thread__set_comm(thread, event->comm.comm)) {
                 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
@@ -445,13 +514,13 @@ int perf_event__process_comm(union perf_event *event,
         return 0;
 }
 
-int perf_event__process_lost(union perf_event *event,
+int perf_event__process_lost(struct perf_tool *tool __used,
+                             union perf_event *event,
                              struct perf_sample *sample __used,
-                             struct perf_session *session)
+                             struct machine *machine __used)
 {
         dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
                     event->lost.id, event->lost.lost);
-        session->hists.stats.total_lost += event->lost.lost;
         return 0;
 }
 
@@ -468,21 +537,15 @@ static void perf_event__set_kernel_mmap_len(union perf_event *event,
                 maps[MAP__FUNCTION]->end = ~0ULL;
 }
 
-static int perf_event__process_kernel_mmap(union perf_event *event,
-                                           struct perf_session *session)
+static int perf_event__process_kernel_mmap(struct perf_tool *tool __used,
+                                           union perf_event *event,
+                                           struct machine *machine)
 {
         struct map *map;
         char kmmap_prefix[PATH_MAX];
-        struct machine *machine;
         enum dso_kernel_type kernel_type;
         bool is_kernel_mmap;
 
-        machine = perf_session__findnew_machine(session, event->mmap.pid);
-        if (!machine) {
-                pr_err("Can't find id %d's machine\n", event->mmap.pid);
-                goto out_problem;
-        }
-
         machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
         if (machine__is_host(machine))
                 kernel_type = DSO_TYPE_KERNEL;
@@ -549,9 +612,9 @@ static int perf_event__process_kernel_mmap(union perf_event *event,
                  * time /proc/sys/kernel/kptr_restrict was non zero.
                  */
                 if (event->mmap.pgoff != 0) {
-                        perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
-                                                                 symbol_name,
-                                                                 event->mmap.pgoff);
+                        maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
+                                                         symbol_name,
+                                                         event->mmap.pgoff);
                 }
 
                 if (machine__is_default_guest(machine)) {
@@ -567,32 +630,35 @@ out_problem:
         return -1;
 }
 
-int perf_event__process_mmap(union perf_event *event,
+size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp)
+{
+        return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %s\n",
+                       event->mmap.pid, event->mmap.tid, event->mmap.start,
+                       event->mmap.len, event->mmap.pgoff, event->mmap.filename);
+}
+
+int perf_event__process_mmap(struct perf_tool *tool,
+                             union perf_event *event,
                              struct perf_sample *sample __used,
-                             struct perf_session *session)
+                             struct machine *machine)
 {
-        struct machine *machine;
         struct thread *thread;
         struct map *map;
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
         int ret = 0;
 
-        dump_printf(" %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %s\n",
-                        event->mmap.pid, event->mmap.tid, event->mmap.start,
-                        event->mmap.len, event->mmap.pgoff, event->mmap.filename);
+        if (dump_trace)
+                perf_event__fprintf_mmap(event, stdout);
 
         if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
             cpumode == PERF_RECORD_MISC_KERNEL) {
-                ret = perf_event__process_kernel_mmap(event, session);
+                ret = perf_event__process_kernel_mmap(tool, event, machine);
                 if (ret < 0)
                         goto out_problem;
                 return 0;
         }
 
-        machine = perf_session__find_host_machine(session);
-        if (machine == NULL)
-                goto out_problem;
-        thread = perf_session__findnew(session, event->mmap.pid);
+        thread = machine__findnew_thread(machine, event->mmap.pid);
         if (thread == NULL)
                 goto out_problem;
         map = map__new(&machine->user_dsos, event->mmap.start,
@@ -610,18 +676,26 @@ out_problem:
         return 0;
 }
 
-int perf_event__process_task(union perf_event *event,
+size_t perf_event__fprintf_task(union perf_event *event, FILE *fp)
+{
+        return fprintf(fp, "(%d:%d):(%d:%d)\n",
+                       event->fork.pid, event->fork.tid,
+                       event->fork.ppid, event->fork.ptid);
+}
+
+int perf_event__process_task(struct perf_tool *tool __used,
+                             union perf_event *event,
                              struct perf_sample *sample __used,
-                             struct perf_session *session)
+                              struct machine *machine)
 {
-        struct thread *thread = perf_session__findnew(session, event->fork.tid);
-        struct thread *parent = perf_session__findnew(session, event->fork.ptid);
+        struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
+        struct thread *parent = machine__findnew_thread(machine, event->fork.ptid);
 
-        dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
-                    event->fork.ppid, event->fork.ptid);
+        if (dump_trace)
+                perf_event__fprintf_task(event, stdout);
 
         if (event->header.type == PERF_RECORD_EXIT) {
-                perf_session__remove_thread(session, thread);
+                machine__remove_thread(machine, thread);
                 return 0;
         }
 
@@ -634,22 +708,45 @@ int perf_event__process_task(union perf_event *event,
         return 0;
 }
 
-int perf_event__process(union perf_event *event, struct perf_sample *sample,
-                        struct perf_session *session)
+size_t perf_event__fprintf(union perf_event *event, FILE *fp)
+{
+        size_t ret = fprintf(fp, "PERF_RECORD_%s",
+                             perf_event__name(event->header.type));
+
+        switch (event->header.type) {
+        case PERF_RECORD_COMM:
+                ret += perf_event__fprintf_comm(event, fp);
+                break;
+        case PERF_RECORD_FORK:
+        case PERF_RECORD_EXIT:
+                ret += perf_event__fprintf_task(event, fp);
+                break;
+        case PERF_RECORD_MMAP:
+                ret += perf_event__fprintf_mmap(event, fp);
+                break;
+        default:
+                ret += fprintf(fp, "\n");
+        }
+
+        return ret;
+}
+
+int perf_event__process(struct perf_tool *tool, union perf_event *event,
+                        struct perf_sample *sample, struct machine *machine)
 {
         switch (event->header.type) {
         case PERF_RECORD_COMM:
-                perf_event__process_comm(event, sample, session);
+                perf_event__process_comm(tool, event, sample, machine);
                 break;
         case PERF_RECORD_MMAP:
-                perf_event__process_mmap(event, sample, session);
+                perf_event__process_mmap(tool, event, sample, machine);
                 break;
         case PERF_RECORD_FORK:
         case PERF_RECORD_EXIT:
-                perf_event__process_task(event, sample, session);
+                perf_event__process_task(tool, event, sample, machine);
                 break;
         case PERF_RECORD_LOST:
-                perf_event__process_lost(event, sample, session);
+                perf_event__process_lost(tool, event, sample, machine);
         default:
                 break;
         }
@@ -658,36 +755,29 @@ int perf_event__process(union perf_event *event, struct perf_sample *sample,
 }
 
 void thread__find_addr_map(struct thread *self,
-                           struct perf_session *session, u8 cpumode,
-                           enum map_type type, pid_t pid, u64 addr,
+                           struct machine *machine, u8 cpumode,
+                           enum map_type type, u64 addr,
                            struct addr_location *al)
 {
         struct map_groups *mg = &self->mg;
-        struct machine *machine = NULL;
 
         al->thread = self;
         al->addr = addr;
         al->cpumode = cpumode;
         al->filtered = false;
 
+        if (machine == NULL) {
+                al->map = NULL;
+                return;
+        }
+
         if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
                 al->level = 'k';
-                machine = perf_session__find_host_machine(session);
-                if (machine == NULL) {
-                        al->map = NULL;
-                        return;
-                }
                 mg = &machine->kmaps;
         } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
                 al->level = '.';
-                machine = perf_session__find_host_machine(session);
         } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
                 al->level = 'g';
-                machine = perf_session__find_machine(session, pid);
-                if (machine == NULL) {
-                        al->map = NULL;
-                        return;
-                }
                 mg = &machine->kmaps;
         } else {
                 /*
@@ -733,13 +823,12 @@ try_again:
                 al->addr = al->map->map_ip(al->map, al->addr);
 }
 
-void thread__find_addr_location(struct thread *self,
-                                struct perf_session *session, u8 cpumode,
-                                enum map_type type, pid_t pid, u64 addr,
+void thread__find_addr_location(struct thread *thread, struct machine *machine,
+                                u8 cpumode, enum map_type type, u64 addr,
                                 struct addr_location *al,
                                 symbol_filter_t filter)
 {
-        thread__find_addr_map(self, session, cpumode, type, pid, addr, al);
+        thread__find_addr_map(thread, machine, cpumode, type, addr, al);
         if (al->map != NULL)
                 al->sym = map__find_symbol(al->map, al->addr, filter);
         else
@@ -747,13 +836,13 @@ void thread__find_addr_location(struct thread *self,
 }
 
 int perf_event__preprocess_sample(const union perf_event *event,
-                                  struct perf_session *session,
+                                  struct machine *machine,
                                   struct addr_location *al,
                                   struct perf_sample *sample,
                                   symbol_filter_t filter)
 {
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        struct thread *thread = perf_session__findnew(session, event->ip.pid);
+        struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
 
         if (thread == NULL)
                 return -1;
@@ -764,18 +853,18 @@ int perf_event__preprocess_sample(const union perf_event *event,
 
         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
         /*
-         * Have we already created the kernel maps for the host machine?
+         * Have we already created the kernel maps for this machine?
          *
          * This should have happened earlier, when we processed the kernel MMAP
          * events, but for older perf.data files there was no such thing, so do
          * it now.
          */
         if (cpumode == PERF_RECORD_MISC_KERNEL &&
-            session->host_machine.vmlinux_maps[MAP__FUNCTION] == NULL)
-                machine__create_kernel_maps(&session->host_machine);
+            machine->vmlinux_maps[MAP__FUNCTION] == NULL)
+                machine__create_kernel_maps(machine);
 
-        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
-                              event->ip.pid, event->ip.ip, al);
+        thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
+                              event->ip.ip, al);
         dump_printf(" ...... dso: %s\n",
                     al->map ? al->map->dso->long_name :
                         al->level == 'H' ? "[hypervisor]" : "<not found>");
@@ -783,13 +872,14 @@ int perf_event__preprocess_sample(const union perf_event *event,
         al->cpu = sample->cpu;
 
         if (al->map) {
+                struct dso *dso = al->map->dso;
+
                 if (symbol_conf.dso_list &&
-                    (!al->map || !al->map->dso ||
-                     !(strlist__has_entry(symbol_conf.dso_list,
-                                          al->map->dso->short_name) ||
-                       (al->map->dso->short_name != al->map->dso->long_name &&
-                        strlist__has_entry(symbol_conf.dso_list,
-                                           al->map->dso->long_name)))))
+                    (!dso || !(strlist__has_entry(symbol_conf.dso_list,
+                                                  dso->short_name) ||
+                               (dso->short_name != dso->long_name &&
+                                strlist__has_entry(symbol_conf.dso_list,
+                                                   dso->long_name)))))
                         goto out_filtered;
 
                 al->sym = map__find_symbol(al->map, al->addr, filter);
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 357a85b85248..cbdeaad9c5e5 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -2,6 +2,7 @@
 #define __PERF_RECORD_H
 
 #include <limits.h>
+#include <stdio.h>
 
 #include "../perf.h"
 #include "map.h"
@@ -141,43 +142,54 @@ union perf_event {
 
 void perf_event__print_totals(void);
 
-struct perf_session;
+struct perf_tool;
 struct thread_map;
 
-typedef int (*perf_event__handler_synth_t)(union perf_event *event, 
-                                           struct perf_session *session);
-typedef int (*perf_event__handler_t)(union perf_event *event,
+typedef int (*perf_event__handler_t)(struct perf_tool *tool,
+                                     union perf_event *event,
                                      struct perf_sample *sample,
-                                      struct perf_session *session);
+                                     struct machine *machine);
 
-int perf_event__synthesize_thread_map(struct thread_map *threads,
+int perf_event__synthesize_thread_map(struct perf_tool *tool,
+                                      struct thread_map *threads,
                                       perf_event__handler_t process,
-                                      struct perf_session *session);
-int perf_event__synthesize_threads(perf_event__handler_t process,
-                                   struct perf_session *session);
-int perf_event__synthesize_kernel_mmap(perf_event__handler_t process,
-                                       struct perf_session *session,
+                                      struct machine *machine);
+int perf_event__synthesize_threads(struct perf_tool *tool,
+                                   perf_event__handler_t process,
+                                   struct machine *machine);
+int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
+                                       perf_event__handler_t process,
                                        struct machine *machine,
                                        const char *symbol_name);
 
-int perf_event__synthesize_modules(perf_event__handler_t process,
-                                   struct perf_session *session,
+int perf_event__synthesize_modules(struct perf_tool *tool,
+                                   perf_event__handler_t process,
                                    struct machine *machine);
 
-int perf_event__process_comm(union perf_event *event, struct perf_sample *sample,
-                             struct perf_session *session);
-int perf_event__process_lost(union perf_event *event, struct perf_sample *sample,
-                             struct perf_session *session);
-int perf_event__process_mmap(union perf_event *event, struct perf_sample *sample,
-                             struct perf_session *session);
-int perf_event__process_task(union perf_event *event, struct perf_sample *sample,
-                             struct perf_session *session);
-int perf_event__process(union perf_event *event, struct perf_sample *sample,
-                        struct perf_session *session);
+int perf_event__process_comm(struct perf_tool *tool,
+                             union perf_event *event,
+                             struct perf_sample *sample,
+                             struct machine *machine);
+int perf_event__process_lost(struct perf_tool *tool,
+                             union perf_event *event,
+                             struct perf_sample *sample,
+                             struct machine *machine);
+int perf_event__process_mmap(struct perf_tool *tool,
+                             union perf_event *event,
+                             struct perf_sample *sample,
+                             struct machine *machine);
+int perf_event__process_task(struct perf_tool *tool,
+                             union perf_event *event,
+                             struct perf_sample *sample,
+                             struct machine *machine);
+int perf_event__process(struct perf_tool *tool,
+                        union perf_event *event,
+                        struct perf_sample *sample,
+                        struct machine *machine);
 
 struct addr_location;
 int perf_event__preprocess_sample(const union perf_event *self,
-                                  struct perf_session *session,
+                                  struct machine *machine,
                                   struct addr_location *al,
                                   struct perf_sample *sample,
                                   symbol_filter_t filter);
@@ -187,5 +199,13 @@ const char *perf_event__name(unsigned int id);
 int perf_event__parse_sample(const union perf_event *event, u64 type,
                              int sample_size, bool sample_id_all,
                              struct perf_sample *sample, bool swapped);
+int perf_event__synthesize_sample(union perf_event *event, u64 type,
+                                  const struct perf_sample *sample,
+                                  bool swapped);
+
+size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp);
+size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp);
+size_t perf_event__fprintf_task(union perf_event *event, FILE *fp);
+size_t perf_event__fprintf(union perf_event *event, FILE *fp);
 
 #endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index fbb4b4ab9cc6..3f16e08a5c8d 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -6,12 +6,16 @@
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
+#include "util.h"
+#include "debugfs.h"
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
 #include "evlist.h"
 #include "evsel.h"
-#include "util.h"
+#include <unistd.h>
+
+#include "parse-events.h"
 
 #include <sys/mman.h>
 
@@ -30,6 +34,7 @@ void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
                 INIT_HLIST_HEAD(&evlist->heads[i]);
         INIT_LIST_HEAD(&evlist->entries);
         perf_evlist__set_maps(evlist, cpus, threads);
+        evlist->workload.pid = -1;
 }
 
 struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
@@ -43,6 +48,22 @@ struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
         return evlist;
 }
 
+void perf_evlist__config_attrs(struct perf_evlist *evlist,
+                               struct perf_record_opts *opts)
+{
+        struct perf_evsel *evsel;
+
+        if (evlist->cpus->map[0] < 0)
+                opts->no_inherit = true;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                perf_evsel__config(evsel, opts);
+
+                if (evlist->nr_entries > 1)
+                        evsel->attr.sample_type |= PERF_SAMPLE_ID;
+        }
+}
+
 static void perf_evlist__purge(struct perf_evlist *evlist)
 {
         struct perf_evsel *pos, *n;
@@ -76,14 +97,25 @@ void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
         ++evlist->nr_entries;
 }
 
+static void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
+                                          struct list_head *list,
+                                          int nr_entries)
+{
+        list_splice_tail(list, &evlist->entries);
+        evlist->nr_entries += nr_entries;
+}
+
 int perf_evlist__add_default(struct perf_evlist *evlist)
 {
         struct perf_event_attr attr = {
                 .type = PERF_TYPE_HARDWARE,
                 .config = PERF_COUNT_HW_CPU_CYCLES,
         };
-        struct perf_evsel *evsel = perf_evsel__new(&attr, 0);
+        struct perf_evsel *evsel;
 
+        event_attr_init(&attr);
+
+        evsel = perf_evsel__new(&attr, 0);
         if (evsel == NULL)
                 goto error;
 
@@ -100,6 +132,126 @@ error:
         return -ENOMEM;
 }
 
+int perf_evlist__add_attrs(struct perf_evlist *evlist,
+                           struct perf_event_attr *attrs, size_t nr_attrs)
+{
+        struct perf_evsel *evsel, *n;
+        LIST_HEAD(head);
+        size_t i;
+
+        for (i = 0; i < nr_attrs; i++) {
+                evsel = perf_evsel__new(attrs + i, evlist->nr_entries + i);
+                if (evsel == NULL)
+                        goto out_delete_partial_list;
+                list_add_tail(&evsel->node, &head);
+        }
+
+        perf_evlist__splice_list_tail(evlist, &head, nr_attrs);
+
+        return 0;
+
+out_delete_partial_list:
+        list_for_each_entry_safe(evsel, n, &head, node)
+                perf_evsel__delete(evsel);
+        return -1;
+}
+
+static int trace_event__id(const char *evname)
+{
+        char *filename, *colon;
+        int err = -1, fd;
+
+        if (asprintf(&filename, "%s/%s/id", tracing_events_path, evname) < 0)
+                return -1;
+
+        colon = strrchr(filename, ':');
+        if (colon != NULL)
+                *colon = '/';
+
+        fd = open(filename, O_RDONLY);
+        if (fd >= 0) {
+                char id[16];
+                if (read(fd, id, sizeof(id)) > 0)
+                        err = atoi(id);
+                close(fd);
+        }
+
+        free(filename);
+        return err;
+}
+
+int perf_evlist__add_tracepoints(struct perf_evlist *evlist,
+                                 const char *tracepoints[],
+                                 size_t nr_tracepoints)
+{
+        int err;
+        size_t i;
+        struct perf_event_attr *attrs = zalloc(nr_tracepoints * sizeof(*attrs));
+
+        if (attrs == NULL)
+                return -1;
+
+        for (i = 0; i < nr_tracepoints; i++) {
+                err = trace_event__id(tracepoints[i]);
+
+                if (err < 0)
+                        goto out_free_attrs;
+
+                attrs[i].type          = PERF_TYPE_TRACEPOINT;
+                attrs[i].config        = err;
+                attrs[i].sample_type   = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
+                                          PERF_SAMPLE_CPU);
+                attrs[i].sample_period = 1;
+        }
+
+        err = perf_evlist__add_attrs(evlist, attrs, nr_tracepoints);
+out_free_attrs:
+        free(attrs);
+        return err;
+}
+
+static struct perf_evsel *
+        perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
+                    (int)evsel->attr.config == id)
+                        return evsel;
+        }
+
+        return NULL;
+}
+
+int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
+                                          const struct perf_evsel_str_handler *assocs,
+                                          size_t nr_assocs)
+{
+        struct perf_evsel *evsel;
+        int err;
+        size_t i;
+
+        for (i = 0; i < nr_assocs; i++) {
+                err = trace_event__id(assocs[i].name);
+                if (err < 0)
+                        goto out;
+
+                evsel = perf_evlist__find_tracepoint_by_id(evlist, err);
+                if (evsel == NULL)
+                        continue;
+
+                err = -EEXIST;
+                if (evsel->handler.func != NULL)
+                        goto out;
+                evsel->handler.func = assocs[i].handler;
+        }
+
+        err = 0;
+out:
+        return err;
+}
+
 void perf_evlist__disable(struct perf_evlist *evlist)
 {
         int cpu, thread;
@@ -126,7 +278,7 @@ void perf_evlist__enable(struct perf_evlist *evlist)
         }
 }
 
-int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
+static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
         int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
         evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
@@ -282,7 +434,7 @@ void perf_evlist__munmap(struct perf_evlist *evlist)
         evlist->mmap = NULL;
 }
 
-int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
+static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
         evlist->nr_mmaps = evlist->cpus->nr;
         if (evlist->cpus->map[0] == -1)
@@ -298,8 +450,10 @@ static int __perf_evlist__mmap(struct perf_evlist *evlist,
         evlist->mmap[idx].mask = mask;
         evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
                                       MAP_SHARED, fd, 0);
-        if (evlist->mmap[idx].base == MAP_FAILED)
+        if (evlist->mmap[idx].base == MAP_FAILED) {
+                evlist->mmap[idx].base = NULL;
                 return -1;
+        }
 
         perf_evlist__add_pollfd(evlist, fd);
         return 0;
@@ -400,14 +554,22 @@ out_unmap:
  *
  * Using perf_evlist__read_on_cpu does this automatically.
  */
-int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite)
+int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
+                      bool overwrite)
 {
         unsigned int page_size = sysconf(_SC_PAGE_SIZE);
-        int mask = pages * page_size - 1;
         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);
+        int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), mask;
+
+        /* 512 kiB: default amount of unprivileged mlocked memory */
+        if (pages == UINT_MAX)
+                pages = (512 * 1024) / page_size;
+        else if (!is_power_of_2(pages))
+                return -EINVAL;
+
+        mask = pages * page_size - 1;
 
         if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
                 return -ENOMEM;
@@ -512,6 +674,38 @@ u64 perf_evlist__sample_type(const struct perf_evlist *evlist)
         return first->attr.sample_type;
 }
 
+u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist)
+{
+        struct perf_evsel *first;
+        struct perf_sample *data;
+        u64 sample_type;
+        u16 size = 0;
+
+        first = list_entry(evlist->entries.next, struct perf_evsel, node);
+
+        if (!first->attr.sample_id_all)
+                goto out;
+
+        sample_type = first->attr.sample_type;
+
+        if (sample_type & PERF_SAMPLE_TID)
+                size += sizeof(data->tid) * 2;
+
+       if (sample_type & PERF_SAMPLE_TIME)
+                size += sizeof(data->time);
+
+        if (sample_type & PERF_SAMPLE_ID)
+                size += sizeof(data->id);
+
+        if (sample_type & PERF_SAMPLE_STREAM_ID)
+                size += sizeof(data->stream_id);
+
+        if (sample_type & PERF_SAMPLE_CPU)
+                size += sizeof(data->cpu) * 2;
+out:
+        return size;
+}
+
 bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
 {
         struct perf_evsel *pos, *first;
@@ -569,3 +763,97 @@ out_err:
 
         return err;
 }
+
+int perf_evlist__prepare_workload(struct perf_evlist *evlist,
+                                  struct perf_record_opts *opts,
+                                  const char *argv[])
+{
+        int child_ready_pipe[2], go_pipe[2];
+        char bf;
+
+        if (pipe(child_ready_pipe) < 0) {
+                perror("failed to create 'ready' pipe");
+                return -1;
+        }
+
+        if (pipe(go_pipe) < 0) {
+                perror("failed to create 'go' pipe");
+                goto out_close_ready_pipe;
+        }
+
+        evlist->workload.pid = fork();
+        if (evlist->workload.pid < 0) {
+                perror("failed to fork");
+                goto out_close_pipes;
+        }
+
+        if (!evlist->workload.pid) {
+                if (opts->pipe_output)
+                        dup2(2, 1);
+
+                close(child_ready_pipe[0]);
+                close(go_pipe[1]);
+                fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+
+                /*
+                 * Do a dummy execvp to get the PLT entry resolved,
+                 * so we avoid the resolver overhead on the real
+                 * execvp call.
+                 */
+                execvp("", (char **)argv);
+
+                /*
+                 * Tell the parent we're ready to go
+                 */
+                close(child_ready_pipe[1]);
+
+                /*
+                 * Wait until the parent tells us to go.
+                 */
+                if (read(go_pipe[0], &bf, 1) == -1)
+                        perror("unable to read pipe");
+
+                execvp(argv[0], (char **)argv);
+
+                perror(argv[0]);
+                kill(getppid(), SIGUSR1);
+                exit(-1);
+        }
+
+        if (!opts->system_wide && opts->target_tid == -1 && opts->target_pid == -1)
+                evlist->threads->map[0] = evlist->workload.pid;
+
+        close(child_ready_pipe[1]);
+        close(go_pipe[0]);
+        /*
+         * wait for child to settle
+         */
+        if (read(child_ready_pipe[0], &bf, 1) == -1) {
+                perror("unable to read pipe");
+                goto out_close_pipes;
+        }
+
+        evlist->workload.cork_fd = go_pipe[1];
+        close(child_ready_pipe[0]);
+        return 0;
+
+out_close_pipes:
+        close(go_pipe[0]);
+        close(go_pipe[1]);
+out_close_ready_pipe:
+        close(child_ready_pipe[0]);
+        close(child_ready_pipe[1]);
+        return -1;
+}
+
+int perf_evlist__start_workload(struct perf_evlist *evlist)
+{
+        if (evlist->workload.cork_fd > 0) {
+                /*
+                 * Remove the cork, let it rip!
+                 */
+                return close(evlist->workload.cork_fd);
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 1779ffef7828..8922aeed0467 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -2,12 +2,16 @@
 #define __PERF_EVLIST_H 1
 
 #include <linux/list.h>
+#include <stdio.h>
 #include "../perf.h"
 #include "event.h"
+#include "util.h"
+#include <unistd.h>
 
 struct pollfd;
 struct thread_map;
 struct cpu_map;
+struct perf_record_opts;
 
 #define PERF_EVLIST__HLIST_BITS 8
 #define PERF_EVLIST__HLIST_SIZE (1 << PERF_EVLIST__HLIST_BITS)
@@ -19,6 +23,10 @@ struct perf_evlist {
         int              nr_fds;
         int              nr_mmaps;
         int              mmap_len;
+        struct {
+                int     cork_fd;
+                pid_t   pid;
+        } workload;
         bool             overwrite;
         union perf_event event_copy;
         struct perf_mmap *mmap;
@@ -28,6 +36,11 @@ struct perf_evlist {
         struct perf_evsel *selected;
 };
 
+struct perf_evsel_str_handler {
+        const char *name;
+        void       *handler;
+};
+
 struct perf_evsel;
 
 struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
@@ -39,11 +52,26 @@ void perf_evlist__delete(struct perf_evlist *evlist);
 
 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry);
 int perf_evlist__add_default(struct perf_evlist *evlist);
+int perf_evlist__add_attrs(struct perf_evlist *evlist,
+                           struct perf_event_attr *attrs, size_t nr_attrs);
+int perf_evlist__add_tracepoints(struct perf_evlist *evlist,
+                                 const char *tracepoints[], size_t nr_tracepoints);
+int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
+                                          const struct perf_evsel_str_handler *assocs,
+                                          size_t nr_assocs);
+
+#define perf_evlist__add_attrs_array(evlist, array) \
+        perf_evlist__add_attrs(evlist, array, ARRAY_SIZE(array))
+
+#define perf_evlist__add_tracepoints_array(evlist, array) \
+        perf_evlist__add_tracepoints(evlist, array, ARRAY_SIZE(array))
+
+#define perf_evlist__set_tracepoints_handlers_array(evlist, array) \
+        perf_evlist__set_tracepoints_handlers(evlist, array, ARRAY_SIZE(array))
 
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
                          int cpu, int thread, u64 id);
 
-int perf_evlist__alloc_pollfd(struct perf_evlist *evlist);
 void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd);
 
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
@@ -52,8 +80,16 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 
 int perf_evlist__open(struct perf_evlist *evlist, bool group);
 
-int perf_evlist__alloc_mmap(struct perf_evlist *evlist);
-int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite);
+void perf_evlist__config_attrs(struct perf_evlist *evlist,
+                               struct perf_record_opts *opts);
+
+int perf_evlist__prepare_workload(struct perf_evlist *evlist,
+                                  struct perf_record_opts *opts,
+                                  const char *argv[]);
+int perf_evlist__start_workload(struct perf_evlist *evlist);
+
+int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
+                      bool overwrite);
 void perf_evlist__munmap(struct perf_evlist *evlist);
 
 void perf_evlist__disable(struct perf_evlist *evlist);
@@ -77,6 +113,7 @@ int perf_evlist__set_filters(struct perf_evlist *evlist);
 
 u64 perf_evlist__sample_type(const struct perf_evlist *evlist);
 bool perf_evlist__sample_id_all(const const struct perf_evlist *evlist);
+u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist);
 
 bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist);
 bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist);
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index e42626422587..667f3b78bb2c 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -34,6 +34,16 @@ int __perf_evsel__sample_size(u64 sample_type)
         return size;
 }
 
+static void hists__init(struct hists *hists)
+{
+        memset(hists, 0, sizeof(*hists));
+        hists->entries_in_array[0] = hists->entries_in_array[1] = RB_ROOT;
+        hists->entries_in = &hists->entries_in_array[0];
+        hists->entries_collapsed = RB_ROOT;
+        hists->entries = RB_ROOT;
+        pthread_mutex_init(&hists->lock, NULL);
+}
+
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx)
 {
@@ -53,6 +63,79 @@ struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
         return evsel;
 }
 
+void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts)
+{
+        struct perf_event_attr *attr = &evsel->attr;
+        int track = !evsel->idx; /* only the first counter needs these */
+
+        attr->sample_id_all = opts->sample_id_all_avail ? 1 : 0;
+        attr->inherit       = !opts->no_inherit;
+        attr->read_format   = PERF_FORMAT_TOTAL_TIME_ENABLED |
+                              PERF_FORMAT_TOTAL_TIME_RUNNING |
+                              PERF_FORMAT_ID;
+
+        attr->sample_type  |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
+
+        /*
+         * We default some events to a 1 default interval. But keep
+         * it a weak assumption overridable by the user.
+         */
+        if (!attr->sample_period || (opts->user_freq != UINT_MAX &&
+                                     opts->user_interval != ULLONG_MAX)) {
+                if (opts->freq) {
+                        attr->sample_type       |= PERF_SAMPLE_PERIOD;
+                        attr->freq              = 1;
+                        attr->sample_freq       = opts->freq;
+                } else {
+                        attr->sample_period = opts->default_interval;
+                }
+        }
+
+        if (opts->no_samples)
+                attr->sample_freq = 0;
+
+        if (opts->inherit_stat)
+                attr->inherit_stat = 1;
+
+        if (opts->sample_address) {
+                attr->sample_type       |= PERF_SAMPLE_ADDR;
+                attr->mmap_data = track;
+        }
+
+        if (opts->call_graph)
+                attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
+
+        if (opts->system_wide)
+                attr->sample_type       |= PERF_SAMPLE_CPU;
+
+        if (opts->period)
+                attr->sample_type       |= PERF_SAMPLE_PERIOD;
+
+        if (opts->sample_id_all_avail &&
+            (opts->sample_time || opts->system_wide ||
+             !opts->no_inherit || opts->cpu_list))
+                attr->sample_type       |= PERF_SAMPLE_TIME;
+
+        if (opts->raw_samples) {
+                attr->sample_type       |= PERF_SAMPLE_TIME;
+                attr->sample_type       |= PERF_SAMPLE_RAW;
+                attr->sample_type       |= PERF_SAMPLE_CPU;
+        }
+
+        if (opts->no_delay) {
+                attr->watermark = 0;
+                attr->wakeup_events = 1;
+        }
+
+        attr->mmap = track;
+        attr->comm = track;
+
+        if (opts->target_pid == -1 && opts->target_tid == -1 && !opts->system_wide) {
+                attr->disabled = 1;
+                attr->enable_on_exec = 1;
+        }
+}
+
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
         int cpu, thread;
@@ -377,7 +460,7 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
                 u32 val32[2];
         } u;
 
-
+        memset(data, 0, sizeof(*data));
         data->cpu = data->pid = data->tid = -1;
         data->stream_id = data->id = data->time = -1ULL;
 
@@ -494,3 +577,82 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
 
         return 0;
 }
+
+int perf_event__synthesize_sample(union perf_event *event, u64 type,
+                                  const struct perf_sample *sample,
+                                  bool swapped)
+{
+        u64 *array;
+
+        /*
+         * used for cross-endian analysis. See git commit 65014ab3
+         * for why this goofiness is needed.
+         */
+        union {
+                u64 val64;
+                u32 val32[2];
+        } u;
+
+        array = event->sample.array;
+
+        if (type & PERF_SAMPLE_IP) {
+                event->ip.ip = sample->ip;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_TID) {
+                u.val32[0] = sample->pid;
+                u.val32[1] = sample->tid;
+                if (swapped) {
+                        /*
+                         * Inverse of what is done in perf_event__parse_sample
+                         */
+                        u.val32[0] = bswap_32(u.val32[0]);
+                        u.val32[1] = bswap_32(u.val32[1]);
+                        u.val64 = bswap_64(u.val64);
+                }
+
+                *array = u.val64;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_TIME) {
+                *array = sample->time;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_ADDR) {
+                *array = sample->addr;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_ID) {
+                *array = sample->id;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_STREAM_ID) {
+                *array = sample->stream_id;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_CPU) {
+                u.val32[0] = sample->cpu;
+                if (swapped) {
+                        /*
+                         * Inverse of what is done in perf_event__parse_sample
+                         */
+                        u.val32[0] = bswap_32(u.val32[0]);
+                        u.val64 = bswap_64(u.val64);
+                }
+                *array = u.val64;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_PERIOD) {
+                *array = sample->period;
+                array++;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index b1d15e6f7ae3..326b8e4d5035 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -61,12 +61,17 @@ struct perf_evsel {
                 off_t           id_offset;
         };
         struct cgroup_sel       *cgrp;
+        struct {
+                void            *func;
+                void            *data;
+        } handler;
         bool                    supported;
 };
 
 struct cpu_map;
 struct thread_map;
 struct perf_evlist;
+struct perf_record_opts;
 
 struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx);
 void perf_evsel__init(struct perf_evsel *evsel,
@@ -74,6 +79,9 @@ void perf_evsel__init(struct perf_evsel *evsel,
 void perf_evsel__exit(struct perf_evsel *evsel);
 void perf_evsel__delete(struct perf_evsel *evsel);
 
+void perf_evsel__config(struct perf_evsel *evsel,
+                        struct perf_record_opts *opts);
+
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads);
 int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index bcd05d05b4f0..3e7e0b09c12c 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
+#include <linux/bitops.h>
 #include <sys/utsname.h>
 
 #include "evlist.h"
@@ -28,9 +29,6 @@ static struct perf_trace_event_type *events;
 static u32 header_argc;
 static const char **header_argv;
 
-static int dsos__write_buildid_table(struct perf_header *header, int fd);
-static int perf_session__cache_build_ids(struct perf_session *session);
-
 int perf_header__push_event(u64 id, const char *name)
 {
         if (strlen(name) > MAX_EVENT_NAME)
@@ -187,6 +185,252 @@ perf_header__set_cmdline(int argc, const char **argv)
         return 0;
 }
 
+#define dsos__for_each_with_build_id(pos, head) \
+        list_for_each_entry(pos, head, node)    \
+                if (!pos->has_build_id)         \
+                        continue;               \
+                else
+
+static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
+                                u16 misc, int fd)
+{
+        struct dso *pos;
+
+        dsos__for_each_with_build_id(pos, head) {
+                int err;
+                struct build_id_event b;
+                size_t len;
+
+                if (!pos->hit)
+                        continue;
+                len = pos->long_name_len + 1;
+                len = ALIGN(len, NAME_ALIGN);
+                memset(&b, 0, sizeof(b));
+                memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
+                b.pid = pid;
+                b.header.misc = misc;
+                b.header.size = sizeof(b) + len;
+                err = do_write(fd, &b, sizeof(b));
+                if (err < 0)
+                        return err;
+                err = write_padded(fd, pos->long_name,
+                                   pos->long_name_len + 1, len);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int machine__write_buildid_table(struct machine *machine, int fd)
+{
+        int err;
+        u16 kmisc = PERF_RECORD_MISC_KERNEL,
+            umisc = PERF_RECORD_MISC_USER;
+
+        if (!machine__is_host(machine)) {
+                kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
+                umisc = PERF_RECORD_MISC_GUEST_USER;
+        }
+
+        err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
+                                          kmisc, fd);
+        if (err == 0)
+                err = __dsos__write_buildid_table(&machine->user_dsos,
+                                                  machine->pid, umisc, fd);
+        return err;
+}
+
+static int dsos__write_buildid_table(struct perf_header *header, int fd)
+{
+        struct perf_session *session = container_of(header,
+                        struct perf_session, header);
+        struct rb_node *nd;
+        int err = machine__write_buildid_table(&session->host_machine, fd);
+
+        if (err)
+                return err;
+
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                err = machine__write_buildid_table(pos, fd);
+                if (err)
+                        break;
+        }
+        return err;
+}
+
+int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+                          const char *name, bool is_kallsyms)
+{
+        const size_t size = PATH_MAX;
+        char *realname, *filename = zalloc(size),
+             *linkname = zalloc(size), *targetname;
+        int len, err = -1;
+
+        if (is_kallsyms) {
+                if (symbol_conf.kptr_restrict) {
+                        pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
+                        return 0;
+                }
+                realname = (char *)name;
+        } else
+                realname = realpath(name, NULL);
+
+        if (realname == NULL || filename == NULL || linkname == NULL)
+                goto out_free;
+
+        len = snprintf(filename, size, "%s%s%s",
+                       debugdir, is_kallsyms ? "/" : "", realname);
+        if (mkdir_p(filename, 0755))
+                goto out_free;
+
+        snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
+
+        if (access(filename, F_OK)) {
+                if (is_kallsyms) {
+                         if (copyfile("/proc/kallsyms", filename))
+                                goto out_free;
+                } else if (link(realname, filename) && copyfile(name, filename))
+                        goto out_free;
+        }
+
+        len = snprintf(linkname, size, "%s/.build-id/%.2s",
+                       debugdir, sbuild_id);
+
+        if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
+                goto out_free;
+
+        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
+        targetname = filename + strlen(debugdir) - 5;
+        memcpy(targetname, "../..", 5);
+
+        if (symlink(targetname, linkname) == 0)
+                err = 0;
+out_free:
+        if (!is_kallsyms)
+                free(realname);
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
+                                 const char *name, const char *debugdir,
+                                 bool is_kallsyms)
+{
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        build_id__sprintf(build_id, build_id_size, sbuild_id);
+
+        return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
+}
+
+int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
+{
+        const size_t size = PATH_MAX;
+        char *filename = zalloc(size),
+             *linkname = zalloc(size);
+        int err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, sbuild_id + 2);
+
+        if (access(linkname, F_OK))
+                goto out_free;
+
+        if (readlink(linkname, filename, size - 1) < 0)
+                goto out_free;
+
+        if (unlink(linkname))
+                goto out_free;
+
+        /*
+         * Since the link is relative, we must make it absolute:
+         */
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, filename);
+
+        if (unlink(linkname))
+                goto out_free;
+
+        err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int dso__cache_build_id(struct dso *dso, const char *debugdir)
+{
+        bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
+
+        return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
+                                     dso->long_name, debugdir, is_kallsyms);
+}
+
+static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
+{
+        struct dso *pos;
+        int err = 0;
+
+        dsos__for_each_with_build_id(pos, head)
+                if (dso__cache_build_id(pos, debugdir))
+                        err = -1;
+
+        return err;
+}
+
+static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
+{
+        int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
+        ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
+        return ret;
+}
+
+static int perf_session__cache_build_ids(struct perf_session *session)
+{
+        struct rb_node *nd;
+        int ret;
+        char debugdir[PATH_MAX];
+
+        snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
+
+        if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
+                return -1;
+
+        ret = machine__cache_build_ids(&session->host_machine, debugdir);
+
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret |= machine__cache_build_ids(pos, debugdir);
+        }
+        return ret ? -1 : 0;
+}
+
+static bool machine__read_build_ids(struct machine *machine, bool with_hits)
+{
+        bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
+        ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
+        return ret;
+}
+
+static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
+{
+        struct rb_node *nd;
+        bool ret = machine__read_build_ids(&session->host_machine, with_hits);
+
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret |= machine__read_build_ids(pos, with_hits);
+        }
+
+        return ret;
+}
+
 static int write_trace_info(int fd, struct perf_header *h __used,
                             struct perf_evlist *evlist)
 {
@@ -202,6 +446,9 @@ static int write_build_id(int fd, struct perf_header *h,
 
         session = container_of(h, struct perf_session, header);
 
+        if (!perf_session__read_build_ids(session, true))
+                return -1;
+
         err = dsos__write_buildid_table(h, fd);
         if (err < 0) {
                 pr_debug("failed to write buildid table\n");
@@ -388,7 +635,7 @@ static int write_event_desc(int fd, struct perf_header *h __used,
                 /*
                  * write event string as passed on cmdline
                  */
-                ret = do_write_string(fd, attr->name);
+                ret = do_write_string(fd, event_name(attr));
                 if (ret < 0)
                         return ret;
                 /*
@@ -1065,26 +1312,30 @@ struct feature_ops {
         bool full_only;
 };
 
-#define FEAT_OPA(n, w, p) \
-        [n] = { .name = #n, .write = w, .print = p }
-#define FEAT_OPF(n, w, p) \
-        [n] = { .name = #n, .write = w, .print = p, .full_only = true }
+#define FEAT_OPA(n, func) \
+        [n] = { .name = #n, .write = write_##func, .print = print_##func }
+#define FEAT_OPF(n, func) \
+        [n] = { .name = #n, .write = write_##func, .print = print_##func, .full_only = true }
+
+/* feature_ops not implemented: */
+#define print_trace_info                NULL
+#define print_build_id                  NULL
 
 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
-        FEAT_OPA(HEADER_TRACE_INFO, write_trace_info, NULL),
-        FEAT_OPA(HEADER_BUILD_ID, write_build_id, NULL),
-        FEAT_OPA(HEADER_HOSTNAME, write_hostname, print_hostname),
-        FEAT_OPA(HEADER_OSRELEASE, write_osrelease, print_osrelease),
-        FEAT_OPA(HEADER_VERSION, write_version, print_version),
-        FEAT_OPA(HEADER_ARCH, write_arch, print_arch),
-        FEAT_OPA(HEADER_NRCPUS, write_nrcpus, print_nrcpus),
-        FEAT_OPA(HEADER_CPUDESC, write_cpudesc, print_cpudesc),
-        FEAT_OPA(HEADER_CPUID, write_cpuid, print_cpuid),
-        FEAT_OPA(HEADER_TOTAL_MEM, write_total_mem, print_total_mem),
-        FEAT_OPA(HEADER_EVENT_DESC, write_event_desc, print_event_desc),
-        FEAT_OPA(HEADER_CMDLINE, write_cmdline, print_cmdline),
-        FEAT_OPF(HEADER_CPU_TOPOLOGY, write_cpu_topology, print_cpu_topology),
-        FEAT_OPF(HEADER_NUMA_TOPOLOGY, write_numa_topology, print_numa_topology),
+        FEAT_OPA(HEADER_TRACE_INFO,     trace_info),
+        FEAT_OPA(HEADER_BUILD_ID,       build_id),
+        FEAT_OPA(HEADER_HOSTNAME,       hostname),
+        FEAT_OPA(HEADER_OSRELEASE,      osrelease),
+        FEAT_OPA(HEADER_VERSION,        version),
+        FEAT_OPA(HEADER_ARCH,           arch),
+        FEAT_OPA(HEADER_NRCPUS,         nrcpus),
+        FEAT_OPA(HEADER_CPUDESC,        cpudesc),
+        FEAT_OPA(HEADER_CPUID,          cpuid),
+        FEAT_OPA(HEADER_TOTAL_MEM,      total_mem),
+        FEAT_OPA(HEADER_EVENT_DESC,     event_desc),
+        FEAT_OPA(HEADER_CMDLINE,        cmdline),
+        FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
+        FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
 };
 
 struct header_print_data {
@@ -1103,9 +1354,9 @@ static int perf_file_section__fprintf_info(struct perf_file_section *section,
                                 "%d, continuing...\n", section->offset, feat);
                 return 0;
         }
-        if (feat < HEADER_TRACE_INFO || feat >= HEADER_LAST_FEATURE) {
+        if (feat >= HEADER_LAST_FEATURE) {
                 pr_warning("unknown feature %d\n", feat);
-                return -1;
+                return 0;
         }
         if (!feat_ops[feat].print)
                 return 0;
@@ -1132,252 +1383,6 @@ int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
         return 0;
 }
 
-#define dsos__for_each_with_build_id(pos, head) \
-        list_for_each_entry(pos, head, node)    \
-                if (!pos->has_build_id)         \
-                        continue;               \
-                else
-
-static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
-                                u16 misc, int fd)
-{
-        struct dso *pos;
-
-        dsos__for_each_with_build_id(pos, head) {
-                int err;
-                struct build_id_event b;
-                size_t len;
-
-                if (!pos->hit)
-                        continue;
-                len = pos->long_name_len + 1;
-                len = ALIGN(len, NAME_ALIGN);
-                memset(&b, 0, sizeof(b));
-                memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
-                b.pid = pid;
-                b.header.misc = misc;
-                b.header.size = sizeof(b) + len;
-                err = do_write(fd, &b, sizeof(b));
-                if (err < 0)
-                        return err;
-                err = write_padded(fd, pos->long_name,
-                                   pos->long_name_len + 1, len);
-                if (err < 0)
-                        return err;
-        }
-
-        return 0;
-}
-
-static int machine__write_buildid_table(struct machine *machine, int fd)
-{
-        int err;
-        u16 kmisc = PERF_RECORD_MISC_KERNEL,
-            umisc = PERF_RECORD_MISC_USER;
-
-        if (!machine__is_host(machine)) {
-                kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
-                umisc = PERF_RECORD_MISC_GUEST_USER;
-        }
-
-        err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
-                                          kmisc, fd);
-        if (err == 0)
-                err = __dsos__write_buildid_table(&machine->user_dsos,
-                                                  machine->pid, umisc, fd);
-        return err;
-}
-
-static int dsos__write_buildid_table(struct perf_header *header, int fd)
-{
-        struct perf_session *session = container_of(header,
-                        struct perf_session, header);
-        struct rb_node *nd;
-        int err = machine__write_buildid_table(&session->host_machine, fd);
-
-        if (err)
-                return err;
-
-        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
-                struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                err = machine__write_buildid_table(pos, fd);
-                if (err)
-                        break;
-        }
-        return err;
-}
-
-int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
-                          const char *name, bool is_kallsyms)
-{
-        const size_t size = PATH_MAX;
-        char *realname, *filename = zalloc(size),
-             *linkname = zalloc(size), *targetname;
-        int len, err = -1;
-
-        if (is_kallsyms) {
-                if (symbol_conf.kptr_restrict) {
-                        pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
-                        return 0;
-                }
-                realname = (char *)name;
-        } else
-                realname = realpath(name, NULL);
-
-        if (realname == NULL || filename == NULL || linkname == NULL)
-                goto out_free;
-
-        len = snprintf(filename, size, "%s%s%s",
-                       debugdir, is_kallsyms ? "/" : "", realname);
-        if (mkdir_p(filename, 0755))
-                goto out_free;
-
-        snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
-
-        if (access(filename, F_OK)) {
-                if (is_kallsyms) {
-                         if (copyfile("/proc/kallsyms", filename))
-                                goto out_free;
-                } else if (link(realname, filename) && copyfile(name, filename))
-                        goto out_free;
-        }
-
-        len = snprintf(linkname, size, "%s/.build-id/%.2s",
-                       debugdir, sbuild_id);
-
-        if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
-                goto out_free;
-
-        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
-        targetname = filename + strlen(debugdir) - 5;
-        memcpy(targetname, "../..", 5);
-
-        if (symlink(targetname, linkname) == 0)
-                err = 0;
-out_free:
-        if (!is_kallsyms)
-                free(realname);
-        free(filename);
-        free(linkname);
-        return err;
-}
-
-static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
-                                 const char *name, const char *debugdir,
-                                 bool is_kallsyms)
-{
-        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
-
-        build_id__sprintf(build_id, build_id_size, sbuild_id);
-
-        return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
-}
-
-int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
-{
-        const size_t size = PATH_MAX;
-        char *filename = zalloc(size),
-             *linkname = zalloc(size);
-        int err = -1;
-
-        if (filename == NULL || linkname == NULL)
-                goto out_free;
-
-        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
-                 debugdir, sbuild_id, sbuild_id + 2);
-
-        if (access(linkname, F_OK))
-                goto out_free;
-
-        if (readlink(linkname, filename, size - 1) < 0)
-                goto out_free;
-
-        if (unlink(linkname))
-                goto out_free;
-
-        /*
-         * Since the link is relative, we must make it absolute:
-         */
-        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
-                 debugdir, sbuild_id, filename);
-
-        if (unlink(linkname))
-                goto out_free;
-
-        err = 0;
-out_free:
-        free(filename);
-        free(linkname);
-        return err;
-}
-
-static int dso__cache_build_id(struct dso *dso, const char *debugdir)
-{
-        bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
-
-        return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
-                                     dso->long_name, debugdir, is_kallsyms);
-}
-
-static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
-{
-        struct dso *pos;
-        int err = 0;
-
-        dsos__for_each_with_build_id(pos, head)
-                if (dso__cache_build_id(pos, debugdir))
-                        err = -1;
-
-        return err;
-}
-
-static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
-{
-        int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
-        ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
-        return ret;
-}
-
-static int perf_session__cache_build_ids(struct perf_session *session)
-{
-        struct rb_node *nd;
-        int ret;
-        char debugdir[PATH_MAX];
-
-        snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
-
-        if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
-                return -1;
-
-        ret = machine__cache_build_ids(&session->host_machine, debugdir);
-
-        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
-                struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                ret |= machine__cache_build_ids(pos, debugdir);
-        }
-        return ret ? -1 : 0;
-}
-
-static bool machine__read_build_ids(struct machine *machine, bool with_hits)
-{
-        bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
-        ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
-        return ret;
-}
-
-static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
-{
-        struct rb_node *nd;
-        bool ret = machine__read_build_ids(&session->host_machine, with_hits);
-
-        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
-                struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                ret |= machine__read_build_ids(pos, with_hits);
-        }
-
-        return ret;
-}
-
 static int do_write_feat(int fd, struct perf_header *h, int type,
                          struct perf_file_section **p,
                          struct perf_evlist *evlist)
@@ -1386,6 +1391,8 @@ static int do_write_feat(int fd, struct perf_header *h, int type,
         int ret = 0;
 
         if (perf_header__has_feat(h, type)) {
+                if (!feat_ops[type].write)
+                        return -1;
 
                 (*p)->offset = lseek(fd, 0, SEEK_CUR);
 
@@ -1408,18 +1415,12 @@ static int perf_header__adds_write(struct perf_header *header,
                                    struct perf_evlist *evlist, int fd)
 {
         int nr_sections;
-        struct perf_session *session;
         struct perf_file_section *feat_sec, *p;
         int sec_size;
         u64 sec_start;
+        int feat;
         int err;
 
-        session = container_of(header, struct perf_session, header);
-
-        if (perf_header__has_feat(header, HEADER_BUILD_ID &&
-            !perf_session__read_build_ids(session, true)))
-                perf_header__clear_feat(header, HEADER_BUILD_ID);
-
         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
         if (!nr_sections)
                 return 0;
@@ -1433,64 +1434,11 @@ static int perf_header__adds_write(struct perf_header *header,
         sec_start = header->data_offset + header->data_size;
         lseek(fd, sec_start + sec_size, SEEK_SET);
 
-        err = do_write_feat(fd, header, HEADER_TRACE_INFO, &p, evlist);
-        if (err)
-                goto out_free;
-
-        err = do_write_feat(fd, header, HEADER_BUILD_ID, &p, evlist);
-        if (err) {
-                perf_header__clear_feat(header, HEADER_BUILD_ID);
-                goto out_free;
+        for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
+                if (do_write_feat(fd, header, feat, &p, evlist))
+                        perf_header__clear_feat(header, feat);
         }
 
-        err = do_write_feat(fd, header, HEADER_HOSTNAME, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_HOSTNAME);
-
-        err = do_write_feat(fd, header, HEADER_OSRELEASE, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_OSRELEASE);
-
-        err = do_write_feat(fd, header, HEADER_VERSION, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_VERSION);
-
-        err = do_write_feat(fd, header, HEADER_ARCH, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_ARCH);
-
-        err = do_write_feat(fd, header, HEADER_NRCPUS, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_NRCPUS);
-
-        err = do_write_feat(fd, header, HEADER_CPUDESC, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_CPUDESC);
-
-        err = do_write_feat(fd, header, HEADER_CPUID, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_CPUID);
-
-        err = do_write_feat(fd, header, HEADER_TOTAL_MEM, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_TOTAL_MEM);
-
-        err = do_write_feat(fd, header, HEADER_CMDLINE, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_CMDLINE);
-
-        err = do_write_feat(fd, header, HEADER_EVENT_DESC, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_EVENT_DESC);
-
-        err = do_write_feat(fd, header, HEADER_CPU_TOPOLOGY, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_CPU_TOPOLOGY);
-
-        err = do_write_feat(fd, header, HEADER_NUMA_TOPOLOGY, &p, evlist);
-        if (err)
-                perf_header__clear_feat(header, HEADER_NUMA_TOPOLOGY);
-
         lseek(fd, sec_start, SEEK_SET);
         /*
          * may write more than needed due to dropped feature, but
@@ -1499,7 +1447,6 @@ static int perf_header__adds_write(struct perf_header *header,
         err = do_write(fd, feat_sec, sec_size);
         if (err < 0)
                 pr_debug("failed to write feature section\n");
-out_free:
         free(feat_sec);
         return err;
 }
@@ -1637,20 +1584,20 @@ static int perf_header__getbuffer64(struct perf_header *header,
 int perf_header__process_sections(struct perf_header *header, int fd,
                                   void *data,
                                   int (*process)(struct perf_file_section *section,
-                                  struct perf_header *ph,
-                                  int feat, int fd, void *data))
+                                                 struct perf_header *ph,
+                                                 int feat, int fd, void *data))
 {
-        struct perf_file_section *feat_sec;
+        struct perf_file_section *feat_sec, *sec;
         int nr_sections;
         int sec_size;
-        int idx = 0;
-        int err = -1, feat = 1;
+        int feat;
+        int err;
 
         nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
         if (!nr_sections)
                 return 0;
 
-        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        feat_sec = sec = calloc(sizeof(*feat_sec), nr_sections);
         if (!feat_sec)
                 return -1;
 
@@ -1658,20 +1605,16 @@ int perf_header__process_sections(struct perf_header *header, int fd,
 
         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
 
-        if (perf_header__getbuffer64(header, fd, feat_sec, sec_size))
+        err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
+        if (err < 0)
                 goto out_free;
 
-        err = 0;
-        while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
-                if (perf_header__has_feat(header, feat)) {
-                        struct perf_file_section *sec = &feat_sec[idx++];
-
-                        err = process(sec, header, feat, fd, data);
-                        if (err < 0)
-                                break;
-                }
-                ++feat;
+        for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
+                err = process(sec++, header, feat, fd, data);
+                if (err < 0)
+                        goto out_free;
         }
+        err = 0;
 out_free:
         free(feat_sec);
         return err;
@@ -1906,32 +1849,21 @@ static int perf_file_section__process(struct perf_file_section *section,
                 return 0;
         }
 
+        if (feat >= HEADER_LAST_FEATURE) {
+                pr_debug("unknown feature %d, continuing...\n", feat);
+                return 0;
+        }
+
         switch (feat) {
         case HEADER_TRACE_INFO:
                 trace_report(fd, false);
                 break;
-
         case HEADER_BUILD_ID:
                 if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
                         pr_debug("Failed to read buildids, continuing...\n");
                 break;
-
-        case HEADER_HOSTNAME:
-        case HEADER_OSRELEASE:
-        case HEADER_VERSION:
-        case HEADER_ARCH:
-        case HEADER_NRCPUS:
-        case HEADER_CPUDESC:
-        case HEADER_CPUID:
-        case HEADER_TOTAL_MEM:
-        case HEADER_CMDLINE:
-        case HEADER_EVENT_DESC:
-        case HEADER_CPU_TOPOLOGY:
-        case HEADER_NUMA_TOPOLOGY:
-                break;
-
         default:
-                pr_debug("unknown feature %d, continuing...\n", feat);
+                break;
         }
 
         return 0;
@@ -2041,6 +1973,8 @@ int perf_session__read_header(struct perf_session *session, int fd)
                 lseek(fd, tmp, SEEK_SET);
         }
 
+        symbol_conf.nr_events = nr_attrs;
+
         if (f_header.event_types.size) {
                 lseek(fd, f_header.event_types.offset, SEEK_SET);
                 events = malloc(f_header.event_types.size);
@@ -2068,9 +2002,9 @@ out_delete_evlist:
         return -ENOMEM;
 }
 
-int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
-                                perf_event__handler_t process,
-                                struct perf_session *session)
+int perf_event__synthesize_attr(struct perf_tool *tool,
+                                struct perf_event_attr *attr, u16 ids, u64 *id,
+                                perf_event__handler_t process)
 {
         union perf_event *ev;
         size_t size;
@@ -2092,22 +2026,23 @@ int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
         ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
         ev->attr.header.size = size;
 
-        err = process(ev, NULL, session);
+        err = process(tool, ev, NULL, NULL);
 
         free(ev);
 
         return err;
 }
 
-int perf_session__synthesize_attrs(struct perf_session *session,
+int perf_event__synthesize_attrs(struct perf_tool *tool,
+                                   struct perf_session *session,
                                    perf_event__handler_t process)
 {
         struct perf_evsel *attr;
         int err = 0;
 
         list_for_each_entry(attr, &session->evlist->entries, node) {
-                err = perf_event__synthesize_attr(&attr->attr, attr->ids,
-                                                  attr->id, process, session);
+                err = perf_event__synthesize_attr(tool, &attr->attr, attr->ids,
+                                                  attr->id, process);
                 if (err) {
                         pr_debug("failed to create perf header attribute\n");
                         return err;
@@ -2118,23 +2053,23 @@ int perf_session__synthesize_attrs(struct perf_session *session,
 }
 
 int perf_event__process_attr(union perf_event *event,
-                             struct perf_session *session)
+                             struct perf_evlist **pevlist)
 {
         unsigned int i, ids, n_ids;
         struct perf_evsel *evsel;
+        struct perf_evlist *evlist = *pevlist;
 
-        if (session->evlist == NULL) {
-                session->evlist = perf_evlist__new(NULL, NULL);
-                if (session->evlist == NULL)
+        if (evlist == NULL) {
+                *pevlist = evlist = perf_evlist__new(NULL, NULL);
+                if (evlist == NULL)
                         return -ENOMEM;
         }
 
-        evsel = perf_evsel__new(&event->attr.attr,
-                                session->evlist->nr_entries);
+        evsel = perf_evsel__new(&event->attr.attr, evlist->nr_entries);
         if (evsel == NULL)
                 return -ENOMEM;
 
-        perf_evlist__add(session->evlist, evsel);
+        perf_evlist__add(evlist, evsel);
 
         ids = event->header.size;
         ids -= (void *)&event->attr.id - (void *)event;
@@ -2148,18 +2083,16 @@ int perf_event__process_attr(union perf_event *event,
                 return -ENOMEM;
 
         for (i = 0; i < n_ids; i++) {
-                perf_evlist__id_add(session->evlist, evsel, 0, i,
-                                    event->attr.id[i]);
+                perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
         }
 
-        perf_session__update_sample_type(session);
-
         return 0;
 }
 
-int perf_event__synthesize_event_type(u64 event_id, char *name,
+int perf_event__synthesize_event_type(struct perf_tool *tool,
+                                      u64 event_id, char *name,
                                       perf_event__handler_t process,
-                                      struct perf_session *session)
+                                      struct machine *machine)
 {
         union perf_event ev;
         size_t size = 0;
@@ -2177,13 +2110,14 @@ int perf_event__synthesize_event_type(u64 event_id, char *name,
         ev.event_type.header.size = sizeof(ev.event_type) -
                 (sizeof(ev.event_type.event_type.name) - size);
 
-        err = process(&ev, NULL, session);
+        err = process(tool, &ev, NULL, machine);
 
         return err;
 }
 
-int perf_event__synthesize_event_types(perf_event__handler_t process,
-                                       struct perf_session *session)
+int perf_event__synthesize_event_types(struct perf_tool *tool,
+                                       perf_event__handler_t process,
+                                       struct machine *machine)
 {
         struct perf_trace_event_type *type;
         int i, err = 0;
@@ -2191,9 +2125,9 @@ int perf_event__synthesize_event_types(perf_event__handler_t process,
         for (i = 0; i < event_count; i++) {
                 type = &events[i];
 
-                err = perf_event__synthesize_event_type(type->event_id,
+                err = perf_event__synthesize_event_type(tool, type->event_id,
                                                         type->name, process,
-                                                        session);
+                                                        machine);
                 if (err) {
                         pr_debug("failed to create perf header event type\n");
                         return err;
@@ -2203,8 +2137,8 @@ int perf_event__synthesize_event_types(perf_event__handler_t process,
         return err;
 }
 
-int perf_event__process_event_type(union perf_event *event,
-                                   struct perf_session *session __unused)
+int perf_event__process_event_type(struct perf_tool *tool __unused,
+                                   union perf_event *event)
 {
         if (perf_header__push_event(event->event_type.event_type.event_id,
                                     event->event_type.event_type.name) < 0)
@@ -2213,9 +2147,9 @@ int perf_event__process_event_type(union perf_event *event,
         return 0;
 }
 
-int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
-                                         perf_event__handler_t process,
-                                   struct perf_session *session __unused)
+int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
+                                        struct perf_evlist *evlist,
+                                        perf_event__handler_t process)
 {
         union perf_event ev;
         struct tracing_data *tdata;
@@ -2246,7 +2180,7 @@ int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
         ev.tracing_data.header.size = sizeof(ev.tracing_data);
         ev.tracing_data.size = aligned_size;
 
-        process(&ev, NULL, session);
+        process(tool, &ev, NULL, NULL);
 
         /*
          * The put function will copy all the tracing data
@@ -2288,10 +2222,10 @@ int perf_event__process_tracing_data(union perf_event *event,
         return size_read + padding;
 }
 
-int perf_event__synthesize_build_id(struct dso *pos, u16 misc,
+int perf_event__synthesize_build_id(struct perf_tool *tool,
+                                    struct dso *pos, u16 misc,
                                     perf_event__handler_t process,
-                                    struct machine *machine,
-                                    struct perf_session *session)
+                                    struct machine *machine)
 {
         union perf_event ev;
         size_t len;
@@ -2311,12 +2245,13 @@ int perf_event__synthesize_build_id(struct dso *pos, u16 misc,
         ev.build_id.header.size = sizeof(ev.build_id) + len;
         memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
 
-        err = process(&ev, NULL, session);
+        err = process(tool, &ev, NULL, machine);
 
         return err;
 }
 
-int perf_event__process_build_id(union perf_event *event,
+int perf_event__process_build_id(struct perf_tool *tool __used,
+                                 union perf_event *event,
                                  struct perf_session *session)
 {
         __event_process_build_id(&event->build_id,
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 3d5a742f4a2a..ac4ec956024e 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -10,7 +10,8 @@
 #include <linux/bitmap.h>
 
 enum {
-        HEADER_TRACE_INFO = 1,
+        HEADER_RESERVED         = 0,    /* always cleared */
+        HEADER_TRACE_INFO       = 1,
         HEADER_BUILD_ID,
 
         HEADER_HOSTNAME,
@@ -27,10 +28,9 @@ enum {
         HEADER_NUMA_TOPOLOGY,
 
         HEADER_LAST_FEATURE,
+        HEADER_FEAT_BITS        = 256,
 };
 
-#define HEADER_FEAT_BITS                        256
-
 struct perf_file_section {
         u64 offset;
         u64 size;
@@ -68,6 +68,7 @@ struct perf_header {
 };
 
 struct perf_evlist;
+struct perf_session;
 
 int perf_session__read_header(struct perf_session *session, int fd);
 int perf_session__write_header(struct perf_session *session,
@@ -96,32 +97,36 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                           const char *name, bool is_kallsyms);
 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
 
-int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
-                                perf_event__handler_t process,
-                                struct perf_session *session);
-int perf_session__synthesize_attrs(struct perf_session *session,
-                                   perf_event__handler_t process);
-int perf_event__process_attr(union perf_event *event, struct perf_session *session);
+int perf_event__synthesize_attr(struct perf_tool *tool,
+                                struct perf_event_attr *attr, u16 ids, u64 *id,
+                                perf_event__handler_t process);
+int perf_event__synthesize_attrs(struct perf_tool *tool,
+                                 struct perf_session *session,
+                                 perf_event__handler_t process);
+int perf_event__process_attr(union perf_event *event, struct perf_evlist **pevlist);
 
-int perf_event__synthesize_event_type(u64 event_id, char *name,
+int perf_event__synthesize_event_type(struct perf_tool *tool,
+                                      u64 event_id, char *name,
                                       perf_event__handler_t process,
-                                      struct perf_session *session);
-int perf_event__synthesize_event_types(perf_event__handler_t process,
-                                       struct perf_session *session);
-int perf_event__process_event_type(union perf_event *event,
-                                   struct perf_session *session);
-
-int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
-                                        perf_event__handler_t process,
-                                        struct perf_session *session);
+                                      struct machine *machine);
+int perf_event__synthesize_event_types(struct perf_tool *tool,
+                                       perf_event__handler_t process,
+                                       struct machine *machine);
+int perf_event__process_event_type(struct perf_tool *tool,
+                                   union perf_event *event);
+
+int perf_event__synthesize_tracing_data(struct perf_tool *tool,
+                                        int fd, struct perf_evlist *evlist,
+                                        perf_event__handler_t process);
 int perf_event__process_tracing_data(union perf_event *event,
                                      struct perf_session *session);
 
-int perf_event__synthesize_build_id(struct dso *pos, u16 misc,
+int perf_event__synthesize_build_id(struct perf_tool *tool,
+                                    struct dso *pos, u16 misc,
                                     perf_event__handler_t process,
-                                    struct machine *machine,
-                                    struct perf_session *session);
-int perf_event__process_build_id(union perf_event *event,
+                                    struct machine *machine);
+int perf_event__process_build_id(struct perf_tool *tool,
+                                 union perf_event *event,
                                  struct perf_session *session);
 
 /*
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index a36a3fa81ffb..6f505d1abac7 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -76,21 +76,21 @@ static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
         }
 }
 
-static void hist_entry__add_cpumode_period(struct hist_entry *self,
+static void hist_entry__add_cpumode_period(struct hist_entry *he,
                                            unsigned int cpumode, u64 period)
 {
         switch (cpumode) {
         case PERF_RECORD_MISC_KERNEL:
-                self->period_sys += period;
+                he->period_sys += period;
                 break;
         case PERF_RECORD_MISC_USER:
-                self->period_us += period;
+                he->period_us += period;
                 break;
         case PERF_RECORD_MISC_GUEST_KERNEL:
-                self->period_guest_sys += period;
+                he->period_guest_sys += period;
                 break;
         case PERF_RECORD_MISC_GUEST_USER:
-                self->period_guest_us += period;
+                he->period_guest_us += period;
                 break;
         default:
                 break;
@@ -165,18 +165,18 @@ void hists__decay_entries_threaded(struct hists *hists,
 static struct hist_entry *hist_entry__new(struct hist_entry *template)
 {
         size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
-        struct hist_entry *self = malloc(sizeof(*self) + callchain_size);
+        struct hist_entry *he = malloc(sizeof(*he) + callchain_size);
 
-        if (self != NULL) {
-                *self = *template;
-                self->nr_events = 1;
-                if (self->ms.map)
-                        self->ms.map->referenced = true;
+        if (he != NULL) {
+                *he = *template;
+                he->nr_events = 1;
+                if (he->ms.map)
+                        he->ms.map->referenced = true;
                 if (symbol_conf.use_callchain)
-                        callchain_init(self->callchain);
+                        callchain_init(he->callchain);
         }
 
-        return self;
+        return he;
 }
 
 static void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
@@ -677,15 +677,16 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
         return ret;
 }
 
-static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
-                                            u64 total_samples, int left_margin)
+static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
+                                            u64 total_samples, int left_margin,
+                                            FILE *fp)
 {
         struct rb_node *rb_node;
         struct callchain_node *chain;
         size_t ret = 0;
         u32 entries_printed = 0;
 
-        rb_node = rb_first(&self->sorted_chain);
+        rb_node = rb_first(&he->sorted_chain);
         while (rb_node) {
                 double percent;
 
@@ -730,35 +731,35 @@ void hists__output_recalc_col_len(struct hists *hists, int max_rows)
         }
 }
 
-static int hist_entry__pcnt_snprintf(struct hist_entry *self, char *s,
+static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
                                      size_t size, struct hists *pair_hists,
                                      bool show_displacement, long displacement,
-                                     bool color, u64 session_total)
+                                     bool color, u64 total_period)
 {
         u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
         u64 nr_events;
         const char *sep = symbol_conf.field_sep;
         int ret;
 
-        if (symbol_conf.exclude_other && !self->parent)
+        if (symbol_conf.exclude_other && !he->parent)
                 return 0;
 
         if (pair_hists) {
-                period = self->pair ? self->pair->period : 0;
-                nr_events = self->pair ? self->pair->nr_events : 0;
+                period = he->pair ? he->pair->period : 0;
+                nr_events = he->pair ? he->pair->nr_events : 0;
                 total = pair_hists->stats.total_period;
-                period_sys = self->pair ? self->pair->period_sys : 0;
-                period_us = self->pair ? self->pair->period_us : 0;
-                period_guest_sys = self->pair ? self->pair->period_guest_sys : 0;
-                period_guest_us = self->pair ? self->pair->period_guest_us : 0;
+                period_sys = he->pair ? he->pair->period_sys : 0;
+                period_us = he->pair ? he->pair->period_us : 0;
+                period_guest_sys = he->pair ? he->pair->period_guest_sys : 0;
+                period_guest_us = he->pair ? he->pair->period_guest_us : 0;
         } else {
-                period = self->period;
-                nr_events = self->nr_events;
-                total = session_total;
-                period_sys = self->period_sys;
-                period_us = self->period_us;
-                period_guest_sys = self->period_guest_sys;
-                period_guest_us = self->period_guest_us;
+                period = he->period;
+                nr_events = he->nr_events;
+                total = total_period;
+                period_sys = he->period_sys;
+                period_us = he->period_us;
+                period_guest_sys = he->period_guest_sys;
+                period_guest_us = he->period_guest_us;
         }
 
         if (total) {
@@ -812,8 +813,8 @@ static int hist_entry__pcnt_snprintf(struct hist_entry *self, char *s,
 
                 if (total > 0)
                         old_percent = (period * 100.0) / total;
-                if (session_total > 0)
-                        new_percent = (self->period * 100.0) / session_total;
+                if (total_period > 0)
+                        new_percent = (he->period * 100.0) / total_period;
 
                 diff = new_percent - old_percent;
 
@@ -862,9 +863,10 @@ int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
         return ret;
 }
 
-int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
-                        struct hists *pair_hists, bool show_displacement,
-                        long displacement, FILE *fp, u64 session_total)
+static int hist_entry__fprintf(struct hist_entry *he, size_t size,
+                               struct hists *hists, struct hists *pair_hists,
+                               bool show_displacement, long displacement,
+                               u64 total_period, FILE *fp)
 {
         char bf[512];
         int ret;
@@ -874,14 +876,14 @@ int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
 
         ret = hist_entry__pcnt_snprintf(he, bf, size, pair_hists,
                                         show_displacement, displacement,
-                                        true, session_total);
+                                        true, total_period);
         hist_entry__snprintf(he, bf + ret, size - ret, hists);
         return fprintf(fp, "%s\n", bf);
 }
 
-static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
-                                            struct hists *hists, FILE *fp,
-                                            u64 session_total)
+static size_t hist_entry__fprintf_callchain(struct hist_entry *he,
+                                            struct hists *hists,
+                                            u64 total_period, FILE *fp)
 {
         int left_margin = 0;
 
@@ -889,11 +891,10 @@ static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
                 struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
                                                          typeof(*se), list);
                 left_margin = hists__col_len(hists, se->se_width_idx);
-                left_margin -= thread__comm_len(self->thread);
+                left_margin -= thread__comm_len(he->thread);
         }
 
-        return hist_entry_callchain__fprintf(fp, self, session_total,
-                                             left_margin);
+        return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
 }
 
 size_t hists__fprintf(struct hists *hists, struct hists *pair,
@@ -903,6 +904,7 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
         struct sort_entry *se;
         struct rb_node *nd;
         size_t ret = 0;
+        u64 total_period;
         unsigned long position = 1;
         long displacement = 0;
         unsigned int width;
@@ -917,20 +919,6 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
 
         fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
 
-        if (symbol_conf.show_nr_samples) {
-                if (sep)
-                        fprintf(fp, "%cSamples", *sep);
-                else
-                        fputs("  Samples  ", fp);
-        }
-
-        if (symbol_conf.show_total_period) {
-                if (sep)
-                        ret += fprintf(fp, "%cPeriod", *sep);
-                else
-                        ret += fprintf(fp, "   Period    ");
-        }
-
         if (symbol_conf.show_cpu_utilization) {
                 if (sep) {
                         ret += fprintf(fp, "%csys", *sep);
@@ -940,8 +928,8 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                                 ret += fprintf(fp, "%cguest us", *sep);
                         }
                 } else {
-                        ret += fprintf(fp, "  sys  ");
-                        ret += fprintf(fp, "  us  ");
+                        ret += fprintf(fp, "     sys  ");
+                        ret += fprintf(fp, "      us  ");
                         if (perf_guest) {
                                 ret += fprintf(fp, "  guest sys  ");
                                 ret += fprintf(fp, "  guest us  ");
@@ -949,6 +937,20 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                 }
         }
 
+        if (symbol_conf.show_nr_samples) {
+                if (sep)
+                        fprintf(fp, "%cSamples", *sep);
+                else
+                        fputs("  Samples  ", fp);
+        }
+
+        if (symbol_conf.show_total_period) {
+                if (sep)
+                        ret += fprintf(fp, "%cPeriod", *sep);
+                else
+                        ret += fprintf(fp, "   Period    ");
+        }
+
         if (pair) {
                 if (sep)
                         ret += fprintf(fp, "%cDelta", *sep);
@@ -993,6 +995,8 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                 goto print_entries;
 
         fprintf(fp, "# ........");
+        if (symbol_conf.show_cpu_utilization)
+                fprintf(fp, "   .......   .......");
         if (symbol_conf.show_nr_samples)
                 fprintf(fp, " ..........");
         if (symbol_conf.show_total_period)
@@ -1025,6 +1029,8 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
                 goto out;
 
 print_entries:
+        total_period = hists->stats.total_period;
+
         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
@@ -1040,11 +1046,10 @@ print_entries:
                         ++position;
                 }
                 ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
-                                           displacement, fp, hists->stats.total_period);
+                                           displacement, total_period, fp);
 
                 if (symbol_conf.use_callchain)
-                        ret += hist_entry__fprintf_callchain(h, hists, fp,
-                                                             hists->stats.total_period);
+                        ret += hist_entry__fprintf_callchain(h, hists, total_period, fp);
                 if (max_rows && ++nr_rows >= max_rows)
                         goto out;
 
@@ -1211,13 +1216,3 @@ size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
 
         return ret;
 }
-
-void hists__init(struct hists *hists)
-{
-        memset(hists, 0, sizeof(*hists));
-        hists->entries_in_array[0] = hists->entries_in_array[1] = RB_ROOT;
-        hists->entries_in = &hists->entries_in_array[0];
-        hists->entries_collapsed = RB_ROOT;
-        hists->entries = RB_ROOT;
-        pthread_mutex_init(&hists->lock, NULL);
-}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index c86c1d27bd1e..f55f0a8d1f81 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -63,16 +63,11 @@ struct hists {
         struct callchain_cursor callchain_cursor;
 };
 
-void hists__init(struct hists *hists);
-
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
                                       struct symbol *parent, u64 period);
-extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
-extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
-int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
-                        struct hists *pair_hists, bool show_displacement,
-                        long displacement, FILE *fp, u64 session_total);
+int64_t hist_entry__cmp(struct hist_entry *left, struct hist_entry *right);
+int64_t hist_entry__collapse(struct hist_entry *left, struct hist_entry *right);
 int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
                          struct hists *hists);
 void hist_entry__free(struct hist_entry *);
@@ -119,7 +114,6 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __used,
 
 static inline int hist_entry__tui_annotate(struct hist_entry *self __used,
                                            int evidx __used,
-                                           int nr_events __used,
                                            void(*timer)(void *arg) __used,
                                            void *arg __used,
                                            int delay_secs __used)
@@ -130,7 +124,7 @@ static inline int hist_entry__tui_annotate(struct hist_entry *self __used,
 #define K_RIGHT -2
 #else
 #include "ui/keysyms.h"
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx, int nr_events,
+int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
                              void(*timer)(void *arg), void *arg, int delay_secs);
 
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index 305c8484f200..62cdee78db7b 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -9,6 +9,17 @@
 #define BITS_PER_BYTE           8
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 
+#define for_each_set_bit(bit, addr, size) \
+        for ((bit) = find_first_bit((addr), (size));            \
+             (bit) < (size);                                    \
+             (bit) = find_next_bit((addr), (size), (bit) + 1))
+
+/* same as for_each_set_bit() but use bit as value to start with */
+#define for_each_set_bit_cont(bit, addr, size) \
+        for ((bit) = find_next_bit((addr), (size), (bit));      \
+             (bit) < (size);                                    \
+             (bit) = find_next_bit((addr), (size), (bit) + 1))
+
 static inline void set_bit(int nr, unsigned long *addr)
 {
         addr[nr / BITS_PER_LONG] |= 1UL << (nr % BITS_PER_LONG);
@@ -30,4 +41,111 @@ static inline unsigned long hweight_long(unsigned long w)
         return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
 }
 
+#define BITOP_WORD(nr)          ((nr) / BITS_PER_LONG)
+
+/**
+ * __ffs - find first bit in word.
+ * @word: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static __always_inline unsigned long __ffs(unsigned long word)
+{
+        int num = 0;
+
+#if BITS_PER_LONG == 64
+        if ((word & 0xffffffff) == 0) {
+                num += 32;
+                word >>= 32;
+        }
+#endif
+        if ((word & 0xffff) == 0) {
+                num += 16;
+                word >>= 16;
+        }
+        if ((word & 0xff) == 0) {
+                num += 8;
+                word >>= 8;
+        }
+        if ((word & 0xf) == 0) {
+                num += 4;
+                word >>= 4;
+        }
+        if ((word & 0x3) == 0) {
+                num += 2;
+                word >>= 2;
+        }
+        if ((word & 0x1) == 0)
+                num += 1;
+        return num;
+}
+
+/*
+ * Find the first set bit in a memory region.
+ */
+static inline unsigned long
+find_first_bit(const unsigned long *addr, unsigned long size)
+{
+        const unsigned long *p = addr;
+        unsigned long result = 0;
+        unsigned long tmp;
+
+        while (size & ~(BITS_PER_LONG-1)) {
+                if ((tmp = *(p++)))
+                        goto found;
+                result += BITS_PER_LONG;
+                size -= BITS_PER_LONG;
+        }
+        if (!size)
+                return result;
+
+        tmp = (*p) & (~0UL >> (BITS_PER_LONG - size));
+        if (tmp == 0UL)         /* Are any bits set? */
+                return result + size;   /* Nope. */
+found:
+        return result + __ffs(tmp);
+}
+
+/*
+ * Find the next set bit in a memory region.
+ */
+static inline unsigned long
+find_next_bit(const unsigned long *addr, unsigned long size, unsigned long offset)
+{
+        const unsigned long *p = addr + BITOP_WORD(offset);
+        unsigned long result = offset & ~(BITS_PER_LONG-1);
+        unsigned long tmp;
+
+        if (offset >= size)
+                return size;
+        size -= result;
+        offset %= BITS_PER_LONG;
+        if (offset) {
+                tmp = *(p++);
+                tmp &= (~0UL << offset);
+                if (size < BITS_PER_LONG)
+                        goto found_first;
+                if (tmp)
+                        goto found_middle;
+                size -= BITS_PER_LONG;
+                result += BITS_PER_LONG;
+        }
+        while (size & ~(BITS_PER_LONG-1)) {
+                if ((tmp = *(p++)))
+                        goto found_middle;
+                result += BITS_PER_LONG;
+                size -= BITS_PER_LONG;
+        }
+        if (!size)
+                return result;
+        tmp = *p;
+
+found_first:
+        tmp &= (~0UL >> (BITS_PER_LONG - size));
+        if (tmp == 0UL)         /* Are any bits set? */
+                return result + size;   /* Nope. */
+found_middle:
+        return result + __ffs(tmp);
+}
+
 #endif
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 78284b13e808..316aa0ab7122 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -562,6 +562,10 @@ int machine__init(struct machine *self, const char *root_dir, pid_t pid)
         INIT_LIST_HEAD(&self->user_dsos);
         INIT_LIST_HEAD(&self->kernel_dsos);
 
+        self->threads = RB_ROOT;
+        INIT_LIST_HEAD(&self->dead_threads);
+        self->last_match = NULL;
+
         self->kmaps.machine = self;
         self->pid           = pid;
         self->root_dir      = strdup(root_dir);
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 890d85545d0f..2b8017f8a930 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -18,9 +18,11 @@ enum map_type {
 extern const char *map_type__name[MAP__NR_TYPES];
 
 struct dso;
+struct ip_callchain;
 struct ref_reloc_sym;
 struct map_groups;
 struct machine;
+struct perf_evsel;
 
 struct map {
         union {
@@ -61,7 +63,11 @@ struct map_groups {
 struct machine {
         struct rb_node    rb_node;
         pid_t             pid;
+        u16               id_hdr_size;
         char              *root_dir;
+        struct rb_root    threads;
+        struct list_head  dead_threads;
+        struct thread     *last_match;
         struct list_head  user_dsos;
         struct list_head  kernel_dsos;
         struct map_groups kmaps;
@@ -148,6 +154,13 @@ int machine__init(struct machine *self, const char *root_dir, pid_t pid);
 void machine__exit(struct machine *self);
 void machine__delete(struct machine *self);
 
+int machine__resolve_callchain(struct machine *machine,
+                               struct perf_evsel *evsel, struct thread *thread,
+                               struct ip_callchain *chain,
+                               struct symbol **parent);
+int maps__set_kallsyms_ref_reloc_sym(struct map **maps, const char *symbol_name,
+                                     u64 addr);
+
 /*
  * Default guest kernel is defined by parameter --guestkallsyms
  * and --guestmodules
@@ -190,6 +203,12 @@ struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
                                                struct map **mapp,
                                                symbol_filter_t filter);
 
+
+struct thread *machine__findnew_thread(struct machine *machine, pid_t pid);
+void machine__remove_thread(struct machine *machine, struct thread *th);
+
+size_t machine__fprintf(struct machine *machine, FILE *fp);
+
 static inline
 struct symbol *machine__find_kernel_symbol(struct machine *self,
                                            enum map_type type, u64 addr,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 928918b796b2..b029296d20d9 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -25,8 +25,6 @@ enum event_result {
         EVT_HANDLED_ALL
 };
 
-char debugfs_path[MAXPATHLEN];
-
 #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
 #define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
 
@@ -40,6 +38,7 @@ static struct event_symbol event_symbols[] = {
   { CHW(BRANCH_INSTRUCTIONS),           "branch-instructions",          "branches"              },
   { CHW(BRANCH_MISSES),                 "branch-misses",                ""                      },
   { CHW(BUS_CYCLES),                    "bus-cycles",                   ""                      },
+  { CHW(REF_CPU_CYCLES),                "ref-cycles",                   ""                      },
 
   { CSW(CPU_CLOCK),                     "cpu-clock",                    ""                      },
   { CSW(TASK_CLOCK),                    "task-clock",                   ""                      },
@@ -70,6 +69,7 @@ static const char *hw_event_names[PERF_COUNT_HW_MAX] = {
         "bus-cycles",
         "stalled-cycles-frontend",
         "stalled-cycles-backend",
+        "ref-cycles",
 };
 
 static const char *sw_event_names[PERF_COUNT_SW_MAX] = {
@@ -140,7 +140,7 @@ static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
         char evt_path[MAXPATHLEN];
         int fd;
 
-        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
+        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
                         sys_dir->d_name, evt_dir->d_name);
         fd = open(evt_path, O_RDONLY);
         if (fd < 0)
@@ -171,16 +171,16 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (debugfs_valid_mountpoint(debugfs_path))
+        if (debugfs_valid_mountpoint(tracing_events_path))
                 return NULL;
 
-        sys_dir = opendir(debugfs_path);
+        sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
                 return NULL;
 
         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 
-                snprintf(dir_path, MAXPATHLEN, "%s/%s", debugfs_path,
+                snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
                          sys_dirent.d_name);
                 evt_dir = opendir(dir_path);
                 if (!evt_dir)
@@ -447,7 +447,7 @@ parse_single_tracepoint_event(char *sys_name,
         u64 id;
         int fd;
 
-        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
+        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
                  sys_name, evt_name);
 
         fd = open(evt_path, O_RDONLY);
@@ -485,7 +485,7 @@ parse_multiple_tracepoint_event(struct perf_evlist *evlist, char *sys_name,
         struct dirent *evt_ent;
         DIR *evt_dir;
 
-        snprintf(evt_path, MAXPATHLEN, "%s/%s", debugfs_path, sys_name);
+        snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
         evt_dir = opendir(evt_path);
 
         if (!evt_dir) {
@@ -528,7 +528,7 @@ parse_tracepoint_event(struct perf_evlist *evlist, const char **strp,
         char sys_name[MAX_EVENT_LENGTH];
         unsigned int sys_length, evt_length;
 
-        if (debugfs_valid_mountpoint(debugfs_path))
+        if (debugfs_valid_mountpoint(tracing_events_path))
                 return 0;
 
         evt_name = strchr(*strp, ':');
@@ -735,8 +735,8 @@ static int
 parse_event_modifier(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
-        int exclude = 0;
-        int eu = 0, ek = 0, eh = 0, precise = 0;
+        int exclude = 0, exclude_GH = 0;
+        int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
 
         if (!*str)
                 return 0;
@@ -760,6 +760,14 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
                         if (!exclude)
                                 exclude = eu = ek = eh = 1;
                         eh = 0;
+                } else if (*str == 'G') {
+                        if (!exclude_GH)
+                                exclude_GH = eG = eH = 1;
+                        eG = 0;
+                } else if (*str == 'H') {
+                        if (!exclude_GH)
+                                exclude_GH = eG = eH = 1;
+                        eH = 0;
                 } else if (*str == 'p') {
                         precise++;
                 } else
@@ -776,6 +784,8 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
         attr->exclude_kernel = ek;
         attr->exclude_hv     = eh;
         attr->precise_ip     = precise;
+        attr->exclude_host   = eH;
+        attr->exclude_guest  = eG;
 
         return 0;
 }
@@ -838,6 +848,7 @@ int parse_events(struct perf_evlist *evlist , const char *str, int unset __used)
         for (;;) {
                 ostr = str;
                 memset(&attr, 0, sizeof(attr));
+                event_attr_init(&attr);
                 ret = parse_event_symbols(evlist, &str, &attr);
                 if (ret == EVT_FAILED)
                         return -1;
@@ -920,10 +931,10 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (debugfs_valid_mountpoint(debugfs_path))
+        if (debugfs_valid_mountpoint(tracing_events_path))
                 return;
 
-        sys_dir = opendir(debugfs_path);
+        sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
                 return;
 
@@ -932,7 +943,7 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
                     !strglobmatch(sys_dirent.d_name, subsys_glob))
                         continue;
 
-                snprintf(dir_path, MAXPATHLEN, "%s/%s", debugfs_path,
+                snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
                          sys_dirent.d_name);
                 evt_dir = opendir(dir_path);
                 if (!evt_dir)
@@ -964,16 +975,16 @@ int is_valid_tracepoint(const char *event_string)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (debugfs_valid_mountpoint(debugfs_path))
+        if (debugfs_valid_mountpoint(tracing_events_path))
                 return 0;
 
-        sys_dir = opendir(debugfs_path);
+        sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
                 return 0;
 
         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 
-                snprintf(dir_path, MAXPATHLEN, "%s/%s", debugfs_path,
+                snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
                          sys_dirent.d_name);
                 evt_dir = opendir(dir_path);
                 if (!evt_dir)
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 2f8e375e038d..7e0cbe75d5f1 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -39,7 +39,6 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob);
 int print_hwcache_events(const char *event_glob);
 extern int is_valid_tracepoint(const char *event_string);
 
-extern char debugfs_path[];
 extern int valid_debugfs_mount(const char *debugfs);
 
 #endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 1132c8f0ce89..17e94d0c36f9 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -5,7 +5,6 @@
 #include "util.h"
 #include "probe-event.h"
 
-#define MAX_PATH_LEN             256
 #define MAX_PROBE_BUFFER        1024
 #define MAX_PROBES               128
 
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 74350ffb57fe..e30749e38a9b 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -27,7 +27,10 @@
 
 #include "../../perf.h"
 #include "../util.h"
+#include "../thread.h"
+#include "../event.h"
 #include "../trace-event.h"
+#include "../evsel.h"
 
 #include <EXTERN.h>
 #include <perl.h>
@@ -245,11 +248,11 @@ static inline struct event *find_cache_event(int type)
         return event;
 }
 
-static void perl_process_event(union perf_event *pevent __unused,
-                               struct perf_sample *sample,
-                               struct perf_evsel *evsel,
-                               struct perf_session *session __unused,
-                               struct thread *thread)
+static void perl_process_tracepoint(union perf_event *pevent __unused,
+                                    struct perf_sample *sample,
+                                    struct perf_evsel *evsel,
+                                    struct machine *machine __unused,
+                                    struct thread *thread)
 {
         struct format_field *field;
         static char handler[256];
@@ -265,6 +268,9 @@ static void perl_process_event(union perf_event *pevent __unused,
 
         dSP;
 
+        if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
+                return;
+
         type = trace_parse_common_type(data);
 
         event = find_cache_event(type);
@@ -332,6 +338,42 @@ static void perl_process_event(union perf_event *pevent __unused,
         LEAVE;
 }
 
+static void perl_process_event_generic(union perf_event *pevent __unused,
+                                       struct perf_sample *sample,
+                                       struct perf_evsel *evsel __unused,
+                                       struct machine *machine __unused,
+                                       struct thread *thread __unused)
+{
+        dSP;
+
+        if (!get_cv("process_event", 0))
+                return;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs(sv_2mortal(newSVpvn((const char *)pevent, pevent->header.size)));
+        XPUSHs(sv_2mortal(newSVpvn((const char *)&evsel->attr, sizeof(evsel->attr))));
+        XPUSHs(sv_2mortal(newSVpvn((const char *)sample, sizeof(*sample))));
+        XPUSHs(sv_2mortal(newSVpvn((const char *)sample->raw_data, sample->raw_size)));
+        PUTBACK;
+        call_pv("process_event", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void perl_process_event(union perf_event *pevent,
+                               struct perf_sample *sample,
+                               struct perf_evsel *evsel,
+                               struct machine *machine,
+                               struct thread *thread)
+{
+        perl_process_tracepoint(pevent, sample, evsel, machine, thread);
+        perl_process_event_generic(pevent, sample, evsel, machine, thread);
+}
+
 static void run_start_sub(void)
 {
         dSP; /* access to Perl stack */
@@ -553,7 +595,28 @@ static int perl_generate_script(const char *outfile)
         fprintf(ofp, "sub print_header\n{\n"
                 "\tmy ($event_name, $cpu, $secs, $nsecs, $pid, $comm) = @_;\n\n"
                 "\tprintf(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \",\n\t       "
-                "$event_name, $cpu, $secs, $nsecs, $pid, $comm);\n}");
+                "$event_name, $cpu, $secs, $nsecs, $pid, $comm);\n}\n");
+
+        fprintf(ofp,
+                "\n# Packed byte string args of process_event():\n"
+                "#\n"
+                "# $event:\tunion perf_event\tutil/event.h\n"
+                "# $attr:\tstruct perf_event_attr\tlinux/perf_event.h\n"
+                "# $sample:\tstruct perf_sample\tutil/event.h\n"
+                "# $raw_data:\tperf_sample->raw_data\tutil/event.h\n"
+                "\n"
+                "sub process_event\n"
+                "{\n"
+                "\tmy ($event, $attr, $sample, $raw_data) = @_;\n"
+                "\n"
+                "\tmy @event\t= unpack(\"LSS\", $event);\n"
+                "\tmy @attr\t= unpack(\"LLQQQQQLLQQ\", $attr);\n"
+                "\tmy @sample\t= unpack(\"QLLQQQQQLL\", $sample);\n"
+                "\tmy @raw_data\t= unpack(\"C*\", $raw_data);\n"
+                "\n"
+                "\tuse Data::Dumper;\n"
+                "\tprint Dumper \\@event, \\@attr, \\@sample, \\@raw_data;\n"
+                "}\n");
 
         fclose(ofp);
 
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 6ccf70e8d8f2..0b2a48783172 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -29,6 +29,8 @@
 
 #include "../../perf.h"
 #include "../util.h"
+#include "../event.h"
+#include "../thread.h"
 #include "../trace-event.h"
 
 PyMODINIT_FUNC initperf_trace_context(void);
@@ -207,7 +209,7 @@ static inline struct event *find_cache_event(int type)
 static void python_process_event(union perf_event *pevent __unused,
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel __unused,
-                                 struct perf_session *session __unused,
+                                 struct machine *machine __unused,
                                  struct thread *thread)
 {
         PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 85c1e6b76f0a..b5ca2558c7bb 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -10,6 +10,7 @@
 #include "evlist.h"
 #include "evsel.h"
 #include "session.h"
+#include "tool.h"
 #include "sort.h"
 #include "util.h"
 #include "cpumap.h"
@@ -78,39 +79,13 @@ out_close:
         return -1;
 }
 
-static void perf_session__id_header_size(struct perf_session *session)
-{
-       struct perf_sample *data;
-       u64 sample_type = session->sample_type;
-       u16 size = 0;
-
-        if (!session->sample_id_all)
-                goto out;
-
-       if (sample_type & PERF_SAMPLE_TID)
-               size += sizeof(data->tid) * 2;
-
-       if (sample_type & PERF_SAMPLE_TIME)
-               size += sizeof(data->time);
-
-       if (sample_type & PERF_SAMPLE_ID)
-               size += sizeof(data->id);
-
-       if (sample_type & PERF_SAMPLE_STREAM_ID)
-               size += sizeof(data->stream_id);
-
-       if (sample_type & PERF_SAMPLE_CPU)
-               size += sizeof(data->cpu) * 2;
-out:
-       session->id_hdr_size = size;
-}
-
 void perf_session__update_sample_type(struct perf_session *self)
 {
         self->sample_type = perf_evlist__sample_type(self->evlist);
         self->sample_size = __perf_evsel__sample_size(self->sample_type);
         self->sample_id_all = perf_evlist__sample_id_all(self->evlist);
-        perf_session__id_header_size(self);
+        self->id_hdr_size = perf_evlist__id_hdr_size(self->evlist);
+        self->host_machine.id_hdr_size = self->id_hdr_size;
 }
 
 int perf_session__create_kernel_maps(struct perf_session *self)
@@ -130,18 +105,26 @@ static void perf_session__destroy_kernel_maps(struct perf_session *self)
 
 struct perf_session *perf_session__new(const char *filename, int mode,
                                        bool force, bool repipe,
-                                       struct perf_event_ops *ops)
+                                       struct perf_tool *tool)
 {
-        size_t len = filename ? strlen(filename) + 1 : 0;
-        struct perf_session *self = zalloc(sizeof(*self) + len);
+        struct perf_session *self;
+        struct stat st;
+        size_t len;
+
+        if (!filename || !strlen(filename)) {
+                if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
+                        filename = "-";
+                else
+                        filename = "perf.data";
+        }
+
+        len = strlen(filename);
+        self = zalloc(sizeof(*self) + len);
 
         if (self == NULL)
                 goto out;
 
         memcpy(self->filename, filename, len);
-        self->threads = RB_ROOT;
-        INIT_LIST_HEAD(&self->dead_threads);
-        self->last_match = NULL;
         /*
          * On 64bit we can mmap the data file in one go. No need for tiny mmap
          * slices. On 32bit we use 32MB.
@@ -171,10 +154,10 @@ struct perf_session *perf_session__new(const char *filename, int mode,
                         goto out_delete;
         }
 
-        if (ops && ops->ordering_requires_timestamps &&
-            ops->ordered_samples && !self->sample_id_all) {
+        if (tool && tool->ordering_requires_timestamps &&
+            tool->ordered_samples && !self->sample_id_all) {
                 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
-                ops->ordered_samples = false;
+                tool->ordered_samples = false;
         }
 
 out:
@@ -184,17 +167,22 @@ out_delete:
         return NULL;
 }
 
-static void perf_session__delete_dead_threads(struct perf_session *self)
+static void machine__delete_dead_threads(struct machine *machine)
 {
         struct thread *n, *t;
 
-        list_for_each_entry_safe(t, n, &self->dead_threads, node) {
+        list_for_each_entry_safe(t, n, &machine->dead_threads, node) {
                 list_del(&t->node);
                 thread__delete(t);
         }
 }
 
-static void perf_session__delete_threads(struct perf_session *self)
+static void perf_session__delete_dead_threads(struct perf_session *session)
+{
+        machine__delete_dead_threads(&session->host_machine);
+}
+
+static void machine__delete_threads(struct machine *self)
 {
         struct rb_node *nd = rb_first(&self->threads);
 
@@ -207,6 +195,11 @@ static void perf_session__delete_threads(struct perf_session *self)
         }
 }
 
+static void perf_session__delete_threads(struct perf_session *session)
+{
+        machine__delete_threads(&session->host_machine);
+}
+
 void perf_session__delete(struct perf_session *self)
 {
         perf_session__destroy_kernel_maps(self);
@@ -217,7 +210,7 @@ void perf_session__delete(struct perf_session *self)
         free(self);
 }
 
-void perf_session__remove_thread(struct perf_session *self, struct thread *th)
+void machine__remove_thread(struct machine *self, struct thread *th)
 {
         self->last_match = NULL;
         rb_erase(&th->rb_node, &self->threads);
@@ -236,16 +229,16 @@ static bool symbol__match_parent_regex(struct symbol *sym)
         return 0;
 }
 
-int perf_session__resolve_callchain(struct perf_session *self,
-                                    struct thread *thread,
-                                    struct ip_callchain *chain,
-                                    struct symbol **parent)
+int machine__resolve_callchain(struct machine *self, struct perf_evsel *evsel,
+                               struct thread *thread,
+                               struct ip_callchain *chain,
+                               struct symbol **parent)
 {
         u8 cpumode = PERF_RECORD_MISC_USER;
         unsigned int i;
         int err;
 
-        callchain_cursor_reset(&self->callchain_cursor);
+        callchain_cursor_reset(&evsel->hists.callchain_cursor);
 
         for (i = 0; i < chain->nr; i++) {
                 u64 ip;
@@ -272,7 +265,7 @@ int perf_session__resolve_callchain(struct perf_session *self,
 
                 al.filtered = false;
                 thread__find_addr_location(thread, self, cpumode,
-                                MAP__FUNCTION, thread->pid, ip, &al, NULL);
+                                           MAP__FUNCTION, ip, &al, NULL);
                 if (al.sym != NULL) {
                         if (sort__has_parent && !*parent &&
                             symbol__match_parent_regex(al.sym))
@@ -281,7 +274,7 @@ int perf_session__resolve_callchain(struct perf_session *self,
                                 break;
                 }
 
-                err = callchain_cursor_append(&self->callchain_cursor,
+                err = callchain_cursor_append(&evsel->hists.callchain_cursor,
                                               ip, al.map, al.sym);
                 if (err)
                         return err;
@@ -290,75 +283,91 @@ int perf_session__resolve_callchain(struct perf_session *self,
         return 0;
 }
 
-static int process_event_synth_stub(union perf_event *event __used,
-                                    struct perf_session *session __used)
+static int process_event_synth_tracing_data_stub(union perf_event *event __used,
+                                                 struct perf_session *session __used)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_event_sample_stub(union perf_event *event __used,
+static int process_event_synth_attr_stub(union perf_event *event __used,
+                                         struct perf_evlist **pevlist __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static int process_event_sample_stub(struct perf_tool *tool __used,
+                                     union perf_event *event __used,
                                      struct perf_sample *sample __used,
                                      struct perf_evsel *evsel __used,
-                                     struct perf_session *session __used)
+                                     struct machine *machine __used)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_event_stub(union perf_event *event __used,
+static int process_event_stub(struct perf_tool *tool __used,
+                              union perf_event *event __used,
                               struct perf_sample *sample __used,
-                              struct perf_session *session __used)
+                              struct machine *machine __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static int process_finished_round_stub(struct perf_tool *tool __used,
+                                       union perf_event *event __used,
+                                       struct perf_session *perf_session __used)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_finished_round_stub(union perf_event *event __used,
-                                       struct perf_session *session __used,
-                                       struct perf_event_ops *ops __used)
+static int process_event_type_stub(struct perf_tool *tool __used,
+                                   union perf_event *event __used)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_finished_round(union perf_event *event,
-                                  struct perf_session *session,
-                                  struct perf_event_ops *ops);
+static int process_finished_round(struct perf_tool *tool,
+                                  union perf_event *event,
+                                  struct perf_session *session);
 
-static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
+static void perf_tool__fill_defaults(struct perf_tool *tool)
 {
-        if (handler->sample == NULL)
-                handler->sample = process_event_sample_stub;
-        if (handler->mmap == NULL)
-                handler->mmap = process_event_stub;
-        if (handler->comm == NULL)
-                handler->comm = process_event_stub;
-        if (handler->fork == NULL)
-                handler->fork = process_event_stub;
-        if (handler->exit == NULL)
-                handler->exit = process_event_stub;
-        if (handler->lost == NULL)
-                handler->lost = perf_event__process_lost;
-        if (handler->read == NULL)
-                handler->read = process_event_stub;
-        if (handler->throttle == NULL)
-                handler->throttle = process_event_stub;
-        if (handler->unthrottle == NULL)
-                handler->unthrottle = process_event_stub;
-        if (handler->attr == NULL)
-                handler->attr = process_event_synth_stub;
-        if (handler->event_type == NULL)
-                handler->event_type = process_event_synth_stub;
-        if (handler->tracing_data == NULL)
-                handler->tracing_data = process_event_synth_stub;
-        if (handler->build_id == NULL)
-                handler->build_id = process_event_synth_stub;
-        if (handler->finished_round == NULL) {
-                if (handler->ordered_samples)
-                        handler->finished_round = process_finished_round;
+        if (tool->sample == NULL)
+                tool->sample = process_event_sample_stub;
+        if (tool->mmap == NULL)
+                tool->mmap = process_event_stub;
+        if (tool->comm == NULL)
+                tool->comm = process_event_stub;
+        if (tool->fork == NULL)
+                tool->fork = process_event_stub;
+        if (tool->exit == NULL)
+                tool->exit = process_event_stub;
+        if (tool->lost == NULL)
+                tool->lost = perf_event__process_lost;
+        if (tool->read == NULL)
+                tool->read = process_event_sample_stub;
+        if (tool->throttle == NULL)
+                tool->throttle = process_event_stub;
+        if (tool->unthrottle == NULL)
+                tool->unthrottle = process_event_stub;
+        if (tool->attr == NULL)
+                tool->attr = process_event_synth_attr_stub;
+        if (tool->event_type == NULL)
+                tool->event_type = process_event_type_stub;
+        if (tool->tracing_data == NULL)
+                tool->tracing_data = process_event_synth_tracing_data_stub;
+        if (tool->build_id == NULL)
+                tool->build_id = process_finished_round_stub;
+        if (tool->finished_round == NULL) {
+                if (tool->ordered_samples)
+                        tool->finished_round = process_finished_round;
                 else
-                        handler->finished_round = process_finished_round_stub;
+                        tool->finished_round = process_finished_round_stub;
         }
 }
 
@@ -490,11 +499,11 @@ static void perf_session_free_sample_buffers(struct perf_session *session)
 static int perf_session_deliver_event(struct perf_session *session,
                                       union perf_event *event,
                                       struct perf_sample *sample,
-                                      struct perf_event_ops *ops,
+                                      struct perf_tool *tool,
                                       u64 file_offset);
 
 static void flush_sample_queue(struct perf_session *s,
-                               struct perf_event_ops *ops)
+                               struct perf_tool *tool)
 {
         struct ordered_samples *os = &s->ordered_samples;
         struct list_head *head = &os->samples;
@@ -505,7 +514,7 @@ static void flush_sample_queue(struct perf_session *s,
         unsigned idx = 0, progress_next = os->nr_samples / 16;
         int ret;
 
-        if (!ops->ordered_samples || !limit)
+        if (!tool->ordered_samples || !limit)
                 return;
 
         list_for_each_entry_safe(iter, tmp, head, list) {
@@ -516,7 +525,7 @@ static void flush_sample_queue(struct perf_session *s,
                 if (ret)
                         pr_err("Can't parse sample, err = %d\n", ret);
                 else
-                        perf_session_deliver_event(s, iter->event, &sample, ops,
+                        perf_session_deliver_event(s, iter->event, &sample, tool,
                                                    iter->file_offset);
 
                 os->last_flush = iter->timestamp;
@@ -578,11 +587,11 @@ static void flush_sample_queue(struct perf_session *s,
  *      Flush every events below timestamp 7
  *      etc...
  */
-static int process_finished_round(union perf_event *event __used,
-                                  struct perf_session *session,
-                                  struct perf_event_ops *ops)
+static int process_finished_round(struct perf_tool *tool,
+                                  union perf_event *event __used,
+                                  struct perf_session *session)
 {
-        flush_sample_queue(session, ops);
+        flush_sample_queue(session, tool);
         session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
 
         return 0;
@@ -737,13 +746,26 @@ static void dump_sample(struct perf_session *session, union perf_event *event,
                 callchain__printf(sample);
 }
 
+static struct machine *
+        perf_session__find_machine_for_cpumode(struct perf_session *session,
+                                               union perf_event *event)
+{
+        const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest)
+                return perf_session__find_machine(session, event->ip.pid);
+
+        return perf_session__find_host_machine(session);
+}
+
 static int perf_session_deliver_event(struct perf_session *session,
                                       union perf_event *event,
                                       struct perf_sample *sample,
-                                      struct perf_event_ops *ops,
+                                      struct perf_tool *tool,
                                       u64 file_offset)
 {
         struct perf_evsel *evsel;
+        struct machine *machine;
 
         dump_event(session, event, file_offset, sample);
 
@@ -765,6 +787,8 @@ static int perf_session_deliver_event(struct perf_session *session,
                 hists__inc_nr_events(&evsel->hists, event->header.type);
         }
 
+        machine = perf_session__find_machine_for_cpumode(session, event);
+
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
                 dump_sample(session, event, sample);
@@ -772,23 +796,25 @@ static int perf_session_deliver_event(struct perf_session *session,
                         ++session->hists.stats.nr_unknown_id;
                         return -1;
                 }
-                return ops->sample(event, sample, evsel, session);
+                return tool->sample(tool, event, sample, evsel, machine);
         case PERF_RECORD_MMAP:
-                return ops->mmap(event, sample, session);
+                return tool->mmap(tool, event, sample, machine);
         case PERF_RECORD_COMM:
-                return ops->comm(event, sample, session);
+                return tool->comm(tool, event, sample, machine);
         case PERF_RECORD_FORK:
-                return ops->fork(event, sample, session);
+                return tool->fork(tool, event, sample, machine);
         case PERF_RECORD_EXIT:
-                return ops->exit(event, sample, session);
+                return tool->exit(tool, event, sample, machine);
         case PERF_RECORD_LOST:
-                return ops->lost(event, sample, session);
+                if (tool->lost == perf_event__process_lost)
+                        session->hists.stats.total_lost += event->lost.lost;
+                return tool->lost(tool, event, sample, machine);
         case PERF_RECORD_READ:
-                return ops->read(event, sample, session);
+                return tool->read(tool, event, sample, evsel, machine);
         case PERF_RECORD_THROTTLE:
-                return ops->throttle(event, sample, session);
+                return tool->throttle(tool, event, sample, machine);
         case PERF_RECORD_UNTHROTTLE:
-                return ops->unthrottle(event, sample, session);
+                return tool->unthrottle(tool, event, sample, machine);
         default:
                 ++session->hists.stats.nr_unknown_events;
                 return -1;
@@ -812,24 +838,29 @@ static int perf_session__preprocess_sample(struct perf_session *session,
 }
 
 static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
-                                            struct perf_event_ops *ops, u64 file_offset)
+                                            struct perf_tool *tool, u64 file_offset)
 {
+        int err;
+
         dump_event(session, event, file_offset, NULL);
 
         /* These events are processed right away */
         switch (event->header.type) {
         case PERF_RECORD_HEADER_ATTR:
-                return ops->attr(event, session);
+                err = tool->attr(event, &session->evlist);
+                if (err == 0)
+                        perf_session__update_sample_type(session);
+                return err;
         case PERF_RECORD_HEADER_EVENT_TYPE:
-                return ops->event_type(event, session);
+                return tool->event_type(tool, event);
         case PERF_RECORD_HEADER_TRACING_DATA:
                 /* setup for reading amidst mmap */
                 lseek(session->fd, file_offset, SEEK_SET);
-                return ops->tracing_data(event, session);
+                return tool->tracing_data(event, session);
         case PERF_RECORD_HEADER_BUILD_ID:
-                return ops->build_id(event, session);
+                return tool->build_id(tool, event, session);
         case PERF_RECORD_FINISHED_ROUND:
-                return ops->finished_round(event, session, ops);
+                return tool->finished_round(tool, event, session);
         default:
                 return -EINVAL;
         }
@@ -837,7 +868,7 @@ static int perf_session__process_user_event(struct perf_session *session, union
 
 static int perf_session__process_event(struct perf_session *session,
                                        union perf_event *event,
-                                       struct perf_event_ops *ops,
+                                       struct perf_tool *tool,
                                        u64 file_offset)
 {
         struct perf_sample sample;
@@ -853,7 +884,7 @@ static int perf_session__process_event(struct perf_session *session,
         hists__inc_nr_events(&session->hists, event->header.type);
 
         if (event->header.type >= PERF_RECORD_USER_TYPE_START)
-                return perf_session__process_user_event(session, event, ops, file_offset);
+                return perf_session__process_user_event(session, event, tool, file_offset);
 
         /*
          * For all kernel events we get the sample data
@@ -866,14 +897,14 @@ static int perf_session__process_event(struct perf_session *session,
         if (perf_session__preprocess_sample(session, event, &sample))
                 return 0;
 
-        if (ops->ordered_samples) {
+        if (tool->ordered_samples) {
                 ret = perf_session_queue_event(session, event, &sample,
                                                file_offset);
                 if (ret != -ETIME)
                         return ret;
         }
 
-        return perf_session_deliver_event(session, event, &sample, ops,
+        return perf_session_deliver_event(session, event, &sample, tool,
                                           file_offset);
 }
 
@@ -884,6 +915,11 @@ void perf_event_header__bswap(struct perf_event_header *self)
         self->size = bswap_16(self->size);
 }
 
+struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
+{
+        return machine__findnew_thread(&session->host_machine, pid);
+}
+
 static struct thread *perf_session__register_idle_thread(struct perf_session *self)
 {
         struct thread *thread = perf_session__findnew(self, 0);
@@ -897,9 +933,9 @@ static struct thread *perf_session__register_idle_thread(struct perf_session *se
 }
 
 static void perf_session__warn_about_errors(const struct perf_session *session,
-                                            const struct perf_event_ops *ops)
+                                            const struct perf_tool *tool)
 {
-        if (ops->lost == perf_event__process_lost &&
+        if (tool->lost == perf_event__process_lost &&
             session->hists.stats.nr_events[PERF_RECORD_LOST] != 0) {
                 ui__warning("Processed %d events and lost %d chunks!\n\n"
                             "Check IO/CPU overload!\n\n",
@@ -934,7 +970,7 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
 volatile int session_done;
 
 static int __perf_session__process_pipe_events(struct perf_session *self,
-                                               struct perf_event_ops *ops)
+                                               struct perf_tool *tool)
 {
         union perf_event event;
         uint32_t size;
@@ -943,7 +979,7 @@ static int __perf_session__process_pipe_events(struct perf_session *self,
         int err;
         void *p;
 
-        perf_event_ops__fill_defaults(ops);
+        perf_tool__fill_defaults(tool);
 
         head = 0;
 more:
@@ -979,8 +1015,7 @@ more:
                 }
         }
 
-        if (size == 0 ||
-            (skip = perf_session__process_event(self, &event, ops, head)) < 0) {
+        if ((skip = perf_session__process_event(self, &event, tool, head)) < 0) {
                 dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n",
                             head, event.header.size, event.header.type);
                 /*
@@ -1003,7 +1038,7 @@ more:
 done:
         err = 0;
 out_err:
-        perf_session__warn_about_errors(self, ops);
+        perf_session__warn_about_errors(self, tool);
         perf_session_free_sample_buffers(self);
         return err;
 }
@@ -1034,7 +1069,7 @@ fetch_mmaped_event(struct perf_session *session,
 
 int __perf_session__process_events(struct perf_session *session,
                                    u64 data_offset, u64 data_size,
-                                   u64 file_size, struct perf_event_ops *ops)
+                                   u64 file_size, struct perf_tool *tool)
 {
         u64 head, page_offset, file_offset, file_pos, progress_next;
         int err, mmap_prot, mmap_flags, map_idx = 0;
@@ -1043,7 +1078,7 @@ int __perf_session__process_events(struct perf_session *session,
         union perf_event *event;
         uint32_t size;
 
-        perf_event_ops__fill_defaults(ops);
+        perf_tool__fill_defaults(tool);
 
         page_size = sysconf(_SC_PAGESIZE);
 
@@ -1098,7 +1133,7 @@ more:
         size = event->header.size;
 
         if (size == 0 ||
-            perf_session__process_event(session, event, ops, file_pos) < 0) {
+            perf_session__process_event(session, event, tool, file_pos) < 0) {
                 dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n",
                             file_offset + head, event->header.size,
                             event->header.type);
@@ -1127,15 +1162,15 @@ more:
         err = 0;
         /* do the final flush for ordered samples */
         session->ordered_samples.next_flush = ULLONG_MAX;
-        flush_sample_queue(session, ops);
+        flush_sample_queue(session, tool);
 out_err:
-        perf_session__warn_about_errors(session, ops);
+        perf_session__warn_about_errors(session, tool);
         perf_session_free_sample_buffers(session);
         return err;
 }
 
 int perf_session__process_events(struct perf_session *self,
-                                 struct perf_event_ops *ops)
+                                 struct perf_tool *tool)
 {
         int err;
 
@@ -1146,9 +1181,9 @@ int perf_session__process_events(struct perf_session *self,
                 err = __perf_session__process_events(self,
                                                      self->header.data_offset,
                                                      self->header.data_size,
-                                                     self->size, ops);
+                                                     self->size, tool);
         else
-                err = __perf_session__process_pipe_events(self, ops);
+                err = __perf_session__process_pipe_events(self, tool);
 
         return err;
 }
@@ -1163,9 +1198,8 @@ bool perf_session__has_traces(struct perf_session *self, const char *msg)
         return true;
 }
 
-int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
-                                             const char *symbol_name,
-                                             u64 addr)
+int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
+                                     const char *symbol_name, u64 addr)
 {
         char *bracket;
         enum map_type i;
@@ -1224,6 +1258,27 @@ size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
         return ret;
 }
 
+size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
+{
+        /*
+         * FIXME: Here we have to actually print all the machines in this
+         * session, not just the host...
+         */
+        return machine__fprintf(&session->host_machine, fp);
+}
+
+void perf_session__remove_thread(struct perf_session *session,
+                                 struct thread *th)
+{
+        /*
+         * FIXME: This one makes no sense, we need to remove the thread from
+         * the machine it belongs to, perf_session can have many machines, so
+         * doing it always on ->host_machine is wrong.  Fix when auditing all
+         * the 'perf kvm' code.
+         */
+        machine__remove_thread(&session->host_machine, th);
+}
+
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
                                               unsigned int type)
 {
@@ -1236,17 +1291,16 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
         return NULL;
 }
 
-void perf_session__print_ip(union perf_event *event,
-                            struct perf_sample *sample,
-                            struct perf_session *session,
-                            int print_sym, int print_dso)
+void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
+                          struct machine *machine, struct perf_evsel *evsel,
+                          int print_sym, int print_dso)
 {
         struct addr_location al;
         const char *symname, *dsoname;
-        struct callchain_cursor *cursor = &session->callchain_cursor;
+        struct callchain_cursor *cursor = &evsel->hists.callchain_cursor;
         struct callchain_cursor_node *node;
 
-        if (perf_event__preprocess_sample(event, session, &al, sample,
+        if (perf_event__preprocess_sample(event, machine, &al, sample,
                                           NULL) < 0) {
                 error("problem processing %d event, skipping it.\n",
                         event->header.type);
@@ -1255,7 +1309,7 @@ void perf_session__print_ip(union perf_event *event,
 
         if (symbol_conf.use_callchain && sample->callchain) {
 
-                if (perf_session__resolve_callchain(session, al.thread,
+                if (machine__resolve_callchain(machine, evsel, al.thread,
                                                 sample->callchain, NULL) != 0) {
                         if (verbose)
                                 error("Failed to resolve callchain. Skipping\n");
@@ -1333,6 +1387,10 @@ int perf_session__cpu_bitmap(struct perf_session *session,
         }
 
         map = cpu_map__new(cpu_list);
+        if (map == NULL) {
+                pr_err("Invalid cpu_list\n");
+                return -1;
+        }
 
         for (i = 0; i < map->nr; i++) {
                 int cpu = map->map[i];
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 6e393c98eb34..37bc38381fb6 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -30,9 +30,6 @@ struct perf_session {
         struct perf_header      header;
         unsigned long           size;
         unsigned long           mmap_window;
-        struct rb_root          threads;
-        struct list_head        dead_threads;
-        struct thread           *last_match;
         struct machine          host_machine;
         struct rb_root          machines;
         struct perf_evlist      *evlist;
@@ -53,65 +50,31 @@ struct perf_session {
         int                     cwdlen;
         char                    *cwd;
         struct ordered_samples  ordered_samples;
-        struct callchain_cursor callchain_cursor;
-        char                    filename[0];
+        char                    filename[1];
 };
 
-struct perf_evsel;
-struct perf_event_ops;
-
-typedef int (*event_sample)(union perf_event *event, struct perf_sample *sample,
-                            struct perf_evsel *evsel, struct perf_session *session);
-typedef int (*event_op)(union perf_event *self, struct perf_sample *sample,
-                        struct perf_session *session);
-typedef int (*event_synth_op)(union perf_event *self,
-                              struct perf_session *session);
-typedef int (*event_op2)(union perf_event *self, struct perf_session *session,
-                         struct perf_event_ops *ops);
-
-struct perf_event_ops {
-        event_sample    sample;
-        event_op        mmap,
-                        comm,
-                        fork,
-                        exit,
-                        lost,
-                        read,
-                        throttle,
-                        unthrottle;
-        event_synth_op  attr,
-                        event_type,
-                        tracing_data,
-                        build_id;
-        event_op2       finished_round;
-        bool            ordered_samples;
-        bool            ordering_requires_timestamps;
-};
+struct perf_tool;
 
 struct perf_session *perf_session__new(const char *filename, int mode,
                                        bool force, bool repipe,
-                                       struct perf_event_ops *ops);
+                                       struct perf_tool *tool);
 void perf_session__delete(struct perf_session *self);
 
 void perf_event_header__bswap(struct perf_event_header *self);
 
 int __perf_session__process_events(struct perf_session *self,
                                    u64 data_offset, u64 data_size, u64 size,
-                                   struct perf_event_ops *ops);
+                                   struct perf_tool *tool);
 int perf_session__process_events(struct perf_session *self,
-                                 struct perf_event_ops *event_ops);
+                                 struct perf_tool *tool);
 
-int perf_session__resolve_callchain(struct perf_session *self,
+int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel *evsel,
                                     struct thread *thread,
                                     struct ip_callchain *chain,
                                     struct symbol **parent);
 
 bool perf_session__has_traces(struct perf_session *self, const char *msg);
 
-int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
-                                             const char *symbol_name,
-                                             u64 addr);
-
 void mem_bswap_64(void *src, int byte_size);
 void perf_event__attr_swap(struct perf_event_attr *attr);
 
@@ -144,12 +107,16 @@ struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t p
 
 static inline
 void perf_session__process_machines(struct perf_session *self,
+                                    struct perf_tool *tool,
                                     machine__process_t process)
 {
-        process(&self->host_machine, self);
-        return machines__process(&self->machines, process, self);
+        process(&self->host_machine, tool);
+        return machines__process(&self->machines, process, tool);
 }
 
+struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
+size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
+
 size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp);
 
 size_t perf_session__fprintf_dsos_buildid(struct perf_session *self,
@@ -167,13 +134,20 @@ static inline int perf_session__parse_sample(struct perf_session *session,
                                         session->header.needs_swap);
 }
 
+static inline int perf_session__synthesize_sample(struct perf_session *session,
+                                                  union perf_event *event,
+                                                  const struct perf_sample *sample)
+{
+        return perf_event__synthesize_sample(event, session->sample_type,
+                                             sample, session->header.needs_swap);
+}
+
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
                                             unsigned int type);
 
-void perf_session__print_ip(union perf_event *event,
-                                 struct perf_sample *sample,
-                                 struct perf_session *session,
-                                 int print_sym, int print_dso);
+void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
+                          struct machine *machine, struct perf_evsel *evsel,
+                          int print_sym, int print_dso);
 
 int perf_session__cpu_bitmap(struct perf_session *session,
                              const char *cpu_list, unsigned long *cpu_bitmap);
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 95d370074928..36d4c5619575 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -27,7 +27,8 @@ build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 perf = Extension('perf',
                   sources = ['util/python.c', 'util/ctype.c', 'util/evlist.c',
                              'util/evsel.c', 'util/cpumap.c', 'util/thread_map.c',
-                             'util/util.c', 'util/xyarray.c', 'util/cgroup.c'],
+                             'util/util.c', 'util/xyarray.c', 'util/cgroup.c',
+                             'util/debugfs.c'],
                   include_dirs = ['util/include'],
                   extra_compile_args = cflags,
                  )
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 632b50c7bc26..215d50f2042e 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1757,7 +1757,7 @@ static int map_groups__set_modules_path_dir(struct map_groups *mg,
                 struct stat st;
 
                 /*sshfs might return bad dent->d_type, so we have to stat*/
-                sprintf(path, "%s/%s", dir_name, dent->d_name);
+                snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
                 if (stat(path, &st))
                         continue;
 
@@ -1766,8 +1766,6 @@ static int map_groups__set_modules_path_dir(struct map_groups *mg,
                             !strcmp(dent->d_name, ".."))
                                 continue;
 
-                        snprintf(path, sizeof(path), "%s/%s",
-                                 dir_name, dent->d_name);
                         ret = map_groups__set_modules_path_dir(mg, path);
                         if (ret < 0)
                                 goto out;
@@ -1788,9 +1786,6 @@ static int map_groups__set_modules_path_dir(struct map_groups *mg,
                         if (map == NULL)
                                 continue;
 
-                        snprintf(path, sizeof(path), "%s/%s",
-                                 dir_name, dent->d_name);
-
                         long_name = strdup(path);
                         if (long_name == NULL) {
                                 ret = -1;
@@ -2609,10 +2604,10 @@ int symbol__init(void)
         symbol_conf.initialized = true;
         return 0;
 
-out_free_dso_list:
-        strlist__delete(symbol_conf.dso_list);
 out_free_comm_list:
         strlist__delete(symbol_conf.comm_list);
+out_free_dso_list:
+        strlist__delete(symbol_conf.dso_list);
         return -1;
 }
 
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 29f8d742e92f..123c2e14353e 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -68,6 +68,7 @@ struct strlist;
 
 struct symbol_conf {
         unsigned short  priv_size;
+        unsigned short  nr_events;
         bool            try_vmlinux_path,
                         use_modules,
                         sort_by_name,
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index d5d3b22250f3..fb4b7ea6752f 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -61,7 +61,7 @@ static size_t thread__fprintf(struct thread *self, FILE *fp)
                map_groups__fprintf(&self->mg, verbose, fp);
 }
 
-struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
+struct thread *machine__findnew_thread(struct machine *self, pid_t pid)
 {
         struct rb_node **p = &self->threads.rb_node;
         struct rb_node *parent = NULL;
@@ -125,12 +125,12 @@ int thread__fork(struct thread *self, struct thread *parent)
         return 0;
 }
 
-size_t perf_session__fprintf(struct perf_session *self, FILE *fp)
+size_t machine__fprintf(struct machine *machine, FILE *fp)
 {
         size_t ret = 0;
         struct rb_node *nd;
 
-        for (nd = rb_first(&self->threads); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 
                 ret += thread__fprintf(pos, fp);
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index e5f2401c1b5e..70c2c13ff679 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -18,16 +18,14 @@ struct thread {
         int                     comm_len;
 };
 
-struct perf_session;
+struct machine;
 
 void thread__delete(struct thread *self);
 
 int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
-struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
 void thread__insert_map(struct thread *self, struct map *map);
 int thread__fork(struct thread *self, struct thread *parent);
-size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
 
 static inline struct map *thread__find_map(struct thread *self,
                                            enum map_type type, u64 addr)
@@ -35,14 +33,12 @@ static inline struct map *thread__find_map(struct thread *self,
         return self ? map_groups__find(&self->mg, type, addr) : NULL;
 }
 
-void thread__find_addr_map(struct thread *self,
-                           struct perf_session *session, u8 cpumode,
-                           enum map_type type, pid_t pid, u64 addr,
+void thread__find_addr_map(struct thread *thread, struct machine *machine,
+                           u8 cpumode, enum map_type type, u64 addr,
                            struct addr_location *al);
 
-void thread__find_addr_location(struct thread *self,
-                                struct perf_session *session, u8 cpumode,
-                                enum map_type type, pid_t pid, u64 addr,
+void thread__find_addr_location(struct thread *thread, struct machine *machine,
+                                u8 cpumode, enum map_type type, u64 addr,
                                 struct addr_location *al,
                                 symbol_filter_t filter);
 #endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
new file mode 100644
index 000000000000..b0e1aadba8d5
--- /dev/null
+++ b/tools/perf/util/tool.h
@@ -0,0 +1,50 @@
+#ifndef __PERF_TOOL_H
+#define __PERF_TOOL_H
+
+#include <stdbool.h>
+
+struct perf_session;
+union perf_event;
+struct perf_evlist;
+struct perf_evsel;
+struct perf_sample;
+struct perf_tool;
+struct machine;
+
+typedef int (*event_sample)(struct perf_tool *tool, union perf_event *event,
+                            struct perf_sample *sample,
+                            struct perf_evsel *evsel, struct machine *machine);
+
+typedef int (*event_op)(struct perf_tool *tool, union perf_event *event,
+                        struct perf_sample *sample, struct machine *machine);
+
+typedef int (*event_attr_op)(union perf_event *event,
+                             struct perf_evlist **pevlist);
+typedef int (*event_simple_op)(struct perf_tool *tool, union perf_event *event);
+
+typedef int (*event_synth_op)(union perf_event *event,
+                              struct perf_session *session);
+
+typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
+                         struct perf_session *session);
+
+struct perf_tool {
+        event_sample    sample,
+                        read;
+        event_op        mmap,
+                        comm,
+                        fork,
+                        exit,
+                        lost,
+                        throttle,
+                        unthrottle;
+        event_attr_op   attr;
+        event_synth_op  tracing_data;
+        event_simple_op event_type;
+        event_op2       finished_round,
+                        build_id;
+        bool            ordered_samples;
+        bool            ordering_requires_timestamps;
+};
+
+#endif /* __PERF_TOOL_H */
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index 399650967958..a248f3c2c60d 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -1,15 +1,17 @@
 #ifndef __PERF_TOP_H
 #define __PERF_TOP_H 1
 
+#include "tool.h"
 #include "types.h"
-#include "../perf.h"
 #include <stddef.h>
+#include <stdbool.h>
 
 struct perf_evlist;
 struct perf_evsel;
 struct perf_session;
 
 struct perf_top {
+        struct perf_tool   tool;
         struct perf_evlist *evlist;
         /*
          * Symbols will be added here in perf_event__process_sample and will
@@ -23,10 +25,26 @@ struct perf_top {
         int                freq;
         pid_t              target_pid, target_tid;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
+        bool               system_wide;
+        bool               use_tui, use_stdio;
+        bool               sort_has_symbols;
+        bool               dont_use_callchains;
+        bool               kptr_restrict_warned;
+        bool               vmlinux_warned;
+        bool               inherit;
+        bool               group;
+        bool               sample_id_all_avail;
+        bool               dump_symtab;
         const char         *cpu_list;
         struct hist_entry  *sym_filter_entry;
         struct perf_evsel  *sym_evsel;
         struct perf_session *session;
+        struct winsize     winsize;
+        unsigned int       mmap_pages;
+        int                default_interval;
+        int                realtime_prio;
+        int                sym_pcnt_filter;
+        const char         *sym_filter;
 };
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index d2655f08bcc0..fc22cf5c605f 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -18,7 +18,7 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#define _GNU_SOURCE
+#include "util.h"
 #include <dirent.h>
 #include <mntent.h>
 #include <stdio.h>
@@ -31,7 +31,6 @@
 #include <pthread.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include <ctype.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <linux/list.h>
@@ -44,10 +43,6 @@
 
 #define VERSION "0.5"
 
-#define _STR(x) #x
-#define STR(x) _STR(x)
-#define MAX_PATH 256
-
 #define TRACE_CTRL      "tracing_on"
 #define TRACE           "trace"
 #define AVAILABLE       "available_tracers"
@@ -73,26 +68,6 @@ struct events {
 };
 
 
-
-static void die(const char *fmt, ...)
-{
-        va_list ap;
-        int ret = errno;
-
-        if (errno)
-                perror("perf");
-        else
-                ret = -1;
-
-        va_start(ap, fmt);
-        fprintf(stderr, "  ");
-        vfprintf(stderr, fmt, ap);
-        va_end(ap);
-
-        fprintf(stderr, "\n");
-        exit(ret);
-}
-
 void *malloc_or_die(unsigned int size)
 {
         void *data;
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 0a7ed5b5e281..6c164dc9ee95 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -1537,6 +1537,8 @@ process_flags(struct event *event, struct print_arg *arg, char **tok)
         field = malloc_or_die(sizeof(*field));
 
         type = process_arg(event, field, &token);
+        while (type == EVENT_OP)
+                type = process_op(event, field, &token);
         if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index c9dcbec7d800..a3fdf55f317b 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -39,7 +39,7 @@ static int stop_script_unsupported(void)
 static void process_event_unsupported(union perf_event *event __unused,
                                       struct perf_sample *sample __unused,
                                       struct perf_evsel *evsel __unused,
-                                      struct perf_session *session __unused,
+                                      struct machine *machine __unused,
                                       struct thread *thread __unused)
 {
 }
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index a84100817649..58ae14c5baac 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -3,7 +3,11 @@
 
 #include <stdbool.h>
 #include "parse-events.h"
-#include "session.h"
+
+struct machine;
+struct perf_sample;
+union perf_event;
+struct thread;
 
 #define __unused __attribute__((unused))
 
@@ -292,7 +296,7 @@ struct scripting_ops {
         void (*process_event) (union perf_event *event,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
-                               struct perf_session *session,
+                               struct machine *machine,
                                struct thread *thread);
         int (*generate_script) (const char *outfile);
 };
diff --git a/tools/perf/util/ui/browsers/annotate.c b/tools/perf/util/ui/browsers/annotate.c
index 0575905d1205..295a9c93f945 100644
--- a/tools/perf/util/ui/browsers/annotate.c
+++ b/tools/perf/util/ui/browsers/annotate.c
@@ -224,7 +224,7 @@ static bool annotate_browser__toggle_source(struct annotate_browser *browser)
 }
 
 static int annotate_browser__run(struct annotate_browser *self, int evidx,
-                                 int nr_events, void(*timer)(void *arg),
+                                 void(*timer)(void *arg),
                                  void *arg, int delay_secs)
 {
         struct rb_node *nd = NULL;
@@ -328,8 +328,7 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                                 notes = symbol__annotation(target);
                                 pthread_mutex_lock(&notes->lock);
 
-                                if (notes->src == NULL &&
-                                    symbol__alloc_hist(target, nr_events) < 0) {
+                                if (notes->src == NULL && symbol__alloc_hist(target) < 0) {
                                         pthread_mutex_unlock(&notes->lock);
                                         ui__warning("Not enough memory for annotating '%s' symbol!\n",
                                                     target->name);
@@ -337,7 +336,7 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                                 }
 
                                 pthread_mutex_unlock(&notes->lock);
-                                symbol__tui_annotate(target, ms->map, evidx, nr_events,
+                                symbol__tui_annotate(target, ms->map, evidx,
                                                      timer, arg, delay_secs);
                         }
                         continue;
@@ -358,15 +357,15 @@ out:
         return key;
 }
 
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx, int nr_events,
+int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
                              void(*timer)(void *arg), void *arg, int delay_secs)
 {
-        return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx, nr_events,
+        return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx,
                                     timer, arg, delay_secs);
 }
 
 int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
-                         int nr_events, void(*timer)(void *arg), void *arg,
+                         void(*timer)(void *arg), void *arg,
                          int delay_secs)
 {
         struct objdump_line *pos, *n;
@@ -419,8 +418,7 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
         browser.b.nr_entries = browser.nr_entries;
         browser.b.entries = &notes->src->source,
         browser.b.width += 18; /* Percentage */
-        ret = annotate_browser__run(&browser, evidx, nr_events,
-                                    timer, arg, delay_secs);
+        ret = annotate_browser__run(&browser, evidx, timer, arg, delay_secs);
         list_for_each_entry_safe(pos, n, &notes->src->source, node) {
                 list_del(&pos->node);
                 objdump_line__free(pos);
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/util/ui/browsers/hists.c
index d0c94b459685..1212a386a033 100644
--- a/tools/perf/util/ui/browsers/hists.c
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -1020,7 +1020,7 @@ do_annotate:
                          * Don't let this be freed, say, by hists__decay_entry.
                          */
                         he->used = true;
-                        err = hist_entry__tui_annotate(he, evsel->idx, nr_events,
+                        err = hist_entry__tui_annotate(he, evsel->idx,
                                                        timer, arg, delay_secs);
                         he->used = false;
                         ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
diff --git a/tools/perf/util/ui/progress.c b/tools/perf/util/ui/progress.c
index 295e366b6311..13aa64e50e11 100644
--- a/tools/perf/util/ui/progress.c
+++ b/tools/perf/util/ui/progress.c
@@ -14,6 +14,9 @@ void ui_progress__update(u64 curr, u64 total, const char *title)
         if (use_browser <= 0)
                 return;
 
+        if (total == 0)
+                return;
+
         ui__refresh_dimensions(true);
         pthread_mutex_lock(&ui__lock);
         y = SLtt_Screen_Rows / 2 - 2;
diff --git a/tools/perf/util/usage.c b/tools/perf/util/usage.c
index e16bf9a707e8..d76d1c0ff98f 100644
--- a/tools/perf/util/usage.c
+++ b/tools/perf/util/usage.c
@@ -1,5 +1,8 @@
 /*
- * GIT - The information manager from hell
+ * usage.c
+ *
+ * Various reporting routines.
+ * Originally copied from GIT source.
  *
  * Copyright (C) Linus Torvalds, 2005
  */
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 5b3ea49aa63e..813141047fc2 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -1,6 +1,21 @@
+#include "../perf.h"
 #include "util.h"
 #include <sys/mman.h>
 
+/*
+ * XXX We need to find a better place for these things...
+ */
+bool perf_host  = true;
+bool perf_guest = true;
+
+void event_attr_init(struct perf_event_attr *attr)
+{
+        if (!perf_host)
+                attr->exclude_host  = 1;
+        if (!perf_guest)
+                attr->exclude_guest = 1;
+}
+
 int mkdir_p(char *path, mode_t mode)
 {
         struct stat st;
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 0128906bac88..b9c530cce79a 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -242,7 +242,22 @@ int strtailcmp(const char *s1, const char *s2);
 unsigned long convert_unit(unsigned long value, char *unit);
 int readn(int fd, void *buf, size_t size);
 
+struct perf_event_attr;
+
+void event_attr_init(struct perf_event_attr *attr);
+
 #define _STR(x) #x
 #define STR(x) _STR(x)
 
+/*
+ *  Determine whether some value is a power of two, where zero is
+ * *not* considered a power of two.
+ */
+
+static inline __attribute__((const))
+bool is_power_of_2(unsigned long n)
+{
+        return (n != 0 && ((n & (n - 1)) == 0));
+}
+
 #endif
diff --git a/tools/perf/util/values.c b/tools/perf/util/values.c
index bdd33470b235..697c8b4e59cc 100644
--- a/tools/perf/util/values.c
+++ b/tools/perf/util/values.c
@@ -32,6 +32,7 @@ void perf_read_values_destroy(struct perf_read_values *values)
 
         for (i = 0; i < values->threads; i++)
                 free(values->value[i]);
+        free(values->value);
         free(values->pid);
         free(values->tid);
         free(values->counterrawid);