Merge branch 'master' of /home/davem/src/GIT/linux-2.6/

Conflicts:
	include/linux/mod_devicetable.h
	scripts/mod/file2alias.c

55 files changed, 6975 insertions, 1977 deletions

diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index 54552a00a11..49ece792191 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -1,6 +1,10 @@
 #!/bin/sh
 
-GVF=PERF-VERSION-FILE
+if [ $# -eq 1 ]  ; then
+        OUTPUT=$1
+fi
+
+GVF=${OUTPUT}PERF-VERSION-FILE
 DEF_VER=v0.0.2.PERF
 
 LF='
diff --git a/tools/perf/util/bitmap.c b/tools/perf/util/bitmap.c
new file mode 100644
index 00000000000..5e230acae1e
--- /dev/null
+++ b/tools/perf/util/bitmap.c
@@ -0,0 +1,21 @@
+/*
+ * From lib/bitmap.c
+ * Helper functions for bitmap.h.
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+#include <linux/bitmap.h>
+
+int __bitmap_weight(const unsigned long *bitmap, int bits)
+{
+        int k, w = 0, lim = bits/BITS_PER_LONG;
+
+        for (k = 0; k < lim; k++)
+                w += hweight_long(bitmap[k]);
+
+        if (bits % BITS_PER_LONG)
+                w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
+
+        return w;
+}
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 04904b35ba8..0f60a390680 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -24,7 +24,7 @@ static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
         }
 
         thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
-                              event->ip.ip, &al);
+                              event->ip.pid, event->ip.ip, &al);
 
         if (al.map != NULL)
                 al.map->dso->hit = 1;
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 918eb376abe..4b9aab7f040 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -1,6 +1,7 @@
 #ifndef __PERF_CACHE_H
 #define __PERF_CACHE_H
 
+#include <stdbool.h>
 #include "util.h"
 #include "strbuf.h"
 #include "../perf.h"
@@ -69,6 +70,19 @@ extern const char *pager_program;
 extern int pager_in_use(void);
 extern int pager_use_color;
 
+extern bool use_browser;
+
+#ifdef NO_NEWT_SUPPORT
+static inline void setup_browser(void)
+{
+        setup_pager();
+}
+static inline void exit_browser(bool wait_for_ok __used) {}
+#else
+void setup_browser(void);
+void exit_browser(bool wait_for_ok);
+#endif
+
 extern const char *editor_program;
 extern const char *excludes_file;
 
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index b3b71258272..21a52e0a443 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com>
+ * Copyright (C) 2009-2010, Frederic Weisbecker <fweisbec@gmail.com>
  *
  * Handle the callchains from the stream in an ad-hoc radix tree and then
  * sort them in an rbtree.
@@ -17,6 +17,13 @@
 
 #include "callchain.h"
 
+bool ip_callchain__valid(struct ip_callchain *chain, event_t *event)
+{
+        unsigned int chain_size = event->header.size;
+        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
+        return chain->nr * sizeof(u64) <= chain_size;
+}
+
 #define chain_for_each_child(child, parent)     \
         list_for_each_entry(child, &parent->children, brothers)
 
@@ -160,7 +167,7 @@ create_child(struct callchain_node *parent, bool inherit_children)
 {
         struct callchain_node *new;
 
-        new = malloc(sizeof(*new));
+        new = zalloc(sizeof(*new));
         if (!new) {
                 perror("not enough memory to create child for code path tree");
                 return NULL;
@@ -183,25 +190,36 @@ create_child(struct callchain_node *parent, bool inherit_children)
         return new;
 }
 
+
+struct resolved_ip {
+        u64               ip;
+        struct map_symbol ms;
+};
+
+struct resolved_chain {
+        u64                     nr;
+        struct resolved_ip      ips[0];
+};
+
+
 /*
  * Fill the node with callchain values
  */
 static void
-fill_node(struct callchain_node *node, struct ip_callchain *chain,
-          int start, struct symbol **syms)
+fill_node(struct callchain_node *node, struct resolved_chain *chain, int start)
 {
         unsigned int i;
 
         for (i = start; i < chain->nr; i++) {
                 struct callchain_list *call;
 
-                call = malloc(sizeof(*call));
+                call = zalloc(sizeof(*call));
                 if (!call) {
                         perror("not enough memory for the code path tree");
                         return;
                 }
-                call->ip = chain->ips[i];
-                call->sym = syms[i];
+                call->ip = chain->ips[i].ip;
+                call->ms = chain->ips[i].ms;
                 list_add_tail(&call->list, &node->val);
         }
         node->val_nr = chain->nr - start;
@@ -210,13 +228,13 @@ fill_node(struct callchain_node *node, struct ip_callchain *chain,
 }
 
 static void
-add_child(struct callchain_node *parent, struct ip_callchain *chain,
-          int start, struct symbol **syms)
+add_child(struct callchain_node *parent, struct resolved_chain *chain,
+          int start)
 {
         struct callchain_node *new;
 
         new = create_child(parent, false);
-        fill_node(new, chain, start, syms);
+        fill_node(new, chain, start);
 
         new->children_hit = 0;
         new->hit = 1;
@@ -228,9 +246,8 @@ add_child(struct callchain_node *parent, struct ip_callchain *chain,
  * Then create another child to host the given callchain of new branch
  */
 static void
-split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
-                struct callchain_list *to_split, int idx_parents, int idx_local,
-                struct symbol **syms)
+split_add_child(struct callchain_node *parent, struct resolved_chain *chain,
+                struct callchain_list *to_split, int idx_parents, int idx_local)
 {
         struct callchain_node *new;
         struct list_head *old_tail;
@@ -257,7 +274,7 @@ split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
         /* create a new child for the new branch if any */
         if (idx_total < chain->nr) {
                 parent->hit = 0;
-                add_child(parent, chain, idx_total, syms);
+                add_child(parent, chain, idx_total);
                 parent->children_hit++;
         } else {
                 parent->hit = 1;
@@ -265,32 +282,33 @@ split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
 }
 
 static int
-__append_chain(struct callchain_node *root, struct ip_callchain *chain,
-               unsigned int start, struct symbol **syms);
+__append_chain(struct callchain_node *root, struct resolved_chain *chain,
+               unsigned int start);
 
 static void
-__append_chain_children(struct callchain_node *root, struct ip_callchain *chain,
-                        struct symbol **syms, unsigned int start)
+__append_chain_children(struct callchain_node *root,
+                        struct resolved_chain *chain,
+                        unsigned int start)
 {
         struct callchain_node *rnode;
 
         /* lookup in childrens */
         chain_for_each_child(rnode, root) {
-                unsigned int ret = __append_chain(rnode, chain, start, syms);
+                unsigned int ret = __append_chain(rnode, chain, start);
 
                 if (!ret)
                         goto inc_children_hit;
         }
         /* nothing in children, add to the current node */
-        add_child(root, chain, start, syms);
+        add_child(root, chain, start);
 
 inc_children_hit:
         root->children_hit++;
 }
 
 static int
-__append_chain(struct callchain_node *root, struct ip_callchain *chain,
-               unsigned int start, struct symbol **syms)
+__append_chain(struct callchain_node *root, struct resolved_chain *chain,
+               unsigned int start)
 {
         struct callchain_list *cnode;
         unsigned int i = start;
@@ -302,13 +320,19 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
          * anywhere inside a function.
          */
         list_for_each_entry(cnode, &root->val, list) {
+                struct symbol *sym;
+
                 if (i == chain->nr)
                         break;
-                if (cnode->sym && syms[i]) {
-                        if (cnode->sym->start != syms[i]->start)
+
+                sym = chain->ips[i].ms.sym;
+
+                if (cnode->ms.sym && sym) {
+                        if (cnode->ms.sym->start != sym->start)
                                 break;
-                } else if (cnode->ip != chain->ips[i])
+                } else if (cnode->ip != chain->ips[i].ip)
                         break;
+
                 if (!found)
                         found = true;
                 i++;
@@ -320,7 +344,7 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
 
         /* we match only a part of the node. Split it and add the new chain */
         if (i - start < root->val_nr) {
-                split_add_child(root, chain, cnode, start, i - start, syms);
+                split_add_child(root, chain, cnode, start, i - start);
                 return 0;
         }
 
@@ -331,15 +355,50 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
         }
 
         /* We match the node and still have a part remaining */
-        __append_chain_children(root, chain, syms, i);
+        __append_chain_children(root, chain, i);
 
         return 0;
 }
 
-void append_chain(struct callchain_node *root, struct ip_callchain *chain,
-                  struct symbol **syms)
+static void filter_context(struct ip_callchain *old, struct resolved_chain *new,
+                           struct map_symbol *syms)
 {
+        int i, j = 0;
+
+        for (i = 0; i < (int)old->nr; i++) {
+                if (old->ips[i] >= PERF_CONTEXT_MAX)
+                        continue;
+
+                new->ips[j].ip = old->ips[i];
+                new->ips[j].ms = syms[i];
+                j++;
+        }
+
+        new->nr = j;
+}
+
+
+int append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                 struct map_symbol *syms)
+{
+        struct resolved_chain *filtered;
+
         if (!chain->nr)
-                return;
-        __append_chain_children(root, chain, syms, 0);
+                return 0;
+
+        filtered = zalloc(sizeof(*filtered) +
+                          chain->nr * sizeof(struct resolved_ip));
+        if (!filtered)
+                return -ENOMEM;
+
+        filter_context(chain, filtered, syms);
+
+        if (!filtered->nr)
+                goto end;
+
+        __append_chain_children(root, filtered, 0);
+end:
+        free(filtered);
+
+        return 0;
 }
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index ad4626de4c2..1cba1f5504e 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -4,6 +4,7 @@
 #include "../perf.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
+#include "event.h"
 #include "util.h"
 #include "symbol.h"
 
@@ -33,13 +34,14 @@ typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_node *,
 
 struct callchain_param {
         enum chain_mode         mode;
+        u32                     print_limit;
         double                  min_percent;
         sort_chain_func_t       sort;
 };
 
 struct callchain_list {
         u64                     ip;
-        struct symbol           *sym;
+        struct map_symbol       ms;
         struct list_head        list;
 };
 
@@ -56,6 +58,8 @@ static inline u64 cumul_hits(struct callchain_node *node)
 }
 
 int register_callchain_param(struct callchain_param *param);
-void append_chain(struct callchain_node *root, struct ip_callchain *chain,
-                  struct symbol **syms);
+int append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                 struct map_symbol *syms);
+
+bool ip_callchain__valid(struct ip_callchain *chain, event_t *event);
 #endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index e88bca55a59..e191eb9a667 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -166,6 +166,31 @@ int perf_color_default_config(const char *var, const char *value, void *cb)
         return perf_default_config(var, value, cb);
 }
 
+static int __color_vsnprintf(char *bf, size_t size, const char *color,
+                             const char *fmt, va_list args, const char *trail)
+{
+        int r = 0;
+
+        /*
+         * Auto-detect:
+         */
+        if (perf_use_color_default < 0) {
+                if (isatty(1) || pager_in_use())
+                        perf_use_color_default = 1;
+                else
+                        perf_use_color_default = 0;
+        }
+
+        if (perf_use_color_default && *color)
+                r += snprintf(bf, size, "%s", color);
+        r += vsnprintf(bf + r, size - r, fmt, args);
+        if (perf_use_color_default && *color)
+                r += snprintf(bf + r, size - r, "%s", PERF_COLOR_RESET);
+        if (trail)
+                r += snprintf(bf + r, size - r, "%s", trail);
+        return r;
+}
+
 static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
                 va_list args, const char *trail)
 {
@@ -191,11 +216,28 @@ static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
         return r;
 }
 
+int color_vsnprintf(char *bf, size_t size, const char *color,
+                    const char *fmt, va_list args)
+{
+        return __color_vsnprintf(bf, size, color, fmt, args, NULL);
+}
+
 int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args)
 {
         return __color_vfprintf(fp, color, fmt, args, NULL);
 }
 
+int color_snprintf(char *bf, size_t size, const char *color,
+                   const char *fmt, ...)
+{
+        va_list args;
+        int r;
+
+        va_start(args, fmt);
+        r = color_vsnprintf(bf, size, color, fmt, args);
+        va_end(args);
+        return r;
+}
 
 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
 {
@@ -274,3 +316,9 @@ int percent_color_fprintf(FILE *fp, const char *fmt, double percent)
 
         return r;
 }
+
+int percent_color_snprintf(char *bf, size_t size, const char *fmt, double percent)
+{
+        const char *color = get_percent_color(percent);
+        return color_snprintf(bf, size, color, fmt, percent);
+}
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 24e8809210b..dea082b7960 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -32,10 +32,14 @@ int perf_color_default_config(const char *var, const char *value, void *cb);
 int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
 void color_parse(const char *value, const char *var, char *dst);
 void color_parse_mem(const char *value, int len, const char *var, char *dst);
+int color_vsnprintf(char *bf, size_t size, const char *color,
+                    const char *fmt, va_list args);
 int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args);
 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...);
+int color_snprintf(char *bf, size_t size, const char *color, const char *fmt, ...);
 int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...);
 int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
+int percent_color_snprintf(char *bf, size_t size, const char *fmt, double percent);
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
 const char *get_percent_color(double percent);
 
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 0905600c385..dd824cf3b62 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -6,13 +6,14 @@
 #include <stdarg.h>
 #include <stdio.h>
 
+#include "cache.h"
 #include "color.h"
 #include "event.h"
 #include "debug.h"
 #include "util.h"
 
 int verbose = 0;
-int dump_trace = 0;
+bool dump_trace = false;
 
 int eprintf(int level, const char *fmt, ...)
 {
@@ -21,7 +22,10 @@ int eprintf(int level, const char *fmt, ...)
 
         if (verbose >= level) {
                 va_start(args, fmt);
-                ret = vfprintf(stderr, fmt, args);
+                if (use_browser)
+                        ret = browser__show_help(fmt, args);
+                else
+                        ret = vfprintf(stderr, fmt, args);
                 va_end(args);
         }
 
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index c6c24c522de..047ac3324eb 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -2,14 +2,38 @@
 #ifndef __PERF_DEBUG_H
 #define __PERF_DEBUG_H
 
+#include <stdbool.h>
 #include "event.h"
 
 extern int verbose;
-extern int dump_trace;
+extern bool dump_trace;
 
-int eprintf(int level,
-            const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(event_t *event);
 
+struct ui_progress;
+
+#ifdef NO_NEWT_SUPPORT
+static inline int browser__show_help(const char *format __used, va_list ap __used)
+{
+        return 0;
+}
+
+static inline struct ui_progress *ui_progress__new(const char *title __used,
+                                                   u64 total __used)
+{
+        return (struct ui_progress *)1;
+}
+
+static inline void ui_progress__update(struct ui_progress *self __used,
+                                       u64 curr __used) {}
+
+static inline void ui_progress__delete(struct ui_progress *self __used) {}
+#else
+int browser__show_help(const char *format, va_list ap);
+struct ui_progress *ui_progress__new(const char *title, u64 total);
+void ui_progress__update(struct ui_progress *self, u64 curr);
+void ui_progress__delete(struct ui_progress *self);
+#endif
+
 #endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 705ec63548b..50771b5813e 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -7,6 +7,23 @@
 #include "strlist.h"
 #include "thread.h"
 
+const char *event__name[] = {
+        [0]                      = "TOTAL",
+        [PERF_RECORD_MMAP]       = "MMAP",
+        [PERF_RECORD_LOST]       = "LOST",
+        [PERF_RECORD_COMM]       = "COMM",
+        [PERF_RECORD_EXIT]       = "EXIT",
+        [PERF_RECORD_THROTTLE]   = "THROTTLE",
+        [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
+        [PERF_RECORD_FORK]       = "FORK",
+        [PERF_RECORD_READ]       = "READ",
+        [PERF_RECORD_SAMPLE]     = "SAMPLE",
+        [PERF_RECORD_HEADER_ATTR]        = "ATTR",
+        [PERF_RECORD_HEADER_EVENT_TYPE]  = "EVENT_TYPE",
+        [PERF_RECORD_HEADER_TRACING_DATA]        = "TRACING_DATA",
+        [PERF_RECORD_HEADER_BUILD_ID]    = "BUILD_ID",
+};
+
 static pid_t event__synthesize_comm(pid_t pid, int full,
                                     event__handler_t process,
                                     struct perf_session *session)
@@ -112,7 +129,11 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
                 event_t ev = {
                         .header = {
                                 .type = PERF_RECORD_MMAP,
-                                .misc = 0, /* Just like the kernel, see kernel/perf_event.c __perf_event_mmap */
+                                /*
+                                 * Just like the kernel, see __perf_event_mmap
+                                 * in kernel/perf_event.c
+                                 */
+                                .misc = PERF_RECORD_MISC_USER,
                          },
                 };
                 int n;
@@ -130,6 +151,7 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
                         continue;
                 pbf += n + 3;
                 if (*pbf == 'x') { /* vm_exec */
+                        u64 vm_pgoff;
                         char *execname = strchr(bf, '/');
 
                         /* Catch VDSO */
@@ -139,6 +161,14 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
                         if (execname == NULL)
                                 continue;
 
+                        pbf += 3;
+                        n = hex2u64(pbf, &vm_pgoff);
+                        /* pgoff is in bytes, not pages */
+                        if (n >= 0)
+                                ev.mmap.pgoff = vm_pgoff << getpagesize();
+                        else
+                                ev.mmap.pgoff = 0;
+
                         size = strlen(execname);
                         execname[size - 1] = '\0'; /* Remove \n */
                         memcpy(ev.mmap.filename, execname, size);
@@ -158,11 +188,23 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
 }
 
 int event__synthesize_modules(event__handler_t process,
-                              struct perf_session *session)
+                              struct perf_session *session,
+                              struct machine *machine)
 {
         struct rb_node *nd;
+        struct map_groups *kmaps = &machine->kmaps;
+        u16 misc;
+
+        /*
+         * kernel uses 0 for user space maps, see kernel/perf_event.c
+         * __perf_event_mmap
+         */
+        if (machine__is_host(machine))
+                misc = PERF_RECORD_MISC_KERNEL;
+        else
+                misc = PERF_RECORD_MISC_GUEST_KERNEL;
 
-        for (nd = rb_first(&session->kmaps.maps[MAP__FUNCTION]);
+        for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]);
              nd; nd = rb_next(nd)) {
                 event_t ev;
                 size_t size;
@@ -173,12 +215,13 @@ int event__synthesize_modules(event__handler_t process,
 
                 size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
                 memset(&ev, 0, sizeof(ev));
-                ev.mmap.header.misc = 1; /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
+                ev.mmap.header.misc = misc;
                 ev.mmap.header.type = PERF_RECORD_MMAP;
                 ev.mmap.header.size = (sizeof(ev.mmap) -
                                         (sizeof(ev.mmap.filename) - size));
                 ev.mmap.start = pos->start;
                 ev.mmap.len   = pos->end - pos->start;
+                ev.mmap.pid   = machine->pid;
 
                 memcpy(ev.mmap.filename, pos->dso->long_name,
                        pos->dso->long_name_len + 1);
@@ -241,13 +284,18 @@ static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
 
 int event__synthesize_kernel_mmap(event__handler_t process,
                                   struct perf_session *session,
+                                  struct machine *machine,
                                   const char *symbol_name)
 {
         size_t size;
+        const char *filename, *mmap_name;
+        char path[PATH_MAX];
+        char name_buff[PATH_MAX];
+        struct map *map;
+
         event_t ev = {
                 .header = {
                         .type = PERF_RECORD_MMAP,
-                        .misc = 1, /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
                 },
         };
         /*
@@ -257,16 +305,37 @@ int event__synthesize_kernel_mmap(event__handler_t process,
          */
         struct process_symbol_args args = { .name = symbol_name, };
 
-        if (kallsyms__parse("/proc/kallsyms", &args, find_symbol_cb) <= 0)
+        mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff));
+        if (machine__is_host(machine)) {
+                /*
+                 * kernel uses PERF_RECORD_MISC_USER for user space maps,
+                 * see kernel/perf_event.c __perf_event_mmap
+                 */
+                ev.header.misc = PERF_RECORD_MISC_KERNEL;
+                filename = "/proc/kallsyms";
+        } else {
+                ev.header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
+                if (machine__is_default_guest(machine))
+                        filename = (char *) symbol_conf.default_guest_kallsyms;
+                else {
+                        sprintf(path, "%s/proc/kallsyms", machine->root_dir);
+                        filename = path;
+                }
+        }
+
+        if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
                 return -ENOENT;
 
+        map = machine->vmlinux_maps[MAP__FUNCTION];
         size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
-                        "[kernel.kallsyms.%s]", symbol_name) + 1;
+                        "%s%s", mmap_name, symbol_name) + 1;
         size = ALIGN(size, sizeof(u64));
-        ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size));
+        ev.mmap.header.size = (sizeof(ev.mmap) -
+                        (sizeof(ev.mmap.filename) - size));
         ev.mmap.pgoff = args.start;
-        ev.mmap.start = session->vmlinux_maps[MAP__FUNCTION]->start;
-        ev.mmap.len   = session->vmlinux_maps[MAP__FUNCTION]->end - ev.mmap.start ;
+        ev.mmap.start = map->start;
+        ev.mmap.len   = map->end - ev.mmap.start;
+        ev.mmap.pid   = machine->pid;
 
         return process(&ev, session);
 }
@@ -316,26 +385,54 @@ int event__process_comm(event_t *self, struct perf_session *session)
 int event__process_lost(event_t *self, struct perf_session *session)
 {
         dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
-        session->events_stats.lost += self->lost.lost;
+        session->hists.stats.total_lost += self->lost.lost;
         return 0;
 }
 
-int event__process_mmap(event_t *self, struct perf_session *session)
+static void event_set_kernel_mmap_len(struct map **maps, event_t *self)
+{
+        maps[MAP__FUNCTION]->start = self->mmap.start;
+        maps[MAP__FUNCTION]->end   = self->mmap.start + self->mmap.len;
+        /*
+         * Be a bit paranoid here, some perf.data file came with
+         * a zero sized synthesized MMAP event for the kernel.
+         */
+        if (maps[MAP__FUNCTION]->end == 0)
+                maps[MAP__FUNCTION]->end = ~0UL;
+}
+
+static int event__process_kernel_mmap(event_t *self,
+                        struct perf_session *session)
 {
-        struct thread *thread;
         struct map *map;
+        char kmmap_prefix[PATH_MAX];
+        struct machine *machine;
+        enum dso_kernel_type kernel_type;
+        bool is_kernel_mmap;
+
+        machine = perf_session__findnew_machine(session, self->mmap.pid);
+        if (!machine) {
+                pr_err("Can't find id %d's machine\n", self->mmap.pid);
+                goto out_problem;
+        }
 
-        dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n",
-                    self->mmap.pid, self->mmap.tid, self->mmap.start,
-                    self->mmap.len, self->mmap.pgoff, self->mmap.filename);
+        machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
+        if (machine__is_host(machine))
+                kernel_type = DSO_TYPE_KERNEL;
+        else
+                kernel_type = DSO_TYPE_GUEST_KERNEL;
 
-        if (self->mmap.pid == 0) {
-                static const char kmmap_prefix[] = "[kernel.kallsyms.";
+        is_kernel_mmap = memcmp(self->mmap.filename,
+                                kmmap_prefix,
+                                strlen(kmmap_prefix)) == 0;
+        if (self->mmap.filename[0] == '/' ||
+            (!is_kernel_mmap && self->mmap.filename[0] == '[')) {
 
-                if (self->mmap.filename[0] == '/') {
-                        char short_module_name[1024];
-                        char *name = strrchr(self->mmap.filename, '/'), *dot;
+                char short_module_name[1024];
+                char *name, *dot;
 
+                if (self->mmap.filename[0] == '/') {
+                        name = strrchr(self->mmap.filename, '/');
                         if (name == NULL)
                                 goto out_problem;
 
@@ -343,58 +440,84 @@ int event__process_mmap(event_t *self, struct perf_session *session)
                         dot = strrchr(name, '.');
                         if (dot == NULL)
                                 goto out_problem;
-
                         snprintf(short_module_name, sizeof(short_module_name),
-                                 "[%.*s]", (int)(dot - name), name);
+                                        "[%.*s]", (int)(dot - name), name);
                         strxfrchar(short_module_name, '-', '_');
-
-                        map = perf_session__new_module_map(session,
-                                                           self->mmap.start,
-                                                           self->mmap.filename);
-                        if (map == NULL)
-                                goto out_problem;
-
-                        name = strdup(short_module_name);
-                        if (name == NULL)
-                                goto out_problem;
-
-                        map->dso->short_name = name;
-                        map->end = map->start + self->mmap.len;
-                } else if (memcmp(self->mmap.filename, kmmap_prefix,
-                                sizeof(kmmap_prefix) - 1) == 0) {
-                        const char *symbol_name = (self->mmap.filename +
-                                                   sizeof(kmmap_prefix) - 1);
+                } else
+                        strcpy(short_module_name, self->mmap.filename);
+
+                map = machine__new_module(machine, self->mmap.start,
+                                          self->mmap.filename);
+                if (map == NULL)
+                        goto out_problem;
+
+                name = strdup(short_module_name);
+                if (name == NULL)
+                        goto out_problem;
+
+                map->dso->short_name = name;
+                map->end = map->start + self->mmap.len;
+        } else if (is_kernel_mmap) {
+                const char *symbol_name = (self->mmap.filename +
+                                strlen(kmmap_prefix));
+                /*
+                 * Should be there already, from the build-id table in
+                 * the header.
+                 */
+                struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
+                                                     kmmap_prefix);
+                if (kernel == NULL)
+                        goto out_problem;
+
+                kernel->kernel = kernel_type;
+                if (__machine__create_kernel_maps(machine, kernel) < 0)
+                        goto out_problem;
+
+                event_set_kernel_mmap_len(machine->vmlinux_maps, self);
+                perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
+                                                         symbol_name,
+                                                         self->mmap.pgoff);
+                if (machine__is_default_guest(machine)) {
                         /*
-                         * Should be there already, from the build-id table in
-                         * the header.
+                         * preload dso of guest kernel and modules
                          */
-                        struct dso *kernel = __dsos__findnew(&dsos__kernel,
-                                                             "[kernel.kallsyms]");
-                        if (kernel == NULL)
-                                goto out_problem;
-
-                        kernel->kernel = 1;
-                        if (__perf_session__create_kernel_maps(session, kernel) < 0)
-                                goto out_problem;
+                        dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
+                                  NULL);
+                }
+        }
+        return 0;
+out_problem:
+        return -1;
+}
 
-                        session->vmlinux_maps[MAP__FUNCTION]->start = self->mmap.start;
-                        session->vmlinux_maps[MAP__FUNCTION]->end   = self->mmap.start + self->mmap.len;
-                        /*
-                         * Be a bit paranoid here, some perf.data file came with
-                         * a zero sized synthesized MMAP event for the kernel.
-                         */
-                        if (session->vmlinux_maps[MAP__FUNCTION]->end == 0)
-                                session->vmlinux_maps[MAP__FUNCTION]->end = ~0UL;
+int event__process_mmap(event_t *self, struct perf_session *session)
+{
+        struct machine *machine;
+        struct thread *thread;
+        struct map *map;
+        u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        int ret = 0;
 
-                        perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name,
-                                                                 self->mmap.pgoff);
-                }
+        dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n",
+                        self->mmap.pid, self->mmap.tid, self->mmap.start,
+                        self->mmap.len, self->mmap.pgoff, self->mmap.filename);
+
+        if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
+            cpumode == PERF_RECORD_MISC_KERNEL) {
+                ret = event__process_kernel_mmap(self, session);
+                if (ret < 0)
+                        goto out_problem;
                 return 0;
         }
 
+        machine = perf_session__find_host_machine(session);
+        if (machine == NULL)
+                goto out_problem;
         thread = perf_session__findnew(session, self->mmap.pid);
-        map = map__new(&self->mmap, MAP__FUNCTION,
-                       session->cwd, session->cwdlen);
+        map = map__new(&machine->user_dsos, self->mmap.start,
+                        self->mmap.len, self->mmap.pgoff,
+                        self->mmap.pid, self->mmap.filename,
+                        MAP__FUNCTION, session->cwd, session->cwdlen);
 
         if (thread == NULL || map == NULL)
                 goto out_problem;
@@ -434,22 +557,56 @@ int event__process_task(event_t *self, struct perf_session *session)
 
 void thread__find_addr_map(struct thread *self,
                            struct perf_session *session, u8 cpumode,
-                           enum map_type type, u64 addr,
+                           enum map_type type, pid_t pid, u64 addr,
                            struct addr_location *al)
 {
         struct map_groups *mg = &self->mg;
+        struct machine *machine = NULL;
 
         al->thread = self;
         al->addr = addr;
+        al->cpumode = cpumode;
+        al->filtered = false;
 
-        if (cpumode == PERF_RECORD_MISC_KERNEL) {
+        if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
                 al->level = 'k';
-                mg = &session->kmaps;
-        } else if (cpumode == PERF_RECORD_MISC_USER)
+                machine = perf_session__find_host_machine(session);
+                if (machine == NULL) {
+                        al->map = NULL;
+                        return;
+                }
+                mg = &machine->kmaps;
+        } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
                 al->level = '.';
-        else {
-                al->level = 'H';
+                machine = perf_session__find_host_machine(session);
+        } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
+                al->level = 'g';
+                machine = perf_session__find_machine(session, pid);
+                if (machine == NULL) {
+                        al->map = NULL;
+                        return;
+                }
+                mg = &machine->kmaps;
+        } else {
+                /*
+                 * 'u' means guest os user space.
+                 * TODO: We don't support guest user space. Might support late.
+                 */
+                if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest)
+                        al->level = 'u';
+                else
+                        al->level = 'H';
                 al->map = NULL;
+
+                if ((cpumode == PERF_RECORD_MISC_GUEST_USER ||
+                        cpumode == PERF_RECORD_MISC_GUEST_KERNEL) &&
+                        !perf_guest)
+                        al->filtered = true;
+                if ((cpumode == PERF_RECORD_MISC_USER ||
+                        cpumode == PERF_RECORD_MISC_KERNEL) &&
+                        !perf_host)
+                        al->filtered = true;
+
                 return;
         }
 try_again:
@@ -464,8 +621,10 @@ try_again:
                  * "[vdso]" dso, but for now lets use the old trick of looking
                  * in the whole kernel symbol list.
                  */
-                if ((long long)al->addr < 0 && mg != &session->kmaps) {
-                        mg = &session->kmaps;
+                if ((long long)al->addr < 0 &&
+                    cpumode == PERF_RECORD_MISC_KERNEL &&
+                    machine && mg != &machine->kmaps) {
+                        mg = &machine->kmaps;
                         goto try_again;
                 }
         } else
@@ -474,11 +633,11 @@ try_again:
 
 void thread__find_addr_location(struct thread *self,
                                 struct perf_session *session, u8 cpumode,
-                                enum map_type type, u64 addr,
+                                enum map_type type, pid_t pid, u64 addr,
                                 struct addr_location *al,
                                 symbol_filter_t filter)
 {
-        thread__find_addr_map(self, session, cpumode, type, addr, al);
+        thread__find_addr_map(self, session, cpumode, type, pid, addr, al);
         if (al->map != NULL)
                 al->sym = map__find_symbol(al->map, al->addr, filter);
         else
@@ -490,8 +649,10 @@ static void dso__calc_col_width(struct dso *self)
         if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
             (!symbol_conf.dso_list ||
              strlist__has_entry(symbol_conf.dso_list, self->name))) {
-                unsigned int slen = strlen(self->name);
-                if (slen > dsos__col_width)
+                u16 slen = self->short_name_len;
+                if (verbose)
+                        slen = self->long_name_len;
+                if (dsos__col_width < slen)
                         dsos__col_width = slen;
         }
 
@@ -512,31 +673,55 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
                 goto out_filtered;
 
         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        /*
+         * Have we already created the kernel maps for the host machine?
+         *
+         * This should have happened earlier, when we processed the kernel MMAP
+         * events, but for older perf.data files there was no such thing, so do
+         * it now.
+         */
+        if (cpumode == PERF_RECORD_MISC_KERNEL &&
+            session->host_machine.vmlinux_maps[MAP__FUNCTION] == NULL)
+                machine__create_kernel_maps(&session->host_machine);
 
-        thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
-                                   self->ip.ip, al, filter);
+        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                              self->ip.pid, self->ip.ip, al);
         dump_printf(" ...... dso: %s\n",
                     al->map ? al->map->dso->long_name :
                         al->level == 'H' ? "[hypervisor]" : "<not found>");
-        /*
-         * We have to do this here as we may have a dso with no symbol hit that
-         * has a name longer than the ones with symbols sampled.
-         */
-        if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated)
-                dso__calc_col_width(al->map->dso);
-
-        if (symbol_conf.dso_list &&
-            (!al->map || !al->map->dso ||
-             !(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) ||
-               (al->map->dso->short_name != al->map->dso->long_name &&
-                strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name)))))
-                goto out_filtered;
+        al->sym = NULL;
+
+        if (al->map) {
+                if (symbol_conf.dso_list &&
+                    (!al->map || !al->map->dso ||
+                     !(strlist__has_entry(symbol_conf.dso_list,
+                                          al->map->dso->short_name) ||
+                       (al->map->dso->short_name != al->map->dso->long_name &&
+                        strlist__has_entry(symbol_conf.dso_list,
+                                           al->map->dso->long_name)))))
+                        goto out_filtered;
+                /*
+                 * We have to do this here as we may have a dso with no symbol
+                 * hit that has a name longer than the ones with symbols
+                 * sampled.
+                 */
+                if (!sort_dso.elide && !al->map->dso->slen_calculated)
+                        dso__calc_col_width(al->map->dso);
+
+                al->sym = map__find_symbol(al->map, al->addr, filter);
+        } else {
+                const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
+
+                if (dsos__col_width < unresolved_col_width &&
+                    !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
+                    !symbol_conf.dso_list)
+                        dsos__col_width = unresolved_col_width;
+        }
 
         if (symbol_conf.sym_list && al->sym &&
             !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
                 goto out_filtered;
 
-        al->filtered = false;
         return 0;
 
 out_filtered:
@@ -570,6 +755,7 @@ int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
                 array++;
         }
 
+        data->id = -1ULL;
         if (type & PERF_SAMPLE_ID) {
                 data->id = *array;
                 array++;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index a33b94952e3..8577085db06 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -68,21 +68,54 @@ struct sample_data {
         u64 addr;
         u64 id;
         u64 stream_id;
-        u32 cpu;
         u64 period;
-        struct ip_callchain *callchain;
+        u32 cpu;
         u32 raw_size;
         void *raw_data;
+        struct ip_callchain *callchain;
 };
 
 #define BUILD_ID_SIZE 20
 
 struct build_id_event {
         struct perf_event_header header;
+        pid_t                    pid;
         u8                       build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
         char                     filename[];
 };
 
+enum perf_user_event_type { /* above any possible kernel type */
+        PERF_RECORD_HEADER_ATTR                 = 64,
+        PERF_RECORD_HEADER_EVENT_TYPE           = 65,
+        PERF_RECORD_HEADER_TRACING_DATA         = 66,
+        PERF_RECORD_HEADER_BUILD_ID             = 67,
+        PERF_RECORD_FINISHED_ROUND              = 68,
+        PERF_RECORD_HEADER_MAX
+};
+
+struct attr_event {
+        struct perf_event_header header;
+        struct perf_event_attr attr;
+        u64 id[];
+};
+
+#define MAX_EVENT_NAME 64
+
+struct perf_trace_event_type {
+        u64     event_id;
+        char    name[MAX_EVENT_NAME];
+};
+
+struct event_type_event {
+        struct perf_event_header header;
+        struct perf_trace_event_type event_type;
+};
+
+struct tracing_data_event {
+        struct perf_event_header header;
+        u32 size;
+};
+
 typedef union event_union {
         struct perf_event_header        header;
         struct ip_event                 ip;
@@ -92,22 +125,12 @@ typedef union event_union {
         struct lost_event               lost;
         struct read_event               read;
         struct sample_event             sample;
+        struct attr_event               attr;
+        struct event_type_event         event_type;
+        struct tracing_data_event       tracing_data;
+        struct build_id_event           build_id;
 } event_t;
 
-struct events_stats {
-        u64 total;
-        u64 lost;
-};
-
-struct event_stat_id {
-        struct rb_node          rb_node;
-        struct rb_root          hists;
-        struct events_stats     stats;
-        u64                     config;
-        u64                     event_stream;
-        u32                     type;
-};
-
 void event__print_totals(void);
 
 struct perf_session;
@@ -119,10 +142,13 @@ int event__synthesize_thread(pid_t pid, event__handler_t process,
 void event__synthesize_threads(event__handler_t process,
                                struct perf_session *session);
 int event__synthesize_kernel_mmap(event__handler_t process,
-                                  struct perf_session *session,
-                                  const char *symbol_name);
+                                struct perf_session *session,
+                                struct machine *machine,
+                                const char *symbol_name);
+
 int event__synthesize_modules(event__handler_t process,
-                              struct perf_session *session);
+                              struct perf_session *session,
+                              struct machine *machine);
 
 int event__process_comm(event_t *self, struct perf_session *session);
 int event__process_lost(event_t *self, struct perf_session *session);
@@ -134,4 +160,6 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
                              struct addr_location *al, symbol_filter_t filter);
 int event__parse_sample(event_t *event, u64 type, struct sample_data *data);
 
+extern const char *event__name[];
+
 #endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 6c9aa16ee51..8847bec64c5 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -99,13 +99,6 @@ int perf_header__add_attr(struct perf_header *self,
         return 0;
 }
 
-#define MAX_EVENT_NAME 64
-
-struct perf_trace_event_type {
-        u64     event_id;
-        char    name[MAX_EVENT_NAME];
-};
-
 static int event_count;
 static struct perf_trace_event_type *events;
 
@@ -197,7 +190,8 @@ static int write_padded(int fd, const void *bf, size_t count,
                         continue;               \
                 else
 
-static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
+static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
+                                u16 misc, int fd)
 {
         struct dso *pos;
 
@@ -212,6 +206,7 @@ static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
                 len = ALIGN(len, NAME_ALIGN);
                 memset(&b, 0, sizeof(b));
                 memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
+                b.pid = pid;
                 b.header.misc = misc;
                 b.header.size = sizeof(b) + len;
                 err = do_write(fd, &b, sizeof(b));
@@ -226,13 +221,32 @@ static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
         return 0;
 }
 
-static int dsos__write_buildid_table(int fd)
+static int dsos__write_buildid_table(struct perf_header *header, int fd)
 {
-        int err = __dsos__write_buildid_table(&dsos__kernel,
-                                              PERF_RECORD_MISC_KERNEL, fd);
-        if (err == 0)
-                err = __dsos__write_buildid_table(&dsos__user,
-                                                  PERF_RECORD_MISC_USER, fd);
+        struct perf_session *session = container_of(header,
+                        struct perf_session, header);
+        struct rb_node *nd;
+        int err = 0;
+        u16 kmisc, umisc;
+
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                if (machine__is_host(pos)) {
+                        kmisc = PERF_RECORD_MISC_KERNEL;
+                        umisc = PERF_RECORD_MISC_USER;
+                } else {
+                        kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
+                        umisc = PERF_RECORD_MISC_GUEST_USER;
+                }
+
+                err = __dsos__write_buildid_table(&pos->kernel_dsos, pos->pid,
+                                                  kmisc, fd);
+                if (err == 0)
+                        err = __dsos__write_buildid_table(&pos->user_dsos,
+                                                          pos->pid, umisc, fd);
+                if (err)
+                        break;
+        }
         return err;
 }
 
@@ -349,9 +363,12 @@ static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
         return err;
 }
 
-static int dsos__cache_build_ids(void)
+static int dsos__cache_build_ids(struct perf_header *self)
 {
-        int err_kernel, err_user;
+        struct perf_session *session = container_of(self,
+                        struct perf_session, header);
+        struct rb_node *nd;
+        int ret = 0;
         char debugdir[PATH_MAX];
 
         snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"),
@@ -360,9 +377,28 @@ static int dsos__cache_build_ids(void)
         if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
                 return -1;
 
-        err_kernel = __dsos__cache_build_ids(&dsos__kernel, debugdir);
-        err_user   = __dsos__cache_build_ids(&dsos__user, debugdir);
-        return err_kernel || err_user ? -1 : 0;
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret |= __dsos__cache_build_ids(&pos->kernel_dsos, debugdir);
+                ret |= __dsos__cache_build_ids(&pos->user_dsos, debugdir);
+        }
+        return ret ? -1 : 0;
+}
+
+static bool dsos__read_build_ids(struct perf_header *self, bool with_hits)
+{
+        bool ret = false;
+        struct perf_session *session = container_of(self,
+                        struct perf_session, header);
+        struct rb_node *nd;
+
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret |= __dsos__read_build_ids(&pos->kernel_dsos, with_hits);
+                ret |= __dsos__read_build_ids(&pos->user_dsos, with_hits);
+        }
+
+        return ret;
 }
 
 static int perf_header__adds_write(struct perf_header *self, int fd)
@@ -373,7 +409,7 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
         u64 sec_start;
         int idx = 0, err;
 
-        if (dsos__read_build_ids(true))
+        if (dsos__read_build_ids(self, true))
                 perf_header__set_feat(self, HEADER_BUILD_ID);
 
         nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
@@ -400,7 +436,6 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
                 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
         }
 
-
         if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
                 struct perf_file_section *buildid_sec;
 
@@ -408,14 +443,14 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
 
                 /* Write build-ids */
                 buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
-                err = dsos__write_buildid_table(fd);
+                err = dsos__write_buildid_table(self, fd);
                 if (err < 0) {
                         pr_debug("failed to write buildid table\n");
                         goto out_free;
                 }
                 buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
                                           buildid_sec->offset;
-                dsos__cache_build_ids();
+                dsos__cache_build_ids(self);
         }
 
         lseek(fd, sec_start, SEEK_SET);
@@ -427,6 +462,25 @@ out_free:
         return err;
 }
 
+int perf_header__write_pipe(int fd)
+{
+        struct perf_pipe_file_header f_header;
+        int err;
+
+        f_header = (struct perf_pipe_file_header){
+                .magic     = PERF_MAGIC,
+                .size      = sizeof(f_header),
+        };
+
+        err = do_write(fd, &f_header, sizeof(f_header));
+        if (err < 0) {
+                pr_debug("failed to write perf pipe header\n");
+                return err;
+        }
+
+        return 0;
+}
+
 int perf_header__write(struct perf_header *self, int fd, bool at_exit)
 {
         struct perf_file_header f_header;
@@ -518,25 +572,10 @@ int perf_header__write(struct perf_header *self, int fd, bool at_exit)
         return 0;
 }
 
-static int do_read(int fd, void *buf, size_t size)
-{
-        while (size) {
-                int ret = read(fd, buf, size);
-
-                if (ret <= 0)
-                        return -1;
-
-                size -= ret;
-                buf += ret;
-        }
-
-        return 0;
-}
-
 static int perf_header__getbuffer64(struct perf_header *self,
                                     int fd, void *buf, size_t size)
 {
-        if (do_read(fd, buf, size))
+        if (do_read(fd, buf, size) <= 0)
                 return -1;
 
         if (self->needs_swap)
@@ -592,7 +631,7 @@ int perf_file_header__read(struct perf_file_header *self,
 {
         lseek(fd, 0, SEEK_SET);
 
-        if (do_read(fd, self, sizeof(*self)) ||
+        if (do_read(fd, self, sizeof(*self)) <= 0 ||
             memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
                 return -1;
 
@@ -636,6 +675,93 @@ int perf_file_header__read(struct perf_file_header *self,
         return 0;
 }
 
+static int __event_process_build_id(struct build_id_event *bev,
+                                    char *filename,
+                                    struct perf_session *session)
+{
+        int err = -1;
+        struct list_head *head;
+        struct machine *machine;
+        u16 misc;
+        struct dso *dso;
+        enum dso_kernel_type dso_type;
+
+        machine = perf_session__findnew_machine(session, bev->pid);
+        if (!machine)
+                goto out;
+
+        misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        switch (misc) {
+        case PERF_RECORD_MISC_KERNEL:
+                dso_type = DSO_TYPE_KERNEL;
+                head = &machine->kernel_dsos;
+                break;
+        case PERF_RECORD_MISC_GUEST_KERNEL:
+                dso_type = DSO_TYPE_GUEST_KERNEL;
+                head = &machine->kernel_dsos;
+                break;
+        case PERF_RECORD_MISC_USER:
+        case PERF_RECORD_MISC_GUEST_USER:
+                dso_type = DSO_TYPE_USER;
+                head = &machine->user_dsos;
+                break;
+        default:
+                goto out;
+        }
+
+        dso = __dsos__findnew(head, filename);
+        if (dso != NULL) {
+                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                dso__set_build_id(dso, &bev->build_id);
+
+                if (filename[0] == '[')
+                        dso->kernel = dso_type;
+
+                build_id__sprintf(dso->build_id, sizeof(dso->build_id),
+                                  sbuild_id);
+                pr_debug("build id event received for %s: %s\n",
+                         dso->long_name, sbuild_id);
+        }
+
+        err = 0;
+out:
+        return err;
+}
+
+static int perf_header__read_build_ids(struct perf_header *self,
+                        int input, u64 offset, u64 size)
+{
+        struct perf_session *session = container_of(self,
+                        struct perf_session, header);
+        struct build_id_event bev;
+        char filename[PATH_MAX];
+        u64 limit = offset + size;
+        int err = -1;
+
+        while (offset < limit) {
+                ssize_t len;
+
+                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
+                        goto out;
+
+                if (self->needs_swap)
+                        perf_event_header__bswap(&bev.header);
+
+                len = bev.header.size - sizeof(bev);
+                if (read(input, filename, len) != len)
+                        goto out;
+
+                __event_process_build_id(&bev, filename, session);
+
+                offset += bev.header.size;
+        }
+        err = 0;
+out:
+        return err;
+}
+
 static int perf_file_section__process(struct perf_file_section *self,
                                       struct perf_header *ph,
                                       int feat, int fd)
@@ -648,7 +774,7 @@ static int perf_file_section__process(struct perf_file_section *self,
 
         switch (feat) {
         case HEADER_TRACE_INFO:
-                trace_report(fd);
+                trace_report(fd, false);
                 break;
 
         case HEADER_BUILD_ID:
@@ -662,13 +788,56 @@ static int perf_file_section__process(struct perf_file_section *self,
         return 0;
 }
 
-int perf_header__read(struct perf_header *self, int fd)
+static int perf_file_header__read_pipe(struct perf_pipe_file_header *self,
+                                       struct perf_header *ph, int fd,
+                                       bool repipe)
+{
+        if (do_read(fd, self, sizeof(*self)) <= 0 ||
+            memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
+                return -1;
+
+        if (repipe && do_write(STDOUT_FILENO, self, sizeof(*self)) < 0)
+                return -1;
+
+        if (self->size != sizeof(*self)) {
+                u64 size = bswap_64(self->size);
+
+                if (size != sizeof(*self))
+                        return -1;
+
+                ph->needs_swap = true;
+        }
+
+        return 0;
+}
+
+static int perf_header__read_pipe(struct perf_session *session, int fd)
 {
+        struct perf_header *self = &session->header;
+        struct perf_pipe_file_header f_header;
+
+        if (perf_file_header__read_pipe(&f_header, self, fd,
+                                        session->repipe) < 0) {
+                pr_debug("incompatible file format\n");
+                return -EINVAL;
+        }
+
+        session->fd = fd;
+
+        return 0;
+}
+
+int perf_header__read(struct perf_session *session, int fd)
+{
+        struct perf_header *self = &session->header;
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         u64                     f_id;
         int nr_attrs, nr_ids, i, j;
 
+        if (session->fd_pipe)
+                return perf_header__read_pipe(session, fd);
+
         if (perf_file_header__read(&f_header, self, fd) < 0) {
                 pr_debug("incompatible file format\n");
                 return -EINVAL;
@@ -753,6 +922,14 @@ perf_header__find_attr(u64 id, struct perf_header *header)
 {
         int i;
 
+        /*
+         * We set id to -1 if the data file doesn't contain sample
+         * ids. Check for this and avoid walking through the entire
+         * list of ids which may be large.
+         */
+        if (id == -1ULL)
+                return NULL;
+
         for (i = 0; i < header->attrs; i++) {
                 struct perf_header_attr *attr = header->attr[i];
                 int j;
@@ -765,3 +942,231 @@ perf_header__find_attr(u64 id, struct perf_header *header)
 
         return NULL;
 }
+
+int event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
+                           event__handler_t process,
+                           struct perf_session *session)
+{
+        event_t *ev;
+        size_t size;
+        int err;
+
+        size = sizeof(struct perf_event_attr);
+        size = ALIGN(size, sizeof(u64));
+        size += sizeof(struct perf_event_header);
+        size += ids * sizeof(u64);
+
+        ev = malloc(size);
+
+        ev->attr.attr = *attr;
+        memcpy(ev->attr.id, id, ids * sizeof(u64));
+
+        ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
+        ev->attr.header.size = size;
+
+        err = process(ev, session);
+
+        free(ev);
+
+        return err;
+}
+
+int event__synthesize_attrs(struct perf_header *self,
+                            event__handler_t process,
+                            struct perf_session *session)
+{
+        struct perf_header_attr *attr;
+        int i, err = 0;
+
+        for (i = 0; i < self->attrs; i++) {
+                attr = self->attr[i];
+
+                err = event__synthesize_attr(&attr->attr, attr->ids, attr->id,
+                                             process, session);
+                if (err) {
+                        pr_debug("failed to create perf header attribute\n");
+                        return err;
+                }
+        }
+
+        return err;
+}
+
+int event__process_attr(event_t *self, struct perf_session *session)
+{
+        struct perf_header_attr *attr;
+        unsigned int i, ids, n_ids;
+
+        attr = perf_header_attr__new(&self->attr.attr);
+        if (attr == NULL)
+                return -ENOMEM;
+
+        ids = self->header.size;
+        ids -= (void *)&self->attr.id - (void *)self;
+        n_ids = ids / sizeof(u64);
+
+        for (i = 0; i < n_ids; i++) {
+                if (perf_header_attr__add_id(attr, self->attr.id[i]) < 0) {
+                        perf_header_attr__delete(attr);
+                        return -ENOMEM;
+                }
+        }
+
+        if (perf_header__add_attr(&session->header, attr) < 0) {
+                perf_header_attr__delete(attr);
+                return -ENOMEM;
+        }
+
+        perf_session__update_sample_type(session);
+
+        return 0;
+}
+
+int event__synthesize_event_type(u64 event_id, char *name,
+                                 event__handler_t process,
+                                 struct perf_session *session)
+{
+        event_t ev;
+        size_t size = 0;
+        int err = 0;
+
+        memset(&ev, 0, sizeof(ev));
+
+        ev.event_type.event_type.event_id = event_id;
+        memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
+        strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
+
+        ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
+        size = strlen(name);
+        size = ALIGN(size, sizeof(u64));
+        ev.event_type.header.size = sizeof(ev.event_type) -
+                (sizeof(ev.event_type.event_type.name) - size);
+
+        err = process(&ev, session);
+
+        return err;
+}
+
+int event__synthesize_event_types(event__handler_t process,
+                                  struct perf_session *session)
+{
+        struct perf_trace_event_type *type;
+        int i, err = 0;
+
+        for (i = 0; i < event_count; i++) {
+                type = &events[i];
+
+                err = event__synthesize_event_type(type->event_id, type->name,
+                                                   process, session);
+                if (err) {
+                        pr_debug("failed to create perf header event type\n");
+                        return err;
+                }
+        }
+
+        return err;
+}
+
+int event__process_event_type(event_t *self,
+                              struct perf_session *session __unused)
+{
+        if (perf_header__push_event(self->event_type.event_type.event_id,
+                                    self->event_type.event_type.name) < 0)
+                return -ENOMEM;
+
+        return 0;
+}
+
+int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
+                                   int nb_events,
+                                   event__handler_t process,
+                                   struct perf_session *session __unused)
+{
+        event_t ev;
+        ssize_t size = 0, aligned_size = 0, padding;
+        int err = 0;
+
+        memset(&ev, 0, sizeof(ev));
+
+        ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
+        size = read_tracing_data_size(fd, pattrs, nb_events);
+        if (size <= 0)
+                return size;
+        aligned_size = ALIGN(size, sizeof(u64));
+        padding = aligned_size - size;
+        ev.tracing_data.header.size = sizeof(ev.tracing_data);
+        ev.tracing_data.size = aligned_size;
+
+        process(&ev, session);
+
+        err = read_tracing_data(fd, pattrs, nb_events);
+        write_padded(fd, NULL, 0, padding);
+
+        return aligned_size;
+}
+
+int event__process_tracing_data(event_t *self,
+                                struct perf_session *session)
+{
+        ssize_t size_read, padding, size = self->tracing_data.size;
+        off_t offset = lseek(session->fd, 0, SEEK_CUR);
+        char buf[BUFSIZ];
+
+        /* setup for reading amidst mmap */
+        lseek(session->fd, offset + sizeof(struct tracing_data_event),
+              SEEK_SET);
+
+        size_read = trace_report(session->fd, session->repipe);
+
+        padding = ALIGN(size_read, sizeof(u64)) - size_read;
+
+        if (read(session->fd, buf, padding) < 0)
+                die("reading input file");
+        if (session->repipe) {
+                int retw = write(STDOUT_FILENO, buf, padding);
+                if (retw <= 0 || retw != padding)
+                        die("repiping tracing data padding");
+        }
+
+        if (size_read + padding != size)
+                die("tracing data size mismatch");
+
+        return size_read + padding;
+}
+
+int event__synthesize_build_id(struct dso *pos, u16 misc,
+                               event__handler_t process,
+                               struct machine *machine,
+                               struct perf_session *session)
+{
+        event_t ev;
+        size_t len;
+        int err = 0;
+
+        if (!pos->hit)
+                return err;
+
+        memset(&ev, 0, sizeof(ev));
+
+        len = pos->long_name_len + 1;
+        len = ALIGN(len, NAME_ALIGN);
+        memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
+        ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
+        ev.build_id.header.misc = misc;
+        ev.build_id.pid = machine->pid;
+        ev.build_id.header.size = sizeof(ev.build_id) + len;
+        memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
+
+        err = process(&ev, session);
+
+        return err;
+}
+
+int event__process_build_id(event_t *self,
+                            struct perf_session *session)
+{
+        __event_process_build_id(&self->build_id,
+                                 self->build_id.filename,
+                                 session);
+        return 0;
+}
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 82a6af72d4c..402ac2454cf 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -39,6 +39,11 @@ struct perf_file_header {
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
 };
 
+struct perf_pipe_file_header {
+        u64                             magic;
+        u64                             size;
+};
+
 struct perf_header;
 
 int perf_file_header__read(struct perf_file_header *self,
@@ -47,21 +52,22 @@ int perf_file_header__read(struct perf_file_header *self,
 struct perf_header {
         int                     frozen;
         int                     attrs, size;
+        bool                    needs_swap;
         struct perf_header_attr **attr;
         s64                     attr_offset;
         u64                     data_offset;
         u64                     data_size;
         u64                     event_offset;
         u64                     event_size;
-        bool                    needs_swap;
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
 };
 
 int perf_header__init(struct perf_header *self);
 void perf_header__exit(struct perf_header *self);
 
-int perf_header__read(struct perf_header *self, int fd);
+int perf_header__read(struct perf_session *session, int fd);
 int perf_header__write(struct perf_header *self, int fd, bool at_exit);
+int perf_header__write_pipe(int fd);
 
 int perf_header__add_attr(struct perf_header *self,
                           struct perf_header_attr *attr);
@@ -89,4 +95,33 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                           const char *name, bool is_kallsyms);
 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
 
+int event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
+                           event__handler_t process,
+                           struct perf_session *session);
+int event__synthesize_attrs(struct perf_header *self,
+                            event__handler_t process,
+                            struct perf_session *session);
+int event__process_attr(event_t *self, struct perf_session *session);
+
+int event__synthesize_event_type(u64 event_id, char *name,
+                                 event__handler_t process,
+                                 struct perf_session *session);
+int event__synthesize_event_types(event__handler_t process,
+                                  struct perf_session *session);
+int event__process_event_type(event_t *self,
+                              struct perf_session *session);
+
+int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
+                                   int nb_events,
+                                   event__handler_t process,
+                                   struct perf_session *session);
+int event__process_tracing_data(event_t *self,
+                                struct perf_session *session);
+
+int event__synthesize_build_id(struct dso *pos, u16 misc,
+                               event__handler_t process,
+                               struct machine *machine,
+                               struct perf_session *session);
+int event__process_build_id(event_t *self, struct perf_session *session);
+
 #endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 2be33c7dbf0..9a71c94f057 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -1,3 +1,4 @@
+#include "util.h"
 #include "hist.h"
 #include "session.h"
 #include "sort.h"
@@ -8,25 +9,69 @@ struct callchain_param	callchain_param = {
         .min_percent = 0.5
 };
 
+static void hist_entry__add_cpumode_period(struct hist_entry *self,
+                                           unsigned int cpumode, u64 period)
+{
+        switch (cpumode) {
+        case PERF_RECORD_MISC_KERNEL:
+                self->period_sys += period;
+                break;
+        case PERF_RECORD_MISC_USER:
+                self->period_us += period;
+                break;
+        case PERF_RECORD_MISC_GUEST_KERNEL:
+                self->period_guest_sys += period;
+                break;
+        case PERF_RECORD_MISC_GUEST_USER:
+                self->period_guest_us += period;
+                break;
+        default:
+                break;
+        }
+}
+
 /*
- * histogram, sorted on item, collects counts
+ * histogram, sorted on item, collects periods
  */
 
-struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
-                                                  struct addr_location *al,
-                                                  struct symbol *sym_parent,
-                                                  u64 count, bool *hit)
+static struct hist_entry *hist_entry__new(struct hist_entry *template)
+{
+        size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_node) : 0;
+        struct hist_entry *self = malloc(sizeof(*self) + callchain_size);
+
+        if (self != NULL) {
+                *self = *template;
+                self->nr_events = 1;
+                if (symbol_conf.use_callchain)
+                        callchain_init(self->callchain);
+        }
+
+        return self;
+}
+
+static void hists__inc_nr_entries(struct hists *self, struct hist_entry *entry)
 {
-        struct rb_node **p = &hists->rb_node;
+        if (entry->ms.sym && self->max_sym_namelen < entry->ms.sym->namelen)
+                self->max_sym_namelen = entry->ms.sym->namelen;
+        ++self->nr_entries;
+}
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+                                      struct addr_location *al,
+                                      struct symbol *sym_parent, u64 period)
+{
+        struct rb_node **p = &self->entries.rb_node;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
         struct hist_entry entry = {
                 .thread = al->thread,
-                .map    = al->map,
-                .sym    = al->sym,
+                .ms = {
+                        .map    = al->map,
+                        .sym    = al->sym,
+                },
                 .ip     = al->addr,
                 .level  = al->level,
-                .count  = count,
+                .period = period,
                 .parent = sym_parent,
         };
         int cmp;
@@ -38,8 +83,9 @@ struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
                 cmp = hist_entry__cmp(&entry, he);
 
                 if (!cmp) {
-                        *hit = true;
-                        return he;
+                        he->period += period;
+                        ++he->nr_events;
+                        goto out;
                 }
 
                 if (cmp < 0)
@@ -48,13 +94,14 @@ struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
                         p = &(*p)->rb_right;
         }
 
-        he = malloc(sizeof(*he));
+        he = hist_entry__new(&entry);
         if (!he)
                 return NULL;
-        *he = entry;
         rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, hists);
-        *hit = false;
+        rb_insert_color(&he->rb_node, &self->entries);
+        hists__inc_nr_entries(self, he);
+out:
+        hist_entry__add_cpumode_period(he, al->cpumode, period);
         return he;
 }
 
@@ -65,7 +112,7 @@ hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
         int64_t cmp = 0;
 
         list_for_each_entry(se, &hist_entry__sort_list, list) {
-                cmp = se->cmp(left, right);
+                cmp = se->se_cmp(left, right);
                 if (cmp)
                         break;
         }
@@ -82,7 +129,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
         list_for_each_entry(se, &hist_entry__sort_list, list) {
                 int64_t (*f)(struct hist_entry *, struct hist_entry *);
 
-                f = se->collapse ?: se->cmp;
+                f = se->se_collapse ?: se->se_cmp;
 
                 cmp = f(left, right);
                 if (cmp)
@@ -101,7 +148,7 @@ void hist_entry__free(struct hist_entry *he)
  * collapse the histogram
  */
 
-static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
+static bool collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
 {
         struct rb_node **p = &root->rb_node;
         struct rb_node *parent = NULL;
@@ -115,9 +162,9 @@ static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
                 cmp = hist_entry__collapse(iter, he);
 
                 if (!cmp) {
-                        iter->count += he->count;
+                        iter->period += he->period;
                         hist_entry__free(he);
-                        return;
+                        return false;
                 }
 
                 if (cmp < 0)
@@ -128,9 +175,10 @@ static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
 
         rb_link_node(&he->rb_node, parent, p);
         rb_insert_color(&he->rb_node, root);
+        return true;
 }
 
-void perf_session__collapse_resort(struct rb_root *hists)
+void hists__collapse_resort(struct hists *self)
 {
         struct rb_root tmp;
         struct rb_node *next;
@@ -140,72 +188,77 @@ void perf_session__collapse_resort(struct rb_root *hists)
                 return;
 
         tmp = RB_ROOT;
-        next = rb_first(hists);
+        next = rb_first(&self->entries);
+        self->nr_entries = 0;
+        self->max_sym_namelen = 0;
 
         while (next) {
                 n = rb_entry(next, struct hist_entry, rb_node);
                 next = rb_next(&n->rb_node);
 
-                rb_erase(&n->rb_node, hists);
-                collapse__insert_entry(&tmp, n);
+                rb_erase(&n->rb_node, &self->entries);
+                if (collapse__insert_entry(&tmp, n))
+                        hists__inc_nr_entries(self, n);
         }
 
-        *hists = tmp;
+        self->entries = tmp;
 }
 
 /*
- * reverse the map, sort on count.
+ * reverse the map, sort on period.
  */
 
-static void perf_session__insert_output_hist_entry(struct rb_root *root,
-                                                   struct hist_entry *he,
-                                                   u64 min_callchain_hits)
+static void __hists__insert_output_entry(struct rb_root *entries,
+                                         struct hist_entry *he,
+                                         u64 min_callchain_hits)
 {
-        struct rb_node **p = &root->rb_node;
+        struct rb_node **p = &entries->rb_node;
         struct rb_node *parent = NULL;
         struct hist_entry *iter;
 
         if (symbol_conf.use_callchain)
-                callchain_param.sort(&he->sorted_chain, &he->callchain,
+                callchain_param.sort(&he->sorted_chain, he->callchain,
                                       min_callchain_hits, &callchain_param);
 
         while (*p != NULL) {
                 parent = *p;
                 iter = rb_entry(parent, struct hist_entry, rb_node);
 
-                if (he->count > iter->count)
+                if (he->period > iter->period)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
         }
 
         rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, root);
+        rb_insert_color(&he->rb_node, entries);
 }
 
-void perf_session__output_resort(struct rb_root *hists, u64 total_samples)
+void hists__output_resort(struct hists *self)
 {
         struct rb_root tmp;
         struct rb_node *next;
         struct hist_entry *n;
         u64 min_callchain_hits;
 
-        min_callchain_hits =
-                total_samples * (callchain_param.min_percent / 100);
+        min_callchain_hits = self->stats.total_period * (callchain_param.min_percent / 100);
 
         tmp = RB_ROOT;
-        next = rb_first(hists);
+        next = rb_first(&self->entries);
+
+        self->nr_entries = 0;
+        self->max_sym_namelen = 0;
 
         while (next) {
                 n = rb_entry(next, struct hist_entry, rb_node);
                 next = rb_next(&n->rb_node);
 
-                rb_erase(&n->rb_node, hists);
-                perf_session__insert_output_hist_entry(&tmp, n,
-                                                       min_callchain_hits);
+                rb_erase(&n->rb_node, &self->entries);
+                __hists__insert_output_entry(&tmp, n, min_callchain_hits);
+                hists__inc_nr_entries(self, n);
         }
 
-        *hists = tmp;
+        self->entries = tmp;
 }
 
 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
@@ -237,7 +290,7 @@ static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
 }
 
 static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
-                                     int depth, int depth_mask, int count,
+                                     int depth, int depth_mask, int period,
                                      u64 total_samples, int hits,
                                      int left_margin)
 {
@@ -250,7 +303,7 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
                         ret += fprintf(fp, "|");
                 else
                         ret += fprintf(fp, " ");
-                if (!count && i == depth - 1) {
+                if (!period && i == depth - 1) {
                         double percent;
 
                         percent = hits * 100.0 / total_samples;
@@ -258,8 +311,8 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
                 } else
                         ret += fprintf(fp, "%s", "          ");
         }
-        if (chain->sym)
-                ret += fprintf(fp, "%s\n", chain->sym->name);
+        if (chain->ms.sym)
+                ret += fprintf(fp, "%s\n", chain->ms.sym->name);
         else
                 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
 
@@ -278,7 +331,7 @@ static void init_rem_hits(void)
         }
 
         strcpy(rem_sq_bracket->name, "[...]");
-        rem_hits.sym = rem_sq_bracket;
+        rem_hits.ms.sym = rem_sq_bracket;
 }
 
 static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
@@ -293,6 +346,7 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
         u64 remaining;
         size_t ret = 0;
         int i;
+        uint entries_printed = 0;
 
         if (callchain_param.mode == CHAIN_GRAPH_REL)
                 new_total = self->children_hit;
@@ -328,8 +382,6 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                                                    left_margin);
                 i = 0;
                 list_for_each_entry(chain, &child->val, list) {
-                        if (chain->ip >= PERF_CONTEXT_MAX)
-                                continue;
                         ret += ipchain__fprintf_graph(fp, chain, depth,
                                                       new_depth_mask, i++,
                                                       new_total,
@@ -341,6 +393,8 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                                                   new_depth_mask | (1 << depth),
                                                   left_margin);
                 node = next;
+                if (++entries_printed == callchain_param.print_limit)
+                        break;
         }
 
         if (callchain_param.mode == CHAIN_GRAPH_REL &&
@@ -366,11 +420,9 @@ static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
         bool printed = false;
         int i = 0;
         int ret = 0;
+        u32 entries_printed = 0;
 
         list_for_each_entry(chain, &self->val, list) {
-                if (chain->ip >= PERF_CONTEXT_MAX)
-                        continue;
-
                 if (!i++ && sort__first_dimension == SORT_SYM)
                         continue;
 
@@ -385,10 +437,13 @@ static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                 } else
                         ret += callchain__fprintf_left_margin(fp, left_margin);
 
-                if (chain->sym)
-                        ret += fprintf(fp, " %s\n", chain->sym->name);
+                if (chain->ms.sym)
+                        ret += fprintf(fp, " %s\n", chain->ms.sym->name);
                 else
                         ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
+
+                if (++entries_printed == callchain_param.print_limit)
+                        break;
         }
 
         ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
@@ -411,8 +466,8 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
         list_for_each_entry(chain, &self->val, list) {
                 if (chain->ip >= PERF_CONTEXT_MAX)
                         continue;
-                if (chain->sym)
-                        ret += fprintf(fp, "                %s\n", chain->sym->name);
+                if (chain->ms.sym)
+                        ret += fprintf(fp, "                %s\n", chain->ms.sym->name);
                 else
                         ret += fprintf(fp, "                %p\n",
                                         (void *)(long)chain->ip);
@@ -427,6 +482,7 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
         struct rb_node *rb_node;
         struct callchain_node *chain;
         size_t ret = 0;
+        u32 entries_printed = 0;
 
         rb_node = rb_first(&self->sorted_chain);
         while (rb_node) {
@@ -449,55 +505,88 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
                         break;
                 }
                 ret += fprintf(fp, "\n");
+                if (++entries_printed == callchain_param.print_limit)
+                        break;
                 rb_node = rb_next(rb_node);
         }
 
         return ret;
 }
 
-static size_t hist_entry__fprintf(struct hist_entry *self,
-                                  struct perf_session *pair_session,
-                                  bool show_displacement,
-                                  long displacement, FILE *fp,
-                                  u64 session_total)
+int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
+                         struct hists *pair_hists, bool show_displacement,
+                         long displacement, bool color, u64 session_total)
 {
         struct sort_entry *se;
-        u64 count, total;
+        u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
         const char *sep = symbol_conf.field_sep;
-        size_t ret;
+        int ret;
 
         if (symbol_conf.exclude_other && !self->parent)
                 return 0;
 
-        if (pair_session) {
-                count = self->pair ? self->pair->count : 0;
-                total = pair_session->events_stats.total;
+        if (pair_hists) {
+                period = self->pair ? self->pair->period : 0;
+                total = pair_hists->stats.total_period;
+                period_sys = self->pair ? self->pair->period_sys : 0;
+                period_us = self->pair ? self->pair->period_us : 0;
+                period_guest_sys = self->pair ? self->pair->period_guest_sys : 0;
+                period_guest_us = self->pair ? self->pair->period_guest_us : 0;
         } else {
-                count = self->count;
+                period = self->period;
                 total = session_total;
+                period_sys = self->period_sys;
+                period_us = self->period_us;
+                period_guest_sys = self->period_guest_sys;
+                period_guest_us = self->period_guest_us;
         }
 
-        if (total)
-                ret = percent_color_fprintf(fp, sep ? "%.2f" : "   %6.2f%%",
-                                            (count * 100.0) / total);
-        else
-                ret = fprintf(fp, sep ? "%lld" : "%12lld ", count);
+        if (total) {
+                if (color)
+                        ret = percent_color_snprintf(s, size,
+                                                     sep ? "%.2f" : "   %6.2f%%",
+                                                     (period * 100.0) / total);
+                else
+                        ret = snprintf(s, size, sep ? "%.2f" : "   %6.2f%%",
+                                       (period * 100.0) / total);
+                if (symbol_conf.show_cpu_utilization) {
+                        ret += percent_color_snprintf(s + ret, size - ret,
+                                        sep ? "%.2f" : "   %6.2f%%",
+                                        (period_sys * 100.0) / total);
+                        ret += percent_color_snprintf(s + ret, size - ret,
+                                        sep ? "%.2f" : "   %6.2f%%",
+                                        (period_us * 100.0) / total);
+                        if (perf_guest) {
+                                ret += percent_color_snprintf(s + ret,
+                                                size - ret,
+                                                sep ? "%.2f" : "   %6.2f%%",
+                                                (period_guest_sys * 100.0) /
+                                                                total);
+                                ret += percent_color_snprintf(s + ret,
+                                                size - ret,
+                                                sep ? "%.2f" : "   %6.2f%%",
+                                                (period_guest_us * 100.0) /
+                                                                total);
+                        }
+                }
+        } else
+                ret = snprintf(s, size, sep ? "%lld" : "%12lld ", period);
 
         if (symbol_conf.show_nr_samples) {
                 if (sep)
-                        fprintf(fp, "%c%lld", *sep, count);
+                        ret += snprintf(s + ret, size - ret, "%c%lld", *sep, period);
                 else
-                        fprintf(fp, "%11lld", count);
+                        ret += snprintf(s + ret, size - ret, "%11lld", period);
         }
 
-        if (pair_session) {
+        if (pair_hists) {
                 char bf[32];
                 double old_percent = 0, new_percent = 0, diff;
 
                 if (total > 0)
-                        old_percent = (count * 100.0) / total;
+                        old_percent = (period * 100.0) / total;
                 if (session_total > 0)
-                        new_percent = (self->count * 100.0) / session_total;
+                        new_percent = (self->period * 100.0) / session_total;
 
                 diff = new_percent - old_percent;
 
@@ -507,9 +596,9 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
                         snprintf(bf, sizeof(bf), " ");
 
                 if (sep)
-                        ret += fprintf(fp, "%c%s", *sep, bf);
+                        ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
                 else
-                        ret += fprintf(fp, "%11.11s", bf);
+                        ret += snprintf(s + ret, size - ret, "%11.11s", bf);
 
                 if (show_displacement) {
                         if (displacement)
@@ -518,9 +607,9 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
                                 snprintf(bf, sizeof(bf), " ");
 
                         if (sep)
-                                fprintf(fp, "%c%s", *sep, bf);
+                                ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
                         else
-                                fprintf(fp, "%6.6s", bf);
+                                ret += snprintf(s + ret, size - ret, "%6.6s", bf);
                 }
         }
 
@@ -528,33 +617,43 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
                 if (se->elide)
                         continue;
 
-                fprintf(fp, "%s", sep ?: "  ");
-                ret += se->print(fp, self, se->width ? *se->width : 0);
+                ret += snprintf(s + ret, size - ret, "%s", sep ?: "  ");
+                ret += se->se_snprintf(self, s + ret, size - ret,
+                                       se->se_width ? *se->se_width : 0);
         }
 
-        ret += fprintf(fp, "\n");
+        return ret;
+}
 
-        if (symbol_conf.use_callchain) {
-                int left_margin = 0;
+int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
+                        bool show_displacement, long displacement, FILE *fp,
+                        u64 session_total)
+{
+        char bf[512];
+        hist_entry__snprintf(self, bf, sizeof(bf), pair_hists,
+                             show_displacement, displacement,
+                             true, session_total);
+        return fprintf(fp, "%s\n", bf);
+}
 
-                if (sort__first_dimension == SORT_COMM) {
-                        se = list_first_entry(&hist_entry__sort_list, typeof(*se),
-                                                list);
-                        left_margin = se->width ? *se->width : 0;
-                        left_margin -= thread__comm_len(self->thread);
-                }
+static size_t hist_entry__fprintf_callchain(struct hist_entry *self, FILE *fp,
+                                            u64 session_total)
+{
+        int left_margin = 0;
 
-                hist_entry_callchain__fprintf(fp, self, session_total,
-                                              left_margin);
+        if (sort__first_dimension == SORT_COMM) {
+                struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
+                                                         typeof(*se), list);
+                left_margin = se->se_width ? *se->se_width : 0;
+                left_margin -= thread__comm_len(self->thread);
         }
 
-        return ret;
+        return hist_entry_callchain__fprintf(fp, self, session_total,
+                                             left_margin);
 }
 
-size_t perf_session__fprintf_hists(struct rb_root *hists,
-                                   struct perf_session *pair,
-                                   bool show_displacement, FILE *fp,
-                                   u64 session_total)
+size_t hists__fprintf(struct hists *self, struct hists *pair,
+                      bool show_displacement, FILE *fp)
 {
         struct sort_entry *se;
         struct rb_node *nd;
@@ -563,7 +662,7 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
         long displacement = 0;
         unsigned int width;
         const char *sep = symbol_conf.field_sep;
-        char *col_width = symbol_conf.col_width_list_str;
+        const char *col_width = symbol_conf.col_width_list_str;
 
         init_rem_hits();
 
@@ -576,6 +675,24 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
                         fputs("  Samples  ", fp);
         }
 
+        if (symbol_conf.show_cpu_utilization) {
+                if (sep) {
+                        ret += fprintf(fp, "%csys", *sep);
+                        ret += fprintf(fp, "%cus", *sep);
+                        if (perf_guest) {
+                                ret += fprintf(fp, "%cguest sys", *sep);
+                                ret += fprintf(fp, "%cguest us", *sep);
+                        }
+                } else {
+                        ret += fprintf(fp, "  sys  ");
+                        ret += fprintf(fp, "  us  ");
+                        if (perf_guest) {
+                                ret += fprintf(fp, "  guest sys  ");
+                                ret += fprintf(fp, "  guest us  ");
+                        }
+                }
+        }
+
         if (pair) {
                 if (sep)
                         ret += fprintf(fp, "%cDelta", *sep);
@@ -594,22 +711,22 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
                 if (se->elide)
                         continue;
                 if (sep) {
-                        fprintf(fp, "%c%s", *sep, se->header);
+                        fprintf(fp, "%c%s", *sep, se->se_header);
                         continue;
                 }
-                width = strlen(se->header);
-                if (se->width) {
+                width = strlen(se->se_header);
+                if (se->se_width) {
                         if (symbol_conf.col_width_list_str) {
                                 if (col_width) {
-                                        *se->width = atoi(col_width);
+                                        *se->se_width = atoi(col_width);
                                         col_width = strchr(col_width, ',');
                                         if (col_width)
                                                 ++col_width;
                                 }
                         }
-                        width = *se->width = max(*se->width, width);
+                        width = *se->se_width = max(*se->se_width, width);
                 }
-                fprintf(fp, "  %*s", width, se->header);
+                fprintf(fp, "  %*s", width, se->se_header);
         }
         fprintf(fp, "\n");
 
@@ -631,10 +748,10 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
                         continue;
 
                 fprintf(fp, "  ");
-                if (se->width)
-                        width = *se->width;
+                if (se->se_width)
+                        width = *se->se_width;
                 else
-                        width = strlen(se->header);
+                        width = strlen(se->se_header);
                 for (i = 0; i < width; i++)
                         fprintf(fp, ".");
         }
@@ -642,7 +759,7 @@ size_t perf_session__fprintf_hists(struct rb_root *hists,
         fprintf(fp, "\n#\n");
 
 print_entries:
-        for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 if (show_displacement) {
@@ -654,10 +771,14 @@ print_entries:
                         ++position;
                 }
                 ret += hist_entry__fprintf(h, pair, show_displacement,
-                                           displacement, fp, session_total);
-                if (h->map == NULL && verbose > 1) {
+                                           displacement, fp, self->stats.total_period);
+
+                if (symbol_conf.use_callchain)
+                        ret += hist_entry__fprintf_callchain(h, fp, self->stats.total_period);
+
+                if (h->ms.map == NULL && verbose > 1) {
                         __map_groups__fprintf_maps(&h->thread->mg,
-                                                   MAP__FUNCTION, fp);
+                                                   MAP__FUNCTION, verbose, fp);
                         fprintf(fp, "%.10s end\n", graph_dotted_line);
                 }
         }
@@ -666,3 +787,271 @@ print_entries:
 
         return ret;
 }
+
+enum hist_filter {
+        HIST_FILTER__DSO,
+        HIST_FILTER__THREAD,
+};
+
+void hists__filter_by_dso(struct hists *self, const struct dso *dso)
+{
+        struct rb_node *nd;
+
+        self->nr_entries = self->stats.total_period = 0;
+        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
+        self->max_sym_namelen = 0;
+
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (symbol_conf.exclude_other && !h->parent)
+                        continue;
+
+                if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
+                        h->filtered |= (1 << HIST_FILTER__DSO);
+                        continue;
+                }
+
+                h->filtered &= ~(1 << HIST_FILTER__DSO);
+                if (!h->filtered) {
+                        ++self->nr_entries;
+                        self->stats.total_period += h->period;
+                        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
+                        if (h->ms.sym &&
+                            self->max_sym_namelen < h->ms.sym->namelen)
+                                self->max_sym_namelen = h->ms.sym->namelen;
+                }
+        }
+}
+
+void hists__filter_by_thread(struct hists *self, const struct thread *thread)
+{
+        struct rb_node *nd;
+
+        self->nr_entries = self->stats.total_period = 0;
+        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
+        self->max_sym_namelen = 0;
+
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (thread != NULL && h->thread != thread) {
+                        h->filtered |= (1 << HIST_FILTER__THREAD);
+                        continue;
+                }
+                h->filtered &= ~(1 << HIST_FILTER__THREAD);
+                if (!h->filtered) {
+                        ++self->nr_entries;
+                        self->stats.total_period += h->period;
+                        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
+                        if (h->ms.sym &&
+                            self->max_sym_namelen < h->ms.sym->namelen)
+                                self->max_sym_namelen = h->ms.sym->namelen;
+                }
+        }
+}
+
+static int symbol__alloc_hist(struct symbol *self)
+{
+        struct sym_priv *priv = symbol__priv(self);
+        const int size = (sizeof(*priv->hist) +
+                          (self->end - self->start) * sizeof(u64));
+
+        priv->hist = zalloc(size);
+        return priv->hist == NULL ? -1 : 0;
+}
+
+int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip)
+{
+        unsigned int sym_size, offset;
+        struct symbol *sym = self->ms.sym;
+        struct sym_priv *priv;
+        struct sym_hist *h;
+
+        if (!sym || !self->ms.map)
+                return 0;
+
+        priv = symbol__priv(sym);
+        if (priv->hist == NULL && symbol__alloc_hist(sym) < 0)
+                return -ENOMEM;
+
+        sym_size = sym->end - sym->start;
+        offset = ip - sym->start;
+
+        pr_debug3("%s: ip=%#Lx\n", __func__, self->ms.map->unmap_ip(self->ms.map, ip));
+
+        if (offset >= sym_size)
+                return 0;
+
+        h = priv->hist;
+        h->sum++;
+        h->ip[offset]++;
+
+        pr_debug3("%#Lx %s: period++ [ip: %#Lx, %#Lx] => %Ld\n", self->ms.sym->start,
+                  self->ms.sym->name, ip, ip - self->ms.sym->start, h->ip[offset]);
+        return 0;
+}
+
+static struct objdump_line *objdump_line__new(s64 offset, char *line)
+{
+        struct objdump_line *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                self->offset = offset;
+                self->line = line;
+        }
+
+        return self;
+}
+
+void objdump_line__free(struct objdump_line *self)
+{
+        free(self->line);
+        free(self);
+}
+
+static void objdump__add_line(struct list_head *head, struct objdump_line *line)
+{
+        list_add_tail(&line->node, head);
+}
+
+struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
+                                               struct objdump_line *pos)
+{
+        list_for_each_entry_continue(pos, head, node)
+                if (pos->offset >= 0)
+                        return pos;
+
+        return NULL;
+}
+
+static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
+                                          struct list_head *head)
+{
+        struct symbol *sym = self->ms.sym;
+        struct objdump_line *objdump_line;
+        char *line = NULL, *tmp, *tmp2, *c;
+        size_t line_len;
+        s64 line_ip, offset = -1;
+
+        if (getline(&line, &line_len, file) < 0)
+                return -1;
+
+        if (!line)
+                return -1;
+
+        while (line_len != 0 && isspace(line[line_len - 1]))
+                line[--line_len] = '\0';
+
+        c = strchr(line, '\n');
+        if (c)
+                *c = 0;
+
+        line_ip = -1;
+
+        /*
+         * Strip leading spaces:
+         */
+        tmp = line;
+        while (*tmp) {
+                if (*tmp != ' ')
+                        break;
+                tmp++;
+        }
+
+        if (*tmp) {
+                /*
+                 * Parse hexa addresses followed by ':'
+                 */
+                line_ip = strtoull(tmp, &tmp2, 16);
+                if (*tmp2 != ':')
+                        line_ip = -1;
+        }
+
+        if (line_ip != -1) {
+                u64 start = map__rip_2objdump(self->ms.map, sym->start);
+                offset = line_ip - start;
+        }
+
+        objdump_line = objdump_line__new(offset, line);
+        if (objdump_line == NULL) {
+                free(line);
+                return -1;
+        }
+        objdump__add_line(head, objdump_line);
+
+        return 0;
+}
+
+int hist_entry__annotate(struct hist_entry *self, struct list_head *head)
+{
+        struct symbol *sym = self->ms.sym;
+        struct map *map = self->ms.map;
+        struct dso *dso = map->dso;
+        const char *filename = dso->long_name;
+        char command[PATH_MAX * 2];
+        FILE *file;
+        u64 len;
+
+        if (!filename)
+                return -1;
+
+        if (dso->origin == DSO__ORIG_KERNEL) {
+                if (dso->annotate_warned)
+                        return 0;
+                dso->annotate_warned = 1;
+                pr_err("Can't annotate %s: No vmlinux file was found in the "
+                       "path:\n", sym->name);
+                vmlinux_path__fprintf(stderr);
+                return -1;
+        }
+
+        pr_debug("%s: filename=%s, sym=%s, start=%#Lx, end=%#Lx\n", __func__,
+                 filename, sym->name, map->unmap_ip(map, sym->start),
+                 map->unmap_ip(map, sym->end));
+
+        len = sym->end - sym->start;
+
+        pr_debug("annotating [%p] %30s : [%p] %30s\n",
+                 dso, dso->long_name, sym, sym->name);
+
+        snprintf(command, sizeof(command),
+                 "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s|expand",
+                 map__rip_2objdump(map, sym->start),
+                 map__rip_2objdump(map, sym->end),
+                 filename, filename);
+
+        pr_debug("Executing: %s\n", command);
+
+        file = popen(command, "r");
+        if (!file)
+                return -1;
+
+        while (!feof(file))
+                if (hist_entry__parse_objdump_line(self, file, head) < 0)
+                        break;
+
+        pclose(file);
+        return 0;
+}
+
+void hists__inc_nr_events(struct hists *self, u32 type)
+{
+        ++self->stats.nr_events[0];
+        ++self->stats.nr_events[type];
+}
+
+size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
+{
+        int i;
+        size_t ret = 0;
+
+        for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
+                if (!event__name[i])
+                        continue;
+                ret += fprintf(fp, "%10s events: %10d\n",
+                               event__name[i], self->stats.nr_events[i]);
+        }
+
+        return ret;
+}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 16f360cce5b..6f17dcd8412 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -6,24 +6,104 @@
 
 extern struct callchain_param callchain_param;
 
-struct perf_session;
 struct hist_entry;
 struct addr_location;
 struct symbol;
 struct rb_root;
 
-struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
-                                                  struct addr_location *al,
-                                                  struct symbol *parent,
-                                                  u64 count, bool *hit);
+struct objdump_line {
+        struct list_head node;
+        s64              offset;
+        char             *line;
+};
+
+void objdump_line__free(struct objdump_line *self);
+struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
+                                               struct objdump_line *pos);
+
+struct sym_hist {
+        u64             sum;
+        u64             ip[0];
+};
+
+struct sym_ext {
+        struct rb_node  node;
+        double          percent;
+        char            *path;
+};
+
+struct sym_priv {
+        struct sym_hist *hist;
+        struct sym_ext  *ext;
+};
+
+/*
+ * The kernel collects the number of events it couldn't send in a stretch and
+ * when possible sends this number in a PERF_RECORD_LOST event. The number of
+ * such "chunks" of lost events is stored in .nr_events[PERF_EVENT_LOST] while
+ * total_lost tells exactly how many events the kernel in fact lost, i.e. it is
+ * the sum of all struct lost_event.lost fields reported.
+ *
+ * The total_period is needed because by default auto-freq is used, so
+ * multipling nr_events[PERF_EVENT_SAMPLE] by a frequency isn't possible to get
+ * the total number of low level events, it is necessary to to sum all struct
+ * sample_event.period and stash the result in total_period.
+ */
+struct events_stats {
+        u64 total_period;
+        u64 total_lost;
+        u32 nr_events[PERF_RECORD_HEADER_MAX];
+        u32 nr_unknown_events;
+};
+
+struct hists {
+        struct rb_node          rb_node;
+        struct rb_root          entries;
+        u64                     nr_entries;
+        struct events_stats     stats;
+        u64                     config;
+        u64                     event_stream;
+        u32                     type;
+        u32                     max_sym_namelen;
+};
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+                                      struct addr_location *al,
+                                      struct symbol *parent, u64 period);
 extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
+int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
+                        bool show_displacement, long displacement, FILE *fp,
+                        u64 total);
+int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
+                         struct hists *pair_hists, bool show_displacement,
+                         long displacement, bool color, u64 total);
 void hist_entry__free(struct hist_entry *);
 
-void perf_session__output_resort(struct rb_root *hists, u64 total_samples);
-void perf_session__collapse_resort(struct rb_root *hists);
-size_t perf_session__fprintf_hists(struct rb_root *hists,
-                                   struct perf_session *pair,
-                                   bool show_displacement, FILE *fp,
-                                   u64 session_total);
+void hists__output_resort(struct hists *self);
+void hists__collapse_resort(struct hists *self);
+
+void hists__inc_nr_events(struct hists *self, u32 type);
+size_t hists__fprintf_nr_events(struct hists *self, FILE *fp);
+
+size_t hists__fprintf(struct hists *self, struct hists *pair,
+                      bool show_displacement, FILE *fp);
+
+int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip);
+int hist_entry__annotate(struct hist_entry *self, struct list_head *head);
+
+void hists__filter_by_dso(struct hists *self, const struct dso *dso);
+void hists__filter_by_thread(struct hists *self, const struct thread *thread);
+
+#ifdef NO_NEWT_SUPPORT
+static inline int hists__browse(struct hists *self __used,
+                                const char *helpline __used,
+                                const char *input_name __used)
+{
+        return 0;
+}
+#else
+int hists__browse(struct hists *self, const char *helpline,
+                  const char *input_name);
+#endif
 #endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/hweight.c b/tools/perf/util/hweight.c
new file mode 100644
index 00000000000..5c1d0d099f0
--- /dev/null
+++ b/tools/perf/util/hweight.c
@@ -0,0 +1,31 @@
+#include <linux/bitops.h>
+
+/**
+ * hweightN - returns the hamming weight of a N-bit word
+ * @x: the word to weigh
+ *
+ * The Hamming Weight of a number is the total number of bits set in it.
+ */
+
+unsigned int hweight32(unsigned int w)
+{
+        unsigned int res = w - ((w >> 1) & 0x55555555);
+        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
+        res = (res + (res >> 4)) & 0x0F0F0F0F;
+        res = res + (res >> 8);
+        return (res + (res >> 16)) & 0x000000FF;
+}
+
+unsigned long hweight64(__u64 w)
+{
+#if BITS_PER_LONG == 32
+        return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
+#elif BITS_PER_LONG == 64
+        __u64 res = w - ((w >> 1) & 0x5555555555555555ul);
+        res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
+        res = (res + (res >> 4)) & 0x0F0F0F0F0F0F0F0Ful;
+        res = res + (res >> 8);
+        res = res + (res >> 16);
+        return (res + (res >> 32)) & 0x00000000000000FFul;
+#endif
+}
diff --git a/tools/perf/util/include/asm/bitops.h b/tools/perf/util/include/asm/bitops.h
deleted file mode 100644
index 58e9817ffae..00000000000
--- a/tools/perf/util/include/asm/bitops.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef _PERF_ASM_BITOPS_H_
-#define _PERF_ASM_BITOPS_H_
-
-#include <sys/types.h>
-#include "../../types.h"
-#include <linux/compiler.h>
-
-/* CHECKME: Not sure both always match */
-#define BITS_PER_LONG   __WORDSIZE
-
-#include "../../../../include/asm-generic/bitops/__fls.h"
-#include "../../../../include/asm-generic/bitops/fls.h"
-#include "../../../../include/asm-generic/bitops/fls64.h"
-#include "../../../../include/asm-generic/bitops/__ffs.h"
-#include "../../../../include/asm-generic/bitops/ffz.h"
-#include "../../../../include/asm-generic/bitops/hweight.h"
-
-#endif
diff --git a/tools/perf/util/include/asm/hweight.h b/tools/perf/util/include/asm/hweight.h
new file mode 100644
index 00000000000..36cf26d434a
--- /dev/null
+++ b/tools/perf/util/include/asm/hweight.h
@@ -0,0 +1,8 @@
+#ifndef PERF_HWEIGHT_H
+#define PERF_HWEIGHT_H
+
+#include <linux/types.h>
+unsigned int hweight32(unsigned int w);
+unsigned long hweight64(__u64 w);
+
+#endif /* PERF_HWEIGHT_H */
diff --git a/tools/perf/util/include/dwarf-regs.h b/tools/perf/util/include/dwarf-regs.h
new file mode 100644
index 00000000000..cf6727e99c4
--- /dev/null
+++ b/tools/perf/util/include/dwarf-regs.h
@@ -0,0 +1,8 @@
+#ifndef _PERF_DWARF_REGS_H_
+#define _PERF_DWARF_REGS_H_
+
+#ifdef DWARF_SUPPORT
+const char *get_arch_regstr(unsigned int n);
+#endif
+
+#endif
diff --git a/tools/perf/util/include/linux/bitmap.h b/tools/perf/util/include/linux/bitmap.h
index 94507639a8c..eda4416efa0 100644
--- a/tools/perf/util/include/linux/bitmap.h
+++ b/tools/perf/util/include/linux/bitmap.h
@@ -1,3 +1,35 @@
-#include "../../../../include/linux/bitmap.h"
-#include "../../../../include/asm-generic/bitops/find.h"
-#include <linux/errno.h>
+#ifndef _PERF_BITOPS_H
+#define _PERF_BITOPS_H
+
+#include <string.h>
+#include <linux/bitops.h>
+
+int __bitmap_weight(const unsigned long *bitmap, int bits);
+
+#define BITMAP_LAST_WORD_MASK(nbits)                                    \
+(                                                                       \
+        ((nbits) % BITS_PER_LONG) ?                                     \
+                (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL               \
+)
+
+#define small_const_nbits(nbits) \
+        (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
+
+static inline void bitmap_zero(unsigned long *dst, int nbits)
+{
+        if (small_const_nbits(nbits))
+                *dst = 0UL;
+        else {
+                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                memset(dst, 0, len);
+        }
+}
+
+static inline int bitmap_weight(const unsigned long *src, int nbits)
+{
+        if (small_const_nbits(nbits))
+                return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
+        return __bitmap_weight(src, nbits);
+}
+
+#endif /* _PERF_BITOPS_H */
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index 8d63116e943..bb4ac2e0538 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -1,13 +1,12 @@
 #ifndef _PERF_LINUX_BITOPS_H_
 #define _PERF_LINUX_BITOPS_H_
 
-#define __KERNEL__
+#include <linux/kernel.h>
+#include <asm/hweight.h>
 
-#define CONFIG_GENERIC_FIND_NEXT_BIT
-#define CONFIG_GENERIC_FIND_FIRST_BIT
-#include "../../../../include/linux/bitops.h"
-
-#undef __KERNEL__
+#define BITS_PER_LONG __WORDSIZE
+#define BITS_PER_BYTE           8
+#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 
 static inline void set_bit(int nr, unsigned long *addr)
 {
@@ -20,10 +19,9 @@ static __always_inline int test_bit(unsigned int nr, const unsigned long *addr)
                 (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0;
 }
 
-unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned
-                long size, unsigned long offset);
-
-unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned
-                long size, unsigned long offset);
+static inline unsigned long hweight_long(unsigned long w)
+{
+        return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
+}
 
 #endif
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
index dfb0713ed47..791f9dd27eb 100644
--- a/tools/perf/util/include/linux/compiler.h
+++ b/tools/perf/util/include/linux/compiler.h
@@ -7,4 +7,6 @@
 #define __user
 #define __attribute_const__
 
+#define __used          __attribute__((__unused__))
+
 #endif
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index f2611655ab5..1eb804fd3fb 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -28,6 +28,8 @@
         (type *)((char *)__mptr - offsetof(type, member)); })
 #endif
 
+#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
+
 #ifndef max
 #define max(x, y) ({                            \
         typeof(x) _max1 = (x);                  \
@@ -85,16 +87,19 @@ simple_strtoul(const char *nptr, char **endptr, int base)
         return strtoul(nptr, endptr, base);
 }
 
+int eprintf(int level,
+            const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
 #endif
 
 #define pr_err(fmt, ...) \
-        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_warning(fmt, ...) \
-        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_info(fmt, ...) \
-        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debug(fmt, ...) \
         eprintf(1, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debugN(n, fmt, ...) \
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index e509cd59c67..e672f2fef65 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -1,9 +1,11 @@
-#include "event.h"
 #include "symbol.h"
+#include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include "debug.h"
+#include <unistd.h>
+#include "map.h"
 
 const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__FUNCTION] = "Functions",
@@ -36,15 +38,16 @@ void map__init(struct map *self, enum map_type type,
         self->map_ip   = map__map_ip;
         self->unmap_ip = map__unmap_ip;
         RB_CLEAR_NODE(&self->rb_node);
+        self->groups   = NULL;
 }
 
-struct map *map__new(struct mmap_event *event, enum map_type type,
-                     char *cwd, int cwdlen)
+struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
+                     u64 pgoff, u32 pid, char *filename,
+                     enum map_type type, char *cwd, int cwdlen)
 {
         struct map *self = malloc(sizeof(*self));
 
         if (self != NULL) {
-                const char *filename = event->filename;
                 char newfilename[PATH_MAX];
                 struct dso *dso;
                 int anon;
@@ -62,16 +65,15 @@ struct map *map__new(struct mmap_event *event, enum map_type type,
                 anon = is_anon_memory(filename);
 
                 if (anon) {
-                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
+                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
                         filename = newfilename;
                 }
 
-                dso = dsos__findnew(filename);
+                dso = __dsos__findnew(dsos__list, filename);
                 if (dso == NULL)
                         goto out_delete;
 
-                map__init(self, type, event->start, event->start + event->len,
-                          event->pgoff, dso);
+                map__init(self, type, start, start + len, pgoff, dso);
 
                 if (anon) {
 set_identity:
@@ -235,3 +237,392 @@ u64 map__objdump_2ip(struct map *map, u64 addr)
                         map->unmap_ip(map, addr);       /* RIP -> IP */
         return ip;
 }
+
+void map_groups__init(struct map_groups *self)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                self->maps[i] = RB_ROOT;
+                INIT_LIST_HEAD(&self->removed_maps[i]);
+        }
+        self->machine = NULL;
+}
+
+void map_groups__flush(struct map_groups *self)
+{
+        int type;
+
+        for (type = 0; type < MAP__NR_TYPES; type++) {
+                struct rb_root *root = &self->maps[type];
+                struct rb_node *next = rb_first(root);
+
+                while (next) {
+                        struct map *pos = rb_entry(next, struct map, rb_node);
+                        next = rb_next(&pos->rb_node);
+                        rb_erase(&pos->rb_node, root);
+                        /*
+                         * We may have references to this map, for
+                         * instance in some hist_entry instances, so
+                         * just move them to a separate list.
+                         */
+                        list_add_tail(&pos->node, &self->removed_maps[pos->type]);
+                }
+        }
+}
+
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       struct map **mapp,
+                                       symbol_filter_t filter)
+{
+        struct map *map = map_groups__find(self, type, addr);
+
+        if (map != NULL) {
+                if (mapp != NULL)
+                        *mapp = map;
+                return map__find_symbol(map, map->map_ip(map, addr), filter);
+        }
+
+        return NULL;
+}
+
+struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
+                                               enum map_type type,
+                                               const char *name,
+                                               struct map **mapp,
+                                               symbol_filter_t filter)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+                struct symbol *sym = map__find_symbol_by_name(pos, name, filter);
+
+                if (sym == NULL)
+                        continue;
+                if (mapp != NULL)
+                        *mapp = pos;
+                return sym;
+        }
+
+        return NULL;
+}
+
+size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                  enum map_type type, int verbose, FILE *fp)
+{
+        size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+                printed += fprintf(fp, "Map:");
+                printed += map__fprintf(pos, fp);
+                if (verbose > 2) {
+                        printed += dso__fprintf(pos->dso, type, fp);
+                        printed += fprintf(fp, "--\n");
+                }
+        }
+
+        return printed;
+}
+
+size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __map_groups__fprintf_maps(self, i, verbose, fp);
+        return printed;
+}
+
+static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
+                                                 enum map_type type,
+                                                 int verbose, FILE *fp)
+{
+        struct map *pos;
+        size_t printed = 0;
+
+        list_for_each_entry(pos, &self->removed_maps[type], node) {
+                printed += fprintf(fp, "Map:");
+                printed += map__fprintf(pos, fp);
+                if (verbose > 1) {
+                        printed += dso__fprintf(pos->dso, type, fp);
+                        printed += fprintf(fp, "--\n");
+                }
+        }
+        return printed;
+}
+
+static size_t map_groups__fprintf_removed_maps(struct map_groups *self,
+                                               int verbose, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __map_groups__fprintf_removed_maps(self, i, verbose, fp);
+        return printed;
+}
+
+size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp)
+{
+        size_t printed = map_groups__fprintf_maps(self, verbose, fp);
+        printed += fprintf(fp, "Removed maps:\n");
+        return printed + map_groups__fprintf_removed_maps(self, verbose, fp);
+}
+
+int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
+                                   int verbose, FILE *fp)
+{
+        struct rb_root *root = &self->maps[map->type];
+        struct rb_node *next = rb_first(root);
+
+        while (next) {
+                struct map *pos = rb_entry(next, struct map, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                if (!map__overlap(pos, map))
+                        continue;
+
+                if (verbose >= 2) {
+                        fputs("overlapping maps:\n", fp);
+                        map__fprintf(map, fp);
+                        map__fprintf(pos, fp);
+                }
+
+                rb_erase(&pos->rb_node, root);
+                /*
+                 * We may have references to this map, for instance in some
+                 * hist_entry instances, so just move them to a separate
+                 * list.
+                 */
+                list_add_tail(&pos->node, &self->removed_maps[map->type]);
+                /*
+                 * Now check if we need to create new maps for areas not
+                 * overlapped by the new map:
+                 */
+                if (map->start > pos->start) {
+                        struct map *before = map__clone(pos);
+
+                        if (before == NULL)
+                                return -ENOMEM;
+
+                        before->end = map->start - 1;
+                        map_groups__insert(self, before);
+                        if (verbose >= 2)
+                                map__fprintf(before, fp);
+                }
+
+                if (map->end < pos->end) {
+                        struct map *after = map__clone(pos);
+
+                        if (after == NULL)
+                                return -ENOMEM;
+
+                        after->start = map->end + 1;
+                        map_groups__insert(self, after);
+                        if (verbose >= 2)
+                                map__fprintf(after, fp);
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * XXX This should not really _copy_ te maps, but refcount them.
+ */
+int map_groups__clone(struct map_groups *self,
+                      struct map_groups *parent, enum map_type type)
+{
+        struct rb_node *nd;
+        for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *map = rb_entry(nd, struct map, rb_node);
+                struct map *new = map__clone(map);
+                if (new == NULL)
+                        return -ENOMEM;
+                map_groups__insert(self, new);
+        }
+        return 0;
+}
+
+static u64 map__reloc_map_ip(struct map *map, u64 ip)
+{
+        return ip + (s64)map->pgoff;
+}
+
+static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
+{
+        return ip - (s64)map->pgoff;
+}
+
+void map__reloc_vmlinux(struct map *self)
+{
+        struct kmap *kmap = map__kmap(self);
+        s64 reloc;
+
+        if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
+                return;
+
+        reloc = (kmap->ref_reloc_sym->unrelocated_addr -
+                 kmap->ref_reloc_sym->addr);
+
+        if (!reloc)
+                return;
+
+        self->map_ip   = map__reloc_map_ip;
+        self->unmap_ip = map__reloc_unmap_ip;
+        self->pgoff    = reloc;
+}
+
+void maps__insert(struct rb_root *maps, struct map *map)
+{
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        const u64 ip = map->start;
+        struct map *m;
+
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct map, rb_node);
+                if (ip < m->start)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&map->rb_node, parent, p);
+        rb_insert_color(&map->rb_node, maps);
+}
+
+struct map *maps__find(struct rb_root *maps, u64 ip)
+{
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        struct map *m;
+
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct map, rb_node);
+                if (ip < m->start)
+                        p = &(*p)->rb_left;
+                else if (ip > m->end)
+                        p = &(*p)->rb_right;
+                else
+                        return m;
+        }
+
+        return NULL;
+}
+
+int machine__init(struct machine *self, const char *root_dir, pid_t pid)
+{
+        map_groups__init(&self->kmaps);
+        RB_CLEAR_NODE(&self->rb_node);
+        INIT_LIST_HEAD(&self->user_dsos);
+        INIT_LIST_HEAD(&self->kernel_dsos);
+
+        self->kmaps.machine = self;
+        self->pid           = pid;
+        self->root_dir      = strdup(root_dir);
+        return self->root_dir == NULL ? -ENOMEM : 0;
+}
+
+struct machine *machines__add(struct rb_root *self, pid_t pid,
+                              const char *root_dir)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct machine *pos, *machine = malloc(sizeof(*machine));
+
+        if (!machine)
+                return NULL;
+
+        if (machine__init(machine, root_dir, pid) != 0) {
+                free(machine);
+                return NULL;
+        }
+
+        while (*p != NULL) {
+                parent = *p;
+                pos = rb_entry(parent, struct machine, rb_node);
+                if (pid < pos->pid)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&machine->rb_node, parent, p);
+        rb_insert_color(&machine->rb_node, self);
+
+        return machine;
+}
+
+struct machine *machines__find(struct rb_root *self, pid_t pid)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct machine *machine;
+        struct machine *default_machine = NULL;
+
+        while (*p != NULL) {
+                parent = *p;
+                machine = rb_entry(parent, struct machine, rb_node);
+                if (pid < machine->pid)
+                        p = &(*p)->rb_left;
+                else if (pid > machine->pid)
+                        p = &(*p)->rb_right;
+                else
+                        return machine;
+                if (!machine->pid)
+                        default_machine = machine;
+        }
+
+        return default_machine;
+}
+
+struct machine *machines__findnew(struct rb_root *self, pid_t pid)
+{
+        char path[PATH_MAX];
+        const char *root_dir;
+        struct machine *machine = machines__find(self, pid);
+
+        if (!machine || machine->pid != pid) {
+                if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID)
+                        root_dir = "";
+                else {
+                        if (!symbol_conf.guestmount)
+                                goto out;
+                        sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
+                        if (access(path, R_OK)) {
+                                pr_err("Can't access file %s\n", path);
+                                goto out;
+                        }
+                        root_dir = path;
+                }
+                machine = machines__add(self, pid, root_dir);
+        }
+
+out:
+        return machine;
+}
+
+void machines__process(struct rb_root *self, machine__process_t process, void *data)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                process(pos, data);
+        }
+}
+
+char *machine__mmap_name(struct machine *self, char *bf, size_t size)
+{
+        if (machine__is_host(self))
+                snprintf(bf, size, "[%s]", "kernel.kallsyms");
+        else if (machine__is_default_guest(self))
+                snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
+        else
+                snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms", self->pid);
+
+        return bf;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index b756368076c..f3913451282 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -4,7 +4,9 @@
 #include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include <linux/types.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "types.h"
 
 enum map_type {
         MAP__FUNCTION = 0,
@@ -18,6 +20,7 @@ extern const char *map_type__name[MAP__NR_TYPES];
 struct dso;
 struct ref_reloc_sym;
 struct map_groups;
+struct machine;
 
 struct map {
         union {
@@ -27,6 +30,7 @@ struct map {
         u64                     start;
         u64                     end;
         enum map_type           type;
+        u32                     priv;
         u64                     pgoff;
 
         /* ip -> dso rip */
@@ -35,6 +39,7 @@ struct map {
         u64                     (*unmap_ip)(struct map *, u64);
 
         struct dso              *dso;
+        struct map_groups       *groups;
 };
 
 struct kmap {
@@ -42,6 +47,32 @@ struct kmap {
         struct map_groups       *kmaps;
 };
 
+struct map_groups {
+        struct rb_root   maps[MAP__NR_TYPES];
+        struct list_head removed_maps[MAP__NR_TYPES];
+        struct machine   *machine;
+};
+
+/* Native host kernel uses -1 as pid index in machine */
+#define HOST_KERNEL_ID                  (-1)
+#define DEFAULT_GUEST_KERNEL_ID         (0)
+
+struct machine {
+        struct rb_node    rb_node;
+        pid_t             pid;
+        char              *root_dir;
+        struct list_head  user_dsos;
+        struct list_head  kernel_dsos;
+        struct map_groups kmaps;
+        struct map        *vmlinux_maps[MAP__NR_TYPES];
+};
+
+static inline
+struct map *machine__kernel_map(struct machine *self, enum map_type type)
+{
+        return self->vmlinux_maps[type];
+}
+
 static inline struct kmap *map__kmap(struct map *self)
 {
         return (struct kmap *)(self + 1);
@@ -68,14 +99,14 @@ u64 map__rip_2objdump(struct map *map, u64 rip);
 u64 map__objdump_2ip(struct map *map, u64 addr);
 
 struct symbol;
-struct mmap_event;
 
 typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
 
 void map__init(struct map *self, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso);
-struct map *map__new(struct mmap_event *event, enum map_type,
-                     char *cwd, int cwdlen);
+struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
+                     u64 pgoff, u32 pid, char *filename,
+                     enum map_type type, char *cwd, int cwdlen);
 void map__delete(struct map *self);
 struct map *map__clone(struct map *self);
 int map__overlap(struct map *l, struct map *r);
@@ -91,4 +122,96 @@ void map__fixup_end(struct map *self);
 
 void map__reloc_vmlinux(struct map *self);
 
+size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                  enum map_type type, int verbose, FILE *fp);
+void maps__insert(struct rb_root *maps, struct map *map);
+struct map *maps__find(struct rb_root *maps, u64 addr);
+void map_groups__init(struct map_groups *self);
+int map_groups__clone(struct map_groups *self,
+                      struct map_groups *parent, enum map_type type);
+size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
+size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp);
+
+typedef void (*machine__process_t)(struct machine *self, void *data);
+
+void machines__process(struct rb_root *self, machine__process_t process, void *data);
+struct machine *machines__add(struct rb_root *self, pid_t pid,
+                              const char *root_dir);
+struct machine *machines__find_host(struct rb_root *self);
+struct machine *machines__find(struct rb_root *self, pid_t pid);
+struct machine *machines__findnew(struct rb_root *self, pid_t pid);
+char *machine__mmap_name(struct machine *self, char *bf, size_t size);
+int machine__init(struct machine *self, const char *root_dir, pid_t pid);
+
+/*
+ * Default guest kernel is defined by parameter --guestkallsyms
+ * and --guestmodules
+ */
+static inline bool machine__is_default_guest(struct machine *self)
+{
+        return self ? self->pid == DEFAULT_GUEST_KERNEL_ID : false;
+}
+
+static inline bool machine__is_host(struct machine *self)
+{
+        return self ? self->pid == HOST_KERNEL_ID : false;
+}
+
+static inline void map_groups__insert(struct map_groups *self, struct map *map)
+{
+        maps__insert(&self->maps[map->type], map);
+        map->groups = self;
+}
+
+static inline struct map *map_groups__find(struct map_groups *self,
+                                           enum map_type type, u64 addr)
+{
+        return maps__find(&self->maps[type], addr);
+}
+
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       struct map **mapp,
+                                       symbol_filter_t filter);
+
+struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
+                                               enum map_type type,
+                                               const char *name,
+                                               struct map **mapp,
+                                               symbol_filter_t filter);
+
+static inline
+struct symbol *machine__find_kernel_symbol(struct machine *self,
+                                           enum map_type type, u64 addr,
+                                           struct map **mapp,
+                                           symbol_filter_t filter)
+{
+        return map_groups__find_symbol(&self->kmaps, type, addr, mapp, filter);
+}
+
+static inline
+struct symbol *machine__find_kernel_function(struct machine *self, u64 addr,
+                                             struct map **mapp,
+                                             symbol_filter_t filter)
+{
+        return machine__find_kernel_symbol(self, MAP__FUNCTION, addr, mapp, filter);
+}
+
+static inline
+struct symbol *map_groups__find_function_by_name(struct map_groups *self,
+                                                 const char *name, struct map **mapp,
+                                                 symbol_filter_t filter)
+{
+        return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter);
+}
+
+int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
+                                   int verbose, FILE *fp);
+
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                     enum map_type type, const char *name);
+struct map *machine__new_module(struct machine *self, u64 start, const char *filename);
+
+void map_groups__flush(struct map_groups *self);
+
 #endif /* __PERF_MAP_H */
diff --git a/tools/perf/util/newt.c b/tools/perf/util/newt.c
new file mode 100644
index 00000000000..ccb7c5bb269
--- /dev/null
+++ b/tools/perf/util/newt.c
@@ -0,0 +1,1084 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#undef _GNU_SOURCE
+
+#include <slang.h>
+#include <stdlib.h>
+#include <newt.h>
+#include <sys/ttydefaults.h>
+
+#include "cache.h"
+#include "hist.h"
+#include "pstack.h"
+#include "session.h"
+#include "sort.h"
+#include "symbol.h"
+
+#if SLANG_VERSION < 20104
+#define slsmg_printf(msg, args...) SLsmg_printf((char *)msg, ##args)
+#define slsmg_write_nstring(msg, len) SLsmg_write_nstring((char *)msg, len)
+#define sltt_set_color(obj, name, fg, bg) SLtt_set_color(obj,(char *)name,\
+                                                         (char *)fg, (char *)bg)
+#else
+#define slsmg_printf SLsmg_printf
+#define slsmg_write_nstring SLsmg_write_nstring
+#define sltt_set_color SLtt_set_color
+#endif
+
+struct ui_progress {
+        newtComponent form, scale;
+};
+
+struct ui_progress *ui_progress__new(const char *title, u64 total)
+{
+        struct ui_progress *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                int cols;
+                newtGetScreenSize(&cols, NULL);
+                cols -= 4;
+                newtCenteredWindow(cols, 1, title);
+                self->form  = newtForm(NULL, NULL, 0);
+                if (self->form == NULL)
+                        goto out_free_self;
+                self->scale = newtScale(0, 0, cols, total);
+                if (self->scale == NULL)
+                        goto out_free_form;
+                newtFormAddComponent(self->form, self->scale);
+                newtRefresh();
+        }
+
+        return self;
+
+out_free_form:
+        newtFormDestroy(self->form);
+out_free_self:
+        free(self);
+        return NULL;
+}
+
+void ui_progress__update(struct ui_progress *self, u64 curr)
+{
+        newtScaleSet(self->scale, curr);
+        newtRefresh();
+}
+
+void ui_progress__delete(struct ui_progress *self)
+{
+        newtFormDestroy(self->form);
+        newtPopWindow();
+        free(self);
+}
+
+static void ui_helpline__pop(void)
+{
+        newtPopHelpLine();
+}
+
+static void ui_helpline__push(const char *msg)
+{
+        newtPushHelpLine(msg);
+}
+
+static void ui_helpline__vpush(const char *fmt, va_list ap)
+{
+        char *s;
+
+        if (vasprintf(&s, fmt, ap) < 0)
+                vfprintf(stderr, fmt, ap);
+        else {
+                ui_helpline__push(s);
+                free(s);
+        }
+}
+
+static void ui_helpline__fpush(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        ui_helpline__vpush(fmt, ap);
+        va_end(ap);
+}
+
+static void ui_helpline__puts(const char *msg)
+{
+        ui_helpline__pop();
+        ui_helpline__push(msg);
+}
+
+static char browser__last_msg[1024];
+
+int browser__show_help(const char *format, va_list ap)
+{
+        int ret;
+        static int backlog;
+
+        ret = vsnprintf(browser__last_msg + backlog,
+                        sizeof(browser__last_msg) - backlog, format, ap);
+        backlog += ret;
+
+        if (browser__last_msg[backlog - 1] == '\n') {
+                ui_helpline__puts(browser__last_msg);
+                newtRefresh();
+                backlog = 0;
+        }
+
+        return ret;
+}
+
+static void newt_form__set_exit_keys(newtComponent self)
+{
+        newtFormAddHotKey(self, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
+        newtFormAddHotKey(self, 'Q');
+        newtFormAddHotKey(self, 'q');
+        newtFormAddHotKey(self, CTRL('c'));
+}
+
+static newtComponent newt_form__new(void)
+{
+        newtComponent self = newtForm(NULL, NULL, 0);
+        if (self)
+                newt_form__set_exit_keys(self);
+        return self;
+}
+
+static int popup_menu(int argc, char * const argv[])
+{
+        struct newtExitStruct es;
+        int i, rc = -1, max_len = 5;
+        newtComponent listbox, form = newt_form__new();
+
+        if (form == NULL)
+                return -1;
+
+        listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
+        if (listbox == NULL)
+                goto out_destroy_form;
+
+        newtFormAddComponent(form, listbox);
+
+        for (i = 0; i < argc; ++i) {
+                int len = strlen(argv[i]);
+                if (len > max_len)
+                        max_len = len;
+                if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
+                        goto out_destroy_form;
+        }
+
+        newtCenteredWindow(max_len, argc, NULL);
+        newtFormRun(form, &es);
+        rc = newtListboxGetCurrent(listbox) - NULL;
+        if (es.reason == NEWT_EXIT_HOTKEY)
+                rc = -1;
+        newtPopWindow();
+out_destroy_form:
+        newtFormDestroy(form);
+        return rc;
+}
+
+static int ui__help_window(const char *text)
+{
+        struct newtExitStruct es;
+        newtComponent tb, form = newt_form__new();
+        int rc = -1;
+        int max_len = 0, nr_lines = 0;
+        const char *t;
+
+        if (form == NULL)
+                return -1;
+
+        t = text;
+        while (1) {
+                const char *sep = strchr(t, '\n');
+                int len;
+
+                if (sep == NULL)
+                        sep = strchr(t, '\0');
+                len = sep - t;
+                if (max_len < len)
+                        max_len = len;
+                ++nr_lines;
+                if (*sep == '\0')
+                        break;
+                t = sep + 1;
+        }
+
+        tb = newtTextbox(0, 0, max_len, nr_lines, 0);
+        if (tb == NULL)
+                goto out_destroy_form;
+
+        newtTextboxSetText(tb, text);
+        newtFormAddComponent(form, tb);
+        newtCenteredWindow(max_len, nr_lines, NULL);
+        newtFormRun(form, &es);
+        newtPopWindow();
+        rc = 0;
+out_destroy_form:
+        newtFormDestroy(form);
+        return rc;
+}
+
+static bool dialog_yesno(const char *msg)
+{
+        /* newtWinChoice should really be accepting const char pointers... */
+        char yes[] = "Yes", no[] = "No";
+        return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
+}
+
+#define HE_COLORSET_TOP         50
+#define HE_COLORSET_MEDIUM      51
+#define HE_COLORSET_NORMAL      52
+#define HE_COLORSET_SELECTED    53
+#define HE_COLORSET_CODE        54
+
+static int ui_browser__percent_color(double percent, bool current)
+{
+        if (current)
+                return HE_COLORSET_SELECTED;
+        if (percent >= MIN_RED)
+                return HE_COLORSET_TOP;
+        if (percent >= MIN_GREEN)
+                return HE_COLORSET_MEDIUM;
+        return HE_COLORSET_NORMAL;
+}
+
+struct ui_browser {
+        newtComponent   form, sb;
+        u64             index, first_visible_entry_idx;
+        void            *first_visible_entry, *entries;
+        u16             top, left, width, height;
+        void            *priv;
+        u32             nr_entries;
+};
+
+static void ui_browser__refresh_dimensions(struct ui_browser *self)
+{
+        int cols, rows;
+        newtGetScreenSize(&cols, &rows);
+
+        if (self->width > cols - 4)
+                self->width = cols - 4;
+        self->height = rows - 5;
+        if (self->height > self->nr_entries)
+                self->height = self->nr_entries;
+        self->top  = (rows - self->height) / 2;
+        self->left = (cols - self->width) / 2;
+}
+
+static void ui_browser__reset_index(struct ui_browser *self)
+{
+        self->index = self->first_visible_entry_idx = 0;
+        self->first_visible_entry = NULL;
+}
+
+static int objdump_line__show(struct objdump_line *self, struct list_head *head,
+                              int width, struct hist_entry *he, int len,
+                              bool current_entry)
+{
+        if (self->offset != -1) {
+                struct symbol *sym = he->ms.sym;
+                unsigned int hits = 0;
+                double percent = 0.0;
+                int color;
+                struct sym_priv *priv = symbol__priv(sym);
+                struct sym_ext *sym_ext = priv->ext;
+                struct sym_hist *h = priv->hist;
+                s64 offset = self->offset;
+                struct objdump_line *next = objdump__get_next_ip_line(head, self);
+
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (sym_ext) {
+                                percent += sym_ext[offset].percent;
+                        } else
+                                hits += h->ip[offset];
+
+                        ++offset;
+                }
+
+                if (sym_ext == NULL && h->sum)
+                        percent = 100.0 * hits / h->sum;
+
+                color = ui_browser__percent_color(percent, current_entry);
+                SLsmg_set_color(color);
+                slsmg_printf(" %7.2f ", percent);
+                if (!current_entry)
+                        SLsmg_set_color(HE_COLORSET_CODE);
+        } else {
+                int color = ui_browser__percent_color(0, current_entry);
+                SLsmg_set_color(color);
+                slsmg_write_nstring(" ", 9);
+        }
+
+        SLsmg_write_char(':');
+        slsmg_write_nstring(" ", 8);
+        if (!*self->line)
+                slsmg_write_nstring(" ", width - 18);
+        else
+                slsmg_write_nstring(self->line, width - 18);
+
+        return 0;
+}
+
+static int ui_browser__refresh_entries(struct ui_browser *self)
+{
+        struct objdump_line *pos;
+        struct list_head *head = self->entries;
+        struct hist_entry *he = self->priv;
+        int row = 0;
+        int len = he->ms.sym->end - he->ms.sym->start;
+
+        if (self->first_visible_entry == NULL || self->first_visible_entry == self->entries)
+                self->first_visible_entry = head->next;
+
+        pos = list_entry(self->first_visible_entry, struct objdump_line, node);
+
+        list_for_each_entry_from(pos, head, node) {
+                bool current_entry = (self->first_visible_entry_idx + row) == self->index;
+                SLsmg_gotorc(self->top + row, self->left);
+                objdump_line__show(pos, head, self->width,
+                                   he, len, current_entry);
+                if (++row == self->height)
+                        break;
+        }
+
+        SLsmg_set_color(HE_COLORSET_NORMAL);
+        SLsmg_fill_region(self->top + row, self->left,
+                          self->height - row, self->width, ' ');
+
+        return 0;
+}
+
+static int ui_browser__run(struct ui_browser *self, const char *title,
+                           struct newtExitStruct *es)
+{
+        if (self->form) {
+                newtFormDestroy(self->form);
+                newtPopWindow();
+        }
+
+        ui_browser__refresh_dimensions(self);
+        newtCenteredWindow(self->width + 2, self->height, title);
+        self->form = newt_form__new();
+        if (self->form == NULL)
+                return -1;
+
+        self->sb = newtVerticalScrollbar(self->width + 1, 0, self->height,
+                                         HE_COLORSET_NORMAL,
+                                         HE_COLORSET_SELECTED);
+        if (self->sb == NULL)
+                return -1;
+
+        newtFormAddHotKey(self->form, NEWT_KEY_UP);
+        newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
+        newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
+        newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
+        newtFormAddHotKey(self->form, NEWT_KEY_HOME);
+        newtFormAddHotKey(self->form, NEWT_KEY_END);
+
+        if (ui_browser__refresh_entries(self) < 0)
+                return -1;
+        newtFormAddComponent(self->form, self->sb);
+
+        while (1) {
+                unsigned int offset;
+
+                newtFormRun(self->form, es);
+
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                switch (es->u.key) {
+                case NEWT_KEY_DOWN:
+                        if (self->index == self->nr_entries - 1)
+                                break;
+                        ++self->index;
+                        if (self->index == self->first_visible_entry_idx + self->height) {
+                                struct list_head *pos = self->first_visible_entry;
+                                ++self->first_visible_entry_idx;
+                                self->first_visible_entry = pos->next;
+                        }
+                        break;
+                case NEWT_KEY_UP:
+                        if (self->index == 0)
+                                break;
+                        --self->index;
+                        if (self->index < self->first_visible_entry_idx) {
+                                struct list_head *pos = self->first_visible_entry;
+                                --self->first_visible_entry_idx;
+                                self->first_visible_entry = pos->prev;
+                        }
+                        break;
+                case NEWT_KEY_PGDN:
+                        if (self->first_visible_entry_idx + self->height > self->nr_entries - 1)
+                                break;
+
+                        offset = self->height;
+                        if (self->index + offset > self->nr_entries - 1)
+                                offset = self->nr_entries - 1 - self->index;
+                        self->index += offset;
+                        self->first_visible_entry_idx += offset;
+
+                        while (offset--) {
+                                struct list_head *pos = self->first_visible_entry;
+                                self->first_visible_entry = pos->next;
+                        }
+
+                        break;
+                case NEWT_KEY_PGUP:
+                        if (self->first_visible_entry_idx == 0)
+                                break;
+
+                        if (self->first_visible_entry_idx < self->height)
+                                offset = self->first_visible_entry_idx;
+                        else
+                                offset = self->height;
+
+                        self->index -= offset;
+                        self->first_visible_entry_idx -= offset;
+
+                        while (offset--) {
+                                struct list_head *pos = self->first_visible_entry;
+                                self->first_visible_entry = pos->prev;
+                        }
+                        break;
+                case NEWT_KEY_HOME:
+                        ui_browser__reset_index(self);
+                        break;
+                case NEWT_KEY_END: {
+                        struct list_head *head = self->entries;
+                        offset = self->height - 1;
+
+                        if (offset > self->nr_entries)
+                                offset = self->nr_entries;
+
+                        self->index = self->first_visible_entry_idx = self->nr_entries - 1 - offset;
+                        self->first_visible_entry = head->prev;
+                        while (offset-- != 0) {
+                                struct list_head *pos = self->first_visible_entry;
+                                self->first_visible_entry = pos->prev;
+                        }
+                }
+                        break;
+                case NEWT_KEY_ESCAPE:
+                case NEWT_KEY_LEFT:
+                case CTRL('c'):
+                case 'Q':
+                case 'q':
+                        return 0;
+                default:
+                        continue;
+                }
+                if (ui_browser__refresh_entries(self) < 0)
+                        return -1;
+        }
+        return 0;
+}
+
+/*
+ * When debugging newt problems it was useful to be able to "unroll"
+ * the calls to newtCheckBoxTreeAdd{Array,Item}, so that we can generate
+ * a source file with the sequence of calls to these methods, to then
+ * tweak the arrays to get the intended results, so I'm keeping this code
+ * here, may be useful again in the future.
+ */
+#undef NEWT_DEBUG
+
+static void newt_checkbox_tree__add(newtComponent tree, const char *str,
+                                    void *priv, int *indexes)
+{
+#ifdef NEWT_DEBUG
+        /* Print the newtCheckboxTreeAddArray to tinker with its index arrays */
+        int i = 0, len = 40 - strlen(str);
+
+        fprintf(stderr,
+                "\tnewtCheckboxTreeAddItem(tree, %*.*s\"%s\", (void *)%p, 0, ",
+                len, len, " ", str, priv);
+        while (indexes[i] != NEWT_ARG_LAST) {
+                if (indexes[i] != NEWT_ARG_APPEND)
+                        fprintf(stderr, " %d,", indexes[i]);
+                else
+                        fprintf(stderr, " %s,", "NEWT_ARG_APPEND");
+                ++i;
+        }
+        fprintf(stderr, " %s", " NEWT_ARG_LAST);\n");
+        fflush(stderr);
+#endif
+        newtCheckboxTreeAddArray(tree, str, priv, 0, indexes);
+}
+
+static char *callchain_list__sym_name(struct callchain_list *self,
+                                      char *bf, size_t bfsize)
+{
+        if (self->ms.sym)
+                return self->ms.sym->name;
+
+        snprintf(bf, bfsize, "%#Lx", self->ip);
+        return bf;
+}
+
+static void __callchain__append_graph_browser(struct callchain_node *self,
+                                              newtComponent tree, u64 total,
+                                              int *indexes, int depth)
+{
+        struct rb_node *node;
+        u64 new_total, remaining;
+        int idx = 0;
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                new_total = self->children_hit;
+        else
+                new_total = total;
+
+        remaining = new_total;
+        node = rb_first(&self->rb_root);
+        while (node) {
+                struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
+                struct rb_node *next = rb_next(node);
+                u64 cumul = cumul_hits(child);
+                struct callchain_list *chain;
+                int first = true, printed = 0;
+                int chain_idx = -1;
+                remaining -= cumul;
+
+                indexes[depth] = NEWT_ARG_APPEND;
+                indexes[depth + 1] = NEWT_ARG_LAST;
+
+                list_for_each_entry(chain, &child->val, list) {
+                        char ipstr[BITS_PER_LONG / 4 + 1],
+                             *alloc_str = NULL;
+                        const char *str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+
+                        if (first) {
+                                double percent = cumul * 100.0 / new_total;
+
+                                first = false;
+                                if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
+                                        str = "Not enough memory!";
+                                else
+                                        str = alloc_str;
+                        } else {
+                                indexes[depth] = idx;
+                                indexes[depth + 1] = NEWT_ARG_APPEND;
+                                indexes[depth + 2] = NEWT_ARG_LAST;
+                                ++chain_idx;
+                        }
+                        newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
+                        free(alloc_str);
+                        ++printed;
+                }
+
+                indexes[depth] = idx;
+                if (chain_idx != -1)
+                        indexes[depth + 1] = chain_idx;
+                if (printed != 0)
+                        ++idx;
+                __callchain__append_graph_browser(child, tree, new_total, indexes,
+                                                  depth + (chain_idx != -1 ? 2 : 1));
+                node = next;
+        }
+}
+
+static void callchain__append_graph_browser(struct callchain_node *self,
+                                            newtComponent tree, u64 total,
+                                            int *indexes, int parent_idx)
+{
+        struct callchain_list *chain;
+        int i = 0;
+
+        indexes[1] = NEWT_ARG_APPEND;
+        indexes[2] = NEWT_ARG_LAST;
+
+        list_for_each_entry(chain, &self->val, list) {
+                char ipstr[BITS_PER_LONG / 4 + 1], *str;
+
+                if (chain->ip >= PERF_CONTEXT_MAX)
+                        continue;
+
+                if (!i++ && sort__first_dimension == SORT_SYM)
+                        continue;
+
+                str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+                newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
+        }
+
+        indexes[1] = parent_idx;
+        indexes[2] = NEWT_ARG_APPEND;
+        indexes[3] = NEWT_ARG_LAST;
+        __callchain__append_graph_browser(self, tree, total, indexes, 2);
+}
+
+static void hist_entry__append_callchain_browser(struct hist_entry *self,
+                                                 newtComponent tree, u64 total, int parent_idx)
+{
+        struct rb_node *rb_node;
+        int indexes[1024] = { [0] = parent_idx, };
+        int idx = 0;
+        struct callchain_node *chain;
+
+        rb_node = rb_first(&self->sorted_chain);
+        while (rb_node) {
+                chain = rb_entry(rb_node, struct callchain_node, rb_node);
+                switch (callchain_param.mode) {
+                case CHAIN_FLAT:
+                        break;
+                case CHAIN_GRAPH_ABS: /* falldown */
+                case CHAIN_GRAPH_REL:
+                        callchain__append_graph_browser(chain, tree, total, indexes, idx++);
+                        break;
+                case CHAIN_NONE:
+                default:
+                        break;
+                }
+                rb_node = rb_next(rb_node);
+        }
+}
+
+static size_t hist_entry__append_browser(struct hist_entry *self,
+                                         newtComponent tree, u64 total)
+{
+        char s[256];
+        size_t ret;
+
+        if (symbol_conf.exclude_other && !self->parent)
+                return 0;
+
+        ret = hist_entry__snprintf(self, s, sizeof(s), NULL,
+                                   false, 0, false, total);
+        if (symbol_conf.use_callchain) {
+                int indexes[2];
+
+                indexes[0] = NEWT_ARG_APPEND;
+                indexes[1] = NEWT_ARG_LAST;
+                newt_checkbox_tree__add(tree, s, &self->ms, indexes);
+        } else
+                newtListboxAppendEntry(tree, s, &self->ms);
+
+        return ret;
+}
+
+static void hist_entry__annotate_browser(struct hist_entry *self)
+{
+        struct ui_browser browser;
+        struct newtExitStruct es;
+        struct objdump_line *pos, *n;
+        LIST_HEAD(head);
+
+        if (self->ms.sym == NULL)
+                return;
+
+        if (hist_entry__annotate(self, &head) < 0)
+                return;
+
+        ui_helpline__push("Press <- or ESC to exit");
+
+        memset(&browser, 0, sizeof(browser));
+        browser.entries = &head;
+        browser.priv = self;
+        list_for_each_entry(pos, &head, node) {
+                size_t line_len = strlen(pos->line);
+                if (browser.width < line_len)
+                        browser.width = line_len;
+                ++browser.nr_entries;
+        }
+
+        browser.width += 18; /* Percentage */
+        ui_browser__run(&browser, self->ms.sym->name, &es);
+        newtFormDestroy(browser.form);
+        newtPopWindow();
+        list_for_each_entry_safe(pos, n, &head, node) {
+                list_del(&pos->node);
+                objdump_line__free(pos);
+        }
+        ui_helpline__pop();
+}
+
+static const void *newt__symbol_tree_get_current(newtComponent self)
+{
+        if (symbol_conf.use_callchain)
+                return newtCheckboxTreeGetCurrent(self);
+        return newtListboxGetCurrent(self);
+}
+
+static void hist_browser__selection(newtComponent self, void *data)
+{
+        const struct map_symbol **symbol_ptr = data;
+        *symbol_ptr = newt__symbol_tree_get_current(self);
+}
+
+struct hist_browser {
+        newtComponent           form, tree;
+        const struct map_symbol *selection;
+};
+
+static struct hist_browser *hist_browser__new(void)
+{
+        struct hist_browser *self = malloc(sizeof(*self));
+
+        if (self != NULL)
+                self->form = NULL;
+
+        return self;
+}
+
+static void hist_browser__delete(struct hist_browser *self)
+{
+        newtFormDestroy(self->form);
+        newtPopWindow();
+        free(self);
+}
+
+static int hist_browser__populate(struct hist_browser *self, struct hists *hists,
+                                  const char *title)
+{
+        int max_len = 0, idx, cols, rows;
+        struct ui_progress *progress;
+        struct rb_node *nd;
+        u64 curr_hist = 0;
+        char seq[] = ".", unit;
+        char str[256];
+        unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
+
+        if (self->form) {
+                newtFormDestroy(self->form);
+                newtPopWindow();
+        }
+
+        nr_events = convert_unit(nr_events, &unit);
+        snprintf(str, sizeof(str), "Events: %lu%c                            ",
+                 nr_events, unit);
+        newtDrawRootText(0, 0, str);
+
+        newtGetScreenSize(NULL, &rows);
+
+        if (symbol_conf.use_callchain)
+                self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
+                                                   NEWT_FLAG_SCROLL);
+        else
+                self->tree = newtListbox(0, 0, rows - 5,
+                                        (NEWT_FLAG_SCROLL |
+                                         NEWT_FLAG_RETURNEXIT));
+
+        newtComponentAddCallback(self->tree, hist_browser__selection,
+                                 &self->selection);
+
+        progress = ui_progress__new("Adding entries to the browser...",
+                                    hists->nr_entries);
+        if (progress == NULL)
+                return -1;
+
+        idx = 0;
+        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                int len;
+
+                if (h->filtered)
+                        continue;
+
+                len = hist_entry__append_browser(h, self->tree, hists->stats.total_period);
+                if (len > max_len)
+                        max_len = len;
+                if (symbol_conf.use_callchain)
+                        hist_entry__append_callchain_browser(h, self->tree,
+                                                             hists->stats.total_period, idx++);
+                ++curr_hist;
+                if (curr_hist % 5)
+                        ui_progress__update(progress, curr_hist);
+        }
+
+        ui_progress__delete(progress);
+
+        newtGetScreenSize(&cols, &rows);
+
+        if (max_len > cols)
+                max_len = cols - 3;
+
+        if (!symbol_conf.use_callchain)
+                newtListboxSetWidth(self->tree, max_len);
+
+        newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
+                           rows - 5, title);
+        self->form = newt_form__new();
+        if (self->form == NULL)
+                return -1;
+
+        newtFormAddHotKey(self->form, 'A');
+        newtFormAddHotKey(self->form, 'a');
+        newtFormAddHotKey(self->form, 'D');
+        newtFormAddHotKey(self->form, 'd');
+        newtFormAddHotKey(self->form, 'T');
+        newtFormAddHotKey(self->form, 't');
+        newtFormAddHotKey(self->form, '?');
+        newtFormAddHotKey(self->form, 'H');
+        newtFormAddHotKey(self->form, 'h');
+        newtFormAddHotKey(self->form, NEWT_KEY_F1);
+        newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
+        newtFormAddComponents(self->form, self->tree, NULL);
+        self->selection = newt__symbol_tree_get_current(self->tree);
+
+        return 0;
+}
+
+static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
+{
+        int *indexes;
+
+        if (!symbol_conf.use_callchain)
+                goto out;
+
+        indexes = newtCheckboxTreeFindItem(self->tree, (void *)self->selection);
+        if (indexes) {
+                bool is_hist_entry = indexes[1] == NEWT_ARG_LAST;
+                free(indexes);
+                if (is_hist_entry)
+                        goto out;
+        }
+        return NULL;
+out:
+        return container_of(self->selection, struct hist_entry, ms);
+}
+
+static struct thread *hist_browser__selected_thread(struct hist_browser *self)
+{
+        struct hist_entry *he = hist_browser__selected_entry(self);
+        return he ? he->thread : NULL;
+}
+
+static int hist_browser__title(char *bf, size_t size, const char *input_name,
+                               const struct dso *dso, const struct thread *thread)
+{
+        int printed = 0;
+
+        if (thread)
+                printed += snprintf(bf + printed, size - printed,
+                                    "Thread: %s(%d)",
+                                    (thread->comm_set ?  thread->comm : ""),
+                                    thread->pid);
+        if (dso)
+                printed += snprintf(bf + printed, size - printed,
+                                    "%sDSO: %s", thread ? " " : "",
+                                    dso->short_name);
+        return printed ?: snprintf(bf, size, "Report: %s", input_name);
+}
+
+int hists__browse(struct hists *self, const char *helpline, const char *input_name)
+{
+        struct hist_browser *browser = hist_browser__new();
+        struct pstack *fstack = pstack__new(2);
+        const struct thread *thread_filter = NULL;
+        const struct dso *dso_filter = NULL;
+        struct newtExitStruct es;
+        char msg[160];
+        int err = -1;
+
+        if (browser == NULL)
+                return -1;
+
+        fstack = pstack__new(2);
+        if (fstack == NULL)
+                goto out;
+
+        ui_helpline__push(helpline);
+
+        hist_browser__title(msg, sizeof(msg), input_name,
+                            dso_filter, thread_filter);
+        if (hist_browser__populate(browser, self, msg) < 0)
+                goto out_free_stack;
+
+        while (1) {
+                const struct thread *thread;
+                const struct dso *dso;
+                char *options[16];
+                int nr_options = 0, choice = 0, i,
+                    annotate = -2, zoom_dso = -2, zoom_thread = -2;
+
+                newtFormRun(browser->form, &es);
+
+                thread = hist_browser__selected_thread(browser);
+                dso = browser->selection->map ? browser->selection->map->dso : NULL;
+
+                if (es.reason == NEWT_EXIT_HOTKEY) {
+                        if (es.u.key == NEWT_KEY_F1)
+                                goto do_help;
+
+                        switch (toupper(es.u.key)) {
+                        case 'A':
+                                goto do_annotate;
+                        case 'D':
+                                goto zoom_dso;
+                        case 'T':
+                                goto zoom_thread;
+                        case 'H':
+                        case '?':
+do_help:
+                                ui__help_window("->        Zoom into DSO/Threads & Annotate current symbol\n"
+                                                "<-        Zoom out\n"
+                                                "a         Annotate current symbol\n"
+                                                "h/?/F1    Show this window\n"
+                                                "d         Zoom into current DSO\n"
+                                                "t         Zoom into current Thread\n"
+                                                "q/CTRL+C  Exit browser");
+                                continue;
+                        default:;
+                        }
+                        if (toupper(es.u.key) == 'Q' ||
+                            es.u.key == CTRL('c'))
+                                break;
+                        if (es.u.key == NEWT_KEY_ESCAPE) {
+                                if (dialog_yesno("Do you really want to exit?"))
+                                        break;
+                                else
+                                        continue;
+                        }
+
+                        if (es.u.key == NEWT_KEY_LEFT) {
+                                const void *top;
+
+                                if (pstack__empty(fstack))
+                                        continue;
+                                top = pstack__pop(fstack);
+                                if (top == &dso_filter)
+                                        goto zoom_out_dso;
+                                if (top == &thread_filter)
+                                        goto zoom_out_thread;
+                                continue;
+                        }
+                }
+
+                if (browser->selection->sym != NULL &&
+                    asprintf(&options[nr_options], "Annotate %s",
+                             browser->selection->sym->name) > 0)
+                        annotate = nr_options++;
+
+                if (thread != NULL &&
+                    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
+                             (thread_filter ? "out of" : "into"),
+                             (thread->comm_set ? thread->comm : ""),
+                             thread->pid) > 0)
+                        zoom_thread = nr_options++;
+
+                if (dso != NULL &&
+                    asprintf(&options[nr_options], "Zoom %s %s DSO",
+                             (dso_filter ? "out of" : "into"),
+                             (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
+                        zoom_dso = nr_options++;
+
+                options[nr_options++] = (char *)"Exit";
+
+                choice = popup_menu(nr_options, options);
+
+                for (i = 0; i < nr_options - 1; ++i)
+                        free(options[i]);
+
+                if (choice == nr_options - 1)
+                        break;
+
+                if (choice == -1)
+                        continue;
+
+                if (choice == annotate) {
+                        struct hist_entry *he;
+do_annotate:
+                        if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
+                                ui_helpline__puts("No vmlinux file found, can't "
+                                                 "annotate with just a "
+                                                 "kallsyms file");
+                                continue;
+                        }
+
+                        he = hist_browser__selected_entry(browser);
+                        if (he == NULL)
+                                continue;
+
+                        hist_entry__annotate_browser(he);
+                } else if (choice == zoom_dso) {
+zoom_dso:
+                        if (dso_filter) {
+                                pstack__remove(fstack, &dso_filter);
+zoom_out_dso:
+                                ui_helpline__pop();
+                                dso_filter = NULL;
+                        } else {
+                                if (dso == NULL)
+                                        continue;
+                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
+                                                   dso->kernel ? "the Kernel" : dso->short_name);
+                                dso_filter = dso;
+                                pstack__push(fstack, &dso_filter);
+                        }
+                        hists__filter_by_dso(self, dso_filter);
+                        hist_browser__title(msg, sizeof(msg), input_name,
+                                            dso_filter, thread_filter);
+                        if (hist_browser__populate(browser, self, msg) < 0)
+                                goto out;
+                } else if (choice == zoom_thread) {
+zoom_thread:
+                        if (thread_filter) {
+                                pstack__remove(fstack, &thread_filter);
+zoom_out_thread:
+                                ui_helpline__pop();
+                                thread_filter = NULL;
+                        } else {
+                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
+                                                   thread->comm_set ? thread->comm : "",
+                                                   thread->pid);
+                                thread_filter = thread;
+                                pstack__push(fstack, &thread_filter);
+                        }
+                        hists__filter_by_thread(self, thread_filter);
+                        hist_browser__title(msg, sizeof(msg), input_name,
+                                            dso_filter, thread_filter);
+                        if (hist_browser__populate(browser, self, msg) < 0)
+                                goto out;
+                }
+        }
+        err = 0;
+out_free_stack:
+        pstack__delete(fstack);
+out:
+        hist_browser__delete(browser);
+        return err;
+}
+
+static struct newtPercentTreeColors {
+        const char *topColorFg, *topColorBg;
+        const char *mediumColorFg, *mediumColorBg;
+        const char *normalColorFg, *normalColorBg;
+        const char *selColorFg, *selColorBg;
+        const char *codeColorFg, *codeColorBg;
+} defaultPercentTreeColors = {
+        "red",       "lightgray",
+        "green",     "lightgray",
+        "black",     "lightgray",
+        "lightgray", "magenta",
+        "blue",      "lightgray",
+};
+
+void setup_browser(void)
+{
+        struct newtPercentTreeColors *c = &defaultPercentTreeColors;
+        if (!isatty(1))
+                return;
+
+        use_browser = true;
+        newtInit();
+        newtCls();
+        ui_helpline__puts(" ");
+        sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
+        sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
+        sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
+        sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
+        sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
+}
+
+void exit_browser(bool wait_for_ok)
+{
+        if (use_browser) {
+                if (wait_for_ok) {
+                        char title[] = "Fatal Error", ok[] = "Ok";
+                        newtWinMessage(title, ok, browser__last_msg);
+                }
+                newtFinished();
+        }
+}
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 05d0c5c2030..9bf0f402ca7 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -5,6 +5,7 @@
 #include "parse-events.h"
 #include "exec_cmd.h"
 #include "string.h"
+#include "symbol.h"
 #include "cache.h"
 #include "header.h"
 #include "debugfs.h"
@@ -409,7 +410,6 @@ static enum event_result
 parse_single_tracepoint_event(char *sys_name,
                               const char *evt_name,
                               unsigned int evt_length,
-                              char *flags,
                               struct perf_event_attr *attr,
                               const char **strp)
 {
@@ -418,14 +418,6 @@ parse_single_tracepoint_event(char *sys_name,
         u64 id;
         int fd;
 
-        if (flags) {
-                if (!strncmp(flags, "record", strlen(flags))) {
-                        attr->sample_type |= PERF_SAMPLE_RAW;
-                        attr->sample_type |= PERF_SAMPLE_TIME;
-                        attr->sample_type |= PERF_SAMPLE_CPU;
-                }
-        }
-
         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
                  sys_name, evt_name);
 
@@ -444,6 +436,13 @@ parse_single_tracepoint_event(char *sys_name,
         attr->type = PERF_TYPE_TRACEPOINT;
         *strp = evt_name + evt_length;
 
+        attr->sample_type |= PERF_SAMPLE_RAW;
+        attr->sample_type |= PERF_SAMPLE_TIME;
+        attr->sample_type |= PERF_SAMPLE_CPU;
+
+        attr->sample_period = 1;
+
+
         return EVT_HANDLED;
 }
 
@@ -532,8 +531,7 @@ static enum event_result parse_tracepoint_event(const char **strp,
                                                        flags);
         } else
                 return parse_single_tracepoint_event(sys_name, evt_name,
-                                                     evt_length, flags,
-                                                     attr, strp);
+                                                     evt_length, attr, strp);
 }
 
 static enum event_result
@@ -690,19 +688,29 @@ static enum event_result
 parse_event_modifier(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
-        int eu = 1, ek = 1, eh = 1;
+        int exclude = 0;
+        int eu = 0, ek = 0, eh = 0, precise = 0;
 
         if (*str++ != ':')
                 return 0;
         while (*str) {
-                if (*str == 'u')
+                if (*str == 'u') {
+                        if (!exclude)
+                                exclude = eu = ek = eh = 1;
                         eu = 0;
-                else if (*str == 'k')
+                } else if (*str == 'k') {
+                        if (!exclude)
+                                exclude = eu = ek = eh = 1;
                         ek = 0;
-                else if (*str == 'h')
+                } else if (*str == 'h') {
+                        if (!exclude)
+                                exclude = eu = ek = eh = 1;
                         eh = 0;
-                else
+                } else if (*str == 'p') {
+                        precise++;
+                } else
                         break;
+
                 ++str;
         }
         if (str >= *strp + 2) {
@@ -710,6 +718,7 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
                 attr->exclude_user   = eu;
                 attr->exclude_kernel = ek;
                 attr->exclude_hv     = eh;
+                attr->precise_ip     = precise;
                 return 1;
         }
         return 0;
@@ -934,7 +943,8 @@ void print_events(void)
 
         printf("\n");
         printf("  %-42s [%s]\n",
-                "rNNN", event_type_descriptors[PERF_TYPE_RAW]);
+                "rNNN (see 'perf list --help' on how to encode it)",
+               event_type_descriptors[PERF_TYPE_RAW]);
         printf("\n");
 
         printf("  %-42s [%s]\n",
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index b8c1f64bc93..fc4ab3fe877 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -13,6 +13,7 @@ struct tracepoint_path {
 };
 
 extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
+extern bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events);
 
 extern int                      nr_counters;
 
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index efebd5b476b..99d02aa57db 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -49,8 +49,9 @@ static int get_value(struct parse_opt_ctx_t *p,
                                 break;
                         /* FALLTHROUGH */
                 case OPTION_BOOLEAN:
+                case OPTION_INCR:
                 case OPTION_BIT:
-                case OPTION_SET_INT:
+                case OPTION_SET_UINT:
                 case OPTION_SET_PTR:
                         return opterror(opt, "takes no value", flags);
                 case OPTION_END:
@@ -58,7 +59,9 @@ static int get_value(struct parse_opt_ctx_t *p,
                 case OPTION_GROUP:
                 case OPTION_STRING:
                 case OPTION_INTEGER:
+                case OPTION_UINTEGER:
                 case OPTION_LONG:
+                case OPTION_U64:
                 default:
                         break;
                 }
@@ -73,11 +76,15 @@ static int get_value(struct parse_opt_ctx_t *p,
                 return 0;
 
         case OPTION_BOOLEAN:
+                *(bool *)opt->value = unset ? false : true;
+                return 0;
+
+        case OPTION_INCR:
                 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
                 return 0;
 
-        case OPTION_SET_INT:
-                *(int *)opt->value = unset ? 0 : opt->defval;
+        case OPTION_SET_UINT:
+                *(unsigned int *)opt->value = unset ? 0 : opt->defval;
                 return 0;
 
         case OPTION_SET_PTR:
@@ -120,6 +127,22 @@ static int get_value(struct parse_opt_ctx_t *p,
                         return opterror(opt, "expects a numerical value", flags);
                 return 0;
 
+        case OPTION_UINTEGER:
+                if (unset) {
+                        *(unsigned int *)opt->value = 0;
+                        return 0;
+                }
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
+                        *(unsigned int *)opt->value = opt->defval;
+                        return 0;
+                }
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                *(unsigned int *)opt->value = strtol(arg, (char **)&s, 10);
+                if (*s)
+                        return opterror(opt, "expects a numerical value", flags);
+                return 0;
+
         case OPTION_LONG:
                 if (unset) {
                         *(long *)opt->value = 0;
@@ -136,6 +159,22 @@ static int get_value(struct parse_opt_ctx_t *p,
                         return opterror(opt, "expects a numerical value", flags);
                 return 0;
 
+        case OPTION_U64:
+                if (unset) {
+                        *(u64 *)opt->value = 0;
+                        return 0;
+                }
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
+                        *(u64 *)opt->value = opt->defval;
+                        return 0;
+                }
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                *(u64 *)opt->value = strtoull(arg, (char **)&s, 10);
+                if (*s)
+                        return opterror(opt, "expects a numerical value", flags);
+                return 0;
+
         case OPTION_END:
         case OPTION_ARGUMENT:
         case OPTION_GROUP:
@@ -441,7 +480,10 @@ int usage_with_options_internal(const char * const *usagestr,
                 switch (opts->type) {
                 case OPTION_ARGUMENT:
                         break;
+                case OPTION_LONG:
+                case OPTION_U64:
                 case OPTION_INTEGER:
+                case OPTION_UINTEGER:
                         if (opts->flags & PARSE_OPT_OPTARG)
                                 if (opts->long_name)
                                         pos += fprintf(stderr, "[=<n>]");
@@ -473,14 +515,14 @@ int usage_with_options_internal(const char * const *usagestr,
                                         pos += fprintf(stderr, " ...");
                         }
                         break;
-                default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
+                default: /* OPTION_{BIT,BOOLEAN,SET_UINT,SET_PTR} */
                 case OPTION_END:
                 case OPTION_GROUP:
                 case OPTION_BIT:
                 case OPTION_BOOLEAN:
-                case OPTION_SET_INT:
+                case OPTION_INCR:
+                case OPTION_SET_UINT:
                 case OPTION_SET_PTR:
-                case OPTION_LONG:
                         break;
                 }
 
@@ -500,6 +542,7 @@ int usage_with_options_internal(const char * const *usagestr,
 void usage_with_options(const char * const *usagestr,
                         const struct option *opts)
 {
+        exit_browser(false);
         usage_with_options_internal(usagestr, opts, 0);
         exit(129);
 }
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 948805af43c..c7d72dce54b 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -1,6 +1,9 @@
 #ifndef __PERF_PARSE_OPTIONS_H
 #define __PERF_PARSE_OPTIONS_H
 
+#include <linux/kernel.h>
+#include <stdbool.h>
+
 enum parse_opt_type {
         /* special types */
         OPTION_END,
@@ -8,14 +11,17 @@ enum parse_opt_type {
         OPTION_GROUP,
         /* options with no arguments */
         OPTION_BIT,
-        OPTION_BOOLEAN, /* _INCR would have been a better name */
-        OPTION_SET_INT,
+        OPTION_BOOLEAN,
+        OPTION_INCR,
+        OPTION_SET_UINT,
         OPTION_SET_PTR,
         /* options with arguments (usually) */
         OPTION_STRING,
         OPTION_INTEGER,
         OPTION_LONG,
         OPTION_CALLBACK,
+        OPTION_U64,
+        OPTION_UINTEGER,
 };
 
 enum parse_opt_flags {
@@ -73,7 +79,7 @@ typedef int parse_opt_cb(const struct option *, const char *arg, int unset);
  *
  * `defval`::
  *   default value to fill (*->value) with for PARSE_OPT_OPTARG.
- *   OPTION_{BIT,SET_INT,SET_PTR} store the {mask,integer,pointer} to put in
+ *   OPTION_{BIT,SET_UINT,SET_PTR} store the {mask,integer,pointer} to put in
  *   the value when met.
  *   CALLBACKS can use it like they want.
  */
@@ -90,16 +96,21 @@ struct option {
         intptr_t defval;
 };
 
+#define check_vtype(v, type) ( BUILD_BUG_ON_ZERO(!__builtin_types_compatible_p(typeof(v), type)) + v )
+
 #define OPT_END()                   { .type = OPTION_END }
 #define OPT_ARGUMENT(l, h)          { .type = OPTION_ARGUMENT, .long_name = (l), .help = (h) }
 #define OPT_GROUP(h)                { .type = OPTION_GROUP, .help = (h) }
-#define OPT_BIT(s, l, v, h, b)      { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (b) }
-#define OPT_BOOLEAN(s, l, v, h)     { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
-#define OPT_SET_INT(s, l, v, h, i)  { .type = OPTION_SET_INT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (i) }
+#define OPT_BIT(s, l, v, h, b)      { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h), .defval = (b) }
+#define OPT_BOOLEAN(s, l, v, h)     { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = check_vtype(v, bool *), .help = (h) }
+#define OPT_INCR(s, l, v, h)        { .type = OPTION_INCR, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) }
+#define OPT_SET_UINT(s, l, v, h, i)  { .type = OPTION_SET_UINT, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h), .defval = (i) }
 #define OPT_SET_PTR(s, l, v, h, p)  { .type = OPTION_SET_PTR, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (p) }
-#define OPT_INTEGER(s, l, v, h)     { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
-#define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
-#define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h) }
+#define OPT_INTEGER(s, l, v, h)     { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) }
+#define OPT_UINTEGER(s, l, v, h)    { .type = OPTION_UINTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h) }
+#define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = check_vtype(v, long *), .help = (h) }
+#define OPT_U64(s, l, v, h)         { .type = OPTION_U64, .short_name = (s), .long_name = (l), .value = check_vtype(v, u64 *), .help = (h) }
+#define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h) }
 #define OPT_DATE(s, l, v, h) \
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
 #define OPT_CALLBACK(s, l, v, a, h, f) \
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 7c004b6ef24..914c67095d9 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -33,20 +33,27 @@
 #include <limits.h>
 
 #undef _GNU_SOURCE
+#include "util.h"
 #include "event.h"
 #include "string.h"
 #include "strlist.h"
 #include "debug.h"
 #include "cache.h"
 #include "color.h"
-#include "parse-events.h"  /* For debugfs_path */
+#include "symbol.h"
+#include "thread.h"
+#include "debugfs.h"
+#include "trace-event.h"        /* For __unused */
 #include "probe-event.h"
+#include "probe-finder.h"
 
 #define MAX_CMDLEN 256
 #define MAX_PROBE_ARGS 128
 #define PERFPROBE_GROUP "probe"
 
-#define semantic_error(msg ...) die("Semantic error :" msg)
+bool probe_event_dry_run;       /* Dry run flag */
+
+#define semantic_error(msg ...) pr_err("Semantic error :" msg)
 
 /* If there is no space to write, returns -E2BIG. */
 static int e_snprintf(char *str, size_t size, const char *format, ...)
@@ -64,7 +71,275 @@ static int e_snprintf(char *str, size_t size, const char *format, ...)
         return ret;
 }
 
-void parse_line_range_desc(const char *arg, struct line_range *lr)
+static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
+static struct machine machine;
+
+/* Initialize symbol maps and path of vmlinux */
+static int init_vmlinux(void)
+{
+        struct dso *kernel;
+        int ret;
+
+        symbol_conf.sort_by_name = true;
+        if (symbol_conf.vmlinux_name == NULL)
+                symbol_conf.try_vmlinux_path = true;
+        else
+                pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
+        ret = symbol__init();
+        if (ret < 0) {
+                pr_debug("Failed to init symbol map.\n");
+                goto out;
+        }
+
+        ret = machine__init(&machine, "/", 0);
+        if (ret < 0)
+                goto out;
+
+        kernel = dso__new_kernel(symbol_conf.vmlinux_name);
+        if (kernel == NULL)
+                die("Failed to create kernel dso.");
+
+        ret = __machine__create_kernel_maps(&machine, kernel);
+        if (ret < 0)
+                pr_debug("Failed to create kernel maps.\n");
+
+out:
+        if (ret < 0)
+                pr_warning("Failed to init vmlinux path.\n");
+        return ret;
+}
+
+#ifdef DWARF_SUPPORT
+static int open_vmlinux(void)
+{
+        if (map__load(machine.vmlinux_maps[MAP__FUNCTION], NULL) < 0) {
+                pr_debug("Failed to load kernel map.\n");
+                return -EINVAL;
+        }
+        pr_debug("Try to open %s\n", machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name);
+        return open(machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name, O_RDONLY);
+}
+
+/* Convert trace point to probe point with debuginfo */
+static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
+                                       struct perf_probe_point *pp)
+{
+        struct symbol *sym;
+        int fd, ret = -ENOENT;
+
+        sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION],
+                                       tp->symbol, NULL);
+        if (sym) {
+                fd = open_vmlinux();
+                if (fd >= 0) {
+                        ret = find_perf_probe_point(fd,
+                                                 sym->start + tp->offset, pp);
+                        close(fd);
+                }
+        }
+        if (ret <= 0) {
+                pr_debug("Failed to find corresponding probes from "
+                         "debuginfo. Use kprobe event information.\n");
+                pp->function = strdup(tp->symbol);
+                if (pp->function == NULL)
+                        return -ENOMEM;
+                pp->offset = tp->offset;
+        }
+        pp->retprobe = tp->retprobe;
+
+        return 0;
+}
+
+/* Try to find perf_probe_event with debuginfo */
+static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
+                                           struct kprobe_trace_event **tevs,
+                                           int max_tevs)
+{
+        bool need_dwarf = perf_probe_event_need_dwarf(pev);
+        int fd, ntevs;
+
+        fd = open_vmlinux();
+        if (fd < 0) {
+                if (need_dwarf) {
+                        pr_warning("Failed to open debuginfo file.\n");
+                        return fd;
+                }
+                pr_debug("Could not open vmlinux. Try to use symbols.\n");
+                return 0;
+        }
+
+        /* Searching trace events corresponding to probe event */
+        ntevs = find_kprobe_trace_events(fd, pev, tevs, max_tevs);
+        close(fd);
+
+        if (ntevs > 0) {        /* Succeeded to find trace events */
+                pr_debug("find %d kprobe_trace_events.\n", ntevs);
+                return ntevs;
+        }
+
+        if (ntevs == 0) {       /* No error but failed to find probe point. */
+                pr_warning("Probe point '%s' not found.\n",
+                           synthesize_perf_probe_point(&pev->point));
+                return -ENOENT;
+        }
+        /* Error path : ntevs < 0 */
+        pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
+        if (ntevs == -EBADF) {
+                pr_warning("Warning: No dwarf info found in the vmlinux - "
+                        "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
+                if (!need_dwarf) {
+                        pr_debug("Trying to use symbols.\nn");
+                        return 0;
+                }
+        }
+        return ntevs;
+}
+
+#define LINEBUF_SIZE 256
+#define NR_ADDITIONAL_LINES 2
+
+static int show_one_line(FILE *fp, int l, bool skip, bool show_num)
+{
+        char buf[LINEBUF_SIZE];
+        const char *color = PERF_COLOR_BLUE;
+
+        if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
+                goto error;
+        if (!skip) {
+                if (show_num)
+                        fprintf(stdout, "%7d  %s", l, buf);
+                else
+                        color_fprintf(stdout, color, "         %s", buf);
+        }
+
+        while (strlen(buf) == LINEBUF_SIZE - 1 &&
+               buf[LINEBUF_SIZE - 2] != '\n') {
+                if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
+                        goto error;
+                if (!skip) {
+                        if (show_num)
+                                fprintf(stdout, "%s", buf);
+                        else
+                                color_fprintf(stdout, color, "%s", buf);
+                }
+        }
+
+        return 0;
+error:
+        if (feof(fp))
+                pr_warning("Source file is shorter than expected.\n");
+        else
+                pr_warning("File read error: %s\n", strerror(errno));
+
+        return -1;
+}
+
+/*
+ * Show line-range always requires debuginfo to find source file and
+ * line number.
+ */
+int show_line_range(struct line_range *lr)
+{
+        int l = 1;
+        struct line_node *ln;
+        FILE *fp;
+        int fd, ret;
+
+        /* Search a line range */
+        ret = init_vmlinux();
+        if (ret < 0)
+                return ret;
+
+        fd = open_vmlinux();
+        if (fd < 0) {
+                pr_warning("Failed to open debuginfo file.\n");
+                return fd;
+        }
+
+        ret = find_line_range(fd, lr);
+        close(fd);
+        if (ret == 0) {
+                pr_warning("Specified source line is not found.\n");
+                return -ENOENT;
+        } else if (ret < 0) {
+                pr_warning("Debuginfo analysis failed. (%d)\n", ret);
+                return ret;
+        }
+
+        setup_pager();
+
+        if (lr->function)
+                fprintf(stdout, "<%s:%d>\n", lr->function,
+                        lr->start - lr->offset);
+        else
+                fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
+
+        fp = fopen(lr->path, "r");
+        if (fp == NULL) {
+                pr_warning("Failed to open %s: %s\n", lr->path,
+                           strerror(errno));
+                return -errno;
+        }
+        /* Skip to starting line number */
+        while (l < lr->start && ret >= 0)
+                ret = show_one_line(fp, l++, true, false);
+        if (ret < 0)
+                goto end;
+
+        list_for_each_entry(ln, &lr->line_list, list) {
+                while (ln->line > l && ret >= 0)
+                        ret = show_one_line(fp, (l++) - lr->offset,
+                                            false, false);
+                if (ret >= 0)
+                        ret = show_one_line(fp, (l++) - lr->offset,
+                                            false, true);
+                if (ret < 0)
+                        goto end;
+        }
+
+        if (lr->end == INT_MAX)
+                lr->end = l + NR_ADDITIONAL_LINES;
+        while (l <= lr->end && !feof(fp) && ret >= 0)
+                ret = show_one_line(fp, (l++) - lr->offset, false, false);
+end:
+        fclose(fp);
+        return ret;
+}
+
+#else   /* !DWARF_SUPPORT */
+
+static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
+                                        struct perf_probe_point *pp)
+{
+        pp->function = strdup(tp->symbol);
+        if (pp->function == NULL)
+                return -ENOMEM;
+        pp->offset = tp->offset;
+        pp->retprobe = tp->retprobe;
+
+        return 0;
+}
+
+static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
+                                struct kprobe_trace_event **tevs __unused,
+                                int max_tevs __unused)
+{
+        if (perf_probe_event_need_dwarf(pev)) {
+                pr_warning("Debuginfo-analysis is not supported.\n");
+                return -ENOSYS;
+        }
+        return 0;
+}
+
+int show_line_range(struct line_range *lr __unused)
+{
+        pr_warning("Debuginfo-analysis is not supported.\n");
+        return -ENOSYS;
+}
+
+#endif
+
+int parse_line_range_desc(const char *arg, struct line_range *lr)
 {
         const char *ptr;
         char *tmp;
@@ -75,29 +350,45 @@ void parse_line_range_desc(const char *arg, struct line_range *lr)
          */
         ptr = strchr(arg, ':');
         if (ptr) {
-                lr->start = (unsigned int)strtoul(ptr + 1, &tmp, 0);
-                if (*tmp == '+')
-                        lr->end = lr->start + (unsigned int)strtoul(tmp + 1,
-                                                                    &tmp, 0);
-                else if (*tmp == '-')
-                        lr->end = (unsigned int)strtoul(tmp + 1, &tmp, 0);
+                lr->start = (int)strtoul(ptr + 1, &tmp, 0);
+                if (*tmp == '+') {
+                        lr->end = lr->start + (int)strtoul(tmp + 1, &tmp, 0);
+                        lr->end--;      /*
+                                         * Adjust the number of lines here.
+                                         * If the number of lines == 1, the
+                                         * the end of line should be equal to
+                                         * the start of line.
+                                         */
+                } else if (*tmp == '-')
+                        lr->end = (int)strtoul(tmp + 1, &tmp, 0);
                 else
-                        lr->end = 0;
-                pr_debug("Line range is %u to %u\n", lr->start, lr->end);
-                if (lr->end && lr->start > lr->end)
+                        lr->end = INT_MAX;
+                pr_debug("Line range is %d to %d\n", lr->start, lr->end);
+                if (lr->start > lr->end) {
                         semantic_error("Start line must be smaller"
-                                       " than end line.");
-                if (*tmp != '\0')
-                        semantic_error("Tailing with invalid character '%d'.",
+                                       " than end line.\n");
+                        return -EINVAL;
+                }
+                if (*tmp != '\0') {
+                        semantic_error("Tailing with invalid character '%d'.\n",
                                        *tmp);
+                        return -EINVAL;
+                }
                 tmp = strndup(arg, (ptr - arg));
-        } else
+        } else {
                 tmp = strdup(arg);
+                lr->end = INT_MAX;
+        }
+
+        if (tmp == NULL)
+                return -ENOMEM;
 
         if (strchr(tmp, '.'))
                 lr->file = tmp;
         else
                 lr->function = tmp;
+
+        return 0;
 }
 
 /* Check the name is good for event/group */
@@ -113,8 +404,9 @@ static bool check_event_name(const char *name)
 }
 
 /* Parse probepoint definition. */
-static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
+static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 {
+        struct perf_probe_point *pp = &pev->point;
         char *ptr, *tmp;
         char c, nc = 0;
         /*
@@ -129,13 +421,19 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
         if (ptr && *ptr == '=') {       /* Event name */
                 *ptr = '\0';
                 tmp = ptr + 1;
-                ptr = strchr(arg, ':');
-                if (ptr)        /* Group name is not supported yet. */
-                        semantic_error("Group name is not supported yet.");
-                if (!check_event_name(arg))
+                if (strchr(arg, ':')) {
+                        semantic_error("Group name is not supported yet.\n");
+                        return -ENOTSUP;
+                }
+                if (!check_event_name(arg)) {
                         semantic_error("%s is bad for event name -it must "
-                                       "follow C symbol-naming rule.", arg);
-                pp->event = strdup(arg);
+                                       "follow C symbol-naming rule.\n", arg);
+                        return -EINVAL;
+                }
+                pev->event = strdup(arg);
+                if (pev->event == NULL)
+                        return -ENOMEM;
+                pev->group = NULL;
                 arg = tmp;
         }
 
@@ -145,12 +443,15 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
                 *ptr++ = '\0';
         }
 
+        tmp = strdup(arg);
+        if (tmp == NULL)
+                return -ENOMEM;
+
         /* Check arg is function or file and copy it */
-        if (strchr(arg, '.'))   /* File */
-                pp->file = strdup(arg);
+        if (strchr(tmp, '.'))   /* File */
+                pp->file = tmp;
         else                    /* Function */
-                pp->function = strdup(arg);
-        DIE_IF(pp->file == NULL && pp->function == NULL);
+                pp->function = tmp;
 
         /* Parse other options */
         while (ptr) {
@@ -158,6 +459,8 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
                 c = nc;
                 if (c == ';') { /* Lazy pattern must be the last part */
                         pp->lazy_line = strdup(arg);
+                        if (pp->lazy_line == NULL)
+                                return -ENOMEM;
                         break;
                 }
                 ptr = strpbrk(arg, ";:+@%");
@@ -168,266 +471,658 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
                 switch (c) {
                 case ':':       /* Line number */
                         pp->line = strtoul(arg, &tmp, 0);
-                        if (*tmp != '\0')
+                        if (*tmp != '\0') {
                                 semantic_error("There is non-digit char"
-                                               " in line number.");
+                                               " in line number.\n");
+                                return -EINVAL;
+                        }
                         break;
                 case '+':       /* Byte offset from a symbol */
                         pp->offset = strtoul(arg, &tmp, 0);
-                        if (*tmp != '\0')
+                        if (*tmp != '\0') {
                                 semantic_error("There is non-digit character"
-                                                " in offset.");
+                                                " in offset.\n");
+                                return -EINVAL;
+                        }
                         break;
                 case '@':       /* File name */
-                        if (pp->file)
-                                semantic_error("SRC@SRC is not allowed.");
+                        if (pp->file) {
+                                semantic_error("SRC@SRC is not allowed.\n");
+                                return -EINVAL;
+                        }
                         pp->file = strdup(arg);
-                        DIE_IF(pp->file == NULL);
+                        if (pp->file == NULL)
+                                return -ENOMEM;
                         break;
                 case '%':       /* Probe places */
                         if (strcmp(arg, "return") == 0) {
                                 pp->retprobe = 1;
-                        } else  /* Others not supported yet */
-                                semantic_error("%%%s is not supported.", arg);
+                        } else {        /* Others not supported yet */
+                                semantic_error("%%%s is not supported.\n", arg);
+                                return -ENOTSUP;
+                        }
                         break;
-                default:
-                        DIE_IF("Program has a bug.");
+                default:        /* Buggy case */
+                        pr_err("This program has a bug at %s:%d.\n",
+                                __FILE__, __LINE__);
+                        return -ENOTSUP;
                         break;
                 }
         }
 
         /* Exclusion check */
-        if (pp->lazy_line && pp->line)
+        if (pp->lazy_line && pp->line) {
                 semantic_error("Lazy pattern can't be used with line number.");
+                return -EINVAL;
+        }
 
-        if (pp->lazy_line && pp->offset)
+        if (pp->lazy_line && pp->offset) {
                 semantic_error("Lazy pattern can't be used with offset.");
+                return -EINVAL;
+        }
 
-        if (pp->line && pp->offset)
+        if (pp->line && pp->offset) {
                 semantic_error("Offset can't be used with line number.");
+                return -EINVAL;
+        }
 
-        if (!pp->line && !pp->lazy_line && pp->file && !pp->function)
+        if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
                 semantic_error("File always requires line number or "
                                "lazy pattern.");
+                return -EINVAL;
+        }
 
-        if (pp->offset && !pp->function)
+        if (pp->offset && !pp->function) {
                 semantic_error("Offset requires an entry function.");
+                return -EINVAL;
+        }
 
-        if (pp->retprobe && !pp->function)
+        if (pp->retprobe && !pp->function) {
                 semantic_error("Return probe requires an entry function.");
+                return -EINVAL;
+        }
 
-        if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe)
+        if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
                 semantic_error("Offset/Line/Lazy pattern can't be used with "
                                "return probe.");
+                return -EINVAL;
+        }
 
-        pr_debug("symbol:%s file:%s line:%d offset:%d return:%d lazy:%s\n",
+        pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
                  pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
                  pp->lazy_line);
+        return 0;
 }
 
-/* Parse perf-probe event definition */
-void parse_perf_probe_event(const char *str, struct probe_point *pp,
-                            bool *need_dwarf)
+/* Parse perf-probe event argument */
+static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
 {
-        char **argv;
-        int argc, i;
+        char *tmp;
+        struct perf_probe_arg_field **fieldp;
+
+        pr_debug("parsing arg: %s into ", str);
 
-        *need_dwarf = false;
+        tmp = strchr(str, '=');
+        if (tmp) {
+                arg->name = strndup(str, tmp - str);
+                if (arg->name == NULL)
+                        return -ENOMEM;
+                pr_debug("name:%s ", arg->name);
+                str = tmp + 1;
+        }
 
-        argv = argv_split(str, &argc);
-        if (!argv)
-                die("argv_split failed.");
-        if (argc > MAX_PROBE_ARGS + 1)
-                semantic_error("Too many arguments");
+        tmp = strchr(str, ':');
+        if (tmp) {      /* Type setting */
+                *tmp = '\0';
+                arg->type = strdup(tmp + 1);
+                if (arg->type == NULL)
+                        return -ENOMEM;
+                pr_debug("type:%s ", arg->type);
+        }
 
+        tmp = strpbrk(str, "-.");
+        if (!is_c_varname(str) || !tmp) {
+                /* A variable, register, symbol or special value */
+                arg->var = strdup(str);
+                if (arg->var == NULL)
+                        return -ENOMEM;
+                pr_debug("%s\n", arg->var);
+                return 0;
+        }
+
+        /* Structure fields */
+        arg->var = strndup(str, tmp - str);
+        if (arg->var == NULL)
+                return -ENOMEM;
+        pr_debug("%s, ", arg->var);
+        fieldp = &arg->field;
+
+        do {
+                *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
+                if (*fieldp == NULL)
+                        return -ENOMEM;
+                if (*tmp == '.') {
+                        str = tmp + 1;
+                        (*fieldp)->ref = false;
+                } else if (tmp[1] == '>') {
+                        str = tmp + 2;
+                        (*fieldp)->ref = true;
+                } else {
+                        semantic_error("Argument parse error: %s\n", str);
+                        return -EINVAL;
+                }
+
+                tmp = strpbrk(str, "-.");
+                if (tmp) {
+                        (*fieldp)->name = strndup(str, tmp - str);
+                        if ((*fieldp)->name == NULL)
+                                return -ENOMEM;
+                        pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
+                        fieldp = &(*fieldp)->next;
+                }
+        } while (tmp);
+        (*fieldp)->name = strdup(str);
+        if ((*fieldp)->name == NULL)
+                return -ENOMEM;
+        pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
+
+        /* If no name is specified, set the last field name */
+        if (!arg->name) {
+                arg->name = strdup((*fieldp)->name);
+                if (arg->name == NULL)
+                        return -ENOMEM;
+        }
+        return 0;
+}
+
+/* Parse perf-probe event command */
+int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
+{
+        char **argv;
+        int argc, i, ret = 0;
+
+        argv = argv_split(cmd, &argc);
+        if (!argv) {
+                pr_debug("Failed to split arguments.\n");
+                return -ENOMEM;
+        }
+        if (argc - 1 > MAX_PROBE_ARGS) {
+                semantic_error("Too many probe arguments (%d).\n", argc - 1);
+                ret = -ERANGE;
+                goto out;
+        }
         /* Parse probe point */
-        parse_perf_probe_probepoint(argv[0], pp);
-        if (pp->file || pp->line || pp->lazy_line)
-                *need_dwarf = true;
+        ret = parse_perf_probe_point(argv[0], pev);
+        if (ret < 0)
+                goto out;
 
         /* Copy arguments and ensure return probe has no C argument */
-        pp->nr_args = argc - 1;
-        pp->args = zalloc(sizeof(char *) * pp->nr_args);
-        for (i = 0; i < pp->nr_args; i++) {
-                pp->args[i] = strdup(argv[i + 1]);
-                if (!pp->args[i])
-                        die("Failed to copy argument.");
-                if (is_c_varname(pp->args[i])) {
-                        if (pp->retprobe)
-                                semantic_error("You can't specify local"
-                                                " variable for kretprobe");
-                        *need_dwarf = true;
+        pev->nargs = argc - 1;
+        pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
+        if (pev->args == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        for (i = 0; i < pev->nargs && ret >= 0; i++) {
+                ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
+                if (ret >= 0 &&
+                    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
+                        semantic_error("You can't specify local variable for"
+                                       " kretprobe.\n");
+                        ret = -EINVAL;
                 }
         }
-
+out:
         argv_free(argv);
+
+        return ret;
+}
+
+/* Return true if this perf_probe_event requires debuginfo */
+bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
+{
+        int i;
+
+        if (pev->point.file || pev->point.line || pev->point.lazy_line)
+                return true;
+
+        for (i = 0; i < pev->nargs; i++)
+                if (is_c_varname(pev->args[i].var))
+                        return true;
+
+        return false;
 }
 
 /* Parse kprobe_events event into struct probe_point */
-void parse_trace_kprobe_event(const char *str, struct probe_point *pp)
+int parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev)
 {
+        struct kprobe_trace_point *tp = &tev->point;
         char pr;
         char *p;
         int ret, i, argc;
         char **argv;
 
-        pr_debug("Parsing kprobe_events: %s\n", str);
-        argv = argv_split(str, &argc);
-        if (!argv)
-                die("argv_split failed.");
-        if (argc < 2)
-                semantic_error("Too less arguments.");
+        pr_debug("Parsing kprobe_events: %s\n", cmd);
+        argv = argv_split(cmd, &argc);
+        if (!argv) {
+                pr_debug("Failed to split arguments.\n");
+                return -ENOMEM;
+        }
+        if (argc < 2) {
+                semantic_error("Too few probe arguments.\n");
+                ret = -ERANGE;
+                goto out;
+        }
 
         /* Scan event and group name. */
         ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
-                     &pr, (float *)(void *)&pp->group,
-                     (float *)(void *)&pp->event);
-        if (ret != 3)
-                semantic_error("Failed to parse event name: %s", argv[0]);
-        pr_debug("Group:%s Event:%s probe:%c\n", pp->group, pp->event, pr);
+                     &pr, (float *)(void *)&tev->group,
+                     (float *)(void *)&tev->event);
+        if (ret != 3) {
+                semantic_error("Failed to parse event name: %s\n", argv[0]);
+                ret = -EINVAL;
+                goto out;
+        }
+        pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 
-        pp->retprobe = (pr == 'r');
+        tp->retprobe = (pr == 'r');
 
         /* Scan function name and offset */
-        ret = sscanf(argv[1], "%a[^+]+%d", (float *)(void *)&pp->function,
-                     &pp->offset);
+        ret = sscanf(argv[1], "%a[^+]+%lu", (float *)(void *)&tp->symbol,
+                     &tp->offset);
         if (ret == 1)
-                pp->offset = 0;
-
-        /* kprobe_events doesn't have this information */
-        pp->line = 0;
-        pp->file = NULL;
+                tp->offset = 0;
 
-        pp->nr_args = argc - 2;
-        pp->args = zalloc(sizeof(char *) * pp->nr_args);
-        for (i = 0; i < pp->nr_args; i++) {
+        tev->nargs = argc - 2;
+        tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
+        if (tev->args == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        for (i = 0; i < tev->nargs; i++) {
                 p = strchr(argv[i + 2], '=');
                 if (p)  /* We don't need which register is assigned. */
-                        *p = '\0';
-                pp->args[i] = strdup(argv[i + 2]);
-                if (!pp->args[i])
-                        die("Failed to copy argument.");
+                        *p++ = '\0';
+                else
+                        p = argv[i + 2];
+                tev->args[i].name = strdup(argv[i + 2]);
+                /* TODO: parse regs and offset */
+                tev->args[i].value = strdup(p);
+                if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
         }
-
+        ret = 0;
+out:
         argv_free(argv);
+        return ret;
 }
 
-/* Synthesize only probe point (not argument) */
-int synthesize_perf_probe_point(struct probe_point *pp)
+/* Compose only probe arg */
+int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
 {
-        char *buf;
-        char offs[64] = "", line[64] = "";
+        struct perf_probe_arg_field *field = pa->field;
         int ret;
+        char *tmp = buf;
 
-        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
-        pp->found = 1;
-        if (!buf)
-                die("Failed to allocate memory by zalloc.");
+        if (pa->name && pa->var)
+                ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
+        else
+                ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
+        if (ret <= 0)
+                goto error;
+        tmp += ret;
+        len -= ret;
+
+        while (field) {
+                ret = e_snprintf(tmp, len, "%s%s", field->ref ? "->" : ".",
+                                 field->name);
+                if (ret <= 0)
+                        goto error;
+                tmp += ret;
+                len -= ret;
+                field = field->next;
+        }
+
+        if (pa->type) {
+                ret = e_snprintf(tmp, len, ":%s", pa->type);
+                if (ret <= 0)
+                        goto error;
+                tmp += ret;
+                len -= ret;
+        }
+
+        return tmp - buf;
+error:
+        pr_debug("Failed to synthesize perf probe argument: %s",
+                 strerror(-ret));
+        return ret;
+}
+
+/* Compose only probe point (not argument) */
+static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
+{
+        char *buf, *tmp;
+        char offs[32] = "", line[32] = "", file[32] = "";
+        int ret, len;
+
+        buf = zalloc(MAX_CMDLEN);
+        if (buf == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
         if (pp->offset) {
-                ret = e_snprintf(offs, 64, "+%d", pp->offset);
+                ret = e_snprintf(offs, 32, "+%lu", pp->offset);
                 if (ret <= 0)
                         goto error;
         }
         if (pp->line) {
-                ret = e_snprintf(line, 64, ":%d", pp->line);
+                ret = e_snprintf(line, 32, ":%d", pp->line);
+                if (ret <= 0)
+                        goto error;
+        }
+        if (pp->file) {
+                len = strlen(pp->file) - 31;
+                if (len < 0)
+                        len = 0;
+                tmp = strchr(pp->file + len, '/');
+                if (!tmp)
+                        tmp = pp->file + len;
+                ret = e_snprintf(file, 32, "@%s", tmp + 1);
                 if (ret <= 0)
                         goto error;
         }
 
         if (pp->function)
-                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s", pp->function,
-                                 offs, pp->retprobe ? "%return" : "", line);
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
+                                 offs, pp->retprobe ? "%return" : "", line,
+                                 file);
         else
-                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", pp->file, line);
-        if (ret <= 0) {
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
+        if (ret <= 0)
+                goto error;
+
+        return buf;
 error:
-                free(pp->probes[0]);
-                pp->probes[0] = NULL;
-                pp->found = 0;
-        }
-        return ret;
+        pr_debug("Failed to synthesize perf probe point: %s",
+                 strerror(-ret));
+        if (buf)
+                free(buf);
+        return NULL;
 }
 
-int synthesize_perf_probe_event(struct probe_point *pp)
+#if 0
+char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 {
         char *buf;
         int i, len, ret;
 
-        len = synthesize_perf_probe_point(pp);
-        if (len < 0)
-                return 0;
+        buf = synthesize_perf_probe_point(&pev->point);
+        if (!buf)
+                return NULL;
 
-        buf = pp->probes[0];
-        for (i = 0; i < pp->nr_args; i++) {
+        len = strlen(buf);
+        for (i = 0; i < pev->nargs; i++) {
                 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
-                                 pp->args[i]);
-                if (ret <= 0)
-                        goto error;
+                                 pev->args[i].name);
+                if (ret <= 0) {
+                        free(buf);
+                        return NULL;
+                }
                 len += ret;
         }
-        pp->found = 1;
 
-        return pp->found;
-error:
-        free(pp->probes[0]);
-        pp->probes[0] = NULL;
+        return buf;
+}
+#endif
+
+static int __synthesize_kprobe_trace_arg_ref(struct kprobe_trace_arg_ref *ref,
+                                             char **buf, size_t *buflen,
+                                             int depth)
+{
+        int ret;
+        if (ref->next) {
+                depth = __synthesize_kprobe_trace_arg_ref(ref->next, buf,
+                                                         buflen, depth + 1);
+                if (depth < 0)
+                        goto out;
+        }
+
+        ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
+        if (ret < 0)
+                depth = ret;
+        else {
+                *buf += ret;
+                *buflen -= ret;
+        }
+out:
+        return depth;
 
-        return ret;
 }
 
-int synthesize_trace_kprobe_event(struct probe_point *pp)
+static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg,
+                                       char *buf, size_t buflen)
 {
+        int ret, depth = 0;
+        char *tmp = buf;
+
+        /* Argument name or separator */
+        if (arg->name)
+                ret = e_snprintf(buf, buflen, " %s=", arg->name);
+        else
+                ret = e_snprintf(buf, buflen, " ");
+        if (ret < 0)
+                return ret;
+        buf += ret;
+        buflen -= ret;
+
+        /* Dereferencing arguments */
+        if (arg->ref) {
+                depth = __synthesize_kprobe_trace_arg_ref(arg->ref, &buf,
+                                                          &buflen, 1);
+                if (depth < 0)
+                        return depth;
+        }
+
+        /* Print argument value */
+        ret = e_snprintf(buf, buflen, "%s", arg->value);
+        if (ret < 0)
+                return ret;
+        buf += ret;
+        buflen -= ret;
+
+        /* Closing */
+        while (depth--) {
+                ret = e_snprintf(buf, buflen, ")");
+                if (ret < 0)
+                        return ret;
+                buf += ret;
+                buflen -= ret;
+        }
+        /* Print argument type */
+        if (arg->type) {
+                ret = e_snprintf(buf, buflen, ":%s", arg->type);
+                if (ret <= 0)
+                        return ret;
+                buf += ret;
+        }
+
+        return buf - tmp;
+}
+
+char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev)
+{
+        struct kprobe_trace_point *tp = &tev->point;
         char *buf;
         int i, len, ret;
 
-        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
-        if (!buf)
-                die("Failed to allocate memory by zalloc.");
-        ret = e_snprintf(buf, MAX_CMDLEN, "%s+%d", pp->function, pp->offset);
-        if (ret <= 0)
+        buf = zalloc(MAX_CMDLEN);
+        if (buf == NULL)
+                return NULL;
+
+        len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s+%lu",
+                         tp->retprobe ? 'r' : 'p',
+                         tev->group, tev->event,
+                         tp->symbol, tp->offset);
+        if (len <= 0)
                 goto error;
-        len = ret;
 
-        for (i = 0; i < pp->nr_args; i++) {
-                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
-                                 pp->args[i]);
+        for (i = 0; i < tev->nargs; i++) {
+                ret = synthesize_kprobe_trace_arg(&tev->args[i], buf + len,
+                                                  MAX_CMDLEN - len);
                 if (ret <= 0)
                         goto error;
                 len += ret;
         }
-        pp->found = 1;
 
-        return pp->found;
+        return buf;
 error:
-        free(pp->probes[0]);
-        pp->probes[0] = NULL;
+        free(buf);
+        return NULL;
+}
+
+int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
+                                struct perf_probe_event *pev)
+{
+        char buf[64] = "";
+        int i, ret;
+
+        /* Convert event/group name */
+        pev->event = strdup(tev->event);
+        pev->group = strdup(tev->group);
+        if (pev->event == NULL || pev->group == NULL)
+                return -ENOMEM;
+
+        /* Convert trace_point to probe_point */
+        ret = convert_to_perf_probe_point(&tev->point, &pev->point);
+        if (ret < 0)
+                return ret;
+
+        /* Convert trace_arg to probe_arg */
+        pev->nargs = tev->nargs;
+        pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
+        if (pev->args == NULL)
+                return -ENOMEM;
+        for (i = 0; i < tev->nargs && ret >= 0; i++) {
+                if (tev->args[i].name)
+                        pev->args[i].name = strdup(tev->args[i].name);
+                else {
+                        ret = synthesize_kprobe_trace_arg(&tev->args[i],
+                                                          buf, 64);
+                        pev->args[i].name = strdup(buf);
+                }
+                if (pev->args[i].name == NULL && ret >= 0)
+                        ret = -ENOMEM;
+        }
+
+        if (ret < 0)
+                clear_perf_probe_event(pev);
 
         return ret;
 }
 
-static int open_kprobe_events(int flags, int mode)
+void clear_perf_probe_event(struct perf_probe_event *pev)
+{
+        struct perf_probe_point *pp = &pev->point;
+        struct perf_probe_arg_field *field, *next;
+        int i;
+
+        if (pev->event)
+                free(pev->event);
+        if (pev->group)
+                free(pev->group);
+        if (pp->file)
+                free(pp->file);
+        if (pp->function)
+                free(pp->function);
+        if (pp->lazy_line)
+                free(pp->lazy_line);
+        for (i = 0; i < pev->nargs; i++) {
+                if (pev->args[i].name)
+                        free(pev->args[i].name);
+                if (pev->args[i].var)
+                        free(pev->args[i].var);
+                if (pev->args[i].type)
+                        free(pev->args[i].type);
+                field = pev->args[i].field;
+                while (field) {
+                        next = field->next;
+                        if (field->name)
+                                free(field->name);
+                        free(field);
+                        field = next;
+                }
+        }
+        if (pev->args)
+                free(pev->args);
+        memset(pev, 0, sizeof(*pev));
+}
+
+void clear_kprobe_trace_event(struct kprobe_trace_event *tev)
+{
+        struct kprobe_trace_arg_ref *ref, *next;
+        int i;
+
+        if (tev->event)
+                free(tev->event);
+        if (tev->group)
+                free(tev->group);
+        if (tev->point.symbol)
+                free(tev->point.symbol);
+        for (i = 0; i < tev->nargs; i++) {
+                if (tev->args[i].name)
+                        free(tev->args[i].name);
+                if (tev->args[i].value)
+                        free(tev->args[i].value);
+                if (tev->args[i].type)
+                        free(tev->args[i].type);
+                ref = tev->args[i].ref;
+                while (ref) {
+                        next = ref->next;
+                        free(ref);
+                        ref = next;
+                }
+        }
+        if (tev->args)
+                free(tev->args);
+        memset(tev, 0, sizeof(*tev));
+}
+
+static int open_kprobe_events(bool readwrite)
 {
         char buf[PATH_MAX];
+        const char *__debugfs;
         int ret;
 
-        ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path);
-        if (ret < 0)
-                die("Failed to make kprobe_events path.");
+        __debugfs = debugfs_find_mountpoint();
+        if (__debugfs == NULL) {
+                pr_warning("Debugfs is not mounted.\n");
+                return -ENOENT;
+        }
+
+        ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
+        if (ret >= 0) {
+                pr_debug("Opening %s write=%d\n", buf, readwrite);
+                if (readwrite && !probe_event_dry_run)
+                        ret = open(buf, O_RDWR, O_APPEND);
+                else
+                        ret = open(buf, O_RDONLY, 0);
+        }
 
-        ret = open(buf, flags, mode);
         if (ret < 0) {
                 if (errno == ENOENT)
-                        die("kprobe_events file does not exist -"
-                            " please rebuild with CONFIG_KPROBE_EVENT.");
+                        pr_warning("kprobe_events file does not exist - please"
+                                 " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
                 else
-                        die("Could not open kprobe_events file: %s",
-                            strerror(errno));
+                        pr_warning("Failed to open kprobe_events file: %s\n",
+                                   strerror(errno));
         }
         return ret;
 }
 
 /* Get raw string list of current kprobe_events */
-static struct strlist *get_trace_kprobe_event_rawlist(int fd)
+static struct strlist *get_kprobe_trace_command_rawlist(int fd)
 {
         int ret, idx;
         FILE *fp;
@@ -447,271 +1142,486 @@ static struct strlist *get_trace_kprobe_event_rawlist(int fd)
                 if (p[idx] == '\n')
                         p[idx] = '\0';
                 ret = strlist__add(sl, buf);
-                if (ret < 0)
-                        die("strlist__add failed: %s", strerror(-ret));
+                if (ret < 0) {
+                        pr_debug("strlist__add failed: %s\n", strerror(-ret));
+                        strlist__delete(sl);
+                        return NULL;
+                }
         }
         fclose(fp);
 
         return sl;
 }
 
-/* Free and zero clear probe_point */
-static void clear_probe_point(struct probe_point *pp)
-{
-        int i;
-
-        if (pp->event)
-                free(pp->event);
-        if (pp->group)
-                free(pp->group);
-        if (pp->function)
-                free(pp->function);
-        if (pp->file)
-                free(pp->file);
-        if (pp->lazy_line)
-                free(pp->lazy_line);
-        for (i = 0; i < pp->nr_args; i++)
-                free(pp->args[i]);
-        if (pp->args)
-                free(pp->args);
-        for (i = 0; i < pp->found; i++)
-                free(pp->probes[i]);
-        memset(pp, 0, sizeof(*pp));
-}
-
 /* Show an event */
-static void show_perf_probe_event(const char *event, const char *place,
-                                  struct probe_point *pp)
+static int show_perf_probe_event(struct perf_probe_event *pev)
 {
         int i, ret;
         char buf[128];
+        char *place;
+
+        /* Synthesize only event probe point */
+        place = synthesize_perf_probe_point(&pev->point);
+        if (!place)
+                return -EINVAL;
 
-        ret = e_snprintf(buf, 128, "%s:%s", pp->group, event);
+        ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
         if (ret < 0)
-                die("Failed to copy event: %s", strerror(-ret));
-        printf("  %-40s (on %s", buf, place);
+                return ret;
+
+        printf("  %-20s (on %s", buf, place);
 
-        if (pp->nr_args > 0) {
+        if (pev->nargs > 0) {
                 printf(" with");
-                for (i = 0; i < pp->nr_args; i++)
-                        printf(" %s", pp->args[i]);
+                for (i = 0; i < pev->nargs; i++) {
+                        ret = synthesize_perf_probe_arg(&pev->args[i],
+                                                        buf, 128);
+                        if (ret < 0)
+                                break;
+                        printf(" %s", buf);
+                }
         }
         printf(")\n");
+        free(place);
+        return ret;
 }
 
 /* List up current perf-probe events */
-void show_perf_probe_events(void)
+int show_perf_probe_events(void)
 {
-        int fd;
-        struct probe_point pp;
+        int fd, ret;
+        struct kprobe_trace_event tev;
+        struct perf_probe_event pev;
         struct strlist *rawlist;
         struct str_node *ent;
 
         setup_pager();
-        memset(&pp, 0, sizeof(pp));
+        ret = init_vmlinux();
+        if (ret < 0)
+                return ret;
+
+        memset(&tev, 0, sizeof(tev));
+        memset(&pev, 0, sizeof(pev));
 
-        fd = open_kprobe_events(O_RDONLY, 0);
-        rawlist = get_trace_kprobe_event_rawlist(fd);
+        fd = open_kprobe_events(false);
+        if (fd < 0)
+                return fd;
+
+        rawlist = get_kprobe_trace_command_rawlist(fd);
         close(fd);
+        if (!rawlist)
+                return -ENOENT;
 
         strlist__for_each(ent, rawlist) {
-                parse_trace_kprobe_event(ent->s, &pp);
-                /* Synthesize only event probe point */
-                synthesize_perf_probe_point(&pp);
-                /* Show an event */
-                show_perf_probe_event(pp.event, pp.probes[0], &pp);
-                clear_probe_point(&pp);
+                ret = parse_kprobe_trace_command(ent->s, &tev);
+                if (ret >= 0) {
+                        ret = convert_to_perf_probe_event(&tev, &pev);
+                        if (ret >= 0)
+                                ret = show_perf_probe_event(&pev);
+                }
+                clear_perf_probe_event(&pev);
+                clear_kprobe_trace_event(&tev);
+                if (ret < 0)
+                        break;
         }
-
         strlist__delete(rawlist);
+
+        return ret;
 }
 
 /* Get current perf-probe event names */
-static struct strlist *get_perf_event_names(int fd, bool include_group)
+static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group)
 {
         char buf[128];
         struct strlist *sl, *rawlist;
         struct str_node *ent;
-        struct probe_point pp;
+        struct kprobe_trace_event tev;
+        int ret = 0;
 
-        memset(&pp, 0, sizeof(pp));
-        rawlist = get_trace_kprobe_event_rawlist(fd);
+        memset(&tev, 0, sizeof(tev));
 
+        rawlist = get_kprobe_trace_command_rawlist(fd);
         sl = strlist__new(true, NULL);
         strlist__for_each(ent, rawlist) {
-                parse_trace_kprobe_event(ent->s, &pp);
+                ret = parse_kprobe_trace_command(ent->s, &tev);
+                if (ret < 0)
+                        break;
                 if (include_group) {
-                        if (e_snprintf(buf, 128, "%s:%s", pp.group,
-                                       pp.event) < 0)
-                                die("Failed to copy group:event name.");
-                        strlist__add(sl, buf);
+                        ret = e_snprintf(buf, 128, "%s:%s", tev.group,
+                                        tev.event);
+                        if (ret >= 0)
+                                ret = strlist__add(sl, buf);
                 } else
-                        strlist__add(sl, pp.event);
-                clear_probe_point(&pp);
+                        ret = strlist__add(sl, tev.event);
+                clear_kprobe_trace_event(&tev);
+                if (ret < 0)
+                        break;
         }
-
         strlist__delete(rawlist);
 
+        if (ret < 0) {
+                strlist__delete(sl);
+                return NULL;
+        }
         return sl;
 }
 
-static void write_trace_kprobe_event(int fd, const char *buf)
+static int write_kprobe_trace_event(int fd, struct kprobe_trace_event *tev)
 {
-        int ret;
+        int ret = 0;
+        char *buf = synthesize_kprobe_trace_command(tev);
+
+        if (!buf) {
+                pr_debug("Failed to synthesize kprobe trace event.\n");
+                return -EINVAL;
+        }
 
         pr_debug("Writing event: %s\n", buf);
-        ret = write(fd, buf, strlen(buf));
-        if (ret <= 0)
-                die("Failed to write event: %s", strerror(errno));
+        if (!probe_event_dry_run) {
+                ret = write(fd, buf, strlen(buf));
+                if (ret <= 0)
+                        pr_warning("Failed to write event: %s\n",
+                                   strerror(errno));
+        }
+        free(buf);
+        return ret;
 }
 
-static void get_new_event_name(char *buf, size_t len, const char *base,
-                               struct strlist *namelist, bool allow_suffix)
+static int get_new_event_name(char *buf, size_t len, const char *base,
+                              struct strlist *namelist, bool allow_suffix)
 {
         int i, ret;
 
         /* Try no suffix */
         ret = e_snprintf(buf, len, "%s", base);
-        if (ret < 0)
-                die("snprintf() failed: %s", strerror(-ret));
+        if (ret < 0) {
+                pr_debug("snprintf() failed: %s\n", strerror(-ret));
+                return ret;
+        }
         if (!strlist__has_entry(namelist, buf))
-                return;
+                return 0;
 
         if (!allow_suffix) {
                 pr_warning("Error: event \"%s\" already exists. "
                            "(Use -f to force duplicates.)\n", base);
-                die("Can't add new event.");
+                return -EEXIST;
         }
 
         /* Try to add suffix */
         for (i = 1; i < MAX_EVENT_INDEX; i++) {
                 ret = e_snprintf(buf, len, "%s_%d", base, i);
-                if (ret < 0)
-                        die("snprintf() failed: %s", strerror(-ret));
+                if (ret < 0) {
+                        pr_debug("snprintf() failed: %s\n", strerror(-ret));
+                        return ret;
+                }
                 if (!strlist__has_entry(namelist, buf))
                         break;
         }
-        if (i == MAX_EVENT_INDEX)
-                die("Too many events are on the same function.");
+        if (i == MAX_EVENT_INDEX) {
+                pr_warning("Too many events are on the same function.\n");
+                ret = -ERANGE;
+        }
+
+        return ret;
 }
 
-void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
-                             bool force_add)
+static int __add_kprobe_trace_events(struct perf_probe_event *pev,
+                                     struct kprobe_trace_event *tevs,
+                                     int ntevs, bool allow_suffix)
 {
-        int i, j, fd;
-        struct probe_point *pp;
-        char buf[MAX_CMDLEN];
-        char event[64];
+        int i, fd, ret;
+        struct kprobe_trace_event *tev = NULL;
+        char buf[64];
+        const char *event, *group;
         struct strlist *namelist;
-        bool allow_suffix;
 
-        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        fd = open_kprobe_events(true);
+        if (fd < 0)
+                return fd;
         /* Get current event names */
-        namelist = get_perf_event_names(fd, false);
-
-        for (j = 0; j < nr_probes; j++) {
-                pp = probes + j;
-                if (!pp->event)
-                        pp->event = strdup(pp->function);
-                if (!pp->group)
-                        pp->group = strdup(PERFPROBE_GROUP);
-                DIE_IF(!pp->event || !pp->group);
-                /* If force_add is true, suffix search is allowed */
-                allow_suffix = force_add;
-                for (i = 0; i < pp->found; i++) {
-                        /* Get an unused new event name */
-                        get_new_event_name(event, 64, pp->event, namelist,
-                                           allow_suffix);
-                        snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s\n",
-                                 pp->retprobe ? 'r' : 'p',
-                                 pp->group, event,
-                                 pp->probes[i]);
-                        write_trace_kprobe_event(fd, buf);
-                        printf("Added new event:\n");
-                        /* Get the first parameter (probe-point) */
-                        sscanf(pp->probes[i], "%s", buf);
-                        show_perf_probe_event(event, buf, pp);
-                        /* Add added event name to namelist */
-                        strlist__add(namelist, event);
-                        /*
-                         * Probes after the first probe which comes from same
-                         * user input are always allowed to add suffix, because
-                         * there might be several addresses corresponding to
-                         * one code line.
-                         */
-                        allow_suffix = true;
+        namelist = get_kprobe_trace_event_names(fd, false);
+        if (!namelist) {
+                pr_debug("Failed to get current event list.\n");
+                return -EIO;
+        }
+
+        ret = 0;
+        printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
+        for (i = 0; i < ntevs; i++) {
+                tev = &tevs[i];
+                if (pev->event)
+                        event = pev->event;
+                else
+                        if (pev->point.function)
+                                event = pev->point.function;
+                        else
+                                event = tev->point.symbol;
+                if (pev->group)
+                        group = pev->group;
+                else
+                        group = PERFPROBE_GROUP;
+
+                /* Get an unused new event name */
+                ret = get_new_event_name(buf, 64, event,
+                                         namelist, allow_suffix);
+                if (ret < 0)
+                        break;
+                event = buf;
+
+                tev->event = strdup(event);
+                tev->group = strdup(group);
+                if (tev->event == NULL || tev->group == NULL) {
+                        ret = -ENOMEM;
+                        break;
                 }
+                ret = write_kprobe_trace_event(fd, tev);
+                if (ret < 0)
+                        break;
+                /* Add added event name to namelist */
+                strlist__add(namelist, event);
+
+                /* Trick here - save current event/group */
+                event = pev->event;
+                group = pev->group;
+                pev->event = tev->event;
+                pev->group = tev->group;
+                show_perf_probe_event(pev);
+                /* Trick here - restore current event/group */
+                pev->event = (char *)event;
+                pev->group = (char *)group;
+
+                /*
+                 * Probes after the first probe which comes from same
+                 * user input are always allowed to add suffix, because
+                 * there might be several addresses corresponding to
+                 * one code line.
+                 */
+                allow_suffix = true;
+        }
+
+        if (ret >= 0) {
+                /* Show how to use the event. */
+                printf("\nYou can now use it on all perf tools, such as:\n\n");
+                printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
+                         tev->event);
         }
-        /* Show how to use the event. */
-        printf("\nYou can now use it on all perf tools, such as:\n\n");
-        printf("\tperf record -e %s:%s -a sleep 1\n\n", PERFPROBE_GROUP, event);
 
         strlist__delete(namelist);
         close(fd);
+        return ret;
+}
+
+static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
+                                          struct kprobe_trace_event **tevs,
+                                          int max_tevs)
+{
+        struct symbol *sym;
+        int ret = 0, i;
+        struct kprobe_trace_event *tev;
+
+        /* Convert perf_probe_event with debuginfo */
+        ret = try_to_find_kprobe_trace_events(pev, tevs, max_tevs);
+        if (ret != 0)
+                return ret;
+
+        /* Allocate trace event buffer */
+        tev = *tevs = zalloc(sizeof(struct kprobe_trace_event));
+        if (tev == NULL)
+                return -ENOMEM;
+
+        /* Copy parameters */
+        tev->point.symbol = strdup(pev->point.function);
+        if (tev->point.symbol == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
+        tev->point.offset = pev->point.offset;
+        tev->nargs = pev->nargs;
+        if (tev->nargs) {
+                tev->args = zalloc(sizeof(struct kprobe_trace_arg)
+                                   * tev->nargs);
+                if (tev->args == NULL) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+                for (i = 0; i < tev->nargs; i++) {
+                        if (pev->args[i].name) {
+                                tev->args[i].name = strdup(pev->args[i].name);
+                                if (tev->args[i].name == NULL) {
+                                        ret = -ENOMEM;
+                                        goto error;
+                                }
+                        }
+                        tev->args[i].value = strdup(pev->args[i].var);
+                        if (tev->args[i].value == NULL) {
+                                ret = -ENOMEM;
+                                goto error;
+                        }
+                        if (pev->args[i].type) {
+                                tev->args[i].type = strdup(pev->args[i].type);
+                                if (tev->args[i].type == NULL) {
+                                        ret = -ENOMEM;
+                                        goto error;
+                                }
+                        }
+                }
+        }
+
+        /* Currently just checking function name from symbol map */
+        sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION],
+                                       tev->point.symbol, NULL);
+        if (!sym) {
+                pr_warning("Kernel symbol \'%s\' not found.\n",
+                           tev->point.symbol);
+                ret = -ENOENT;
+                goto error;
+        }
+
+        return 1;
+error:
+        clear_kprobe_trace_event(tev);
+        free(tev);
+        *tevs = NULL;
+        return ret;
+}
+
+struct __event_package {
+        struct perf_probe_event         *pev;
+        struct kprobe_trace_event       *tevs;
+        int                             ntevs;
+};
+
+int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
+                          bool force_add, int max_tevs)
+{
+        int i, j, ret;
+        struct __event_package *pkgs;
+
+        pkgs = zalloc(sizeof(struct __event_package) * npevs);
+        if (pkgs == NULL)
+                return -ENOMEM;
+
+        /* Init vmlinux path */
+        ret = init_vmlinux();
+        if (ret < 0)
+                return ret;
+
+        /* Loop 1: convert all events */
+        for (i = 0; i < npevs; i++) {
+                pkgs[i].pev = &pevs[i];
+                /* Convert with or without debuginfo */
+                ret  = convert_to_kprobe_trace_events(pkgs[i].pev,
+                                                      &pkgs[i].tevs, max_tevs);
+                if (ret < 0)
+                        goto end;
+                pkgs[i].ntevs = ret;
+        }
+
+        /* Loop 2: add all events */
+        for (i = 0; i < npevs && ret >= 0; i++)
+                ret = __add_kprobe_trace_events(pkgs[i].pev, pkgs[i].tevs,
+                                                pkgs[i].ntevs, force_add);
+end:
+        /* Loop 3: cleanup trace events  */
+        for (i = 0; i < npevs; i++)
+                for (j = 0; j < pkgs[i].ntevs; j++)
+                        clear_kprobe_trace_event(&pkgs[i].tevs[j]);
+
+        return ret;
 }
 
-static void __del_trace_kprobe_event(int fd, struct str_node *ent)
+static int __del_trace_kprobe_event(int fd, struct str_node *ent)
 {
         char *p;
         char buf[128];
+        int ret;
 
         /* Convert from perf-probe event to trace-kprobe event */
-        if (e_snprintf(buf, 128, "-:%s", ent->s) < 0)
-                die("Failed to copy event.");
+        ret = e_snprintf(buf, 128, "-:%s", ent->s);
+        if (ret < 0)
+                goto error;
+
         p = strchr(buf + 2, ':');
-        if (!p)
-                die("Internal error: %s should have ':' but not.", ent->s);
+        if (!p) {
+                pr_debug("Internal error: %s should have ':' but not.\n",
+                         ent->s);
+                ret = -ENOTSUP;
+                goto error;
+        }
         *p = '/';
 
-        write_trace_kprobe_event(fd, buf);
+        pr_debug("Writing event: %s\n", buf);
+        ret = write(fd, buf, strlen(buf));
+        if (ret < 0)
+                goto error;
+
         printf("Remove event: %s\n", ent->s);
+        return 0;
+error:
+        pr_warning("Failed to delete event: %s\n", strerror(-ret));
+        return ret;
 }
 
-static void del_trace_kprobe_event(int fd, const char *group,
-                                   const char *event, struct strlist *namelist)
+static int del_trace_kprobe_event(int fd, const char *group,
+                                  const char *event, struct strlist *namelist)
 {
         char buf[128];
         struct str_node *ent, *n;
-        int found = 0;
+        int found = 0, ret = 0;
 
-        if (e_snprintf(buf, 128, "%s:%s", group, event) < 0)
-                die("Failed to copy event.");
+        ret = e_snprintf(buf, 128, "%s:%s", group, event);
+        if (ret < 0) {
+                pr_err("Failed to copy event.");
+                return ret;
+        }
 
         if (strpbrk(buf, "*?")) { /* Glob-exp */
                 strlist__for_each_safe(ent, n, namelist)
                         if (strglobmatch(ent->s, buf)) {
                                 found++;
-                                __del_trace_kprobe_event(fd, ent);
+                                ret = __del_trace_kprobe_event(fd, ent);
+                                if (ret < 0)
+                                        break;
                                 strlist__remove(namelist, ent);
                         }
         } else {
                 ent = strlist__find(namelist, buf);
                 if (ent) {
                         found++;
-                        __del_trace_kprobe_event(fd, ent);
-                        strlist__remove(namelist, ent);
+                        ret = __del_trace_kprobe_event(fd, ent);
+                        if (ret >= 0)
+                                strlist__remove(namelist, ent);
                 }
         }
-        if (found == 0)
-                pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf);
+        if (found == 0 && ret >= 0)
+                pr_info("Info: Event \"%s\" does not exist.\n", buf);
+
+        return ret;
 }
 
-void del_trace_kprobe_events(struct strlist *dellist)
+int del_perf_probe_events(struct strlist *dellist)
 {
-        int fd;
+        int fd, ret = 0;
         const char *group, *event;
         char *p, *str;
         struct str_node *ent;
         struct strlist *namelist;
 
-        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        fd = open_kprobe_events(true);
+        if (fd < 0)
+                return fd;
+
         /* Get current event names */
-        namelist = get_perf_event_names(fd, true);
+        namelist = get_kprobe_trace_event_names(fd, true);
+        if (namelist == NULL)
+                return -EINVAL;
 
         strlist__for_each(ent, dellist) {
                 str = strdup(ent->s);
-                if (!str)
-                        die("Failed to copy event.");
+                if (str == NULL) {
+                        ret = -ENOMEM;
+                        break;
+                }
                 pr_debug("Parsing: %s\n", str);
                 p = strchr(str, ':');
                 if (p) {
@@ -723,80 +1633,14 @@ void del_trace_kprobe_events(struct strlist *dellist)
                         event = str;
                 }
                 pr_debug("Group: %s, Event: %s\n", group, event);
-                del_trace_kprobe_event(fd, group, event, namelist);
+                ret = del_trace_kprobe_event(fd, group, event, namelist);
                 free(str);
+                if (ret < 0)
+                        break;
         }
         strlist__delete(namelist);
         close(fd);
-}
 
-#define LINEBUF_SIZE 256
-#define NR_ADDITIONAL_LINES 2
-
-static void show_one_line(FILE *fp, unsigned int l, bool skip, bool show_num)
-{
-        char buf[LINEBUF_SIZE];
-        const char *color = PERF_COLOR_BLUE;
-
-        if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
-                goto error;
-        if (!skip) {
-                if (show_num)
-                        fprintf(stdout, "%7u  %s", l, buf);
-                else
-                        color_fprintf(stdout, color, "         %s", buf);
-        }
-
-        while (strlen(buf) == LINEBUF_SIZE - 1 &&
-               buf[LINEBUF_SIZE - 2] != '\n') {
-                if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
-                        goto error;
-                if (!skip) {
-                        if (show_num)
-                                fprintf(stdout, "%s", buf);
-                        else
-                                color_fprintf(stdout, color, "%s", buf);
-                }
-        }
-        return;
-error:
-        if (feof(fp))
-                die("Source file is shorter than expected.");
-        else
-                die("File read error: %s", strerror(errno));
+        return ret;
 }
 
-void show_line_range(struct line_range *lr)
-{
-        unsigned int l = 1;
-        struct line_node *ln;
-        FILE *fp;
-
-        setup_pager();
-
-        if (lr->function)
-                fprintf(stdout, "<%s:%d>\n", lr->function,
-                        lr->start - lr->offset);
-        else
-                fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
-
-        fp = fopen(lr->path, "r");
-        if (fp == NULL)
-                die("Failed to open %s: %s", lr->path, strerror(errno));
-        /* Skip to starting line number */
-        while (l < lr->start)
-                show_one_line(fp, l++, true, false);
-
-        list_for_each_entry(ln, &lr->line_list, list) {
-                while (ln->line > l)
-                        show_one_line(fp, (l++) - lr->offset, false, false);
-                show_one_line(fp, (l++) - lr->offset, false, true);
-        }
-
-        if (lr->end == INT_MAX)
-                lr->end = l + NR_ADDITIONAL_LINES;
-        while (l < lr->end && !feof(fp))
-                show_one_line(fp, (l++) - lr->offset, false, false);
-
-        fclose(fp);
-}
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 711287d4bae..e9db1a214ca 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -2,21 +2,125 @@
 #define _PROBE_EVENT_H
 
 #include <stdbool.h>
-#include "probe-finder.h"
 #include "strlist.h"
 
-extern void parse_line_range_desc(const char *arg, struct line_range *lr);
-extern void parse_perf_probe_event(const char *str, struct probe_point *pp,
-                                   bool *need_dwarf);
-extern int synthesize_perf_probe_point(struct probe_point *pp);
-extern int synthesize_perf_probe_event(struct probe_point *pp);
-extern void parse_trace_kprobe_event(const char *str, struct probe_point *pp);
-extern int synthesize_trace_kprobe_event(struct probe_point *pp);
-extern void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
-                                    bool force_add);
-extern void del_trace_kprobe_events(struct strlist *dellist);
-extern void show_perf_probe_events(void);
-extern void show_line_range(struct line_range *lr);
+extern bool probe_event_dry_run;
+
+/* kprobe-tracer tracing point */
+struct kprobe_trace_point {
+        char            *symbol;        /* Base symbol */
+        unsigned long   offset;         /* Offset from symbol */
+        bool            retprobe;       /* Return probe flag */
+};
+
+/* kprobe-tracer tracing argument referencing offset */
+struct kprobe_trace_arg_ref {
+        struct kprobe_trace_arg_ref     *next;  /* Next reference */
+        long                            offset; /* Offset value */
+};
+
+/* kprobe-tracer tracing argument */
+struct kprobe_trace_arg {
+        char                            *name;  /* Argument name */
+        char                            *value; /* Base value */
+        char                            *type;  /* Type name */
+        struct kprobe_trace_arg_ref     *ref;   /* Referencing offset */
+};
+
+/* kprobe-tracer tracing event (point + arg) */
+struct kprobe_trace_event {
+        char                            *event; /* Event name */
+        char                            *group; /* Group name */
+        struct kprobe_trace_point       point;  /* Trace point */
+        int                             nargs;  /* Number of args */
+        struct kprobe_trace_arg         *args;  /* Arguments */
+};
+
+/* Perf probe probing point */
+struct perf_probe_point {
+        char            *file;          /* File path */
+        char            *function;      /* Function name */
+        int             line;           /* Line number */
+        bool            retprobe;       /* Return probe flag */
+        char            *lazy_line;     /* Lazy matching pattern */
+        unsigned long   offset;         /* Offset from function entry */
+};
+
+/* Perf probe probing argument field chain */
+struct perf_probe_arg_field {
+        struct perf_probe_arg_field     *next;  /* Next field */
+        char                            *name;  /* Name of the field */
+        bool                            ref;    /* Referencing flag */
+};
+
+/* Perf probe probing argument */
+struct perf_probe_arg {
+        char                            *name;  /* Argument name */
+        char                            *var;   /* Variable name */
+        char                            *type;  /* Type name */
+        struct perf_probe_arg_field     *field; /* Structure fields */
+};
+
+/* Perf probe probing event (point + arg) */
+struct perf_probe_event {
+        char                    *event; /* Event name */
+        char                    *group; /* Group name */
+        struct perf_probe_point point;  /* Probe point */
+        int                     nargs;  /* Number of arguments */
+        struct perf_probe_arg   *args;  /* Arguments */
+};
+
+
+/* Line number container */
+struct line_node {
+        struct list_head        list;
+        int                     line;
+};
+
+/* Line range */
+struct line_range {
+        char                    *file;          /* File name */
+        char                    *function;      /* Function name */
+        int                     start;          /* Start line number */
+        int                     end;            /* End line number */
+        int                     offset;         /* Start line offset */
+        char                    *path;          /* Real path name */
+        struct list_head        line_list;      /* Visible lines */
+};
+
+/* Command string to events */
+extern int parse_perf_probe_command(const char *cmd,
+                                    struct perf_probe_event *pev);
+extern int parse_kprobe_trace_command(const char *cmd,
+                                      struct kprobe_trace_event *tev);
+
+/* Events to command string */
+extern char *synthesize_perf_probe_command(struct perf_probe_event *pev);
+extern char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev);
+extern int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf,
+                                     size_t len);
+
+/* Check the perf_probe_event needs debuginfo */
+extern bool perf_probe_event_need_dwarf(struct perf_probe_event *pev);
+
+/* Convert from kprobe_trace_event to perf_probe_event */
+extern int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
+                                       struct perf_probe_event *pev);
+
+/* Release event contents */
+extern void clear_perf_probe_event(struct perf_probe_event *pev);
+extern void clear_kprobe_trace_event(struct kprobe_trace_event *tev);
+
+/* Command string to line-range */
+extern int parse_line_range_desc(const char *cmd, struct line_range *lr);
+
+
+extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
+                                 bool force_add, int max_probe_points);
+extern int del_perf_probe_events(struct strlist *dellist);
+extern int show_perf_probe_events(void);
+extern int show_line_range(struct line_range *lr);
+
 
 /* Maximum index number of event-name postfix */
 #define MAX_EVENT_INDEX 1024
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index c171a243d05..562b1443e78 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -31,6 +31,7 @@
 #include <string.h>
 #include <stdarg.h>
 #include <ctype.h>
+#include <dwarf-regs.h>
 
 #include "string.h"
 #include "event.h"
@@ -38,57 +39,8 @@
 #include "util.h"
 #include "probe-finder.h"
 
-
-/*
- * Generic dwarf analysis helpers
- */
-
-#define X86_32_MAX_REGS 8
-const char *x86_32_regs_table[X86_32_MAX_REGS] = {
-        "%ax",
-        "%cx",
-        "%dx",
-        "%bx",
-        "$stack",       /* Stack address instead of %sp */
-        "%bp",
-        "%si",
-        "%di",
-};
-
-#define X86_64_MAX_REGS 16
-const char *x86_64_regs_table[X86_64_MAX_REGS] = {
-        "%ax",
-        "%dx",
-        "%cx",
-        "%bx",
-        "%si",
-        "%di",
-        "%bp",
-        "%sp",
-        "%r8",
-        "%r9",
-        "%r10",
-        "%r11",
-        "%r12",
-        "%r13",
-        "%r14",
-        "%r15",
-};
-
-/* TODO: switching by dwarf address size */
-#ifdef __x86_64__
-#define ARCH_MAX_REGS X86_64_MAX_REGS
-#define arch_regs_table x86_64_regs_table
-#else
-#define ARCH_MAX_REGS X86_32_MAX_REGS
-#define arch_regs_table x86_32_regs_table
-#endif
-
-/* Return architecture dependent register string (for kprobe-tracer) */
-static const char *get_arch_regstr(unsigned int n)
-{
-        return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
-}
+/* Kprobe tracer basic type is up to u64 */
+#define MAX_BASIC_TYPE_BITS     64
 
 /*
  * Compare the tail of two strings.
@@ -108,7 +60,7 @@ static int strtailcmp(const char *s1, const char *s2)
 /* Line number list operations */
 
 /* Add a line to line number list */
-static void line_list__add_line(struct list_head *head, unsigned int line)
+static int line_list__add_line(struct list_head *head, int line)
 {
         struct line_node *ln;
         struct list_head *p;
@@ -119,21 +71,23 @@ static void line_list__add_line(struct list_head *head, unsigned int line)
                         p = &ln->list;
                         goto found;
                 } else if (ln->line == line)    /* Already exist */
-                        return ;
+                        return 1;
         }
         /* List is empty, or the smallest entry */
         p = head;
 found:
         pr_debug("line list: add a line %u\n", line);
         ln = zalloc(sizeof(struct line_node));
-        DIE_IF(ln == NULL);
+        if (ln == NULL)
+                return -ENOMEM;
         ln->line = line;
         INIT_LIST_HEAD(&ln->list);
         list_add(&ln->list, p);
+        return 0;
 }
 
 /* Check if the line in line number list */
-static int line_list__has_line(struct list_head *head, unsigned int line)
+static int line_list__has_line(struct list_head *head, int line)
 {
         struct line_node *ln;
 
@@ -184,9 +138,129 @@ static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
                 if (strtailcmp(src, fname) == 0)
                         break;
         }
+        if (i == nfiles)
+                return NULL;
         return src;
 }
 
+/* Compare diename and tname */
+static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
+{
+        const char *name;
+        name = dwarf_diename(dw_die);
+        return name ? strcmp(tname, name) : -1;
+}
+
+/* Get type die, but skip qualifiers and typedef */
+static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
+{
+        Dwarf_Attribute attr;
+        int tag;
+
+        do {
+                if (dwarf_attr(vr_die, DW_AT_type, &attr) == NULL ||
+                    dwarf_formref_die(&attr, die_mem) == NULL)
+                        return NULL;
+
+                tag = dwarf_tag(die_mem);
+                vr_die = die_mem;
+        } while (tag == DW_TAG_const_type ||
+                 tag == DW_TAG_restrict_type ||
+                 tag == DW_TAG_volatile_type ||
+                 tag == DW_TAG_shared_type ||
+                 tag == DW_TAG_typedef);
+
+        return die_mem;
+}
+
+static bool die_is_signed_type(Dwarf_Die *tp_die)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Word ret;
+
+        if (dwarf_attr(tp_die, DW_AT_encoding, &attr) == NULL ||
+            dwarf_formudata(&attr, &ret) != 0)
+                return false;
+
+        return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
+                ret == DW_ATE_signed_fixed);
+}
+
+static int die_get_byte_size(Dwarf_Die *tp_die)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Word ret;
+
+        if (dwarf_attr(tp_die, DW_AT_byte_size, &attr) == NULL ||
+            dwarf_formudata(&attr, &ret) != 0)
+                return 0;
+
+        return (int)ret;
+}
+
+/* Get data_member_location offset */
+static int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Op *expr;
+        size_t nexpr;
+        int ret;
+
+        if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
+                return -ENOENT;
+
+        if (dwarf_formudata(&attr, offs) != 0) {
+                /* DW_AT_data_member_location should be DW_OP_plus_uconst */
+                ret = dwarf_getlocation(&attr, &expr, &nexpr);
+                if (ret < 0 || nexpr == 0)
+                        return -ENOENT;
+
+                if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
+                        pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
+                                 expr[0].atom, nexpr);
+                        return -ENOTSUP;
+                }
+                *offs = (Dwarf_Word)expr[0].number;
+        }
+        return 0;
+}
+
+/* Return values for die_find callbacks */
+enum {
+        DIE_FIND_CB_FOUND = 0,          /* End of Search */
+        DIE_FIND_CB_CHILD = 1,          /* Search only children */
+        DIE_FIND_CB_SIBLING = 2,        /* Search only siblings */
+        DIE_FIND_CB_CONTINUE = 3,       /* Search children and siblings */
+};
+
+/* Search a child die */
+static Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
+                                 int (*callback)(Dwarf_Die *, void *),
+                                 void *data, Dwarf_Die *die_mem)
+{
+        Dwarf_Die child_die;
+        int ret;
+
+        ret = dwarf_child(rt_die, die_mem);
+        if (ret != 0)
+                return NULL;
+
+        do {
+                ret = callback(die_mem, data);
+                if (ret == DIE_FIND_CB_FOUND)
+                        return die_mem;
+
+                if ((ret & DIE_FIND_CB_CHILD) &&
+                    die_find_child(die_mem, callback, data, &child_die)) {
+                        memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
+                        return die_mem;
+                }
+        } while ((ret & DIE_FIND_CB_SIBLING) &&
+                 dwarf_siblingof(die_mem, die_mem) == 0);
+
+        return NULL;
+}
+
 struct __addr_die_search_param {
         Dwarf_Addr      addr;
         Dwarf_Die       *die_mem;
@@ -205,8 +279,8 @@ static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
 }
 
 /* Search a real subprogram including this line, */
-static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
-                                          Dwarf_Die *die_mem)
+static Dwarf_Die *die_find_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                                           Dwarf_Die *die_mem)
 {
         struct __addr_die_search_param ad;
         ad.addr = addr;
@@ -218,77 +292,64 @@ static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
                 return die_mem;
 }
 
-/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
-static Dwarf_Die *die_get_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
-                                     Dwarf_Die *die_mem)
+/* die_find callback for inline function search */
+static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
 {
-        Dwarf_Die child_die;
-        int ret;
+        Dwarf_Addr *addr = data;
 
-        ret = dwarf_child(sp_die, die_mem);
-        if (ret != 0)
-                return NULL;
+        if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
+            dwarf_haspc(die_mem, *addr))
+                return DIE_FIND_CB_FOUND;
 
-        do {
-                if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
-                    dwarf_haspc(die_mem, addr))
-                        return die_mem;
-
-                if (die_get_inlinefunc(die_mem, addr, &child_die)) {
-                        memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
-                        return die_mem;
-                }
-        } while (dwarf_siblingof(die_mem, die_mem) == 0);
-
-        return NULL;
+        return DIE_FIND_CB_CONTINUE;
 }
 
-/* Compare diename and tname */
-static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
+/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
+static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
+                                      Dwarf_Die *die_mem)
 {
-        const char *name;
-        name = dwarf_diename(dw_die);
-        DIE_IF(name == NULL);
-        return strcmp(tname, name);
+        return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
 }
 
-/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
-static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
+static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
 {
-        Dwarf_Addr epc;
-        int ret;
+        const char *name = data;
+        int tag;
 
-        ret = dwarf_entrypc(dw_die, &epc);
-        DIE_IF(ret == -1);
-        return epc;
+        tag = dwarf_tag(die_mem);
+        if ((tag == DW_TAG_formal_parameter ||
+             tag == DW_TAG_variable) &&
+            (die_compare_name(die_mem, name) == 0))
+                return DIE_FIND_CB_FOUND;
+
+        return DIE_FIND_CB_CONTINUE;
 }
 
-/* Get a variable die */
+/* Find a variable called 'name' */
 static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
                                     Dwarf_Die *die_mem)
 {
-        Dwarf_Die child_die;
-        int tag;
-        int ret;
+        return die_find_child(sp_die, __die_find_variable_cb, (void *)name,
+                              die_mem);
+}
 
-        ret = dwarf_child(sp_die, die_mem);
-        if (ret != 0)
-                return NULL;
+static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
+{
+        const char *name = data;
 
-        do {
-                tag = dwarf_tag(die_mem);
-                if ((tag == DW_TAG_formal_parameter ||
-                     tag == DW_TAG_variable) &&
-                    (die_compare_name(die_mem, name) == 0))
-                        return die_mem;
+        if ((dwarf_tag(die_mem) == DW_TAG_member) &&
+            (die_compare_name(die_mem, name) == 0))
+                return DIE_FIND_CB_FOUND;
 
-                if (die_find_variable(die_mem, name, &child_die)) {
-                        memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
-                        return die_mem;
-                }
-        } while (dwarf_siblingof(die_mem, die_mem) == 0);
+        return DIE_FIND_CB_SIBLING;
+}
 
-        return NULL;
+/* Find a member called 'name' */
+static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
+                                  Dwarf_Die *die_mem)
+{
+        return die_find_child(st_die, __die_find_member_cb, (void *)name,
+                              die_mem);
 }
 
 /*
@@ -296,19 +357,22 @@ static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
  */
 
 /* Show a location */
-static void show_location(Dwarf_Op *op, struct probe_finder *pf)
+static int convert_location(Dwarf_Op *op, struct probe_finder *pf)
 {
         unsigned int regn;
         Dwarf_Word offs = 0;
-        int deref = 0, ret;
+        bool ref = false;
         const char *regs;
+        struct kprobe_trace_arg *tvar = pf->tvar;
 
-        /* TODO: support CFA */
         /* If this is based on frame buffer, set the offset */
         if (op->atom == DW_OP_fbreg) {
-                if (pf->fb_ops == NULL)
-                        die("The attribute of frame base is not supported.\n");
-                deref = 1;
+                if (pf->fb_ops == NULL) {
+                        pr_warning("The attribute of frame base is not "
+                                   "supported.\n");
+                        return -ENOTSUP;
+                }
+                ref = true;
                 offs = op->number;
                 op = &pf->fb_ops[0];
         }
@@ -316,35 +380,164 @@ static void show_location(Dwarf_Op *op, struct probe_finder *pf)
         if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
                 regn = op->atom - DW_OP_breg0;
                 offs += op->number;
-                deref = 1;
+                ref = true;
         } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
                 regn = op->atom - DW_OP_reg0;
         } else if (op->atom == DW_OP_bregx) {
                 regn = op->number;
                 offs += op->number2;
-                deref = 1;
+                ref = true;
         } else if (op->atom == DW_OP_regx) {
                 regn = op->number;
-        } else
-                die("DW_OP %d is not supported.", op->atom);
+        } else {
+                pr_warning("DW_OP %x is not supported.\n", op->atom);
+                return -ENOTSUP;
+        }
 
         regs = get_arch_regstr(regn);
-        if (!regs)
-                die("%u exceeds max register number.", regn);
+        if (!regs) {
+                pr_warning("Mapping for DWARF register number %u missing on this architecture.", regn);
+                return -ERANGE;
+        }
+
+        tvar->value = strdup(regs);
+        if (tvar->value == NULL)
+                return -ENOMEM;
+
+        if (ref) {
+                tvar->ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
+                if (tvar->ref == NULL)
+                        return -ENOMEM;
+                tvar->ref->offset = (long)offs;
+        }
+        return 0;
+}
+
+static int convert_variable_type(Dwarf_Die *vr_die,
+                                 struct kprobe_trace_arg *targ)
+{
+        Dwarf_Die type;
+        char buf[16];
+        int ret;
+
+        if (die_get_real_type(vr_die, &type) == NULL) {
+                pr_warning("Failed to get a type information of %s.\n",
+                           dwarf_diename(vr_die));
+                return -ENOENT;
+        }
+
+        ret = die_get_byte_size(&type) * 8;
+        if (ret) {
+                /* Check the bitwidth */
+                if (ret > MAX_BASIC_TYPE_BITS) {
+                        pr_info("%s exceeds max-bitwidth."
+                                " Cut down to %d bits.\n",
+                                dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
+                        ret = MAX_BASIC_TYPE_BITS;
+                }
+
+                ret = snprintf(buf, 16, "%c%d",
+                               die_is_signed_type(&type) ? 's' : 'u', ret);
+                if (ret < 0 || ret >= 16) {
+                        if (ret >= 16)
+                                ret = -E2BIG;
+                        pr_warning("Failed to convert variable type: %s\n",
+                                   strerror(-ret));
+                        return ret;
+                }
+                targ->type = strdup(buf);
+                if (targ->type == NULL)
+                        return -ENOMEM;
+        }
+        return 0;
+}
+
+static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
+                                    struct perf_probe_arg_field *field,
+                                    struct kprobe_trace_arg_ref **ref_ptr,
+                                    Dwarf_Die *die_mem)
+{
+        struct kprobe_trace_arg_ref *ref = *ref_ptr;
+        Dwarf_Die type;
+        Dwarf_Word offs;
+        int ret;
+
+        pr_debug("converting %s in %s\n", field->name, varname);
+        if (die_get_real_type(vr_die, &type) == NULL) {
+                pr_warning("Failed to get the type of %s.\n", varname);
+                return -ENOENT;
+        }
+
+        /* Check the pointer and dereference */
+        if (dwarf_tag(&type) == DW_TAG_pointer_type) {
+                if (!field->ref) {
+                        pr_err("Semantic error: %s must be referred by '->'\n",
+                               field->name);
+                        return -EINVAL;
+                }
+                /* Get the type pointed by this pointer */
+                if (die_get_real_type(&type, &type) == NULL) {
+                        pr_warning("Failed to get the type of %s.\n", varname);
+                        return -ENOENT;
+                }
+                /* Verify it is a data structure  */
+                if (dwarf_tag(&type) != DW_TAG_structure_type) {
+                        pr_warning("%s is not a data structure.\n", varname);
+                        return -EINVAL;
+                }
+
+                ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
+                if (ref == NULL)
+                        return -ENOMEM;
+                if (*ref_ptr)
+                        (*ref_ptr)->next = ref;
+                else
+                        *ref_ptr = ref;
+        } else {
+                /* Verify it is a data structure  */
+                if (dwarf_tag(&type) != DW_TAG_structure_type) {
+                        pr_warning("%s is not a data structure.\n", varname);
+                        return -EINVAL;
+                }
+                if (field->ref) {
+                        pr_err("Semantic error: %s must be referred by '.'\n",
+                               field->name);
+                        return -EINVAL;
+                }
+                if (!ref) {
+                        pr_warning("Structure on a register is not "
+                                   "supported yet.\n");
+                        return -ENOTSUP;
+                }
+        }
+
+        if (die_find_member(&type, field->name, die_mem) == NULL) {
+                pr_warning("%s(tyep:%s) has no member %s.\n", varname,
+                           dwarf_diename(&type), field->name);
+                return -EINVAL;
+        }
 
-        if (deref)
-                ret = snprintf(pf->buf, pf->len, " %s=%+jd(%s)",
-                               pf->var, (intmax_t)offs, regs);
+        /* Get the offset of the field */
+        ret = die_get_data_member_location(die_mem, &offs);
+        if (ret < 0) {
+                pr_warning("Failed to get the offset of %s.\n", field->name);
+                return ret;
+        }
+        ref->offset += (long)offs;
+
+        /* Converting next field */
+        if (field->next)
+                return convert_variable_fields(die_mem, field->name,
+                                        field->next, &ref, die_mem);
         else
-                ret = snprintf(pf->buf, pf->len, " %s=%s", pf->var, regs);
-        DIE_IF(ret < 0);
-        DIE_IF(ret >= pf->len);
+                return 0;
 }
 
 /* Show a variables in kprobe event format */
-static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
+static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
 {
         Dwarf_Attribute attr;
+        Dwarf_Die die_mem;
         Dwarf_Op *expr;
         size_t nexpr;
         int ret;
@@ -356,142 +549,191 @@ static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
         if (ret <= 0 || nexpr == 0)
                 goto error;
 
-        show_location(expr, pf);
+        ret = convert_location(expr, pf);
+        if (ret == 0 && pf->pvar->field) {
+                ret = convert_variable_fields(vr_die, pf->pvar->var,
+                                              pf->pvar->field, &pf->tvar->ref,
+                                              &die_mem);
+                vr_die = &die_mem;
+        }
+        if (ret == 0) {
+                if (pf->pvar->type) {
+                        pf->tvar->type = strdup(pf->pvar->type);
+                        if (pf->tvar->type == NULL)
+                                ret = -ENOMEM;
+                } else
+                        ret = convert_variable_type(vr_die, pf->tvar);
+        }
         /* *expr will be cached in libdw. Don't free it. */
-        return ;
+        return ret;
 error:
         /* TODO: Support const_value */
-        die("Failed to find the location of %s at this address.\n"
-            " Perhaps, it has been optimized out.", pf->var);
+        pr_err("Failed to find the location of %s at this address.\n"
+               " Perhaps, it has been optimized out.\n", pf->pvar->var);
+        return -ENOENT;
 }
 
 /* Find a variable in a subprogram die */
-static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
-        int ret;
         Dwarf_Die vr_die;
+        char buf[32], *ptr;
+        int ret;
 
-        /* TODO: Support struct members and arrays */
-        if (!is_c_varname(pf->var)) {
-                /* Output raw parameters */
-                ret = snprintf(pf->buf, pf->len, " %s", pf->var);
-                DIE_IF(ret < 0);
-                DIE_IF(ret >= pf->len);
-                return ;
+        /* TODO: Support arrays */
+        if (pf->pvar->name)
+                pf->tvar->name = strdup(pf->pvar->name);
+        else {
+                ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
+                if (ret < 0)
+                        return ret;
+                ptr = strchr(buf, ':'); /* Change type separator to _ */
+                if (ptr)
+                        *ptr = '_';
+                pf->tvar->name = strdup(buf);
+        }
+        if (pf->tvar->name == NULL)
+                return -ENOMEM;
+
+        if (!is_c_varname(pf->pvar->var)) {
+                /* Copy raw parameters */
+                pf->tvar->value = strdup(pf->pvar->var);
+                if (pf->tvar->value == NULL)
+                        return -ENOMEM;
+                else
+                        return 0;
         }
 
-        pr_debug("Searching '%s' variable in context.\n", pf->var);
+        pr_debug("Searching '%s' variable in context.\n",
+                 pf->pvar->var);
         /* Search child die for local variables and parameters. */
-        if (!die_find_variable(sp_die, pf->var, &vr_die))
-                die("Failed to find '%s' in this function.", pf->var);
-
-        show_variable(&vr_die, pf);
+        if (!die_find_variable(sp_die, pf->pvar->var, &vr_die)) {
+                pr_warning("Failed to find '%s' in this function.\n",
+                           pf->pvar->var);
+                return -ENOENT;
+        }
+        return convert_variable(&vr_die, pf);
 }
 
 /* Show a probe point to output buffer */
-static void show_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
-        struct probe_point *pp = pf->pp;
+        struct kprobe_trace_event *tev;
         Dwarf_Addr eaddr;
         Dwarf_Die die_mem;
         const char *name;
-        char tmp[MAX_PROBE_BUFFER];
-        int ret, i, len;
+        int ret, i;
         Dwarf_Attribute fb_attr;
         size_t nops;
 
+        if (pf->ntevs == pf->max_tevs) {
+                pr_warning("Too many( > %d) probe point found.\n",
+                           pf->max_tevs);
+                return -ERANGE;
+        }
+        tev = &pf->tevs[pf->ntevs++];
+
         /* If no real subprogram, find a real one */
         if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
-                sp_die = die_get_real_subprogram(&pf->cu_die,
+                sp_die = die_find_real_subprogram(&pf->cu_die,
                                                  pf->addr, &die_mem);
-                if (!sp_die)
-                        die("Probe point is not found in subprograms.");
+                if (!sp_die) {
+                        pr_warning("Failed to find probe point in any "
+                                   "functions.\n");
+                        return -ENOENT;
+                }
         }
 
-        /* Output name of probe point */
+        /* Copy the name of probe point */
         name = dwarf_diename(sp_die);
         if (name) {
-                dwarf_entrypc(sp_die, &eaddr);
-                ret = snprintf(tmp, MAX_PROBE_BUFFER, "%s+%lu", name,
-                                (unsigned long)(pf->addr - eaddr));
-                /* Copy the function name if possible */
-                if (!pp->function) {
-                        pp->function = strdup(name);
-                        pp->offset = (size_t)(pf->addr - eaddr);
+                if (dwarf_entrypc(sp_die, &eaddr) != 0) {
+                        pr_warning("Failed to get entry pc of %s\n",
+                                   dwarf_diename(sp_die));
+                        return -ENOENT;
                 }
-        } else {
+                tev->point.symbol = strdup(name);
+                if (tev->point.symbol == NULL)
+                        return -ENOMEM;
+                tev->point.offset = (unsigned long)(pf->addr - eaddr);
+        } else
                 /* This function has no name. */
-                ret = snprintf(tmp, MAX_PROBE_BUFFER, "0x%jx",
-                               (uintmax_t)pf->addr);
-                if (!pp->function) {
-                        /* TODO: Use _stext */
-                        pp->function = strdup("");
-                        pp->offset = (size_t)pf->addr;
-                }
-        }
-        DIE_IF(ret < 0);
-        DIE_IF(ret >= MAX_PROBE_BUFFER);
-        len = ret;
-        pr_debug("Probe point found: %s\n", tmp);
+                tev->point.offset = (unsigned long)pf->addr;
+
+        pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
+                 tev->point.offset);
 
         /* Get the frame base attribute/ops */
         dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
         ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
-        if (ret <= 0 || nops == 0)
+        if (ret <= 0 || nops == 0) {
                 pf->fb_ops = NULL;
+        } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
+                   pf->cfi != NULL) {
+                Dwarf_Frame *frame;
+                if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
+                    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
+                        pr_warning("Failed to get CFA on 0x%jx\n",
+                                   (uintmax_t)pf->addr);
+                        return -ENOENT;
+                }
+        }
 
         /* Find each argument */
-        /* TODO: use dwarf_cfi_addrframe */
-        for (i = 0; i < pp->nr_args; i++) {
-                pf->var = pp->args[i];
-                pf->buf = &tmp[len];
-                pf->len = MAX_PROBE_BUFFER - len;
-                find_variable(sp_die, pf);
-                len += strlen(pf->buf);
+        tev->nargs = pf->pev->nargs;
+        tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
+        if (tev->args == NULL)
+                return -ENOMEM;
+        for (i = 0; i < pf->pev->nargs; i++) {
+                pf->pvar = &pf->pev->args[i];
+                pf->tvar = &tev->args[i];
+                ret = find_variable(sp_die, pf);
+                if (ret != 0)
+                        return ret;
         }
 
         /* *pf->fb_ops will be cached in libdw. Don't free it. */
         pf->fb_ops = NULL;
-
-        if (pp->found == MAX_PROBES)
-                die("Too many( > %d) probe point found.\n", MAX_PROBES);
-
-        pp->probes[pp->found] = strdup(tmp);
-        pp->found++;
+        return 0;
 }
 
 /* Find probe point from its line number */
-static void find_probe_point_by_line(struct probe_finder *pf)
+static int find_probe_point_by_line(struct probe_finder *pf)
 {
         Dwarf_Lines *lines;
         Dwarf_Line *line;
         size_t nlines, i;
         Dwarf_Addr addr;
         int lineno;
-        int ret;
+        int ret = 0;
 
-        ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
-        DIE_IF(ret != 0);
+        if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
+                pr_warning("No source lines found in this CU.\n");
+                return -ENOENT;
+        }
 
-        for (i = 0; i < nlines; i++) {
+        for (i = 0; i < nlines && ret == 0; i++) {
                 line = dwarf_onesrcline(lines, i);
-                dwarf_lineno(line, &lineno);
-                if (lineno != pf->lno)
+                if (dwarf_lineno(line, &lineno) != 0 ||
+                    lineno != pf->lno)
                         continue;
 
                 /* TODO: Get fileno from line, but how? */
                 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
                         continue;
 
-                ret = dwarf_lineaddr(line, &addr);
-                DIE_IF(ret != 0);
+                if (dwarf_lineaddr(line, &addr) != 0) {
+                        pr_warning("Failed to get the address of the line.\n");
+                        return -ENOENT;
+                }
                 pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
                          (int)i, lineno, (uintmax_t)addr);
                 pf->addr = addr;
 
-                show_probe_point(NULL, pf);
+                ret = convert_probe_point(NULL, pf);
                 /* Continuing, because target line might be inlined. */
         }
+        return ret;
 }
 
 /* Find lines which match lazy pattern */
@@ -499,16 +741,27 @@ static int find_lazy_match_lines(struct list_head *head,
                                  const char *fname, const char *pat)
 {
         char *fbuf, *p1, *p2;
-        int fd, line, nlines = 0;
+        int fd, ret, line, nlines = 0;
         struct stat st;
 
         fd = open(fname, O_RDONLY);
-        if (fd < 0)
-                die("failed to open %s", fname);
-        DIE_IF(fstat(fd, &st) < 0);
-        fbuf = malloc(st.st_size + 2);
-        DIE_IF(fbuf == NULL);
-        DIE_IF(read(fd, fbuf, st.st_size) < 0);
+        if (fd < 0) {
+                pr_warning("Failed to open %s: %s\n", fname, strerror(-fd));
+                return fd;
+        }
+
+        ret = fstat(fd, &st);
+        if (ret < 0) {
+                pr_warning("Failed to get the size of %s: %s\n",
+                           fname, strerror(errno));
+                return ret;
+        }
+        fbuf = xmalloc(st.st_size + 2);
+        ret = read(fd, fbuf, st.st_size);
+        if (ret < 0) {
+                pr_warning("Failed to read %s: %s\n", fname, strerror(errno));
+                return ret;
+        }
         close(fd);
         fbuf[st.st_size] = '\n';        /* Dummy line */
         fbuf[st.st_size + 1] = '\0';
@@ -528,7 +781,7 @@ static int find_lazy_match_lines(struct list_head *head,
 }
 
 /* Find probe points from lazy pattern  */
-static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
         Dwarf_Lines *lines;
         Dwarf_Line *line;
@@ -536,37 +789,46 @@ static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
         Dwarf_Addr addr;
         Dwarf_Die die_mem;
         int lineno;
-        int ret;
+        int ret = 0;
 
         if (list_empty(&pf->lcache)) {
                 /* Matching lazy line pattern */
                 ret = find_lazy_match_lines(&pf->lcache, pf->fname,
-                                            pf->pp->lazy_line);
-                if (ret <= 0)
-                        die("No matched lines found in %s.", pf->fname);
+                                            pf->pev->point.lazy_line);
+                if (ret == 0) {
+                        pr_debug("No matched lines found in %s.\n", pf->fname);
+                        return 0;
+                } else if (ret < 0)
+                        return ret;
         }
 
-        ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
-        DIE_IF(ret != 0);
-        for (i = 0; i < nlines; i++) {
+        if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
+                pr_warning("No source lines found in this CU.\n");
+                return -ENOENT;
+        }
+
+        for (i = 0; i < nlines && ret >= 0; i++) {
                 line = dwarf_onesrcline(lines, i);
 
-                dwarf_lineno(line, &lineno);
-                if (!line_list__has_line(&pf->lcache, lineno))
+                if (dwarf_lineno(line, &lineno) != 0 ||
+                    !line_list__has_line(&pf->lcache, lineno))
                         continue;
 
                 /* TODO: Get fileno from line, but how? */
                 if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
                         continue;
 
-                ret = dwarf_lineaddr(line, &addr);
-                DIE_IF(ret != 0);
+                if (dwarf_lineaddr(line, &addr) != 0) {
+                        pr_debug("Failed to get the address of line %d.\n",
+                                 lineno);
+                        continue;
+                }
                 if (sp_die) {
                         /* Address filtering 1: does sp_die include addr? */
                         if (!dwarf_haspc(sp_die, addr))
                                 continue;
                         /* Address filtering 2: No child include addr? */
-                        if (die_get_inlinefunc(sp_die, addr, &die_mem))
+                        if (die_find_inlinefunc(sp_die, addr, &die_mem))
                                 continue;
                 }
 
@@ -574,27 +836,44 @@ static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
                          (int)i, lineno, (unsigned long long)addr);
                 pf->addr = addr;
 
-                show_probe_point(sp_die, pf);
+                ret = convert_probe_point(sp_die, pf);
                 /* Continuing, because target line might be inlined. */
         }
         /* TODO: deallocate lines, but how? */
+        return ret;
 }
 
+/* Callback parameter with return value */
+struct dwarf_callback_param {
+        void *data;
+        int retval;
+};
+
 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        struct probe_finder *pf = (struct probe_finder *)data;
-        struct probe_point *pp = pf->pp;
+        struct dwarf_callback_param *param = data;
+        struct probe_finder *pf = param->data;
+        struct perf_probe_point *pp = &pf->pev->point;
+        Dwarf_Addr addr;
 
         if (pp->lazy_line)
-                find_probe_point_lazy(in_die, pf);
+                param->retval = find_probe_point_lazy(in_die, pf);
         else {
                 /* Get probe address */
-                pf->addr = die_get_entrypc(in_die);
+                if (dwarf_entrypc(in_die, &addr) != 0) {
+                        pr_warning("Failed to get entry pc of %s.\n",
+                                   dwarf_diename(in_die));
+                        param->retval = -ENOENT;
+                        return DWARF_CB_ABORT;
+                }
+                pf->addr = addr;
                 pf->addr += pp->offset;
                 pr_debug("found inline addr: 0x%jx\n",
                          (uintmax_t)pf->addr);
 
-                show_probe_point(in_die, pf);
+                param->retval = convert_probe_point(in_die, pf);
+                if (param->retval < 0)
+                        return DWARF_CB_ABORT;
         }
 
         return DWARF_CB_OK;
@@ -603,59 +882,88 @@ static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 /* Search function from function name */
 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
 {
-        struct probe_finder *pf = (struct probe_finder *)data;
-        struct probe_point *pp = pf->pp;
+        struct dwarf_callback_param *param = data;
+        struct probe_finder *pf = param->data;
+        struct perf_probe_point *pp = &pf->pev->point;
 
         /* Check tag and diename */
         if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
             die_compare_name(sp_die, pp->function) != 0)
-                return 0;
+                return DWARF_CB_OK;
 
         pf->fname = dwarf_decl_file(sp_die);
         if (pp->line) { /* Function relative line */
                 dwarf_decl_line(sp_die, &pf->lno);
                 pf->lno += pp->line;
-                find_probe_point_by_line(pf);
+                param->retval = find_probe_point_by_line(pf);
         } else if (!dwarf_func_inline(sp_die)) {
                 /* Real function */
                 if (pp->lazy_line)
-                        find_probe_point_lazy(sp_die, pf);
+                        param->retval = find_probe_point_lazy(sp_die, pf);
                 else {
-                        pf->addr = die_get_entrypc(sp_die);
+                        if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
+                                pr_warning("Failed to get entry pc of %s.\n",
+                                           dwarf_diename(sp_die));
+                                param->retval = -ENOENT;
+                                return DWARF_CB_ABORT;
+                        }
                         pf->addr += pp->offset;
                         /* TODO: Check the address in this function */
-                        show_probe_point(sp_die, pf);
+                        param->retval = convert_probe_point(sp_die, pf);
                 }
-        } else
+        } else {
+                struct dwarf_callback_param _param = {.data = (void *)pf,
+                                                      .retval = 0};
                 /* Inlined function: search instances */
-                dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf);
+                dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
+                                            &_param);
+                param->retval = _param.retval;
+        }
 
-        return 1; /* Exit; no same symbol in this CU. */
+        return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
 }
 
-static void find_probe_point_by_func(struct probe_finder *pf)
+static int find_probe_point_by_func(struct probe_finder *pf)
 {
-        dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0);
+        struct dwarf_callback_param _param = {.data = (void *)pf,
+                                              .retval = 0};
+        dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
+        return _param.retval;
 }
 
-/* Find a probe point */
-int find_probe_point(int fd, struct probe_point *pp)
+/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
+int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
+                             struct kprobe_trace_event **tevs, int max_tevs)
 {
-        struct probe_finder pf = {.pp = pp};
+        struct probe_finder pf = {.pev = pev, .max_tevs = max_tevs};
+        struct perf_probe_point *pp = &pev->point;
         Dwarf_Off off, noff;
         size_t cuhl;
         Dwarf_Die *diep;
         Dwarf *dbg;
+        int ret = 0;
+
+        pf.tevs = zalloc(sizeof(struct kprobe_trace_event) * max_tevs);
+        if (pf.tevs == NULL)
+                return -ENOMEM;
+        *tevs = pf.tevs;
+        pf.ntevs = 0;
 
         dbg = dwarf_begin(fd, DWARF_C_READ);
-        if (!dbg)
-                return -ENOENT;
+        if (!dbg) {
+                pr_warning("No dwarf info found in the vmlinux - "
+                        "please rebuild with CONFIG_DEBUG_INFO=y.\n");
+                return -EBADF;
+        }
+
+        /* Get the call frame information from this dwarf */
+        pf.cfi = dwarf_getcfi(dbg);
 
-        pp->found = 0;
         off = 0;
         line_list__init(&pf.lcache);
         /* Loop on CUs (Compilation Unit) */
-        while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
+        while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) &&
+               ret >= 0) {
                 /* Get the DIE(Debugging Information Entry) of this CU */
                 diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
                 if (!diep)
@@ -669,12 +977,12 @@ int find_probe_point(int fd, struct probe_point *pp)
 
                 if (!pp->file || pf.fname) {
                         if (pp->function)
-                                find_probe_point_by_func(&pf);
+                                ret = find_probe_point_by_func(&pf);
                         else if (pp->lazy_line)
-                                find_probe_point_lazy(NULL, &pf);
+                                ret = find_probe_point_lazy(NULL, &pf);
                         else {
                                 pf.lno = pp->line;
-                                find_probe_point_by_line(&pf);
+                                ret = find_probe_point_by_line(&pf);
                         }
                 }
                 off = noff;
@@ -682,41 +990,169 @@ int find_probe_point(int fd, struct probe_point *pp)
         line_list__free(&pf.lcache);
         dwarf_end(dbg);
 
-        return pp->found;
+        return (ret < 0) ? ret : pf.ntevs;
+}
+
+/* Reverse search */
+int find_perf_probe_point(int fd, unsigned long addr,
+                          struct perf_probe_point *ppt)
+{
+        Dwarf_Die cudie, spdie, indie;
+        Dwarf *dbg;
+        Dwarf_Line *line;
+        Dwarf_Addr laddr, eaddr;
+        const char *tmp;
+        int lineno, ret = 0;
+        bool found = false;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg)
+                return -EBADF;
+
+        /* Find cu die */
+        if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie)) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        /* Find a corresponding line */
+        line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
+        if (line) {
+                if (dwarf_lineaddr(line, &laddr) == 0 &&
+                    (Dwarf_Addr)addr == laddr &&
+                    dwarf_lineno(line, &lineno) == 0) {
+                        tmp = dwarf_linesrc(line, NULL, NULL);
+                        if (tmp) {
+                                ppt->line = lineno;
+                                ppt->file = strdup(tmp);
+                                if (ppt->file == NULL) {
+                                        ret = -ENOMEM;
+                                        goto end;
+                                }
+                                found = true;
+                        }
+                }
+        }
+
+        /* Find a corresponding function */
+        if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
+                tmp = dwarf_diename(&spdie);
+                if (!tmp || dwarf_entrypc(&spdie, &eaddr) != 0)
+                        goto end;
+
+                if (ppt->line) {
+                        if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
+                                                &indie)) {
+                                /* addr in an inline function */
+                                tmp = dwarf_diename(&indie);
+                                if (!tmp)
+                                        goto end;
+                                ret = dwarf_decl_line(&indie, &lineno);
+                        } else {
+                                if (eaddr == addr) {    /* Function entry */
+                                        lineno = ppt->line;
+                                        ret = 0;
+                                } else
+                                        ret = dwarf_decl_line(&spdie, &lineno);
+                        }
+                        if (ret == 0) {
+                                /* Make a relative line number */
+                                ppt->line -= lineno;
+                                goto found;
+                        }
+                }
+                /* We don't have a line number, let's use offset */
+                ppt->offset = addr - (unsigned long)eaddr;
+found:
+                ppt->function = strdup(tmp);
+                if (ppt->function == NULL) {
+                        ret = -ENOMEM;
+                        goto end;
+                }
+                found = true;
+        }
+
+end:
+        dwarf_end(dbg);
+        if (ret >= 0)
+                ret = found ? 1 : 0;
+        return ret;
+}
+
+/* Add a line and store the src path */
+static int line_range_add_line(const char *src, unsigned int lineno,
+                               struct line_range *lr)
+{
+        /* Copy real path */
+        if (!lr->path) {
+                lr->path = strdup(src);
+                if (lr->path == NULL)
+                        return -ENOMEM;
+        }
+        return line_list__add_line(&lr->line_list, lineno);
+}
+
+/* Search function declaration lines */
+static int line_range_funcdecl_cb(Dwarf_Die *sp_die, void *data)
+{
+        struct dwarf_callback_param *param = data;
+        struct line_finder *lf = param->data;
+        const char *src;
+        int lineno;
+
+        src = dwarf_decl_file(sp_die);
+        if (src && strtailcmp(src, lf->fname) != 0)
+                return DWARF_CB_OK;
+
+        if (dwarf_decl_line(sp_die, &lineno) != 0 ||
+            (lf->lno_s > lineno || lf->lno_e < lineno))
+                return DWARF_CB_OK;
+
+        param->retval = line_range_add_line(src, lineno, lf->lr);
+        if (param->retval < 0)
+                return DWARF_CB_ABORT;
+        return DWARF_CB_OK;
+}
+
+static int find_line_range_func_decl_lines(struct line_finder *lf)
+{
+        struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
+        dwarf_getfuncs(&lf->cu_die, line_range_funcdecl_cb, &param, 0);
+        return param.retval;
 }
 
 /* Find line range from its line number */
-static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
+static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
 {
         Dwarf_Lines *lines;
         Dwarf_Line *line;
         size_t nlines, i;
         Dwarf_Addr addr;
-        int lineno;
-        int ret;
+        int lineno, ret = 0;
         const char *src;
         Dwarf_Die die_mem;
 
         line_list__init(&lf->lr->line_list);
-        ret = dwarf_getsrclines(&lf->cu_die, &lines, &nlines);
-        DIE_IF(ret != 0);
+        if (dwarf_getsrclines(&lf->cu_die, &lines, &nlines) != 0) {
+                pr_warning("No source lines found in this CU.\n");
+                return -ENOENT;
+        }
 
+        /* Search probable lines on lines list */
         for (i = 0; i < nlines; i++) {
                 line = dwarf_onesrcline(lines, i);
-                ret = dwarf_lineno(line, &lineno);
-                DIE_IF(ret != 0);
-                if (lf->lno_s > lineno || lf->lno_e < lineno)
+                if (dwarf_lineno(line, &lineno) != 0 ||
+                    (lf->lno_s > lineno || lf->lno_e < lineno))
                         continue;
 
                 if (sp_die) {
                         /* Address filtering 1: does sp_die include addr? */
-                        ret = dwarf_lineaddr(line, &addr);
-                        DIE_IF(ret != 0);
-                        if (!dwarf_haspc(sp_die, addr))
+                        if (dwarf_lineaddr(line, &addr) != 0 ||
+                            !dwarf_haspc(sp_die, addr))
                                 continue;
 
                         /* Address filtering 2: No child include addr? */
-                        if (die_get_inlinefunc(sp_die, addr, &die_mem))
+                        if (die_find_inlinefunc(sp_die, addr, &die_mem))
                                 continue;
                 }
 
@@ -725,30 +1161,49 @@ static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
                 if (strtailcmp(src, lf->fname) != 0)
                         continue;
 
-                /* Copy real path */
-                if (!lf->lr->path)
-                        lf->lr->path = strdup(src);
-                line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
+                ret = line_range_add_line(src, lineno, lf->lr);
+                if (ret < 0)
+                        return ret;
         }
+
+        /*
+         * Dwarf lines doesn't include function declarations. We have to
+         * check functions list or given function.
+         */
+        if (sp_die) {
+                src = dwarf_decl_file(sp_die);
+                if (src && dwarf_decl_line(sp_die, &lineno) == 0 &&
+                    (lf->lno_s <= lineno && lf->lno_e >= lineno))
+                        ret = line_range_add_line(src, lineno, lf->lr);
+        } else
+                ret = find_line_range_func_decl_lines(lf);
+
         /* Update status */
-        if (!list_empty(&lf->lr->line_list))
-                lf->found = 1;
+        if (ret >= 0)
+                if (!list_empty(&lf->lr->line_list))
+                        ret = lf->found = 1;
+                else
+                        ret = 0;        /* Lines are not found */
         else {
                 free(lf->lr->path);
                 lf->lr->path = NULL;
         }
+        return ret;
 }
 
 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        find_line_range_by_line(in_die, (struct line_finder *)data);
+        struct dwarf_callback_param *param = data;
+
+        param->retval = find_line_range_by_line(in_die, param->data);
         return DWARF_CB_ABORT;  /* No need to find other instances */
 }
 
 /* Search function from function name */
 static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
 {
-        struct line_finder *lf = (struct line_finder *)data;
+        struct dwarf_callback_param *param = data;
+        struct line_finder *lf = param->data;
         struct line_range *lr = lf->lr;
 
         if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
@@ -757,44 +1212,55 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
                 dwarf_decl_line(sp_die, &lr->offset);
                 pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
                 lf->lno_s = lr->offset + lr->start;
-                if (!lr->end)
+                if (lf->lno_s < 0)      /* Overflow */
+                        lf->lno_s = INT_MAX;
+                lf->lno_e = lr->offset + lr->end;
+                if (lf->lno_e < 0)      /* Overflow */
                         lf->lno_e = INT_MAX;
-                else
-                        lf->lno_e = lr->offset + lr->end;
+                pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
                 lr->start = lf->lno_s;
                 lr->end = lf->lno_e;
-                if (dwarf_func_inline(sp_die))
+                if (dwarf_func_inline(sp_die)) {
+                        struct dwarf_callback_param _param;
+                        _param.data = (void *)lf;
+                        _param.retval = 0;
                         dwarf_func_inline_instances(sp_die,
-                                                    line_range_inline_cb, lf);
-                else
-                        find_line_range_by_line(sp_die, lf);
-                return 1;
+                                                    line_range_inline_cb,
+                                                    &_param);
+                        param->retval = _param.retval;
+                } else
+                        param->retval = find_line_range_by_line(sp_die, lf);
+                return DWARF_CB_ABORT;
         }
-        return 0;
+        return DWARF_CB_OK;
 }
 
-static void find_line_range_by_func(struct line_finder *lf)
+static int find_line_range_by_func(struct line_finder *lf)
 {
-        dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0);
+        struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
+        dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
+        return param.retval;
 }
 
 int find_line_range(int fd, struct line_range *lr)
 {
         struct line_finder lf = {.lr = lr, .found = 0};
-        int ret;
+        int ret = 0;
         Dwarf_Off off = 0, noff;
         size_t cuhl;
         Dwarf_Die *diep;
         Dwarf *dbg;
 
         dbg = dwarf_begin(fd, DWARF_C_READ);
-        if (!dbg)
-                return -ENOENT;
+        if (!dbg) {
+                pr_warning("No dwarf info found in the vmlinux - "
+                        "please rebuild with CONFIG_DEBUG_INFO=y.\n");
+                return -EBADF;
+        }
 
         /* Loop on CUs (Compilation Unit) */
-        while (!lf.found) {
-                ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL);
-                if (ret != 0)
+        while (!lf.found && ret >= 0) {
+                if (dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) != 0)
                         break;
 
                 /* Get the DIE(Debugging Information Entry) of this CU */
@@ -810,20 +1276,18 @@ int find_line_range(int fd, struct line_range *lr)
 
                 if (!lr->file || lf.fname) {
                         if (lr->function)
-                                find_line_range_by_func(&lf);
+                                ret = find_line_range_by_func(&lf);
                         else {
                                 lf.lno_s = lr->start;
-                                if (!lr->end)
-                                        lf.lno_e = INT_MAX;
-                                else
-                                        lf.lno_e = lr->end;
-                                find_line_range_by_line(NULL, &lf);
+                                lf.lno_e = lr->end;
+                                ret = find_line_range_by_line(NULL, &lf);
                         }
                 }
                 off = noff;
         }
         pr_debug("path: %lx\n", (unsigned long)lr->path);
         dwarf_end(dbg);
-        return lf.found;
+
+        return (ret < 0) ? ret : lf.found;
 }
 
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 21f7354397b..66f1980e385 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -3,6 +3,7 @@
 
 #include <stdbool.h>
 #include "util.h"
+#include "probe-event.h"
 
 #define MAX_PATH_LEN             256
 #define MAX_PROBE_BUFFER        1024
@@ -14,67 +15,39 @@ static inline int is_c_varname(const char *name)
         return isalpha(name[0]) || name[0] == '_';
 }
 
-struct probe_point {
-        char                    *event;                 /* Event name */
-        char                    *group;                 /* Event group */
+#ifdef DWARF_SUPPORT
+/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
+extern int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
+                                    struct kprobe_trace_event **tevs,
+                                    int max_tevs);
 
-        /* Inputs */
-        char                    *file;                  /* File name */
-        int                     line;                   /* Line number */
-        char                    *lazy_line;             /* Lazy line pattern */
+/* Find a perf_probe_point from debuginfo */
+extern int find_perf_probe_point(int fd, unsigned long addr,
+                                 struct perf_probe_point *ppt);
 
-        char                    *function;              /* Function name */
-        int                     offset;                 /* Offset bytes */
-
-        int                     nr_args;                /* Number of arguments */
-        char                    **args;                 /* Arguments */
-
-        int                     retprobe;               /* Return probe */
-
-        /* Output */
-        int                     found;                  /* Number of found probe points */
-        char                    *probes[MAX_PROBES];    /* Output buffers (will be allocated)*/
-};
-
-/* Line number container */
-struct line_node {
-        struct list_head        list;
-        unsigned int            line;
-};
-
-/* Line range */
-struct line_range {
-        char                    *file;                  /* File name */
-        char                    *function;              /* Function name */
-        unsigned int            start;                  /* Start line number */
-        unsigned int            end;                    /* End line number */
-        int                     offset;                 /* Start line offset */
-        char                    *path;                  /* Real path name */
-        struct list_head        line_list;              /* Visible lines */
-};
-
-#ifndef NO_DWARF_SUPPORT
-extern int find_probe_point(int fd, struct probe_point *pp);
 extern int find_line_range(int fd, struct line_range *lr);
 
 #include <dwarf.h>
 #include <libdw.h>
 
 struct probe_finder {
-        struct probe_point      *pp;            /* Target probe point */
+        struct perf_probe_event *pev;           /* Target probe event */
+        struct kprobe_trace_event *tevs;        /* Result trace events */
+        int                     ntevs;          /* Number of trace events */
+        int                     max_tevs;       /* Max number of trace events */
 
         /* For function searching */
-        Dwarf_Addr              addr;           /* Address */
-        const char              *fname;         /* File name */
         int                     lno;            /* Line number */
+        Dwarf_Addr              addr;           /* Address */
+        const char              *fname;         /* Real file name */
         Dwarf_Die               cu_die;         /* Current CU */
+        struct list_head        lcache;         /* Line cache for lazy match */
 
         /* For variable searching */
+        Dwarf_CFI               *cfi;           /* Call Frame Information */
         Dwarf_Op                *fb_ops;        /* Frame base attribute */
-        const char              *var;           /* Current variable name */
-        char                    *buf;           /* Current output buffer */
-        int                     len;            /* Length of output buffer */
-        struct list_head        lcache;         /* Line cache for lazy match */
+        struct perf_probe_arg   *pvar;          /* Current target variable */
+        struct kprobe_trace_arg *tvar;          /* Current result variable */
 };
 
 struct line_finder {
@@ -87,6 +60,6 @@ struct line_finder {
         int                     found;
 };
 
-#endif /* NO_DWARF_SUPPORT */
+#endif /* DWARF_SUPPORT */
 
 #endif /*_PROBE_FINDER_H */
diff --git a/tools/perf/util/pstack.c b/tools/perf/util/pstack.c
new file mode 100644
index 00000000000..13d36faf64e
--- /dev/null
+++ b/tools/perf/util/pstack.c
@@ -0,0 +1,75 @@
+/*
+ * Simple pointer stack
+ *
+ * (c) 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+
+#include "util.h"
+#include "pstack.h"
+#include <linux/kernel.h>
+#include <stdlib.h>
+
+struct pstack {
+        unsigned short  top;
+        unsigned short  max_nr_entries;
+        void            *entries[0];
+};
+
+struct pstack *pstack__new(unsigned short max_nr_entries)
+{
+        struct pstack *self = zalloc((sizeof(*self) +
+                                     max_nr_entries * sizeof(void *)));
+        if (self != NULL)
+                self->max_nr_entries = max_nr_entries;
+        return self;
+}
+
+void pstack__delete(struct pstack *self)
+{
+        free(self);
+}
+
+bool pstack__empty(const struct pstack *self)
+{
+        return self->top == 0;
+}
+
+void pstack__remove(struct pstack *self, void *key)
+{
+        unsigned short i = self->top, last_index = self->top - 1;
+
+        while (i-- != 0) {
+                if (self->entries[i] == key) {
+                        if (i < last_index)
+                                memmove(self->entries + i,
+                                        self->entries + i + 1,
+                                        (last_index - i) * sizeof(void *));
+                        --self->top;
+                        return;
+                }
+        }
+        pr_err("%s: %p not on the pstack!\n", __func__, key);
+}
+
+void pstack__push(struct pstack *self, void *key)
+{
+        if (self->top == self->max_nr_entries) {
+                pr_err("%s: top=%d, overflow!\n", __func__, self->top);
+                return;
+        }
+        self->entries[self->top++] = key;
+}
+
+void *pstack__pop(struct pstack *self)
+{
+        void *ret;
+
+        if (self->top == 0) {
+                pr_err("%s: underflow!\n", __func__);
+                return NULL;
+        }
+
+        ret = self->entries[--self->top];
+        self->entries[self->top] = NULL;
+        return ret;
+}
diff --git a/tools/perf/util/pstack.h b/tools/perf/util/pstack.h
new file mode 100644
index 00000000000..5ad07023504
--- /dev/null
+++ b/tools/perf/util/pstack.h
@@ -0,0 +1,12 @@
+#ifndef _PERF_PSTACK_
+#define _PERF_PSTACK_
+
+struct pstack;
+struct pstack *pstack__new(unsigned short max_nr_entries);
+void pstack__delete(struct pstack *self);
+bool pstack__empty(const struct pstack *self);
+void pstack__remove(struct pstack *self, void *key);
+void pstack__push(struct pstack *self, void *key);
+void *pstack__pop(struct pstack *self);
+
+#endif /* _PERF_PSTACK_ */
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 5376378e0cf..b059dc50cc2 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -371,7 +371,6 @@ static int perl_start_script(const char *script, int argc, const char **argv)
         run_start_sub();
 
         free(command_line);
-        fprintf(stderr, "perf trace started with Perl script %s\n\n", script);
         return 0;
 error:
         perl_free(my_perl);
@@ -394,8 +393,6 @@ static int perl_stop_script(void)
         perl_destruct(my_perl);
         perl_free(my_perl);
 
-        fprintf(stderr, "\nperf trace Perl script stopped\n");
-
         return 0;
 }
 
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 6a72f14c598..81f39cab3aa 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -374,8 +374,6 @@ static int python_start_script(const char *script, int argc, const char **argv)
         }
 
         free(command_line);
-        fprintf(stderr, "perf trace started with Python script %s\n\n",
-                script);
 
         return err;
 error:
@@ -407,8 +405,6 @@ out:
         Py_XDECREF(main_module);
         Py_Finalize();
 
-        fprintf(stderr, "\nperf trace Python script stopped\n");
-
         return err;
 }
 
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index eed1cb88900..25bfca4f10f 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -14,6 +14,16 @@ static int perf_session__open(struct perf_session *self, bool force)
 {
         struct stat input_stat;
 
+        if (!strcmp(self->filename, "-")) {
+                self->fd_pipe = true;
+                self->fd = STDIN_FILENO;
+
+                if (perf_header__read(self, self->fd) < 0)
+                        pr_err("incompatible file format");
+
+                return 0;
+        }
+
         self->fd = open(self->filename, O_RDONLY);
         if (self->fd < 0) {
                 pr_err("failed to open file: %s", self->filename);
@@ -38,7 +48,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 goto out_close;
         }
 
-        if (perf_header__read(&self->header, self->fd) < 0) {
+        if (perf_header__read(self, self->fd) < 0) {
                 pr_err("incompatible file format");
                 goto out_close;
         }
@@ -52,12 +62,21 @@ out_close:
         return -1;
 }
 
-static inline int perf_session__create_kernel_maps(struct perf_session *self)
+void perf_session__update_sample_type(struct perf_session *self)
+{
+        self->sample_type = perf_header__sample_type(&self->header);
+}
+
+int perf_session__create_kernel_maps(struct perf_session *self)
 {
-        return map_groups__create_kernel_maps(&self->kmaps, self->vmlinux_maps);
+        int ret = machine__create_kernel_maps(&self->host_machine);
+
+        if (ret >= 0)
+                ret = machines__create_guest_kernel_maps(&self->machines);
+        return ret;
 }
 
-struct perf_session *perf_session__new(const char *filename, int mode, bool force)
+struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe)
 {
         size_t len = filename ? strlen(filename) + 1 : 0;
         struct perf_session *self = zalloc(sizeof(*self) + len);
@@ -70,13 +89,15 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
 
         memcpy(self->filename, filename, len);
         self->threads = RB_ROOT;
-        self->stats_by_id = RB_ROOT;
+        self->hists_tree = RB_ROOT;
         self->last_match = NULL;
         self->mmap_window = 32;
         self->cwd = NULL;
         self->cwdlen = 0;
-        self->unknown_events = 0;
-        map_groups__init(&self->kmaps);
+        self->machines = RB_ROOT;
+        self->repipe = repipe;
+        INIT_LIST_HEAD(&self->ordered_samples.samples_head);
+        machine__init(&self->host_machine, "", HOST_KERNEL_ID);
 
         if (mode == O_RDONLY) {
                 if (perf_session__open(self, force) < 0)
@@ -90,7 +111,7 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
                         goto out_delete;
         }
 
-        self->sample_type = perf_header__sample_type(&self->header);
+        perf_session__update_sample_type(self);
 out:
         return self;
 out_free:
@@ -117,22 +138,17 @@ static bool symbol__match_parent_regex(struct symbol *sym)
         return 0;
 }
 
-struct symbol **perf_session__resolve_callchain(struct perf_session *self,
-                                                struct thread *thread,
-                                                struct ip_callchain *chain,
-                                                struct symbol **parent)
+struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
+                                                   struct thread *thread,
+                                                   struct ip_callchain *chain,
+                                                   struct symbol **parent)
 {
         u8 cpumode = PERF_RECORD_MISC_USER;
-        struct symbol **syms = NULL;
         unsigned int i;
+        struct map_symbol *syms = calloc(chain->nr, sizeof(*syms));
 
-        if (symbol_conf.use_callchain) {
-                syms = calloc(chain->nr, sizeof(*syms));
-                if (!syms) {
-                        fprintf(stderr, "Can't allocate memory for symbols\n");
-                        exit(-1);
-                }
-        }
+        if (!syms)
+                return NULL;
 
         for (i = 0; i < chain->nr; i++) {
                 u64 ip = chain->ips[i];
@@ -152,15 +168,17 @@ struct symbol **perf_session__resolve_callchain(struct perf_session *self,
                         continue;
                 }
 
+                al.filtered = false;
                 thread__find_addr_location(thread, self, cpumode,
-                                           MAP__FUNCTION, ip, &al, NULL);
+                                MAP__FUNCTION, thread->pid, ip, &al, NULL);
                 if (al.sym != NULL) {
                         if (sort__has_parent && !*parent &&
                             symbol__match_parent_regex(al.sym))
                                 *parent = al.sym;
                         if (!symbol_conf.use_callchain)
                                 break;
-                        syms[i] = al.sym;
+                        syms[i].map = al.map;
+                        syms[i].sym = al.sym;
                 }
         }
 
@@ -174,6 +192,18 @@ static int process_event_stub(event_t *event __used,
         return 0;
 }
 
+static int process_finished_round_stub(event_t *event __used,
+                                       struct perf_session *session __used,
+                                       struct perf_event_ops *ops __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static int process_finished_round(event_t *event,
+                                  struct perf_session *session,
+                                  struct perf_event_ops *ops);
+
 static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
 {
         if (handler->sample == NULL)
@@ -194,29 +224,20 @@ static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
                 handler->throttle = process_event_stub;
         if (handler->unthrottle == NULL)
                 handler->unthrottle = process_event_stub;
-}
-
-static const char *event__name[] = {
-        [0]                      = "TOTAL",
-        [PERF_RECORD_MMAP]       = "MMAP",
-        [PERF_RECORD_LOST]       = "LOST",
-        [PERF_RECORD_COMM]       = "COMM",
-        [PERF_RECORD_EXIT]       = "EXIT",
-        [PERF_RECORD_THROTTLE]   = "THROTTLE",
-        [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
-        [PERF_RECORD_FORK]       = "FORK",
-        [PERF_RECORD_READ]       = "READ",
-        [PERF_RECORD_SAMPLE]     = "SAMPLE",
-};
-
-unsigned long event__total[PERF_RECORD_MAX];
-
-void event__print_totals(void)
-{
-        int i;
-        for (i = 0; i < PERF_RECORD_MAX; ++i)
-                pr_info("%10s events: %10ld\n",
-                        event__name[i], event__total[i]);
+        if (handler->attr == NULL)
+                handler->attr = process_event_stub;
+        if (handler->event_type == NULL)
+                handler->event_type = process_event_stub;
+        if (handler->tracing_data == NULL)
+                handler->tracing_data = process_event_stub;
+        if (handler->build_id == NULL)
+                handler->build_id = process_event_stub;
+        if (handler->finished_round == NULL) {
+                if (handler->ordered_samples)
+                        handler->finished_round = process_finished_round;
+                else
+                        handler->finished_round = process_finished_round_stub;
+        }
 }
 
 void mem_bswap_64(void *src, int byte_size)
@@ -270,6 +291,37 @@ static void event__read_swap(event_t *self)
         self->read.id           = bswap_64(self->read.id);
 }
 
+static void event__attr_swap(event_t *self)
+{
+        size_t size;
+
+        self->attr.attr.type            = bswap_32(self->attr.attr.type);
+        self->attr.attr.size            = bswap_32(self->attr.attr.size);
+        self->attr.attr.config          = bswap_64(self->attr.attr.config);
+        self->attr.attr.sample_period   = bswap_64(self->attr.attr.sample_period);
+        self->attr.attr.sample_type     = bswap_64(self->attr.attr.sample_type);
+        self->attr.attr.read_format     = bswap_64(self->attr.attr.read_format);
+        self->attr.attr.wakeup_events   = bswap_32(self->attr.attr.wakeup_events);
+        self->attr.attr.bp_type         = bswap_32(self->attr.attr.bp_type);
+        self->attr.attr.bp_addr         = bswap_64(self->attr.attr.bp_addr);
+        self->attr.attr.bp_len          = bswap_64(self->attr.attr.bp_len);
+
+        size = self->header.size;
+        size -= (void *)&self->attr.id - (void *)self;
+        mem_bswap_64(self->attr.id, size);
+}
+
+static void event__event_type_swap(event_t *self)
+{
+        self->event_type.event_type.event_id =
+                bswap_64(self->event_type.event_type.event_id);
+}
+
+static void event__tracing_data_swap(event_t *self)
+{
+        self->tracing_data.size = bswap_32(self->tracing_data.size);
+}
+
 typedef void (*event__swap_op)(event_t *self);
 
 static event__swap_op event__swap_ops[] = {
@@ -280,9 +332,212 @@ static event__swap_op event__swap_ops[] = {
         [PERF_RECORD_LOST]   = event__all64_swap,
         [PERF_RECORD_READ]   = event__read_swap,
         [PERF_RECORD_SAMPLE] = event__all64_swap,
-        [PERF_RECORD_MAX]    = NULL,
+        [PERF_RECORD_HEADER_ATTR]   = event__attr_swap,
+        [PERF_RECORD_HEADER_EVENT_TYPE]   = event__event_type_swap,
+        [PERF_RECORD_HEADER_TRACING_DATA]   = event__tracing_data_swap,
+        [PERF_RECORD_HEADER_BUILD_ID]   = NULL,
+        [PERF_RECORD_HEADER_MAX]    = NULL,
 };
 
+struct sample_queue {
+        u64                     timestamp;
+        struct sample_event     *event;
+        struct list_head        list;
+};
+
+static void flush_sample_queue(struct perf_session *s,
+                               struct perf_event_ops *ops)
+{
+        struct list_head *head = &s->ordered_samples.samples_head;
+        u64 limit = s->ordered_samples.next_flush;
+        struct sample_queue *tmp, *iter;
+
+        if (!ops->ordered_samples || !limit)
+                return;
+
+        list_for_each_entry_safe(iter, tmp, head, list) {
+                if (iter->timestamp > limit)
+                        return;
+
+                if (iter == s->ordered_samples.last_inserted)
+                        s->ordered_samples.last_inserted = NULL;
+
+                ops->sample((event_t *)iter->event, s);
+
+                s->ordered_samples.last_flush = iter->timestamp;
+                list_del(&iter->list);
+                free(iter->event);
+                free(iter);
+        }
+}
+
+/*
+ * When perf record finishes a pass on every buffers, it records this pseudo
+ * event.
+ * We record the max timestamp t found in the pass n.
+ * Assuming these timestamps are monotonic across cpus, we know that if
+ * a buffer still has events with timestamps below t, they will be all
+ * available and then read in the pass n + 1.
+ * Hence when we start to read the pass n + 2, we can safely flush every
+ * events with timestamps below t.
+ *
+ *    ============ PASS n =================
+ *       CPU 0         |   CPU 1
+ *                     |
+ *    cnt1 timestamps  |   cnt2 timestamps
+ *          1          |         2
+ *          2          |         3
+ *          -          |         4  <--- max recorded
+ *
+ *    ============ PASS n + 1 ==============
+ *       CPU 0         |   CPU 1
+ *                     |
+ *    cnt1 timestamps  |   cnt2 timestamps
+ *          3          |         5
+ *          4          |         6
+ *          5          |         7 <---- max recorded
+ *
+ *      Flush every events below timestamp 4
+ *
+ *    ============ PASS n + 2 ==============
+ *       CPU 0         |   CPU 1
+ *                     |
+ *    cnt1 timestamps  |   cnt2 timestamps
+ *          6          |         8
+ *          7          |         9
+ *          -          |         10
+ *
+ *      Flush every events below timestamp 7
+ *      etc...
+ */
+static int process_finished_round(event_t *event __used,
+                                  struct perf_session *session,
+                                  struct perf_event_ops *ops)
+{
+        flush_sample_queue(session, ops);
+        session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
+
+        return 0;
+}
+
+static void __queue_sample_end(struct sample_queue *new, struct list_head *head)
+{
+        struct sample_queue *iter;
+
+        list_for_each_entry_reverse(iter, head, list) {
+                if (iter->timestamp < new->timestamp) {
+                        list_add(&new->list, &iter->list);
+                        return;
+                }
+        }
+
+        list_add(&new->list, head);
+}
+
+static void __queue_sample_before(struct sample_queue *new,
+                                  struct sample_queue *iter,
+                                  struct list_head *head)
+{
+        list_for_each_entry_continue_reverse(iter, head, list) {
+                if (iter->timestamp < new->timestamp) {
+                        list_add(&new->list, &iter->list);
+                        return;
+                }
+        }
+
+        list_add(&new->list, head);
+}
+
+static void __queue_sample_after(struct sample_queue *new,
+                                 struct sample_queue *iter,
+                                 struct list_head *head)
+{
+        list_for_each_entry_continue(iter, head, list) {
+                if (iter->timestamp > new->timestamp) {
+                        list_add_tail(&new->list, &iter->list);
+                        return;
+                }
+        }
+        list_add_tail(&new->list, head);
+}
+
+/* The queue is ordered by time */
+static void __queue_sample_event(struct sample_queue *new,
+                                 struct perf_session *s)
+{
+        struct sample_queue *last_inserted = s->ordered_samples.last_inserted;
+        struct list_head *head = &s->ordered_samples.samples_head;
+
+
+        if (!last_inserted) {
+                __queue_sample_end(new, head);
+                return;
+        }
+
+        /*
+         * Most of the time the current event has a timestamp
+         * very close to the last event inserted, unless we just switched
+         * to another event buffer. Having a sorting based on a list and
+         * on the last inserted event that is close to the current one is
+         * probably more efficient than an rbtree based sorting.
+         */
+        if (last_inserted->timestamp >= new->timestamp)
+                __queue_sample_before(new, last_inserted, head);
+        else
+                __queue_sample_after(new, last_inserted, head);
+}
+
+static int queue_sample_event(event_t *event, struct sample_data *data,
+                              struct perf_session *s)
+{
+        u64 timestamp = data->time;
+        struct sample_queue *new;
+
+
+        if (timestamp < s->ordered_samples.last_flush) {
+                printf("Warning: Timestamp below last timeslice flush\n");
+                return -EINVAL;
+        }
+
+        new = malloc(sizeof(*new));
+        if (!new)
+                return -ENOMEM;
+
+        new->timestamp = timestamp;
+
+        new->event = malloc(event->header.size);
+        if (!new->event) {
+                free(new);
+                return -ENOMEM;
+        }
+
+        memcpy(new->event, event, event->header.size);
+
+        __queue_sample_event(new, s);
+        s->ordered_samples.last_inserted = new;
+
+        if (new->timestamp > s->ordered_samples.max_timestamp)
+                s->ordered_samples.max_timestamp = new->timestamp;
+
+        return 0;
+}
+
+static int perf_session__process_sample(event_t *event, struct perf_session *s,
+                                        struct perf_event_ops *ops)
+{
+        struct sample_data data;
+
+        if (!ops->ordered_samples)
+                return ops->sample(event, s);
+
+        bzero(&data, sizeof(struct sample_data));
+        event__parse_sample(event, s->sample_type, &data);
+
+        queue_sample_event(event, &data, s);
+
+        return 0;
+}
+
 static int perf_session__process_event(struct perf_session *self,
                                        event_t *event,
                                        struct perf_event_ops *ops,
@@ -290,12 +545,11 @@ static int perf_session__process_event(struct perf_session *self,
 {
         trace_event(event);
 
-        if (event->header.type < PERF_RECORD_MAX) {
+        if (event->header.type < PERF_RECORD_HEADER_MAX) {
                 dump_printf("%#Lx [%#x]: PERF_RECORD_%s",
                             offset + head, event->header.size,
                             event__name[event->header.type]);
-                ++event__total[0];
-                ++event__total[event->header.type];
+                hists__inc_nr_events(&self->hists, event->header.type);
         }
 
         if (self->header.needs_swap && event__swap_ops[event->header.type])
@@ -303,7 +557,7 @@ static int perf_session__process_event(struct perf_session *self,
 
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
-                return ops->sample(event, self);
+                return perf_session__process_sample(event, self, ops);
         case PERF_RECORD_MMAP:
                 return ops->mmap(event, self);
         case PERF_RECORD_COMM:
@@ -320,8 +574,20 @@ static int perf_session__process_event(struct perf_session *self,
                 return ops->throttle(event, self);
         case PERF_RECORD_UNTHROTTLE:
                 return ops->unthrottle(event, self);
+        case PERF_RECORD_HEADER_ATTR:
+                return ops->attr(event, self);
+        case PERF_RECORD_HEADER_EVENT_TYPE:
+                return ops->event_type(event, self);
+        case PERF_RECORD_HEADER_TRACING_DATA:
+                /* setup for reading amidst mmap */
+                lseek(self->fd, offset + head, SEEK_SET);
+                return ops->tracing_data(event, self);
+        case PERF_RECORD_HEADER_BUILD_ID:
+                return ops->build_id(event, self);
+        case PERF_RECORD_FINISHED_ROUND:
+                return ops->finished_round(event, self, ops);
         default:
-                self->unknown_events++;
+                ++self->hists.stats.nr_unknown_events;
                 return -1;
         }
 }
@@ -333,56 +599,114 @@ void perf_event_header__bswap(struct perf_event_header *self)
         self->size = bswap_16(self->size);
 }
 
-int perf_header__read_build_ids(struct perf_header *self,
-                                int input, u64 offset, u64 size)
+static struct thread *perf_session__register_idle_thread(struct perf_session *self)
 {
-        struct build_id_event bev;
-        char filename[PATH_MAX];
-        u64 limit = offset + size;
-        int err = -1;
-
-        while (offset < limit) {
-                struct dso *dso;
-                ssize_t len;
-                struct list_head *head = &dsos__user;
+        struct thread *thread = perf_session__findnew(self, 0);
 
-                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
-                        goto out;
+        if (thread == NULL || thread__set_comm(thread, "swapper")) {
+                pr_err("problem inserting idle task.\n");
+                thread = NULL;
+        }
 
-                if (self->needs_swap)
-                        perf_event_header__bswap(&bev.header);
+        return thread;
+}
 
-                len = bev.header.size - sizeof(bev);
-                if (read(input, filename, len) != len)
-                        goto out;
+int do_read(int fd, void *buf, size_t size)
+{
+        void *buf_start = buf;
 
-                if (bev.header.misc & PERF_RECORD_MISC_KERNEL)
-                        head = &dsos__kernel;
+        while (size) {
+                int ret = read(fd, buf, size);
 
-                dso = __dsos__findnew(head, filename);
-                if (dso != NULL) {
-                        dso__set_build_id(dso, &bev.build_id);
-                        if (head == &dsos__kernel && filename[0] == '[')
-                                dso->kernel = 1;
-                }
+                if (ret <= 0)
+                        return ret;
 
-                offset += bev.header.size;
+                size -= ret;
+                buf += ret;
         }
-        err = 0;
-out:
-        return err;
+
+        return buf - buf_start;
 }
 
-static struct thread *perf_session__register_idle_thread(struct perf_session *self)
+#define session_done()  (*(volatile int *)(&session_done))
+volatile int session_done;
+
+static int __perf_session__process_pipe_events(struct perf_session *self,
+                                               struct perf_event_ops *ops)
 {
-        struct thread *thread = perf_session__findnew(self, 0);
+        event_t event;
+        uint32_t size;
+        int skip = 0;
+        u64 head;
+        int err;
+        void *p;
 
-        if (thread == NULL || thread__set_comm(thread, "swapper")) {
-                pr_err("problem inserting idle task.\n");
-                thread = NULL;
+        perf_event_ops__fill_defaults(ops);
+
+        head = 0;
+more:
+        err = do_read(self->fd, &event, sizeof(struct perf_event_header));
+        if (err <= 0) {
+                if (err == 0)
+                        goto done;
+
+                pr_err("failed to read event header\n");
+                goto out_err;
         }
 
-        return thread;
+        if (self->header.needs_swap)
+                perf_event_header__bswap(&event.header);
+
+        size = event.header.size;
+        if (size == 0)
+                size = 8;
+
+        p = &event;
+        p += sizeof(struct perf_event_header);
+
+        if (size - sizeof(struct perf_event_header)) {
+                err = do_read(self->fd, p,
+                              size - sizeof(struct perf_event_header));
+                if (err <= 0) {
+                        if (err == 0) {
+                                pr_err("unexpected end of event stream\n");
+                                goto done;
+                        }
+
+                        pr_err("failed to read event data\n");
+                        goto out_err;
+                }
+        }
+
+        if (size == 0 ||
+            (skip = perf_session__process_event(self, &event, ops,
+                                                0, head)) < 0) {
+                dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
+                            head, event.header.size, event.header.type);
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        dump_printf("\n%#Lx [%#x]: event: %d\n",
+                    head, event.header.size, event.header.type);
+
+        if (skip > 0)
+                head += skip;
+
+        if (!session_done())
+                goto more;
+done:
+        err = 0;
+out_err:
+        return err;
 }
 
 int __perf_session__process_events(struct perf_session *self,
@@ -396,6 +720,10 @@ int __perf_session__process_events(struct perf_session *self,
         event_t *event;
         uint32_t size;
         char *buf;
+        struct ui_progress *progress = ui_progress__new("Processing events...",
+                                                        self->size);
+        if (progress == NULL)
+                return -1;
 
         perf_event_ops__fill_defaults(ops);
 
@@ -424,6 +752,7 @@ remap:
 
 more:
         event = (event_t *)(buf + head);
+        ui_progress__update(progress, offset);
 
         if (self->header.needs_swap)
                 perf_event_header__bswap(&event->header);
@@ -473,7 +802,11 @@ more:
                 goto more;
 done:
         err = 0;
+        /* do the final flush for ordered samples */
+        self->ordered_samples.next_flush = ULLONG_MAX;
+        flush_sample_queue(self, ops);
 out_err:
+        ui_progress__delete(progress);
         return err;
 }
 
@@ -502,9 +835,13 @@ out_getcwd_err:
                 self->cwdlen = strlen(self->cwd);
         }
 
-        err = __perf_session__process_events(self, self->header.data_offset,
-                                             self->header.data_size,
-                                             self->size, ops);
+        if (!self->fd_pipe)
+                err = __perf_session__process_events(self,
+                                                     self->header.data_offset,
+                                                     self->header.data_size,
+                                                     self->size, ops);
+        else
+                err = __perf_session__process_pipe_events(self, ops);
 out_err:
         return err;
 }
@@ -519,56 +856,41 @@ bool perf_session__has_traces(struct perf_session *self, const char *msg)
         return true;
 }
 
-int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
+int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
                                              const char *symbol_name,
                                              u64 addr)
 {
         char *bracket;
         enum map_type i;
+        struct ref_reloc_sym *ref;
 
-        self->ref_reloc_sym.name = strdup(symbol_name);
-        if (self->ref_reloc_sym.name == NULL)
+        ref = zalloc(sizeof(struct ref_reloc_sym));
+        if (ref == NULL)
                 return -ENOMEM;
 
-        bracket = strchr(self->ref_reloc_sym.name, ']');
+        ref->name = strdup(symbol_name);
+        if (ref->name == NULL) {
+                free(ref);
+                return -ENOMEM;
+        }
+
+        bracket = strchr(ref->name, ']');
         if (bracket)
                 *bracket = '\0';
 
-        self->ref_reloc_sym.addr = addr;
+        ref->addr = addr;
 
         for (i = 0; i < MAP__NR_TYPES; ++i) {
-                struct kmap *kmap = map__kmap(self->vmlinux_maps[i]);
-                kmap->ref_reloc_sym = &self->ref_reloc_sym;
+                struct kmap *kmap = map__kmap(maps[i]);
+                kmap->ref_reloc_sym = ref;
         }
 
         return 0;
 }
 
-static u64 map__reloc_map_ip(struct map *map, u64 ip)
-{
-        return ip + (s64)map->pgoff;
-}
-
-static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
-{
-        return ip - (s64)map->pgoff;
-}
-
-void map__reloc_vmlinux(struct map *self)
+size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
 {
-        struct kmap *kmap = map__kmap(self);
-        s64 reloc;
-
-        if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
-                return;
-
-        reloc = (kmap->ref_reloc_sym->unrelocated_addr -
-                 kmap->ref_reloc_sym->addr);
-
-        if (!reloc)
-                return;
-
-        self->map_ip   = map__reloc_map_ip;
-        self->unmap_ip = map__reloc_unmap_ip;
-        self->pgoff    = reloc;
+        return __dsos__fprintf(&self->host_machine.kernel_dsos, fp) +
+               __dsos__fprintf(&self->host_machine.user_dsos, fp) +
+               machines__fprintf_dsos(&self->machines, fp);
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 5c33417eebb..e7fce486ebe 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -1,6 +1,7 @@
 #ifndef __PERF_SESSION_H
 #define __PERF_SESSION_H
 
+#include "hist.h"
 #include "event.h"
 #include "header.h"
 #include "symbol.h"
@@ -8,45 +9,69 @@
 #include <linux/rbtree.h>
 #include "../../../include/linux/perf_event.h"
 
+struct sample_queue;
 struct ip_callchain;
 struct thread;
 
+struct ordered_samples {
+        u64                     last_flush;
+        u64                     next_flush;
+        u64                     max_timestamp;
+        struct list_head        samples_head;
+        struct sample_queue     *last_inserted;
+};
+
 struct perf_session {
         struct perf_header      header;
         unsigned long           size;
         unsigned long           mmap_window;
-        struct map_groups       kmaps;
         struct rb_root          threads;
         struct thread           *last_match;
-        struct map              *vmlinux_maps[MAP__NR_TYPES];
-        struct events_stats     events_stats;
-        struct rb_root          stats_by_id;
-        unsigned long           event_total[PERF_RECORD_MAX];
-        unsigned long           unknown_events;
-        struct rb_root          hists;
+        struct machine          host_machine;
+        struct rb_root          machines;
+        struct rb_root          hists_tree;
+        /*
+         * FIXME: should point to the first entry in hists_tree and
+         *        be a hists instance. Right now its only 'report'
+         *        that is using ->hists_tree while all the rest use
+         *        ->hists.
+         */
+        struct hists            hists;
         u64                     sample_type;
-        struct ref_reloc_sym    ref_reloc_sym;
         int                     fd;
+        bool                    fd_pipe;
+        bool                    repipe;
         int                     cwdlen;
         char                    *cwd;
+        struct ordered_samples  ordered_samples;
         char filename[0];
 };
 
+struct perf_event_ops;
+
 typedef int (*event_op)(event_t *self, struct perf_session *session);
+typedef int (*event_op2)(event_t *self, struct perf_session *session,
+                         struct perf_event_ops *ops);
 
 struct perf_event_ops {
-        event_op sample,
-                 mmap,
-                 comm,
-                 fork,
-                 exit,
-                 lost,
-                 read,
-                 throttle,
-                 unthrottle;
+        event_op        sample,
+                        mmap,
+                        comm,
+                        fork,
+                        exit,
+                        lost,
+                        read,
+                        throttle,
+                        unthrottle,
+                        attr,
+                        event_type,
+                        tracing_data,
+                        build_id;
+        event_op2       finished_round;
+        bool            ordered_samples;
 };
 
-struct perf_session *perf_session__new(const char *filename, int mode, bool force);
+struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe);
 void perf_session__delete(struct perf_session *self);
 
 void perf_event_header__bswap(struct perf_event_header *self);
@@ -57,33 +82,66 @@ int __perf_session__process_events(struct perf_session *self,
 int perf_session__process_events(struct perf_session *self,
                                  struct perf_event_ops *event_ops);
 
-struct symbol **perf_session__resolve_callchain(struct perf_session *self,
-                                                struct thread *thread,
-                                                struct ip_callchain *chain,
-                                                struct symbol **parent);
+struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
+                                                   struct thread *thread,
+                                                   struct ip_callchain *chain,
+                                                   struct symbol **parent);
 
 bool perf_session__has_traces(struct perf_session *self, const char *msg);
 
-int perf_header__read_build_ids(struct perf_header *self, int input,
-                                u64 offset, u64 file_size);
-
-int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
+int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
                                              const char *symbol_name,
                                              u64 addr);
 
 void mem_bswap_64(void *src, int byte_size);
 
-static inline int __perf_session__create_kernel_maps(struct perf_session *self,
-                                                struct dso *kernel)
+int perf_session__create_kernel_maps(struct perf_session *self);
+
+int do_read(int fd, void *buf, size_t size);
+void perf_session__update_sample_type(struct perf_session *self);
+
+static inline
+struct machine *perf_session__find_host_machine(struct perf_session *self)
+{
+        return &self->host_machine;
+}
+
+static inline
+struct machine *perf_session__find_machine(struct perf_session *self, pid_t pid)
+{
+        if (pid == HOST_KERNEL_ID)
+                return &self->host_machine;
+        return machines__find(&self->machines, pid);
+}
+
+static inline
+struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t pid)
+{
+        if (pid == HOST_KERNEL_ID)
+                return &self->host_machine;
+        return machines__findnew(&self->machines, pid);
+}
+
+static inline
+void perf_session__process_machines(struct perf_session *self,
+                                    machine__process_t process)
+{
+        process(&self->host_machine, self);
+        return machines__process(&self->machines, process, self);
+}
+
+size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp);
+
+static inline
+size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
+                                          bool with_hits)
 {
-        return __map_groups__create_kernel_maps(&self->kmaps,
-                                                self->vmlinux_maps, kernel);
+        return machines__fprintf_dsos_buildid(&self->machines, fp, with_hits);
 }
 
-static inline struct map *
-        perf_session__new_module_map(struct perf_session *self,
-                                     u64 start, const char *filename)
+static inline
+size_t perf_session__fprintf_nr_events(struct perf_session *self, FILE *fp)
 {
-        return map_groups__new_module(&self->kmaps, start, filename);
+        return hists__fprintf_nr_events(&self->hists, fp);
 }
 #endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index cb0f327de9e..2316cb5a411 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,10 +1,10 @@
 #include "sort.h"
 
 regex_t         parent_regex;
-char            default_parent_pattern[] = "^sys_|^do_page_fault";
-char            *parent_pattern = default_parent_pattern;
-char            default_sort_order[] = "comm,dso,symbol";
-char            *sort_order = default_sort_order;
+const char      default_parent_pattern[] = "^sys_|^do_page_fault";
+const char      *parent_pattern = default_parent_pattern;
+const char      default_sort_order[] = "comm,dso,symbol";
+const char      *sort_order = default_sort_order;
 int             sort__need_collapse = 0;
 int             sort__has_parent = 0;
 
@@ -18,39 +18,50 @@ char * field_sep;
 
 LIST_HEAD(hist_entry__sort_list);
 
+static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width);
+static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
+                                     size_t size, unsigned int width);
+static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width);
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width);
+static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width);
+
 struct sort_entry sort_thread = {
-        .header = "Command:  Pid",
-        .cmp    = sort__thread_cmp,
-        .print  = sort__thread_print,
-        .width  = &threads__col_width,
+        .se_header      = "Command:  Pid",
+        .se_cmp         = sort__thread_cmp,
+        .se_snprintf    = hist_entry__thread_snprintf,
+        .se_width       = &threads__col_width,
 };
 
 struct sort_entry sort_comm = {
-        .header         = "Command",
-        .cmp            = sort__comm_cmp,
-        .collapse       = sort__comm_collapse,
-        .print          = sort__comm_print,
-        .width          = &comms__col_width,
+        .se_header      = "Command",
+        .se_cmp         = sort__comm_cmp,
+        .se_collapse    = sort__comm_collapse,
+        .se_snprintf    = hist_entry__comm_snprintf,
+        .se_width       = &comms__col_width,
 };
 
 struct sort_entry sort_dso = {
-        .header = "Shared Object",
-        .cmp    = sort__dso_cmp,
-        .print  = sort__dso_print,
-        .width  = &dsos__col_width,
+        .se_header      = "Shared Object",
+        .se_cmp         = sort__dso_cmp,
+        .se_snprintf    = hist_entry__dso_snprintf,
+        .se_width       = &dsos__col_width,
 };
 
 struct sort_entry sort_sym = {
-        .header = "Symbol",
-        .cmp    = sort__sym_cmp,
-        .print  = sort__sym_print,
+        .se_header      = "Symbol",
+        .se_cmp         = sort__sym_cmp,
+        .se_snprintf    = hist_entry__sym_snprintf,
 };
 
 struct sort_entry sort_parent = {
-        .header = "Parent symbol",
-        .cmp    = sort__parent_cmp,
-        .print  = sort__parent_print,
-        .width  = &parent_symbol__col_width,
+        .se_header      = "Parent symbol",
+        .se_cmp         = sort__parent_cmp,
+        .se_snprintf    = hist_entry__parent_snprintf,
+        .se_width       = &parent_symbol__col_width,
 };
 
 struct sort_dimension {
@@ -85,45 +96,38 @@ sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
         return right->thread->pid - left->thread->pid;
 }
 
-int repsep_fprintf(FILE *fp, const char *fmt, ...)
+static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
 {
         int n;
         va_list ap;
 
         va_start(ap, fmt);
-        if (!field_sep)
-                n = vfprintf(fp, fmt, ap);
-        else {
-                char *bf = NULL;
-                n = vasprintf(&bf, fmt, ap);
-                if (n > 0) {
-                        char *sep = bf;
-
-                        while (1) {
-                                sep = strchr(sep, *field_sep);
-                                if (sep == NULL)
-                                        break;
-                                *sep = '.';
-                        }
+        n = vsnprintf(bf, size, fmt, ap);
+        if (field_sep && n > 0) {
+                char *sep = bf;
+
+                while (1) {
+                        sep = strchr(sep, *field_sep);
+                        if (sep == NULL)
+                                break;
+                        *sep = '.';
                 }
-                fputs(bf, fp);
-                free(bf);
         }
         va_end(ap);
         return n;
 }
 
-size_t
-sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
 {
-        return repsep_fprintf(fp, "%*s:%5d", width - 6,
+        return repsep_snprintf(bf, size, "%*s:%5d", width,
                               self->thread->comm ?: "", self->thread->pid);
 }
 
-size_t
-sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
+                                     size_t size, unsigned int width)
 {
-        return repsep_fprintf(fp, "%*s", width, self->thread->comm);
+        return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
 }
 
 /* --sort dso */
@@ -131,8 +135,8 @@ sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
 int64_t
 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 {
-        struct dso *dso_l = left->map ? left->map->dso : NULL;
-        struct dso *dso_r = right->map ? right->map->dso : NULL;
+        struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
+        struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
         const char *dso_name_l, *dso_name_r;
 
         if (!dso_l || !dso_r)
@@ -149,16 +153,16 @@ sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
         return strcmp(dso_name_l, dso_name_r);
 }
 
-size_t
-sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
 {
-        if (self->map && self->map->dso) {
-                const char *dso_name = !verbose ? self->map->dso->short_name :
-                                                  self->map->dso->long_name;
-                return repsep_fprintf(fp, "%-*s", width, dso_name);
+        if (self->ms.map && self->ms.map->dso) {
+                const char *dso_name = !verbose ? self->ms.map->dso->short_name :
+                                                  self->ms.map->dso->long_name;
+                return repsep_snprintf(bf, size, "%-*s", width, dso_name);
         }
 
-        return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
+        return repsep_snprintf(bf, size, "%*Lx", width, self->ip);
 }
 
 /* --sort symbol */
@@ -168,31 +172,31 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         u64 ip_l, ip_r;
 
-        if (left->sym == right->sym)
+        if (left->ms.sym == right->ms.sym)
                 return 0;
 
-        ip_l = left->sym ? left->sym->start : left->ip;
-        ip_r = right->sym ? right->sym->start : right->ip;
+        ip_l = left->ms.sym ? left->ms.sym->start : left->ip;
+        ip_r = right->ms.sym ? right->ms.sym->start : right->ip;
 
         return (int64_t)(ip_r - ip_l);
 }
 
-
-size_t
-sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width __used)
 {
         size_t ret = 0;
 
         if (verbose) {
-                char o = self->map ? dso__symtab_origin(self->map->dso) : '!';
-                ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip, o);
+                char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
+                ret += repsep_snprintf(bf, size, "%#018llx %c ", self->ip, o);
         }
 
-        ret += repsep_fprintf(fp, "[%c] ", self->level);
-        if (self->sym)
-                ret += repsep_fprintf(fp, "%s", self->sym->name);
+        ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
+        if (self->ms.sym)
+                ret += repsep_snprintf(bf + ret, size - ret, "%s",
+                                       self->ms.sym->name);
         else
-                ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
+                ret += repsep_snprintf(bf + ret, size - ret, "%#016llx", self->ip);
 
         return ret;
 }
@@ -231,10 +235,10 @@ sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
         return strcmp(sym_l->name, sym_r->name);
 }
 
-size_t
-sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
 {
-        return repsep_fprintf(fp, "%-*s", width,
+        return repsep_snprintf(bf, size, "%-*s", width,
                               self->parent ? self->parent->name : "[other]");
 }
 
@@ -251,7 +255,7 @@ int sort_dimension__add(const char *tok)
                 if (strncasecmp(tok, sd->name, strlen(tok)))
                         continue;
 
-                if (sd->entry->collapse)
+                if (sd->entry->se_collapse)
                         sort__need_collapse = 1;
 
                 if (sd->entry == &sort_parent) {
@@ -260,9 +264,8 @@ int sort_dimension__add(const char *tok)
                                 char err[BUFSIZ];
 
                                 regerror(ret, &parent_regex, err, sizeof(err));
-                                fprintf(stderr, "Invalid regex: %s\n%s",
-                                        parent_pattern, err);
-                                exit(-1);
+                                pr_err("Invalid regex: %s\n%s", parent_pattern, err);
+                                return -EINVAL;
                         }
                         sort__has_parent = 1;
                 }
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 753f9ea99fb..0d61c4082f4 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -25,10 +25,10 @@
 #include "sort.h"
 
 extern regex_t parent_regex;
-extern char *sort_order;
-extern char default_parent_pattern[];
-extern char *parent_pattern;
-extern char default_sort_order[];
+extern const char *sort_order;
+extern const char default_parent_pattern[];
+extern const char *parent_pattern;
+extern const char default_sort_order[];
 extern int sort__need_collapse;
 extern int sort__has_parent;
 extern char *field_sep;
@@ -43,19 +43,24 @@ extern enum sort_type sort__first_dimension;
 
 struct hist_entry {
         struct rb_node          rb_node;
-        u64                     count;
+        u64                     period;
+        u64                     period_sys;
+        u64                     period_us;
+        u64                     period_guest_sys;
+        u64                     period_guest_us;
+        struct map_symbol       ms;
         struct thread           *thread;
-        struct map              *map;
-        struct symbol           *sym;
         u64                     ip;
+        u32                     nr_events;
         char                    level;
-        struct symbol     *parent;
-        struct callchain_node   callchain;
+        u8                      filtered;
+        struct symbol           *parent;
         union {
                 unsigned long     position;
                 struct hist_entry *pair;
                 struct rb_root    sorted_chain;
         };
+        struct callchain_node   callchain[0];
 };
 
 enum sort_type {
@@ -73,12 +78,13 @@ enum sort_type {
 struct sort_entry {
         struct list_head list;
 
-        const char *header;
+        const char *se_header;
 
-        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
-        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
-        size_t  (*print)(FILE *fp, struct hist_entry *, unsigned int width);
-        unsigned int *width;
+        int64_t (*se_cmp)(struct hist_entry *, struct hist_entry *);
+        int64_t (*se_collapse)(struct hist_entry *, struct hist_entry *);
+        int     (*se_snprintf)(struct hist_entry *self, char *bf, size_t size,
+                               unsigned int width);
+        unsigned int *se_width;
         bool    elide;
 };
 
@@ -87,7 +93,6 @@ extern struct list_head hist_entry__sort_list;
 
 void setup_sorting(const char * const usagestr[], const struct option *opts);
 
-extern int repsep_fprintf(FILE *fp, const char *fmt, ...);
 extern size_t sort__thread_print(FILE *, struct hist_entry *, unsigned int);
 extern size_t sort__comm_print(FILE *, struct hist_entry *, unsigned int);
 extern size_t sort__dso_print(FILE *, struct hist_entry *, unsigned int);
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index a175949ed21..0409fc7c005 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,48 +1,5 @@
-#include "string.h"
 #include "util.h"
-
-static int hex(char ch)
-{
-        if ((ch >= '0') && (ch <= '9'))
-                return ch - '0';
-        if ((ch >= 'a') && (ch <= 'f'))
-                return ch - 'a' + 10;
-        if ((ch >= 'A') && (ch <= 'F'))
-                return ch - 'A' + 10;
-        return -1;
-}
-
-/*
- * While we find nice hex chars, build a long_val.
- * Return number of chars processed.
- */
-int hex2u64(const char *ptr, u64 *long_val)
-{
-        const char *p = ptr;
-        *long_val = 0;
-
-        while (*p) {
-                const int hex_val = hex(*p);
-
-                if (hex_val < 0)
-                        break;
-
-                *long_val = (*long_val << 4) | hex_val;
-                p++;
-        }
-
-        return p - ptr;
-}
-
-char *strxfrchar(char *s, char from, char to)
-{
-        char *p = s;
-
-        while ((p = strchr(p, from)) != NULL)
-                *p++ = to;
-
-        return s;
-}
+#include "string.h"
 
 #define K 1024LL
 /*
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
deleted file mode 100644
index 542e44de371..00000000000
--- a/tools/perf/util/string.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef __PERF_STRING_H_
-#define __PERF_STRING_H_
-
-#include <stdbool.h>
-#include "types.h"
-
-int hex2u64(const char *ptr, u64 *val);
-char *strxfrchar(char *s, char from, char to);
-s64 perf_atoll(const char *str);
-char **argv_split(const char *str, int *argcp);
-void argv_free(char **argv);
-bool strglobmatch(const char *str, const char *pat);
-bool strlazymatch(const char *str, const char *pat);
-
-#define _STR(x) #x
-#define STR(x) _STR(x)
-
-#endif /* __PERF_STRING_H */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index c458c4a371d..a06131f6259 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,13 +1,19 @@
-#include "util.h"
-#include "../perf.h"
-#include "sort.h"
-#include "string.h"
+#define _GNU_SOURCE
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <fcntl.h>
+#include <unistd.h>
 #include "symbol.h"
-#include "thread.h"
+#include "strlist.h"
 
-#include "debug.h"
-
-#include <asm/bug.h>
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
@@ -18,22 +24,12 @@
 #define NT_GNU_BUILD_ID 3
 #endif
 
-enum dso_origin {
-        DSO__ORIG_KERNEL = 0,
-        DSO__ORIG_JAVA_JIT,
-        DSO__ORIG_BUILD_ID_CACHE,
-        DSO__ORIG_FEDORA,
-        DSO__ORIG_UBUNTU,
-        DSO__ORIG_BUILDID,
-        DSO__ORIG_DSO,
-        DSO__ORIG_KMODULE,
-        DSO__ORIG_NOT_FOUND,
-};
-
 static void dsos__add(struct list_head *head, struct dso *dso);
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 static int dso__load_kernel_sym(struct dso *self, struct map *map,
                                 symbol_filter_t filter);
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
+                        symbol_filter_t filter);
 static int vmlinux_path__nr_entries;
 static char **vmlinux_path;
 
@@ -126,16 +122,17 @@ static void map_groups__fixup_end(struct map_groups *self)
 static struct symbol *symbol__new(u64 start, u64 len, const char *name)
 {
         size_t namelen = strlen(name) + 1;
-        struct symbol *self = zalloc(symbol_conf.priv_size +
-                                     sizeof(*self) + namelen);
+        struct symbol *self = calloc(1, (symbol_conf.priv_size +
+                                         sizeof(*self) + namelen));
         if (self == NULL)
                 return NULL;
 
         if (symbol_conf.priv_size)
                 self = ((void *)self) + symbol_conf.priv_size;
 
-        self->start = start;
-        self->end   = len ? start + len - 1 : start;
+        self->start   = start;
+        self->end     = len ? start + len - 1 : start;
+        self->namelen = namelen - 1;
 
         pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
 
@@ -178,7 +175,7 @@ static void dso__set_basename(struct dso *self)
 
 struct dso *dso__new(const char *name)
 {
-        struct dso *self = zalloc(sizeof(*self) + strlen(name) + 1);
+        struct dso *self = calloc(1, sizeof(*self) + strlen(name) + 1);
 
         if (self != NULL) {
                 int i;
@@ -192,6 +189,8 @@ struct dso *dso__new(const char *name)
                 self->loaded = 0;
                 self->sorted_by_name = 0;
                 self->has_build_id = 0;
+                self->kernel = DSO_TYPE_USER;
+                INIT_LIST_HEAD(&self->node);
         }
 
         return self;
@@ -408,12 +407,9 @@ int kallsyms__parse(const char *filename, void *arg,
                 char *symbol_name;
 
                 line_len = getline(&line, &n, file);
-                if (line_len < 0)
+                if (line_len < 0 || !line)
                         break;
 
-                if (!line)
-                        goto out_failure;
-
                 line[--line_len] = '\0'; /* \n */
 
                 len = hex2u64(line, &start);
@@ -465,6 +461,7 @@ static int map__process_kallsym_symbol(void *arg, const char *name,
          * map__split_kallsyms, when we have split the maps per module
          */
         symbols__insert(root, sym);
+
         return 0;
 }
 
@@ -489,6 +486,7 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
                                symbol_filter_t filter)
 {
         struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct machine *machine = kmaps->machine;
         struct map *curr_map = map;
         struct symbol *pos;
         int count = 0;
@@ -510,15 +508,33 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
                         *module++ = '\0';
 
                         if (strcmp(curr_map->dso->short_name, module)) {
-                                curr_map = map_groups__find_by_name(kmaps, map->type, module);
+                                if (curr_map != map &&
+                                    self->kernel == DSO_TYPE_GUEST_KERNEL &&
+                                    machine__is_default_guest(machine)) {
+                                        /*
+                                         * We assume all symbols of a module are
+                                         * continuous in * kallsyms, so curr_map
+                                         * points to a module and all its
+                                         * symbols are in its kmap. Mark it as
+                                         * loaded.
+                                         */
+                                        dso__set_loaded(curr_map->dso,
+                                                        curr_map->type);
+                                }
+
+                                curr_map = map_groups__find_by_name(kmaps,
+                                                        map->type, module);
                                 if (curr_map == NULL) {
-                                        pr_debug("/proc/{kallsyms,modules} "
+                                        pr_debug("%s/proc/{kallsyms,modules} "
                                                  "inconsistency while looking "
-                                                 "for \"%s\" module!\n", module);
-                                        return -1;
+                                                 "for \"%s\" module!\n",
+                                                 machine->root_dir, module);
+                                        curr_map = map;
+                                        goto discard_symbol;
                                 }
 
-                                if (curr_map->dso->loaded)
+                                if (curr_map->dso->loaded &&
+                                    !machine__is_default_guest(machine))
                                         goto discard_symbol;
                         }
                         /*
@@ -531,13 +547,21 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
                         char dso_name[PATH_MAX];
                         struct dso *dso;
 
-                        snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
-                                 kernel_range++);
+                        if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                                snprintf(dso_name, sizeof(dso_name),
+                                        "[guest.kernel].%d",
+                                        kernel_range++);
+                        else
+                                snprintf(dso_name, sizeof(dso_name),
+                                        "[kernel].%d",
+                                        kernel_range++);
 
                         dso = dso__new(dso_name);
                         if (dso == NULL)
                                 return -1;
 
+                        dso->kernel = self->kernel;
+
                         curr_map = map__new2(pos->start, dso, map->type);
                         if (curr_map == NULL) {
                                 dso__delete(dso);
@@ -561,6 +585,12 @@ discard_symbol:		rb_erase(&pos->rb_node, root);
                 }
         }
 
+        if (curr_map != map &&
+            self->kernel == DSO_TYPE_GUEST_KERNEL &&
+            machine__is_default_guest(kmaps->machine)) {
+                dso__set_loaded(curr_map->dso, curr_map->type);
+        }
+
         return count;
 }
 
@@ -571,7 +601,10 @@ int dso__load_kallsyms(struct dso *self, const char *filename,
                 return -1;
 
         symbols__fixup_end(&self->symbols[map->type]);
-        self->origin = DSO__ORIG_KERNEL;
+        if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                self->origin = DSO__ORIG_GUEST_KERNEL;
+        else
+                self->origin = DSO__ORIG_KERNEL;
 
         return dso__split_kallsyms(self, map, filter);
 }
@@ -870,8 +903,8 @@ out_close:
         if (err == 0)
                 return nr;
 out:
-        pr_warning("%s: problems reading %s PLT info.\n",
-                   __func__, self->long_name);
+        pr_debug("%s: problems reading %s PLT info.\n",
+                 __func__, self->long_name);
         return 0;
 }
 
@@ -958,7 +991,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
         nr_syms = shdr.sh_size / shdr.sh_entsize;
 
         memset(&sym, 0, sizeof(sym));
-        if (!self->kernel) {
+        if (self->kernel == DSO_TYPE_USER) {
                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
                                 elf_section_by_name(elf, &ehdr, &shdr,
                                                      ".gnu.prelink_undo",
@@ -990,7 +1023,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
 
                 section_name = elf_sec__name(&shdr, secstrs);
 
-                if (self->kernel || kmodule) {
+                if (self->kernel != DSO_TYPE_USER || kmodule) {
                         char dso_name[PATH_MAX];
 
                         if (strcmp(section_name,
@@ -1017,6 +1050,7 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                                 curr_dso = dso__new(dso_name);
                                 if (curr_dso == NULL)
                                         goto out_elf_end;
+                                curr_dso->kernel = self->kernel;
                                 curr_map = map__new2(start, curr_dso,
                                                      map->type);
                                 if (curr_map == NULL) {
@@ -1025,9 +1059,9 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                                 }
                                 curr_map->map_ip = identity__map_ip;
                                 curr_map->unmap_ip = identity__map_ip;
-                                curr_dso->origin = DSO__ORIG_KERNEL;
+                                curr_dso->origin = self->origin;
                                 map_groups__insert(kmap->kmaps, curr_map);
-                                dsos__add(&dsos__kernel, curr_dso);
+                                dsos__add(&self->node, curr_dso);
                                 dso__set_loaded(curr_dso, map->type);
                         } else
                                 curr_dso = curr_map->dso;
@@ -1089,7 +1123,7 @@ static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
         return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
 }
 
-static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
+bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
         bool have_build_id = false;
         struct dso *pos;
@@ -1107,13 +1141,6 @@ static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
         return have_build_id;
 }
 
-bool dsos__read_build_ids(bool with_hits)
-{
-        bool kbuildids = __dsos__read_build_ids(&dsos__kernel, with_hits),
-             ubuildids = __dsos__read_build_ids(&dsos__user, with_hits);
-        return kbuildids || ubuildids;
-}
-
 /*
  * Align offset to 4 bytes as needed for note name and descriptor data.
  */
@@ -1248,6 +1275,8 @@ char dso__symtab_origin(const struct dso *self)
                 [DSO__ORIG_BUILDID] =  'b',
                 [DSO__ORIG_DSO] =      'd',
                 [DSO__ORIG_KMODULE] =  'K',
+                [DSO__ORIG_GUEST_KERNEL] =  'g',
+                [DSO__ORIG_GUEST_KMODULE] =  'G',
         };
 
         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
@@ -1263,11 +1292,20 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
         int ret = -1;
         int fd;
+        struct machine *machine;
+        const char *root_dir;
 
         dso__set_loaded(self, map->type);
 
-        if (self->kernel)
+        if (self->kernel == DSO_TYPE_KERNEL)
                 return dso__load_kernel_sym(self, map, filter);
+        else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                return dso__load_guest_kernel_sym(self, map, filter);
+
+        if (map->groups && map->groups->machine)
+                machine = map->groups->machine;
+        else
+                machine = NULL;
 
         name = malloc(size);
         if (!name)
@@ -1321,6 +1359,13 @@ more:
                 case DSO__ORIG_DSO:
                         snprintf(name, size, "%s", self->long_name);
                         break;
+                case DSO__ORIG_GUEST_KMODULE:
+                        if (map->groups && map->groups->machine)
+                                root_dir = map->groups->machine->root_dir;
+                        else
+                                root_dir = "";
+                        snprintf(name, size, "%s%s", root_dir, self->long_name);
+                        break;
 
                 default:
                         goto out;
@@ -1374,7 +1419,8 @@ struct map *map_groups__find_by_name(struct map_groups *self,
         return NULL;
 }
 
-static int dso__kernel_module_get_build_id(struct dso *self)
+static int dso__kernel_module_get_build_id(struct dso *self,
+                                const char *root_dir)
 {
         char filename[PATH_MAX];
         /*
@@ -1384,8 +1430,8 @@ static int dso__kernel_module_get_build_id(struct dso *self)
         const char *name = self->short_name + 1;
 
         snprintf(filename, sizeof(filename),
-                 "/sys/module/%.*s/notes/.note.gnu.build-id",
-                 (int)strlen(name - 1), name);
+                 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
+                 root_dir, (int)strlen(name) - 1, name);
 
         if (sysfs__read_build_id(filename, self->build_id,
                                  sizeof(self->build_id)) == 0)
@@ -1394,26 +1440,33 @@ static int dso__kernel_module_get_build_id(struct dso *self)
         return 0;
 }
 
-static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirname)
+static int map_groups__set_modules_path_dir(struct map_groups *self,
+                                const char *dir_name)
 {
         struct dirent *dent;
-        DIR *dir = opendir(dirname);
+        DIR *dir = opendir(dir_name);
 
         if (!dir) {
-                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
+                pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
                 return -1;
         }
 
         while ((dent = readdir(dir)) != NULL) {
                 char path[PATH_MAX];
+                struct stat st;
 
-                if (dent->d_type == DT_DIR) {
+                /*sshfs might return bad dent->d_type, so we have to stat*/
+                sprintf(path, "%s/%s", dir_name, dent->d_name);
+                if (stat(path, &st))
+                        continue;
+
+                if (S_ISDIR(st.st_mode)) {
                         if (!strcmp(dent->d_name, ".") ||
                             !strcmp(dent->d_name, ".."))
                                 continue;
 
                         snprintf(path, sizeof(path), "%s/%s",
-                                 dirname, dent->d_name);
+                                 dir_name, dent->d_name);
                         if (map_groups__set_modules_path_dir(self, path) < 0)
                                 goto failure;
                 } else {
@@ -1433,13 +1486,13 @@ static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirna
                                 continue;
 
                         snprintf(path, sizeof(path), "%s/%s",
-                                 dirname, dent->d_name);
+                                 dir_name, dent->d_name);
 
                         long_name = strdup(path);
                         if (long_name == NULL)
                                 goto failure;
                         dso__set_long_name(map->dso, long_name);
-                        dso__kernel_module_get_build_id(map->dso);
+                        dso__kernel_module_get_build_id(map->dso, "");
                 }
         }
 
@@ -1449,18 +1502,47 @@ failure:
         return -1;
 }
 
-static int map_groups__set_modules_path(struct map_groups *self)
+static char *get_kernel_version(const char *root_dir)
 {
-        struct utsname uts;
+        char version[PATH_MAX];
+        FILE *file;
+        char *name, *tmp;
+        const char *prefix = "Linux version ";
+
+        sprintf(version, "%s/proc/version", root_dir);
+        file = fopen(version, "r");
+        if (!file)
+                return NULL;
+
+        version[0] = '\0';
+        tmp = fgets(version, sizeof(version), file);
+        fclose(file);
+
+        name = strstr(version, prefix);
+        if (!name)
+                return NULL;
+        name += strlen(prefix);
+        tmp = strchr(name, ' ');
+        if (tmp)
+                *tmp = '\0';
+
+        return strdup(name);
+}
+
+static int machine__set_modules_path(struct machine *self)
+{
+        char *version;
         char modules_path[PATH_MAX];
 
-        if (uname(&uts) < 0)
+        version = get_kernel_version(self->root_dir);
+        if (!version)
                 return -1;
 
-        snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
-                 uts.release);
+        snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
+                 self->root_dir, version);
+        free(version);
 
-        return map_groups__set_modules_path_dir(self, modules_path);
+        return map_groups__set_modules_path_dir(&self->kmaps, modules_path);
 }
 
 /*
@@ -1470,8 +1552,8 @@ static int map_groups__set_modules_path(struct map_groups *self)
  */
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 {
-        struct map *self = zalloc(sizeof(*self) +
-                                  (dso->kernel ? sizeof(struct kmap) : 0));
+        struct map *self = calloc(1, (sizeof(*self) +
+                                      (dso->kernel ? sizeof(struct kmap) : 0)));
         if (self != NULL) {
                 /*
                  * ->end will be filled after we load all the symbols
@@ -1482,11 +1564,11 @@ static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
         return self;
 }
 
-struct map *map_groups__new_module(struct map_groups *self, u64 start,
-                                   const char *filename)
+struct map *machine__new_module(struct machine *self, u64 start,
+                                const char *filename)
 {
         struct map *map;
-        struct dso *dso = __dsos__findnew(&dsos__kernel, filename);
+        struct dso *dso = __dsos__findnew(&self->kernel_dsos, filename);
 
         if (dso == NULL)
                 return NULL;
@@ -1495,18 +1577,31 @@ struct map *map_groups__new_module(struct map_groups *self, u64 start,
         if (map == NULL)
                 return NULL;
 
-        dso->origin = DSO__ORIG_KMODULE;
-        map_groups__insert(self, map);
+        if (machine__is_host(self))
+                dso->origin = DSO__ORIG_KMODULE;
+        else
+                dso->origin = DSO__ORIG_GUEST_KMODULE;
+        map_groups__insert(&self->kmaps, map);
         return map;
 }
 
-static int map_groups__create_modules(struct map_groups *self)
+static int machine__create_modules(struct machine *self)
 {
         char *line = NULL;
         size_t n;
-        FILE *file = fopen("/proc/modules", "r");
+        FILE *file;
         struct map *map;
+        const char *modules;
+        char path[PATH_MAX];
+
+        if (machine__is_default_guest(self))
+                modules = symbol_conf.default_guest_modules;
+        else {
+                sprintf(path, "%s/proc/modules", self->root_dir);
+                modules = path;
+        }
 
+        file = fopen(modules, "r");
         if (file == NULL)
                 return -1;
 
@@ -1538,16 +1633,16 @@ static int map_groups__create_modules(struct map_groups *self)
                 *sep = '\0';
 
                 snprintf(name, sizeof(name), "[%s]", line);
-                map = map_groups__new_module(self, start, name);
+                map = machine__new_module(self, start, name);
                 if (map == NULL)
                         goto out_delete_line;
-                dso__kernel_module_get_build_id(map->dso);
+                dso__kernel_module_get_build_id(map->dso, self->root_dir);
         }
 
         free(line);
         fclose(file);
 
-        return map_groups__set_modules_path(self);
+        return machine__set_modules_path(self);
 
 out_delete_line:
         free(line);
@@ -1714,8 +1809,56 @@ out_fixup:
         return err;
 }
 
-LIST_HEAD(dsos__user);
-LIST_HEAD(dsos__kernel);
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter)
+{
+        int err;
+        const char *kallsyms_filename = NULL;
+        struct machine *machine;
+        char path[PATH_MAX];
+
+        if (!map->groups) {
+                pr_debug("Guest kernel map hasn't the point to groups\n");
+                return -1;
+        }
+        machine = map->groups->machine;
+
+        if (machine__is_default_guest(machine)) {
+                /*
+                 * if the user specified a vmlinux filename, use it and only
+                 * it, reporting errors to the user if it cannot be used.
+                 * Or use file guest_kallsyms inputted by user on commandline
+                 */
+                if (symbol_conf.default_guest_vmlinux_name != NULL) {
+                        err = dso__load_vmlinux(self, map,
+                                symbol_conf.default_guest_vmlinux_name, filter);
+                        goto out_try_fixup;
+                }
+
+                kallsyms_filename = symbol_conf.default_guest_kallsyms;
+                if (!kallsyms_filename)
+                        return -1;
+        } else {
+                sprintf(path, "%s/proc/kallsyms", machine->root_dir);
+                kallsyms_filename = path;
+        }
+
+        err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
+        if (err > 0)
+                pr_debug("Using %s for symbols\n", kallsyms_filename);
+
+out_try_fixup:
+        if (err > 0) {
+                if (kallsyms_filename != NULL) {
+                        machine__mmap_name(machine, path, sizeof(path));
+                        dso__set_long_name(self, strdup(path));
+                }
+                map__fixup_start(map);
+                map__fixup_end(map);
+        }
+
+        return err;
+}
 
 static void dsos__add(struct list_head *head, struct dso *dso)
 {
@@ -1747,21 +1890,32 @@ struct dso *__dsos__findnew(struct list_head *head, const char *name)
         return dso;
 }
 
-static void __dsos__fprintf(struct list_head *head, FILE *fp)
+size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 {
         struct dso *pos;
+        size_t ret = 0;
 
         list_for_each_entry(pos, head, node) {
                 int i;
                 for (i = 0; i < MAP__NR_TYPES; ++i)
-                        dso__fprintf(pos, i, fp);
+                        ret += dso__fprintf(pos, i, fp);
         }
+
+        return ret;
 }
 
-void dsos__fprintf(FILE *fp)
+size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
 {
-        __dsos__fprintf(&dsos__kernel, fp);
-        __dsos__fprintf(&dsos__user, fp);
+        struct rb_node *nd;
+        size_t ret = 0;
+
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret += __dsos__fprintf(&pos->kernel_dsos, fp);
+                ret += __dsos__fprintf(&pos->user_dsos, fp);
+        }
+
+        return ret;
 }
 
 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
@@ -1779,10 +1933,17 @@ static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
         return ret;
 }
 
-size_t dsos__fprintf_buildid(FILE *fp, bool with_hits)
+size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
 {
-        return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) +
-                __dsos__fprintf_buildid(&dsos__user, fp, with_hits));
+        struct rb_node *nd;
+        size_t ret = 0;
+
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret += __dsos__fprintf_buildid(&pos->kernel_dsos, fp, with_hits);
+                ret += __dsos__fprintf_buildid(&pos->user_dsos, fp, with_hits);
+        }
+        return ret;
 }
 
 struct dso *dso__new_kernel(const char *name)
@@ -1791,55 +1952,98 @@ struct dso *dso__new_kernel(const char *name)
 
         if (self != NULL) {
                 dso__set_short_name(self, "[kernel]");
-                self->kernel     = 1;
+                self->kernel = DSO_TYPE_KERNEL;
         }
 
         return self;
 }
 
-void dso__read_running_kernel_build_id(struct dso *self)
+static struct dso *dso__new_guest_kernel(struct machine *machine,
+                                        const char *name)
 {
-        if (sysfs__read_build_id("/sys/kernel/notes", self->build_id,
+        char bf[PATH_MAX];
+        struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
+
+        if (self != NULL) {
+                dso__set_short_name(self, "[guest.kernel]");
+                self->kernel = DSO_TYPE_GUEST_KERNEL;
+        }
+
+        return self;
+}
+
+void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
+{
+        char path[PATH_MAX];
+
+        if (machine__is_default_guest(machine))
+                return;
+        sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
+        if (sysfs__read_build_id(path, self->build_id,
                                  sizeof(self->build_id)) == 0)
                 self->has_build_id = true;
 }
 
-static struct dso *dsos__create_kernel(const char *vmlinux)
+static struct dso *machine__create_kernel(struct machine *self)
 {
-        struct dso *kernel = dso__new_kernel(vmlinux);
+        const char *vmlinux_name = NULL;
+        struct dso *kernel;
 
-        if (kernel != NULL) {
-                dso__read_running_kernel_build_id(kernel);
-                dsos__add(&dsos__kernel, kernel);
+        if (machine__is_host(self)) {
+                vmlinux_name = symbol_conf.vmlinux_name;
+                kernel = dso__new_kernel(vmlinux_name);
+        } else {
+                if (machine__is_default_guest(self))
+                        vmlinux_name = symbol_conf.default_guest_vmlinux_name;
+                kernel = dso__new_guest_kernel(self, vmlinux_name);
         }
 
+        if (kernel != NULL) {
+                dso__read_running_kernel_build_id(kernel, self);
+                dsos__add(&self->kernel_dsos, kernel);
+        }
         return kernel;
 }
 
-int __map_groups__create_kernel_maps(struct map_groups *self,
-                                     struct map *vmlinux_maps[MAP__NR_TYPES],
-                                     struct dso *kernel)
+int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
 {
         enum map_type type;
 
         for (type = 0; type < MAP__NR_TYPES; ++type) {
                 struct kmap *kmap;
 
-                vmlinux_maps[type] = map__new2(0, kernel, type);
-                if (vmlinux_maps[type] == NULL)
+                self->vmlinux_maps[type] = map__new2(0, kernel, type);
+                if (self->vmlinux_maps[type] == NULL)
                         return -1;
 
-                vmlinux_maps[type]->map_ip =
-                        vmlinux_maps[type]->unmap_ip = identity__map_ip;
+                self->vmlinux_maps[type]->map_ip =
+                        self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
 
-                kmap = map__kmap(vmlinux_maps[type]);
-                kmap->kmaps = self;
-                map_groups__insert(self, vmlinux_maps[type]);
+                kmap = map__kmap(self->vmlinux_maps[type]);
+                kmap->kmaps = &self->kmaps;
+                map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
         }
 
         return 0;
 }
 
+int machine__create_kernel_maps(struct machine *self)
+{
+        struct dso *kernel = machine__create_kernel(self);
+
+        if (kernel == NULL ||
+            __machine__create_kernel_maps(self, kernel) < 0)
+                return -1;
+
+        if (symbol_conf.use_modules && machine__create_modules(self) < 0)
+                pr_debug("Problems creating module maps, continuing anyway...\n");
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        map_groups__fixup_end(&self->kmaps);
+        return 0;
+}
+
 static void vmlinux_path__exit(void)
 {
         while (--vmlinux_path__nr_entries >= 0) {
@@ -1895,6 +2099,17 @@ out_fail:
         return -1;
 }
 
+size_t vmlinux_path__fprintf(FILE *fp)
+{
+        int i;
+        size_t printed = 0;
+
+        for (i = 0; i < vmlinux_path__nr_entries; ++i)
+                printed += fprintf(fp, "[%d] %s\n", i, vmlinux_path[i]);
+
+        return printed;
+}
+
 static int setup_list(struct strlist **list, const char *list_str,
                       const char *list_name)
 {
@@ -1945,22 +2160,129 @@ out_free_comm_list:
         return -1;
 }
 
-int map_groups__create_kernel_maps(struct map_groups *self,
-                                   struct map *vmlinux_maps[MAP__NR_TYPES])
+int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
 {
-        struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name);
+        struct machine *machine = machines__findnew(self, pid);
 
-        if (kernel == NULL)
+        if (machine == NULL)
                 return -1;
 
-        if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0)
-                return -1;
+        return machine__create_kernel_maps(machine);
+}
 
-        if (symbol_conf.use_modules && map_groups__create_modules(self) < 0)
-                pr_debug("Problems creating module maps, continuing anyway...\n");
-        /*
-         * Now that we have all the maps created, just set the ->end of them:
-         */
-        map_groups__fixup_end(self);
-        return 0;
+static int hex(char ch)
+{
+        if ((ch >= '0') && (ch <= '9'))
+                return ch - '0';
+        if ((ch >= 'a') && (ch <= 'f'))
+                return ch - 'a' + 10;
+        if ((ch >= 'A') && (ch <= 'F'))
+                return ch - 'A' + 10;
+        return -1;
+}
+
+/*
+ * While we find nice hex chars, build a long_val.
+ * Return number of chars processed.
+ */
+int hex2u64(const char *ptr, u64 *long_val)
+{
+        const char *p = ptr;
+        *long_val = 0;
+
+        while (*p) {
+                const int hex_val = hex(*p);
+
+                if (hex_val < 0)
+                        break;
+
+                *long_val = (*long_val << 4) | hex_val;
+                p++;
+        }
+
+        return p - ptr;
+}
+
+char *strxfrchar(char *s, char from, char to)
+{
+        char *p = s;
+
+        while ((p = strchr(p, from)) != NULL)
+                *p++ = to;
+
+        return s;
+}
+
+int machines__create_guest_kernel_maps(struct rb_root *self)
+{
+        int ret = 0;
+        struct dirent **namelist = NULL;
+        int i, items = 0;
+        char path[PATH_MAX];
+        pid_t pid;
+
+        if (symbol_conf.default_guest_vmlinux_name ||
+            symbol_conf.default_guest_modules ||
+            symbol_conf.default_guest_kallsyms) {
+                machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
+        }
+
+        if (symbol_conf.guestmount) {
+                items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
+                if (items <= 0)
+                        return -ENOENT;
+                for (i = 0; i < items; i++) {
+                        if (!isdigit(namelist[i]->d_name[0])) {
+                                /* Filter out . and .. */
+                                continue;
+                        }
+                        pid = atoi(namelist[i]->d_name);
+                        sprintf(path, "%s/%s/proc/kallsyms",
+                                symbol_conf.guestmount,
+                                namelist[i]->d_name);
+                        ret = access(path, R_OK);
+                        if (ret) {
+                                pr_debug("Can't access file %s\n", path);
+                                goto failure;
+                        }
+                        machines__create_kernel_maps(self, pid);
+                }
+failure:
+                free(namelist);
+        }
+
+        return ret;
+}
+
+int machine__load_kallsyms(struct machine *self, const char *filename,
+                           enum map_type type, symbol_filter_t filter)
+{
+        struct map *map = self->vmlinux_maps[type];
+        int ret = dso__load_kallsyms(map->dso, filename, map, filter);
+
+        if (ret > 0) {
+                dso__set_loaded(map->dso, type);
+                /*
+                 * Since /proc/kallsyms will have multiple sessions for the
+                 * kernel, with modules between them, fixup the end of all
+                 * sections.
+                 */
+                __map_groups__fixup_end(&self->kmaps, type);
+        }
+
+        return ret;
+}
+
+int machine__load_vmlinux_path(struct machine *self, enum map_type type,
+                               symbol_filter_t filter)
+{
+        struct map *map = self->vmlinux_maps[type];
+        int ret = dso__load_vmlinux_path(map->dso, map, filter);
+
+        if (ret > 0) {
+                dso__set_loaded(map->dso, type);
+                map__reloc_vmlinux(map);
+        }
+
+        return ret;
 }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index f30a3742891..032469e4187 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -3,10 +3,11 @@
 
 #include <linux/types.h>
 #include <stdbool.h>
-#include "types.h"
+#include <stdint.h>
+#include "map.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include "event.h"
+#include <stdio.h>
 
 #define DEBUG_CACHE_DIR ".debug"
 
@@ -29,6 +30,9 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
 #endif
 #endif
 
+int hex2u64(const char *ptr, u64 *val);
+char *strxfrchar(char *s, char from, char to);
+
 /*
  * libelf 0.8.x and earlier do not support ELF_C_READ_MMAP;
  * for newer versions we can use mmap to reduce memory usage:
@@ -44,10 +48,13 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
 #endif
 
+#define BUILD_ID_SIZE 20
+
 struct symbol {
         struct rb_node  rb_node;
         u64             start;
         u64             end;
+        u16             namelen;
         char            name[0];
 };
 
@@ -63,10 +70,15 @@ struct symbol_conf {
                         show_nr_samples,
                         use_callchain,
                         exclude_other,
-                        full_paths;
+                        full_paths,
+                        show_cpu_utilization;
         const char      *vmlinux_name,
                         *field_sep;
-        char            *dso_list_str,
+        const char      *default_guest_vmlinux_name,
+                        *default_guest_kallsyms,
+                        *default_guest_modules;
+        const char      *guestmount;
+        const char      *dso_list_str,
                         *comm_list_str,
                         *sym_list_str,
                         *col_width_list_str;
@@ -88,6 +100,11 @@ struct ref_reloc_sym {
         u64             unrelocated_addr;
 };
 
+struct map_symbol {
+        struct map    *map;
+        struct symbol *sym;
+};
+
 struct addr_location {
         struct thread *thread;
         struct map    *map;
@@ -95,6 +112,13 @@ struct addr_location {
         u64           addr;
         char          level;
         bool          filtered;
+        unsigned int  cpumode;
+};
+
+enum dso_kernel_type {
+        DSO_TYPE_USER = 0,
+        DSO_TYPE_KERNEL,
+        DSO_TYPE_GUEST_KERNEL
 };
 
 struct dso {
@@ -104,8 +128,9 @@ struct dso {
         u8               adjust_symbols:1;
         u8               slen_calculated:1;
         u8               has_build_id:1;
-        u8               kernel:1;
+        enum dso_kernel_type    kernel;
         u8               hit:1;
+        u8               annotate_warned:1;
         unsigned char    origin;
         u8               sorted_by_name;
         u8               loaded;
@@ -131,42 +156,65 @@ static inline void dso__set_loaded(struct dso *self, enum map_type type)
 
 void dso__sort_by_name(struct dso *self, enum map_type type);
 
-extern struct list_head dsos__user, dsos__kernel;
-
 struct dso *__dsos__findnew(struct list_head *head, const char *name);
 
-static inline struct dso *dsos__findnew(const char *name)
-{
-        return __dsos__findnew(&dsos__user, name);
-}
-
 int dso__load(struct dso *self, struct map *map, symbol_filter_t filter);
 int dso__load_vmlinux_path(struct dso *self, struct map *map,
                            symbol_filter_t filter);
 int dso__load_kallsyms(struct dso *self, const char *filename, struct map *map,
                        symbol_filter_t filter);
-void dsos__fprintf(FILE *fp);
-size_t dsos__fprintf_buildid(FILE *fp, bool with_hits);
+int machine__load_kallsyms(struct machine *self, const char *filename,
+                           enum map_type type, symbol_filter_t filter);
+int machine__load_vmlinux_path(struct machine *self, enum map_type type,
+                               symbol_filter_t filter);
+
+size_t __dsos__fprintf(struct list_head *head, FILE *fp);
+
+size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp);
+size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits);
 
 size_t dso__fprintf_buildid(struct dso *self, FILE *fp);
 size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp);
+
+enum dso_origin {
+        DSO__ORIG_KERNEL = 0,
+        DSO__ORIG_GUEST_KERNEL,
+        DSO__ORIG_JAVA_JIT,
+        DSO__ORIG_BUILD_ID_CACHE,
+        DSO__ORIG_FEDORA,
+        DSO__ORIG_UBUNTU,
+        DSO__ORIG_BUILDID,
+        DSO__ORIG_DSO,
+        DSO__ORIG_GUEST_KMODULE,
+        DSO__ORIG_KMODULE,
+        DSO__ORIG_NOT_FOUND,
+};
+
 char dso__symtab_origin(const struct dso *self);
 void dso__set_long_name(struct dso *self, char *name);
 void dso__set_build_id(struct dso *self, void *build_id);
-void dso__read_running_kernel_build_id(struct dso *self);
+void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine);
 struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
 struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
                                         const char *name);
 
 int filename__read_build_id(const char *filename, void *bf, size_t size);
 int sysfs__read_build_id(const char *filename, void *bf, size_t size);
-bool dsos__read_build_ids(bool with_hits);
+bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
 int build_id__sprintf(const u8 *self, int len, char *bf);
 int kallsyms__parse(const char *filename, void *arg,
                     int (*process_symbol)(void *arg, const char *name,
                                           char type, u64 start));
 
+int __machine__create_kernel_maps(struct machine *self, struct dso *kernel);
+int machine__create_kernel_maps(struct machine *self);
+
+int machines__create_kernel_maps(struct rb_root *self, pid_t pid);
+int machines__create_guest_kernel_maps(struct rb_root *self);
+
 int symbol__init(void);
 bool symbol_type__is_a(char symbol_type, enum map_type map_type);
 
+size_t vmlinux_path__fprintf(FILE *fp);
+
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index fa968312ee7..1f7ecd47f49 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -7,13 +7,35 @@
 #include "util.h"
 #include "debug.h"
 
-void map_groups__init(struct map_groups *self)
+int find_all_tid(int pid, pid_t ** all_tid)
 {
+        char name[256];
+        int items;
+        struct dirent **namelist = NULL;
+        int ret = 0;
         int i;
-        for (i = 0; i < MAP__NR_TYPES; ++i) {
-                self->maps[i] = RB_ROOT;
-                INIT_LIST_HEAD(&self->removed_maps[i]);
+
+        sprintf(name, "/proc/%d/task", pid);
+        items = scandir(name, &namelist, NULL, NULL);
+        if (items <= 0)
+                return -ENOENT;
+        *all_tid = malloc(sizeof(pid_t) * items);
+        if (!*all_tid) {
+                ret = -ENOMEM;
+                goto failure;
         }
+
+        for (i = 0; i < items; i++)
+                (*all_tid)[i] = atoi(namelist[i]->d_name);
+
+        ret = items;
+
+failure:
+        for (i=0; i<items; i++)
+                free(namelist[i]);
+        free(namelist);
+
+        return ret;
 }
 
 static struct thread *thread__new(pid_t pid)
@@ -31,28 +53,6 @@ static struct thread *thread__new(pid_t pid)
         return self;
 }
 
-static void map_groups__flush(struct map_groups *self)
-{
-        int type;
-
-        for (type = 0; type < MAP__NR_TYPES; type++) {
-                struct rb_root *root = &self->maps[type];
-                struct rb_node *next = rb_first(root);
-
-                while (next) {
-                        struct map *pos = rb_entry(next, struct map, rb_node);
-                        next = rb_next(&pos->rb_node);
-                        rb_erase(&pos->rb_node, root);
-                        /*
-                         * We may have references to this map, for
-                         * instance in some hist_entry instances, so
-                         * just move them to a separate list.
-                         */
-                        list_add_tail(&pos->node, &self->removed_maps[pos->type]);
-                }
-        }
-}
-
 int thread__set_comm(struct thread *self, const char *comm)
 {
         int err;
@@ -79,69 +79,10 @@ int thread__comm_len(struct thread *self)
         return self->comm_len;
 }
 
-size_t __map_groups__fprintf_maps(struct map_groups *self,
-                                  enum map_type type, FILE *fp)
-{
-        size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
-        struct rb_node *nd;
-
-        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
-                struct map *pos = rb_entry(nd, struct map, rb_node);
-                printed += fprintf(fp, "Map:");
-                printed += map__fprintf(pos, fp);
-                if (verbose > 2) {
-                        printed += dso__fprintf(pos->dso, type, fp);
-                        printed += fprintf(fp, "--\n");
-                }
-        }
-
-        return printed;
-}
-
-size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp)
-{
-        size_t printed = 0, i;
-        for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_maps(self, i, fp);
-        return printed;
-}
-
-static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
-                                                 enum map_type type, FILE *fp)
-{
-        struct map *pos;
-        size_t printed = 0;
-
-        list_for_each_entry(pos, &self->removed_maps[type], node) {
-                printed += fprintf(fp, "Map:");
-                printed += map__fprintf(pos, fp);
-                if (verbose > 1) {
-                        printed += dso__fprintf(pos->dso, type, fp);
-                        printed += fprintf(fp, "--\n");
-                }
-        }
-        return printed;
-}
-
-static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp)
-{
-        size_t printed = 0, i;
-        for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_removed_maps(self, i, fp);
-        return printed;
-}
-
-static size_t map_groups__fprintf(struct map_groups *self, FILE *fp)
-{
-        size_t printed = map_groups__fprintf_maps(self, fp);
-        printed += fprintf(fp, "Removed maps:\n");
-        return printed + map_groups__fprintf_removed_maps(self, fp);
-}
-
 static size_t thread__fprintf(struct thread *self, FILE *fp)
 {
         return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
-               map_groups__fprintf(&self->mg, fp);
+               map_groups__fprintf(&self->mg, verbose, fp);
 }
 
 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
@@ -183,127 +124,12 @@ struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
         return th;
 }
 
-static int map_groups__fixup_overlappings(struct map_groups *self,
-                                          struct map *map)
-{
-        struct rb_root *root = &self->maps[map->type];
-        struct rb_node *next = rb_first(root);
-
-        while (next) {
-                struct map *pos = rb_entry(next, struct map, rb_node);
-                next = rb_next(&pos->rb_node);
-
-                if (!map__overlap(pos, map))
-                        continue;
-
-                if (verbose >= 2) {
-                        fputs("overlapping maps:\n", stderr);
-                        map__fprintf(map, stderr);
-                        map__fprintf(pos, stderr);
-                }
-
-                rb_erase(&pos->rb_node, root);
-                /*
-                 * We may have references to this map, for instance in some
-                 * hist_entry instances, so just move them to a separate
-                 * list.
-                 */
-                list_add_tail(&pos->node, &self->removed_maps[map->type]);
-                /*
-                 * Now check if we need to create new maps for areas not
-                 * overlapped by the new map:
-                 */
-                if (map->start > pos->start) {
-                        struct map *before = map__clone(pos);
-
-                        if (before == NULL)
-                                return -ENOMEM;
-
-                        before->end = map->start - 1;
-                        map_groups__insert(self, before);
-                        if (verbose >= 2)
-                                map__fprintf(before, stderr);
-                }
-
-                if (map->end < pos->end) {
-                        struct map *after = map__clone(pos);
-
-                        if (after == NULL)
-                                return -ENOMEM;
-
-                        after->start = map->end + 1;
-                        map_groups__insert(self, after);
-                        if (verbose >= 2)
-                                map__fprintf(after, stderr);
-                }
-        }
-
-        return 0;
-}
-
-void maps__insert(struct rb_root *maps, struct map *map)
-{
-        struct rb_node **p = &maps->rb_node;
-        struct rb_node *parent = NULL;
-        const u64 ip = map->start;
-        struct map *m;
-
-        while (*p != NULL) {
-                parent = *p;
-                m = rb_entry(parent, struct map, rb_node);
-                if (ip < m->start)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&map->rb_node, parent, p);
-        rb_insert_color(&map->rb_node, maps);
-}
-
-struct map *maps__find(struct rb_root *maps, u64 ip)
-{
-        struct rb_node **p = &maps->rb_node;
-        struct rb_node *parent = NULL;
-        struct map *m;
-
-        while (*p != NULL) {
-                parent = *p;
-                m = rb_entry(parent, struct map, rb_node);
-                if (ip < m->start)
-                        p = &(*p)->rb_left;
-                else if (ip > m->end)
-                        p = &(*p)->rb_right;
-                else
-                        return m;
-        }
-
-        return NULL;
-}
-
 void thread__insert_map(struct thread *self, struct map *map)
 {
-        map_groups__fixup_overlappings(&self->mg, map);
+        map_groups__fixup_overlappings(&self->mg, map, verbose, stderr);
         map_groups__insert(&self->mg, map);
 }
 
-/*
- * XXX This should not really _copy_ te maps, but refcount them.
- */
-static int map_groups__clone(struct map_groups *self,
-                             struct map_groups *parent, enum map_type type)
-{
-        struct rb_node *nd;
-        for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
-                struct map *map = rb_entry(nd, struct map, rb_node);
-                struct map *new = map__clone(map);
-                if (new == NULL)
-                        return -ENOMEM;
-                map_groups__insert(self, new);
-        }
-        return 0;
-}
-
 int thread__fork(struct thread *self, struct thread *parent)
 {
         int i;
@@ -336,15 +162,3 @@ size_t perf_session__fprintf(struct perf_session *self, FILE *fp)
 
         return ret;
 }
-
-struct symbol *map_groups__find_symbol(struct map_groups *self,
-                                       enum map_type type, u64 addr,
-                                       symbol_filter_t filter)
-{
-        struct map *map = map_groups__find(self, type, addr);
-
-        if (map != NULL)
-                return map__find_symbol(map, map->map_ip(map, addr), filter);
-
-        return NULL;
-}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index dcf70303e58..1dfd9ff8bdc 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -5,14 +5,6 @@
 #include <unistd.h>
 #include "symbol.h"
 
-struct map_groups {
-        struct rb_root          maps[MAP__NR_TYPES];
-        struct list_head        removed_maps[MAP__NR_TYPES];
-};
-
-size_t __map_groups__fprintf_maps(struct map_groups *self,
-                                  enum map_type type, FILE *fp);
-
 struct thread {
         struct rb_node          rb_node;
         struct map_groups       mg;
@@ -23,29 +15,16 @@ struct thread {
         int                     comm_len;
 };
 
-void map_groups__init(struct map_groups *self);
+struct perf_session;
+
+int find_all_tid(int pid, pid_t ** all_tid);
 int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
 void thread__insert_map(struct thread *self, struct map *map);
 int thread__fork(struct thread *self, struct thread *parent);
-size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp);
 size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
 
-void maps__insert(struct rb_root *maps, struct map *map);
-struct map *maps__find(struct rb_root *maps, u64 addr);
-
-static inline void map_groups__insert(struct map_groups *self, struct map *map)
-{
-         maps__insert(&self->maps[map->type], map);
-}
-
-static inline struct map *map_groups__find(struct map_groups *self,
-                                           enum map_type type, u64 addr)
-{
-        return maps__find(&self->maps[type], addr);
-}
-
 static inline struct map *thread__find_map(struct thread *self,
                                            enum map_type type, u64 addr)
 {
@@ -54,34 +33,12 @@ static inline struct map *thread__find_map(struct thread *self,
 
 void thread__find_addr_map(struct thread *self,
                            struct perf_session *session, u8 cpumode,
-                           enum map_type type, u64 addr,
+                           enum map_type type, pid_t pid, u64 addr,
                            struct addr_location *al);
 
 void thread__find_addr_location(struct thread *self,
                                 struct perf_session *session, u8 cpumode,
-                                enum map_type type, u64 addr,
+                                enum map_type type, pid_t pid, u64 addr,
                                 struct addr_location *al,
                                 symbol_filter_t filter);
-struct symbol *map_groups__find_symbol(struct map_groups *self,
-                                       enum map_type type, u64 addr,
-                                       symbol_filter_t filter);
-
-static inline struct symbol *map_groups__find_function(struct map_groups *self,
-                                                       u64 addr,
-                                                       symbol_filter_t filter)
-{
-        return map_groups__find_symbol(self, MAP__FUNCTION, addr, filter);
-}
-
-struct map *map_groups__find_by_name(struct map_groups *self,
-                                     enum map_type type, const char *name);
-
-int __map_groups__create_kernel_maps(struct map_groups *self,
-                                     struct map *vmlinux_maps[MAP__NR_TYPES],
-                                     struct dso *kernel);
-int map_groups__create_kernel_maps(struct map_groups *self,
-                                   struct map *vmlinux_maps[MAP__NR_TYPES]);
-
-struct map *map_groups__new_module(struct map_groups *self, u64 start,
-                                   const char *filename);
 #endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 5ea8973ad33..b1572601286 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -154,10 +154,17 @@ 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);
@@ -480,6 +487,17 @@ get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
         return nr_tracepoints > 0 ? path.next : NULL;
 }
 
+bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
+{
+        int i;
+
+        for (i = 0; i < nb_events; i++)
+                if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
+                        return true;
+
+        return false;
+}
+
 int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 {
         char buf[BUFSIZ];
@@ -526,3 +544,20 @@ int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 
         return 0;
 }
+
+ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
+                               int nb_events)
+{
+        ssize_t size;
+        int err = 0;
+
+        calc_data_size = 1;
+        err = read_tracing_data(fd, pattrs, nb_events);
+        size = calc_data_size - 1;
+        calc_data_size = 0;
+
+        if (err < 0)
+                return err;
+
+        return size;
+}
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 613c9cc9057..73a02223c62 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -37,10 +37,12 @@ int header_page_ts_offset;
 int header_page_ts_size;
 int header_page_size_offset;
 int header_page_size_size;
+int header_page_overwrite_offset;
+int header_page_overwrite_size;
 int header_page_data_offset;
 int header_page_data_size;
 
-int latency_format;
+bool latency_format;
 
 static char *input_buf;
 static unsigned long long input_buf_ptr;
@@ -628,23 +630,32 @@ static int test_type(enum event_type type, enum event_type expect)
         return 0;
 }
 
-static int test_type_token(enum event_type type, char *token,
-                    enum event_type expect, const char *expect_tok)
+static int __test_type_token(enum event_type type, char *token,
+                             enum event_type expect, const char *expect_tok,
+                             bool warn)
 {
         if (type != expect) {
-                warning("Error: expected type %d but read %d",
-                    expect, type);
+                if (warn)
+                        warning("Error: expected type %d but read %d",
+                                expect, type);
                 return -1;
         }
 
         if (strcmp(token, expect_tok) != 0) {
-                warning("Error: expected '%s' but read '%s'",
-                    expect_tok, token);
+                if (warn)
+                        warning("Error: expected '%s' but read '%s'",
+                                expect_tok, token);
                 return -1;
         }
         return 0;
 }
 
+static int test_type_token(enum event_type type, char *token,
+                           enum event_type expect, const char *expect_tok)
+{
+        return __test_type_token(type, token, expect, expect_tok, true);
+}
+
 static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
 {
         enum event_type type;
@@ -661,7 +672,8 @@ static int read_expect_type(enum event_type expect, char **tok)
         return __read_expect_type(expect, tok, 1);
 }
 
-static int __read_expected(enum event_type expect, const char *str, int newline_ok)
+static int __read_expected(enum event_type expect, const char *str,
+                           int newline_ok, bool warn)
 {
         enum event_type type;
         char *token;
@@ -672,7 +684,7 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
         else
                 type = read_token_item(&token);
 
-        ret = test_type_token(type, token, expect, str);
+        ret = __test_type_token(type, token, expect, str, warn);
 
         free_token(token);
 
@@ -681,12 +693,12 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
 
 static int read_expected(enum event_type expect, const char *str)
 {
-        return __read_expected(expect, str, 1);
+        return __read_expected(expect, str, 1, true);
 }
 
 static int read_expected_item(enum event_type expect, const char *str)
 {
-        return __read_expected(expect, str, 0);
+        return __read_expected(expect, str, 0, true);
 }
 
 static char *event_read_name(void)
@@ -744,7 +756,7 @@ static int field_is_string(struct format_field *field)
 
 static int field_is_dynamic(struct format_field *field)
 {
-        if (!strcmp(field->type, "__data_loc"))
+        if (!strncmp(field->type, "__data_loc", 10))
                 return 1;
 
         return 0;
@@ -3087,88 +3099,6 @@ static void print_args(struct print_arg *args)
         }
 }
 
-static void parse_header_field(const char *field,
-                               int *offset, int *size)
-{
-        char *token;
-        int type;
-
-        if (read_expected(EVENT_ITEM, "field") < 0)
-                return;
-        if (read_expected(EVENT_OP, ":") < 0)
-                return;
-
-        /* type */
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        free_token(token);
-
-        if (read_expected(EVENT_ITEM, field) < 0)
-                return;
-        if (read_expected(EVENT_OP, ";") < 0)
-                return;
-        if (read_expected(EVENT_ITEM, "offset") < 0)
-                return;
-        if (read_expected(EVENT_OP, ":") < 0)
-                return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        *offset = atoi(token);
-        free_token(token);
-        if (read_expected(EVENT_OP, ";") < 0)
-                return;
-        if (read_expected(EVENT_ITEM, "size") < 0)
-                return;
-        if (read_expected(EVENT_OP, ":") < 0)
-                return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        *size = atoi(token);
-        free_token(token);
-        if (read_expected(EVENT_OP, ";") < 0)
-                return;
-        type = read_token(&token);
-        if (type != EVENT_NEWLINE) {
-                /* newer versions of the kernel have a "signed" type */
-                if (type != EVENT_ITEM)
-                        goto fail;
-
-                if (strcmp(token, "signed") != 0)
-                        goto fail;
-
-                free_token(token);
-
-                if (read_expected(EVENT_OP, ":") < 0)
-                        return;
-
-                if (read_expect_type(EVENT_ITEM, &token))
-                        goto fail;
-
-                free_token(token);
-                if (read_expected(EVENT_OP, ";") < 0)
-                        return;
-
-                if (read_expect_type(EVENT_NEWLINE, &token))
-                        goto fail;
-        }
- fail:
-        free_token(token);
-}
-
-int parse_header_page(char *buf, unsigned long size)
-{
-        init_input_buf(buf, size);
-
-        parse_header_field("timestamp", &header_page_ts_offset,
-                           &header_page_ts_size);
-        parse_header_field("commit", &header_page_size_offset,
-                           &header_page_size_size);
-        parse_header_field("data", &header_page_data_offset,
-                           &header_page_data_size);
-
-        return 0;
-}
-
 int parse_ftrace_file(char *buf, unsigned long size)
 {
         struct format_field *field;
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 7cd1193918c..cb54cd002f4 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -50,14 +50,51 @@ static int long_size;
 
 static unsigned long    page_size;
 
+static ssize_t calc_data_size;
+static bool repipe;
+
+/* If it fails, the next read will report it */
+static void skip(int size)
+{
+        lseek(input_fd, size, SEEK_CUR);
+}
+
+static int do_read(int fd, void *buf, int size)
+{
+        int rsize = size;
+
+        while (size) {
+                int ret = read(fd, buf, size);
+
+                if (ret <= 0)
+                        return -1;
+
+                if (repipe) {
+                        int retw = write(STDOUT_FILENO, buf, ret);
+
+                        if (retw <= 0 || retw != ret)
+                                die("repiping input file");
+                }
+
+                size -= ret;
+                buf += ret;
+        }
+
+        return rsize;
+}
+
 static int read_or_die(void *data, int size)
 {
         int r;
 
-        r = read(input_fd, data, size);
-        if (r != size)
+        r = do_read(input_fd, data, size);
+        if (r <= 0)
                 die("reading input file (size expected=%d received=%d)",
                     size, r);
+
+        if (calc_data_size)
+                calc_data_size += r;
+
         return r;
 }
 
@@ -82,57 +119,36 @@ static char *read_string(void)
         char buf[BUFSIZ];
         char *str = NULL;
         int size = 0;
-        int i;
         off_t r;
+        char c;
 
         for (;;) {
-                r = read(input_fd, buf, BUFSIZ);
+                r = read(input_fd, &c, 1);
                 if (r < 0)
                         die("reading input file");
 
                 if (!r)
                         die("no data");
 
-                for (i = 0; i < r; i++) {
-                        if (!buf[i])
-                                break;
-                }
-                if (i < r)
-                        break;
+                if (repipe) {
+                        int retw = write(STDOUT_FILENO, &c, 1);
 
-                if (str) {
-                        size += BUFSIZ;
-                        str = realloc(str, size);
-                        if (!str)
-                                die("malloc of size %d", size);
-                        memcpy(str + (size - BUFSIZ), buf, BUFSIZ);
-                } else {
-                        size = BUFSIZ;
-                        str = malloc_or_die(size);
-                        memcpy(str, buf, size);
+                        if (retw <= 0 || retw != r)
+                                die("repiping input file string");
                 }
-        }
 
-        /* trailing \0: */
-        i++;
-
-        /* move the file descriptor to the end of the string */
-        r = lseek(input_fd, -(r - i), SEEK_CUR);
-        if (r == (off_t)-1)
-                die("lseek");
-
-        if (str) {
-                size += i;
-                str = realloc(str, size);
-                if (!str)
-                        die("malloc of size %d", size);
-                memcpy(str + (size - i), buf, i);
-        } else {
-                size = i;
-                str = malloc_or_die(i);
-                memcpy(str, buf, i);
+                buf[size++] = c;
+
+                if (!c)
+                        break;
         }
 
+        if (calc_data_size)
+                calc_data_size += size;
+
+        str = malloc_or_die(size);
+        memcpy(str, buf, size);
+
         return str;
 }
 
@@ -174,7 +190,6 @@ static void read_ftrace_printk(void)
 static void read_header_files(void)
 {
         unsigned long long size;
-        char *header_page;
         char *header_event;
         char buf[BUFSIZ];
 
@@ -184,10 +199,7 @@ static void read_header_files(void)
                 die("did not read header page");
 
         size = read8();
-        header_page = malloc_or_die(size);
-        read_or_die(header_page, size);
-        parse_header_page(header_page, size);
-        free(header_page);
+        skip(size);
 
         /*
          * The size field in the page is of type long,
@@ -459,7 +471,7 @@ struct record *trace_read_data(int cpu)
         return data;
 }
 
-void trace_report(int fd)
+ssize_t trace_report(int fd, bool __repipe)
 {
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
@@ -467,6 +479,10 @@ void trace_report(int fd)
         int show_version = 0;
         int show_funcs = 0;
         int show_printk = 0;
+        ssize_t size;
+
+        calc_data_size = 1;
+        repipe = __repipe;
 
         input_fd = fd;
 
@@ -499,14 +515,18 @@ void trace_report(int fd)
         read_proc_kallsyms();
         read_ftrace_printk();
 
+        size = calc_data_size - 1;
+        calc_data_size = 0;
+        repipe = false;
+
         if (show_funcs) {
                 print_funcs();
-                return;
+                return size;
         }
         if (show_printk) {
                 print_printk();
-                return;
+                return size;
         }
 
-        return;
+        return size;
 }
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index c3269b937db..406d452956d 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,6 +1,7 @@
 #ifndef __PERF_TRACE_EVENTS_H
 #define __PERF_TRACE_EVENTS_H
 
+#include <stdbool.h>
 #include "parse-events.h"
 
 #define __unused __attribute__((unused))
@@ -162,7 +163,7 @@ struct record *trace_read_data(int cpu);
 
 void parse_set_info(int nr_cpus, int long_sz);
 
-void trace_report(int fd);
+ssize_t trace_report(int fd, bool repipe);
 
 void *malloc_or_die(unsigned int size);
 
@@ -241,9 +242,8 @@ extern int header_page_size_size;
 extern int header_page_data_offset;
 extern int header_page_data_size;
 
-extern int latency_format;
+extern bool latency_format;
 
-int parse_header_page(char *buf, unsigned long size);
 int trace_parse_common_type(void *data);
 int trace_parse_common_pid(void *data);
 int parse_common_pc(void *data);
@@ -258,6 +258,8 @@ void *raw_field_ptr(struct event *event, const char *name, void *data);
 unsigned long long eval_flag(const char *flag);
 
 int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events);
+ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
+                               int nb_events);
 
 /* taken from kernel/trace/trace.h */
 enum trace_flag_type {
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index f9b890fde68..214265674dd 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -92,3 +92,25 @@ out_close_from:
 out:
         return err;
 }
+
+unsigned long convert_unit(unsigned long value, char *unit)
+{
+        *unit = ' ';
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'K';
+        }
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'M';
+        }
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'G';
+        }
+
+        return value;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 0f5b2a6f108..0795bf304b1 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -42,12 +42,14 @@
 #define _ALL_SOURCE 1
 #define _GNU_SOURCE 1
 #define _BSD_SOURCE 1
+#define HAS_BOOL
 
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/statfs.h>
 #include <fcntl.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -78,6 +80,7 @@
 #include <pwd.h>
 #include <inttypes.h>
 #include "../../../include/linux/magic.h"
+#include "types.h"
 
 
 #ifndef NO_ICONV
@@ -295,6 +298,13 @@ extern void *xmemdupz(const void *data, size_t len);
 extern char *xstrndup(const char *str, size_t len);
 extern void *xrealloc(void *ptr, size_t size) __attribute__((weak));
 
+static inline void *xzalloc(size_t size)
+{
+        void *buf = xmalloc(size);
+
+        return memset(buf, 0, size);
+}
+
 static inline void *zalloc(size_t size)
 {
         return calloc(1, size);
@@ -309,6 +319,7 @@ static inline int has_extension(const char *filename, const char *ext)
 {
         size_t len = strlen(filename);
         size_t extlen = strlen(ext);
+
         return len > extlen && !memcmp(filename + len - extlen, ext, extlen);
 }
 
@@ -322,6 +333,7 @@ static inline int has_extension(const char *filename, const char *ext)
 #undef isalnum
 #undef tolower
 #undef toupper
+
 extern unsigned char sane_ctype[256];
 #define GIT_SPACE               0x01
 #define GIT_DIGIT               0x02
@@ -406,4 +418,14 @@ void git_qsort(void *base, size_t nmemb, size_t size,
 int mkdir_p(char *path, mode_t mode);
 int copyfile(const char *from, const char *to);
 
+s64 perf_atoll(const char *str);
+char **argv_split(const char *str, int *argcp);
+void argv_free(char **argv);
+bool strglobmatch(const char *str, const char *pat);
+bool strlazymatch(const char *str, const char *pat);
+unsigned long convert_unit(unsigned long value, char *unit);
+
+#define _STR(x) #x
+#define STR(x) _STR(x)
+
 #endif