Merge commit '8700c95adb03' into timers/nohz

The full dynticks tree needs the latest RCU and sched
upstream updates in order to fix some dependencies.

Merge a common upstream merge point that has these
updates.

Conflicts:
	include/linux/perf_event.h
	kernel/rcutree.h
	kernel/rcutree_plugin.h

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>

35 files changed, 1519 insertions, 805 deletions

diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index d33fe937e6f1..d102716c43a1 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -14,6 +14,7 @@
 #include "symbol.h"
 #include "debug.h"
 #include "annotate.h"
+#include "evsel.h"
 #include <pthread.h>
 #include <linux/bitops.h>
 
@@ -602,8 +603,42 @@ struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disa
         return NULL;
 }
 
+double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
+                            s64 end, const char **path)
+{
+        struct source_line *src_line = notes->src->lines;
+        double percent = 0.0;
+
+        if (src_line) {
+                size_t sizeof_src_line = sizeof(*src_line) +
+                                sizeof(src_line->p) * (src_line->nr_pcnt - 1);
+
+                while (offset < end) {
+                        src_line = (void *)notes->src->lines +
+                                        (sizeof_src_line * offset);
+
+                        if (*path == NULL)
+                                *path = src_line->path;
+
+                        percent += src_line->p[evidx].percent;
+                        offset++;
+                }
+        } else {
+                struct sym_hist *h = annotation__histogram(notes, evidx);
+                unsigned int hits = 0;
+
+                while (offset < end)
+                        hits += h->addr[offset++];
+
+                if (h->sum)
+                        percent = 100.0 * hits / h->sum;
+        }
+
+        return percent;
+}
+
 static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 start,
-                      int evidx, u64 len, int min_pcnt, int printed,
+                      struct perf_evsel *evsel, u64 len, int min_pcnt, int printed,
                       int max_lines, struct disasm_line *queue)
 {
         static const char *prev_line;
@@ -611,34 +646,37 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
 
         if (dl->offset != -1) {
                 const char *path = NULL;
-                unsigned int hits = 0;
-                double percent = 0.0;
+                double percent, max_percent = 0.0;
+                double *ppercents = &percent;
+                int i, nr_percent = 1;
                 const char *color;
                 struct annotation *notes = symbol__annotation(sym);
-                struct source_line *src_line = notes->src->lines;
-                struct sym_hist *h = annotation__histogram(notes, evidx);
                 s64 offset = dl->offset;
                 const u64 addr = start + offset;
                 struct disasm_line *next;
 
                 next = disasm__get_next_ip_line(&notes->src->source, dl);
 
-                while (offset < (s64)len &&
-                       (next == NULL || offset < next->offset)) {
-                        if (src_line) {
-                                if (path == NULL)
-                                        path = src_line[offset].path;
-                                percent += src_line[offset].percent;
-                        } else
-                                hits += h->addr[offset];
-
-                        ++offset;
+                if (perf_evsel__is_group_event(evsel)) {
+                        nr_percent = evsel->nr_members;
+                        ppercents = calloc(nr_percent, sizeof(double));
+                        if (ppercents == NULL)
+                                return -1;
                 }
 
-                if (src_line == NULL && h->sum)
-                        percent = 100.0 * hits / h->sum;
+                for (i = 0; i < nr_percent; i++) {
+                        percent = disasm__calc_percent(notes,
+                                        notes->src->lines ? i : evsel->idx + i,
+                                        offset,
+                                        next ? next->offset : (s64) len,
+                                        &path);
+
+                        ppercents[i] = percent;
+                        if (percent > max_percent)
+                                max_percent = percent;
+                }
 
-                if (percent < min_pcnt)
+                if (max_percent < min_pcnt)
                         return -1;
 
                 if (max_lines && printed >= max_lines)
@@ -648,12 +686,12 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
                         list_for_each_entry_from(queue, &notes->src->source, node) {
                                 if (queue == dl)
                                         break;
-                                disasm_line__print(queue, sym, start, evidx, len,
+                                disasm_line__print(queue, sym, start, evsel, len,
                                                     0, 0, 1, NULL);
                         }
                 }
 
-                color = get_percent_color(percent);
+                color = get_percent_color(max_percent);
 
                 /*
                  * Also color the filename and line if needed, with
@@ -669,25 +707,59 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
                         }
                 }
 
-                color_fprintf(stdout, color, " %7.2f", percent);
+                for (i = 0; i < nr_percent; i++) {
+                        percent = ppercents[i];
+                        color = get_percent_color(percent);
+                        color_fprintf(stdout, color, " %7.2f", percent);
+                }
+
                 printf(" :      ");
                 color_fprintf(stdout, PERF_COLOR_MAGENTA, "  %" PRIx64 ":", addr);
                 color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", dl->line);
+
+                if (ppercents != &percent)
+                        free(ppercents);
+
         } else if (max_lines && printed >= max_lines)
                 return 1;
         else {
+                int width = 8;
+
                 if (queue)
                         return -1;
 
+                if (perf_evsel__is_group_event(evsel))
+                        width *= evsel->nr_members;
+
                 if (!*dl->line)
-                        printf("         :\n");
+                        printf(" %*s:\n", width, " ");
                 else
-                        printf("         :      %s\n", dl->line);
+                        printf(" %*s:   %s\n", width, " ", dl->line);
         }
 
         return 0;
 }
 
+/*
+ * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw)
+ * which looks like following
+ *
+ *  0000000000415500 <_init>:
+ *    415500:       sub    $0x8,%rsp
+ *    415504:       mov    0x2f5ad5(%rip),%rax        # 70afe0 <_DYNAMIC+0x2f8>
+ *    41550b:       test   %rax,%rax
+ *    41550e:       je     415515 <_init+0x15>
+ *    415510:       callq  416e70 <__gmon_start__@plt>
+ *    415515:       add    $0x8,%rsp
+ *    415519:       retq
+ *
+ * it will be parsed and saved into struct disasm_line as
+ *  <offset>       <name>  <ops.raw>
+ *
+ * The offset will be a relative offset from the start of the symbol and -1
+ * means that it's not a disassembly line so should be treated differently.
+ * The ops.raw part will be parsed further according to type of the instruction.
+ */
 static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                                       FILE *file, size_t privsize)
 {
@@ -858,7 +930,7 @@ static void insert_source_line(struct rb_root *root, struct source_line *src_lin
         struct source_line *iter;
         struct rb_node **p = &root->rb_node;
         struct rb_node *parent = NULL;
-        int ret;
+        int i, ret;
 
         while (*p != NULL) {
                 parent = *p;
@@ -866,7 +938,8 @@ static void insert_source_line(struct rb_root *root, struct source_line *src_lin
 
                 ret = strcmp(iter->path, src_line->path);
                 if (ret == 0) {
-                        iter->percent_sum += src_line->percent;
+                        for (i = 0; i < src_line->nr_pcnt; i++)
+                                iter->p[i].percent_sum += src_line->p[i].percent;
                         return;
                 }
 
@@ -876,12 +949,26 @@ static void insert_source_line(struct rb_root *root, struct source_line *src_lin
                         p = &(*p)->rb_right;
         }
 
-        src_line->percent_sum = src_line->percent;
+        for (i = 0; i < src_line->nr_pcnt; i++)
+                src_line->p[i].percent_sum = src_line->p[i].percent;
 
         rb_link_node(&src_line->node, parent, p);
         rb_insert_color(&src_line->node, root);
 }
 
+static int cmp_source_line(struct source_line *a, struct source_line *b)
+{
+        int i;
+
+        for (i = 0; i < a->nr_pcnt; i++) {
+                if (a->p[i].percent_sum == b->p[i].percent_sum)
+                        continue;
+                return a->p[i].percent_sum > b->p[i].percent_sum;
+        }
+
+        return 0;
+}
+
 static void __resort_source_line(struct rb_root *root, struct source_line *src_line)
 {
         struct source_line *iter;
@@ -892,7 +979,7 @@ static void __resort_source_line(struct rb_root *root, struct source_line *src_l
                 parent = *p;
                 iter = rb_entry(parent, struct source_line, node);
 
-                if (src_line->percent_sum > iter->percent_sum)
+                if (cmp_source_line(src_line, iter))
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -924,32 +1011,52 @@ static void symbol__free_source_line(struct symbol *sym, int len)
 {
         struct annotation *notes = symbol__annotation(sym);
         struct source_line *src_line = notes->src->lines;
+        size_t sizeof_src_line;
         int i;
 
-        for (i = 0; i < len; i++)
-                free(src_line[i].path);
+        sizeof_src_line = sizeof(*src_line) +
+                          (sizeof(src_line->p) * (src_line->nr_pcnt - 1));
+
+        for (i = 0; i < len; i++) {
+                free(src_line->path);
+                src_line = (void *)src_line + sizeof_src_line;
+        }
 
-        free(src_line);
+        free(notes->src->lines);
         notes->src->lines = NULL;
 }
 
 /* Get the filename:line for the colored entries */
 static int symbol__get_source_line(struct symbol *sym, struct map *map,
-                                   int evidx, struct rb_root *root, int len,
+                                   struct perf_evsel *evsel,
+                                   struct rb_root *root, int len,
                                    const char *filename)
 {
         u64 start;
-        int i;
+        int i, k;
+        int evidx = evsel->idx;
         char cmd[PATH_MAX * 2];
         struct source_line *src_line;
         struct annotation *notes = symbol__annotation(sym);
         struct sym_hist *h = annotation__histogram(notes, evidx);
         struct rb_root tmp_root = RB_ROOT;
+        int nr_pcnt = 1;
+        u64 h_sum = h->sum;
+        size_t sizeof_src_line = sizeof(struct source_line);
+
+        if (perf_evsel__is_group_event(evsel)) {
+                for (i = 1; i < evsel->nr_members; i++) {
+                        h = annotation__histogram(notes, evidx + i);
+                        h_sum += h->sum;
+                }
+                nr_pcnt = evsel->nr_members;
+                sizeof_src_line += (nr_pcnt - 1) * sizeof(src_line->p);
+        }
 
-        if (!h->sum)
+        if (!h_sum)
                 return 0;
 
-        src_line = notes->src->lines = calloc(len, sizeof(struct source_line));
+        src_line = notes->src->lines = calloc(len, sizeof_src_line);
         if (!notes->src->lines)
                 return -1;
 
@@ -960,29 +1067,41 @@ static int symbol__get_source_line(struct symbol *sym, struct map *map,
                 size_t line_len;
                 u64 offset;
                 FILE *fp;
+                double percent_max = 0.0;
 
-                src_line[i].percent = 100.0 * h->addr[i] / h->sum;
-                if (src_line[i].percent <= 0.5)
-                        continue;
+                src_line->nr_pcnt = nr_pcnt;
+
+                for (k = 0; k < nr_pcnt; k++) {
+                        h = annotation__histogram(notes, evidx + k);
+                        src_line->p[k].percent = 100.0 * h->addr[i] / h->sum;
+
+                        if (src_line->p[k].percent > percent_max)
+                                percent_max = src_line->p[k].percent;
+                }
+
+                if (percent_max <= 0.5)
+                        goto next;
 
                 offset = start + i;
                 sprintf(cmd, "addr2line -e %s %016" PRIx64, filename, offset);
                 fp = popen(cmd, "r");
                 if (!fp)
-                        continue;
+                        goto next;
 
                 if (getline(&path, &line_len, fp) < 0 || !line_len)
-                        goto next;
+                        goto next_close;
 
-                src_line[i].path = malloc(sizeof(char) * line_len + 1);
-                if (!src_line[i].path)
-                        goto next;
+                src_line->path = malloc(sizeof(char) * line_len + 1);
+                if (!src_line->path)
+                        goto next_close;
 
-                strcpy(src_line[i].path, path);
-                insert_source_line(&tmp_root, &src_line[i]);
+                strcpy(src_line->path, path);
+                insert_source_line(&tmp_root, src_line);
 
-        next:
+        next_close:
                 pclose(fp);
+        next:
+                src_line = (void *)src_line + sizeof_src_line;
         }
 
         resort_source_line(root, &tmp_root);
@@ -1004,24 +1123,33 @@ static void print_summary(struct rb_root *root, const char *filename)
 
         node = rb_first(root);
         while (node) {
-                double percent;
+                double percent, percent_max = 0.0;
                 const char *color;
                 char *path;
+                int i;
 
                 src_line = rb_entry(node, struct source_line, node);
-                percent = src_line->percent_sum;
-                color = get_percent_color(percent);
+                for (i = 0; i < src_line->nr_pcnt; i++) {
+                        percent = src_line->p[i].percent_sum;
+                        color = get_percent_color(percent);
+                        color_fprintf(stdout, color, " %7.2f", percent);
+
+                        if (percent > percent_max)
+                                percent_max = percent;
+                }
+
                 path = src_line->path;
+                color = get_percent_color(percent_max);
+                color_fprintf(stdout, color, " %s", path);
 
-                color_fprintf(stdout, color, " %7.2f %s", percent, path);
                 node = rb_next(node);
         }
 }
 
-static void symbol__annotate_hits(struct symbol *sym, int evidx)
+static void symbol__annotate_hits(struct symbol *sym, struct perf_evsel *evsel)
 {
         struct annotation *notes = symbol__annotation(sym);
-        struct sym_hist *h = annotation__histogram(notes, evidx);
+        struct sym_hist *h = annotation__histogram(notes, evsel->idx);
         u64 len = symbol__size(sym), offset;
 
         for (offset = 0; offset < len; ++offset)
@@ -1031,9 +1159,9 @@ static void symbol__annotate_hits(struct symbol *sym, int evidx)
         printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->sum", h->sum);
 }
 
-int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
-                            bool full_paths, int min_pcnt, int max_lines,
-                            int context)
+int symbol__annotate_printf(struct symbol *sym, struct map *map,
+                            struct perf_evsel *evsel, bool full_paths,
+                            int min_pcnt, int max_lines, int context)
 {
         struct dso *dso = map->dso;
         char *filename;
@@ -1044,6 +1172,8 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
         int printed = 2, queue_len = 0;
         int more = 0;
         u64 len;
+        int width = 8;
+        int namelen;
 
         filename = strdup(dso->long_name);
         if (!filename)
@@ -1055,12 +1185,18 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                 d_filename = basename(filename);
 
         len = symbol__size(sym);
+        namelen = strlen(d_filename);
+
+        if (perf_evsel__is_group_event(evsel))
+                width *= evsel->nr_members;
 
-        printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
-        printf("------------------------------------------------\n");
+        printf(" %-*.*s|        Source code & Disassembly of %s\n",
+               width, width, "Percent", d_filename);
+        printf("-%-*.*s-------------------------------------\n",
+               width+namelen, width+namelen, graph_dotted_line);
 
         if (verbose)
-                symbol__annotate_hits(sym, evidx);
+                symbol__annotate_hits(sym, evsel);
 
         list_for_each_entry(pos, &notes->src->source, node) {
                 if (context && queue == NULL) {
@@ -1068,7 +1204,7 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                         queue_len = 0;
                 }
 
-                switch (disasm_line__print(pos, sym, start, evidx, len,
+                switch (disasm_line__print(pos, sym, start, evsel, len,
                                             min_pcnt, printed, max_lines,
                                             queue)) {
                 case 0:
@@ -1163,9 +1299,9 @@ size_t disasm__fprintf(struct list_head *head, FILE *fp)
         return printed;
 }
 
-int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
-                         bool print_lines, bool full_paths, int min_pcnt,
-                         int max_lines)
+int symbol__tty_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel, bool print_lines,
+                         bool full_paths, int min_pcnt, int max_lines)
 {
         struct dso *dso = map->dso;
         const char *filename = dso->long_name;
@@ -1178,12 +1314,12 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
         len = symbol__size(sym);
 
         if (print_lines) {
-                symbol__get_source_line(sym, map, evidx, &source_line,
+                symbol__get_source_line(sym, map, evsel, &source_line,
                                         len, filename);
                 print_summary(&source_line, filename);
         }
 
-        symbol__annotate_printf(sym, map, evidx, full_paths,
+        symbol__annotate_printf(sym, map, evsel, full_paths,
                                 min_pcnt, max_lines, 0);
         if (print_lines)
                 symbol__free_source_line(sym, len);
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index c422440fe611..af755156d278 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -50,6 +50,8 @@ bool ins__is_jump(const struct ins *ins);
 bool ins__is_call(const struct ins *ins);
 int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops);
 
+struct annotation;
+
 struct disasm_line {
         struct list_head    node;
         s64                 offset;
@@ -68,17 +70,24 @@ void disasm_line__free(struct disasm_line *dl);
 struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos);
 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw);
 size_t disasm__fprintf(struct list_head *head, FILE *fp);
+double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
+                            s64 end, const char **path);
 
 struct sym_hist {
         u64             sum;
         u64             addr[0];
 };
 
-struct source_line {
-        struct rb_node  node;
+struct source_line_percent {
         double          percent;
         double          percent_sum;
+};
+
+struct source_line {
+        struct rb_node  node;
         char            *path;
+        int             nr_pcnt;
+        struct source_line_percent p[1];
 };
 
 /** struct annotated_source - symbols with hits have this attached as in sannotation
@@ -130,47 +139,49 @@ void symbol__annotate_zero_histograms(struct symbol *sym);
 
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize);
 int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym);
-int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
-                            bool full_paths, int min_pcnt, int max_lines,
-                            int context);
+int symbol__annotate_printf(struct symbol *sym, struct map *map,
+                            struct perf_evsel *evsel, bool full_paths,
+                            int min_pcnt, int max_lines, int context);
 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
 void disasm__purge(struct list_head *head);
 
-int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
-                         bool print_lines, bool full_paths, int min_pcnt,
-                         int max_lines);
+int symbol__tty_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel, bool print_lines,
+                         bool full_paths, int min_pcnt, int max_lines);
 
-#ifdef NEWT_SUPPORT
-int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
+#ifdef SLANG_SUPPORT
+int symbol__tui_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel,
                          struct hist_browser_timer *hbt);
 #else
 static inline int symbol__tui_annotate(struct symbol *sym __maybe_unused,
-                                       struct map *map __maybe_unused,
-                                       int evidx __maybe_unused,
-                                       struct hist_browser_timer *hbt
-                                       __maybe_unused)
+                                struct map *map __maybe_unused,
+                                struct perf_evsel *evsel  __maybe_unused,
+                                struct hist_browser_timer *hbt
+                                __maybe_unused)
 {
         return 0;
 }
 #endif
 
 #ifdef GTK2_SUPPORT
-int symbol__gtk_annotate(struct symbol *sym, struct map *map, int evidx,
+int symbol__gtk_annotate(struct symbol *sym, struct map *map,
+                         struct perf_evsel *evsel,
                          struct hist_browser_timer *hbt);
 
-static inline int hist_entry__gtk_annotate(struct hist_entry *he, int evidx,
+static inline int hist_entry__gtk_annotate(struct hist_entry *he,
+                                           struct perf_evsel *evsel,
                                            struct hist_browser_timer *hbt)
 {
-        return symbol__gtk_annotate(he->ms.sym, he->ms.map, evidx, hbt);
+        return symbol__gtk_annotate(he->ms.sym, he->ms.map, evsel, hbt);
 }
 
 void perf_gtk__show_annotations(void);
 #else
 static inline int hist_entry__gtk_annotate(struct hist_entry *he __maybe_unused,
-                                           int evidx __maybe_unused,
-                                           struct hist_browser_timer *hbt
-                                           __maybe_unused)
+                                struct perf_evsel *evsel __maybe_unused,
+                                struct hist_browser_timer *hbt __maybe_unused)
 {
         return 0;
 }
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index f817046e22b1..beb8cf9f9976 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -4,6 +4,7 @@
 #include "cpumap.h"
 #include <assert.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 static struct cpu_map *cpu_map__default_new(void)
 {
@@ -219,7 +220,7 @@ int cpu_map__get_socket(struct cpu_map *map, int idx)
         if (!mnt)
                 return -1;
 
-        sprintf(path,
+        snprintf(path, PATH_MAX,
                 "%s/devices/system/cpu/cpu%d/topology/physical_package_id",
                 mnt, cpu);
 
@@ -231,27 +232,88 @@ int cpu_map__get_socket(struct cpu_map *map, int idx)
         return ret == 1 ? cpu : -1;
 }
 
-int cpu_map__build_socket_map(struct cpu_map *cpus, struct cpu_map **sockp)
+static int cmp_ids(const void *a, const void *b)
 {
-        struct cpu_map *sock;
+        return *(int *)a - *(int *)b;
+}
+
+static int cpu_map__build_map(struct cpu_map *cpus, struct cpu_map **res,
+                              int (*f)(struct cpu_map *map, int cpu))
+{
+        struct cpu_map *c;
         int nr = cpus->nr;
         int cpu, s1, s2;
 
-        sock = calloc(1, sizeof(*sock) + nr * sizeof(int));
-        if (!sock)
+        /* allocate as much as possible */
+        c = calloc(1, sizeof(*c) + nr * sizeof(int));
+        if (!c)
                 return -1;
 
         for (cpu = 0; cpu < nr; cpu++) {
-                s1 = cpu_map__get_socket(cpus, cpu);
-                for (s2 = 0; s2 < sock->nr; s2++) {
-                        if (s1 == sock->map[s2])
+                s1 = f(cpus, cpu);
+                for (s2 = 0; s2 < c->nr; s2++) {
+                        if (s1 == c->map[s2])
                                 break;
                 }
-                if (s2 == sock->nr) {
-                        sock->map[sock->nr] = s1;
-                        sock->nr++;
+                if (s2 == c->nr) {
+                        c->map[c->nr] = s1;
+                        c->nr++;
                 }
         }
-        *sockp = sock;
+        /* ensure we process id in increasing order */
+        qsort(c->map, c->nr, sizeof(int), cmp_ids);
+
+        *res = c;
         return 0;
 }
+
+int cpu_map__get_core(struct cpu_map *map, int idx)
+{
+        FILE *fp;
+        const char *mnt;
+        char path[PATH_MAX];
+        int cpu, ret, s;
+
+        if (idx > map->nr)
+                return -1;
+
+        cpu = map->map[idx];
+
+        mnt = sysfs_find_mountpoint();
+        if (!mnt)
+                return -1;
+
+        snprintf(path, PATH_MAX,
+                "%s/devices/system/cpu/cpu%d/topology/core_id",
+                mnt, cpu);
+
+        fp = fopen(path, "r");
+        if (!fp)
+                return -1;
+        ret = fscanf(fp, "%d", &cpu);
+        fclose(fp);
+        if (ret != 1)
+                return -1;
+
+        s = cpu_map__get_socket(map, idx);
+        if (s == -1)
+                return -1;
+
+        /*
+         * encode socket in upper 16 bits
+         * core_id is relative to socket, and
+         * we need a global id. So we combine
+         * socket+ core id
+         */
+        return (s << 16) | (cpu & 0xffff);
+}
+
+int cpu_map__build_socket_map(struct cpu_map *cpus, struct cpu_map **sockp)
+{
+        return cpu_map__build_map(cpus, sockp, cpu_map__get_socket);
+}
+
+int cpu_map__build_core_map(struct cpu_map *cpus, struct cpu_map **corep)
+{
+        return cpu_map__build_map(cpus, corep, cpu_map__get_core);
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 161b00756a12..9bed02e5fb3d 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -15,7 +15,9 @@ void cpu_map__delete(struct cpu_map *map);
 struct cpu_map *cpu_map__read(FILE *file);
 size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp);
 int cpu_map__get_socket(struct cpu_map *map, int idx);
+int cpu_map__get_core(struct cpu_map *map, int idx);
 int cpu_map__build_socket_map(struct cpu_map *cpus, struct cpu_map **sockp);
+int cpu_map__build_core_map(struct cpu_map *cpus, struct cpu_map **corep);
 
 static inline int cpu_map__socket(struct cpu_map *sock, int s)
 {
@@ -24,6 +26,16 @@ static inline int cpu_map__socket(struct cpu_map *sock, int s)
         return sock->map[s];
 }
 
+static inline int cpu_map__id_to_socket(int id)
+{
+        return id >> 16;
+}
+
+static inline int cpu_map__id_to_cpu(int id)
+{
+        return id & 0xffff;
+}
+
 static inline int cpu_map__nr(const struct cpu_map *map)
 {
         return map ? map->nr : 1;
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
deleted file mode 100644
index dd8b19319c03..000000000000
--- a/tools/perf/util/debugfs.c
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "util.h"
-#include "debugfs.h"
-#include "cache.h"
-
-#include <linux/kernel.h>
-#include <sys/mount.h>
-
-static int debugfs_premounted;
-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/",
-        "/debug/",
-        0,
-};
-
-static int debugfs_found;
-
-/* find the path to the mounted debugfs */
-const char *debugfs_find_mountpoint(void)
-{
-        const char **ptr;
-        char type[100];
-        FILE *fp;
-
-        if (debugfs_found)
-                return (const char *) debugfs_mountpoint;
-
-        ptr = debugfs_known_mountpoints;
-        while (*ptr) {
-                if (debugfs_valid_mountpoint(*ptr) == 0) {
-                        debugfs_found = 1;
-                        strcpy(debugfs_mountpoint, *ptr);
-                        return debugfs_mountpoint;
-                }
-                ptr++;
-        }
-
-        /* give up and parse /proc/mounts */
-        fp = fopen("/proc/mounts", "r");
-        if (fp == NULL)
-                return NULL;
-
-        while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
-                      debugfs_mountpoint, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-
-        if (strcmp(type, "debugfs") != 0)
-                return NULL;
-
-        debugfs_found = 1;
-
-        return debugfs_mountpoint;
-}
-
-/* verify that a mountpoint is actually a debugfs instance */
-
-int debugfs_valid_mountpoint(const char *debugfs)
-{
-        struct statfs st_fs;
-
-        if (statfs(debugfs, &st_fs) < 0)
-                return -ENOENT;
-        else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
-                return -ENOENT;
-
-        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)
-{
-        /* see if it's already mounted */
-        if (debugfs_find_mountpoint()) {
-                debugfs_premounted = 1;
-                goto out;
-        }
-
-        /* if not mounted and no argument */
-        if (mountpoint == NULL) {
-                /* see if environment variable set */
-                mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
-                /* if no environment variable, use default */
-                if (mountpoint == NULL)
-                        mountpoint = "/sys/kernel/debug";
-        }
-
-        if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
-                return NULL;
-
-        /* save the 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);
-}
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
deleted file mode 100644
index 68f3e87ec57f..000000000000
--- a/tools/perf/util/debugfs.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef __DEBUGFS_H__
-#define __DEBUGFS_H__
-
-const char *debugfs_find_mountpoint(void);
-int debugfs_valid_mountpoint(const char *debugfs);
-char *debugfs_mount(const char *mountpoint);
-void debugfs_set_path(const char *mountpoint);
-
-extern char debugfs_mountpoint[];
-extern char tracing_events_path[];
-
-#endif /* __DEBUGFS_H__ */
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 0d573ff4771a..181389535c0c 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -88,8 +88,10 @@ struct perf_sample {
         u64 id;
         u64 stream_id;
         u64 period;
+        u64 weight;
         u32 cpu;
         u32 raw_size;
+        u64 data_src;
         void *raw_data;
         struct ip_callchain *callchain;
         struct branch_stack *branch_stack;
@@ -97,6 +99,13 @@ struct perf_sample {
         struct stack_dump user_stack;
 };
 
+#define PERF_MEM_DATA_SRC_NONE \
+        (PERF_MEM_S(OP, NA) |\
+         PERF_MEM_S(LVL, NA) |\
+         PERF_MEM_S(SNOOP, NA) |\
+         PERF_MEM_S(LOCK, NA) |\
+         PERF_MEM_S(TLB, NA))
+
 struct build_id_event {
         struct perf_event_header header;
         pid_t                    pid;
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index c8be0fbc5145..f7c727801aab 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -7,7 +7,7 @@
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "util.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
@@ -38,13 +38,12 @@ void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
         evlist->workload.pid = -1;
 }
 
-struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
-                                     struct thread_map *threads)
+struct perf_evlist *perf_evlist__new(void)
 {
         struct perf_evlist *evlist = zalloc(sizeof(*evlist));
 
         if (evlist != NULL)
-                perf_evlist__init(evlist, cpus, threads);
+                perf_evlist__init(evlist, NULL, NULL);
 
         return evlist;
 }
@@ -228,12 +227,14 @@ void perf_evlist__disable(struct perf_evlist *evlist)
 {
         int cpu, thread;
         struct perf_evsel *pos;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
                         if (!perf_evsel__is_group_leader(pos))
                                 continue;
-                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                        for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
                                       PERF_EVENT_IOC_DISABLE, 0);
                 }
@@ -244,12 +245,14 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 {
         int cpu, thread;
         struct perf_evsel *pos;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (cpu = 0; cpu < cpu_map__nr(evlist->cpus); cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
                         if (!perf_evsel__is_group_leader(pos))
                                 continue;
-                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                        for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
                                       PERF_EVENT_IOC_ENABLE, 0);
                 }
@@ -258,7 +261,9 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 
 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
-        int nfds = cpu_map__nr(evlist->cpus) * evlist->threads->nr * evlist->nr_entries;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
+        int nfds = nr_cpus * nr_threads * evlist->nr_entries;
         evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
         return evlist->pollfd != NULL ? 0 : -ENOMEM;
 }
@@ -417,7 +422,7 @@ static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
         evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
         if (cpu_map__all(evlist->cpus))
-                evlist->nr_mmaps = evlist->threads->nr;
+                evlist->nr_mmaps = thread_map__nr(evlist->threads);
         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
         return evlist->mmap != NULL ? 0 : -ENOMEM;
 }
@@ -442,11 +447,13 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
 {
         struct perf_evsel *evsel;
         int cpu, thread;
+        int nr_cpus = cpu_map__nr(evlist->cpus);
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 int output = -1;
 
-                for (thread = 0; thread < evlist->threads->nr; thread++) {
+                for (thread = 0; thread < nr_threads; thread++) {
                         list_for_each_entry(evsel, &evlist->entries, node) {
                                 int fd = FD(evsel, cpu, thread);
 
@@ -470,7 +477,7 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
         return 0;
 
 out_unmap:
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
                 if (evlist->mmap[cpu].base != NULL) {
                         munmap(evlist->mmap[cpu].base, evlist->mmap_len);
                         evlist->mmap[cpu].base = NULL;
@@ -483,8 +490,9 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
 {
         struct perf_evsel *evsel;
         int thread;
+        int nr_threads = thread_map__nr(evlist->threads);
 
-        for (thread = 0; thread < evlist->threads->nr; thread++) {
+        for (thread = 0; thread < nr_threads; thread++) {
                 int output = -1;
 
                 list_for_each_entry(evsel, &evlist->entries, node) {
@@ -509,7 +517,7 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
         return 0;
 
 out_unmap:
-        for (thread = 0; thread < evlist->threads->nr; thread++) {
+        for (thread = 0; thread < nr_threads; thread++) {
                 if (evlist->mmap[thread].base != NULL) {
                         munmap(evlist->mmap[thread].base, evlist->mmap_len);
                         evlist->mmap[thread].base = NULL;
@@ -610,7 +618,7 @@ int perf_evlist__apply_filters(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
         int err = 0;
         const int ncpus = cpu_map__nr(evlist->cpus),
-                  nthreads = evlist->threads->nr;
+                  nthreads = thread_map__nr(evlist->threads);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 if (evsel->filter == NULL)
@@ -629,7 +637,7 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
         struct perf_evsel *evsel;
         int err = 0;
         const int ncpus = cpu_map__nr(evlist->cpus),
-                  nthreads = evlist->threads->nr;
+                  nthreads = thread_map__nr(evlist->threads);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
@@ -712,10 +720,20 @@ void perf_evlist__set_selected(struct perf_evlist *evlist,
         evlist->selected = evsel;
 }
 
+void perf_evlist__close(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+        int ncpus = cpu_map__nr(evlist->cpus);
+        int nthreads = thread_map__nr(evlist->threads);
+
+        list_for_each_entry_reverse(evsel, &evlist->entries, node)
+                perf_evsel__close(evsel, ncpus, nthreads);
+}
+
 int perf_evlist__open(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
-        int err, ncpus, nthreads;
+        int err;
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
@@ -725,19 +743,15 @@ int perf_evlist__open(struct perf_evlist *evlist)
 
         return 0;
 out_err:
-        ncpus = evlist->cpus ? evlist->cpus->nr : 1;
-        nthreads = evlist->threads ? evlist->threads->nr : 1;
-
-        list_for_each_entry_reverse(evsel, &evlist->entries, node)
-                perf_evsel__close(evsel, ncpus, nthreads);
-
+        perf_evlist__close(evlist);
         errno = -err;
         return err;
 }
 
 int perf_evlist__prepare_workload(struct perf_evlist *evlist,
-                                  struct perf_record_opts *opts,
-                                  const char *argv[])
+                                  struct perf_target *target,
+                                  const char *argv[], bool pipe_output,
+                                  bool want_signal)
 {
         int child_ready_pipe[2], go_pipe[2];
         char bf;
@@ -759,7 +773,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
         }
 
         if (!evlist->workload.pid) {
-                if (opts->pipe_output)
+                if (pipe_output)
                         dup2(2, 1);
 
                 close(child_ready_pipe[0]);
@@ -787,11 +801,12 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
                 execvp(argv[0], (char **)argv);
 
                 perror(argv[0]);
-                kill(getppid(), SIGUSR1);
+                if (want_signal)
+                        kill(getppid(), SIGUSR1);
                 exit(-1);
         }
 
-        if (perf_target__none(&opts->target))
+        if (perf_target__none(target))
                 evlist->threads->map[0] = evlist->workload.pid;
 
         close(child_ready_pipe[1]);
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 2dd07bd60b4f..0583d36252be 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -49,8 +49,7 @@ struct perf_evsel_str_handler {
         void       *handler;
 };
 
-struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
-                                     struct thread_map *threads);
+struct perf_evlist *perf_evlist__new(void);
 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
                        struct thread_map *threads);
 void perf_evlist__exit(struct perf_evlist *evlist);
@@ -82,13 +81,15 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 
 int perf_evlist__open(struct perf_evlist *evlist);
+void perf_evlist__close(struct perf_evlist *evlist);
 
 void perf_evlist__config(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[]);
+                                  struct perf_target *target,
+                                  const char *argv[], bool pipe_output,
+                                  bool want_signal);
 int perf_evlist__start_workload(struct perf_evlist *evlist);
 
 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 9c82f98f26de..07b1a3ad3e24 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -10,7 +10,7 @@
 #include <byteswap.h>
 #include <linux/bitops.h>
 #include "asm/bug.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "event-parse.h"
 #include "evsel.h"
 #include "evlist.h"
@@ -554,6 +554,9 @@ void perf_evsel__config(struct perf_evsel *evsel,
                 perf_evsel__set_sample_bit(evsel, CPU);
         }
 
+        if (opts->sample_address)
+                attr->sample_type       |= PERF_SAMPLE_DATA_SRC;
+
         if (opts->no_delay) {
                 attr->watermark = 0;
                 attr->wakeup_events = 1;
@@ -563,6 +566,9 @@ void perf_evsel__config(struct perf_evsel *evsel,
                 attr->branch_sample_type = opts->branch_stack;
         }
 
+        if (opts->sample_weight)
+                attr->sample_type       |= PERF_SAMPLE_WEIGHT;
+
         attr->mmap = track;
         attr->comm = track;
 
@@ -633,6 +639,12 @@ int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
         return 0;
 }
 
+void perf_evsel__reset_counts(struct perf_evsel *evsel, int ncpus)
+{
+        memset(evsel->counts, 0, (sizeof(*evsel->counts) +
+                                 (ncpus * sizeof(struct perf_counts_values))));
+}
+
 int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
 {
         evsel->counts = zalloc((sizeof(*evsel->counts) +
@@ -673,9 +685,8 @@ void perf_evsel__free_counts(struct perf_evsel *evsel)
 void perf_evsel__exit(struct perf_evsel *evsel)
 {
         assert(list_empty(&evsel->node));
-        xyarray__delete(evsel->fd);
-        xyarray__delete(evsel->sample_id);
-        free(evsel->id);
+        perf_evsel__free_fd(evsel);
+        perf_evsel__free_id(evsel);
 }
 
 void perf_evsel__delete(struct perf_evsel *evsel)
@@ -1012,6 +1023,7 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
         data->cpu = data->pid = data->tid = -1;
         data->stream_id = data->id = data->time = -1ULL;
         data->period = 1;
+        data->weight = 0;
 
         if (event->header.type != PERF_RECORD_SAMPLE) {
                 if (!evsel->attr.sample_id_all)
@@ -1162,6 +1174,18 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                 }
         }
 
+        data->weight = 0;
+        if (type & PERF_SAMPLE_WEIGHT) {
+                data->weight = *array;
+                array++;
+        }
+
+        data->data_src = PERF_MEM_DATA_SRC_NONE;
+        if (type & PERF_SAMPLE_DATA_SRC) {
+                data->data_src = *array;
+                array++;
+        }
+
         return 0;
 }
 
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 52021c3087df..3f156ccc1acb 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -9,6 +9,7 @@
 #include "xyarray.h"
 #include "cgroup.h"
 #include "hist.h"
+#include "symbol.h"
  
 struct perf_counts_values {
         union {
@@ -120,6 +121,7 @@ int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size);
 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);
+void perf_evsel__reset_counts(struct perf_evsel *evsel, int ncpus);
 void perf_evsel__free_fd(struct perf_evsel *evsel);
 void perf_evsel__free_id(struct perf_evsel *evsel);
 void perf_evsel__free_counts(struct perf_evsel *evsel);
@@ -246,11 +248,34 @@ static inline struct perf_evsel *perf_evsel__next(struct perf_evsel *evsel)
         return list_entry(evsel->node.next, struct perf_evsel, node);
 }
 
+/**
+ * perf_evsel__is_group_leader - Return whether given evsel is a leader event
+ *
+ * @evsel - evsel selector to be tested
+ *
+ * Return %true if @evsel is a group leader or a stand-alone event
+ */
 static inline bool perf_evsel__is_group_leader(const struct perf_evsel *evsel)
 {
         return evsel->leader == evsel;
 }
 
+/**
+ * perf_evsel__is_group_event - Return whether given evsel is a group event
+ *
+ * @evsel - evsel selector to be tested
+ *
+ * Return %true iff event group view is enabled and @evsel is a actual group
+ * leader which has other members in the group
+ */
+static inline bool perf_evsel__is_group_event(struct perf_evsel *evsel)
+{
+        if (!symbol_conf.event_group)
+                return false;
+
+        return perf_evsel__is_group_leader(evsel) && evsel->nr_members > 1;
+}
+
 struct perf_attr_details {
         bool freq;
         bool verbose;
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index f4bfd79ef6a7..326068a593a5 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,5 +1,3 @@
-#define _FILE_OFFSET_BITS 64
-
 #include "util.h"
 #include <sys/types.h>
 #include <byteswap.h>
@@ -1672,8 +1670,8 @@ static int process_tracing_data(struct perf_file_section *section __maybe_unused
                                 struct perf_header *ph __maybe_unused,
                                 int fd, void *data)
 {
-        trace_report(fd, data, false);
-        return 0;
+        ssize_t ret = trace_report(fd, data, false);
+        return ret < 0 ? -1 : 0;
 }
 
 static int process_build_id(struct perf_file_section *section,
@@ -2752,6 +2750,11 @@ static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
         if (evsel->tp_format)
                 return 0;
 
+        if (pevent == NULL) {
+                pr_debug("broken or missing trace data\n");
+                return -1;
+        }
+
         event = pevent_find_event(pevent, evsel->attr.config);
         if (event == NULL)
                 return -1;
@@ -2789,7 +2792,7 @@ int perf_session__read_header(struct perf_session *session, int fd)
         u64                     f_id;
         int nr_attrs, nr_ids, i, j;
 
-        session->evlist = perf_evlist__new(NULL, NULL);
+        session->evlist = perf_evlist__new();
         if (session->evlist == NULL)
                 return -ENOMEM;
 
@@ -2940,7 +2943,7 @@ int perf_event__process_attr(union perf_event *event,
         struct perf_evlist *evlist = *pevlist;
 
         if (evlist == NULL) {
-                *pevlist = evlist = perf_evlist__new(NULL, NULL);
+                *pevlist = evlist = perf_evlist__new();
                 if (evlist == NULL)
                         return -ENOMEM;
         }
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index f855941bebea..6b32721f829a 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -67,12 +67,16 @@ static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
 void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 {
         const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
+        int symlen;
         u16 len;
 
         if (h->ms.sym)
                 hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen + 4);
-        else
+        else {
+                symlen = unresolved_col_width + 4 + 2;
+                hists__new_col_len(hists, HISTC_SYMBOL, symlen);
                 hists__set_unres_dso_col_len(hists, HISTC_DSO);
+        }
 
         len = thread__comm_len(h->thread);
         if (hists__new_col_len(hists, HISTC_COMM, len))
@@ -87,7 +91,6 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                 hists__new_col_len(hists, HISTC_PARENT, h->parent->namelen);
 
         if (h->branch_info) {
-                int symlen;
                 /*
                  * +4 accounts for '[x] ' priv level info
                  * +2 account of 0x prefix on raw addresses
@@ -116,6 +119,42 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                         hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
                 }
         }
+
+        if (h->mem_info) {
+                /*
+                 * +4 accounts for '[x] ' priv level info
+                 * +2 account of 0x prefix on raw addresses
+                 */
+                if (h->mem_info->daddr.sym) {
+                        symlen = (int)h->mem_info->daddr.sym->namelen + 4
+                               + unresolved_col_width + 2;
+                        hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
+                                           symlen);
+                } else {
+                        symlen = unresolved_col_width + 4 + 2;
+                        hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
+                                           symlen);
+                }
+                if (h->mem_info->daddr.map) {
+                        symlen = dso__name_len(h->mem_info->daddr.map->dso);
+                        hists__new_col_len(hists, HISTC_MEM_DADDR_DSO,
+                                           symlen);
+                } else {
+                        symlen = unresolved_col_width + 4 + 2;
+                        hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
+                }
+        } else {
+                symlen = unresolved_col_width + 4 + 2;
+                hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL, symlen);
+                hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
+        }
+
+        hists__new_col_len(hists, HISTC_MEM_LOCKED, 6);
+        hists__new_col_len(hists, HISTC_MEM_TLB, 22);
+        hists__new_col_len(hists, HISTC_MEM_SNOOP, 12);
+        hists__new_col_len(hists, HISTC_MEM_LVL, 21 + 3);
+        hists__new_col_len(hists, HISTC_LOCAL_WEIGHT, 12);
+        hists__new_col_len(hists, HISTC_GLOBAL_WEIGHT, 12);
 }
 
 void hists__output_recalc_col_len(struct hists *hists, int max_rows)
@@ -155,9 +194,12 @@ static void hist_entry__add_cpumode_period(struct hist_entry *he,
         }
 }
 
-static void he_stat__add_period(struct he_stat *he_stat, u64 period)
+static void he_stat__add_period(struct he_stat *he_stat, u64 period,
+                                u64 weight)
 {
+
         he_stat->period         += period;
+        he_stat->weight         += weight;
         he_stat->nr_events      += 1;
 }
 
@@ -169,12 +211,14 @@ static void he_stat__add_stat(struct he_stat *dest, struct he_stat *src)
         dest->period_guest_sys  += src->period_guest_sys;
         dest->period_guest_us   += src->period_guest_us;
         dest->nr_events         += src->nr_events;
+        dest->weight            += src->weight;
 }
 
 static void hist_entry__decay(struct hist_entry *he)
 {
         he->stat.period = (he->stat.period * 7) / 8;
         he->stat.nr_events = (he->stat.nr_events * 7) / 8;
+        /* XXX need decay for weight too? */
 }
 
 static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
@@ -239,7 +283,7 @@ 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 *he = malloc(sizeof(*he) + callchain_size);
+        struct hist_entry *he = zalloc(sizeof(*he) + callchain_size);
 
         if (he != NULL) {
                 *he = *template;
@@ -254,6 +298,13 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template)
                                 he->branch_info->to.map->referenced = true;
                 }
 
+                if (he->mem_info) {
+                        if (he->mem_info->iaddr.map)
+                                he->mem_info->iaddr.map->referenced = true;
+                        if (he->mem_info->daddr.map)
+                                he->mem_info->daddr.map->referenced = true;
+                }
+
                 if (symbol_conf.use_callchain)
                         callchain_init(he->callchain);
 
@@ -282,7 +333,8 @@ static u8 symbol__parent_filter(const struct symbol *parent)
 static struct hist_entry *add_hist_entry(struct hists *hists,
                                       struct hist_entry *entry,
                                       struct addr_location *al,
-                                      u64 period)
+                                      u64 period,
+                                      u64 weight)
 {
         struct rb_node **p;
         struct rb_node *parent = NULL;
@@ -306,7 +358,7 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
                 cmp = hist_entry__cmp(he, entry);
 
                 if (!cmp) {
-                        he_stat__add_period(&he->stat, period);
+                        he_stat__add_period(&he->stat, period, weight);
 
                         /* If the map of an existing hist_entry has
                          * become out-of-date due to an exec() or
@@ -341,11 +393,42 @@ out_unlock:
         return he;
 }
 
+struct hist_entry *__hists__add_mem_entry(struct hists *self,
+                                          struct addr_location *al,
+                                          struct symbol *sym_parent,
+                                          struct mem_info *mi,
+                                          u64 period,
+                                          u64 weight)
+{
+        struct hist_entry entry = {
+                .thread = al->thread,
+                .ms = {
+                        .map    = al->map,
+                        .sym    = al->sym,
+                },
+                .stat = {
+                        .period = period,
+                        .weight = weight,
+                        .nr_events = 1,
+                },
+                .cpu    = al->cpu,
+                .ip     = al->addr,
+                .level  = al->level,
+                .parent = sym_parent,
+                .filtered = symbol__parent_filter(sym_parent),
+                .hists = self,
+                .mem_info = mi,
+                .branch_info = NULL,
+        };
+        return add_hist_entry(self, &entry, al, period, weight);
+}
+
 struct hist_entry *__hists__add_branch_entry(struct hists *self,
                                              struct addr_location *al,
                                              struct symbol *sym_parent,
                                              struct branch_info *bi,
-                                             u64 period)
+                                             u64 period,
+                                             u64 weight)
 {
         struct hist_entry entry = {
                 .thread = al->thread,
@@ -359,19 +442,22 @@ struct hist_entry *__hists__add_branch_entry(struct hists *self,
                 .stat = {
                         .period = period,
                         .nr_events = 1,
+                        .weight = weight,
                 },
                 .parent = sym_parent,
                 .filtered = symbol__parent_filter(sym_parent),
                 .branch_info = bi,
                 .hists  = self,
+                .mem_info = NULL,
         };
 
-        return add_hist_entry(self, &entry, al, period);
+        return add_hist_entry(self, &entry, al, period, weight);
 }
 
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
-                                      struct symbol *sym_parent, u64 period)
+                                      struct symbol *sym_parent, u64 period,
+                                      u64 weight)
 {
         struct hist_entry entry = {
                 .thread = al->thread,
@@ -385,13 +471,16 @@ struct hist_entry *__hists__add_entry(struct hists *self,
                 .stat = {
                         .period = period,
                         .nr_events = 1,
+                        .weight = weight,
                 },
                 .parent = sym_parent,
                 .filtered = symbol__parent_filter(sym_parent),
                 .hists  = self,
+                .branch_info = NULL,
+                .mem_info = NULL,
         };
 
-        return add_hist_entry(self, &entry, al, period);
+        return add_hist_entry(self, &entry, al, period, weight);
 }
 
 int64_t
@@ -431,6 +520,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
 void hist_entry__free(struct hist_entry *he)
 {
         free(he->branch_info);
+        free(he->mem_info);
         free(he);
 }
 
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 38624686ee9a..14c2fe20aa62 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -49,6 +49,14 @@ enum hist_column {
         HISTC_DSO_FROM,
         HISTC_DSO_TO,
         HISTC_SRCLINE,
+        HISTC_LOCAL_WEIGHT,
+        HISTC_GLOBAL_WEIGHT,
+        HISTC_MEM_DADDR_SYMBOL,
+        HISTC_MEM_DADDR_DSO,
+        HISTC_MEM_LOCKED,
+        HISTC_MEM_TLB,
+        HISTC_MEM_LVL,
+        HISTC_MEM_SNOOP,
         HISTC_NR_COLS, /* Last entry */
 };
 
@@ -73,7 +81,8 @@ struct hists {
 
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
-                                      struct symbol *parent, u64 period);
+                                      struct symbol *parent, u64 period,
+                                      u64 weight);
 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__sort_snprintf(struct hist_entry *self, char *bf, size_t size,
@@ -84,7 +93,15 @@ struct hist_entry *__hists__add_branch_entry(struct hists *self,
                                              struct addr_location *al,
                                              struct symbol *sym_parent,
                                              struct branch_info *bi,
-                                             u64 period);
+                                             u64 period,
+                                             u64 weight);
+
+struct hist_entry *__hists__add_mem_entry(struct hists *self,
+                                          struct addr_location *al,
+                                          struct symbol *sym_parent,
+                                          struct mem_info *mi,
+                                          u64 period,
+                                          u64 weight);
 
 void hists__output_resort(struct hists *self);
 void hists__output_resort_threaded(struct hists *hists);
@@ -175,9 +192,9 @@ struct hist_browser_timer {
         int refresh;
 };
 
-#ifdef NEWT_SUPPORT
+#ifdef SLANG_SUPPORT
 #include "../ui/keysyms.h"
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
+int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
                              struct hist_browser_timer *hbt);
 
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
@@ -196,7 +213,8 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
 
 static inline int hist_entry__tui_annotate(struct hist_entry *self
                                            __maybe_unused,
-                                           int evidx __maybe_unused,
+                                           struct perf_evsel *evsel
+                                           __maybe_unused,
                                            struct hist_browser_timer *hbt
                                            __maybe_unused)
 {
@@ -208,8 +226,9 @@ static inline int script_browse(const char *script_opt __maybe_unused)
         return 0;
 }
 
-#define K_LEFT -1
-#define K_RIGHT -2
+#define K_LEFT  -1000
+#define K_RIGHT -2000
+#define K_SWITCH_INPUT_DATA -3000
 #endif
 
 #ifdef GTK2_SUPPORT
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index efdb38e65a92..b2ecad6ec46b 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -955,6 +955,7 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
         struct thread *thread;
         struct map *map;
+        enum map_type type;
         int ret = 0;
 
         if (dump_trace)
@@ -971,10 +972,17 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         thread = machine__findnew_thread(machine, event->mmap.pid);
         if (thread == NULL)
                 goto out_problem;
+
+        if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
+                type = MAP__VARIABLE;
+        else
+                type = MAP__FUNCTION;
+
         map = map__new(&machine->user_dsos, event->mmap.start,
                         event->mmap.len, event->mmap.pgoff,
                         event->mmap.pid, event->mmap.filename,
-                        MAP__FUNCTION);
+                        type);
+
         if (map == NULL)
                 goto out_problem;
 
@@ -1003,6 +1011,17 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event
         return 0;
 }
 
+static void machine__remove_thread(struct machine *machine, struct thread *th)
+{
+        machine->last_match = NULL;
+        rb_erase(&th->rb_node, &machine->threads);
+        /*
+         * We may have references to this thread, for instance in some hist_entry
+         * instances, so just move them to a separate list.
+         */
+        list_add_tail(&th->node, &machine->dead_threads);
+}
+
 int machine__process_exit_event(struct machine *machine, union perf_event *event)
 {
         struct thread *thread = machine__find_thread(machine, event->fork.tid);
@@ -1039,17 +1058,6 @@ int machine__process_event(struct machine *machine, union perf_event *event)
         return ret;
 }
 
-void machine__remove_thread(struct machine *machine, struct thread *th)
-{
-        machine->last_match = NULL;
-        rb_erase(&th->rb_node, &machine->threads);
-        /*
-         * We may have references to this thread, for instance in some hist_entry
-         * instances, so just move them to a separate list.
-         */
-        list_add_tail(&th->node, &machine->dead_threads);
-}
-
 static bool symbol__match_parent_regex(struct symbol *sym)
 {
         if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
@@ -1097,6 +1105,38 @@ found:
         ams->map = al.map;
 }
 
+static void ip__resolve_data(struct machine *machine, struct thread *thread,
+                             u8 m, struct addr_map_symbol *ams, u64 addr)
+{
+        struct addr_location al;
+
+        memset(&al, 0, sizeof(al));
+
+        thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr, &al,
+                                   NULL);
+        ams->addr = addr;
+        ams->al_addr = al.addr;
+        ams->sym = al.sym;
+        ams->map = al.map;
+}
+
+struct mem_info *machine__resolve_mem(struct machine *machine,
+                                      struct thread *thr,
+                                      struct perf_sample *sample,
+                                      u8 cpumode)
+{
+        struct mem_info *mi = zalloc(sizeof(*mi));
+
+        if (!mi)
+                return NULL;
+
+        ip__resolve_ams(machine, thr, &mi->iaddr, sample->ip);
+        ip__resolve_data(machine, thr, cpumode, &mi->daddr, sample->addr);
+        mi->data_src.val = sample->data_src;
+
+        return mi;
+}
+
 struct branch_info *machine__resolve_bstack(struct machine *machine,
                                             struct thread *thr,
                                             struct branch_stack *bs)
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index 5ac5892f2326..77940680f1fc 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -76,6 +76,9 @@ void machine__delete(struct machine *machine);
 struct branch_info *machine__resolve_bstack(struct machine *machine,
                                             struct thread *thread,
                                             struct branch_stack *bs);
+struct mem_info *machine__resolve_mem(struct machine *machine,
+                                      struct thread *thread,
+                                      struct perf_sample *sample, u8 cpumode);
 int machine__resolve_callchain(struct machine *machine,
                                struct perf_evsel *evsel,
                                struct thread *thread,
@@ -97,7 +100,6 @@ static inline bool machine__is_host(struct machine *machine)
 }
 
 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);
 
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index c84f48cf9678..6c8bb0fb189b 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -10,7 +10,7 @@
 #include "symbol.h"
 #include "cache.h"
 #include "header.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "parse-events-bison.h"
 #define YY_EXTRA_TYPE int
 #include "parse-events-flex.h"
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 49a256e6e0a2..aa04bf9c9ad7 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -40,7 +40,7 @@
 #include "color.h"
 #include "symbol.h"
 #include "thread.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "trace-event.h"        /* For __maybe_unused */
 #include "probe-event.h"
 #include "probe-finder.h"
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index 64536a993f4a..f75ae1b9900c 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -15,7 +15,6 @@ util/thread_map.c
 util/util.c
 util/xyarray.c
 util/cgroup.c
-util/debugfs.c
 util/rblist.c
 util/strlist.c
 util/sysfs.c
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index bd85280bb6e8..cf1fe01b7e89 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1,5 +1,3 @@
-#define _FILE_OFFSET_BITS 64
-
 #include <linux/kernel.h>
 
 #include <byteswap.h>
@@ -800,6 +798,12 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
 
         if (sample_type & PERF_SAMPLE_STACK_USER)
                 stack_user__printf(&sample->user_stack);
+
+        if (sample_type & PERF_SAMPLE_WEIGHT)
+                printf("... weight: %" PRIu64 "\n", sample->weight);
+
+        if (sample_type & PERF_SAMPLE_DATA_SRC)
+                printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
 }
 
 static struct machine *
@@ -1365,18 +1369,6 @@ size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
         return machine__fprintf(&session->machines.host, 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 ->machines.host is wrong.  Fix when auditing all
-         * the 'perf kvm' code.
-         */
-        machine__remove_thread(&session->machines.host, th);
-}
-
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
                                               unsigned int type)
 {
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index b5c0847edfa9..6b51d47acdba 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -72,7 +72,6 @@ void perf_event__attr_swap(struct perf_event_attr *attr);
 int perf_session__create_kernel_maps(struct perf_session *self);
 
 void perf_session__set_id_hdr_size(struct perf_session *session);
-void perf_session__remove_thread(struct perf_session *self, struct thread *th);
 
 static inline
 struct machine *perf_session__find_machine(struct perf_session *self, pid_t pid)
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 73d510269784..6b0ed322907e 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -24,6 +24,7 @@ cflags += getenv('CFLAGS', '').split()
 build_lib = getenv('PYTHON_EXTBUILD_LIB')
 build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 libtraceevent = getenv('LIBTRACEEVENT')
+liblk = getenv('LIBLK')
 
 ext_sources = [f.strip() for f in file('util/python-ext-sources')
                                 if len(f.strip()) > 0 and f[0] != '#']
@@ -32,7 +33,7 @@ perf = Extension('perf',
                   sources = ext_sources,
                   include_dirs = ['util/include'],
                   extra_compile_args = cflags,
-                  extra_objects = [libtraceevent],
+                  extra_objects = [libtraceevent, liblk],
                  )
 
 setup(name='perf',
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index d41926cb9e3f..5f52d492590c 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -198,11 +198,19 @@ static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
         }
 
         ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
-        if (sym)
-                ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
-                                       width - ret,
-                                       sym->name);
-        else {
+        if (sym && map) {
+                if (map->type == MAP__VARIABLE) {
+                        ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
+                        ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
+                                        ip - map->unmap_ip(map, sym->start));
+                        ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                       width - ret, "");
+                } else {
+                        ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                               width - ret,
+                                               sym->name);
+                }
+        } else {
                 size_t len = BITS_PER_LONG / 4;
                 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
                                        len, ip);
@@ -457,6 +465,304 @@ static int hist_entry__mispredict_snprintf(struct hist_entry *self, char *bf,
         return repsep_snprintf(bf, size, "%-*s", width, out);
 }
 
+/* --sort daddr_sym */
+static int64_t
+sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        uint64_t l = 0, r = 0;
+
+        if (left->mem_info)
+                l = left->mem_info->daddr.addr;
+        if (right->mem_info)
+                r = right->mem_info->daddr.addr;
+
+        return (int64_t)(r - l);
+}
+
+static int hist_entry__daddr_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        uint64_t addr = 0;
+        struct map *map = NULL;
+        struct symbol *sym = NULL;
+
+        if (self->mem_info) {
+                addr = self->mem_info->daddr.addr;
+                map = self->mem_info->daddr.map;
+                sym = self->mem_info->daddr.sym;
+        }
+        return _hist_entry__sym_snprintf(map, sym, addr, self->level, bf, size,
+                                         width);
+}
+
+static int64_t
+sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct map *map_l = NULL;
+        struct map *map_r = NULL;
+
+        if (left->mem_info)
+                map_l = left->mem_info->daddr.map;
+        if (right->mem_info)
+                map_r = right->mem_info->daddr.map;
+
+        return _sort__dso_cmp(map_l, map_r);
+}
+
+static int hist_entry__dso_daddr_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        struct map *map = NULL;
+
+        if (self->mem_info)
+                map = self->mem_info->daddr.map;
+
+        return _hist_entry__dso_snprintf(map, bf, size, width);
+}
+
+static int64_t
+sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_lock = PERF_MEM_LOCK_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_lock = PERF_MEM_LOCK_NA;
+
+        return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
+}
+
+static int hist_entry__locked_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        const char *out;
+        u64 mask = PERF_MEM_LOCK_NA;
+
+        if (self->mem_info)
+                mask = self->mem_info->data_src.mem_lock;
+
+        if (mask & PERF_MEM_LOCK_NA)
+                out = "N/A";
+        else if (mask & PERF_MEM_LOCK_LOCKED)
+                out = "Yes";
+        else
+                out = "No";
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+static int64_t
+sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
+
+        return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
+}
+
+static const char * const tlb_access[] = {
+        "N/A",
+        "HIT",
+        "MISS",
+        "L1",
+        "L2",
+        "Walker",
+        "Fault",
+};
+#define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
+
+static int hist_entry__tlb_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        char out[64];
+        size_t sz = sizeof(out) - 1; /* -1 for null termination */
+        size_t l = 0, i;
+        u64 m = PERF_MEM_TLB_NA;
+        u64 hit, miss;
+
+        out[0] = '\0';
+
+        if (self->mem_info)
+                m = self->mem_info->data_src.mem_dtlb;
+
+        hit = m & PERF_MEM_TLB_HIT;
+        miss = m & PERF_MEM_TLB_MISS;
+
+        /* already taken care of */
+        m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
+
+        for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
+                if (!(m & 0x1))
+                        continue;
+                if (l) {
+                        strcat(out, " or ");
+                        l += 4;
+                }
+                strncat(out, tlb_access[i], sz - l);
+                l += strlen(tlb_access[i]);
+        }
+        if (*out == '\0')
+                strcpy(out, "N/A");
+        if (hit)
+                strncat(out, " hit", sz - l);
+        if (miss)
+                strncat(out, " miss", sz - l);
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+static int64_t
+sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_lvl = PERF_MEM_LVL_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_lvl = PERF_MEM_LVL_NA;
+
+        return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
+}
+
+static const char * const mem_lvl[] = {
+        "N/A",
+        "HIT",
+        "MISS",
+        "L1",
+        "LFB",
+        "L2",
+        "L3",
+        "Local RAM",
+        "Remote RAM (1 hop)",
+        "Remote RAM (2 hops)",
+        "Remote Cache (1 hop)",
+        "Remote Cache (2 hops)",
+        "I/O",
+        "Uncached",
+};
+#define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
+
+static int hist_entry__lvl_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        char out[64];
+        size_t sz = sizeof(out) - 1; /* -1 for null termination */
+        size_t i, l = 0;
+        u64 m =  PERF_MEM_LVL_NA;
+        u64 hit, miss;
+
+        if (self->mem_info)
+                m  = self->mem_info->data_src.mem_lvl;
+
+        out[0] = '\0';
+
+        hit = m & PERF_MEM_LVL_HIT;
+        miss = m & PERF_MEM_LVL_MISS;
+
+        /* already taken care of */
+        m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
+
+        for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
+                if (!(m & 0x1))
+                        continue;
+                if (l) {
+                        strcat(out, " or ");
+                        l += 4;
+                }
+                strncat(out, mem_lvl[i], sz - l);
+                l += strlen(mem_lvl[i]);
+        }
+        if (*out == '\0')
+                strcpy(out, "N/A");
+        if (hit)
+                strncat(out, " hit", sz - l);
+        if (miss)
+                strncat(out, " miss", sz - l);
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+static int64_t
+sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        union perf_mem_data_src data_src_l;
+        union perf_mem_data_src data_src_r;
+
+        if (left->mem_info)
+                data_src_l = left->mem_info->data_src;
+        else
+                data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
+
+        if (right->mem_info)
+                data_src_r = right->mem_info->data_src;
+        else
+                data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
+
+        return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
+}
+
+static const char * const snoop_access[] = {
+        "N/A",
+        "None",
+        "Miss",
+        "Hit",
+        "HitM",
+};
+#define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
+
+static int hist_entry__snoop_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        char out[64];
+        size_t sz = sizeof(out) - 1; /* -1 for null termination */
+        size_t i, l = 0;
+        u64 m = PERF_MEM_SNOOP_NA;
+
+        out[0] = '\0';
+
+        if (self->mem_info)
+                m = self->mem_info->data_src.mem_snoop;
+
+        for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
+                if (!(m & 0x1))
+                        continue;
+                if (l) {
+                        strcat(out, " or ");
+                        l += 4;
+                }
+                strncat(out, snoop_access[i], sz - l);
+                l += strlen(snoop_access[i]);
+        }
+
+        if (*out == '\0')
+                strcpy(out, "N/A");
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
 struct sort_entry sort_mispredict = {
         .se_header      = "Branch Mispredicted",
         .se_cmp         = sort__mispredict_cmp,
@@ -464,6 +770,91 @@ struct sort_entry sort_mispredict = {
         .se_width_idx   = HISTC_MISPREDICT,
 };
 
+static u64 he_weight(struct hist_entry *he)
+{
+        return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
+}
+
+static int64_t
+sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return he_weight(left) - he_weight(right);
+}
+
+static int hist_entry__local_weight_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        return repsep_snprintf(bf, size, "%-*llu", width, he_weight(self));
+}
+
+struct sort_entry sort_local_weight = {
+        .se_header      = "Local Weight",
+        .se_cmp         = sort__local_weight_cmp,
+        .se_snprintf    = hist_entry__local_weight_snprintf,
+        .se_width_idx   = HISTC_LOCAL_WEIGHT,
+};
+
+static int64_t
+sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return left->stat.weight - right->stat.weight;
+}
+
+static int hist_entry__global_weight_snprintf(struct hist_entry *self, char *bf,
+                                              size_t size, unsigned int width)
+{
+        return repsep_snprintf(bf, size, "%-*llu", width, self->stat.weight);
+}
+
+struct sort_entry sort_global_weight = {
+        .se_header      = "Weight",
+        .se_cmp         = sort__global_weight_cmp,
+        .se_snprintf    = hist_entry__global_weight_snprintf,
+        .se_width_idx   = HISTC_GLOBAL_WEIGHT,
+};
+
+struct sort_entry sort_mem_daddr_sym = {
+        .se_header      = "Data Symbol",
+        .se_cmp         = sort__daddr_cmp,
+        .se_snprintf    = hist_entry__daddr_snprintf,
+        .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
+};
+
+struct sort_entry sort_mem_daddr_dso = {
+        .se_header      = "Data Object",
+        .se_cmp         = sort__dso_daddr_cmp,
+        .se_snprintf    = hist_entry__dso_daddr_snprintf,
+        .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
+};
+
+struct sort_entry sort_mem_locked = {
+        .se_header      = "Locked",
+        .se_cmp         = sort__locked_cmp,
+        .se_snprintf    = hist_entry__locked_snprintf,
+        .se_width_idx   = HISTC_MEM_LOCKED,
+};
+
+struct sort_entry sort_mem_tlb = {
+        .se_header      = "TLB access",
+        .se_cmp         = sort__tlb_cmp,
+        .se_snprintf    = hist_entry__tlb_snprintf,
+        .se_width_idx   = HISTC_MEM_TLB,
+};
+
+struct sort_entry sort_mem_lvl = {
+        .se_header      = "Memory access",
+        .se_cmp         = sort__lvl_cmp,
+        .se_snprintf    = hist_entry__lvl_snprintf,
+        .se_width_idx   = HISTC_MEM_LVL,
+};
+
+struct sort_entry sort_mem_snoop = {
+        .se_header      = "Snoop",
+        .se_cmp         = sort__snoop_cmp,
+        .se_snprintf    = hist_entry__snoop_snprintf,
+        .se_width_idx   = HISTC_MEM_SNOOP,
+};
+
 struct sort_dimension {
         const char              *name;
         struct sort_entry       *entry;
@@ -480,6 +871,14 @@ static struct sort_dimension common_sort_dimensions[] = {
         DIM(SORT_PARENT, "parent", sort_parent),
         DIM(SORT_CPU, "cpu", sort_cpu),
         DIM(SORT_SRCLINE, "srcline", sort_srcline),
+        DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
+        DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
+        DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
+        DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
+        DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
+        DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
+        DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
+        DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
 };
 
 #undef DIM
@@ -516,7 +915,10 @@ int sort_dimension__add(const char *tok)
                                 return -EINVAL;
                         }
                         sort__has_parent = 1;
-                } else if (sd->entry == &sort_sym) {
+                } else if (sd->entry == &sort_sym ||
+                           sd->entry == &sort_sym_from ||
+                           sd->entry == &sort_sym_to ||
+                           sd->entry == &sort_mem_daddr_sym) {
                         sort__has_sym = 1;
                 }
 
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index b13e56f6ccbe..f24bdf64238c 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -49,6 +49,7 @@ struct he_stat {
         u64                     period_us;
         u64                     period_guest_sys;
         u64                     period_guest_us;
+        u64                     weight;
         u32                     nr_events;
 };
 
@@ -100,7 +101,8 @@ struct hist_entry {
         struct rb_root          sorted_chain;
         struct branch_info      *branch_info;
         struct hists            *hists;
-        struct callchain_root   callchain[0];
+        struct mem_info         *mem_info;
+        struct callchain_root   callchain[0]; /* must be last member */
 };
 
 static inline bool hist_entry__has_pairs(struct hist_entry *he)
@@ -130,6 +132,14 @@ enum sort_type {
         SORT_PARENT,
         SORT_CPU,
         SORT_SRCLINE,
+        SORT_LOCAL_WEIGHT,
+        SORT_GLOBAL_WEIGHT,
+        SORT_MEM_DADDR_SYMBOL,
+        SORT_MEM_DADDR_DSO,
+        SORT_MEM_LOCKED,
+        SORT_MEM_TLB,
+        SORT_MEM_LVL,
+        SORT_MEM_SNOOP,
 
         /* branch stack specific sort keys */
         __SORT_BRANCH_STACK,
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
index 55433aa42c8f..eabdce0a2daa 100644
--- a/tools/perf/util/strlist.c
+++ b/tools/perf/util/strlist.c
@@ -143,7 +143,7 @@ struct strlist *strlist__new(bool dupstr, const char *list)
                 slist->rblist.node_delete = strlist__node_delete;
 
                 slist->dupstr    = dupstr;
-                if (slist && strlist__parse_list(slist, list) != 0)
+                if (list && strlist__parse_list(slist, list) != 0)
                         goto out_error;
         }
 
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 54efcb5659ac..4b12bf850325 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -806,9 +806,12 @@ int dso__load_sym(struct dso *dso, struct map *map,
                  * DWARF DW_compile_unit has this, but we don't always have access
                  * to it...
                  */
-                demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
-                if (demangled != NULL)
-                        elf_name = demangled;
+                if (symbol_conf.demangle) {
+                        demangled = bfd_demangle(NULL, elf_name,
+                                                 DMGL_PARAMS | DMGL_ANSI);
+                        if (demangled != NULL)
+                                elf_name = demangled;
+                }
 new_symbol:
                 f = symbol__new(sym.st_value, sym.st_size,
                                 GELF_ST_BIND(sym.st_info), elf_name);
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index e6432d85b43d..8cf3b5426a9a 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -36,6 +36,7 @@ struct symbol_conf symbol_conf = {
         .use_modules      = true,
         .try_vmlinux_path = true,
         .annotate_src     = true,
+        .demangle         = true,
         .symfs            = "",
 };
 
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index b62ca37c4b77..5f720dc076da 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -97,7 +97,8 @@ struct symbol_conf {
                         kptr_restrict,
                         annotate_asm_raw,
                         annotate_src,
-                        event_group;
+                        event_group,
+                        demangle;
         const char      *vmlinux_name,
                         *kallsyms_name,
                         *source_prefix,
@@ -155,6 +156,12 @@ struct branch_info {
         struct branch_flags flags;
 };
 
+struct mem_info {
+        struct addr_map_symbol iaddr;
+        struct addr_map_symbol daddr;
+        union perf_mem_data_src data_src;
+};
+
 struct addr_location {
         struct thread *thread;
         struct map    *map;
diff --git a/tools/perf/util/thread_map.h b/tools/perf/util/thread_map.h
index f718df8a3c59..0cd8b3108084 100644
--- a/tools/perf/util/thread_map.h
+++ b/tools/perf/util/thread_map.h
@@ -21,4 +21,9 @@ void thread_map__delete(struct thread_map *threads);
 
 size_t thread_map__fprintf(struct thread_map *threads, FILE *fp);
 
+static inline int thread_map__nr(struct thread_map *threads)
+{
+        return threads ? threads->nr : 1;
+}
+
 #endif  /* __PERF_THREAD_MAP_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index a8d81c35ef66..3917eb9a8479 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -38,52 +38,20 @@
 
 #include "../perf.h"
 #include "trace-event.h"
-#include "debugfs.h"
+#include <lk/debugfs.h>
 #include "evsel.h"
 
 #define VERSION "0.5"
 
-#define TRACE_CTRL      "tracing_on"
-#define TRACE           "trace"
-#define AVAILABLE       "available_tracers"
-#define CURRENT         "current_tracer"
-#define ITER_CTRL       "trace_options"
-#define MAX_LATENCY     "tracing_max_latency"
-
-unsigned int page_size;
-
-static const char *output_file = "trace.info";
 static int output_fd;
 
-struct event_list {
-        struct event_list *next;
-        const char *event;
-};
-
-struct events {
-        struct events *sibling;
-        struct events *children;
-        struct events *next;
-        char *name;
-};
-
-
-static void *malloc_or_die(unsigned int size)
-{
-        void *data;
-
-        data = malloc(size);
-        if (!data)
-                die("malloc");
-        return data;
-}
 
 static const char *find_debugfs(void)
 {
-        const char *path = debugfs_mount(NULL);
+        const char *path = perf_debugfs_mount(NULL);
 
         if (!path)
-                die("Your kernel not support debugfs filesystem");
+                pr_debug("Your kernel does not support the debugfs filesystem");
 
         return path;
 }
@@ -102,8 +70,12 @@ static const char *find_tracing_dir(void)
                 return tracing;
 
         debugfs = find_debugfs();
+        if (!debugfs)
+                return NULL;
 
-        tracing = malloc_or_die(strlen(debugfs) + 9);
+        tracing = malloc(strlen(debugfs) + 9);
+        if (!tracing)
+                return NULL;
 
         sprintf(tracing, "%s/tracing", debugfs);
 
@@ -120,7 +92,9 @@ static char *get_tracing_file(const char *name)
         if (!tracing)
                 return NULL;
 
-        file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
+        file = malloc(strlen(tracing) + strlen(name) + 2);
+        if (!file)
+                return NULL;
 
         sprintf(file, "%s/%s", tracing, name);
         return file;
@@ -131,24 +105,6 @@ static void put_tracing_file(char *file)
         free(file);
 }
 
-static ssize_t calc_data_size;
-
-static ssize_t write_or_die(const void *buf, size_t len)
-{
-        int ret;
-
-        if (calc_data_size) {
-                calc_data_size += len;
-                return len;
-        }
-
-        ret = write(output_fd, buf, len);
-        if (ret < 0)
-                die("writing to '%s'", output_file);
-
-        return ret;
-}
-
 int bigendian(void)
 {
         unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
@@ -159,59 +115,106 @@ int bigendian(void)
 }
 
 /* unfortunately, you can not stat debugfs or proc files for size */
-static void record_file(const char *file, size_t hdr_sz)
+static int record_file(const char *file, ssize_t hdr_sz)
 {
         unsigned long long size = 0;
         char buf[BUFSIZ], *sizep;
         off_t hdr_pos = lseek(output_fd, 0, SEEK_CUR);
         int r, fd;
+        int err = -EIO;
 
         fd = open(file, O_RDONLY);
-        if (fd < 0)
-                die("Can't read '%s'", file);
+        if (fd < 0) {
+                pr_debug("Can't read '%s'", file);
+                return -errno;
+        }
 
         /* put in zeros for file size, then fill true size later */
-        if (hdr_sz)
-                write_or_die(&size, hdr_sz);
+        if (hdr_sz) {
+                if (write(output_fd, &size, hdr_sz) != hdr_sz)
+                        goto out;
+        }
 
         do {
                 r = read(fd, buf, BUFSIZ);
                 if (r > 0) {
                         size += r;
-                        write_or_die(buf, r);
+                        if (write(output_fd, buf, r) != r)
+                                goto out;
                 }
         } while (r > 0);
-        close(fd);
 
         /* ugh, handle big-endian hdr_size == 4 */
         sizep = (char*)&size;
         if (bigendian())
                 sizep += sizeof(u64) - hdr_sz;
 
-        if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0)
-                die("writing to %s", output_file);
+        if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0) {
+                pr_debug("writing file size failed\n");
+                goto out;
+        }
+
+        err = 0;
+out:
+        close(fd);
+        return err;
 }
 
-static void read_header_files(void)
+static int read_header_files(void)
 {
         char *path;
         struct stat st;
+        int err = -EIO;
 
         path = get_tracing_file("events/header_page");
-        if (stat(path, &st) < 0)
-                die("can't read '%s'", path);
+        if (!path) {
+                pr_debug("can't get tracing/events/header_page");
+                return -ENOMEM;
+        }
+
+        if (stat(path, &st) < 0) {
+                pr_debug("can't read '%s'", path);
+                goto out;
+        }
+
+        if (write(output_fd, "header_page", 12) != 12) {
+                pr_debug("can't write header_page\n");
+                goto out;
+        }
+
+        if (record_file(path, 8) < 0) {
+                pr_debug("can't record header_page file\n");
+                goto out;
+        }
 
-        write_or_die("header_page", 12);
-        record_file(path, 8);
         put_tracing_file(path);
 
         path = get_tracing_file("events/header_event");
-        if (stat(path, &st) < 0)
-                die("can't read '%s'", path);
+        if (!path) {
+                pr_debug("can't get tracing/events/header_event");
+                err = -ENOMEM;
+                goto out;
+        }
+
+        if (stat(path, &st) < 0) {
+                pr_debug("can't read '%s'", path);
+                goto out;
+        }
 
-        write_or_die("header_event", 13);
-        record_file(path, 8);
+        if (write(output_fd, "header_event", 13) != 13) {
+                pr_debug("can't write header_event\n");
+                goto out;
+        }
+
+        if (record_file(path, 8) < 0) {
+                pr_debug("can't record header_event file\n");
+                goto out;
+        }
+
+        err = 0;
+out:
         put_tracing_file(path);
+        return err;
 }
 
 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -225,7 +228,7 @@ static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
         return false;
 }
 
-static void copy_event_system(const char *sys, struct tracepoint_path *tps)
+static int copy_event_system(const char *sys, struct tracepoint_path *tps)
 {
         struct dirent *dent;
         struct stat st;
@@ -233,10 +236,13 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
         DIR *dir;
         int count = 0;
         int ret;
+        int err;
 
         dir = opendir(sys);
-        if (!dir)
-                die("can't read directory '%s'", sys);
+        if (!dir) {
+                pr_debug("can't read directory '%s'", sys);
+                return -errno;
+        }
 
         while ((dent = readdir(dir))) {
                 if (dent->d_type != DT_DIR ||
@@ -244,7 +250,11 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
-                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                format = malloc(strlen(sys) + strlen(dent->d_name) + 10);
+                if (!format) {
+                        err = -ENOMEM;
+                        goto out;
+                }
                 sprintf(format, "%s/%s/format", sys, dent->d_name);
                 ret = stat(format, &st);
                 free(format);
@@ -253,7 +263,11 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                 count++;
         }
 
-        write_or_die(&count, 4);
+        if (write(output_fd, &count, 4) != 4) {
+                err = -EIO;
+                pr_debug("can't write count\n");
+                goto out;
+        }
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
@@ -262,27 +276,45 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
-                format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
+                format = malloc(strlen(sys) + strlen(dent->d_name) + 10);
+                if (!format) {
+                        err = -ENOMEM;
+                        goto out;
+                }
                 sprintf(format, "%s/%s/format", sys, dent->d_name);
                 ret = stat(format, &st);
 
-                if (ret >= 0)
-                        record_file(format, 8);
-
+                if (ret >= 0) {
+                        err = record_file(format, 8);
+                        if (err) {
+                                free(format);
+                                goto out;
+                        }
+                }
                 free(format);
         }
+        err = 0;
+out:
         closedir(dir);
+        return err;
 }
 
-static void read_ftrace_files(struct tracepoint_path *tps)
+static int read_ftrace_files(struct tracepoint_path *tps)
 {
         char *path;
+        int ret;
 
         path = get_tracing_file("events/ftrace");
+        if (!path) {
+                pr_debug("can't get tracing/events/ftrace");
+                return -ENOMEM;
+        }
 
-        copy_event_system(path, tps);
+        ret = copy_event_system(path, tps);
 
         put_tracing_file(path);
+
+        return ret;
 }
 
 static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -296,7 +328,7 @@ static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
         return false;
 }
 
-static void read_event_files(struct tracepoint_path *tps)
+static int read_event_files(struct tracepoint_path *tps)
 {
         struct dirent *dent;
         struct stat st;
@@ -305,12 +337,20 @@ static void read_event_files(struct tracepoint_path *tps)
         DIR *dir;
         int count = 0;
         int ret;
+        int err;
 
         path = get_tracing_file("events");
+        if (!path) {
+                pr_debug("can't get tracing/events");
+                return -ENOMEM;
+        }
 
         dir = opendir(path);
-        if (!dir)
-                die("can't read directory '%s'", path);
+        if (!dir) {
+                err = -errno;
+                pr_debug("can't read directory '%s'", path);
+                goto out;
+        }
 
         while ((dent = readdir(dir))) {
                 if (dent->d_type != DT_DIR ||
@@ -322,7 +362,11 @@ static void read_event_files(struct tracepoint_path *tps)
                 count++;
         }
 
-        write_or_die(&count, 4);
+        if (write(output_fd, &count, 4) != 4) {
+                err = -EIO;
+                pr_debug("can't write count\n");
+                goto out;
+        }
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
@@ -332,56 +376,90 @@ static void read_event_files(struct tracepoint_path *tps)
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
                         continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
+                sys = malloc(strlen(path) + strlen(dent->d_name) + 2);
+                if (!sys) {
+                        err = -ENOMEM;
+                        goto out;
+                }
                 sprintf(sys, "%s/%s", path, dent->d_name);
                 ret = stat(sys, &st);
                 if (ret >= 0) {
-                        write_or_die(dent->d_name, strlen(dent->d_name) + 1);
-                        copy_event_system(sys, tps);
+                        ssize_t size = strlen(dent->d_name) + 1;
+
+                        if (write(output_fd, dent->d_name, size) != size ||
+                            copy_event_system(sys, tps) < 0) {
+                                err = -EIO;
+                                free(sys);
+                                goto out;
+                        }
                 }
                 free(sys);
         }
-
+        err = 0;
+out:
         closedir(dir);
         put_tracing_file(path);
+
+        return err;
 }
 
-static void read_proc_kallsyms(void)
+static int read_proc_kallsyms(void)
 {
         unsigned int size;
         const char *path = "/proc/kallsyms";
         struct stat st;
-        int ret;
+        int ret, err = 0;
 
         ret = stat(path, &st);
         if (ret < 0) {
                 /* not found */
                 size = 0;
-                write_or_die(&size, 4);
-                return;
+                if (write(output_fd, &size, 4) != 4)
+                        err = -EIO;
+                return err;
         }
-        record_file(path, 4);
+        return record_file(path, 4);
 }
 
-static void read_ftrace_printk(void)
+static int read_ftrace_printk(void)
 {
         unsigned int size;
         char *path;
         struct stat st;
-        int ret;
+        int ret, err = 0;
 
         path = get_tracing_file("printk_formats");
+        if (!path) {
+                pr_debug("can't get tracing/printk_formats");
+                return -ENOMEM;
+        }
+
         ret = stat(path, &st);
         if (ret < 0) {
                 /* not found */
                 size = 0;
-                write_or_die(&size, 4);
+                if (write(output_fd, &size, 4) != 4)
+                        err = -EIO;
                 goto out;
         }
-        record_file(path, 4);
+        err = record_file(path, 4);
 
 out:
         put_tracing_file(path);
+        return err;
+}
+
+static void
+put_tracepoints_path(struct tracepoint_path *tps)
+{
+        while (tps) {
+                struct tracepoint_path *t = tps;
+
+                tps = tps->next;
+                free(t->name);
+                free(t->system);
+                free(t);
+        }
 }
 
 static struct tracepoint_path *
@@ -396,27 +474,17 @@ get_tracepoints_path(struct list_head *pattrs)
                         continue;
                 ++nr_tracepoints;
                 ppath->next = tracepoint_id_to_path(pos->attr.config);
-                if (!ppath->next)
-                        die("%s\n", "No memory to alloc tracepoints list");
+                if (!ppath->next) {
+                        pr_debug("No memory to alloc tracepoints list\n");
+                        put_tracepoints_path(&path);
+                        return NULL;
+                }
                 ppath = ppath->next;
         }
 
         return nr_tracepoints > 0 ? path.next : NULL;
 }
 
-static void
-put_tracepoints_path(struct tracepoint_path *tps)
-{
-        while (tps) {
-                struct tracepoint_path *t = tps;
-
-                tps = tps->next;
-                free(t->name);
-                free(t->system);
-                free(t);
-        }
-}
-
 bool have_tracepoints(struct list_head *pattrs)
 {
         struct perf_evsel *pos;
@@ -428,9 +496,10 @@ bool have_tracepoints(struct list_head *pattrs)
         return false;
 }
 
-static void tracing_data_header(void)
+static int tracing_data_header(void)
 {
         char buf[20];
+        ssize_t size;
 
         /* just guessing this is someone's birthday.. ;) */
         buf[0] = 23;
@@ -438,9 +507,12 @@ static void tracing_data_header(void)
         buf[2] = 68;
         memcpy(buf + 3, "tracing", 7);
 
-        write_or_die(buf, 10);
+        if (write(output_fd, buf, 10) != 10)
+                return -1;
 
-        write_or_die(VERSION, strlen(VERSION) + 1);
+        size = strlen(VERSION) + 1;
+        if (write(output_fd, VERSION, size) != size)
+                return -1;
 
         /* save endian */
         if (bigendian())
@@ -450,15 +522,19 @@ static void tracing_data_header(void)
 
         read_trace_init(buf[0], buf[0]);
 
-        write_or_die(buf, 1);
+        if (write(output_fd, buf, 1) != 1)
+                return -1;
 
         /* save size of long */
         buf[0] = sizeof(long);
-        write_or_die(buf, 1);
+        if (write(output_fd, buf, 1) != 1)
+                return -1;
 
         /* save page_size */
-        page_size = sysconf(_SC_PAGESIZE);
-        write_or_die(&page_size, 4);
+        if (write(output_fd, &page_size, 4) != 4)
+                return -1;
+
+        return 0;
 }
 
 struct tracing_data *tracing_data_get(struct list_head *pattrs,
@@ -466,6 +542,7 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
 {
         struct tracepoint_path *tps;
         struct tracing_data *tdata;
+        int err;
 
         output_fd = fd;
 
@@ -473,7 +550,10 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
         if (!tps)
                 return NULL;
 
-        tdata = malloc_or_die(sizeof(*tdata));
+        tdata = malloc(sizeof(*tdata));
+        if (!tdata)
+                return NULL;
+
         tdata->temp = temp;
         tdata->size = 0;
 
@@ -482,12 +562,16 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
 
                 snprintf(tdata->temp_file, sizeof(tdata->temp_file),
                          "/tmp/perf-XXXXXX");
-                if (!mkstemp(tdata->temp_file))
-                        die("Can't make temp file");
+                if (!mkstemp(tdata->temp_file)) {
+                        pr_debug("Can't make temp file");
+                        return NULL;
+                }
 
                 temp_fd = open(tdata->temp_file, O_RDWR);
-                if (temp_fd < 0)
-                        die("Can't read '%s'", tdata->temp_file);
+                if (temp_fd < 0) {
+                        pr_debug("Can't read '%s'", tdata->temp_file);
+                        return NULL;
+                }
 
                 /*
                  * Set the temp file the default output, so all the
@@ -496,13 +580,24 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                 output_fd = temp_fd;
         }
 
-        tracing_data_header();
-        read_header_files();
-        read_ftrace_files(tps);
-        read_event_files(tps);
-        read_proc_kallsyms();
-        read_ftrace_printk();
+        err = tracing_data_header();
+        if (err)
+                goto out;
+        err = read_header_files();
+        if (err)
+                goto out;
+        err = read_ftrace_files(tps);
+        if (err)
+                goto out;
+        err = read_event_files(tps);
+        if (err)
+                goto out;
+        err = read_proc_kallsyms();
+        if (err)
+                goto out;
+        err = read_ftrace_printk();
 
+out:
         /*
          * All tracing data are stored by now, we can restore
          * the default output file in case we used temp file.
@@ -513,22 +608,31 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                 output_fd = fd;
         }
 
+        if (err) {
+                free(tdata);
+                tdata = NULL;
+        }
+
         put_tracepoints_path(tps);
         return tdata;
 }
 
-void tracing_data_put(struct tracing_data *tdata)
+int tracing_data_put(struct tracing_data *tdata)
 {
+        int err = 0;
+
         if (tdata->temp) {
-                record_file(tdata->temp_file, 0);
+                err = record_file(tdata->temp_file, 0);
                 unlink(tdata->temp_file);
         }
 
         free(tdata);
+        return err;
 }
 
 int read_tracing_data(int fd, struct list_head *pattrs)
 {
+        int err;
         struct tracing_data *tdata;
 
         /*
@@ -539,6 +643,6 @@ int read_tracing_data(int fd, struct list_head *pattrs)
         if (!tdata)
                 return -ENOMEM;
 
-        tracing_data_put(tdata);
-        return 0;
+        err = tracing_data_put(tdata);
+        return err;
 }
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 3aabcd687cd5..4454835a9ebc 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -183,43 +183,6 @@ void event_format__print(struct event_format *event,
         trace_seq_do_printf(&s);
 }
 
-void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
-{
-        int type = trace_parse_common_type(pevent, data);
-        struct event_format *event = pevent_find_event(pevent, type);
-
-        if (!event) {
-                warning("ug! no event found for type %d", type);
-                return;
-        }
-
-        event_format__print(event, cpu, data, size);
-}
-
-void print_event(struct pevent *pevent, int cpu, void *data, int size,
-                 unsigned long long nsecs, char *comm)
-{
-        struct pevent_record record;
-        struct trace_seq s;
-        int pid;
-
-        pevent->latency_format = latency_format;
-
-        record.ts = nsecs;
-        record.cpu = cpu;
-        record.size = size;
-        record.data = data;
-        pid = pevent_data_pid(pevent, &record);
-
-        if (!pevent_pid_is_registered(pevent, pid))
-                pevent_register_comm(pevent, comm, pid);
-
-        trace_seq_init(&s);
-        pevent_print_event(pevent, &s, &record);
-        trace_seq_do_printf(&s);
-        printf("\n");
-}
-
 void parse_proc_kallsyms(struct pevent *pevent,
                          char *file, unsigned int size __maybe_unused)
 {
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 3741572696af..af215c0d2379 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -18,8 +18,6 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#define _FILE_OFFSET_BITS 64
-
 #include <dirent.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -41,26 +39,14 @@
 
 static int input_fd;
 
-static int read_page;
-
 int file_bigendian;
 int host_bigendian;
 static int long_size;
 
-static ssize_t calc_data_size;
+static ssize_t trace_data_size;
 static bool repipe;
 
-static void *malloc_or_die(int size)
-{
-        void *ret;
-
-        ret = malloc(size);
-        if (!ret)
-                die("malloc");
-        return ret;
-}
-
-static int do_read(int fd, void *buf, int size)
+static int __do_read(int fd, void *buf, int size)
 {
         int rsize = size;
 
@@ -73,8 +59,10 @@ static int do_read(int fd, void *buf, int size)
                 if (repipe) {
                         int retw = write(STDOUT_FILENO, buf, ret);
 
-                        if (retw <= 0 || retw != ret)
-                                die("repiping input file");
+                        if (retw <= 0 || retw != ret) {
+                                pr_debug("repiping input file");
+                                return -1;
+                        }
                 }
 
                 size -= ret;
@@ -84,17 +72,18 @@ static int do_read(int fd, void *buf, int size)
         return rsize;
 }
 
-static int read_or_die(void *data, int size)
+static int do_read(void *data, int size)
 {
         int r;
 
-        r = do_read(input_fd, data, size);
-        if (r <= 0)
-                die("reading input file (size expected=%d received=%d)",
-                    size, r);
+        r = __do_read(input_fd, data, size);
+        if (r <= 0) {
+                pr_debug("reading input file (size expected=%d received=%d)",
+                         size, r);
+                return -1;
+        }
 
-        if (calc_data_size)
-                calc_data_size += r;
+        trace_data_size += r;
 
         return r;
 }
@@ -107,7 +96,7 @@ static void skip(int size)
 
         while (size) {
                 r = size > BUFSIZ ? BUFSIZ : size;
-                read_or_die(buf, r);
+                do_read(buf, r);
                 size -= r;
         };
 }
@@ -116,7 +105,8 @@ static unsigned int read4(struct pevent *pevent)
 {
         unsigned int data;
 
-        read_or_die(&data, 4);
+        if (do_read(&data, 4) < 0)
+                return 0;
         return __data2host4(pevent, data);
 }
 
@@ -124,7 +114,8 @@ static unsigned long long read8(struct pevent *pevent)
 {
         unsigned long long data;
 
-        read_or_die(&data, 8);
+        if (do_read(&data, 8) < 0)
+                return 0;
         return __data2host8(pevent, data);
 }
 
@@ -138,17 +129,23 @@ static char *read_string(void)
 
         for (;;) {
                 r = read(input_fd, &c, 1);
-                if (r < 0)
-                        die("reading input file");
+                if (r < 0) {
+                        pr_debug("reading input file");
+                        goto out;
+                }
 
-                if (!r)
-                        die("no data");
+                if (!r) {
+                        pr_debug("no data");
+                        goto out;
+                }
 
                 if (repipe) {
                         int retw = write(STDOUT_FILENO, &c, 1);
 
-                        if (retw <= 0 || retw != r)
-                                die("repiping input file string");
+                        if (retw <= 0 || retw != r) {
+                                pr_debug("repiping input file string");
+                                goto out;
+                        }
                 }
 
                 buf[size++] = c;
@@ -157,60 +154,79 @@ static char *read_string(void)
                         break;
         }
 
-        if (calc_data_size)
-                calc_data_size += size;
-
-        str = malloc_or_die(size);
-        memcpy(str, buf, size);
+        trace_data_size += size;
 
+        str = malloc(size);
+        if (str)
+                memcpy(str, buf, size);
+out:
         return str;
 }
 
-static void read_proc_kallsyms(struct pevent *pevent)
+static int read_proc_kallsyms(struct pevent *pevent)
 {
         unsigned int size;
         char *buf;
 
         size = read4(pevent);
         if (!size)
-                return;
+                return 0;
+
+        buf = malloc(size + 1);
+        if (buf == NULL)
+                return -1;
 
-        buf = malloc_or_die(size + 1);
-        read_or_die(buf, size);
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
         buf[size] = '\0';
 
         parse_proc_kallsyms(pevent, buf, size);
 
         free(buf);
+        return 0;
 }
 
-static void read_ftrace_printk(struct pevent *pevent)
+static int read_ftrace_printk(struct pevent *pevent)
 {
         unsigned int size;
         char *buf;
 
+        /* it can have 0 size */
         size = read4(pevent);
         if (!size)
-                return;
+                return 0;
+
+        buf = malloc(size);
+        if (buf == NULL)
+                return -1;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
 
         parse_ftrace_printk(pevent, buf, size);
 
         free(buf);
+        return 0;
 }
 
-static void read_header_files(struct pevent *pevent)
+static int read_header_files(struct pevent *pevent)
 {
         unsigned long long size;
         char *header_event;
         char buf[BUFSIZ];
+        int ret = 0;
 
-        read_or_die(buf, 12);
+        if (do_read(buf, 12) < 0)
+                return -1;
 
-        if (memcmp(buf, "header_page", 12) != 0)
-                die("did not read header page");
+        if (memcmp(buf, "header_page", 12) != 0) {
+                pr_debug("did not read header page");
+                return -1;
+        }
 
         size = read8(pevent);
         skip(size);
@@ -221,269 +237,107 @@ static void read_header_files(struct pevent *pevent)
          */
         long_size = header_page_size_size;
 
-        read_or_die(buf, 13);
-        if (memcmp(buf, "header_event", 13) != 0)
-                die("did not read header event");
+        if (do_read(buf, 13) < 0)
+                return -1;
+
+        if (memcmp(buf, "header_event", 13) != 0) {
+                pr_debug("did not read header event");
+                return -1;
+        }
 
         size = read8(pevent);
-        header_event = malloc_or_die(size);
-        read_or_die(header_event, size);
+        header_event = malloc(size);
+        if (header_event == NULL)
+                return -1;
+
+        if (do_read(header_event, size) < 0)
+                ret = -1;
+
         free(header_event);
+        return ret;
 }
 
-static void read_ftrace_file(struct pevent *pevent, unsigned long long size)
+static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
 {
         char *buf;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        buf = malloc(size);
+        if (buf == NULL)
+                return -1;
+
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
+
         parse_ftrace_file(pevent, buf, size);
         free(buf);
+        return 0;
 }
 
-static void read_event_file(struct pevent *pevent, char *sys,
+static int read_event_file(struct pevent *pevent, char *sys,
                             unsigned long long size)
 {
         char *buf;
 
-        buf = malloc_or_die(size);
-        read_or_die(buf, size);
+        buf = malloc(size);
+        if (buf == NULL)
+                return -1;
+
+        if (do_read(buf, size) < 0) {
+                free(buf);
+                return -1;
+        }
+
         parse_event_file(pevent, buf, size, sys);
         free(buf);
+        return 0;
 }
 
-static void read_ftrace_files(struct pevent *pevent)
+static int read_ftrace_files(struct pevent *pevent)
 {
         unsigned long long size;
         int count;
         int i;
+        int ret;
 
         count = read4(pevent);
 
         for (i = 0; i < count; i++) {
                 size = read8(pevent);
-                read_ftrace_file(pevent, size);
+                ret = read_ftrace_file(pevent, size);
+                if (ret)
+                        return ret;
         }
+        return 0;
 }
 
-static void read_event_files(struct pevent *pevent)
+static int read_event_files(struct pevent *pevent)
 {
         unsigned long long size;
         char *sys;
         int systems;
         int count;
         int i,x;
+        int ret;
 
         systems = read4(pevent);
 
         for (i = 0; i < systems; i++) {
                 sys = read_string();
+                if (sys == NULL)
+                        return -1;
 
                 count = read4(pevent);
+
                 for (x=0; x < count; x++) {
                         size = read8(pevent);
-                        read_event_file(pevent, sys, size);
+                        ret = read_event_file(pevent, sys, size);
+                        if (ret)
+                                return ret;
                 }
         }
-}
-
-struct cpu_data {
-        unsigned long long      offset;
-        unsigned long long      size;
-        unsigned long long      timestamp;
-        struct pevent_record    *next;
-        char                    *page;
-        int                     cpu;
-        int                     index;
-        int                     page_size;
-};
-
-static struct cpu_data *cpu_data;
-
-static void update_cpu_data_index(int cpu)
-{
-        cpu_data[cpu].offset += page_size;
-        cpu_data[cpu].size -= page_size;
-        cpu_data[cpu].index = 0;
-}
-
-static void get_next_page(int cpu)
-{
-        off_t save_seek;
-        off_t ret;
-
-        if (!cpu_data[cpu].page)
-                return;
-
-        if (read_page) {
-                if (cpu_data[cpu].size <= page_size) {
-                        free(cpu_data[cpu].page);
-                        cpu_data[cpu].page = NULL;
-                        return;
-                }
-
-                update_cpu_data_index(cpu);
-
-                /* other parts of the code may expect the pointer to not move */
-                save_seek = lseek(input_fd, 0, SEEK_CUR);
-
-                ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
-                if (ret == (off_t)-1)
-                        die("failed to lseek");
-                ret = read(input_fd, cpu_data[cpu].page, page_size);
-                if (ret < 0)
-                        die("failed to read page");
-
-                /* reset the file pointer back */
-                lseek(input_fd, save_seek, SEEK_SET);
-
-                return;
-        }
-
-        munmap(cpu_data[cpu].page, page_size);
-        cpu_data[cpu].page = NULL;
-
-        if (cpu_data[cpu].size <= page_size)
-                return;
-
-        update_cpu_data_index(cpu);
-
-        cpu_data[cpu].page = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE,
-                                  input_fd, cpu_data[cpu].offset);
-        if (cpu_data[cpu].page == MAP_FAILED)
-                die("failed to mmap cpu %d at offset 0x%llx",
-                    cpu, cpu_data[cpu].offset);
-}
-
-static unsigned int type_len4host(unsigned int type_len_ts)
-{
-        if (file_bigendian)
-                return (type_len_ts >> 27) & ((1 << 5) - 1);
-        else
-                return type_len_ts & ((1 << 5) - 1);
-}
-
-static unsigned int ts4host(unsigned int type_len_ts)
-{
-        if (file_bigendian)
-                return type_len_ts & ((1 << 27) - 1);
-        else
-                return type_len_ts >> 5;
-}
-
-static int calc_index(void *ptr, int cpu)
-{
-        return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
-}
-
-struct pevent_record *trace_peek_data(struct pevent *pevent, int cpu)
-{
-        struct pevent_record *data;
-        void *page = cpu_data[cpu].page;
-        int idx = cpu_data[cpu].index;
-        void *ptr = page + idx;
-        unsigned long long extend;
-        unsigned int type_len_ts;
-        unsigned int type_len;
-        unsigned int delta;
-        unsigned int length = 0;
-
-        if (cpu_data[cpu].next)
-                return cpu_data[cpu].next;
-
-        if (!page)
-                return NULL;
-
-        if (!idx) {
-                /* FIXME: handle header page */
-                if (header_page_ts_size != 8)
-                        die("expected a long long type for timestamp");
-                cpu_data[cpu].timestamp = data2host8(pevent, ptr);
-                ptr += 8;
-                switch (header_page_size_size) {
-                case 4:
-                        cpu_data[cpu].page_size = data2host4(pevent, ptr);
-                        ptr += 4;
-                        break;
-                case 8:
-                        cpu_data[cpu].page_size = data2host8(pevent, ptr);
-                        ptr += 8;
-                        break;
-                default:
-                        die("bad long size");
-                }
-                ptr = cpu_data[cpu].page + header_page_data_offset;
-        }
-
-read_again:
-        idx = calc_index(ptr, cpu);
-
-        if (idx >= cpu_data[cpu].page_size) {
-                get_next_page(cpu);
-                return trace_peek_data(pevent, cpu);
-        }
-
-        type_len_ts = data2host4(pevent, ptr);
-        ptr += 4;
-
-        type_len = type_len4host(type_len_ts);
-        delta = ts4host(type_len_ts);
-
-        switch (type_len) {
-        case RINGBUF_TYPE_PADDING:
-                if (!delta)
-                        die("error, hit unexpected end of page");
-                length = data2host4(pevent, ptr);
-                ptr += 4;
-                length *= 4;
-                ptr += length;
-                goto read_again;
-
-        case RINGBUF_TYPE_TIME_EXTEND:
-                extend = data2host4(pevent, ptr);
-                ptr += 4;
-                extend <<= TS_SHIFT;
-                extend += delta;
-                cpu_data[cpu].timestamp += extend;
-                goto read_again;
-
-        case RINGBUF_TYPE_TIME_STAMP:
-                ptr += 12;
-                break;
-        case 0:
-                length = data2host4(pevent, ptr);
-                ptr += 4;
-                die("here! length=%d", length);
-                break;
-        default:
-                length = type_len * 4;
-                break;
-        }
-
-        cpu_data[cpu].timestamp += delta;
-
-        data = malloc_or_die(sizeof(*data));
-        memset(data, 0, sizeof(*data));
-
-        data->ts = cpu_data[cpu].timestamp;
-        data->size = length;
-        data->data = ptr;
-        ptr += length;
-
-        cpu_data[cpu].index = calc_index(ptr, cpu);
-        cpu_data[cpu].next = data;
-
-        return data;
-}
-
-struct pevent_record *trace_read_data(struct pevent *pevent, int cpu)
-{
-        struct pevent_record *data;
-
-        data = trace_peek_data(pevent, cpu);
-        cpu_data[cpu].next = NULL;
-
-        return data;
+        return 0;
 }
 
 ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
@@ -494,58 +348,85 @@ ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
         int show_version = 0;
         int show_funcs = 0;
         int show_printk = 0;
-        ssize_t size;
+        ssize_t size = -1;
+        struct pevent *pevent;
+        int err;
 
-        calc_data_size = 1;
-        repipe = __repipe;
+        *ppevent = NULL;
 
+        repipe = __repipe;
         input_fd = fd;
 
-        read_or_die(buf, 3);
-        if (memcmp(buf, test, 3) != 0)
-                die("no trace data in the file");
+        if (do_read(buf, 3) < 0)
+                return -1;
+        if (memcmp(buf, test, 3) != 0) {
+                pr_debug("no trace data in the file");
+                return -1;
+        }
 
-        read_or_die(buf, 7);
-        if (memcmp(buf, "tracing", 7) != 0)
-                die("not a trace file (missing 'tracing' tag)");
+        if (do_read(buf, 7) < 0)
+                return -1;
+        if (memcmp(buf, "tracing", 7) != 0) {
+                pr_debug("not a trace file (missing 'tracing' tag)");
+                return -1;
+        }
 
         version = read_string();
+        if (version == NULL)
+                return -1;
         if (show_version)
                 printf("version = %s\n", version);
         free(version);
 
-        read_or_die(buf, 1);
+        if (do_read(buf, 1) < 0)
+                return -1;
         file_bigendian = buf[0];
         host_bigendian = bigendian();
 
-        *ppevent = read_trace_init(file_bigendian, host_bigendian);
-        if (*ppevent == NULL)
-                die("read_trace_init failed");
+        pevent = read_trace_init(file_bigendian, host_bigendian);
+        if (pevent == NULL) {
+                pr_debug("read_trace_init failed");
+                goto out;
+        }
 
-        read_or_die(buf, 1);
+        if (do_read(buf, 1) < 0)
+                goto out;
         long_size = buf[0];
 
-        page_size = read4(*ppevent);
-
-        read_header_files(*ppevent);
-
-        read_ftrace_files(*ppevent);
-        read_event_files(*ppevent);
-        read_proc_kallsyms(*ppevent);
-        read_ftrace_printk(*ppevent);
-
-        size = calc_data_size - 1;
-        calc_data_size = 0;
+        page_size = read4(pevent);
+        if (!page_size)
+                goto out;
+
+        err = read_header_files(pevent);
+        if (err)
+                goto out;
+        err = read_ftrace_files(pevent);
+        if (err)
+                goto out;
+        err = read_event_files(pevent);
+        if (err)
+                goto out;
+        err = read_proc_kallsyms(pevent);
+        if (err)
+                goto out;
+        err = read_ftrace_printk(pevent);
+        if (err)
+                goto out;
+
+        size = trace_data_size;
         repipe = false;
 
         if (show_funcs) {
-                pevent_print_funcs(*ppevent);
-                return size;
-        }
-        if (show_printk) {
-                pevent_print_printk(*ppevent);
-                return size;
+                pevent_print_funcs(pevent);
+        } else if (show_printk) {
+                pevent_print_printk(pevent);
         }
 
+        *ppevent = pevent;
+        pevent = NULL;
+
+out:
+        if (pevent)
+                pevent_free(pevent);
         return size;
 }
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index a55fd37ffea1..1978c398ad87 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -30,13 +30,9 @@ enum {
 int bigendian(void);
 
 struct pevent *read_trace_init(int file_bigendian, int host_bigendian);
-void print_trace_event(struct pevent *pevent, int cpu, void *data, int size);
 void event_format__print(struct event_format *event,
                          int cpu, void *data, int size);
 
-void print_event(struct pevent *pevent, int cpu, void *data, int size,
-                 unsigned long long nsecs, char *comm);
-
 int parse_ftrace_file(struct pevent *pevent, char *buf, unsigned long size);
 int parse_event_file(struct pevent *pevent,
                      char *buf, unsigned long size, char *sys);
@@ -72,7 +68,7 @@ struct tracing_data {
 
 struct tracing_data *tracing_data_get(struct list_head *pattrs,
                                       int fd, bool temp);
-void tracing_data_put(struct tracing_data *tdata);
+int tracing_data_put(struct tracing_data *tdata);
 
 
 struct addr_location;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 805d1f52c5b4..59d868add275 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -17,6 +17,8 @@ bool test_attr__enabled;
 bool perf_host  = true;
 bool perf_guest = false;
 
+char tracing_events_path[PATH_MAX + 1] = "/sys/kernel/debug/tracing/events";
+
 void event_attr_init(struct perf_event_attr *attr)
 {
         if (!perf_host)
@@ -242,3 +244,28 @@ void get_term_dimensions(struct winsize *ws)
         ws->ws_row = 25;
         ws->ws_col = 80;
 }
+
+static void set_tracing_events_path(const char *mountpoint)
+{
+        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
+                 mountpoint, "tracing/events");
+}
+
+const char *perf_debugfs_mount(const char *mountpoint)
+{
+        const char *mnt;
+
+        mnt = debugfs_mount(mountpoint);
+        if (!mnt)
+                return NULL;
+
+        set_tracing_events_path(mnt);
+
+        return mnt;
+}
+
+void perf_debugfs_set_path(const char *mntpt)
+{
+        snprintf(debugfs_mountpoint, strlen(debugfs_mountpoint), "%s", mntpt);
+        set_tracing_events_path(mntpt);
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 09b4c26b71aa..a45710b70a55 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -1,8 +1,6 @@
 #ifndef GIT_COMPAT_UTIL_H
 #define GIT_COMPAT_UTIL_H
 
-#define _FILE_OFFSET_BITS 64
-
 #ifndef FLEX_ARRAY
 /*
  * See if our compiler is known to support flexible array members.
@@ -73,10 +71,14 @@
 #include <linux/magic.h>
 #include "types.h"
 #include <sys/ttydefaults.h>
+#include <lk/debugfs.h>
 
 extern const char *graph_line;
 extern const char *graph_dotted_line;
 extern char buildid_dir[];
+extern char tracing_events_path[];
+extern void perf_debugfs_set_path(const char *mountpoint);
+const char *perf_debugfs_mount(const char *mountpoint);
 
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
@@ -274,5 +276,4 @@ extern unsigned int page_size;
 
 struct winsize;
 void get_term_dimensions(struct winsize *ws);
-
-#endif
+#endif /* GIT_COMPAT_UTIL_H */