Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Conflicts:
	tools/Makefile

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

. Honor parallel jobs, fix from Borislav Petkov

. Introduce tools/lib/lk library, initially just removing duplication
  among tools/perf and tools/vm. from Borislav Petkov

. Fix build on non-glibc systems due to libio.h absence, from Cody P Schafer.

. Remove some perf_session and tracing dead code, from David Ahern.

. Introduce perf stat --repeat forever, from Frederik Deweerdt.

. Add perf test entries for checking --cpu in record and stat, from Jiri Olsa.

. Add perf test entries for checking breakpoint overflow signal handler issues,
  from Jiri Olsa.

. Add perf test entry for for checking number of EXIT events, from Namhyung Kim.

. Simplify some perf_evlist methods and to allow 'stat' to share code with
  'record' and 'trace'.

. Remove dead code in related to libtraceevent integration, from Namhyung Kim.

. Event group view for 'annotate' in --stdio, --tui and --gtk, from Namhyung Kim.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
[ resolved the trivial merge conflict with upstream ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>

25 files changed, 371 insertions, 553 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..6f3c16f01ab4 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,
+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/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/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..1adb824610f0 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"
@@ -633,6 +633,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 +679,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)
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..a9b7349f7c5f 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2789,7 +2789,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 +2940,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.h b/tools/perf/util/hist.h
index 226a4ae2f936..848331377bdb 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -177,7 +177,7 @@ struct hist_browser_timer {
 
 #ifdef NEWT_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 +196,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)
 {
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index efdb38e65a92..c5e3b123782b 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -1003,6 +1003,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 +1050,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))
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index 5ac5892f2326..e0b2c00b2e75 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -97,7 +97,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..ab265c2cfab3 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1365,18 +1365,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/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..5729f434c5b1 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -38,35 +38,14 @@
 
 #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)
 {
@@ -80,7 +59,7 @@ static void *malloc_or_die(unsigned int size)
 
 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");
@@ -131,17 +110,10 @@ 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);
@@ -457,7 +429,6 @@ static void tracing_data_header(void)
         write_or_die(buf, 1);
 
         /* save page_size */
-        page_size = sysconf(_SC_PAGESIZE);
         write_or_die(&page_size, 4);
 }
 
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..7cb24635adf2 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -41,8 +41,6 @@
 
 static int input_fd;
 
-static int read_page;
-
 int file_bigendian;
 int host_bigendian;
 static int long_size;
@@ -287,205 +285,6 @@ static void read_event_files(struct pevent *pevent)
         }
 }
 
-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;
-}
-
 ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
 {
         char buf[BUFSIZ];
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index a55fd37ffea1..28ccde8ba20f 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);
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..6a0781c3a573 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -73,10 +73,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 +278,4 @@ extern unsigned int page_size;
 
 struct winsize;
 void get_term_dimensions(struct winsize *ws);
-
-#endif
+#endif /* GIT_COMPAT_UTIL_H */