78 files changed, 9900 insertions, 1589 deletions

diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
new file mode 100644
index 000000000000..04904b35ba81
--- /dev/null
+++ b/tools/perf/util/build-id.c
@@ -0,0 +1,39 @@
+/*
+ * build-id.c
+ *
+ * build-id support
+ *
+ * Copyright (C) 2009, 2010 Red Hat Inc.
+ * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+#include "build-id.h"
+#include "event.h"
+#include "symbol.h"
+#include <linux/kernel.h>
+
+static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
+{
+        struct addr_location al;
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread = perf_session__findnew(session, event->ip.pid);
+
+        if (thread == NULL) {
+                pr_err("problem processing %d event, skipping it.\n",
+                        event->header.type);
+                return -1;
+        }
+
+        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                              event->ip.ip, &al);
+
+        if (al.map != NULL)
+                al.map->dso->hit = 1;
+
+        return 0;
+}
+
+struct perf_event_ops build_id__mark_dso_hit_ops = {
+        .sample = build_id__mark_dso_hit,
+        .mmap   = event__process_mmap,
+        .fork   = event__process_task,
+};
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
new file mode 100644
index 000000000000..1d981d63cf9a
--- /dev/null
+++ b/tools/perf/util/build-id.h
@@ -0,0 +1,8 @@
+#ifndef PERF_BUILD_ID_H_
+#define PERF_BUILD_ID_H_ 1
+
+#include "session.h"
+
+extern struct perf_event_ops build_id__mark_dso_hit_ops;
+
+#endif
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 6f8ea9d210b6..918eb376abe3 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -1,10 +1,15 @@
-#ifndef CACHE_H
-#define CACHE_H
+#ifndef __PERF_CACHE_H
+#define __PERF_CACHE_H
 
 #include "util.h"
 #include "strbuf.h"
 #include "../perf.h"
 
+#define CMD_EXEC_PATH "--exec-path"
+#define CMD_PERF_DIR "--perf-dir="
+#define CMD_WORK_TREE "--work-tree="
+#define CMD_DEBUGFS_DIR "--debugfs-dir="
+
 #define PERF_DIR_ENVIRONMENT "PERF_DIR"
 #define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
 #define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
@@ -117,4 +122,4 @@ extern char *perf_pathdup(const char *fmt, ...)
 
 extern size_t strlcpy(char *dest, const char *src, size_t size);
 
-#endif /* CACHE_H */
+#endif /* __PERF_CACHE_H */
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 3b8380f1b478..b3b71258272a 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -206,7 +206,7 @@ fill_node(struct callchain_node *node, struct ip_callchain *chain,
         }
         node->val_nr = chain->nr - start;
         if (!node->val_nr)
-                printf("Warning: empty node in callchain tree\n");
+                pr_warning("Warning: empty node in callchain tree\n");
 }
 
 static void
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 43cf3ea9e088..ad4626de4c2b 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -58,4 +58,4 @@ 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);
-#endif
+#endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 58d597564b99..24e8809210bb 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -1,5 +1,5 @@
-#ifndef COLOR_H
-#define COLOR_H
+#ifndef __PERF_COLOR_H
+#define __PERF_COLOR_H
 
 /* "\033[1;38;5;2xx;48;5;2xxm\0" is 23 bytes */
 #define COLOR_MAXLEN 24
@@ -39,4 +39,4 @@ int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *bu
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
 const char *get_percent_color(double percent);
 
-#endif /* COLOR_H */
+#endif /* __PERF_COLOR_H */
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
new file mode 100644
index 000000000000..4e01490e51e5
--- /dev/null
+++ b/tools/perf/util/cpumap.c
@@ -0,0 +1,59 @@
+#include "util.h"
+#include "../perf.h"
+#include "cpumap.h"
+#include <assert.h>
+#include <stdio.h>
+
+int cpumap[MAX_NR_CPUS];
+
+static int default_cpu_map(void)
+{
+        int nr_cpus, i;
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert((int)nr_cpus >= 0);
+
+        for (i = 0; i < nr_cpus; ++i)
+                cpumap[i] = i;
+
+        return nr_cpus;
+}
+
+int read_cpu_map(void)
+{
+        FILE *onlnf;
+        int nr_cpus = 0;
+        int n, cpu, prev;
+        char sep;
+
+        onlnf = fopen("/sys/devices/system/cpu/online", "r");
+        if (!onlnf)
+                return default_cpu_map();
+
+        sep = 0;
+        prev = -1;
+        for (;;) {
+                n = fscanf(onlnf, "%u%c", &cpu, &sep);
+                if (n <= 0)
+                        break;
+                if (prev >= 0) {
+                        assert(nr_cpus + cpu - prev - 1 < MAX_NR_CPUS);
+                        while (++prev < cpu)
+                                cpumap[nr_cpus++] = prev;
+                }
+                assert (nr_cpus < MAX_NR_CPUS);
+                cpumap[nr_cpus++] = cpu;
+                if (n == 2 && sep == '-')
+                        prev = cpu;
+                else
+                        prev = -1;
+                if (n == 1 || sep == '\n')
+                        break;
+        }
+        fclose(onlnf);
+        if (nr_cpus > 0)
+                return nr_cpus;
+
+        return default_cpu_map();
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
new file mode 100644
index 000000000000..86c78bb33098
--- /dev/null
+++ b/tools/perf/util/cpumap.h
@@ -0,0 +1,7 @@
+#ifndef __PERF_CPUMAP_H
+#define __PERF_CPUMAP_H
+
+extern int read_cpu_map(void);
+extern int cpumap[];
+
+#endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/ctype.c b/tools/perf/util/ctype.c
index 0b791bd346bc..35073621e5de 100644
--- a/tools/perf/util/ctype.c
+++ b/tools/perf/util/ctype.c
@@ -29,3 +29,11 @@ unsigned char sane_ctype[256] = {
         A, A, A, A, A, A, A, A, A, A, A, R, R, P, P, 0,         /* 112..127 */
         /* Nothing in the 128.. range */
 };
+
+const char *graph_line =
+        "_____________________________________________________________________"
+        "_____________________________________________________________________";
+const char *graph_dotted_line =
+        "---------------------------------------------------------------------"
+        "---------------------------------------------------------------------"
+        "---------------------------------------------------------------------";
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index e8ca98fe0bd4..0905600c3851 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -9,16 +9,17 @@
 #include "color.h"
 #include "event.h"
 #include "debug.h"
+#include "util.h"
 
 int verbose = 0;
 int dump_trace = 0;
 
-int eprintf(const char *fmt, ...)
+int eprintf(int level, const char *fmt, ...)
 {
         va_list args;
         int ret = 0;
 
-        if (verbose) {
+        if (verbose >= level) {
                 va_start(args, fmt);
                 ret = vfprintf(stderr, fmt, args);
                 va_end(args);
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 437eea58ce40..c6c24c522dea 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -1,8 +1,15 @@
 /* For debugging general purposes */
+#ifndef __PERF_DEBUG_H
+#define __PERF_DEBUG_H
+
+#include "event.h"
 
 extern int verbose;
 extern int dump_trace;
 
-int eprintf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+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);
+
+#endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
new file mode 100644
index 000000000000..a88fefc0cc0a
--- /dev/null
+++ b/tools/perf/util/debugfs.c
@@ -0,0 +1,240 @@
+#include "util.h"
+#include "debugfs.h"
+#include "cache.h"
+
+static int debugfs_premounted;
+static char debugfs_mountpoint[MAX_PATH+1];
+
+static const char *debugfs_known_mountpoints[] = {
+        "/sys/kernel/debug/",
+        "/debug/",
+        0,
+};
+
+/* use this to force a umount */
+void debugfs_force_cleanup(void)
+{
+        debugfs_find_mountpoint();
+        debugfs_premounted = 0;
+        debugfs_umount();
+}
+
+/* construct a full path to a debugfs element */
+int debugfs_make_path(const char *element, char *buffer, int size)
+{
+        int len;
+
+        if (strlen(debugfs_mountpoint) == 0) {
+                buffer[0] = '\0';
+                return -1;
+        }
+
+        len = strlen(debugfs_mountpoint) + strlen(element) + 1;
+        if (len >= size)
+                return len+1;
+
+        snprintf(buffer, size-1, "%s/%s", debugfs_mountpoint, element);
+        return 0;
+}
+
+static int debugfs_found;
+
+/* find the path to the mounted debugfs */
+const char *debugfs_find_mountpoint(void)
+{
+        const char **ptr;
+        char type[100];
+        FILE *fp;
+
+        if (debugfs_found)
+                return (const char *) debugfs_mountpoint;
+
+        ptr = debugfs_known_mountpoints;
+        while (*ptr) {
+                if (debugfs_valid_mountpoint(*ptr) == 0) {
+                        debugfs_found = 1;
+                        strcpy(debugfs_mountpoint, *ptr);
+                        return debugfs_mountpoint;
+                }
+                ptr++;
+        }
+
+        /* give up and parse /proc/mounts */
+        fp = fopen("/proc/mounts", "r");
+        if (fp == NULL)
+                die("Can't open /proc/mounts for read");
+
+        while (fscanf(fp, "%*s %"
+                      STR(MAX_PATH)
+                      "s %99s %*s %*d %*d\n",
+                      debugfs_mountpoint, type) == 2) {
+                if (strcmp(type, "debugfs") == 0)
+                        break;
+        }
+        fclose(fp);
+
+        if (strcmp(type, "debugfs") != 0)
+                return NULL;
+
+        debugfs_found = 1;
+
+        return debugfs_mountpoint;
+}
+
+/* verify that a mountpoint is actually a debugfs instance */
+
+int debugfs_valid_mountpoint(const char *debugfs)
+{
+        struct statfs st_fs;
+
+        if (statfs(debugfs, &st_fs) < 0)
+                return -ENOENT;
+        else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
+                return -ENOENT;
+
+        return 0;
+}
+
+
+int debugfs_valid_entry(const char *path)
+{
+        struct stat st;
+
+        if (stat(path, &st))
+                return -errno;
+
+        return 0;
+}
+
+/* mount the debugfs somewhere if it's not mounted */
+
+char *debugfs_mount(const char *mountpoint)
+{
+        /* see if it's already mounted */
+        if (debugfs_find_mountpoint()) {
+                debugfs_premounted = 1;
+                return debugfs_mountpoint;
+        }
+
+        /* if not mounted and no argument */
+        if (mountpoint == NULL) {
+                /* see if environment variable set */
+                mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
+                /* if no environment variable, use default */
+                if (mountpoint == NULL)
+                        mountpoint = "/sys/kernel/debug";
+        }
+
+        if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
+                return NULL;
+
+        /* save the mountpoint */
+        strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
+        debugfs_found = 1;
+
+        return debugfs_mountpoint;
+}
+
+/* umount the debugfs */
+
+int debugfs_umount(void)
+{
+        char umountcmd[128];
+        int ret;
+
+        /* if it was already mounted, leave it */
+        if (debugfs_premounted)
+                return 0;
+
+        /* make sure it's a valid mount point */
+        ret = debugfs_valid_mountpoint(debugfs_mountpoint);
+        if (ret)
+                return ret;
+
+        snprintf(umountcmd, sizeof(umountcmd),
+                 "/bin/umount %s", debugfs_mountpoint);
+        return system(umountcmd);
+}
+
+int debugfs_write(const char *entry, const char *value)
+{
+        char path[MAX_PATH+1];
+        int ret, count;
+        int fd;
+
+        /* construct the path */
+        snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
+
+        /* verify that it exists */
+        ret = debugfs_valid_entry(path);
+        if (ret)
+                return ret;
+
+        /* get how many chars we're going to write */
+        count = strlen(value);
+
+        /* open the debugfs entry */
+        fd = open(path, O_RDWR);
+        if (fd < 0)
+                return -errno;
+
+        while (count > 0) {
+                /* write it */
+                ret = write(fd, value, count);
+                if (ret <= 0) {
+                        if (ret == EAGAIN)
+                                continue;
+                        close(fd);
+                        return -errno;
+                }
+                count -= ret;
+        }
+
+        /* close it */
+        close(fd);
+
+        /* return success */
+        return 0;
+}
+
+/*
+ * read a debugfs entry
+ * returns the number of chars read or a negative errno
+ */
+int debugfs_read(const char *entry, char *buffer, size_t size)
+{
+        char path[MAX_PATH+1];
+        int ret;
+        int fd;
+
+        /* construct the path */
+        snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
+
+        /* verify that it exists */
+        ret = debugfs_valid_entry(path);
+        if (ret)
+                return ret;
+
+        /* open the debugfs entry */
+        fd = open(path, O_RDONLY);
+        if (fd < 0)
+                return -errno;
+
+        do {
+                /* read it */
+                ret = read(fd, buffer, size);
+                if (ret == 0) {
+                        close(fd);
+                        return EOF;
+                }
+        } while (ret < 0 && errno == EAGAIN);
+
+        /* close it */
+        close(fd);
+
+        /* make *sure* there's a null character at the end */
+        buffer[ret] = '\0';
+
+        /* return the number of chars read */
+        return ret;
+}
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
new file mode 100644
index 000000000000..83a02879745f
--- /dev/null
+++ b/tools/perf/util/debugfs.h
@@ -0,0 +1,25 @@
+#ifndef __DEBUGFS_H__
+#define __DEBUGFS_H__
+
+#include <sys/mount.h>
+
+#ifndef MAX_PATH
+# define MAX_PATH 256
+#endif
+
+#ifndef STR
+# define _STR(x) #x
+# define STR(x) _STR(x)
+#endif
+
+extern const char *debugfs_find_mountpoint(void);
+extern int debugfs_valid_mountpoint(const char *debugfs);
+extern int debugfs_valid_entry(const char *path);
+extern char *debugfs_mount(const char *mountpoint);
+extern int debugfs_umount(void);
+extern int debugfs_write(const char *entry, const char *value);
+extern int debugfs_read(const char *entry, char *buffer, size_t size);
+extern void debugfs_force_cleanup(void);
+extern int debugfs_make_path(const char *element, char *buffer, int size);
+
+#endif /* __DEBUGFS_H__ */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
new file mode 100644
index 000000000000..705ec63548b4
--- /dev/null
+++ b/tools/perf/util/event.c
@@ -0,0 +1,612 @@
+#include <linux/types.h>
+#include "event.h"
+#include "debug.h"
+#include "session.h"
+#include "sort.h"
+#include "string.h"
+#include "strlist.h"
+#include "thread.h"
+
+static pid_t event__synthesize_comm(pid_t pid, int full,
+                                    event__handler_t process,
+                                    struct perf_session *session)
+{
+        event_t ev;
+        char filename[PATH_MAX];
+        char bf[BUFSIZ];
+        FILE *fp;
+        size_t size = 0;
+        DIR *tasks;
+        struct dirent dirent, *next;
+        pid_t tgid = 0;
+
+        snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
+
+        fp = fopen(filename, "r");
+        if (fp == NULL) {
+out_race:
+                /*
+                 * We raced with a task exiting - just return:
+                 */
+                pr_debug("couldn't open %s\n", filename);
+                return 0;
+        }
+
+        memset(&ev.comm, 0, sizeof(ev.comm));
+        while (!ev.comm.comm[0] || !ev.comm.pid) {
+                if (fgets(bf, sizeof(bf), fp) == NULL)
+                        goto out_failure;
+
+                if (memcmp(bf, "Name:", 5) == 0) {
+                        char *name = bf + 5;
+                        while (*name && isspace(*name))
+                                ++name;
+                        size = strlen(name) - 1;
+                        memcpy(ev.comm.comm, name, size++);
+                } else if (memcmp(bf, "Tgid:", 5) == 0) {
+                        char *tgids = bf + 5;
+                        while (*tgids && isspace(*tgids))
+                                ++tgids;
+                        tgid = ev.comm.pid = atoi(tgids);
+                }
+        }
+
+        ev.comm.header.type = PERF_RECORD_COMM;
+        size = ALIGN(size, sizeof(u64));
+        ev.comm.header.size = sizeof(ev.comm) - (sizeof(ev.comm.comm) - size);
+
+        if (!full) {
+                ev.comm.tid = pid;
+
+                process(&ev, session);
+                goto out_fclose;
+        }
+
+        snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
+
+        tasks = opendir(filename);
+        if (tasks == NULL)
+                goto out_race;
+
+        while (!readdir_r(tasks, &dirent, &next) && next) {
+                char *end;
+                pid = strtol(dirent.d_name, &end, 10);
+                if (*end)
+                        continue;
+
+                ev.comm.tid = pid;
+
+                process(&ev, session);
+        }
+        closedir(tasks);
+
+out_fclose:
+        fclose(fp);
+        return tgid;
+
+out_failure:
+        pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
+        return -1;
+}
+
+static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
+                                         event__handler_t process,
+                                         struct perf_session *session)
+{
+        char filename[PATH_MAX];
+        FILE *fp;
+
+        snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
+
+        fp = fopen(filename, "r");
+        if (fp == NULL) {
+                /*
+                 * We raced with a task exiting - just return:
+                 */
+                pr_debug("couldn't open %s\n", filename);
+                return -1;
+        }
+
+        while (1) {
+                char bf[BUFSIZ], *pbf = bf;
+                event_t ev = {
+                        .header = {
+                                .type = PERF_RECORD_MMAP,
+                                .misc = 0, /* Just like the kernel, see kernel/perf_event.c __perf_event_mmap */
+                         },
+                };
+                int n;
+                size_t size;
+                if (fgets(bf, sizeof(bf), fp) == NULL)
+                        break;
+
+                /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
+                n = hex2u64(pbf, &ev.mmap.start);
+                if (n < 0)
+                        continue;
+                pbf += n + 1;
+                n = hex2u64(pbf, &ev.mmap.len);
+                if (n < 0)
+                        continue;
+                pbf += n + 3;
+                if (*pbf == 'x') { /* vm_exec */
+                        char *execname = strchr(bf, '/');
+
+                        /* Catch VDSO */
+                        if (execname == NULL)
+                                execname = strstr(bf, "[vdso]");
+
+                        if (execname == NULL)
+                                continue;
+
+                        size = strlen(execname);
+                        execname[size - 1] = '\0'; /* Remove \n */
+                        memcpy(ev.mmap.filename, execname, size);
+                        size = ALIGN(size, sizeof(u64));
+                        ev.mmap.len -= ev.mmap.start;
+                        ev.mmap.header.size = (sizeof(ev.mmap) -
+                                               (sizeof(ev.mmap.filename) - size));
+                        ev.mmap.pid = tgid;
+                        ev.mmap.tid = pid;
+
+                        process(&ev, session);
+                }
+        }
+
+        fclose(fp);
+        return 0;
+}
+
+int event__synthesize_modules(event__handler_t process,
+                              struct perf_session *session)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(&session->kmaps.maps[MAP__FUNCTION]);
+             nd; nd = rb_next(nd)) {
+                event_t ev;
+                size_t size;
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+
+                if (pos->dso->kernel)
+                        continue;
+
+                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.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;
+
+                memcpy(ev.mmap.filename, pos->dso->long_name,
+                       pos->dso->long_name_len + 1);
+                process(&ev, session);
+        }
+
+        return 0;
+}
+
+int event__synthesize_thread(pid_t pid, event__handler_t process,
+                             struct perf_session *session)
+{
+        pid_t tgid = event__synthesize_comm(pid, 1, process, session);
+        if (tgid == -1)
+                return -1;
+        return event__synthesize_mmap_events(pid, tgid, process, session);
+}
+
+void event__synthesize_threads(event__handler_t process,
+                               struct perf_session *session)
+{
+        DIR *proc;
+        struct dirent dirent, *next;
+
+        proc = opendir("/proc");
+
+        while (!readdir_r(proc, &dirent, &next) && next) {
+                char *end;
+                pid_t pid = strtol(dirent.d_name, &end, 10);
+
+                if (*end) /* only interested in proper numerical dirents */
+                        continue;
+
+                event__synthesize_thread(pid, process, session);
+        }
+
+        closedir(proc);
+}
+
+struct process_symbol_args {
+        const char *name;
+        u64        start;
+};
+
+static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
+{
+        struct process_symbol_args *args = arg;
+
+        /*
+         * Must be a function or at least an alias, as in PARISC64, where "_text" is
+         * an 'A' to the same address as "_stext".
+         */
+        if (!(symbol_type__is_a(type, MAP__FUNCTION) ||
+              type == 'A') || strcmp(name, args->name))
+                return 0;
+
+        args->start = start;
+        return 1;
+}
+
+int event__synthesize_kernel_mmap(event__handler_t process,
+                                  struct perf_session *session,
+                                  const char *symbol_name)
+{
+        size_t size;
+        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 */
+                },
+        };
+        /*
+         * We should get this from /sys/kernel/sections/.text, but till that is
+         * available use this, and after it is use this as a fallback for older
+         * kernels.
+         */
+        struct process_symbol_args args = { .name = symbol_name, };
+
+        if (kallsyms__parse("/proc/kallsyms", &args, find_symbol_cb) <= 0)
+                return -ENOENT;
+
+        size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
+                        "[kernel.kallsyms.%s]", symbol_name) + 1;
+        size = ALIGN(size, sizeof(u64));
+        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 ;
+
+        return process(&ev, session);
+}
+
+static void thread__comm_adjust(struct thread *self)
+{
+        char *comm = self->comm;
+
+        if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
+            (!symbol_conf.comm_list ||
+             strlist__has_entry(symbol_conf.comm_list, comm))) {
+                unsigned int slen = strlen(comm);
+
+                if (slen > comms__col_width) {
+                        comms__col_width = slen;
+                        threads__col_width = slen + 6;
+                }
+        }
+}
+
+static int thread__set_comm_adjust(struct thread *self, const char *comm)
+{
+        int ret = thread__set_comm(self, comm);
+
+        if (ret)
+                return ret;
+
+        thread__comm_adjust(self);
+
+        return 0;
+}
+
+int event__process_comm(event_t *self, struct perf_session *session)
+{
+        struct thread *thread = perf_session__findnew(session, self->comm.pid);
+
+        dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
+
+        if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) {
+                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+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;
+        return 0;
+}
+
+int event__process_mmap(event_t *self, struct perf_session *session)
+{
+        struct thread *thread;
+        struct map *map;
+
+        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 (self->mmap.pid == 0) {
+                static const char kmmap_prefix[] = "[kernel.kallsyms.";
+
+                if (self->mmap.filename[0] == '/') {
+                        char short_module_name[1024];
+                        char *name = strrchr(self->mmap.filename, '/'), *dot;
+
+                        if (name == NULL)
+                                goto out_problem;
+
+                        ++name; /* skip / */
+                        dot = strrchr(name, '.');
+                        if (dot == NULL)
+                                goto out_problem;
+
+                        snprintf(short_module_name, sizeof(short_module_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);
+                        /*
+                         * Should be there already, from the build-id table in
+                         * the header.
+                         */
+                        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;
+
+                        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;
+
+                        perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name,
+                                                                 self->mmap.pgoff);
+                }
+                return 0;
+        }
+
+        thread = perf_session__findnew(session, self->mmap.pid);
+        map = map__new(&self->mmap, MAP__FUNCTION,
+                       session->cwd, session->cwdlen);
+
+        if (thread == NULL || map == NULL)
+                goto out_problem;
+
+        thread__insert_map(thread, map);
+        return 0;
+
+out_problem:
+        dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
+        return 0;
+}
+
+int event__process_task(event_t *self, struct perf_session *session)
+{
+        struct thread *thread = perf_session__findnew(session, self->fork.pid);
+        struct thread *parent = perf_session__findnew(session, self->fork.ppid);
+
+        dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
+                    self->fork.ppid, self->fork.ptid);
+        /*
+         * A thread clone will have the same PID for both parent and child.
+         */
+        if (thread == parent)
+                return 0;
+
+        if (self->header.type == PERF_RECORD_EXIT)
+                return 0;
+
+        if (thread == NULL || parent == NULL ||
+            thread__fork(thread, parent) < 0) {
+                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+void thread__find_addr_map(struct thread *self,
+                           struct perf_session *session, u8 cpumode,
+                           enum map_type type, u64 addr,
+                           struct addr_location *al)
+{
+        struct map_groups *mg = &self->mg;
+
+        al->thread = self;
+        al->addr = addr;
+
+        if (cpumode == PERF_RECORD_MISC_KERNEL) {
+                al->level = 'k';
+                mg = &session->kmaps;
+        } else if (cpumode == PERF_RECORD_MISC_USER)
+                al->level = '.';
+        else {
+                al->level = 'H';
+                al->map = NULL;
+                return;
+        }
+try_again:
+        al->map = map_groups__find(mg, type, al->addr);
+        if (al->map == NULL) {
+                /*
+                 * If this is outside of all known maps, and is a negative
+                 * address, try to look it up in the kernel dso, as it might be
+                 * a vsyscall or vdso (which executes in user-mode).
+                 *
+                 * XXX This is nasty, we should have a symbol list in the
+                 * "[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;
+                        goto try_again;
+                }
+        } else
+                al->addr = al->map->map_ip(al->map, al->addr);
+}
+
+void thread__find_addr_location(struct thread *self,
+                                struct perf_session *session, u8 cpumode,
+                                enum map_type type, u64 addr,
+                                struct addr_location *al,
+                                symbol_filter_t filter)
+{
+        thread__find_addr_map(self, session, cpumode, type, addr, al);
+        if (al->map != NULL)
+                al->sym = map__find_symbol(al->map, al->addr, filter);
+        else
+                al->sym = NULL;
+}
+
+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)
+                        dsos__col_width = slen;
+        }
+
+        self->slen_calculated = 1;
+}
+
+int event__preprocess_sample(const event_t *self, struct perf_session *session,
+                             struct addr_location *al, symbol_filter_t filter)
+{
+        u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread = perf_session__findnew(session, self->ip.pid);
+
+        if (thread == NULL)
+                return -1;
+
+        if (symbol_conf.comm_list &&
+            !strlist__has_entry(symbol_conf.comm_list, thread->comm))
+                goto out_filtered;
+
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
+                                   self->ip.ip, al, filter);
+        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;
+
+        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:
+        al->filtered = true;
+        return 0;
+}
+
+int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
+{
+        u64 *array = event->sample.array;
+
+        if (type & PERF_SAMPLE_IP) {
+                data->ip = event->ip.ip;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_TID) {
+                u32 *p = (u32 *)array;
+                data->pid = p[0];
+                data->tid = p[1];
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_TIME) {
+                data->time = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_ADDR) {
+                data->addr = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_ID) {
+                data->id = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_STREAM_ID) {
+                data->stream_id = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_CPU) {
+                u32 *p = (u32 *)array;
+                data->cpu = *p;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_PERIOD) {
+                data->period = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_READ) {
+                pr_debug("PERF_SAMPLE_READ is unsuported for now\n");
+                return -1;
+        }
+
+        if (type & PERF_SAMPLE_CALLCHAIN) {
+                data->callchain = (struct ip_callchain *)array;
+                array += 1 + data->callchain->nr;
+        }
+
+        if (type & PERF_SAMPLE_RAW) {
+                u32 *p = (u32 *)array;
+                data->raw_size = *p;
+                p++;
+                data->raw_data = p;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 2c9c26d6ded0..a33b94952e34 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -1,14 +1,10 @@
 #ifndef __PERF_RECORD_H
 #define __PERF_RECORD_H
-#include "../perf.h"
-#include "util.h"
-#include <linux/list.h>
 
-enum {
-        SHOW_KERNEL     = 1,
-        SHOW_USER       = 2,
-        SHOW_HV         = 4,
-};
+#include <limits.h>
+
+#include "../perf.h"
+#include "map.h"
 
 /*
  * PERF_SAMPLE_IP | PERF_SAMPLE_TID | *
@@ -60,11 +56,32 @@ struct read_event {
         u64 id;
 };
 
-struct sample_event{
+struct sample_event {
         struct perf_event_header        header;
         u64 array[];
 };
 
+struct sample_data {
+        u64 ip;
+        u32 pid, tid;
+        u64 time;
+        u64 addr;
+        u64 id;
+        u64 stream_id;
+        u32 cpu;
+        u64 period;
+        struct ip_callchain *callchain;
+        u32 raw_size;
+        void *raw_data;
+};
+
+#define BUILD_ID_SIZE 20
+
+struct build_id_event {
+        struct perf_event_header header;
+        u8                       build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
+        char                     filename[];
+};
 
 typedef union event_union {
         struct perf_event_header        header;
@@ -77,28 +94,44 @@ typedef union event_union {
         struct sample_event             sample;
 } event_t;
 
-struct map {
-        struct list_head        node;
-        u64                     start;
-        u64                     end;
-        u64                     pgoff;
-        u64                     (*map_ip)(struct map *, u64);
-        struct dso              *dso;
+struct events_stats {
+        u64 total;
+        u64 lost;
 };
 
-static inline u64 map__map_ip(struct map *map, u64 ip)
-{
-        return ip - map->start + map->pgoff;
-}
+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;
+
+typedef int (*event__handler_t)(event_t *event, struct perf_session *session);
+
+int event__synthesize_thread(pid_t pid, event__handler_t process,
+                             struct perf_session *session);
+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);
+int event__synthesize_modules(event__handler_t process,
+                              struct perf_session *session);
 
-static inline u64 vdso__map_ip(struct map *map __used, u64 ip)
-{
-        return ip;
-}
+int event__process_comm(event_t *self, struct perf_session *session);
+int event__process_lost(event_t *self, struct perf_session *session);
+int event__process_mmap(event_t *self, struct perf_session *session);
+int event__process_task(event_t *self, struct perf_session *session);
 
-struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen);
-struct map *map__clone(struct map *self);
-int map__overlap(struct map *l, struct map *r);
-size_t map__fprintf(struct map *self, FILE *fp);
+struct addr_location;
+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);
 
-#endif
+#endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/exec_cmd.h b/tools/perf/util/exec_cmd.h
index effe25eb1545..31647ac92ed1 100644
--- a/tools/perf/util/exec_cmd.h
+++ b/tools/perf/util/exec_cmd.h
@@ -1,5 +1,5 @@
-#ifndef PERF_EXEC_CMD_H
-#define PERF_EXEC_CMD_H
+#ifndef __PERF_EXEC_CMD_H
+#define __PERF_EXEC_CMD_H
 
 extern void perf_set_argv_exec_path(const char *exec_path);
 extern const char *perf_extract_argv0_path(const char *path);
@@ -10,4 +10,4 @@ extern int execv_perf_cmd(const char **argv); /* NULL terminated */
 extern int execl_perf_cmd(const char *cmd, ...);
 extern const char *system_path(const char *path);
 
-#endif /* PERF_EXEC_CMD_H */
+#endif /* __PERF_EXEC_CMD_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index e306857b2c2b..6c9aa16ee51f 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,10 +1,20 @@
+#define _FILE_OFFSET_BITS 64
+
 #include <sys/types.h>
+#include <byteswap.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
 
 #include "util.h"
 #include "header.h"
+#include "../perf.h"
+#include "trace-event.h"
+#include "session.h"
+#include "symbol.h"
+#include "debug.h"
 
 /*
  * Create new perf.data header attribute:
@@ -13,75 +23,80 @@ struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
 {
         struct perf_header_attr *self = malloc(sizeof(*self));
 
-        if (!self)
-                die("nomem");
-
-        self->attr = *attr;
-        self->ids = 0;
-        self->size = 1;
-        self->id = malloc(sizeof(u64));
-
-        if (!self->id)
-                die("nomem");
+        if (self != NULL) {
+                self->attr = *attr;
+                self->ids  = 0;
+                self->size = 1;
+                self->id   = malloc(sizeof(u64));
+                if (self->id == NULL) {
+                        free(self);
+                        self = NULL;
+                }
+        }
 
         return self;
 }
 
-void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
+void perf_header_attr__delete(struct perf_header_attr *self)
+{
+        free(self->id);
+        free(self);
+}
+
+int perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
 {
         int pos = self->ids;
 
         self->ids++;
         if (self->ids > self->size) {
-                self->size *= 2;
-                self->id = realloc(self->id, self->size * sizeof(u64));
-                if (!self->id)
-                        die("nomem");
+                int nsize = self->size * 2;
+                u64 *nid = realloc(self->id, nsize * sizeof(u64));
+
+                if (nid == NULL)
+                        return -1;
+
+                self->size = nsize;
+                self->id = nid;
         }
         self->id[pos] = id;
+        return 0;
 }
 
-/*
- * Create new perf.data header:
- */
-struct perf_header *perf_header__new(void)
+int perf_header__init(struct perf_header *self)
 {
-        struct perf_header *self = malloc(sizeof(*self));
-
-        if (!self)
-                die("nomem");
-
-        self->frozen = 0;
-
-        self->attrs = 0;
         self->size = 1;
         self->attr = malloc(sizeof(void *));
-
-        if (!self->attr)
-                die("nomem");
-
-        self->data_offset = 0;
-        self->data_size = 0;
-
-        return self;
+        return self->attr == NULL ? -ENOMEM : 0;
 }
 
-void perf_header__add_attr(struct perf_header *self,
-                           struct perf_header_attr *attr)
+void perf_header__exit(struct perf_header *self)
 {
-        int pos = self->attrs;
+        int i;
+        for (i = 0; i < self->attrs; ++i)
+                perf_header_attr__delete(self->attr[i]);
+        free(self->attr);
+}
 
+int perf_header__add_attr(struct perf_header *self,
+                          struct perf_header_attr *attr)
+{
         if (self->frozen)
-                die("frozen");
-
-        self->attrs++;
-        if (self->attrs > self->size) {
-                self->size *= 2;
-                self->attr = realloc(self->attr, self->size * sizeof(void *));
-                if (!self->attr)
-                        die("nomem");
+                return -1;
+
+        if (self->attrs == self->size) {
+                int nsize = self->size * 2;
+                struct perf_header_attr **nattr;
+
+                nattr = realloc(self->attr, nsize * sizeof(void *));
+                if (nattr == NULL)
+                        return -1;
+
+                self->size = nsize;
+                self->attr = nattr;
         }
-        self->attr[pos] = attr;
+
+        self->attr[self->attrs++] = attr;
+        return 0;
 }
 
 #define MAX_EVENT_NAME 64
@@ -94,24 +109,28 @@ struct perf_trace_event_type {
 static int event_count;
 static struct perf_trace_event_type *events;
 
-void perf_header__push_event(u64 id, const char *name)
+int perf_header__push_event(u64 id, const char *name)
 {
         if (strlen(name) > MAX_EVENT_NAME)
-                printf("Event %s will be truncated\n", name);
+                pr_warning("Event %s will be truncated\n", name);
 
         if (!events) {
                 events = malloc(sizeof(struct perf_trace_event_type));
-                if (!events)
-                        die("nomem");
+                if (events == NULL)
+                        return -ENOMEM;
         } else {
-                events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
-                if (!events)
-                        die("nomem");
+                struct perf_trace_event_type *nevents;
+
+                nevents = realloc(events, (event_count + 1) * sizeof(*events));
+                if (nevents == NULL)
+                        return -ENOMEM;
+                events = nevents;
         }
         memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
         events[event_count].event_id = id;
         strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
         event_count++;
+        return 0;
 }
 
 char *perf_header__find_event(u64 id)
@@ -128,44 +147,292 @@ static const char *__perf_magic = "PERFFILE";
 
 #define PERF_MAGIC      (*(u64 *)__perf_magic)
 
-struct perf_file_section {
-        u64 offset;
-        u64 size;
-};
-
 struct perf_file_attr {
         struct perf_event_attr  attr;
         struct perf_file_section        ids;
 };
 
-struct perf_file_header {
-        u64                             magic;
-        u64                             size;
-        u64                             attr_size;
-        struct perf_file_section        attrs;
-        struct perf_file_section        data;
-        struct perf_file_section        event_types;
-};
+void perf_header__set_feat(struct perf_header *self, int feat)
+{
+        set_bit(feat, self->adds_features);
+}
 
-static void do_write(int fd, void *buf, size_t size)
+bool perf_header__has_feat(const struct perf_header *self, int feat)
+{
+        return test_bit(feat, self->adds_features);
+}
+
+static int do_write(int fd, const void *buf, size_t size)
 {
         while (size) {
                 int ret = write(fd, buf, size);
 
                 if (ret < 0)
-                        die("failed to write");
+                        return -errno;
 
                 size -= ret;
                 buf += ret;
         }
+
+        return 0;
+}
+
+#define NAME_ALIGN 64
+
+static int write_padded(int fd, const void *bf, size_t count,
+                        size_t count_aligned)
+{
+        static const char zero_buf[NAME_ALIGN];
+        int err = do_write(fd, bf, count);
+
+        if (!err)
+                err = do_write(fd, zero_buf, count_aligned - count);
+
+        return err;
+}
+
+#define dsos__for_each_with_build_id(pos, head) \
+        list_for_each_entry(pos, head, node)    \
+                if (!pos->has_build_id)         \
+                        continue;               \
+                else
+
+static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
+{
+        struct dso *pos;
+
+        dsos__for_each_with_build_id(pos, head) {
+                int err;
+                struct build_id_event b;
+                size_t len;
+
+                if (!pos->hit)
+                        continue;
+                len = pos->long_name_len + 1;
+                len = ALIGN(len, NAME_ALIGN);
+                memset(&b, 0, sizeof(b));
+                memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
+                b.header.misc = misc;
+                b.header.size = sizeof(b) + len;
+                err = do_write(fd, &b, sizeof(b));
+                if (err < 0)
+                        return err;
+                err = write_padded(fd, pos->long_name,
+                                   pos->long_name_len + 1, len);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int dsos__write_buildid_table(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);
+        return err;
+}
+
+int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+                          const char *name, bool is_kallsyms)
+{
+        const size_t size = PATH_MAX;
+        char *filename = malloc(size),
+             *linkname = malloc(size), *targetname;
+        int len, err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        len = snprintf(filename, size, "%s%s%s",
+                       debugdir, is_kallsyms ? "/" : "", name);
+        if (mkdir_p(filename, 0755))
+                goto out_free;
+
+        snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
+
+        if (access(filename, F_OK)) {
+                if (is_kallsyms) {
+                         if (copyfile("/proc/kallsyms", filename))
+                                goto out_free;
+                } else if (link(name, filename) && copyfile(name, filename))
+                        goto out_free;
+        }
+
+        len = snprintf(linkname, size, "%s/.build-id/%.2s",
+                       debugdir, sbuild_id);
+
+        if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
+                goto out_free;
+
+        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
+        targetname = filename + strlen(debugdir) - 5;
+        memcpy(targetname, "../..", 5);
+
+        if (symlink(targetname, linkname) == 0)
+                err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
+                                 const char *name, const char *debugdir,
+                                 bool is_kallsyms)
+{
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        build_id__sprintf(build_id, build_id_size, sbuild_id);
+
+        return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
+}
+
+int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
+{
+        const size_t size = PATH_MAX;
+        char *filename = malloc(size),
+             *linkname = malloc(size);
+        int err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, sbuild_id + 2);
+
+        if (access(linkname, F_OK))
+                goto out_free;
+
+        if (readlink(linkname, filename, size) < 0)
+                goto out_free;
+
+        if (unlink(linkname))
+                goto out_free;
+
+        /*
+         * Since the link is relative, we must make it absolute:
+         */
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, filename);
+
+        if (unlink(linkname))
+                goto out_free;
+
+        err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int dso__cache_build_id(struct dso *self, const char *debugdir)
+{
+        bool is_kallsyms = self->kernel && self->long_name[0] != '/';
+
+        return build_id_cache__add_b(self->build_id, sizeof(self->build_id),
+                                     self->long_name, debugdir, is_kallsyms);
+}
+
+static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
+{
+        struct dso *pos;
+        int err = 0;
+
+        dsos__for_each_with_build_id(pos, head)
+                if (dso__cache_build_id(pos, debugdir))
+                        err = -1;
+
+        return err;
+}
+
+static int dsos__cache_build_ids(void)
+{
+        int err_kernel, err_user;
+        char debugdir[PATH_MAX];
+
+        snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"),
+                 DEBUG_CACHE_DIR);
+
+        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;
+}
+
+static int perf_header__adds_write(struct perf_header *self, int fd)
+{
+        int nr_sections;
+        struct perf_file_section *feat_sec;
+        int sec_size;
+        u64 sec_start;
+        int idx = 0, err;
+
+        if (dsos__read_build_ids(true))
+                perf_header__set_feat(self, HEADER_BUILD_ID);
+
+        nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
+        if (!nr_sections)
+                return 0;
+
+        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        if (feat_sec == NULL)
+                return -ENOMEM;
+
+        sec_size = sizeof(*feat_sec) * nr_sections;
+
+        sec_start = self->data_offset + self->data_size;
+        lseek(fd, sec_start + sec_size, SEEK_SET);
+
+        if (perf_header__has_feat(self, HEADER_TRACE_INFO)) {
+                struct perf_file_section *trace_sec;
+
+                trace_sec = &feat_sec[idx++];
+
+                /* Write trace info */
+                trace_sec->offset = lseek(fd, 0, SEEK_CUR);
+                read_tracing_data(fd, attrs, nr_counters);
+                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;
+
+                buildid_sec = &feat_sec[idx++];
+
+                /* Write build-ids */
+                buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
+                err = dsos__write_buildid_table(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();
+        }
+
+        lseek(fd, sec_start, SEEK_SET);
+        err = do_write(fd, feat_sec, sec_size);
+        if (err < 0)
+                pr_debug("failed to write feature section\n");
+out_free:
+        free(feat_sec);
+        return err;
 }
 
-void perf_header__write(struct perf_header *self, int fd)
+int perf_header__write(struct perf_header *self, int fd, bool at_exit)
 {
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         struct perf_header_attr *attr;
-        int i;
+        int i, err;
 
         lseek(fd, sizeof(f_header), SEEK_SET);
 
@@ -174,7 +441,11 @@ void perf_header__write(struct perf_header *self, int fd)
                 attr = self->attr[i];
 
                 attr->id_offset = lseek(fd, 0, SEEK_CUR);
-                do_write(fd, attr->id, attr->ids * sizeof(u64));
+                err = do_write(fd, attr->id, attr->ids * sizeof(u64));
+                if (err < 0) {
+                        pr_debug("failed to write perf header\n");
+                        return err;
+                }
         }
 
 
@@ -190,17 +461,31 @@ void perf_header__write(struct perf_header *self, int fd)
                                 .size   = attr->ids * sizeof(u64),
                         }
                 };
-                do_write(fd, &f_attr, sizeof(f_attr));
+                err = do_write(fd, &f_attr, sizeof(f_attr));
+                if (err < 0) {
+                        pr_debug("failed to write perf header attribute\n");
+                        return err;
+                }
         }
 
         self->event_offset = lseek(fd, 0, SEEK_CUR);
         self->event_size = event_count * sizeof(struct perf_trace_event_type);
-        if (events)
-                do_write(fd, events, self->event_size);
-
+        if (events) {
+                err = do_write(fd, events, self->event_size);
+                if (err < 0) {
+                        pr_debug("failed to write perf header events\n");
+                        return err;
+                }
+        }
 
         self->data_offset = lseek(fd, 0, SEEK_CUR);
 
+        if (at_exit) {
+                err = perf_header__adds_write(self, fd);
+                if (err < 0)
+                        return err;
+        }
+
         f_header = (struct perf_file_header){
                 .magic     = PERF_MAGIC,
                 .size      = sizeof(f_header),
@@ -219,44 +504,175 @@ void perf_header__write(struct perf_header *self, int fd)
                 },
         };
 
+        memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
+
         lseek(fd, 0, SEEK_SET);
-        do_write(fd, &f_header, sizeof(f_header));
+        err = do_write(fd, &f_header, sizeof(f_header));
+        if (err < 0) {
+                pr_debug("failed to write perf header\n");
+                return err;
+        }
         lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 
         self->frozen = 1;
+        return 0;
 }
 
-static void do_read(int fd, void *buf, size_t size)
+static int do_read(int fd, void *buf, size_t size)
 {
         while (size) {
                 int ret = read(fd, buf, size);
 
-                if (ret < 0)
-                        die("failed to read");
-                if (ret == 0)
-                        die("failed to read: missing data");
+                if (ret <= 0)
+                        return -1;
 
                 size -= ret;
                 buf += ret;
         }
+
+        return 0;
 }
 
-struct perf_header *perf_header__read(int fd)
+static int perf_header__getbuffer64(struct perf_header *self,
+                                    int fd, void *buf, size_t size)
 {
-        struct perf_header      *self = perf_header__new();
-        struct perf_file_header f_header;
-        struct perf_file_attr   f_attr;
-        u64                     f_id;
+        if (do_read(fd, buf, size))
+                return -1;
 
-        int nr_attrs, nr_ids, i, j;
+        if (self->needs_swap)
+                mem_bswap_64(buf, size);
+
+        return 0;
+}
+
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 struct perf_header *ph,
+                                                 int feat, int fd))
+{
+        struct perf_file_section *feat_sec;
+        int nr_sections;
+        int sec_size;
+        int idx = 0;
+        int err = -1, feat = 1;
+
+        nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
+        if (!nr_sections)
+                return 0;
+
+        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        if (!feat_sec)
+                return -1;
+
+        sec_size = sizeof(*feat_sec) * nr_sections;
+
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        if (perf_header__getbuffer64(self, fd, feat_sec, sec_size))
+                goto out_free;
+
+        err = 0;
+        while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
+                if (perf_header__has_feat(self, feat)) {
+                        struct perf_file_section *sec = &feat_sec[idx++];
+
+                        err = process(sec, self, feat, fd);
+                        if (err < 0)
+                                break;
+                }
+                ++feat;
+        }
+out_free:
+        free(feat_sec);
+        return err;
+}
 
+int perf_file_header__read(struct perf_file_header *self,
+                           struct perf_header *ph, int fd)
+{
         lseek(fd, 0, SEEK_SET);
-        do_read(fd, &f_header, sizeof(f_header));
 
-        if (f_header.magic      != PERF_MAGIC           ||
-            f_header.size       != sizeof(f_header)     ||
-            f_header.attr_size  != sizeof(f_attr))
-                die("incompatible file format");
+        if (do_read(fd, self, sizeof(*self)) ||
+            memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
+                return -1;
+
+        if (self->attr_size != sizeof(struct perf_file_attr)) {
+                u64 attr_size = bswap_64(self->attr_size);
+
+                if (attr_size != sizeof(struct perf_file_attr))
+                        return -1;
+
+                mem_bswap_64(self, offsetof(struct perf_file_header,
+                                            adds_features));
+                ph->needs_swap = true;
+        }
+
+        if (self->size != sizeof(*self)) {
+                /* Support the previous format */
+                if (self->size == offsetof(typeof(*self), adds_features))
+                        bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
+                else
+                        return -1;
+        }
+
+        memcpy(&ph->adds_features, &self->adds_features,
+               sizeof(ph->adds_features));
+        /*
+         * FIXME: hack that assumes that if we need swap the perf.data file
+         * may be coming from an arch with a different word-size, ergo different
+         * DEFINE_BITMAP format, investigate more later, but for now its mostly
+         * safe to assume that we have a build-id section. Trace files probably
+         * have several other issues in this realm anyway...
+         */
+        if (ph->needs_swap) {
+                memset(&ph->adds_features, 0, sizeof(ph->adds_features));
+                perf_header__set_feat(ph, HEADER_BUILD_ID);
+        }
+
+        ph->event_offset = self->event_types.offset;
+        ph->event_size   = self->event_types.size;
+        ph->data_offset  = self->data.offset;
+        ph->data_size    = self->data.size;
+        return 0;
+}
+
+static int perf_file_section__process(struct perf_file_section *self,
+                                      struct perf_header *ph,
+                                      int feat, int fd)
+{
+        if (lseek(fd, self->offset, SEEK_SET) == (off_t)-1) {
+                pr_debug("Failed to lseek to %Ld offset for feature %d, "
+                         "continuing...\n", self->offset, feat);
+                return 0;
+        }
+
+        switch (feat) {
+        case HEADER_TRACE_INFO:
+                trace_report(fd);
+                break;
+
+        case HEADER_BUILD_ID:
+                if (perf_header__read_build_ids(ph, fd, self->offset, self->size))
+                        pr_debug("Failed to read buildids, continuing...\n");
+                break;
+        default:
+                pr_debug("unknown feature %d, continuing...\n", feat);
+        }
+
+        return 0;
+}
+
+int perf_header__read(struct perf_header *self, int fd)
+{
+        struct perf_file_header f_header;
+        struct perf_file_attr   f_attr;
+        u64                     f_id;
+        int nr_attrs, nr_ids, i, j;
+
+        if (perf_file_header__read(&f_header, self, fd) < 0) {
+                pr_debug("incompatible file format\n");
+                return -EINVAL;
+        }
 
         nr_attrs = f_header.attrs.size / sizeof(f_attr);
         lseek(fd, f_header.attrs.offset, SEEK_SET);
@@ -265,42 +681,54 @@ struct perf_header *perf_header__read(int fd)
                 struct perf_header_attr *attr;
                 off_t tmp;
 
-                do_read(fd, &f_attr, sizeof(f_attr));
+                if (perf_header__getbuffer64(self, fd, &f_attr, sizeof(f_attr)))
+                        goto out_errno;
+
                 tmp = lseek(fd, 0, SEEK_CUR);
 
                 attr = perf_header_attr__new(&f_attr.attr);
+                if (attr == NULL)
+                         return -ENOMEM;
 
                 nr_ids = f_attr.ids.size / sizeof(u64);
                 lseek(fd, f_attr.ids.offset, SEEK_SET);
 
                 for (j = 0; j < nr_ids; j++) {
-                        do_read(fd, &f_id, sizeof(f_id));
+                        if (perf_header__getbuffer64(self, fd, &f_id, sizeof(f_id)))
+                                goto out_errno;
 
-                        perf_header_attr__add_id(attr, f_id);
+                        if (perf_header_attr__add_id(attr, f_id) < 0) {
+                                perf_header_attr__delete(attr);
+                                return -ENOMEM;
+                        }
+                }
+                if (perf_header__add_attr(self, attr) < 0) {
+                        perf_header_attr__delete(attr);
+                        return -ENOMEM;
                 }
-                perf_header__add_attr(self, attr);
+
                 lseek(fd, tmp, SEEK_SET);
         }
 
         if (f_header.event_types.size) {
                 lseek(fd, f_header.event_types.offset, SEEK_SET);
                 events = malloc(f_header.event_types.size);
-                if (!events)
-                        die("nomem");
-                do_read(fd, events, f_header.event_types.size);
+                if (events == NULL)
+                        return -ENOMEM;
+                if (perf_header__getbuffer64(self, fd, events,
+                                             f_header.event_types.size))
+                        goto out_errno;
                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
-        self->event_offset = f_header.event_types.offset;
-        self->event_size   = f_header.event_types.size;
 
-        self->data_offset = f_header.data.offset;
-        self->data_size   = f_header.data.size;
+        perf_header__process_sections(self, fd, perf_file_section__process);
 
         lseek(fd, self->data_offset, SEEK_SET);
 
         self->frozen = 1;
-
-        return self;
+        return 0;
+out_errno:
+        return -errno;
 }
 
 u64 perf_header__sample_type(struct perf_header *header)
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index a0761bc7863c..82a6af72d4cc 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -1,9 +1,13 @@
-#ifndef _PERF_HEADER_H
-#define _PERF_HEADER_H
+#ifndef __PERF_HEADER_H
+#define __PERF_HEADER_H
 
 #include "../../../include/linux/perf_event.h"
 #include <sys/types.h>
+#include <stdbool.h>
 #include "types.h"
+#include "event.h"
+
+#include <linux/bitmap.h>
 
 struct perf_header_attr {
         struct perf_event_attr attr;
@@ -12,36 +16,77 @@ struct perf_header_attr {
         off_t id_offset;
 };
 
+enum {
+        HEADER_TRACE_INFO = 1,
+        HEADER_BUILD_ID,
+        HEADER_LAST_FEATURE,
+};
+
+#define HEADER_FEAT_BITS                        256
+
+struct perf_file_section {
+        u64 offset;
+        u64 size;
+};
+
+struct perf_file_header {
+        u64                             magic;
+        u64                             size;
+        u64                             attr_size;
+        struct perf_file_section        attrs;
+        struct perf_file_section        data;
+        struct perf_file_section        event_types;
+        DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
+};
+
+struct perf_header;
+
+int perf_file_header__read(struct perf_file_header *self,
+                           struct perf_header *ph, int fd);
+
 struct perf_header {
-        int frozen;
-        int attrs, size;
+        int                     frozen;
+        int                     attrs, size;
         struct perf_header_attr **attr;
-        s64 attr_offset;
-        u64 data_offset;
-        u64 data_size;
-        u64 event_offset;
-        u64 event_size;
+        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);
 };
 
-struct perf_header *perf_header__read(int fd);
-void perf_header__write(struct perf_header *self, int fd);
+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__write(struct perf_header *self, int fd, bool at_exit);
 
-void perf_header__add_attr(struct perf_header *self,
-                           struct perf_header_attr *attr);
+int perf_header__add_attr(struct perf_header *self,
+                          struct perf_header_attr *attr);
 
-void perf_header__push_event(u64 id, const char *name);
+int perf_header__push_event(u64 id, const char *name);
 char *perf_header__find_event(u64 id);
 
+struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr);
+void perf_header_attr__delete(struct perf_header_attr *self);
 
-struct perf_header_attr *
-perf_header_attr__new(struct perf_event_attr *attr);
-void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
+int perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
 
 u64 perf_header__sample_type(struct perf_header *header);
 struct perf_event_attr *
 perf_header__find_attr(u64 id, struct perf_header *header);
+void perf_header__set_feat(struct perf_header *self, int feat);
+bool perf_header__has_feat(const struct perf_header *self, int feat);
 
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 struct perf_header *ph,
+                                                 int feat, int fd));
 
-struct perf_header *perf_header__new(void);
+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);
 
-#endif /* _PERF_HEADER_H */
+#endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/help.h b/tools/perf/util/help.h
index 7128783637b4..7f5c6dedd714 100644
--- a/tools/perf/util/help.h
+++ b/tools/perf/util/help.h
@@ -1,5 +1,5 @@
-#ifndef HELP_H
-#define HELP_H
+#ifndef __PERF_HELP_H
+#define __PERF_HELP_H
 
 struct cmdnames {
         size_t alloc;
@@ -26,4 +26,4 @@ int is_in_cmdlist(struct cmdnames *c, const char *s);
 void list_commands(const char *title, struct cmdnames *main_cmds,
                    struct cmdnames *other_cmds);
 
-#endif /* HELP_H */
+#endif /* __PERF_HELP_H */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
new file mode 100644
index 000000000000..2be33c7dbf03
--- /dev/null
+++ b/tools/perf/util/hist.c
@@ -0,0 +1,668 @@
+#include "hist.h"
+#include "session.h"
+#include "sort.h"
+#include <math.h>
+
+struct callchain_param  callchain_param = {
+        .mode   = CHAIN_GRAPH_REL,
+        .min_percent = 0.5
+};
+
+/*
+ * histogram, sorted on item, collects counts
+ */
+
+struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
+                                                  struct addr_location *al,
+                                                  struct symbol *sym_parent,
+                                                  u64 count, bool *hit)
+{
+        struct rb_node **p = &hists->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *he;
+        struct hist_entry entry = {
+                .thread = al->thread,
+                .map    = al->map,
+                .sym    = al->sym,
+                .ip     = al->addr,
+                .level  = al->level,
+                .count  = count,
+                .parent = sym_parent,
+        };
+        int cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                he = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__cmp(&entry, he);
+
+                if (!cmp) {
+                        *hit = true;
+                        return he;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        he = malloc(sizeof(*he));
+        if (!he)
+                return NULL;
+        *he = entry;
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, hists);
+        *hit = false;
+        return he;
+}
+
+int64_t
+hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                cmp = se->cmp(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+int64_t
+hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                int64_t (*f)(struct hist_entry *, struct hist_entry *);
+
+                f = se->collapse ?: se->cmp;
+
+                cmp = f(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+void hist_entry__free(struct hist_entry *he)
+{
+        free(he);
+}
+
+/*
+ * collapse the histogram
+ */
+
+static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+        int64_t cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__collapse(iter, he);
+
+                if (!cmp) {
+                        iter->count += he->count;
+                        hist_entry__free(he);
+                        return;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, root);
+}
+
+void perf_session__collapse_resort(struct rb_root *hists)
+{
+        struct rb_root tmp;
+        struct rb_node *next;
+        struct hist_entry *n;
+
+        if (!sort__need_collapse)
+                return;
+
+        tmp = RB_ROOT;
+        next = rb_first(hists);
+
+        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);
+        }
+
+        *hists = tmp;
+}
+
+/*
+ * reverse the map, sort on count.
+ */
+
+static void perf_session__insert_output_hist_entry(struct rb_root *root,
+                                                   struct hist_entry *he,
+                                                   u64 min_callchain_hits)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+
+        if (symbol_conf.use_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)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, root);
+}
+
+void perf_session__output_resort(struct rb_root *hists, u64 total_samples)
+{
+        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);
+
+        tmp = RB_ROOT;
+        next = rb_first(hists);
+
+        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);
+        }
+
+        *hists = tmp;
+}
+
+static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
+{
+        int i;
+        int ret = fprintf(fp, "            ");
+
+        for (i = 0; i < left_margin; i++)
+                ret += fprintf(fp, " ");
+
+        return ret;
+}
+
+static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
+                                          int left_margin)
+{
+        int i;
+        size_t ret = callchain__fprintf_left_margin(fp, left_margin);
+
+        for (i = 0; i < depth; i++)
+                if (depth_mask & (1 << i))
+                        ret += fprintf(fp, "|          ");
+                else
+                        ret += fprintf(fp, "           ");
+
+        ret += fprintf(fp, "\n");
+
+        return ret;
+}
+
+static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
+                                     int depth, int depth_mask, int count,
+                                     u64 total_samples, int hits,
+                                     int left_margin)
+{
+        int i;
+        size_t ret = 0;
+
+        ret += callchain__fprintf_left_margin(fp, left_margin);
+        for (i = 0; i < depth; i++) {
+                if (depth_mask & (1 << i))
+                        ret += fprintf(fp, "|");
+                else
+                        ret += fprintf(fp, " ");
+                if (!count && i == depth - 1) {
+                        double percent;
+
+                        percent = hits * 100.0 / total_samples;
+                        ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
+                } else
+                        ret += fprintf(fp, "%s", "          ");
+        }
+        if (chain->sym)
+                ret += fprintf(fp, "%s\n", chain->sym->name);
+        else
+                ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
+
+        return ret;
+}
+
+static struct symbol *rem_sq_bracket;
+static struct callchain_list rem_hits;
+
+static void init_rem_hits(void)
+{
+        rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
+        if (!rem_sq_bracket) {
+                fprintf(stderr, "Not enough memory to display remaining hits\n");
+                return;
+        }
+
+        strcpy(rem_sq_bracket->name, "[...]");
+        rem_hits.sym = rem_sq_bracket;
+}
+
+static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
+                                         u64 total_samples, int depth,
+                                         int depth_mask, int left_margin)
+{
+        struct rb_node *node, *next;
+        struct callchain_node *child;
+        struct callchain_list *chain;
+        int new_depth_mask = depth_mask;
+        u64 new_total;
+        u64 remaining;
+        size_t ret = 0;
+        int i;
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                new_total = self->children_hit;
+        else
+                new_total = total_samples;
+
+        remaining = new_total;
+
+        node = rb_first(&self->rb_root);
+        while (node) {
+                u64 cumul;
+
+                child = rb_entry(node, struct callchain_node, rb_node);
+                cumul = cumul_hits(child);
+                remaining -= cumul;
+
+                /*
+                 * The depth mask manages the output of pipes that show
+                 * the depth. We don't want to keep the pipes of the current
+                 * level for the last child of this depth.
+                 * Except if we have remaining filtered hits. They will
+                 * supersede the last child
+                 */
+                next = rb_next(node);
+                if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
+                        new_depth_mask &= ~(1 << (depth - 1));
+
+                /*
+                 * But we keep the older depth mask for the line separator
+                 * to keep the level link until we reach the last child
+                 */
+                ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
+                                                   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,
+                                                      cumul,
+                                                      left_margin);
+                }
+                ret += __callchain__fprintf_graph(fp, child, new_total,
+                                                  depth + 1,
+                                                  new_depth_mask | (1 << depth),
+                                                  left_margin);
+                node = next;
+        }
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL &&
+                remaining && remaining != new_total) {
+
+                if (!rem_sq_bracket)
+                        return ret;
+
+                new_depth_mask &= ~(1 << (depth - 1));
+
+                ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
+                                              new_depth_mask, 0, new_total,
+                                              remaining, left_margin);
+        }
+
+        return ret;
+}
+
+static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
+                                       u64 total_samples, int left_margin)
+{
+        struct callchain_list *chain;
+        bool printed = false;
+        int i = 0;
+        int ret = 0;
+
+        list_for_each_entry(chain, &self->val, list) {
+                if (chain->ip >= PERF_CONTEXT_MAX)
+                        continue;
+
+                if (!i++ && sort__first_dimension == SORT_SYM)
+                        continue;
+
+                if (!printed) {
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+                        ret += fprintf(fp, "|\n");
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+                        ret += fprintf(fp, "---");
+
+                        left_margin += 3;
+                        printed = true;
+                } else
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+
+                if (chain->sym)
+                        ret += fprintf(fp, " %s\n", chain->sym->name);
+                else
+                        ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
+        }
+
+        ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
+
+        return ret;
+}
+
+static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
+                                      u64 total_samples)
+{
+        struct callchain_list *chain;
+        size_t ret = 0;
+
+        if (!self)
+                return 0;
+
+        ret += callchain__fprintf_flat(fp, self->parent, total_samples);
+
+
+        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);
+                else
+                        ret += fprintf(fp, "                %p\n",
+                                        (void *)(long)chain->ip);
+        }
+
+        return ret;
+}
+
+static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
+                                            u64 total_samples, int left_margin)
+{
+        struct rb_node *rb_node;
+        struct callchain_node *chain;
+        size_t ret = 0;
+
+        rb_node = rb_first(&self->sorted_chain);
+        while (rb_node) {
+                double percent;
+
+                chain = rb_entry(rb_node, struct callchain_node, rb_node);
+                percent = chain->hit * 100.0 / total_samples;
+                switch (callchain_param.mode) {
+                case CHAIN_FLAT:
+                        ret += percent_color_fprintf(fp, "           %6.2f%%\n",
+                                                     percent);
+                        ret += callchain__fprintf_flat(fp, chain, total_samples);
+                        break;
+                case CHAIN_GRAPH_ABS: /* Falldown */
+                case CHAIN_GRAPH_REL:
+                        ret += callchain__fprintf_graph(fp, chain, total_samples,
+                                                        left_margin);
+                case CHAIN_NONE:
+                default:
+                        break;
+                }
+                ret += fprintf(fp, "\n");
+                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)
+{
+        struct sort_entry *se;
+        u64 count, total;
+        const char *sep = symbol_conf.field_sep;
+        size_t 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;
+        } else {
+                count = self->count;
+                total = session_total;
+        }
+
+        if (total)
+                ret = percent_color_fprintf(fp, sep ? "%.2f" : "   %6.2f%%",
+                                            (count * 100.0) / total);
+        else
+                ret = fprintf(fp, sep ? "%lld" : "%12lld ", count);
+
+        if (symbol_conf.show_nr_samples) {
+                if (sep)
+                        fprintf(fp, "%c%lld", *sep, count);
+                else
+                        fprintf(fp, "%11lld", count);
+        }
+
+        if (pair_session) {
+                char bf[32];
+                double old_percent = 0, new_percent = 0, diff;
+
+                if (total > 0)
+                        old_percent = (count * 100.0) / total;
+                if (session_total > 0)
+                        new_percent = (self->count * 100.0) / session_total;
+
+                diff = new_percent - old_percent;
+
+                if (fabs(diff) >= 0.01)
+                        snprintf(bf, sizeof(bf), "%+4.2F%%", diff);
+                else
+                        snprintf(bf, sizeof(bf), " ");
+
+                if (sep)
+                        ret += fprintf(fp, "%c%s", *sep, bf);
+                else
+                        ret += fprintf(fp, "%11.11s", bf);
+
+                if (show_displacement) {
+                        if (displacement)
+                                snprintf(bf, sizeof(bf), "%+4ld", displacement);
+                        else
+                                snprintf(bf, sizeof(bf), " ");
+
+                        if (sep)
+                                fprintf(fp, "%c%s", *sep, bf);
+                        else
+                                fprintf(fp, "%6.6s", bf);
+                }
+        }
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+
+                fprintf(fp, "%s", sep ?: "  ");
+                ret += se->print(fp, self, se->width ? *se->width : 0);
+        }
+
+        ret += fprintf(fp, "\n");
+
+        if (symbol_conf.use_callchain) {
+                int left_margin = 0;
+
+                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);
+                }
+
+                hist_entry_callchain__fprintf(fp, self, session_total,
+                                              left_margin);
+        }
+
+        return ret;
+}
+
+size_t perf_session__fprintf_hists(struct rb_root *hists,
+                                   struct perf_session *pair,
+                                   bool show_displacement, FILE *fp,
+                                   u64 session_total)
+{
+        struct sort_entry *se;
+        struct rb_node *nd;
+        size_t ret = 0;
+        unsigned long position = 1;
+        long displacement = 0;
+        unsigned int width;
+        const char *sep = symbol_conf.field_sep;
+        char *col_width = symbol_conf.col_width_list_str;
+
+        init_rem_hits();
+
+        fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
+
+        if (symbol_conf.show_nr_samples) {
+                if (sep)
+                        fprintf(fp, "%cSamples", *sep);
+                else
+                        fputs("  Samples  ", fp);
+        }
+
+        if (pair) {
+                if (sep)
+                        ret += fprintf(fp, "%cDelta", *sep);
+                else
+                        ret += fprintf(fp, "  Delta    ");
+
+                if (show_displacement) {
+                        if (sep)
+                                ret += fprintf(fp, "%cDisplacement", *sep);
+                        else
+                                ret += fprintf(fp, " Displ");
+                }
+        }
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+                if (sep) {
+                        fprintf(fp, "%c%s", *sep, se->header);
+                        continue;
+                }
+                width = strlen(se->header);
+                if (se->width) {
+                        if (symbol_conf.col_width_list_str) {
+                                if (col_width) {
+                                        *se->width = atoi(col_width);
+                                        col_width = strchr(col_width, ',');
+                                        if (col_width)
+                                                ++col_width;
+                                }
+                        }
+                        width = *se->width = max(*se->width, width);
+                }
+                fprintf(fp, "  %*s", width, se->header);
+        }
+        fprintf(fp, "\n");
+
+        if (sep)
+                goto print_entries;
+
+        fprintf(fp, "# ........");
+        if (symbol_conf.show_nr_samples)
+                fprintf(fp, " ..........");
+        if (pair) {
+                fprintf(fp, " ..........");
+                if (show_displacement)
+                        fprintf(fp, " .....");
+        }
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                unsigned int i;
+
+                if (se->elide)
+                        continue;
+
+                fprintf(fp, "  ");
+                if (se->width)
+                        width = *se->width;
+                else
+                        width = strlen(se->header);
+                for (i = 0; i < width; i++)
+                        fprintf(fp, ".");
+        }
+
+        fprintf(fp, "\n#\n");
+
+print_entries:
+        for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (show_displacement) {
+                        if (h->pair != NULL)
+                                displacement = ((long)h->pair->position -
+                                                (long)position);
+                        else
+                                displacement = 0;
+                        ++position;
+                }
+                ret += hist_entry__fprintf(h, pair, show_displacement,
+                                           displacement, fp, session_total);
+                if (h->map == NULL && verbose > 1) {
+                        __map_groups__fprintf_maps(&h->thread->mg,
+                                                   MAP__FUNCTION, fp);
+                        fprintf(fp, "%.10s end\n", graph_dotted_line);
+                }
+        }
+
+        free(rem_sq_bracket);
+
+        return ret;
+}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
new file mode 100644
index 000000000000..16f360cce5bf
--- /dev/null
+++ b/tools/perf/util/hist.h
@@ -0,0 +1,29 @@
+#ifndef __PERF_HIST_H
+#define __PERF_HIST_H
+
+#include <linux/types.h>
+#include "callchain.h"
+
+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);
+extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
+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);
+#endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/include/asm/asm-offsets.h b/tools/perf/util/include/asm/asm-offsets.h
new file mode 100644
index 000000000000..ed538942523d
--- /dev/null
+++ b/tools/perf/util/include/asm/asm-offsets.h
@@ -0,0 +1 @@
+/* stub */
diff --git a/tools/perf/util/include/asm/bitops.h b/tools/perf/util/include/asm/bitops.h
new file mode 100644
index 000000000000..58e9817ffae0
--- /dev/null
+++ b/tools/perf/util/include/asm/bitops.h
@@ -0,0 +1,18 @@
+#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/bug.h b/tools/perf/util/include/asm/bug.h
new file mode 100644
index 000000000000..7fcc6810adc2
--- /dev/null
+++ b/tools/perf/util/include/asm/bug.h
@@ -0,0 +1,22 @@
+#ifndef _PERF_ASM_GENERIC_BUG_H
+#define _PERF_ASM_GENERIC_BUG_H
+
+#define __WARN_printf(arg...)   do { fprintf(stderr, arg); } while (0)
+
+#define WARN(condition, format...) ({           \
+        int __ret_warn_on = !!(condition);      \
+        if (unlikely(__ret_warn_on))            \
+                __WARN_printf(format);          \
+        unlikely(__ret_warn_on);                \
+})
+
+#define WARN_ONCE(condition, format...) ({      \
+        static int __warned;                    \
+        int __ret_warn_once = !!(condition);    \
+                                                \
+        if (unlikely(__ret_warn_once))          \
+                if (WARN(!__warned, format))    \
+                        __warned = 1;           \
+        unlikely(__ret_warn_once);              \
+})
+#endif
diff --git a/tools/perf/util/include/asm/byteorder.h b/tools/perf/util/include/asm/byteorder.h
new file mode 100644
index 000000000000..b722abe3a626
--- /dev/null
+++ b/tools/perf/util/include/asm/byteorder.h
@@ -0,0 +1,2 @@
+#include <asm/types.h>
+#include "../../../../include/linux/swab.h"
diff --git a/tools/perf/util/include/asm/swab.h b/tools/perf/util/include/asm/swab.h
new file mode 100644
index 000000000000..ed538942523d
--- /dev/null
+++ b/tools/perf/util/include/asm/swab.h
@@ -0,0 +1 @@
+/* stub */
diff --git a/tools/perf/util/include/asm/uaccess.h b/tools/perf/util/include/asm/uaccess.h
new file mode 100644
index 000000000000..d0f72b8fcc35
--- /dev/null
+++ b/tools/perf/util/include/asm/uaccess.h
@@ -0,0 +1,14 @@
+#ifndef _PERF_ASM_UACCESS_H_
+#define _PERF_ASM_UACCESS_H_
+
+#define __get_user(src, dest)                                           \
+({                                                                      \
+        (src) = *dest;                                                  \
+        0;                                                              \
+})
+
+#define get_user        __get_user
+
+#define access_ok(type, addr, size)     1
+
+#endif
diff --git a/tools/perf/util/include/linux/bitmap.h b/tools/perf/util/include/linux/bitmap.h
new file mode 100644
index 000000000000..94507639a8c4
--- /dev/null
+++ b/tools/perf/util/include/linux/bitmap.h
@@ -0,0 +1,3 @@
+#include "../../../../include/linux/bitmap.h"
+#include "../../../../include/asm-generic/bitops/find.h"
+#include <linux/errno.h>
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
new file mode 100644
index 000000000000..8d63116e9435
--- /dev/null
+++ b/tools/perf/util/include/linux/bitops.h
@@ -0,0 +1,29 @@
+#ifndef _PERF_LINUX_BITOPS_H_
+#define _PERF_LINUX_BITOPS_H_
+
+#define __KERNEL__
+
+#define CONFIG_GENERIC_FIND_NEXT_BIT
+#define CONFIG_GENERIC_FIND_FIRST_BIT
+#include "../../../../include/linux/bitops.h"
+
+#undef __KERNEL__
+
+static inline void set_bit(int nr, unsigned long *addr)
+{
+        addr[nr / BITS_PER_LONG] |= 1UL << (nr % BITS_PER_LONG);
+}
+
+static __always_inline int test_bit(unsigned int nr, const unsigned long *addr)
+{
+        return ((1UL << (nr % BITS_PER_LONG)) &
+                (((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);
+
+#endif
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
new file mode 100644
index 000000000000..dfb0713ed47f
--- /dev/null
+++ b/tools/perf/util/include/linux/compiler.h
@@ -0,0 +1,10 @@
+#ifndef _PERF_LINUX_COMPILER_H_
+#define _PERF_LINUX_COMPILER_H_
+
+#ifndef __always_inline
+#define __always_inline inline
+#endif
+#define __user
+#define __attribute_const__
+
+#endif
diff --git a/tools/perf/util/include/linux/ctype.h b/tools/perf/util/include/linux/ctype.h
new file mode 100644
index 000000000000..a53d4ee1e0b7
--- /dev/null
+++ b/tools/perf/util/include/linux/ctype.h
@@ -0,0 +1 @@
+#include "../util.h"
diff --git a/tools/perf/util/include/linux/hash.h b/tools/perf/util/include/linux/hash.h
new file mode 100644
index 000000000000..201f57397997
--- /dev/null
+++ b/tools/perf/util/include/linux/hash.h
@@ -0,0 +1,5 @@
+#include "../../../../include/linux/hash.h"
+
+#ifndef PERF_HASH_H
+#define PERF_HASH_H
+#endif
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index a6b87390cb52..f2611655ab51 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -1,6 +1,16 @@
 #ifndef PERF_LINUX_KERNEL_H_
 #define PERF_LINUX_KERNEL_H_
 
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+
+#define ALIGN(x,a)              __ALIGN_MASK(x,(typeof(x))(a)-1)
+#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
+
 #ifndef offsetof
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 #endif
@@ -26,4 +36,71 @@
         _max1 > _max2 ? _max1 : _max2; })
 #endif
 
+#ifndef min
+#define min(x, y) ({                            \
+        typeof(x) _min1 = (x);                  \
+        typeof(y) _min2 = (y);                  \
+        (void) (&_min1 == &_min2);              \
+        _min1 < _min2 ? _min1 : _min2; })
+#endif
+
+#ifndef BUG_ON
+#define BUG_ON(cond) assert(!(cond))
+#endif
+
+/*
+ * Both need more care to handle endianness
+ * (Don't use bitmap_copy_le() for now)
+ */
+#define cpu_to_le64(x)  (x)
+#define cpu_to_le32(x)  (x)
+
+static inline int
+vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+        int i;
+        ssize_t ssize = size;
+
+        i = vsnprintf(buf, size, fmt, args);
+
+        return (i >= ssize) ? (ssize - 1) : i;
+}
+
+static inline int scnprintf(char * buf, size_t size, const char * fmt, ...)
+{
+        va_list args;
+        ssize_t ssize = size;
+        int i;
+
+        va_start(args, fmt);
+        i = vsnprintf(buf, size, fmt, args);
+        va_end(args);
+
+        return (i >= ssize) ? (ssize - 1) : i;
+}
+
+static inline unsigned long
+simple_strtoul(const char *nptr, char **endptr, int base)
+{
+        return strtoul(nptr, endptr, base);
+}
+
+#ifndef pr_fmt
+#define pr_fmt(fmt) fmt
+#endif
+
+#define pr_err(fmt, ...) \
+        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+#define pr_warning(fmt, ...) \
+        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+#define pr_info(fmt, ...) \
+        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+#define pr_debug(fmt, ...) \
+        eprintf(1, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debugN(n, fmt, ...) \
+        eprintf(n, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
+
 #endif
diff --git a/tools/perf/util/include/linux/string.h b/tools/perf/util/include/linux/string.h
new file mode 100644
index 000000000000..3b2f5900276f
--- /dev/null
+++ b/tools/perf/util/include/linux/string.h
@@ -0,0 +1 @@
+#include <string.h>
diff --git a/tools/perf/util/include/linux/types.h b/tools/perf/util/include/linux/types.h
new file mode 100644
index 000000000000..196862a81a21
--- /dev/null
+++ b/tools/perf/util/include/linux/types.h
@@ -0,0 +1,9 @@
+#ifndef _PERF_LINUX_TYPES_H_
+#define _PERF_LINUX_TYPES_H_
+
+#include <asm/types.h>
+
+#define DECLARE_BITMAP(name,bits) \
+        unsigned long name[BITS_TO_LONGS(bits)]
+
+#endif
diff --git a/tools/perf/util/levenshtein.h b/tools/perf/util/levenshtein.h
index 0173abeef52c..b0fcb6d8a881 100644
--- a/tools/perf/util/levenshtein.h
+++ b/tools/perf/util/levenshtein.h
@@ -1,8 +1,8 @@
-#ifndef LEVENSHTEIN_H
-#define LEVENSHTEIN_H
+#ifndef __PERF_LEVENSHTEIN_H
+#define __PERF_LEVENSHTEIN_H
 
 int levenshtein(const char *string1, const char *string2,
         int swap_penalty, int substition_penalty,
         int insertion_penalty, int deletion_penalty);
 
-#endif
+#endif /* __PERF_LEVENSHTEIN_H */
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 804e02382739..e509cd59c67d 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -3,6 +3,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include "debug.h"
+
+const char *map_type__name[MAP__NR_TYPES] = {
+        [MAP__FUNCTION] = "Functions",
+        [MAP__VARIABLE] = "Variables",
+};
 
 static inline int is_anon_memory(const char *filename)
 {
@@ -19,13 +25,28 @@ static int strcommon(const char *pathname, char *cwd, int cwdlen)
         return n;
 }
 
- struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen)
+void map__init(struct map *self, enum map_type type,
+               u64 start, u64 end, u64 pgoff, struct dso *dso)
+{
+        self->type     = type;
+        self->start    = start;
+        self->end      = end;
+        self->pgoff    = pgoff;
+        self->dso      = dso;
+        self->map_ip   = map__map_ip;
+        self->unmap_ip = map__unmap_ip;
+        RB_CLEAR_NODE(&self->rb_node);
+}
+
+struct map *map__new(struct mmap_event *event, 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;
 
                 if (cwd) {
@@ -45,18 +66,20 @@ static int strcommon(const char *pathname, char *cwd, int cwdlen)
                         filename = newfilename;
                 }
 
-                self->start = event->start;
-                self->end   = event->start + event->len;
-                self->pgoff = event->pgoff;
-
-                self->dso = dsos__findnew(filename);
-                if (self->dso == NULL)
+                dso = dsos__findnew(filename);
+                if (dso == NULL)
                         goto out_delete;
 
-                if (self->dso == vdso || anon)
-                        self->map_ip = vdso__map_ip;
-                else
-                        self->map_ip = map__map_ip;
+                map__init(self, type, event->start, event->start + event->len,
+                          event->pgoff, dso);
+
+                if (anon) {
+set_identity:
+                        self->map_ip = self->unmap_ip = identity__map_ip;
+                } else if (strcmp(filename, "[vdso]") == 0) {
+                        dso__set_loaded(dso, self->type);
+                        goto set_identity;
+                }
         }
         return self;
 out_delete:
@@ -64,6 +87,103 @@ out_delete:
         return NULL;
 }
 
+void map__delete(struct map *self)
+{
+        free(self);
+}
+
+void map__fixup_start(struct map *self)
+{
+        struct rb_root *symbols = &self->dso->symbols[self->type];
+        struct rb_node *nd = rb_first(symbols);
+        if (nd != NULL) {
+                struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+                self->start = sym->start;
+        }
+}
+
+void map__fixup_end(struct map *self)
+{
+        struct rb_root *symbols = &self->dso->symbols[self->type];
+        struct rb_node *nd = rb_last(symbols);
+        if (nd != NULL) {
+                struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+                self->end = sym->end;
+        }
+}
+
+#define DSO__DELETED "(deleted)"
+
+int map__load(struct map *self, symbol_filter_t filter)
+{
+        const char *name = self->dso->long_name;
+        int nr;
+
+        if (dso__loaded(self->dso, self->type))
+                return 0;
+
+        nr = dso__load(self->dso, self, filter);
+        if (nr < 0) {
+                if (self->dso->has_build_id) {
+                        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                        build_id__sprintf(self->dso->build_id,
+                                          sizeof(self->dso->build_id),
+                                          sbuild_id);
+                        pr_warning("%s with build id %s not found",
+                                   name, sbuild_id);
+                } else
+                        pr_warning("Failed to open %s", name);
+
+                pr_warning(", continuing without symbols\n");
+                return -1;
+        } else if (nr == 0) {
+                const size_t len = strlen(name);
+                const size_t real_len = len - sizeof(DSO__DELETED);
+
+                if (len > sizeof(DSO__DELETED) &&
+                    strcmp(name + real_len + 1, DSO__DELETED) == 0) {
+                        pr_warning("%.*s was updated, restart the long "
+                                   "running apps that use it!\n",
+                                   (int)real_len, name);
+                } else {
+                        pr_warning("no symbols found in %s, maybe install "
+                                   "a debug package?\n", name);
+                }
+
+                return -1;
+        }
+        /*
+         * Only applies to the kernel, as its symtabs aren't relative like the
+         * module ones.
+         */
+        if (self->dso->kernel)
+                map__reloc_vmlinux(self);
+
+        return 0;
+}
+
+struct symbol *map__find_symbol(struct map *self, u64 addr,
+                                symbol_filter_t filter)
+{
+        if (map__load(self, filter) < 0)
+                return NULL;
+
+        return dso__find_symbol(self->dso, self->type, addr);
+}
+
+struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+                                        symbol_filter_t filter)
+{
+        if (map__load(self, filter) < 0)
+                return NULL;
+
+        if (!dso__sorted_by_name(self->dso, self->type))
+                dso__sort_by_name(self->dso, self->type);
+
+        return dso__find_symbol_by_name(self->dso, self->type, name);
+}
+
 struct map *map__clone(struct map *self)
 {
         struct map *map = malloc(sizeof(*self));
@@ -95,3 +215,23 @@ size_t map__fprintf(struct map *self, FILE *fp)
         return fprintf(fp, " %Lx-%Lx %Lx %s\n",
                        self->start, self->end, self->pgoff, self->dso->name);
 }
+
+/*
+ * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
+ * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
+ */
+u64 map__rip_2objdump(struct map *map, u64 rip)
+{
+        u64 addr = map->dso->adjust_symbols ?
+                        map->unmap_ip(map, rip) :       /* RIP -> IP */
+                        rip;
+        return addr;
+}
+
+u64 map__objdump_2ip(struct map *map, u64 addr)
+{
+        u64 ip = map->dso->adjust_symbols ?
+                        addr :
+                        map->unmap_ip(map, addr);       /* RIP -> IP */
+        return ip;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
new file mode 100644
index 000000000000..b756368076c6
--- /dev/null
+++ b/tools/perf/util/map.h
@@ -0,0 +1,94 @@
+#ifndef __PERF_MAP_H
+#define __PERF_MAP_H
+
+#include <linux/compiler.h>
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include <linux/types.h>
+
+enum map_type {
+        MAP__FUNCTION = 0,
+        MAP__VARIABLE,
+};
+
+#define MAP__NR_TYPES (MAP__VARIABLE + 1)
+
+extern const char *map_type__name[MAP__NR_TYPES];
+
+struct dso;
+struct ref_reloc_sym;
+struct map_groups;
+
+struct map {
+        union {
+                struct rb_node  rb_node;
+                struct list_head node;
+        };
+        u64                     start;
+        u64                     end;
+        enum map_type           type;
+        u64                     pgoff;
+
+        /* ip -> dso rip */
+        u64                     (*map_ip)(struct map *, u64);
+        /* dso rip -> ip */
+        u64                     (*unmap_ip)(struct map *, u64);
+
+        struct dso              *dso;
+};
+
+struct kmap {
+        struct ref_reloc_sym    *ref_reloc_sym;
+        struct map_groups       *kmaps;
+};
+
+static inline struct kmap *map__kmap(struct map *self)
+{
+        return (struct kmap *)(self + 1);
+}
+
+static inline u64 map__map_ip(struct map *map, u64 ip)
+{
+        return ip - map->start + map->pgoff;
+}
+
+static inline u64 map__unmap_ip(struct map *map, u64 ip)
+{
+        return ip + map->start - map->pgoff;
+}
+
+static inline u64 identity__map_ip(struct map *map __used, u64 ip)
+{
+        return ip;
+}
+
+
+/* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
+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);
+void map__delete(struct map *self);
+struct map *map__clone(struct map *self);
+int map__overlap(struct map *l, struct map *r);
+size_t map__fprintf(struct map *self, FILE *fp);
+
+int map__load(struct map *self, symbol_filter_t filter);
+struct symbol *map__find_symbol(struct map *self,
+                                u64 addr, symbol_filter_t filter);
+struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+                                        symbol_filter_t filter);
+void map__fixup_start(struct map *self);
+void map__fixup_end(struct map *self);
+
+void map__reloc_vmlinux(struct map *self);
+
+#endif /* __PERF_MAP_H */
diff --git a/tools/perf/util/module.c b/tools/perf/util/module.c
deleted file mode 100644
index 0d8c85defcd2..000000000000
--- a/tools/perf/util/module.c
+++ /dev/null
@@ -1,545 +0,0 @@
-#include "util.h"
-#include "../perf.h"
-#include "string.h"
-#include "module.h"
-
-#include <libelf.h>
-#include <libgen.h>
-#include <gelf.h>
-#include <elf.h>
-#include <dirent.h>
-#include <sys/utsname.h>
-
-static unsigned int crc32(const char *p, unsigned int len)
-{
-        int i;
-        unsigned int crc = 0;
-
-        while (len--) {
-                crc ^= *p++;
-                for (i = 0; i < 8; i++)
-                        crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
-        }
-        return crc;
-}
-
-/* module section methods */
-
-struct sec_dso *sec_dso__new_dso(const char *name)
-{
-        struct sec_dso *self = malloc(sizeof(*self) + strlen(name) + 1);
-
-        if (self != NULL) {
-                strcpy(self->name, name);
-                self->secs = RB_ROOT;
-                self->find_section = sec_dso__find_section;
-        }
-
-        return self;
-}
-
-static void sec_dso__delete_section(struct section *self)
-{
-        free(((void *)self));
-}
-
-void sec_dso__delete_sections(struct sec_dso *self)
-{
-        struct section *pos;
-        struct rb_node *next = rb_first(&self->secs);
-
-        while (next) {
-                pos = rb_entry(next, struct section, rb_node);
-                next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, &self->secs);
-                sec_dso__delete_section(pos);
-        }
-}
-
-void sec_dso__delete_self(struct sec_dso *self)
-{
-        sec_dso__delete_sections(self);
-        free(self);
-}
-
-static void sec_dso__insert_section(struct sec_dso *self, struct section *sec)
-{
-        struct rb_node **p = &self->secs.rb_node;
-        struct rb_node *parent = NULL;
-        const u64 hash = sec->hash;
-        struct section *s;
-
-        while (*p != NULL) {
-                parent = *p;
-                s = rb_entry(parent, struct section, rb_node);
-                if (hash < s->hash)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&sec->rb_node, parent, p);
-        rb_insert_color(&sec->rb_node, &self->secs);
-}
-
-struct section *sec_dso__find_section(struct sec_dso *self, const char *name)
-{
-        struct rb_node *n;
-        u64 hash;
-        int len;
-
-        if (self == NULL)
-                return NULL;
-
-        len = strlen(name);
-        hash = crc32(name, len);
-
-        n = self->secs.rb_node;
-
-        while (n) {
-                struct section *s = rb_entry(n, struct section, rb_node);
-
-                if (hash < s->hash)
-                        n = n->rb_left;
-                else if (hash > s->hash)
-                        n = n->rb_right;
-                else {
-                        if (!strcmp(name, s->name))
-                                return s;
-                        else
-                                n = rb_next(&s->rb_node);
-                }
-        }
-
-        return NULL;
-}
-
-static size_t sec_dso__fprintf_section(struct section *self, FILE *fp)
-{
-        return fprintf(fp, "name:%s vma:%llx path:%s\n",
-                       self->name, self->vma, self->path);
-}
-
-size_t sec_dso__fprintf(struct sec_dso *self, FILE *fp)
-{
-        size_t ret = fprintf(fp, "dso: %s\n", self->name);
-
-        struct rb_node *nd;
-        for (nd = rb_first(&self->secs); nd; nd = rb_next(nd)) {
-                struct section *pos = rb_entry(nd, struct section, rb_node);
-                ret += sec_dso__fprintf_section(pos, fp);
-        }
-
-        return ret;
-}
-
-static struct section *section__new(const char *name, const char *path)
-{
-        struct section *self = calloc(1, sizeof(*self));
-
-        if (!self)
-                goto out_failure;
-
-        self->name = calloc(1, strlen(name) + 1);
-        if (!self->name)
-                goto out_failure;
-
-        self->path = calloc(1, strlen(path) + 1);
-        if (!self->path)
-                goto out_failure;
-
-        strcpy(self->name, name);
-        strcpy(self->path, path);
-        self->hash = crc32(self->name, strlen(name));
-
-        return self;
-
-out_failure:
-        if (self) {
-                if (self->name)
-                        free(self->name);
-                if (self->path)
-                        free(self->path);
-                free(self);
-        }
-
-        return NULL;
-}
-
-/* module methods */
-
-struct mod_dso *mod_dso__new_dso(const char *name)
-{
-        struct mod_dso *self = malloc(sizeof(*self) + strlen(name) + 1);
-
-        if (self != NULL) {
-                strcpy(self->name, name);
-                self->mods = RB_ROOT;
-                self->find_module = mod_dso__find_module;
-        }
-
-        return self;
-}
-
-static void mod_dso__delete_module(struct module *self)
-{
-        free(((void *)self));
-}
-
-void mod_dso__delete_modules(struct mod_dso *self)
-{
-        struct module *pos;
-        struct rb_node *next = rb_first(&self->mods);
-
-        while (next) {
-                pos = rb_entry(next, struct module, rb_node);
-                next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, &self->mods);
-                mod_dso__delete_module(pos);
-        }
-}
-
-void mod_dso__delete_self(struct mod_dso *self)
-{
-        mod_dso__delete_modules(self);
-        free(self);
-}
-
-static void mod_dso__insert_module(struct mod_dso *self, struct module *mod)
-{
-        struct rb_node **p = &self->mods.rb_node;
-        struct rb_node *parent = NULL;
-        const u64 hash = mod->hash;
-        struct module *m;
-
-        while (*p != NULL) {
-                parent = *p;
-                m = rb_entry(parent, struct module, rb_node);
-                if (hash < m->hash)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&mod->rb_node, parent, p);
-        rb_insert_color(&mod->rb_node, &self->mods);
-}
-
-struct module *mod_dso__find_module(struct mod_dso *self, const char *name)
-{
-        struct rb_node *n;
-        u64 hash;
-        int len;
-
-        if (self == NULL)
-                return NULL;
-
-        len = strlen(name);
-        hash = crc32(name, len);
-
-        n = self->mods.rb_node;
-
-        while (n) {
-                struct module *m = rb_entry(n, struct module, rb_node);
-
-                if (hash < m->hash)
-                        n = n->rb_left;
-                else if (hash > m->hash)
-                        n = n->rb_right;
-                else {
-                        if (!strcmp(name, m->name))
-                                return m;
-                        else
-                                n = rb_next(&m->rb_node);
-                }
-        }
-
-        return NULL;
-}
-
-static size_t mod_dso__fprintf_module(struct module *self, FILE *fp)
-{
-        return fprintf(fp, "name:%s path:%s\n", self->name, self->path);
-}
-
-size_t mod_dso__fprintf(struct mod_dso *self, FILE *fp)
-{
-        struct rb_node *nd;
-        size_t ret;
-
-        ret = fprintf(fp, "dso: %s\n", self->name);
-
-        for (nd = rb_first(&self->mods); nd; nd = rb_next(nd)) {
-                struct module *pos = rb_entry(nd, struct module, rb_node);
-
-                ret += mod_dso__fprintf_module(pos, fp);
-        }
-
-        return ret;
-}
-
-static struct module *module__new(const char *name, const char *path)
-{
-        struct module *self = calloc(1, sizeof(*self));
-
-        if (!self)
-                goto out_failure;
-
-        self->name = calloc(1, strlen(name) + 1);
-        if (!self->name)
-                goto out_failure;
-
-        self->path = calloc(1, strlen(path) + 1);
-        if (!self->path)
-                goto out_failure;
-
-        strcpy(self->name, name);
-        strcpy(self->path, path);
-        self->hash = crc32(self->name, strlen(name));
-
-        return self;
-
-out_failure:
-        if (self) {
-                if (self->name)
-                        free(self->name);
-                if (self->path)
-                        free(self->path);
-                free(self);
-        }
-
-        return NULL;
-}
-
-static int mod_dso__load_sections(struct module *mod)
-{
-        int count = 0, path_len;
-        struct dirent *entry;
-        char *line = NULL;
-        char *dir_path;
-        DIR *dir;
-        size_t n;
-
-        path_len = strlen("/sys/module/");
-        path_len += strlen(mod->name);
-        path_len += strlen("/sections/");
-
-        dir_path = calloc(1, path_len + 1);
-        if (dir_path == NULL)
-                goto out_failure;
-
-        strcat(dir_path, "/sys/module/");
-        strcat(dir_path, mod->name);
-        strcat(dir_path, "/sections/");
-
-        dir = opendir(dir_path);
-        if (dir == NULL)
-                goto out_free;
-
-        while ((entry = readdir(dir))) {
-                struct section *section;
-                char *path, *vma;
-                int line_len;
-                FILE *file;
-
-                if (!strcmp(".", entry->d_name) || !strcmp("..", entry->d_name))
-                        continue;
-
-                path = calloc(1, path_len + strlen(entry->d_name) + 1);
-                if (path == NULL)
-                        break;
-                strcat(path, dir_path);
-                strcat(path, entry->d_name);
-
-                file = fopen(path, "r");
-                if (file == NULL) {
-                        free(path);
-                        break;
-                }
-
-                line_len = getline(&line, &n, file);
-                if (line_len < 0) {
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-
-                if (!line) {
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-
-                line[--line_len] = '\0'; /* \n */
-
-                vma = strstr(line, "0x");
-                if (!vma) {
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-                vma += 2;
-
-                section = section__new(entry->d_name, path);
-                if (!section) {
-                        fprintf(stderr, "load_sections: allocation error\n");
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-
-                hex2u64(vma, &section->vma);
-                sec_dso__insert_section(mod->sections, section);
-
-                free(path);
-                fclose(file);
-                count++;
-        }
-
-        closedir(dir);
-        free(line);
-        free(dir_path);
-
-        return count;
-
-out_free:
-        free(dir_path);
-
-out_failure:
-        return count;
-}
-
-static int mod_dso__load_module_paths(struct mod_dso *self)
-{
-        struct utsname uts;
-        int count = 0, len, err = -1;
-        char *line = NULL;
-        FILE *file;
-        char *dpath, *dir;
-        size_t n;
-
-        if (uname(&uts) < 0)
-                return err;
-
-        len = strlen("/lib/modules/");
-        len += strlen(uts.release);
-        len += strlen("/modules.dep");
-
-        dpath = calloc(1, len + 1);
-        if (dpath == NULL)
-                return err;
-
-        strcat(dpath, "/lib/modules/");
-        strcat(dpath, uts.release);
-        strcat(dpath, "/modules.dep");
-
-        file = fopen(dpath, "r");
-        if (file == NULL)
-                goto out_failure;
-
-        dir = dirname(dpath);
-        if (!dir)
-                goto out_failure;
-        strcat(dir, "/");
-
-        while (!feof(file)) {
-                struct module *module;
-                char *name, *path, *tmp;
-                FILE *modfile;
-                int line_len;
-
-                line_len = getline(&line, &n, file);
-                if (line_len < 0)
-                        break;
-
-                if (!line)
-                        break;
-
-                line[--line_len] = '\0'; /* \n */
-
-                path = strchr(line, ':');
-                if (!path)
-                        break;
-                *path = '\0';
-
-                path = strdup(line);
-                if (!path)
-                        break;
-
-                if (!strstr(path, dir)) {
-                        if (strncmp(path, "kernel/", 7))
-                                break;
-
-                        free(path);
-                        path = calloc(1, strlen(dir) + strlen(line) + 1);
-                        if (!path)
-                                break;
-                        strcat(path, dir);
-                        strcat(path, line);
-                }
-
-                modfile = fopen(path, "r");
-                if (modfile == NULL)
-                        break;
-                fclose(modfile);
-
-                name = strdup(path);
-                if (!name)
-                        break;
-
-                name = strtok(name, "/");
-                tmp = name;
-
-                while (tmp) {
-                        tmp = strtok(NULL, "/");
-                        if (tmp)
-                                name = tmp;
-                }
-
-                name = strsep(&name, ".");
-                if (!name)
-                        break;
-
-                /* Quirk: replace '-' with '_' in all modules */
-                for (len = strlen(name); len; len--) {
-                        if (*(name+len) == '-')
-                                *(name+len) = '_';
-                }
-
-                module = module__new(name, path);
-                if (!module)
-                        break;
-                mod_dso__insert_module(self, module);
-
-                module->sections = sec_dso__new_dso("sections");
-                if (!module->sections)
-                        break;
-
-                module->active = mod_dso__load_sections(module);
-
-                if (module->active > 0)
-                        count++;
-        }
-
-        if (feof(file))
-                err = count;
-        else
-                fprintf(stderr, "load_module_paths: modules.dep parsing failure!\n");
-
-out_failure:
-        if (dpath)
-                free(dpath);
-        if (file)
-                fclose(file);
-        if (line)
-                free(line);
-
-        return err;
-}
-
-int mod_dso__load_modules(struct mod_dso *dso)
-{
-        int err;
-
-        err = mod_dso__load_module_paths(dso);
-
-        return err;
-}
diff --git a/tools/perf/util/module.h b/tools/perf/util/module.h
deleted file mode 100644
index 8a592ef641ca..000000000000
--- a/tools/perf/util/module.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef _PERF_MODULE_
-#define _PERF_MODULE_ 1
-
-#include <linux/types.h>
-#include "../types.h"
-#include <linux/list.h>
-#include <linux/rbtree.h>
-
-struct section {
-        struct rb_node  rb_node;
-        u64             hash;
-        u64             vma;
-        char            *name;
-        char            *path;
-};
-
-struct sec_dso {
-        struct list_head node;
-        struct rb_root   secs;
-        struct section    *(*find_section)(struct sec_dso *, const char *name);
-        char             name[0];
-};
-
-struct module {
-        struct rb_node  rb_node;
-        u64             hash;
-        char            *name;
-        char            *path;
-        struct sec_dso  *sections;
-        int             active;
-};
-
-struct mod_dso {
-        struct list_head node;
-        struct rb_root   mods;
-        struct module    *(*find_module)(struct mod_dso *, const char *name);
-        char             name[0];
-};
-
-struct sec_dso *sec_dso__new_dso(const char *name);
-void sec_dso__delete_sections(struct sec_dso *self);
-void sec_dso__delete_self(struct sec_dso *self);
-size_t sec_dso__fprintf(struct sec_dso *self, FILE *fp);
-struct section *sec_dso__find_section(struct sec_dso *self, const char *name);
-
-struct mod_dso *mod_dso__new_dso(const char *name);
-void mod_dso__delete_modules(struct mod_dso *self);
-void mod_dso__delete_self(struct mod_dso *self);
-size_t mod_dso__fprintf(struct mod_dso *self, FILE *fp);
-struct module *mod_dso__find_module(struct mod_dso *self, const char *name);
-int mod_dso__load_modules(struct mod_dso *dso);
-
-#endif /* _PERF_MODULE_ */
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 8cfb48cbbea0..05d0c5c2030c 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1,4 +1,4 @@
-
+#include "../../../include/linux/hw_breakpoint.h"
 #include "util.h"
 #include "../perf.h"
 #include "parse-options.h"
@@ -7,10 +7,12 @@
 #include "string.h"
 #include "cache.h"
 #include "header.h"
+#include "debugfs.h"
 
-int                                     nr_counters;
+int                             nr_counters;
 
 struct perf_event_attr          attrs[MAX_COUNTERS];
+char                            *filters[MAX_COUNTERS];
 
 struct event_symbol {
         u8              type;
@@ -46,6 +48,8 @@ static struct event_symbol event_symbols[] = {
   { CSW(PAGE_FAULTS_MAJ),       "major-faults",         ""              },
   { CSW(CONTEXT_SWITCHES),      "context-switches",     "cs"            },
   { CSW(CPU_MIGRATIONS),        "cpu-migrations",       "migrations"    },
+  { CSW(ALIGNMENT_FAULTS),      "alignment-faults",     ""              },
+  { CSW(EMULATION_FAULTS),      "emulation-faults",     ""              },
 };
 
 #define __PERF_EVENT_FIELD(config, name) \
@@ -74,6 +78,8 @@ static const char *sw_event_names[] = {
         "CPU-migrations",
         "minor-faults",
         "major-faults",
+        "alignment-faults",
+        "emulation-faults",
 };
 
 #define MAX_ALIASES 8
@@ -148,16 +154,6 @@ static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
 
 #define MAX_EVENT_LENGTH 512
 
-int valid_debugfs_mount(const char *debugfs)
-{
-        struct statfs st_fs;
-
-        if (statfs(debugfs, &st_fs) < 0)
-                return -ENOENT;
-        else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
-                return -ENOENT;
-        return 0;
-}
 
 struct tracepoint_path *tracepoint_id_to_path(u64 config)
 {
@@ -170,7 +166,7 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (valid_debugfs_mount(debugfs_path))
+        if (debugfs_valid_mountpoint(debugfs_path))
                 return NULL;
 
         sys_dir = opendir(debugfs_path);
@@ -201,7 +197,7 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
                         if (id == config) {
                                 closedir(evt_dir);
                                 closedir(sys_dir);
-                                path = calloc(1, sizeof(path));
+                                path = zalloc(sizeof(*path));
                                 path->system = malloc(MAX_EVENT_LENGTH);
                                 if (!path->system) {
                                         free(path);
@@ -454,7 +450,8 @@ parse_single_tracepoint_event(char *sys_name,
 /* sys + ':' + event + ':' + flags*/
 #define MAX_EVOPT_LEN   (MAX_EVENT_LENGTH * 2 + 2 + 128)
 static enum event_result
-parse_subsystem_tracepoint_event(char *sys_name, char *flags)
+parse_multiple_tracepoint_event(char *sys_name, const char *evt_exp,
+                                char *flags)
 {
         char evt_path[MAXPATHLEN];
         struct dirent *evt_ent;
@@ -471,7 +468,6 @@ parse_subsystem_tracepoint_event(char *sys_name, char *flags)
         while ((evt_ent = readdir(evt_dir))) {
                 char event_opt[MAX_EVOPT_LEN + 1];
                 int len;
-                unsigned int rem = MAX_EVOPT_LEN;
 
                 if (!strcmp(evt_ent->d_name, ".")
                     || !strcmp(evt_ent->d_name, "..")
@@ -479,20 +475,15 @@ parse_subsystem_tracepoint_event(char *sys_name, char *flags)
                     || !strcmp(evt_ent->d_name, "filter"))
                         continue;
 
-                len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s", sys_name,
-                               evt_ent->d_name);
+                if (!strglobmatch(evt_ent->d_name, evt_exp))
+                        continue;
+
+                len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name,
+                               evt_ent->d_name, flags ? ":" : "",
+                               flags ?: "");
                 if (len < 0)
                         return EVT_FAILED;
 
-                rem -= len;
-                if (flags) {
-                        if (rem < strlen(flags) + 1)
-                                return EVT_FAILED;
-
-                        strcat(event_opt, ":");
-                        strcat(event_opt, flags);
-                }
-
                 if (parse_events(NULL, event_opt, 0))
                         return EVT_FAILED;
         }
@@ -509,7 +500,7 @@ static enum event_result parse_tracepoint_event(const char **strp,
         char sys_name[MAX_EVENT_LENGTH];
         unsigned int sys_length, evt_length;
 
-        if (valid_debugfs_mount(debugfs_path))
+        if (debugfs_valid_mountpoint(debugfs_path))
                 return 0;
 
         evt_name = strchr(*strp, ':');
@@ -535,15 +526,91 @@ static enum event_result parse_tracepoint_event(const char **strp,
         if (evt_length >= MAX_EVENT_LENGTH)
                 return EVT_FAILED;
 
-        if (!strcmp(evt_name, "*")) {
+        if (strpbrk(evt_name, "*?")) {
                 *strp = evt_name + evt_length;
-                return parse_subsystem_tracepoint_event(sys_name, flags);
+                return parse_multiple_tracepoint_event(sys_name, evt_name,
+                                                       flags);
         } else
                 return parse_single_tracepoint_event(sys_name, evt_name,
                                                      evt_length, flags,
                                                      attr, strp);
 }
 
+static enum event_result
+parse_breakpoint_type(const char *type, const char **strp,
+                      struct perf_event_attr *attr)
+{
+        int i;
+
+        for (i = 0; i < 3; i++) {
+                if (!type[i])
+                        break;
+
+                switch (type[i]) {
+                case 'r':
+                        attr->bp_type |= HW_BREAKPOINT_R;
+                        break;
+                case 'w':
+                        attr->bp_type |= HW_BREAKPOINT_W;
+                        break;
+                case 'x':
+                        attr->bp_type |= HW_BREAKPOINT_X;
+                        break;
+                default:
+                        return EVT_FAILED;
+                }
+        }
+        if (!attr->bp_type) /* Default */
+                attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
+
+        *strp = type + i;
+
+        return EVT_HANDLED;
+}
+
+static enum event_result
+parse_breakpoint_event(const char **strp, struct perf_event_attr *attr)
+{
+        const char *target;
+        const char *type;
+        char *endaddr;
+        u64 addr;
+        enum event_result err;
+
+        target = strchr(*strp, ':');
+        if (!target)
+                return EVT_FAILED;
+
+        if (strncmp(*strp, "mem", target - *strp) != 0)
+                return EVT_FAILED;
+
+        target++;
+
+        addr = strtoull(target, &endaddr, 0);
+        if (target == endaddr)
+                return EVT_FAILED;
+
+        attr->bp_addr = addr;
+        *strp = endaddr;
+
+        type = strchr(target, ':');
+
+        /* If no type is defined, just rw as default */
+        if (!type) {
+                attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
+        } else {
+                err = parse_breakpoint_type(++type, strp, attr);
+                if (err == EVT_FAILED)
+                        return EVT_FAILED;
+        }
+
+        /* We should find a nice way to override the access type */
+        attr->bp_len = HW_BREAKPOINT_LEN_4;
+        attr->type = PERF_TYPE_BREAKPOINT;
+
+        return EVT_HANDLED;
+}
+
 static int check_events(const char *str, unsigned int i)
 {
         int n;
@@ -677,6 +744,12 @@ parse_event_symbols(const char **str, struct perf_event_attr *attr)
         if (ret != EVT_FAILED)
                 goto modifier;
 
+        ret = parse_breakpoint_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
+
+        fprintf(stderr, "invalid or unsupported event: '%s'\n", *str);
+        fprintf(stderr, "Run 'perf list' for a list of valid events\n");
         return EVT_FAILED;
 
 modifier:
@@ -685,11 +758,11 @@ modifier:
         return ret;
 }
 
-static void store_event_type(const char *orgname)
+static int store_event_type(const char *orgname)
 {
         char filename[PATH_MAX], *c;
         FILE *file;
-        int id;
+        int id, n;
 
         sprintf(filename, "%s/", debugfs_path);
         strncat(filename, orgname, strlen(orgname));
@@ -701,21 +774,24 @@ static void store_event_type(const char *orgname)
 
         file = fopen(filename, "r");
         if (!file)
-                return;
-        if (fscanf(file, "%i", &id) < 1)
-                die("cannot store event ID");
+                return 0;
+        n = fscanf(file, "%i", &id);
         fclose(file);
-        perf_header__push_event(id, orgname);
+        if (n < 1) {
+                pr_err("cannot store event ID\n");
+                return -EINVAL;
+        }
+        return perf_header__push_event(id, orgname);
 }
 
-
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 {
         struct perf_event_attr attr;
         enum event_result ret;
 
         if (strchr(str, ':'))
-                store_event_type(str);
+                if (store_event_type(str) < 0)
+                        return -1;
 
         for (;;) {
                 if (nr_counters == MAX_COUNTERS)
@@ -745,12 +821,35 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
         return 0;
 }
 
+int parse_filter(const struct option *opt __used, const char *str,
+                 int unset __used)
+{
+        int i = nr_counters - 1;
+        int len = strlen(str);
+
+        if (i < 0 || attrs[i].type != PERF_TYPE_TRACEPOINT) {
+                fprintf(stderr,
+                        "-F option should follow a -e tracepoint option\n");
+                return -1;
+        }
+
+        filters[i] = malloc(len + 1);
+        if (!filters[i]) {
+                fprintf(stderr, "not enough memory to hold filter string\n");
+                return -1;
+        }
+        strcpy(filters[i], str);
+
+        return 0;
+}
+
 static const char * const event_type_descriptors[] = {
-        "",
         "Hardware event",
         "Software event",
         "Tracepoint event",
         "Hardware cache event",
+        "Raw hardware event descriptor",
+        "Hardware breakpoint",
 };
 
 /*
@@ -764,7 +863,7 @@ static void print_tracepoint_events(void)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (valid_debugfs_mount(debugfs_path))
+        if (debugfs_valid_mountpoint(debugfs_path))
                 return;
 
         sys_dir = opendir(debugfs_path);
@@ -782,8 +881,8 @@ static void print_tracepoint_events(void)
                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                  sys_dirent.d_name, evt_dirent.d_name);
-                        fprintf(stderr, "  %-42s [%s]\n", evt_path,
-                                event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
+                        printf("  %-42s [%s]\n", evt_path,
+                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
                 }
                 closedir(evt_dir);
         }
@@ -799,28 +898,26 @@ void print_events(void)
         unsigned int i, type, op, prev_type = -1;
         char name[40];
 
-        fprintf(stderr, "\n");
-        fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
+        printf("\n");
+        printf("List of pre-defined events (to be used in -e):\n");
 
         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
-                type = syms->type + 1;
-                if (type >= ARRAY_SIZE(event_type_descriptors))
-                        type = 0;
+                type = syms->type;
 
                 if (type != prev_type)
-                        fprintf(stderr, "\n");
+                        printf("\n");
 
                 if (strlen(syms->alias))
                         sprintf(name, "%s OR %s", syms->symbol, syms->alias);
                 else
                         strcpy(name, syms->symbol);
-                fprintf(stderr, "  %-42s [%s]\n", name,
+                printf("  %-42s [%s]\n", name,
                         event_type_descriptors[type]);
 
                 prev_type = type;
         }
 
-        fprintf(stderr, "\n");
+        printf("\n");
         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
                         /* skip invalid cache type */
@@ -828,17 +925,22 @@ void print_events(void)
                                 continue;
 
                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
-                                fprintf(stderr, "  %-42s [%s]\n",
+                                printf("  %-42s [%s]\n",
                                         event_cache_name(type, op, i),
-                                        event_type_descriptors[4]);
+                                        event_type_descriptors[PERF_TYPE_HW_CACHE]);
                         }
                 }
         }
 
-        fprintf(stderr, "\n");
-        fprintf(stderr, "  %-42s [raw hardware event descriptor]\n",
-                "rNNN");
-        fprintf(stderr, "\n");
+        printf("\n");
+        printf("  %-42s [%s]\n",
+                "rNNN", event_type_descriptors[PERF_TYPE_RAW]);
+        printf("\n");
+
+        printf("  %-42s [%s]\n",
+                        "mem:<addr>[:access]",
+                        event_type_descriptors[PERF_TYPE_BREAKPOINT]);
+        printf("\n");
 
         print_tracepoint_events();
 
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 30c608112845..b8c1f64bc935 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -1,5 +1,5 @@
-#ifndef _PARSE_EVENTS_H
-#define _PARSE_EVENTS_H
+#ifndef __PERF_PARSE_EVENTS_H
+#define __PERF_PARSE_EVENTS_H
 /*
  * Parse symbolic events/counts passed in as options:
  */
@@ -17,11 +17,13 @@ extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
 extern int                      nr_counters;
 
 extern struct perf_event_attr attrs[MAX_COUNTERS];
+extern char *filters[MAX_COUNTERS];
 
 extern const char *event_name(int ctr);
 extern const char *__event_name(int type, u64 config);
 
 extern int parse_events(const struct option *opt, const char *str, int unset);
+extern int parse_filter(const struct option *opt, const char *str, int unset);
 
 #define EVENTS_HELP_MAX (128*1024)
 
@@ -31,4 +33,4 @@ extern char debugfs_path[];
 extern int valid_debugfs_mount(const char *debugfs);
 
 
-#endif /* _PARSE_EVENTS_H */
+#endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index 6d8af48c925e..efebd5b476b3 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -430,6 +430,9 @@ int usage_with_options_internal(const char * const *usagestr,
                 pos = fprintf(stderr, "    ");
                 if (opts->short_name)
                         pos += fprintf(stderr, "-%c", opts->short_name);
+                else
+                        pos += fprintf(stderr, "    ");
+
                 if (opts->long_name && opts->short_name)
                         pos += fprintf(stderr, ", ");
                 if (opts->long_name)
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 2ee248ff27e5..948805af43c2 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -1,5 +1,5 @@
-#ifndef PARSE_OPTIONS_H
-#define PARSE_OPTIONS_H
+#ifndef __PERF_PARSE_OPTIONS_H
+#define __PERF_PARSE_OPTIONS_H
 
 enum parse_opt_type {
         /* special types */
@@ -174,4 +174,4 @@ extern int parse_opt_verbosity_cb(const struct option *, const char *, int);
 
 extern const char *parse_options_fix_filename(const char *prefix, const char *file);
 
-#endif
+#endif /* __PERF_PARSE_OPTIONS_H */
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
new file mode 100644
index 000000000000..7c004b6ef24f
--- /dev/null
+++ b/tools/perf/util/probe-event.c
@@ -0,0 +1,802 @@
+/*
+ * probe-event.c : perf-probe definition to kprobe_events format converter
+ *
+ * Written by Masami Hiramatsu <mhiramat@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#define _GNU_SOURCE
+#include <sys/utsname.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#undef _GNU_SOURCE
+#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 "probe-event.h"
+
+#define MAX_CMDLEN 256
+#define MAX_PROBE_ARGS 128
+#define PERFPROBE_GROUP "probe"
+
+#define semantic_error(msg ...) die("Semantic error :" msg)
+
+/* If there is no space to write, returns -E2BIG. */
+static int e_snprintf(char *str, size_t size, const char *format, ...)
+        __attribute__((format(printf, 3, 4)));
+
+static int e_snprintf(char *str, size_t size, const char *format, ...)
+{
+        int ret;
+        va_list ap;
+        va_start(ap, format);
+        ret = vsnprintf(str, size, format, ap);
+        va_end(ap);
+        if (ret >= (int)size)
+                ret = -E2BIG;
+        return ret;
+}
+
+void parse_line_range_desc(const char *arg, struct line_range *lr)
+{
+        const char *ptr;
+        char *tmp;
+        /*
+         * <Syntax>
+         * SRC:SLN[+NUM|-ELN]
+         * FUNC[:SLN[+NUM|-ELN]]
+         */
+        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);
+                else
+                        lr->end = 0;
+                pr_debug("Line range is %u to %u\n", lr->start, lr->end);
+                if (lr->end && lr->start > lr->end)
+                        semantic_error("Start line must be smaller"
+                                       " than end line.");
+                if (*tmp != '\0')
+                        semantic_error("Tailing with invalid character '%d'.",
+                                       *tmp);
+                tmp = strndup(arg, (ptr - arg));
+        } else
+                tmp = strdup(arg);
+
+        if (strchr(tmp, '.'))
+                lr->file = tmp;
+        else
+                lr->function = tmp;
+}
+
+/* Check the name is good for event/group */
+static bool check_event_name(const char *name)
+{
+        if (!isalpha(*name) && *name != '_')
+                return false;
+        while (*++name != '\0') {
+                if (!isalpha(*name) && !isdigit(*name) && *name != '_')
+                        return false;
+        }
+        return true;
+}
+
+/* Parse probepoint definition. */
+static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
+{
+        char *ptr, *tmp;
+        char c, nc = 0;
+        /*
+         * <Syntax>
+         * perf probe [EVENT=]SRC[:LN|;PTN]
+         * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
+         *
+         * TODO:Group name support
+         */
+
+        ptr = strpbrk(arg, ";=@+%");
+        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))
+                        semantic_error("%s is bad for event name -it must "
+                                       "follow C symbol-naming rule.", arg);
+                pp->event = strdup(arg);
+                arg = tmp;
+        }
+
+        ptr = strpbrk(arg, ";:+@%");
+        if (ptr) {
+                nc = *ptr;
+                *ptr++ = '\0';
+        }
+
+        /* Check arg is function or file and copy it */
+        if (strchr(arg, '.'))   /* File */
+                pp->file = strdup(arg);
+        else                    /* Function */
+                pp->function = strdup(arg);
+        DIE_IF(pp->file == NULL && pp->function == NULL);
+
+        /* Parse other options */
+        while (ptr) {
+                arg = ptr;
+                c = nc;
+                if (c == ';') { /* Lazy pattern must be the last part */
+                        pp->lazy_line = strdup(arg);
+                        break;
+                }
+                ptr = strpbrk(arg, ";:+@%");
+                if (ptr) {
+                        nc = *ptr;
+                        *ptr++ = '\0';
+                }
+                switch (c) {
+                case ':':       /* Line number */
+                        pp->line = strtoul(arg, &tmp, 0);
+                        if (*tmp != '\0')
+                                semantic_error("There is non-digit char"
+                                               " in line number.");
+                        break;
+                case '+':       /* Byte offset from a symbol */
+                        pp->offset = strtoul(arg, &tmp, 0);
+                        if (*tmp != '\0')
+                                semantic_error("There is non-digit character"
+                                                " in offset.");
+                        break;
+                case '@':       /* File name */
+                        if (pp->file)
+                                semantic_error("SRC@SRC is not allowed.");
+                        pp->file = strdup(arg);
+                        DIE_IF(pp->file == NULL);
+                        break;
+                case '%':       /* Probe places */
+                        if (strcmp(arg, "return") == 0) {
+                                pp->retprobe = 1;
+                        } else  /* Others not supported yet */
+                                semantic_error("%%%s is not supported.", arg);
+                        break;
+                default:
+                        DIE_IF("Program has a bug.");
+                        break;
+                }
+        }
+
+        /* Exclusion check */
+        if (pp->lazy_line && pp->line)
+                semantic_error("Lazy pattern can't be used with line number.");
+
+        if (pp->lazy_line && pp->offset)
+                semantic_error("Lazy pattern can't be used with offset.");
+
+        if (pp->line && pp->offset)
+                semantic_error("Offset can't be used with line number.");
+
+        if (!pp->line && !pp->lazy_line && pp->file && !pp->function)
+                semantic_error("File always requires line number or "
+                               "lazy pattern.");
+
+        if (pp->offset && !pp->function)
+                semantic_error("Offset requires an entry function.");
+
+        if (pp->retprobe && !pp->function)
+                semantic_error("Return probe requires an entry function.");
+
+        if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe)
+                semantic_error("Offset/Line/Lazy pattern can't be used with "
+                               "return probe.");
+
+        pr_debug("symbol:%s file:%s line:%d offset:%d return:%d lazy:%s\n",
+                 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
+                 pp->lazy_line);
+}
+
+/* Parse perf-probe event definition */
+void parse_perf_probe_event(const char *str, struct probe_point *pp,
+                            bool *need_dwarf)
+{
+        char **argv;
+        int argc, i;
+
+        *need_dwarf = false;
+
+        argv = argv_split(str, &argc);
+        if (!argv)
+                die("argv_split failed.");
+        if (argc > MAX_PROBE_ARGS + 1)
+                semantic_error("Too many arguments");
+
+        /* Parse probe point */
+        parse_perf_probe_probepoint(argv[0], pp);
+        if (pp->file || pp->line || pp->lazy_line)
+                *need_dwarf = true;
+
+        /* 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;
+                }
+        }
+
+        argv_free(argv);
+}
+
+/* Parse kprobe_events event into struct probe_point */
+void parse_trace_kprobe_event(const char *str, struct probe_point *pp)
+{
+        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.");
+
+        /* 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);
+
+        pp->retprobe = (pr == 'r');
+
+        /* Scan function name and offset */
+        ret = sscanf(argv[1], "%a[^+]+%d", (float *)(void *)&pp->function,
+                     &pp->offset);
+        if (ret == 1)
+                pp->offset = 0;
+
+        /* kprobe_events doesn't have this information */
+        pp->line = 0;
+        pp->file = NULL;
+
+        pp->nr_args = argc - 2;
+        pp->args = zalloc(sizeof(char *) * pp->nr_args);
+        for (i = 0; i < pp->nr_args; 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.");
+        }
+
+        argv_free(argv);
+}
+
+/* Synthesize only probe point (not argument) */
+int synthesize_perf_probe_point(struct probe_point *pp)
+{
+        char *buf;
+        char offs[64] = "", line[64] = "";
+        int ret;
+
+        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
+        pp->found = 1;
+        if (!buf)
+                die("Failed to allocate memory by zalloc.");
+        if (pp->offset) {
+                ret = e_snprintf(offs, 64, "+%d", pp->offset);
+                if (ret <= 0)
+                        goto error;
+        }
+        if (pp->line) {
+                ret = e_snprintf(line, 64, ":%d", pp->line);
+                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);
+        else
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", pp->file, line);
+        if (ret <= 0) {
+error:
+                free(pp->probes[0]);
+                pp->probes[0] = NULL;
+                pp->found = 0;
+        }
+        return ret;
+}
+
+int synthesize_perf_probe_event(struct probe_point *pp)
+{
+        char *buf;
+        int i, len, ret;
+
+        len = synthesize_perf_probe_point(pp);
+        if (len < 0)
+                return 0;
+
+        buf = pp->probes[0];
+        for (i = 0; i < pp->nr_args; i++) {
+                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
+                                 pp->args[i]);
+                if (ret <= 0)
+                        goto error;
+                len += ret;
+        }
+        pp->found = 1;
+
+        return pp->found;
+error:
+        free(pp->probes[0]);
+        pp->probes[0] = NULL;
+
+        return ret;
+}
+
+int synthesize_trace_kprobe_event(struct probe_point *pp)
+{
+        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)
+                goto error;
+        len = ret;
+
+        for (i = 0; i < pp->nr_args; i++) {
+                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
+                                 pp->args[i]);
+                if (ret <= 0)
+                        goto error;
+                len += ret;
+        }
+        pp->found = 1;
+
+        return pp->found;
+error:
+        free(pp->probes[0]);
+        pp->probes[0] = NULL;
+
+        return ret;
+}
+
+static int open_kprobe_events(int flags, int mode)
+{
+        char buf[PATH_MAX];
+        int ret;
+
+        ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path);
+        if (ret < 0)
+                die("Failed to make kprobe_events path.");
+
+        ret = open(buf, flags, mode);
+        if (ret < 0) {
+                if (errno == ENOENT)
+                        die("kprobe_events file does not exist -"
+                            " please rebuild with CONFIG_KPROBE_EVENT.");
+                else
+                        die("Could not open kprobe_events file: %s",
+                            strerror(errno));
+        }
+        return ret;
+}
+
+/* Get raw string list of current kprobe_events */
+static struct strlist *get_trace_kprobe_event_rawlist(int fd)
+{
+        int ret, idx;
+        FILE *fp;
+        char buf[MAX_CMDLEN];
+        char *p;
+        struct strlist *sl;
+
+        sl = strlist__new(true, NULL);
+
+        fp = fdopen(dup(fd), "r");
+        while (!feof(fp)) {
+                p = fgets(buf, MAX_CMDLEN, fp);
+                if (!p)
+                        break;
+
+                idx = strlen(p) - 1;
+                if (p[idx] == '\n')
+                        p[idx] = '\0';
+                ret = strlist__add(sl, buf);
+                if (ret < 0)
+                        die("strlist__add failed: %s", strerror(-ret));
+        }
+        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)
+{
+        int i, ret;
+        char buf[128];
+
+        ret = e_snprintf(buf, 128, "%s:%s", pp->group, event);
+        if (ret < 0)
+                die("Failed to copy event: %s", strerror(-ret));
+        printf("  %-40s (on %s", buf, place);
+
+        if (pp->nr_args > 0) {
+                printf(" with");
+                for (i = 0; i < pp->nr_args; i++)
+                        printf(" %s", pp->args[i]);
+        }
+        printf(")\n");
+}
+
+/* List up current perf-probe events */
+void show_perf_probe_events(void)
+{
+        int fd;
+        struct probe_point pp;
+        struct strlist *rawlist;
+        struct str_node *ent;
+
+        setup_pager();
+        memset(&pp, 0, sizeof(pp));
+
+        fd = open_kprobe_events(O_RDONLY, 0);
+        rawlist = get_trace_kprobe_event_rawlist(fd);
+        close(fd);
+
+        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);
+        }
+
+        strlist__delete(rawlist);
+}
+
+/* Get current perf-probe event names */
+static struct strlist *get_perf_event_names(int fd, bool include_group)
+{
+        char buf[128];
+        struct strlist *sl, *rawlist;
+        struct str_node *ent;
+        struct probe_point pp;
+
+        memset(&pp, 0, sizeof(pp));
+        rawlist = get_trace_kprobe_event_rawlist(fd);
+
+        sl = strlist__new(true, NULL);
+        strlist__for_each(ent, rawlist) {
+                parse_trace_kprobe_event(ent->s, &pp);
+                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);
+                } else
+                        strlist__add(sl, pp.event);
+                clear_probe_point(&pp);
+        }
+
+        strlist__delete(rawlist);
+
+        return sl;
+}
+
+static void write_trace_kprobe_event(int fd, const char *buf)
+{
+        int ret;
+
+        pr_debug("Writing event: %s\n", buf);
+        ret = write(fd, buf, strlen(buf));
+        if (ret <= 0)
+                die("Failed to write event: %s", strerror(errno));
+}
+
+static void 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 (!strlist__has_entry(namelist, buf))
+                return;
+
+        if (!allow_suffix) {
+                pr_warning("Error: event \"%s\" already exists. "
+                           "(Use -f to force duplicates.)\n", base);
+                die("Can't add new event.");
+        }
+
+        /* 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 (!strlist__has_entry(namelist, buf))
+                        break;
+        }
+        if (i == MAX_EVENT_INDEX)
+                die("Too many events are on the same function.");
+}
+
+void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
+                             bool force_add)
+{
+        int i, j, fd;
+        struct probe_point *pp;
+        char buf[MAX_CMDLEN];
+        char event[64];
+        struct strlist *namelist;
+        bool allow_suffix;
+
+        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        /* 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;
+                }
+        }
+        /* 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);
+}
+
+static void __del_trace_kprobe_event(int fd, struct str_node *ent)
+{
+        char *p;
+        char buf[128];
+
+        /* Convert from perf-probe event to trace-kprobe event */
+        if (e_snprintf(buf, 128, "-:%s", ent->s) < 0)
+                die("Failed to copy event.");
+        p = strchr(buf + 2, ':');
+        if (!p)
+                die("Internal error: %s should have ':' but not.", ent->s);
+        *p = '/';
+
+        write_trace_kprobe_event(fd, buf);
+        printf("Remove event: %s\n", ent->s);
+}
+
+static void 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;
+
+        if (e_snprintf(buf, 128, "%s:%s", group, event) < 0)
+                die("Failed to copy event.");
+
+        if (strpbrk(buf, "*?")) { /* Glob-exp */
+                strlist__for_each_safe(ent, n, namelist)
+                        if (strglobmatch(ent->s, buf)) {
+                                found++;
+                                __del_trace_kprobe_event(fd, ent);
+                                strlist__remove(namelist, ent);
+                        }
+        } else {
+                ent = strlist__find(namelist, buf);
+                if (ent) {
+                        found++;
+                        __del_trace_kprobe_event(fd, ent);
+                        strlist__remove(namelist, ent);
+                }
+        }
+        if (found == 0)
+                pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf);
+}
+
+void del_trace_kprobe_events(struct strlist *dellist)
+{
+        int fd;
+        const char *group, *event;
+        char *p, *str;
+        struct str_node *ent;
+        struct strlist *namelist;
+
+        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        /* Get current event names */
+        namelist = get_perf_event_names(fd, true);
+
+        strlist__for_each(ent, dellist) {
+                str = strdup(ent->s);
+                if (!str)
+                        die("Failed to copy event.");
+                pr_debug("Parsing: %s\n", str);
+                p = strchr(str, ':');
+                if (p) {
+                        group = str;
+                        *p = '\0';
+                        event = p + 1;
+                } else {
+                        group = "*";
+                        event = str;
+                }
+                pr_debug("Group: %s, Event: %s\n", group, event);
+                del_trace_kprobe_event(fd, group, event, namelist);
+                free(str);
+        }
+        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));
+}
+
+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
new file mode 100644
index 000000000000..711287d4baea
--- /dev/null
+++ b/tools/perf/util/probe-event.h
@@ -0,0 +1,24 @@
+#ifndef _PROBE_EVENT_H
+#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);
+
+/* Maximum index number of event-name postfix */
+#define MAX_EVENT_INDEX 1024
+
+#endif /*_PROBE_EVENT_H */
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
new file mode 100644
index 000000000000..c171a243d05b
--- /dev/null
+++ b/tools/perf/util/probe-finder.c
@@ -0,0 +1,829 @@
+/*
+ * probe-finder.c : C expression to kprobe event converter
+ *
+ * Written by Masami Hiramatsu <mhiramat@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include <sys/utsname.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+#include "string.h"
+#include "event.h"
+#include "debug.h"
+#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;
+}
+
+/*
+ * Compare the tail of two strings.
+ * Return 0 if whole of either string is same as another's tail part.
+ */
+static int strtailcmp(const char *s1, const char *s2)
+{
+        int i1 = strlen(s1);
+        int i2 = strlen(s2);
+        while (--i1 >= 0 && --i2 >= 0) {
+                if (s1[i1] != s2[i2])
+                        return s1[i1] - s2[i2];
+        }
+        return 0;
+}
+
+/* Line number list operations */
+
+/* Add a line to line number list */
+static void line_list__add_line(struct list_head *head, unsigned int line)
+{
+        struct line_node *ln;
+        struct list_head *p;
+
+        /* Reverse search, because new line will be the last one */
+        list_for_each_entry_reverse(ln, head, list) {
+                if (ln->line < line) {
+                        p = &ln->list;
+                        goto found;
+                } else if (ln->line == line)    /* Already exist */
+                        return ;
+        }
+        /* 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);
+        ln->line = line;
+        INIT_LIST_HEAD(&ln->list);
+        list_add(&ln->list, p);
+}
+
+/* Check if the line in line number list */
+static int line_list__has_line(struct list_head *head, unsigned int line)
+{
+        struct line_node *ln;
+
+        /* Reverse search, because new line will be the last one */
+        list_for_each_entry(ln, head, list)
+                if (ln->line == line)
+                        return 1;
+
+        return 0;
+}
+
+/* Init line number list */
+static void line_list__init(struct list_head *head)
+{
+        INIT_LIST_HEAD(head);
+}
+
+/* Free line number list */
+static void line_list__free(struct list_head *head)
+{
+        struct line_node *ln;
+        while (!list_empty(head)) {
+                ln = list_first_entry(head, struct line_node, list);
+                list_del(&ln->list);
+                free(ln);
+        }
+}
+
+/* Dwarf wrappers */
+
+/* Find the realpath of the target file. */
+static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
+{
+        Dwarf_Files *files;
+        size_t nfiles, i;
+        const char *src = NULL;
+        int ret;
+
+        if (!fname)
+                return NULL;
+
+        ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
+        if (ret != 0)
+                return NULL;
+
+        for (i = 0; i < nfiles; i++) {
+                src = dwarf_filesrc(files, i, NULL, NULL);
+                if (strtailcmp(src, fname) == 0)
+                        break;
+        }
+        return src;
+}
+
+struct __addr_die_search_param {
+        Dwarf_Addr      addr;
+        Dwarf_Die       *die_mem;
+};
+
+static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
+{
+        struct __addr_die_search_param *ad = data;
+
+        if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
+            dwarf_haspc(fn_die, ad->addr)) {
+                memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
+                return DWARF_CB_ABORT;
+        }
+        return DWARF_CB_OK;
+}
+
+/* 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)
+{
+        struct __addr_die_search_param ad;
+        ad.addr = addr;
+        ad.die_mem = die_mem;
+        /* dwarf_getscopes can't find subprogram. */
+        if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
+                return NULL;
+        else
+                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)
+{
+        Dwarf_Die child_die;
+        int ret;
+
+        ret = dwarf_child(sp_die, die_mem);
+        if (ret != 0)
+                return NULL;
+
+        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;
+}
+
+/* Compare diename and tname */
+static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
+{
+        const char *name;
+        name = dwarf_diename(dw_die);
+        DIE_IF(name == NULL);
+        return strcmp(tname, name);
+}
+
+/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
+static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
+{
+        Dwarf_Addr epc;
+        int ret;
+
+        ret = dwarf_entrypc(dw_die, &epc);
+        DIE_IF(ret == -1);
+        return epc;
+}
+
+/* Get a variable die */
+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;
+
+        ret = dwarf_child(sp_die, die_mem);
+        if (ret != 0)
+                return NULL;
+
+        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 (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 NULL;
+}
+
+/*
+ * Probe finder related functions
+ */
+
+/* Show a location */
+static void show_location(Dwarf_Op *op, struct probe_finder *pf)
+{
+        unsigned int regn;
+        Dwarf_Word offs = 0;
+        int deref = 0, ret;
+        const char *regs;
+
+        /* 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;
+                offs = op->number;
+                op = &pf->fb_ops[0];
+        }
+
+        if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
+                regn = op->atom - DW_OP_breg0;
+                offs += op->number;
+                deref = 1;
+        } 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;
+        } else if (op->atom == DW_OP_regx) {
+                regn = op->number;
+        } else
+                die("DW_OP %d is not supported.", op->atom);
+
+        regs = get_arch_regstr(regn);
+        if (!regs)
+                die("%u exceeds max register number.", regn);
+
+        if (deref)
+                ret = snprintf(pf->buf, pf->len, " %s=%+jd(%s)",
+                               pf->var, (intmax_t)offs, regs);
+        else
+                ret = snprintf(pf->buf, pf->len, " %s=%s", pf->var, regs);
+        DIE_IF(ret < 0);
+        DIE_IF(ret >= pf->len);
+}
+
+/* Show a variables in kprobe event format */
+static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Op *expr;
+        size_t nexpr;
+        int ret;
+
+        if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
+                goto error;
+        /* TODO: handle more than 1 exprs */
+        ret = dwarf_getlocation_addr(&attr, pf->addr, &expr, &nexpr, 1);
+        if (ret <= 0 || nexpr == 0)
+                goto error;
+
+        show_location(expr, pf);
+        /* *expr will be cached in libdw. Don't free it. */
+        return ;
+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);
+}
+
+/* Find a variable in a subprogram die */
+static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        int ret;
+        Dwarf_Die vr_die;
+
+        /* 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 ;
+        }
+
+        pr_debug("Searching '%s' variable in context.\n", pf->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);
+}
+
+/* Show a probe point to output buffer */
+static void show_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        struct probe_point *pp = pf->pp;
+        Dwarf_Addr eaddr;
+        Dwarf_Die die_mem;
+        const char *name;
+        char tmp[MAX_PROBE_BUFFER];
+        int ret, i, len;
+        Dwarf_Attribute fb_attr;
+        size_t nops;
+
+        /* 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,
+                                                 pf->addr, &die_mem);
+                if (!sp_die)
+                        die("Probe point is not found in subprograms.");
+        }
+
+        /* Output 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);
+                }
+        } 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);
+
+        /* 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)
+                pf->fb_ops = NULL;
+
+        /* 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);
+        }
+
+        /* *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++;
+}
+
+/* Find probe point from its line number */
+static void 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;
+
+        ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
+        DIE_IF(ret != 0);
+
+        for (i = 0; i < nlines; i++) {
+                line = dwarf_onesrcline(lines, i);
+                dwarf_lineno(line, &lineno);
+                if (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);
+                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);
+                /* Continuing, because target line might be inlined. */
+        }
+}
+
+/* Find lines which match lazy pattern */
+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;
+        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);
+        close(fd);
+        fbuf[st.st_size] = '\n';        /* Dummy line */
+        fbuf[st.st_size + 1] = '\0';
+        p1 = fbuf;
+        line = 1;
+        while ((p2 = strchr(p1, '\n')) != NULL) {
+                *p2 = '\0';
+                if (strlazymatch(p1, pat)) {
+                        line_list__add_line(head, line);
+                        nlines++;
+                }
+                line++;
+                p1 = p2 + 1;
+        }
+        free(fbuf);
+        return nlines;
+}
+
+/* Find probe points from lazy pattern  */
+static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
+        Dwarf_Addr addr;
+        Dwarf_Die die_mem;
+        int lineno;
+        int ret;
+
+        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);
+        }
+
+        ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
+        DIE_IF(ret != 0);
+        for (i = 0; i < nlines; i++) {
+                line = dwarf_onesrcline(lines, i);
+
+                dwarf_lineno(line, &lineno);
+                if (!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 (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))
+                                continue;
+                }
+
+                pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
+                         (int)i, lineno, (unsigned long long)addr);
+                pf->addr = addr;
+
+                show_probe_point(sp_die, pf);
+                /* Continuing, because target line might be inlined. */
+        }
+        /* TODO: deallocate lines, but how? */
+}
+
+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;
+
+        if (pp->lazy_line)
+                find_probe_point_lazy(in_die, pf);
+        else {
+                /* Get probe address */
+                pf->addr = die_get_entrypc(in_die);
+                pf->addr += pp->offset;
+                pr_debug("found inline addr: 0x%jx\n",
+                         (uintmax_t)pf->addr);
+
+                show_probe_point(in_die, pf);
+        }
+
+        return DWARF_CB_OK;
+}
+
+/* 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;
+
+        /* Check tag and diename */
+        if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
+            die_compare_name(sp_die, pp->function) != 0)
+                return 0;
+
+        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);
+        } else if (!dwarf_func_inline(sp_die)) {
+                /* Real function */
+                if (pp->lazy_line)
+                        find_probe_point_lazy(sp_die, pf);
+                else {
+                        pf->addr = die_get_entrypc(sp_die);
+                        pf->addr += pp->offset;
+                        /* TODO: Check the address in this function */
+                        show_probe_point(sp_die, pf);
+                }
+        } else
+                /* Inlined function: search instances */
+                dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf);
+
+        return 1; /* Exit; no same symbol in this CU. */
+}
+
+static void find_probe_point_by_func(struct probe_finder *pf)
+{
+        dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0);
+}
+
+/* Find a probe point */
+int find_probe_point(int fd, struct probe_point *pp)
+{
+        struct probe_finder pf = {.pp = pp};
+        Dwarf_Off off, noff;
+        size_t cuhl;
+        Dwarf_Die *diep;
+        Dwarf *dbg;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg)
+                return -ENOENT;
+
+        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)) {
+                /* Get the DIE(Debugging Information Entry) of this CU */
+                diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
+                if (!diep)
+                        continue;
+
+                /* Check if target file is included. */
+                if (pp->file)
+                        pf.fname = cu_find_realpath(&pf.cu_die, pp->file);
+                else
+                        pf.fname = NULL;
+
+                if (!pp->file || pf.fname) {
+                        if (pp->function)
+                                find_probe_point_by_func(&pf);
+                        else if (pp->lazy_line)
+                                find_probe_point_lazy(NULL, &pf);
+                        else {
+                                pf.lno = pp->line;
+                                find_probe_point_by_line(&pf);
+                        }
+                }
+                off = noff;
+        }
+        line_list__free(&pf.lcache);
+        dwarf_end(dbg);
+
+        return pp->found;
+}
+
+/* Find line range from its line number */
+static void 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;
+        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);
+
+        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)
+                        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))
+                                continue;
+
+                        /* Address filtering 2: No child include addr? */
+                        if (die_get_inlinefunc(sp_die, addr, &die_mem))
+                                continue;
+                }
+
+                /* TODO: Get fileno from line, but how? */
+                src = dwarf_linesrc(line, NULL, NULL);
+                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);
+        }
+        /* Update status */
+        if (!list_empty(&lf->lr->line_list))
+                lf->found = 1;
+        else {
+                free(lf->lr->path);
+                lf->lr->path = NULL;
+        }
+}
+
+static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
+{
+        find_line_range_by_line(in_die, (struct line_finder *)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 line_range *lr = lf->lr;
+
+        if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
+            die_compare_name(sp_die, lr->function) == 0) {
+                lf->fname = dwarf_decl_file(sp_die);
+                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)
+                        lf->lno_e = INT_MAX;
+                else
+                        lf->lno_e = lr->offset + lr->end;
+                lr->start = lf->lno_s;
+                lr->end = lf->lno_e;
+                if (dwarf_func_inline(sp_die))
+                        dwarf_func_inline_instances(sp_die,
+                                                    line_range_inline_cb, lf);
+                else
+                        find_line_range_by_line(sp_die, lf);
+                return 1;
+        }
+        return 0;
+}
+
+static void find_line_range_by_func(struct line_finder *lf)
+{
+        dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0);
+}
+
+int find_line_range(int fd, struct line_range *lr)
+{
+        struct line_finder lf = {.lr = lr, .found = 0};
+        int ret;
+        Dwarf_Off off = 0, noff;
+        size_t cuhl;
+        Dwarf_Die *diep;
+        Dwarf *dbg;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg)
+                return -ENOENT;
+
+        /* Loop on CUs (Compilation Unit) */
+        while (!lf.found) {
+                ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL);
+                if (ret != 0)
+                        break;
+
+                /* Get the DIE(Debugging Information Entry) of this CU */
+                diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
+                if (!diep)
+                        continue;
+
+                /* Check if target file is included. */
+                if (lr->file)
+                        lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
+                else
+                        lf.fname = 0;
+
+                if (!lr->file || lf.fname) {
+                        if (lr->function)
+                                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);
+                        }
+                }
+                off = noff;
+        }
+        pr_debug("path: %lx\n", (unsigned long)lr->path);
+        dwarf_end(dbg);
+        return lf.found;
+}
+
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
new file mode 100644
index 000000000000..21f7354397b4
--- /dev/null
+++ b/tools/perf/util/probe-finder.h
@@ -0,0 +1,92 @@
+#ifndef _PROBE_FINDER_H
+#define _PROBE_FINDER_H
+
+#include <stdbool.h>
+#include "util.h"
+
+#define MAX_PATH_LEN             256
+#define MAX_PROBE_BUFFER        1024
+#define MAX_PROBES               128
+
+static inline int is_c_varname(const char *name)
+{
+        /* TODO */
+        return isalpha(name[0]) || name[0] == '_';
+}
+
+struct probe_point {
+        char                    *event;                 /* Event name */
+        char                    *group;                 /* Event group */
+
+        /* Inputs */
+        char                    *file;                  /* File name */
+        int                     line;                   /* Line number */
+        char                    *lazy_line;             /* Lazy line pattern */
+
+        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 */
+
+        /* For function searching */
+        Dwarf_Addr              addr;           /* Address */
+        const char              *fname;         /* File name */
+        int                     lno;            /* Line number */
+        Dwarf_Die               cu_die;         /* Current CU */
+
+        /* For variable searching */
+        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 line_finder {
+        struct line_range       *lr;            /* Target line range */
+
+        const char              *fname;         /* File name */
+        int                     lno_s;          /* Start line number */
+        int                     lno_e;          /* End line number */
+        Dwarf_Die               cu_die;         /* Current CU */
+        int                     found;
+};
+
+#endif /* NO_DWARF_SUPPORT */
+
+#endif /*_PROBE_FINDER_H */
diff --git a/tools/perf/util/quote.h b/tools/perf/util/quote.h
index a5454a1d1c13..b6a019733919 100644
--- a/tools/perf/util/quote.h
+++ b/tools/perf/util/quote.h
@@ -1,5 +1,5 @@
-#ifndef QUOTE_H
-#define QUOTE_H
+#ifndef __PERF_QUOTE_H
+#define __PERF_QUOTE_H
 
 #include <stddef.h>
 #include <stdio.h>
@@ -65,4 +65,4 @@ extern void perl_quote_print(FILE *stream, const char *src);
 extern void python_quote_print(FILE *stream, const char *src);
 extern void tcl_quote_print(FILE *stream, const char *src);
 
-#endif
+#endif /* __PERF_QUOTE_H */
diff --git a/tools/perf/util/run-command.h b/tools/perf/util/run-command.h
index cc1837deba88..d79028727ce2 100644
--- a/tools/perf/util/run-command.h
+++ b/tools/perf/util/run-command.h
@@ -1,5 +1,5 @@
-#ifndef RUN_COMMAND_H
-#define RUN_COMMAND_H
+#ifndef __PERF_RUN_COMMAND_H
+#define __PERF_RUN_COMMAND_H
 
 enum {
         ERR_RUN_COMMAND_FORK = 10000,
@@ -85,4 +85,4 @@ struct async {
 int start_async(struct async *async);
 int finish_async(struct async *async);
 
-#endif
+#endif /* __PERF_RUN_COMMAND_H */
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
new file mode 100644
index 000000000000..5376378e0cfc
--- /dev/null
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -0,0 +1,568 @@
+/*
+ * trace-event-perl.  Feed perf trace events to an embedded Perl interpreter.
+ *
+ * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../../perf.h"
+#include "../util.h"
+#include "../trace-event.h"
+
+#include <EXTERN.h>
+#include <perl.h>
+
+void boot_Perf__Trace__Context(pTHX_ CV *cv);
+void boot_DynaLoader(pTHX_ CV *cv);
+typedef PerlInterpreter * INTERP;
+
+void xs_init(pTHX);
+
+void xs_init(pTHX)
+{
+        const char *file = __FILE__;
+        dXSUB_SYS;
+
+        newXS("Perf::Trace::Context::bootstrap", boot_Perf__Trace__Context,
+              file);
+        newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
+}
+
+INTERP my_perl;
+
+#define FTRACE_MAX_EVENT                                \
+        ((1 << (sizeof(unsigned short) * 8)) - 1)
+
+struct event *events[FTRACE_MAX_EVENT];
+
+extern struct scripting_context *scripting_context;
+
+static char *cur_field_name;
+static int zero_flag_atom;
+
+static void define_symbolic_value(const char *ev_name,
+                                  const char *field_name,
+                                  const char *field_value,
+                                  const char *field_str)
+{
+        unsigned long long value;
+        dSP;
+
+        value = eval_flag(field_value);
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVuv(value)));
+        XPUSHs(sv_2mortal(newSVpv(field_str, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_symbolic_value", 0))
+                call_pv("main::define_symbolic_value", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_symbolic_values(struct print_flag_sym *field,
+                                   const char *ev_name,
+                                   const char *field_name)
+{
+        define_symbolic_value(ev_name, field_name, field->value, field->str);
+        if (field->next)
+                define_symbolic_values(field->next, ev_name, field_name);
+}
+
+static void define_symbolic_field(const char *ev_name,
+                                  const char *field_name)
+{
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_symbolic_field", 0))
+                call_pv("main::define_symbolic_field", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_flag_value(const char *ev_name,
+                              const char *field_name,
+                              const char *field_value,
+                              const char *field_str)
+{
+        unsigned long long value;
+        dSP;
+
+        value = eval_flag(field_value);
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVuv(value)));
+        XPUSHs(sv_2mortal(newSVpv(field_str, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_flag_value", 0))
+                call_pv("main::define_flag_value", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_flag_values(struct print_flag_sym *field,
+                               const char *ev_name,
+                               const char *field_name)
+{
+        define_flag_value(ev_name, field_name, field->value, field->str);
+        if (field->next)
+                define_flag_values(field->next, ev_name, field_name);
+}
+
+static void define_flag_field(const char *ev_name,
+                              const char *field_name,
+                              const char *delim)
+{
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(delim, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_flag_field", 0))
+                call_pv("main::define_flag_field", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_event_symbols(struct event *event,
+                                 const char *ev_name,
+                                 struct print_arg *args)
+{
+        switch (args->type) {
+        case PRINT_NULL:
+                break;
+        case PRINT_ATOM:
+                define_flag_value(ev_name, cur_field_name, "0",
+                                  args->atom.atom);
+                zero_flag_atom = 0;
+                break;
+        case PRINT_FIELD:
+                if (cur_field_name)
+                        free(cur_field_name);
+                cur_field_name = strdup(args->field.name);
+                break;
+        case PRINT_FLAGS:
+                define_event_symbols(event, ev_name, args->flags.field);
+                define_flag_field(ev_name, cur_field_name, args->flags.delim);
+                define_flag_values(args->flags.flags, ev_name, cur_field_name);
+                break;
+        case PRINT_SYMBOL:
+                define_event_symbols(event, ev_name, args->symbol.field);
+                define_symbolic_field(ev_name, cur_field_name);
+                define_symbolic_values(args->symbol.symbols, ev_name,
+                                       cur_field_name);
+                break;
+        case PRINT_STRING:
+                break;
+        case PRINT_TYPE:
+                define_event_symbols(event, ev_name, args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        zero_flag_atom = 1;
+                define_event_symbols(event, ev_name, args->op.left);
+                define_event_symbols(event, ev_name, args->op.right);
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+
+        if (args->next)
+                define_event_symbols(event, ev_name, args->next);
+}
+
+static inline struct event *find_cache_event(int type)
+{
+        static char ev_name[256];
+        struct event *event;
+
+        if (events[type])
+                return events[type];
+
+        events[type] = event = trace_find_event(type);
+        if (!event)
+                return NULL;
+
+        sprintf(ev_name, "%s::%s", event->system, event->name);
+
+        define_event_symbols(event, ev_name, event->print_fmt.args);
+
+        return event;
+}
+
+static void perl_process_event(int cpu, void *data,
+                               int size __unused,
+                               unsigned long long nsecs, char *comm)
+{
+        struct format_field *field;
+        static char handler[256];
+        unsigned long long val;
+        unsigned long s, ns;
+        struct event *event;
+        int type;
+        int pid;
+
+        dSP;
+
+        type = trace_parse_common_type(data);
+
+        event = find_cache_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = trace_parse_common_pid(data);
+
+        sprintf(handler, "%s::%s", event->system, event->name);
+
+        s = nsecs / NSECS_PER_SEC;
+        ns = nsecs - s * NSECS_PER_SEC;
+
+        scripting_context->event_data = data;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(handler, 0)));
+        XPUSHs(sv_2mortal(newSViv(PTR2IV(scripting_context))));
+        XPUSHs(sv_2mortal(newSVuv(cpu)));
+        XPUSHs(sv_2mortal(newSVuv(s)));
+        XPUSHs(sv_2mortal(newSVuv(ns)));
+        XPUSHs(sv_2mortal(newSViv(pid)));
+        XPUSHs(sv_2mortal(newSVpv(comm, 0)));
+
+        /* common fields other than pid can be accessed via xsub fns */
+
+        for (field = event->format.fields; field; field = field->next) {
+                if (field->flags & FIELD_IS_STRING) {
+                        int offset;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                offset = *(int *)(data + field->offset);
+                                offset &= 0xffff;
+                        } else
+                                offset = field->offset;
+                        XPUSHs(sv_2mortal(newSVpv((char *)data + offset, 0)));
+                } else { /* FIELD_IS_NUMERIC */
+                        val = read_size(data + field->offset, field->size);
+                        if (field->flags & FIELD_IS_SIGNED) {
+                                XPUSHs(sv_2mortal(newSViv(val)));
+                        } else {
+                                XPUSHs(sv_2mortal(newSVuv(val)));
+                        }
+                }
+        }
+
+        PUTBACK;
+
+        if (get_cv(handler, 0))
+                call_pv(handler, G_SCALAR);
+        else if (get_cv("main::trace_unhandled", 0)) {
+                XPUSHs(sv_2mortal(newSVpv(handler, 0)));
+                XPUSHs(sv_2mortal(newSViv(PTR2IV(scripting_context))));
+                XPUSHs(sv_2mortal(newSVuv(cpu)));
+                XPUSHs(sv_2mortal(newSVuv(nsecs)));
+                XPUSHs(sv_2mortal(newSViv(pid)));
+                XPUSHs(sv_2mortal(newSVpv(comm, 0)));
+                call_pv("main::trace_unhandled", G_SCALAR);
+        }
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void run_start_sub(void)
+{
+        dSP; /* access to Perl stack */
+        PUSHMARK(SP);
+
+        if (get_cv("main::trace_begin", 0))
+                call_pv("main::trace_begin", G_DISCARD | G_NOARGS);
+}
+
+/*
+ * Start trace script
+ */
+static int perl_start_script(const char *script, int argc, const char **argv)
+{
+        const char **command_line;
+        int i, err = 0;
+
+        command_line = malloc((argc + 2) * sizeof(const char *));
+        command_line[0] = "";
+        command_line[1] = script;
+        for (i = 2; i < argc + 2; i++)
+                command_line[i] = argv[i - 2];
+
+        my_perl = perl_alloc();
+        perl_construct(my_perl);
+
+        if (perl_parse(my_perl, xs_init, argc + 2, (char **)command_line,
+                       (char **)NULL)) {
+                err = -1;
+                goto error;
+        }
+
+        if (perl_run(my_perl)) {
+                err = -1;
+                goto error;
+        }
+
+        if (SvTRUE(ERRSV)) {
+                err = -1;
+                goto error;
+        }
+
+        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);
+        free(command_line);
+
+        return err;
+}
+
+/*
+ * Stop trace script
+ */
+static int perl_stop_script(void)
+{
+        dSP; /* access to Perl stack */
+        PUSHMARK(SP);
+
+        if (get_cv("main::trace_end", 0))
+                call_pv("main::trace_end", G_DISCARD | G_NOARGS);
+
+        perl_destruct(my_perl);
+        perl_free(my_perl);
+
+        fprintf(stderr, "\nperf trace Perl script stopped\n");
+
+        return 0;
+}
+
+static int perl_generate_script(const char *outfile)
+{
+        struct event *event = NULL;
+        struct format_field *f;
+        char fname[PATH_MAX];
+        int not_first, count;
+        FILE *ofp;
+
+        sprintf(fname, "%s.pl", outfile);
+        ofp = fopen(fname, "w");
+        if (ofp == NULL) {
+                fprintf(stderr, "couldn't open %s\n", fname);
+                return -1;
+        }
+
+        fprintf(ofp, "# perf trace event handlers, "
+                "generated by perf trace -g perl\n");
+
+        fprintf(ofp, "# Licensed under the terms of the GNU GPL"
+                " License version 2\n\n");
+
+        fprintf(ofp, "# The common_* event handler fields are the most useful "
+                "fields common to\n");
+
+        fprintf(ofp, "# all events.  They don't necessarily correspond to "
+                "the 'common_*' fields\n");
+
+        fprintf(ofp, "# in the format files.  Those fields not available as "
+                "handler params can\n");
+
+        fprintf(ofp, "# be retrieved using Perl functions of the form "
+                "common_*($context).\n");
+
+        fprintf(ofp, "# See Context.pm for the list of available "
+                "functions.\n\n");
+
+        fprintf(ofp, "use lib \"$ENV{'PERF_EXEC_PATH'}/scripts/perl/"
+                "Perf-Trace-Util/lib\";\n");
+
+        fprintf(ofp, "use lib \"./Perf-Trace-Util/lib\";\n");
+        fprintf(ofp, "use Perf::Trace::Core;\n");
+        fprintf(ofp, "use Perf::Trace::Context;\n");
+        fprintf(ofp, "use Perf::Trace::Util;\n\n");
+
+        fprintf(ofp, "sub trace_begin\n{\n\t# optional\n}\n\n");
+        fprintf(ofp, "sub trace_end\n{\n\t# optional\n}\n\n");
+
+        while ((event = trace_find_next_event(event))) {
+                fprintf(ofp, "sub %s::%s\n{\n", event->system, event->name);
+                fprintf(ofp, "\tmy (");
+
+                fprintf(ofp, "$event_name, ");
+                fprintf(ofp, "$context, ");
+                fprintf(ofp, "$common_cpu, ");
+                fprintf(ofp, "$common_secs, ");
+                fprintf(ofp, "$common_nsecs,\n");
+                fprintf(ofp, "\t    $common_pid, ");
+                fprintf(ofp, "$common_comm,\n\t    ");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t    ");
+
+                        fprintf(ofp, "$%s", f->name);
+                }
+                fprintf(ofp, ") = @_;\n\n");
+
+                fprintf(ofp, "\tprint_header($event_name, $common_cpu, "
+                        "$common_secs, $common_nsecs,\n\t             "
+                        "$common_pid, $common_comm);\n\n");
+
+                fprintf(ofp, "\tprintf(\"");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (count && count % 4 == 0) {
+                                fprintf(ofp, "\".\n\t       \"");
+                        }
+                        count++;
+
+                        fprintf(ofp, "%s=", f->name);
+                        if (f->flags & FIELD_IS_STRING ||
+                            f->flags & FIELD_IS_FLAG ||
+                            f->flags & FIELD_IS_SYMBOLIC)
+                                fprintf(ofp, "%%s");
+                        else if (f->flags & FIELD_IS_SIGNED)
+                                fprintf(ofp, "%%d");
+                        else
+                                fprintf(ofp, "%%u");
+                }
+
+                fprintf(ofp, "\\n\",\n\t       ");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t       ");
+
+                        if (f->flags & FIELD_IS_FLAG) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t       ");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "flag_str(\"");
+                                fprintf(ofp, "%s::%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", $%s)", f->name,
+                                        f->name);
+                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t       ");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "symbol_str(\"");
+                                fprintf(ofp, "%s::%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", $%s)", f->name,
+                                        f->name);
+                        } else
+                                fprintf(ofp, "$%s", f->name);
+                }
+
+                fprintf(ofp, ");\n");
+                fprintf(ofp, "}\n\n");
+        }
+
+        fprintf(ofp, "sub trace_unhandled\n{\n\tmy ($event_name, $context, "
+                "$common_cpu, $common_secs, $common_nsecs,\n\t    "
+                "$common_pid, $common_comm) = @_;\n\n");
+
+        fprintf(ofp, "\tprint_header($event_name, $common_cpu, "
+                "$common_secs, $common_nsecs,\n\t             $common_pid, "
+                "$common_comm);\n}\n\n");
+
+        fprintf(ofp, "sub print_header\n{\n"
+                "\tmy ($event_name, $cpu, $secs, $nsecs, $pid, $comm) = @_;\n\n"
+                "\tprintf(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \",\n\t       "
+                "$event_name, $cpu, $secs, $nsecs, $pid, $comm);\n}");
+
+        fclose(ofp);
+
+        fprintf(stderr, "generated Perl script: %s\n", fname);
+
+        return 0;
+}
+
+struct scripting_ops perl_scripting_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script,
+        .stop_script = perl_stop_script,
+        .process_event = perl_process_event,
+        .generate_script = perl_generate_script,
+};
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
new file mode 100644
index 000000000000..6a72f14c5986
--- /dev/null
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -0,0 +1,580 @@
+/*
+ * trace-event-python.  Feed trace events to an embedded Python interpreter.
+ *
+ * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <Python.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../../perf.h"
+#include "../util.h"
+#include "../trace-event.h"
+
+PyMODINIT_FUNC initperf_trace_context(void);
+
+#define FTRACE_MAX_EVENT                                \
+        ((1 << (sizeof(unsigned short) * 8)) - 1)
+
+struct event *events[FTRACE_MAX_EVENT];
+
+#define MAX_FIELDS      64
+#define N_COMMON_FIELDS 7
+
+extern struct scripting_context *scripting_context;
+
+static char *cur_field_name;
+static int zero_flag_atom;
+
+static PyObject *main_module, *main_dict;
+
+static void handler_call_die(const char *handler_name)
+{
+        PyErr_Print();
+        Py_FatalError("problem in Python trace event handler");
+}
+
+static void define_value(enum print_arg_type field_type,
+                         const char *ev_name,
+                         const char *field_name,
+                         const char *field_value,
+                         const char *field_str)
+{
+        const char *handler_name = "define_flag_value";
+        PyObject *handler, *t, *retval;
+        unsigned long long value;
+        unsigned n = 0;
+
+        if (field_type == PRINT_SYMBOL)
+                handler_name = "define_symbolic_value";
+
+        t = PyTuple_New(4);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        value = eval_flag(field_value);
+
+        PyTuple_SetItem(t, n++, PyString_FromString(ev_name));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_name));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(value));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_str));
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        }
+
+        Py_DECREF(t);
+}
+
+static void define_values(enum print_arg_type field_type,
+                          struct print_flag_sym *field,
+                          const char *ev_name,
+                          const char *field_name)
+{
+        define_value(field_type, ev_name, field_name, field->value,
+                     field->str);
+
+        if (field->next)
+                define_values(field_type, field->next, ev_name, field_name);
+}
+
+static void define_field(enum print_arg_type field_type,
+                         const char *ev_name,
+                         const char *field_name,
+                         const char *delim)
+{
+        const char *handler_name = "define_flag_field";
+        PyObject *handler, *t, *retval;
+        unsigned n = 0;
+
+        if (field_type == PRINT_SYMBOL)
+                handler_name = "define_symbolic_field";
+
+        if (field_type == PRINT_FLAGS)
+                t = PyTuple_New(3);
+        else
+                t = PyTuple_New(2);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        PyTuple_SetItem(t, n++, PyString_FromString(ev_name));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_name));
+        if (field_type == PRINT_FLAGS)
+                PyTuple_SetItem(t, n++, PyString_FromString(delim));
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        }
+
+        Py_DECREF(t);
+}
+
+static void define_event_symbols(struct event *event,
+                                 const char *ev_name,
+                                 struct print_arg *args)
+{
+        switch (args->type) {
+        case PRINT_NULL:
+                break;
+        case PRINT_ATOM:
+                define_value(PRINT_FLAGS, ev_name, cur_field_name, "0",
+                             args->atom.atom);
+                zero_flag_atom = 0;
+                break;
+        case PRINT_FIELD:
+                if (cur_field_name)
+                        free(cur_field_name);
+                cur_field_name = strdup(args->field.name);
+                break;
+        case PRINT_FLAGS:
+                define_event_symbols(event, ev_name, args->flags.field);
+                define_field(PRINT_FLAGS, ev_name, cur_field_name,
+                             args->flags.delim);
+                define_values(PRINT_FLAGS, args->flags.flags, ev_name,
+                              cur_field_name);
+                break;
+        case PRINT_SYMBOL:
+                define_event_symbols(event, ev_name, args->symbol.field);
+                define_field(PRINT_SYMBOL, ev_name, cur_field_name, NULL);
+                define_values(PRINT_SYMBOL, args->symbol.symbols, ev_name,
+                              cur_field_name);
+                break;
+        case PRINT_STRING:
+                break;
+        case PRINT_TYPE:
+                define_event_symbols(event, ev_name, args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        zero_flag_atom = 1;
+                define_event_symbols(event, ev_name, args->op.left);
+                define_event_symbols(event, ev_name, args->op.right);
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+
+        if (args->next)
+                define_event_symbols(event, ev_name, args->next);
+}
+
+static inline struct event *find_cache_event(int type)
+{
+        static char ev_name[256];
+        struct event *event;
+
+        if (events[type])
+                return events[type];
+
+        events[type] = event = trace_find_event(type);
+        if (!event)
+                return NULL;
+
+        sprintf(ev_name, "%s__%s", event->system, event->name);
+
+        define_event_symbols(event, ev_name, event->print_fmt.args);
+
+        return event;
+}
+
+static void python_process_event(int cpu, void *data,
+                                 int size __unused,
+                                 unsigned long long nsecs, char *comm)
+{
+        PyObject *handler, *retval, *context, *t, *obj;
+        static char handler_name[256];
+        struct format_field *field;
+        unsigned long long val;
+        unsigned long s, ns;
+        struct event *event;
+        unsigned n = 0;
+        int type;
+        int pid;
+
+        t = PyTuple_New(MAX_FIELDS);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        type = trace_parse_common_type(data);
+
+        event = find_cache_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = trace_parse_common_pid(data);
+
+        sprintf(handler_name, "%s__%s", event->system, event->name);
+
+        s = nsecs / NSECS_PER_SEC;
+        ns = nsecs - s * NSECS_PER_SEC;
+
+        scripting_context->event_data = data;
+
+        context = PyCObject_FromVoidPtr(scripting_context, NULL);
+
+        PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
+        PyTuple_SetItem(t, n++,
+                        PyCObject_FromVoidPtr(scripting_context, NULL));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(s));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
+        PyTuple_SetItem(t, n++, PyString_FromString(comm));
+
+        for (field = event->format.fields; field; field = field->next) {
+                if (field->flags & FIELD_IS_STRING) {
+                        int offset;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                offset = *(int *)(data + field->offset);
+                                offset &= 0xffff;
+                        } else
+                                offset = field->offset;
+                        obj = PyString_FromString((char *)data + offset);
+                } else { /* FIELD_IS_NUMERIC */
+                        val = read_size(data + field->offset, field->size);
+                        if (field->flags & FIELD_IS_SIGNED) {
+                                if ((long long)val >= LONG_MIN &&
+                                    (long long)val <= LONG_MAX)
+                                        obj = PyInt_FromLong(val);
+                                else
+                                        obj = PyLong_FromLongLong(val);
+                        } else {
+                                if (val <= LONG_MAX)
+                                        obj = PyInt_FromLong(val);
+                                else
+                                        obj = PyLong_FromUnsignedLongLong(val);
+                        }
+                }
+                PyTuple_SetItem(t, n++, obj);
+        }
+
+        if (_PyTuple_Resize(&t, n) == -1)
+                Py_FatalError("error resizing Python tuple");
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        } else {
+                handler = PyDict_GetItemString(main_dict, "trace_unhandled");
+                if (handler && PyCallable_Check(handler)) {
+                        if (_PyTuple_Resize(&t, N_COMMON_FIELDS) == -1)
+                                Py_FatalError("error resizing Python tuple");
+
+                        retval = PyObject_CallObject(handler, t);
+                        if (retval == NULL)
+                                handler_call_die("trace_unhandled");
+                }
+        }
+
+        Py_DECREF(t);
+}
+
+static int run_start_sub(void)
+{
+        PyObject *handler, *retval;
+        int err = 0;
+
+        main_module = PyImport_AddModule("__main__");
+        if (main_module == NULL)
+                return -1;
+        Py_INCREF(main_module);
+
+        main_dict = PyModule_GetDict(main_module);
+        if (main_dict == NULL) {
+                err = -1;
+                goto error;
+        }
+        Py_INCREF(main_dict);
+
+        handler = PyDict_GetItemString(main_dict, "trace_begin");
+        if (handler == NULL || !PyCallable_Check(handler))
+                goto out;
+
+        retval = PyObject_CallObject(handler, NULL);
+        if (retval == NULL)
+                handler_call_die("trace_begin");
+
+        Py_DECREF(retval);
+        return err;
+error:
+        Py_XDECREF(main_dict);
+        Py_XDECREF(main_module);
+out:
+        return err;
+}
+
+/*
+ * Start trace script
+ */
+static int python_start_script(const char *script, int argc, const char **argv)
+{
+        const char **command_line;
+        char buf[PATH_MAX];
+        int i, err = 0;
+        FILE *fp;
+
+        command_line = malloc((argc + 1) * sizeof(const char *));
+        command_line[0] = script;
+        for (i = 1; i < argc + 1; i++)
+                command_line[i] = argv[i - 1];
+
+        Py_Initialize();
+
+        initperf_trace_context();
+
+        PySys_SetArgv(argc + 1, (char **)command_line);
+
+        fp = fopen(script, "r");
+        if (!fp) {
+                sprintf(buf, "Can't open python script \"%s\"", script);
+                perror(buf);
+                err = -1;
+                goto error;
+        }
+
+        err = PyRun_SimpleFile(fp, script);
+        if (err) {
+                fprintf(stderr, "Error running python script %s\n", script);
+                goto error;
+        }
+
+        err = run_start_sub();
+        if (err) {
+                fprintf(stderr, "Error starting python script %s\n", script);
+                goto error;
+        }
+
+        free(command_line);
+        fprintf(stderr, "perf trace started with Python script %s\n\n",
+                script);
+
+        return err;
+error:
+        Py_Finalize();
+        free(command_line);
+
+        return err;
+}
+
+/*
+ * Stop trace script
+ */
+static int python_stop_script(void)
+{
+        PyObject *handler, *retval;
+        int err = 0;
+
+        handler = PyDict_GetItemString(main_dict, "trace_end");
+        if (handler == NULL || !PyCallable_Check(handler))
+                goto out;
+
+        retval = PyObject_CallObject(handler, NULL);
+        if (retval == NULL)
+                handler_call_die("trace_end");
+        else
+                Py_DECREF(retval);
+out:
+        Py_XDECREF(main_dict);
+        Py_XDECREF(main_module);
+        Py_Finalize();
+
+        fprintf(stderr, "\nperf trace Python script stopped\n");
+
+        return err;
+}
+
+static int python_generate_script(const char *outfile)
+{
+        struct event *event = NULL;
+        struct format_field *f;
+        char fname[PATH_MAX];
+        int not_first, count;
+        FILE *ofp;
+
+        sprintf(fname, "%s.py", outfile);
+        ofp = fopen(fname, "w");
+        if (ofp == NULL) {
+                fprintf(stderr, "couldn't open %s\n", fname);
+                return -1;
+        }
+        fprintf(ofp, "# perf trace event handlers, "
+                "generated by perf trace -g python\n");
+
+        fprintf(ofp, "# Licensed under the terms of the GNU GPL"
+                " License version 2\n\n");
+
+        fprintf(ofp, "# The common_* event handler fields are the most useful "
+                "fields common to\n");
+
+        fprintf(ofp, "# all events.  They don't necessarily correspond to "
+                "the 'common_*' fields\n");
+
+        fprintf(ofp, "# in the format files.  Those fields not available as "
+                "handler params can\n");
+
+        fprintf(ofp, "# be retrieved using Python functions of the form "
+                "common_*(context).\n");
+
+        fprintf(ofp, "# See the perf-trace-python Documentation for the list "
+                "of available functions.\n\n");
+
+        fprintf(ofp, "import os\n");
+        fprintf(ofp, "import sys\n\n");
+
+        fprintf(ofp, "sys.path.append(os.environ['PERF_EXEC_PATH'] + \\\n");
+        fprintf(ofp, "\t'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')\n");
+        fprintf(ofp, "\nfrom perf_trace_context import *\n");
+        fprintf(ofp, "from Core import *\n\n\n");
+
+        fprintf(ofp, "def trace_begin():\n");
+        fprintf(ofp, "\tprint \"in trace_begin\"\n\n");
+
+        fprintf(ofp, "def trace_end():\n");
+        fprintf(ofp, "\tprint \"in trace_end\"\n\n");
+
+        while ((event = trace_find_next_event(event))) {
+                fprintf(ofp, "def %s__%s(", event->system, event->name);
+                fprintf(ofp, "event_name, ");
+                fprintf(ofp, "context, ");
+                fprintf(ofp, "common_cpu,\n");
+                fprintf(ofp, "\tcommon_secs, ");
+                fprintf(ofp, "common_nsecs, ");
+                fprintf(ofp, "common_pid, ");
+                fprintf(ofp, "common_comm,\n\t");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t");
+
+                        fprintf(ofp, "%s", f->name);
+                }
+                fprintf(ofp, "):\n");
+
+                fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
+                        "common_secs, common_nsecs,\n\t\t\t"
+                        "common_pid, common_comm)\n\n");
+
+                fprintf(ofp, "\t\tprint \"");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (count && count % 3 == 0) {
+                                fprintf(ofp, "\" \\\n\t\t\"");
+                        }
+                        count++;
+
+                        fprintf(ofp, "%s=", f->name);
+                        if (f->flags & FIELD_IS_STRING ||
+                            f->flags & FIELD_IS_FLAG ||
+                            f->flags & FIELD_IS_SYMBOLIC)
+                                fprintf(ofp, "%%s");
+                        else if (f->flags & FIELD_IS_SIGNED)
+                                fprintf(ofp, "%%d");
+                        else
+                                fprintf(ofp, "%%u");
+                }
+
+                fprintf(ofp, "\\n\" %% \\\n\t\t(");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t\t");
+
+                        if (f->flags & FIELD_IS_FLAG) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t\t");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "flag_str(\"");
+                                fprintf(ofp, "%s__%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", %s)", f->name,
+                                        f->name);
+                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t\t");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "symbol_str(\"");
+                                fprintf(ofp, "%s__%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", %s)", f->name,
+                                        f->name);
+                        } else
+                                fprintf(ofp, "%s", f->name);
+                }
+
+                fprintf(ofp, "),\n\n");
+        }
+
+        fprintf(ofp, "def trace_unhandled(event_name, context, "
+                "common_cpu, common_secs, common_nsecs,\n\t\t"
+                "common_pid, common_comm):\n");
+
+        fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
+                "common_secs, common_nsecs,\n\t\tcommon_pid, "
+                "common_comm)\n\n");
+
+        fprintf(ofp, "def print_header("
+                "event_name, cpu, secs, nsecs, pid, comm):\n"
+                "\tprint \"%%-20s %%5u %%05u.%%09u %%8u %%-20s \" %% \\\n\t"
+                "(event_name, cpu, secs, nsecs, pid, comm),\n");
+
+        fclose(ofp);
+
+        fprintf(stderr, "generated Python script: %s\n", fname);
+
+        return 0;
+}
+
+struct scripting_ops python_scripting_ops = {
+        .name = "Python",
+        .start_script = python_start_script,
+        .stop_script = python_stop_script,
+        .process_event = python_process_event,
+        .generate_script = python_generate_script,
+};
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
new file mode 100644
index 000000000000..eed1cb889008
--- /dev/null
+++ b/tools/perf/util/session.c
@@ -0,0 +1,574 @@
+#define _FILE_OFFSET_BITS 64
+
+#include <linux/kernel.h>
+
+#include <byteswap.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "session.h"
+#include "sort.h"
+#include "util.h"
+
+static int perf_session__open(struct perf_session *self, bool force)
+{
+        struct stat input_stat;
+
+        self->fd = open(self->filename, O_RDONLY);
+        if (self->fd < 0) {
+                pr_err("failed to open file: %s", self->filename);
+                if (!strcmp(self->filename, "perf.data"))
+                        pr_err("  (try 'perf record' first)");
+                pr_err("\n");
+                return -errno;
+        }
+
+        if (fstat(self->fd, &input_stat) < 0)
+                goto out_close;
+
+        if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
+                pr_err("file %s not owned by current user or root\n",
+                       self->filename);
+                goto out_close;
+        }
+
+        if (!input_stat.st_size) {
+                pr_info("zero-sized file (%s), nothing to do!\n",
+                        self->filename);
+                goto out_close;
+        }
+
+        if (perf_header__read(&self->header, self->fd) < 0) {
+                pr_err("incompatible file format");
+                goto out_close;
+        }
+
+        self->size = input_stat.st_size;
+        return 0;
+
+out_close:
+        close(self->fd);
+        self->fd = -1;
+        return -1;
+}
+
+static inline int perf_session__create_kernel_maps(struct perf_session *self)
+{
+        return map_groups__create_kernel_maps(&self->kmaps, self->vmlinux_maps);
+}
+
+struct perf_session *perf_session__new(const char *filename, int mode, bool force)
+{
+        size_t len = filename ? strlen(filename) + 1 : 0;
+        struct perf_session *self = zalloc(sizeof(*self) + len);
+
+        if (self == NULL)
+                goto out;
+
+        if (perf_header__init(&self->header) < 0)
+                goto out_free;
+
+        memcpy(self->filename, filename, len);
+        self->threads = RB_ROOT;
+        self->stats_by_id = 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);
+
+        if (mode == O_RDONLY) {
+                if (perf_session__open(self, force) < 0)
+                        goto out_delete;
+        } else if (mode == O_WRONLY) {
+                /*
+                 * In O_RDONLY mode this will be performed when reading the
+                 * kernel MMAP event, in event__process_mmap().
+                 */
+                if (perf_session__create_kernel_maps(self) < 0)
+                        goto out_delete;
+        }
+
+        self->sample_type = perf_header__sample_type(&self->header);
+out:
+        return self;
+out_free:
+        free(self);
+        return NULL;
+out_delete:
+        perf_session__delete(self);
+        return NULL;
+}
+
+void perf_session__delete(struct perf_session *self)
+{
+        perf_header__exit(&self->header);
+        close(self->fd);
+        free(self->cwd);
+        free(self);
+}
+
+static bool symbol__match_parent_regex(struct symbol *sym)
+{
+        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
+                return 1;
+
+        return 0;
+}
+
+struct 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;
+
+        if (symbol_conf.use_callchain) {
+                syms = calloc(chain->nr, sizeof(*syms));
+                if (!syms) {
+                        fprintf(stderr, "Can't allocate memory for symbols\n");
+                        exit(-1);
+                }
+        }
+
+        for (i = 0; i < chain->nr; i++) {
+                u64 ip = chain->ips[i];
+                struct addr_location al;
+
+                if (ip >= PERF_CONTEXT_MAX) {
+                        switch (ip) {
+                        case PERF_CONTEXT_HV:
+                                cpumode = PERF_RECORD_MISC_HYPERVISOR;  break;
+                        case PERF_CONTEXT_KERNEL:
+                                cpumode = PERF_RECORD_MISC_KERNEL;      break;
+                        case PERF_CONTEXT_USER:
+                                cpumode = PERF_RECORD_MISC_USER;        break;
+                        default:
+                                break;
+                        }
+                        continue;
+                }
+
+                thread__find_addr_location(thread, self, cpumode,
+                                           MAP__FUNCTION, 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;
+                }
+        }
+
+        return syms;
+}
+
+static int process_event_stub(event_t *event __used,
+                              struct perf_session *session __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
+{
+        if (handler->sample == NULL)
+                handler->sample = process_event_stub;
+        if (handler->mmap == NULL)
+                handler->mmap = process_event_stub;
+        if (handler->comm == NULL)
+                handler->comm = process_event_stub;
+        if (handler->fork == NULL)
+                handler->fork = process_event_stub;
+        if (handler->exit == NULL)
+                handler->exit = process_event_stub;
+        if (handler->lost == NULL)
+                handler->lost = process_event_stub;
+        if (handler->read == NULL)
+                handler->read = process_event_stub;
+        if (handler->throttle == NULL)
+                handler->throttle = process_event_stub;
+        if (handler->unthrottle == NULL)
+                handler->unthrottle = process_event_stub;
+}
+
+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]);
+}
+
+void mem_bswap_64(void *src, int byte_size)
+{
+        u64 *m = src;
+
+        while (byte_size > 0) {
+                *m = bswap_64(*m);
+                byte_size -= sizeof(u64);
+                ++m;
+        }
+}
+
+static void event__all64_swap(event_t *self)
+{
+        struct perf_event_header *hdr = &self->header;
+        mem_bswap_64(hdr + 1, self->header.size - sizeof(*hdr));
+}
+
+static void event__comm_swap(event_t *self)
+{
+        self->comm.pid = bswap_32(self->comm.pid);
+        self->comm.tid = bswap_32(self->comm.tid);
+}
+
+static void event__mmap_swap(event_t *self)
+{
+        self->mmap.pid   = bswap_32(self->mmap.pid);
+        self->mmap.tid   = bswap_32(self->mmap.tid);
+        self->mmap.start = bswap_64(self->mmap.start);
+        self->mmap.len   = bswap_64(self->mmap.len);
+        self->mmap.pgoff = bswap_64(self->mmap.pgoff);
+}
+
+static void event__task_swap(event_t *self)
+{
+        self->fork.pid  = bswap_32(self->fork.pid);
+        self->fork.tid  = bswap_32(self->fork.tid);
+        self->fork.ppid = bswap_32(self->fork.ppid);
+        self->fork.ptid = bswap_32(self->fork.ptid);
+        self->fork.time = bswap_64(self->fork.time);
+}
+
+static void event__read_swap(event_t *self)
+{
+        self->read.pid          = bswap_32(self->read.pid);
+        self->read.tid          = bswap_32(self->read.tid);
+        self->read.value        = bswap_64(self->read.value);
+        self->read.time_enabled = bswap_64(self->read.time_enabled);
+        self->read.time_running = bswap_64(self->read.time_running);
+        self->read.id           = bswap_64(self->read.id);
+}
+
+typedef void (*event__swap_op)(event_t *self);
+
+static event__swap_op event__swap_ops[] = {
+        [PERF_RECORD_MMAP]   = event__mmap_swap,
+        [PERF_RECORD_COMM]   = event__comm_swap,
+        [PERF_RECORD_FORK]   = event__task_swap,
+        [PERF_RECORD_EXIT]   = event__task_swap,
+        [PERF_RECORD_LOST]   = event__all64_swap,
+        [PERF_RECORD_READ]   = event__read_swap,
+        [PERF_RECORD_SAMPLE] = event__all64_swap,
+        [PERF_RECORD_MAX]    = NULL,
+};
+
+static int perf_session__process_event(struct perf_session *self,
+                                       event_t *event,
+                                       struct perf_event_ops *ops,
+                                       u64 offset, u64 head)
+{
+        trace_event(event);
+
+        if (event->header.type < PERF_RECORD_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];
+        }
+
+        if (self->header.needs_swap && event__swap_ops[event->header.type])
+                event__swap_ops[event->header.type](event);
+
+        switch (event->header.type) {
+        case PERF_RECORD_SAMPLE:
+                return ops->sample(event, self);
+        case PERF_RECORD_MMAP:
+                return ops->mmap(event, self);
+        case PERF_RECORD_COMM:
+                return ops->comm(event, self);
+        case PERF_RECORD_FORK:
+                return ops->fork(event, self);
+        case PERF_RECORD_EXIT:
+                return ops->exit(event, self);
+        case PERF_RECORD_LOST:
+                return ops->lost(event, self);
+        case PERF_RECORD_READ:
+                return ops->read(event, self);
+        case PERF_RECORD_THROTTLE:
+                return ops->throttle(event, self);
+        case PERF_RECORD_UNTHROTTLE:
+                return ops->unthrottle(event, self);
+        default:
+                self->unknown_events++;
+                return -1;
+        }
+}
+
+void perf_event_header__bswap(struct perf_event_header *self)
+{
+        self->type = bswap_32(self->type);
+        self->misc = bswap_16(self->misc);
+        self->size = bswap_16(self->size);
+}
+
+int perf_header__read_build_ids(struct perf_header *self,
+                                int input, u64 offset, u64 size)
+{
+        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;
+
+                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;
+
+                if (bev.header.misc & PERF_RECORD_MISC_KERNEL)
+                        head = &dsos__kernel;
+
+                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;
+                }
+
+                offset += bev.header.size;
+        }
+        err = 0;
+out:
+        return err;
+}
+
+static struct thread *perf_session__register_idle_thread(struct perf_session *self)
+{
+        struct thread *thread = perf_session__findnew(self, 0);
+
+        if (thread == NULL || thread__set_comm(thread, "swapper")) {
+                pr_err("problem inserting idle task.\n");
+                thread = NULL;
+        }
+
+        return thread;
+}
+
+int __perf_session__process_events(struct perf_session *self,
+                                   u64 data_offset, u64 data_size,
+                                   u64 file_size, struct perf_event_ops *ops)
+{
+        int err, mmap_prot, mmap_flags;
+        u64 head, shift;
+        u64 offset = 0;
+        size_t  page_size;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+
+        perf_event_ops__fill_defaults(ops);
+
+        page_size = sysconf(_SC_PAGESIZE);
+
+        head = data_offset;
+        shift = page_size * (head / page_size);
+        offset += shift;
+        head -= shift;
+
+        mmap_prot  = PROT_READ;
+        mmap_flags = MAP_SHARED;
+
+        if (self->header.needs_swap) {
+                mmap_prot  |= PROT_WRITE;
+                mmap_flags = MAP_PRIVATE;
+        }
+remap:
+        buf = mmap(NULL, page_size * self->mmap_window, mmap_prot,
+                   mmap_flags, self->fd, offset);
+        if (buf == MAP_FAILED) {
+                pr_err("failed to mmap file\n");
+                err = -errno;
+                goto out_err;
+        }
+
+more:
+        event = (event_t *)(buf + head);
+
+        if (self->header.needs_swap)
+                perf_event_header__bswap(&event->header);
+        size = event->header.size;
+        if (size == 0)
+                size = 8;
+
+        if (head + event->header.size >= page_size * self->mmap_window) {
+                int munmap_ret;
+
+                shift = page_size * (head / page_size);
+
+                munmap_ret = munmap(buf, page_size * self->mmap_window);
+                assert(munmap_ret == 0);
+
+                offset += shift;
+                head -= shift;
+                goto remap;
+        }
+
+        size = event->header.size;
+
+        dump_printf("\n%#Lx [%#x]: event: %d\n",
+                    offset + head, event->header.size, event->header.type);
+
+        if (size == 0 ||
+            perf_session__process_event(self, event, ops, offset, head) < 0) {
+                dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
+                            offset + 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;
+
+        if (offset + head >= data_offset + data_size)
+                goto done;
+
+        if (offset + head < file_size)
+                goto more;
+done:
+        err = 0;
+out_err:
+        return err;
+}
+
+int perf_session__process_events(struct perf_session *self,
+                                 struct perf_event_ops *ops)
+{
+        int err;
+
+        if (perf_session__register_idle_thread(self) == NULL)
+                return -ENOMEM;
+
+        if (!symbol_conf.full_paths) {
+                char bf[PATH_MAX];
+
+                if (getcwd(bf, sizeof(bf)) == NULL) {
+                        err = -errno;
+out_getcwd_err:
+                        pr_err("failed to get the current directory\n");
+                        goto out_err;
+                }
+                self->cwd = strdup(bf);
+                if (self->cwd == NULL) {
+                        err = -ENOMEM;
+                        goto 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);
+out_err:
+        return err;
+}
+
+bool perf_session__has_traces(struct perf_session *self, const char *msg)
+{
+        if (!(self->sample_type & PERF_SAMPLE_RAW)) {
+                pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
+                return false;
+        }
+
+        return true;
+}
+
+int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
+                                             const char *symbol_name,
+                                             u64 addr)
+{
+        char *bracket;
+        enum map_type i;
+
+        self->ref_reloc_sym.name = strdup(symbol_name);
+        if (self->ref_reloc_sym.name == NULL)
+                return -ENOMEM;
+
+        bracket = strchr(self->ref_reloc_sym.name, ']');
+        if (bracket)
+                *bracket = '\0';
+
+        self->ref_reloc_sym.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;
+        }
+
+        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;
+}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
new file mode 100644
index 000000000000..5c33417eebb3
--- /dev/null
+++ b/tools/perf/util/session.h
@@ -0,0 +1,89 @@
+#ifndef __PERF_SESSION_H
+#define __PERF_SESSION_H
+
+#include "event.h"
+#include "header.h"
+#include "symbol.h"
+#include "thread.h"
+#include <linux/rbtree.h>
+#include "../../../include/linux/perf_event.h"
+
+struct ip_callchain;
+struct thread;
+
+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;
+        u64                     sample_type;
+        struct ref_reloc_sym    ref_reloc_sym;
+        int                     fd;
+        int                     cwdlen;
+        char                    *cwd;
+        char filename[0];
+};
+
+typedef int (*event_op)(event_t *self, struct perf_session *session);
+
+struct perf_event_ops {
+        event_op sample,
+                 mmap,
+                 comm,
+                 fork,
+                 exit,
+                 lost,
+                 read,
+                 throttle,
+                 unthrottle;
+};
+
+struct perf_session *perf_session__new(const char *filename, int mode, bool force);
+void perf_session__delete(struct perf_session *self);
+
+void perf_event_header__bswap(struct perf_event_header *self);
+
+int __perf_session__process_events(struct perf_session *self,
+                                   u64 data_offset, u64 data_size, u64 size,
+                                   struct perf_event_ops *ops);
+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);
+
+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,
+                                             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)
+{
+        return __map_groups__create_kernel_maps(&self->kmaps,
+                                                self->vmlinux_maps, kernel);
+}
+
+static inline struct map *
+        perf_session__new_module_map(struct perf_session *self,
+                                     u64 start, const char *filename)
+{
+        return map_groups__new_module(&self->kmaps, start, filename);
+}
+#endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sigchain.h b/tools/perf/util/sigchain.h
index 618083bce0c6..1a53c11265fd 100644
--- a/tools/perf/util/sigchain.h
+++ b/tools/perf/util/sigchain.h
@@ -1,5 +1,5 @@
-#ifndef SIGCHAIN_H
-#define SIGCHAIN_H
+#ifndef __PERF_SIGCHAIN_H
+#define __PERF_SIGCHAIN_H
 
 typedef void (*sigchain_fun)(int);
 
@@ -8,4 +8,4 @@ int sigchain_pop(int sig);
 
 void sigchain_push_common(sigchain_fun f);
 
-#endif /* SIGCHAIN_H */
+#endif /* __PERF_SIGCHAIN_H */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
new file mode 100644
index 000000000000..cb0f327de9e8
--- /dev/null
+++ b/tools/perf/util/sort.c
@@ -0,0 +1,316 @@
+#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;
+int             sort__need_collapse = 0;
+int             sort__has_parent = 0;
+
+enum sort_type  sort__first_dimension;
+
+unsigned int dsos__col_width;
+unsigned int comms__col_width;
+unsigned int threads__col_width;
+static unsigned int parent_symbol__col_width;
+char * field_sep;
+
+LIST_HEAD(hist_entry__sort_list);
+
+struct sort_entry sort_thread = {
+        .header = "Command:  Pid",
+        .cmp    = sort__thread_cmp,
+        .print  = sort__thread_print,
+        .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,
+};
+
+struct sort_entry sort_dso = {
+        .header = "Shared Object",
+        .cmp    = sort__dso_cmp,
+        .print  = sort__dso_print,
+        .width  = &dsos__col_width,
+};
+
+struct sort_entry sort_sym = {
+        .header = "Symbol",
+        .cmp    = sort__sym_cmp,
+        .print  = sort__sym_print,
+};
+
+struct sort_entry sort_parent = {
+        .header = "Parent symbol",
+        .cmp    = sort__parent_cmp,
+        .print  = sort__parent_print,
+        .width  = &parent_symbol__col_width,
+};
+
+struct sort_dimension {
+        const char              *name;
+        struct sort_entry       *entry;
+        int                     taken;
+};
+
+static struct sort_dimension sort_dimensions[] = {
+        { .name = "pid",        .entry = &sort_thread,  },
+        { .name = "comm",       .entry = &sort_comm,    },
+        { .name = "dso",        .entry = &sort_dso,     },
+        { .name = "symbol",     .entry = &sort_sym,     },
+        { .name = "parent",     .entry = &sort_parent,  },
+};
+
+int64_t cmp_null(void *l, void *r)
+{
+        if (!l && !r)
+                return 0;
+        else if (!l)
+                return -1;
+        else
+                return 1;
+}
+
+/* --sort pid */
+
+int64_t
+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, ...)
+{
+        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 = '.';
+                        }
+                }
+                fputs(bf, fp);
+                free(bf);
+        }
+        va_end(ap);
+        return n;
+}
+
+size_t
+sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%*s:%5d", width - 6,
+                              self->thread->comm ?: "", self->thread->pid);
+}
+
+size_t
+sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%*s", width, self->thread->comm);
+}
+
+/* --sort dso */
+
+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;
+        const char *dso_name_l, *dso_name_r;
+
+        if (!dso_l || !dso_r)
+                return cmp_null(dso_l, dso_r);
+
+        if (verbose) {
+                dso_name_l = dso_l->long_name;
+                dso_name_r = dso_r->long_name;
+        } else {
+                dso_name_l = dso_l->short_name;
+                dso_name_r = dso_r->short_name;
+        }
+
+        return strcmp(dso_name_l, dso_name_r);
+}
+
+size_t
+sort__dso_print(FILE *fp, struct hist_entry *self, 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);
+        }
+
+        return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
+}
+
+/* --sort symbol */
+
+int64_t
+sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        u64 ip_l, ip_r;
+
+        if (left->sym == right->sym)
+                return 0;
+
+        ip_l = left->sym ? left->sym->start : left->ip;
+        ip_r = right->sym ? right->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)
+{
+        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);
+        }
+
+        ret += repsep_fprintf(fp, "[%c] ", self->level);
+        if (self->sym)
+                ret += repsep_fprintf(fp, "%s", self->sym->name);
+        else
+                ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
+
+        return ret;
+}
+
+/* --sort comm */
+
+int64_t
+sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+int64_t
+sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        char *comm_l = left->thread->comm;
+        char *comm_r = right->thread->comm;
+
+        if (!comm_l || !comm_r)
+                return cmp_null(comm_l, comm_r);
+
+        return strcmp(comm_l, comm_r);
+}
+
+/* --sort parent */
+
+int64_t
+sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct symbol *sym_l = left->parent;
+        struct symbol *sym_r = right->parent;
+
+        if (!sym_l || !sym_r)
+                return cmp_null(sym_l, sym_r);
+
+        return strcmp(sym_l->name, sym_r->name);
+}
+
+size_t
+sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%-*s", width,
+                              self->parent ? self->parent->name : "[other]");
+}
+
+int sort_dimension__add(const char *tok)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
+                struct sort_dimension *sd = &sort_dimensions[i];
+
+                if (sd->taken)
+                        continue;
+
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
+
+                if (sd->entry->collapse)
+                        sort__need_collapse = 1;
+
+                if (sd->entry == &sort_parent) {
+                        int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
+                        if (ret) {
+                                char err[BUFSIZ];
+
+                                regerror(ret, &parent_regex, err, sizeof(err));
+                                fprintf(stderr, "Invalid regex: %s\n%s",
+                                        parent_pattern, err);
+                                exit(-1);
+                        }
+                        sort__has_parent = 1;
+                }
+
+                if (list_empty(&hist_entry__sort_list)) {
+                        if (!strcmp(sd->name, "pid"))
+                                sort__first_dimension = SORT_PID;
+                        else if (!strcmp(sd->name, "comm"))
+                                sort__first_dimension = SORT_COMM;
+                        else if (!strcmp(sd->name, "dso"))
+                                sort__first_dimension = SORT_DSO;
+                        else if (!strcmp(sd->name, "symbol"))
+                                sort__first_dimension = SORT_SYM;
+                        else if (!strcmp(sd->name, "parent"))
+                                sort__first_dimension = SORT_PARENT;
+                }
+
+                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+                sd->taken = 1;
+
+                return 0;
+        }
+
+        return -ESRCH;
+}
+
+void setup_sorting(const char * const usagestr[], const struct option *opts)
+{
+        char *tmp, *tok, *str = strdup(sort_order);
+
+        for (tok = strtok_r(str, ", ", &tmp);
+                        tok; tok = strtok_r(NULL, ", ", &tmp)) {
+                if (sort_dimension__add(tok) < 0) {
+                        error("Unknown --sort key: `%s'", tok);
+                        usage_with_options(usagestr, opts);
+                }
+        }
+
+        free(str);
+}
+
+void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
+                             const char *list_name, FILE *fp)
+{
+        if (list && strlist__nr_entries(list) == 1) {
+                if (fp != NULL)
+                        fprintf(fp, "# %s: %s\n", list_name,
+                                strlist__entry(list, 0)->s);
+                self->elide = true;
+        }
+}
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
new file mode 100644
index 000000000000..753f9ea99fb0
--- /dev/null
+++ b/tools/perf/util/sort.h
@@ -0,0 +1,107 @@
+#ifndef __PERF_SORT_H
+#define __PERF_SORT_H
+#include "../builtin.h"
+
+#include "util.h"
+
+#include "color.h"
+#include <linux/list.h>
+#include "cache.h"
+#include <linux/rbtree.h>
+#include "symbol.h"
+#include "string.h"
+#include "callchain.h"
+#include "strlist.h"
+#include "values.h"
+
+#include "../perf.h"
+#include "debug.h"
+#include "header.h"
+
+#include "parse-options.h"
+#include "parse-events.h"
+
+#include "thread.h"
+#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 int sort__need_collapse;
+extern int sort__has_parent;
+extern char *field_sep;
+extern struct sort_entry sort_comm;
+extern struct sort_entry sort_dso;
+extern struct sort_entry sort_sym;
+extern struct sort_entry sort_parent;
+extern unsigned int dsos__col_width;
+extern unsigned int comms__col_width;
+extern unsigned int threads__col_width;
+extern enum sort_type sort__first_dimension;
+
+struct hist_entry {
+        struct rb_node          rb_node;
+        u64                     count;
+        struct thread           *thread;
+        struct map              *map;
+        struct symbol           *sym;
+        u64                     ip;
+        char                    level;
+        struct symbol     *parent;
+        struct callchain_node   callchain;
+        union {
+                unsigned long     position;
+                struct hist_entry *pair;
+                struct rb_root    sorted_chain;
+        };
+};
+
+enum sort_type {
+        SORT_PID,
+        SORT_COMM,
+        SORT_DSO,
+        SORT_SYM,
+        SORT_PARENT
+};
+
+/*
+ * configurable sorting bits
+ */
+
+struct sort_entry {
+        struct list_head list;
+
+        const char *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;
+        bool    elide;
+};
+
+extern struct sort_entry sort_thread;
+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);
+extern size_t sort__sym_print(FILE *, struct hist_entry *, unsigned int __used);
+extern int64_t cmp_null(void *, void *);
+extern int64_t sort__thread_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__comm_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__comm_collapse(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__dso_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__sym_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__parent_cmp(struct hist_entry *, struct hist_entry *);
+extern size_t sort__parent_print(FILE *, struct hist_entry *, unsigned int);
+extern int sort_dimension__add(const char *);
+void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
+                             const char *list_name, FILE *fp);
+
+#endif  /* __PERF_SORT_H */
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
index d2aa86c014c1..a3d121d6c83e 100644
--- a/tools/perf/util/strbuf.h
+++ b/tools/perf/util/strbuf.h
@@ -1,5 +1,5 @@
-#ifndef STRBUF_H
-#define STRBUF_H
+#ifndef __PERF_STRBUF_H
+#define __PERF_STRBUF_H
 
 /*
  * Strbuf's can be use in many ways: as a byte array, or to store arbitrary
@@ -134,4 +134,4 @@ extern int launch_editor(const char *path, struct strbuf *buffer, const char *co
 extern int strbuf_branchname(struct strbuf *sb, const char *name);
 extern int strbuf_check_branch_ref(struct strbuf *sb, const char *name);
 
-#endif /* STRBUF_H */
+#endif /* __PERF_STRBUF_H */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index c93eca9a7be3..a175949ed216 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,4 +1,5 @@
 #include "string.h"
+#include "util.h"
 
 static int hex(char ch)
 {
@@ -32,3 +33,307 @@ int hex2u64(const char *ptr, u64 *long_val)
 
         return p - ptr;
 }
+
+char *strxfrchar(char *s, char from, char to)
+{
+        char *p = s;
+
+        while ((p = strchr(p, from)) != NULL)
+                *p++ = to;
+
+        return s;
+}
+
+#define K 1024LL
+/*
+ * perf_atoll()
+ * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB")
+ * and return its numeric value
+ */
+s64 perf_atoll(const char *str)
+{
+        unsigned int i;
+        s64 length = -1, unit = 1;
+
+        if (!isdigit(str[0]))
+                goto out_err;
+
+        for (i = 1; i < strlen(str); i++) {
+                switch (str[i]) {
+                case 'B':
+                case 'b':
+                        break;
+                case 'K':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto kilo;
+                case 'k':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+kilo:
+                        unit = K;
+                        break;
+                case 'M':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto mega;
+                case 'm':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+mega:
+                        unit = K * K;
+                        break;
+                case 'G':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto giga;
+                case 'g':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+giga:
+                        unit = K * K * K;
+                        break;
+                case 'T':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto tera;
+                case 't':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+tera:
+                        unit = K * K * K * K;
+                        break;
+                case '\0':      /* only specified figures */
+                        unit = 1;
+                        break;
+                default:
+                        if (!isdigit(str[i]))
+                                goto out_err;
+                        break;
+                }
+        }
+
+        length = atoll(str) * unit;
+        goto out;
+
+out_err:
+        length = -1;
+out:
+        return length;
+}
+
+/*
+ * Helper function for splitting a string into an argv-like array.
+ * originaly copied from lib/argv_split.c
+ */
+static const char *skip_sep(const char *cp)
+{
+        while (*cp && isspace(*cp))
+                cp++;
+
+        return cp;
+}
+
+static const char *skip_arg(const char *cp)
+{
+        while (*cp && !isspace(*cp))
+                cp++;
+
+        return cp;
+}
+
+static int count_argc(const char *str)
+{
+        int count = 0;
+
+        while (*str) {
+                str = skip_sep(str);
+                if (*str) {
+                        count++;
+                        str = skip_arg(str);
+                }
+        }
+
+        return count;
+}
+
+/**
+ * argv_free - free an argv
+ * @argv - the argument vector to be freed
+ *
+ * Frees an argv and the strings it points to.
+ */
+void argv_free(char **argv)
+{
+        char **p;
+        for (p = argv; *p; p++)
+                free(*p);
+
+        free(argv);
+}
+
+/**
+ * argv_split - split a string at whitespace, returning an argv
+ * @str: the string to be split
+ * @argcp: returned argument count
+ *
+ * Returns an array of pointers to strings which are split out from
+ * @str.  This is performed by strictly splitting on white-space; no
+ * quote processing is performed.  Multiple whitespace characters are
+ * considered to be a single argument separator.  The returned array
+ * is always NULL-terminated.  Returns NULL on memory allocation
+ * failure.
+ */
+char **argv_split(const char *str, int *argcp)
+{
+        int argc = count_argc(str);
+        char **argv = zalloc(sizeof(*argv) * (argc+1));
+        char **argvp;
+
+        if (argv == NULL)
+                goto out;
+
+        if (argcp)
+                *argcp = argc;
+
+        argvp = argv;
+
+        while (*str) {
+                str = skip_sep(str);
+
+                if (*str) {
+                        const char *p = str;
+                        char *t;
+
+                        str = skip_arg(str);
+
+                        t = strndup(p, str-p);
+                        if (t == NULL)
+                                goto fail;
+                        *argvp++ = t;
+                }
+        }
+        *argvp = NULL;
+
+out:
+        return argv;
+
+fail:
+        argv_free(argv);
+        return NULL;
+}
+
+/* Character class matching */
+static bool __match_charclass(const char *pat, char c, const char **npat)
+{
+        bool complement = false, ret = true;
+
+        if (*pat == '!') {
+                complement = true;
+                pat++;
+        }
+        if (*pat++ == c)        /* First character is special */
+                goto end;
+
+        while (*pat && *pat != ']') {   /* Matching */
+                if (*pat == '-' && *(pat + 1) != ']') { /* Range */
+                        if (*(pat - 1) <= c && c <= *(pat + 1))
+                                goto end;
+                        if (*(pat - 1) > *(pat + 1))
+                                goto error;
+                        pat += 2;
+                } else if (*pat++ == c)
+                        goto end;
+        }
+        if (!*pat)
+                goto error;
+        ret = false;
+
+end:
+        while (*pat && *pat != ']')     /* Searching closing */
+                pat++;
+        if (!*pat)
+                goto error;
+        *npat = pat + 1;
+        return complement ? !ret : ret;
+
+error:
+        return false;
+}
+
+/* Glob/lazy pattern matching */
+static bool __match_glob(const char *str, const char *pat, bool ignore_space)
+{
+        while (*str && *pat && *pat != '*') {
+                if (ignore_space) {
+                        /* Ignore spaces for lazy matching */
+                        if (isspace(*str)) {
+                                str++;
+                                continue;
+                        }
+                        if (isspace(*pat)) {
+                                pat++;
+                                continue;
+                        }
+                }
+                if (*pat == '?') {      /* Matches any single character */
+                        str++;
+                        pat++;
+                        continue;
+                } else if (*pat == '[') /* Character classes/Ranges */
+                        if (__match_charclass(pat + 1, *str, &pat)) {
+                                str++;
+                                continue;
+                        } else
+                                return false;
+                else if (*pat == '\\') /* Escaped char match as normal char */
+                        pat++;
+                if (*str++ != *pat++)
+                        return false;
+        }
+        /* Check wild card */
+        if (*pat == '*') {
+                while (*pat == '*')
+                        pat++;
+                if (!*pat)      /* Tail wild card matches all */
+                        return true;
+                while (*str)
+                        if (strglobmatch(str++, pat))
+                                return true;
+        }
+        return !*str && !*pat;
+}
+
+/**
+ * strglobmatch - glob expression pattern matching
+ * @str: the target string to match
+ * @pat: the pattern string to match
+ *
+ * This returns true if the @str matches @pat. @pat can includes wildcards
+ * ('*','?') and character classes ([CHARS], complementation and ranges are
+ * also supported). Also, this supports escape character ('\') to use special
+ * characters as normal character.
+ *
+ * Note: if @pat syntax is broken, this always returns false.
+ */
+bool strglobmatch(const char *str, const char *pat)
+{
+        return __match_glob(str, pat, false);
+}
+
+/**
+ * strlazymatch - matching pattern strings lazily with glob pattern
+ * @str: the target string to match
+ * @pat: the pattern string to match
+ *
+ * This is similar to strglobmatch, except this ignores spaces in
+ * the target string.
+ */
+bool strlazymatch(const char *str, const char *pat)
+{
+        return __match_glob(str, pat, true);
+}
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
index bf39dfadfd24..542e44de3719 100644
--- a/tools/perf/util/string.h
+++ b/tools/perf/util/string.h
@@ -1,11 +1,18 @@
-#ifndef _PERF_STRING_H_
-#define _PERF_STRING_H_
+#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
+#endif /* __PERF_STRING_H */
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
index 7ad38171dc2b..6783a2043555 100644
--- a/tools/perf/util/strlist.c
+++ b/tools/perf/util/strlist.c
@@ -102,7 +102,7 @@ void strlist__remove(struct strlist *self, struct str_node *sn)
         str_node__delete(sn, self->dupstr);
 }
 
-bool strlist__has_entry(struct strlist *self, const char *entry)
+struct str_node *strlist__find(struct strlist *self, const char *entry)
 {
         struct rb_node **p = &self->entries.rb_node;
         struct rb_node *parent = NULL;
@@ -120,10 +120,10 @@ bool strlist__has_entry(struct strlist *self, const char *entry)
                 else if (rc < 0)
                         p = &(*p)->rb_right;
                 else
-                        return true;
+                        return sn;
         }
 
-        return false;
+        return NULL;
 }
 
 static int strlist__parse_list_entry(struct strlist *self, const char *s)
diff --git a/tools/perf/util/strlist.h b/tools/perf/util/strlist.h
index 921818e44a54..3ba839007d2c 100644
--- a/tools/perf/util/strlist.h
+++ b/tools/perf/util/strlist.h
@@ -1,5 +1,5 @@
-#ifndef STRLIST_H_
-#define STRLIST_H_
+#ifndef __PERF_STRLIST_H
+#define __PERF_STRLIST_H
 
 #include <linux/rbtree.h>
 #include <stdbool.h>
@@ -23,7 +23,12 @@ int strlist__load(struct strlist *self, const char *filename);
 int strlist__add(struct strlist *self, const char *str);
 
 struct str_node *strlist__entry(const struct strlist *self, unsigned int idx);
-bool strlist__has_entry(struct strlist *self, const char *entry);
+struct str_node *strlist__find(struct strlist *self, const char *entry);
+
+static inline bool strlist__has_entry(struct strlist *self, const char *entry)
+{
+        return strlist__find(self, entry) != NULL;
+}
 
 static inline bool strlist__empty(const struct strlist *self)
 {
@@ -35,5 +40,39 @@ static inline unsigned int strlist__nr_entries(const struct strlist *self)
         return self->nr_entries;
 }
 
+/* For strlist iteration */
+static inline struct str_node *strlist__first(struct strlist *self)
+{
+        struct rb_node *rn = rb_first(&self->entries);
+        return rn ? rb_entry(rn, struct str_node, rb_node) : NULL;
+}
+static inline struct str_node *strlist__next(struct str_node *sn)
+{
+        struct rb_node *rn;
+        if (!sn)
+                return NULL;
+        rn = rb_next(&sn->rb_node);
+        return rn ? rb_entry(rn, struct str_node, rb_node) : NULL;
+}
+
+/**
+ * strlist_for_each      - iterate over a strlist
+ * @pos:        the &struct str_node to use as a loop cursor.
+ * @self:       the &struct strlist for loop.
+ */
+#define strlist__for_each(pos, self)    \
+        for (pos = strlist__first(self); pos; pos = strlist__next(pos))
+
+/**
+ * strlist_for_each_safe - iterate over a strlist safe against removal of
+ *                         str_node
+ * @pos:        the &struct str_node to use as a loop cursor.
+ * @n:          another &struct str_node to use as temporary storage.
+ * @self:       the &struct strlist for loop.
+ */
+#define strlist__for_each_safe(pos, n, self)    \
+        for (pos = strlist__first(self), n = strlist__next(pos); pos;\
+             pos = n, n = strlist__next(n))
+
 int strlist__parse_list(struct strlist *self, const char *s);
-#endif /* STRLIST_H_ */
+#endif /* __PERF_STRLIST_H */
diff --git a/tools/perf/util/svghelper.h b/tools/perf/util/svghelper.h
index cd93195aedb3..e0781989cc31 100644
--- a/tools/perf/util/svghelper.h
+++ b/tools/perf/util/svghelper.h
@@ -1,5 +1,5 @@
-#ifndef _INCLUDE_GUARD_SVG_HELPER_
-#define _INCLUDE_GUARD_SVG_HELPER_
+#ifndef __PERF_SVGHELPER_H
+#define __PERF_SVGHELPER_H
 
 #include "types.h"
 
@@ -25,4 +25,4 @@ extern void svg_close(void);
 
 extern int svg_page_width;
 
-#endif
+#endif /* __PERF_SVGHELPER_H */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 226f44a2357d..c458c4a371d1 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,111 +1,234 @@
 #include "util.h"
 #include "../perf.h"
+#include "sort.h"
 #include "string.h"
 #include "symbol.h"
+#include "thread.h"
 
 #include "debug.h"
 
+#include <asm/bug.h>
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
+#include <limits.h>
+#include <sys/utsname.h>
 
-const char *sym_hist_filter;
+#ifndef NT_GNU_BUILD_ID
+#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 struct symbol *symbol__new(u64 start, u64 len,
-                                  const char *name, unsigned int priv_size,
-                                  u64 obj_start, int v)
+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 vmlinux_path__nr_entries;
+static char **vmlinux_path;
+
+struct symbol_conf symbol_conf = {
+        .exclude_other    = true,
+        .use_modules      = true,
+        .try_vmlinux_path = true,
+};
+
+bool dso__loaded(const struct dso *self, enum map_type type)
 {
-        size_t namelen = strlen(name) + 1;
-        struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
+        return self->loaded & (1 << type);
+}
 
-        if (!self)
-                return NULL;
+bool dso__sorted_by_name(const struct dso *self, enum map_type type)
+{
+        return self->sorted_by_name & (1 << type);
+}
+
+static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
+{
+        self->sorted_by_name |= (1 << type);
+}
+
+bool symbol_type__is_a(char symbol_type, enum map_type map_type)
+{
+        switch (map_type) {
+        case MAP__FUNCTION:
+                return symbol_type == 'T' || symbol_type == 'W';
+        case MAP__VARIABLE:
+                return symbol_type == 'D' || symbol_type == 'd';
+        default:
+                return false;
+        }
+}
 
-        if (v >= 2)
-                printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
-                        (u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
+static void symbols__fixup_end(struct rb_root *self)
+{
+        struct rb_node *nd, *prevnd = rb_first(self);
+        struct symbol *curr, *prev;
 
-        self->obj_start= obj_start;
-        self->hist = NULL;
-        self->hist_sum = 0;
+        if (prevnd == NULL)
+                return;
 
-        if (sym_hist_filter && !strcmp(name, sym_hist_filter))
-                self->hist = calloc(sizeof(u64), len);
+        curr = rb_entry(prevnd, struct symbol, rb_node);
 
-        if (priv_size) {
-                memset(self, 0, priv_size);
-                self = ((void *)self) + priv_size;
+        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
+                prev = curr;
+                curr = rb_entry(nd, struct symbol, rb_node);
+
+                if (prev->end == prev->start)
+                        prev->end = curr->start - 1;
         }
+
+        /* Last entry */
+        if (curr->end == curr->start)
+                curr->end = roundup(curr->start, 4096);
+}
+
+static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
+{
+        struct map *prev, *curr;
+        struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
+
+        if (prevnd == NULL)
+                return;
+
+        curr = rb_entry(prevnd, struct map, rb_node);
+
+        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
+                prev = curr;
+                curr = rb_entry(nd, struct map, rb_node);
+                prev->end = curr->start - 1;
+        }
+
+        /*
+         * We still haven't the actual symbols, so guess the
+         * last map final address.
+         */
+        curr->end = ~0UL;
+}
+
+static void map_groups__fixup_end(struct map_groups *self)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                __map_groups__fixup_end(self, i);
+}
+
+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);
+        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;
+
+        pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
+
         memcpy(self->name, name, namelen);
 
         return self;
 }
 
-static void symbol__delete(struct symbol *self, unsigned int priv_size)
+void symbol__delete(struct symbol *self)
 {
-        free(((void *)self) - priv_size);
+        free(((void *)self) - symbol_conf.priv_size);
 }
 
 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 {
-        if (!self->module)
-                return fprintf(fp, " %llx-%llx %s\n",
+        return fprintf(fp, " %llx-%llx %s\n",
                        self->start, self->end, self->name);
-        else
-                return fprintf(fp, " %llx-%llx %s \t[%s]\n",
-                       self->start, self->end, self->name, self->module->name);
 }
 
-struct dso *dso__new(const char *name, unsigned int sym_priv_size)
+void dso__set_long_name(struct dso *self, char *name)
 {
-        struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+        if (name == NULL)
+                return;
+        self->long_name = name;
+        self->long_name_len = strlen(name);
+}
+
+static void dso__set_short_name(struct dso *self, const char *name)
+{
+        if (name == NULL)
+                return;
+        self->short_name = name;
+        self->short_name_len = strlen(name);
+}
+
+static void dso__set_basename(struct dso *self)
+{
+        dso__set_short_name(self, basename(self->long_name));
+}
+
+struct dso *dso__new(const char *name)
+{
+        struct dso *self = zalloc(sizeof(*self) + strlen(name) + 1);
 
         if (self != NULL) {
+                int i;
                 strcpy(self->name, name);
-                self->syms = RB_ROOT;
-                self->sym_priv_size = sym_priv_size;
-                self->find_symbol = dso__find_symbol;
+                dso__set_long_name(self, self->name);
+                dso__set_short_name(self, self->name);
+                for (i = 0; i < MAP__NR_TYPES; ++i)
+                        self->symbols[i] = self->symbol_names[i] = RB_ROOT;
                 self->slen_calculated = 0;
                 self->origin = DSO__ORIG_NOT_FOUND;
+                self->loaded = 0;
+                self->sorted_by_name = 0;
+                self->has_build_id = 0;
         }
 
         return self;
 }
 
-static void dso__delete_symbols(struct dso *self)
+static void symbols__delete(struct rb_root *self)
 {
         struct symbol *pos;
-        struct rb_node *next = rb_first(&self->syms);
+        struct rb_node *next = rb_first(self);
 
         while (next) {
                 pos = rb_entry(next, struct symbol, rb_node);
                 next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, &self->syms);
-                symbol__delete(pos, self->sym_priv_size);
+                rb_erase(&pos->rb_node, self);
+                symbol__delete(pos);
         }
 }
 
 void dso__delete(struct dso *self)
 {
-        dso__delete_symbols(self);
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                symbols__delete(&self->symbols[i]);
+        if (self->long_name != self->name)
+                free(self->long_name);
         free(self);
 }
 
-static void dso__insert_symbol(struct dso *self, struct symbol *sym)
+void dso__set_build_id(struct dso *self, void *build_id)
 {
-        struct rb_node **p = &self->syms.rb_node;
+        memcpy(self->build_id, build_id, sizeof(self->build_id));
+        self->has_build_id = 1;
+}
+
+static void symbols__insert(struct rb_root *self, struct symbol *sym)
+{
+        struct rb_node **p = &self->rb_node;
         struct rb_node *parent = NULL;
         const u64 ip = sym->start;
         struct symbol *s;
@@ -119,17 +242,17 @@ static void dso__insert_symbol(struct dso *self, struct symbol *sym)
                         p = &(*p)->rb_right;
         }
         rb_link_node(&sym->rb_node, parent, p);
-        rb_insert_color(&sym->rb_node, &self->syms);
+        rb_insert_color(&sym->rb_node, self);
 }
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip)
+static struct symbol *symbols__find(struct rb_root *self, u64 ip)
 {
         struct rb_node *n;
 
         if (self == NULL)
                 return NULL;
 
-        n = self->syms.rb_node;
+        n = self->rb_node;
 
         while (n) {
                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
@@ -145,12 +268,120 @@ struct symbol *dso__find_symbol(struct dso *self, u64 ip)
         return NULL;
 }
 
-size_t dso__fprintf(struct dso *self, FILE *fp)
+struct symbol_name_rb_node {
+        struct rb_node  rb_node;
+        struct symbol   sym;
+};
+
+static void symbols__insert_by_name(struct rb_root *self, struct symbol *sym)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct symbol_name_rb_node *symn = ((void *)sym) - sizeof(*parent), *s;
+
+        while (*p != NULL) {
+                parent = *p;
+                s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
+                if (strcmp(sym->name, s->sym.name) < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&symn->rb_node, parent, p);
+        rb_insert_color(&symn->rb_node, self);
+}
+
+static void symbols__sort_by_name(struct rb_root *self, struct rb_root *source)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(source); nd; nd = rb_next(nd)) {
+                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+                symbols__insert_by_name(self, pos);
+        }
+}
+
+static struct symbol *symbols__find_by_name(struct rb_root *self, const char *name)
+{
+        struct rb_node *n;
+
+        if (self == NULL)
+                return NULL;
+
+        n = self->rb_node;
+
+        while (n) {
+                struct symbol_name_rb_node *s;
+                int cmp;
+
+                s = rb_entry(n, struct symbol_name_rb_node, rb_node);
+                cmp = strcmp(name, s->sym.name);
+
+                if (cmp < 0)
+                        n = n->rb_left;
+                else if (cmp > 0)
+                        n = n->rb_right;
+                else
+                        return &s->sym;
+        }
+
+        return NULL;
+}
+
+struct symbol *dso__find_symbol(struct dso *self,
+                                enum map_type type, u64 addr)
+{
+        return symbols__find(&self->symbols[type], addr);
+}
+
+struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
+                                        const char *name)
+{
+        return symbols__find_by_name(&self->symbol_names[type], name);
+}
+
+void dso__sort_by_name(struct dso *self, enum map_type type)
+{
+        dso__set_sorted_by_name(self, type);
+        return symbols__sort_by_name(&self->symbol_names[type],
+                                     &self->symbols[type]);
+}
+
+int build_id__sprintf(const u8 *self, int len, char *bf)
+{
+        char *bid = bf;
+        const u8 *raw = self;
+        int i;
+
+        for (i = 0; i < len; ++i) {
+                sprintf(bid, "%02x", *raw);
+                ++raw;
+                bid += 2;
+        }
+
+        return raw - self;
+}
+
+size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
 {
-        size_t ret = fprintf(fp, "dso: %s\n", self->name);
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
+        return fprintf(fp, "%s", sbuild_id);
+}
 
+size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
+{
         struct rb_node *nd;
-        for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
+        size_t ret = fprintf(fp, "dso: %s (", self->short_name);
+
+        if (self->short_name != self->long_name)
+                ret += fprintf(fp, "%s, ", self->long_name);
+        ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
+                       self->loaded ? "" : "NOT ");
+        ret += dso__fprintf_buildid(self, fp);
+        ret += fprintf(fp, ")\n");
+        for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
                 ret += symbol__fprintf(pos, fp);
         }
@@ -158,22 +389,23 @@ size_t dso__fprintf(struct dso *self, FILE *fp)
         return ret;
 }
 
-static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int v)
+int kallsyms__parse(const char *filename, void *arg,
+                    int (*process_symbol)(void *arg, const char *name,
+                                                     char type, u64 start))
 {
-        struct rb_node *nd, *prevnd;
         char *line = NULL;
         size_t n;
-        FILE *file = fopen("/proc/kallsyms", "r");
-        int count = 0;
+        int err = 0;
+        FILE *file = fopen(filename, "r");
 
         if (file == NULL)
                 goto out_failure;
 
         while (!feof(file)) {
                 u64 start;
-                struct symbol *sym;
                 int line_len, len;
                 char symbol_type;
+                char *symbol_name;
 
                 line_len = getline(&line, &n, file);
                 if (line_len < 0)
@@ -191,64 +423,168 @@ static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int v)
                         continue;
 
                 symbol_type = toupper(line[len]);
-                /*
-                 * We're interested only in code ('T'ext)
-                 */
-                if (symbol_type != 'T' && symbol_type != 'W')
-                        continue;
-                /*
-                 * Well fix up the end later, when we have all sorted.
-                 */
-                sym = symbol__new(start, 0xdead, line + len + 2,
-                                  self->sym_priv_size, 0, v);
+                symbol_name = line + len + 2;
 
-                if (sym == NULL)
-                        goto out_delete_line;
-
-                if (filter && filter(self, sym))
-                        symbol__delete(sym, self->sym_priv_size);
-                else {
-                        dso__insert_symbol(self, sym);
-                        count++;
-                }
+                err = process_symbol(arg, symbol_name, symbol_type, start);
+                if (err)
+                        break;
         }
 
+        free(line);
+        fclose(file);
+        return err;
+
+out_failure:
+        return -1;
+}
+
+struct process_kallsyms_args {
+        struct map *map;
+        struct dso *dso;
+};
+
+static int map__process_kallsym_symbol(void *arg, const char *name,
+                                       char type, u64 start)
+{
+        struct symbol *sym;
+        struct process_kallsyms_args *a = arg;
+        struct rb_root *root = &a->dso->symbols[a->map->type];
+
+        if (!symbol_type__is_a(type, a->map->type))
+                return 0;
+
         /*
-         * Now that we have all sorted out, just set the ->end of all
-         * symbols
+         * Will fix up the end later, when we have all symbols sorted.
          */
-        prevnd = rb_first(&self->syms);
+        sym = symbol__new(start, 0, name);
 
-        if (prevnd == NULL)
-                goto out_delete_line;
+        if (sym == NULL)
+                return -ENOMEM;
+        /*
+         * We will pass the symbols to the filter later, in
+         * map__split_kallsyms, when we have split the maps per module
+         */
+        symbols__insert(root, sym);
+        return 0;
+}
 
-        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
-                struct symbol *prev = rb_entry(prevnd, struct symbol, rb_node),
-                              *curr = rb_entry(nd, struct symbol, rb_node);
+/*
+ * Loads the function entries in /proc/kallsyms into kernel_map->dso,
+ * so that we can in the next step set the symbol ->end address and then
+ * call kernel_maps__split_kallsyms.
+ */
+static int dso__load_all_kallsyms(struct dso *self, const char *filename,
+                                  struct map *map)
+{
+        struct process_kallsyms_args args = { .map = map, .dso = self, };
+        return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
+}
 
-                prev->end = curr->start - 1;
-                prevnd = nd;
-        }
+/*
+ * Split the symbols into maps, making sure there are no overlaps, i.e. the
+ * kernel range is broken in several maps, named [kernel].N, as we don't have
+ * the original ELF section names vmlinux have.
+ */
+static int dso__split_kallsyms(struct dso *self, struct map *map,
+                               symbol_filter_t filter)
+{
+        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct map *curr_map = map;
+        struct symbol *pos;
+        int count = 0;
+        struct rb_root *root = &self->symbols[map->type];
+        struct rb_node *next = rb_first(root);
+        int kernel_range = 0;
 
-        free(line);
-        fclose(file);
+        while (next) {
+                char *module;
+
+                pos = rb_entry(next, struct symbol, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                module = strchr(pos->name, '\t');
+                if (module) {
+                        if (!symbol_conf.use_modules)
+                                goto discard_symbol;
+
+                        *module++ = '\0';
+
+                        if (strcmp(curr_map->dso->short_name, module)) {
+                                curr_map = map_groups__find_by_name(kmaps, map->type, module);
+                                if (curr_map == NULL) {
+                                        pr_debug("/proc/{kallsyms,modules} "
+                                                 "inconsistency while looking "
+                                                 "for \"%s\" module!\n", module);
+                                        return -1;
+                                }
+
+                                if (curr_map->dso->loaded)
+                                        goto discard_symbol;
+                        }
+                        /*
+                         * So that we look just like we get from .ko files,
+                         * i.e. not prelinked, relative to map->start.
+                         */
+                        pos->start = curr_map->map_ip(curr_map, pos->start);
+                        pos->end   = curr_map->map_ip(curr_map, pos->end);
+                } else if (curr_map != map) {
+                        char dso_name[PATH_MAX];
+                        struct dso *dso;
+
+                        snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
+                                 kernel_range++);
+
+                        dso = dso__new(dso_name);
+                        if (dso == NULL)
+                                return -1;
+
+                        curr_map = map__new2(pos->start, dso, map->type);
+                        if (curr_map == NULL) {
+                                dso__delete(dso);
+                                return -1;
+                        }
+
+                        curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
+                        map_groups__insert(kmaps, curr_map);
+                        ++kernel_range;
+                }
+
+                if (filter && filter(curr_map, pos)) {
+discard_symbol:         rb_erase(&pos->rb_node, root);
+                        symbol__delete(pos);
+                } else {
+                        if (curr_map != map) {
+                                rb_erase(&pos->rb_node, root);
+                                symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
+                        }
+                        count++;
+                }
+        }
 
         return count;
+}
 
-out_delete_line:
-        free(line);
-out_failure:
-        return -1;
+int dso__load_kallsyms(struct dso *self, const char *filename,
+                       struct map *map, symbol_filter_t filter)
+{
+        if (dso__load_all_kallsyms(self, filename, map) < 0)
+                return -1;
+
+        symbols__fixup_end(&self->symbols[map->type]);
+        self->origin = DSO__ORIG_KERNEL;
+
+        return dso__split_kallsyms(self, map, filter);
 }
 
-static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int v)
+static int dso__load_perf_map(struct dso *self, struct map *map,
+                              symbol_filter_t filter)
 {
         char *line = NULL;
         size_t n;
         FILE *file;
         int nr_syms = 0;
 
-        file = fopen(self->name, "r");
+        file = fopen(self->long_name, "r");
         if (file == NULL)
                 goto out_failure;
 
@@ -278,16 +614,15 @@ static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int v)
                 if (len + 2 >= line_len)
                         continue;
 
-                sym = symbol__new(start, size, line + len,
-                                  self->sym_priv_size, start, v);
+                sym = symbol__new(start, size, line + len);
 
                 if (sym == NULL)
                         goto out_delete_line;
 
-                if (filter && filter(self, sym))
-                        symbol__delete(sym, self->sym_priv_size);
+                if (filter && filter(map, sym))
+                        symbol__delete(sym);
                 else {
-                        dso__insert_symbol(self, sym);
+                        symbols__insert(&self->symbols[map->type], sym);
                         nr_syms++;
                 }
         }
@@ -327,6 +662,13 @@ static inline int elf_sym__is_function(const GElf_Sym *sym)
                sym->st_shndx != SHN_UNDEF;
 }
 
+static inline bool elf_sym__is_object(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_OBJECT &&
+                sym->st_name != 0 &&
+                sym->st_shndx != SHN_UNDEF;
+}
+
 static inline int elf_sym__is_label(const GElf_Sym *sym)
 {
         return elf_sym__type(sym) == STT_NOTYPE &&
@@ -347,6 +689,12 @@ static inline int elf_sec__is_text(const GElf_Shdr *shdr,
         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 }
 
+static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
+                                    const Elf_Data *secstrs)
+{
+        return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
+}
+
 static inline const char *elf_sym__name(const GElf_Sym *sym,
                                         const Elf_Data *symstrs)
 {
@@ -393,7 +741,8 @@ static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
-static int dso__synthesize_plt_symbols(struct  dso *self, int v)
+static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
+                                       symbol_filter_t filter)
 {
         uint32_t nr_rel_entries, idx;
         GElf_Sym sym;
@@ -409,7 +758,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
         Elf *elf;
         int nr = 0, symidx, fd, err = 0;
 
-        fd = open(self->name, O_RDONLY);
+        fd = open(self->long_name, O_RDONLY);
         if (fd < 0)
                 goto out;
 
@@ -477,12 +826,16 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname, self->sym_priv_size, 0, v);
+                                        sympltname);
                         if (!f)
                                 goto out_elf_end;
 
-                        dso__insert_symbol(self, f);
-                        ++nr;
+                        if (filter && filter(map, f))
+                                symbol__delete(f);
+                        else {
+                                symbols__insert(&self->symbols[map->type], f);
+                                ++nr;
+                        }
                 }
         } else if (shdr_rel_plt.sh_type == SHT_REL) {
                 GElf_Rel pos_mem, *pos;
@@ -495,12 +848,16 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname, self->sym_priv_size, 0, v);
+                                        sympltname);
                         if (!f)
                                 goto out_elf_end;
 
-                        dso__insert_symbol(self, f);
-                        ++nr;
+                        if (filter && filter(map, f))
+                                symbol__delete(f);
+                        else {
+                                symbols__insert(&self->symbols[map->type], f);
+                                ++nr;
+                        }
                 }
         }
 
@@ -513,14 +870,41 @@ out_close:
         if (err == 0)
                 return nr;
 out:
-        fprintf(stderr, "%s: problems reading %s PLT info.\n",
-                __func__, self->name);
+        pr_warning("%s: problems reading %s PLT info.\n",
+                   __func__, self->long_name);
         return 0;
 }
 
-static int dso__load_sym(struct dso *self, int fd, const char *name,
-                         symbol_filter_t filter, int v, struct module *mod)
+static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
 {
+        switch (type) {
+        case MAP__FUNCTION:
+                return elf_sym__is_function(self);
+        case MAP__VARIABLE:
+                return elf_sym__is_object(self);
+        default:
+                return false;
+        }
+}
+
+static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
+{
+        switch (type) {
+        case MAP__FUNCTION:
+                return elf_sec__is_text(self, secstrs);
+        case MAP__VARIABLE:
+                return elf_sec__is_data(self, secstrs);
+        default:
+                return false;
+        }
+}
+
+static int dso__load_sym(struct dso *self, struct map *map, const char *name,
+                         int fd, symbol_filter_t filter, int kmodule)
+{
+        struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
+        struct map *curr_map = map;
+        struct dso *curr_dso = self;
         Elf_Data *symstrs, *secstrs;
         uint32_t nr_syms;
         int err = -1;
@@ -531,19 +915,16 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
         GElf_Sym sym;
         Elf_Scn *sec, *sec_strndx;
         Elf *elf;
-        int nr = 0, kernel = !strcmp("[kernel]", self->name);
+        int nr = 0;
 
         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot read %s ELF file.\n",
-                                __func__, name);
+                pr_err("%s: cannot read %s ELF file.\n", __func__, name);
                 goto out_close;
         }
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot get elf header.\n", __func__);
+                pr_err("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
@@ -577,7 +958,7 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
         nr_syms = shdr.sh_size / shdr.sh_entsize;
 
         memset(&sym, 0, sizeof(sym));
-        if (!kernel) {
+        if (!self->kernel) {
                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
                                 elf_section_by_name(elf, &ehdr, &shdr,
                                                      ".gnu.prelink_undo",
@@ -586,14 +967,16 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
 
         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
                 struct symbol *f;
-                const char *elf_name;
-                char *demangled;
-                u64 obj_start;
-                struct section *section = NULL;
+                const char *elf_name = elf_sym__name(&sym, symstrs);
+                char *demangled = NULL;
                 int is_label = elf_sym__is_label(&sym);
                 const char *section_name;
 
-                if (!is_label && !elf_sym__is_function(&sym))
+                if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
+                    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
+                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
+
+                if (!is_label && !elf_sym__is_a(&sym, map->type))
                         continue;
 
                 sec = elf_getscn(elf, sym.st_shndx);
@@ -602,55 +985,98 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
 
                 gelf_getshdr(sec, &shdr);
 
-                if (is_label && !elf_sec__is_text(&shdr, secstrs))
+                if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
                         continue;
 
                 section_name = elf_sec__name(&shdr, secstrs);
-                obj_start = sym.st_value;
 
-                if (self->adjust_symbols) {
-                        if (v >= 2)
-                                printf("adjusting symbol: st_value: %Lx sh_addr: %Lx sh_offset: %Lx\n",
-                                        (u64)sym.st_value, (u64)shdr.sh_addr, (u64)shdr.sh_offset);
+                if (self->kernel || kmodule) {
+                        char dso_name[PATH_MAX];
 
-                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
-                }
+                        if (strcmp(section_name,
+                                   (curr_dso->short_name +
+                                    self->short_name_len)) == 0)
+                                goto new_symbol;
 
-                if (mod) {
-                        section = mod->sections->find_section(mod->sections, section_name);
-                        if (section)
-                                sym.st_value += section->vma;
-                        else {
-                                fprintf(stderr, "dso__load_sym() module %s lookup of %s failed\n",
-                                        mod->name, section_name);
-                                goto out_elf_end;
+                        if (strcmp(section_name, ".text") == 0) {
+                                curr_map = map;
+                                curr_dso = self;
+                                goto new_symbol;
                         }
+
+                        snprintf(dso_name, sizeof(dso_name),
+                                 "%s%s", self->short_name, section_name);
+
+                        curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
+                        if (curr_map == NULL) {
+                                u64 start = sym.st_value;
+
+                                if (kmodule)
+                                        start += map->start + shdr.sh_offset;
+
+                                curr_dso = dso__new(dso_name);
+                                if (curr_dso == NULL)
+                                        goto out_elf_end;
+                                curr_map = map__new2(start, curr_dso,
+                                                     map->type);
+                                if (curr_map == NULL) {
+                                        dso__delete(curr_dso);
+                                        goto out_elf_end;
+                                }
+                                curr_map->map_ip = identity__map_ip;
+                                curr_map->unmap_ip = identity__map_ip;
+                                curr_dso->origin = DSO__ORIG_KERNEL;
+                                map_groups__insert(kmap->kmaps, curr_map);
+                                dsos__add(&dsos__kernel, curr_dso);
+                                dso__set_loaded(curr_dso, map->type);
+                        } else
+                                curr_dso = curr_map->dso;
+
+                        goto new_symbol;
+                }
+
+                if (curr_dso->adjust_symbols) {
+                        pr_debug4("%s: adjusting symbol: st_value: %#Lx "
+                                  "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
+                                  (u64)sym.st_value, (u64)shdr.sh_addr,
+                                  (u64)shdr.sh_offset);
+                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
                 }
                 /*
                  * We need to figure out if the object was created from C++ sources
                  * DWARF DW_compile_unit has this, but we don't always have access
                  * to it...
                  */
-                elf_name = elf_sym__name(&sym, symstrs);
                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
                 if (demangled != NULL)
                         elf_name = demangled;
-
-                f = symbol__new(sym.st_value, sym.st_size, elf_name,
-                                self->sym_priv_size, obj_start, v);
+new_symbol:
+                f = symbol__new(sym.st_value, sym.st_size, elf_name);
                 free(demangled);
                 if (!f)
                         goto out_elf_end;
 
-                if (filter && filter(self, f))
-                        symbol__delete(f, self->sym_priv_size);
+                if (filter && filter(curr_map, f))
+                        symbol__delete(f);
                 else {
-                        f->module = mod;
-                        dso__insert_symbol(self, f);
+                        symbols__insert(&curr_dso->symbols[curr_map->type], f);
                         nr++;
                 }
         }
 
+        /*
+         * For misannotated, zeroed, ASM function sizes.
+         */
+        if (nr > 0) {
+                symbols__fixup_end(&self->symbols[map->type]);
+                if (kmap) {
+                        /*
+                         * We need to fixup this here too because we create new
+                         * maps here, for things like vsyscall sections.
+                         */
+                        __map_groups__fixup_end(kmap->kmaps, map->type);
+                }
+        }
         err = nr;
 out_elf_end:
         elf_end(elf);
@@ -658,63 +1084,157 @@ out_close:
         return err;
 }
 
-#define BUILD_ID_SIZE 128
+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 char *dso__read_build_id(struct dso *self, int v)
+static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
-        int i;
+        bool have_build_id = false;
+        struct dso *pos;
+
+        list_for_each_entry(pos, head, node) {
+                if (with_hits && !pos->hit)
+                        continue;
+                if (filename__read_build_id(pos->long_name, pos->build_id,
+                                            sizeof(pos->build_id)) > 0) {
+                        have_build_id     = true;
+                        pos->has_build_id = true;
+                }
+        }
+
+        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.
+ */
+#define NOTE_ALIGN(n) (((n) + 3) & -4U)
+
+int filename__read_build_id(const char *filename, void *bf, size_t size)
+{
+        int fd, err = -1;
         GElf_Ehdr ehdr;
         GElf_Shdr shdr;
-        Elf_Data *build_id_data;
+        Elf_Data *data;
         Elf_Scn *sec;
-        char *build_id = NULL, *bid;
-        unsigned char *raw;
+        Elf_Kind ek;
+        void *ptr;
         Elf *elf;
-        int fd = open(self->name, O_RDONLY);
 
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
         if (fd < 0)
                 goto out;
 
         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot read %s ELF file.\n",
-                                __func__, self->name);
+                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
                 goto out_close;
         }
 
+        ek = elf_kind(elf);
+        if (ek != ELF_K_ELF)
+                goto out_elf_end;
+
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot get elf header.\n", __func__);
+                pr_err("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
-        sec = elf_section_by_name(elf, &ehdr, &shdr, ".note.gnu.build-id", NULL);
-        if (sec == NULL)
-                goto out_elf_end;
+        sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                  ".note.gnu.build-id", NULL);
+        if (sec == NULL) {
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".notes", NULL);
+                if (sec == NULL)
+                        goto out_elf_end;
+        }
 
-        build_id_data = elf_getdata(sec, NULL);
-        if (build_id_data == NULL)
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
                 goto out_elf_end;
-        build_id = malloc(BUILD_ID_SIZE);
-        if (build_id == NULL)
-                goto out_elf_end;
-        raw = build_id_data->d_buf + 16;
-        bid = build_id;
 
-        for (i = 0; i < 20; ++i) {
-                sprintf(bid, "%02x", *raw);
-                ++raw;
-                bid += 2;
+        ptr = data->d_buf;
+        while (ptr < (data->d_buf + data->d_size)) {
+                GElf_Nhdr *nhdr = ptr;
+                int namesz = NOTE_ALIGN(nhdr->n_namesz),
+                    descsz = NOTE_ALIGN(nhdr->n_descsz);
+                const char *name;
+
+                ptr += sizeof(*nhdr);
+                name = ptr;
+                ptr += namesz;
+                if (nhdr->n_type == NT_GNU_BUILD_ID &&
+                    nhdr->n_namesz == sizeof("GNU")) {
+                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
+                                memcpy(bf, ptr, BUILD_ID_SIZE);
+                                err = BUILD_ID_SIZE;
+                                break;
+                        }
+                }
+                ptr += descsz;
         }
-        if (v >= 2)
-                printf("%s(%s): %s\n", __func__, self->name, build_id);
 out_elf_end:
         elf_end(elf);
 out_close:
         close(fd);
 out:
-        return build_id;
+        return err;
+}
+
+int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
+{
+        int fd, err = -1;
+
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out;
+
+        while (1) {
+                char bf[BUFSIZ];
+                GElf_Nhdr nhdr;
+                int namesz, descsz;
+
+                if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
+                        break;
+
+                namesz = NOTE_ALIGN(nhdr.n_namesz);
+                descsz = NOTE_ALIGN(nhdr.n_descsz);
+                if (nhdr.n_type == NT_GNU_BUILD_ID &&
+                    nhdr.n_namesz == sizeof("GNU")) {
+                        if (read(fd, bf, namesz) != namesz)
+                                break;
+                        if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
+                                if (read(fd, build_id,
+                                    BUILD_ID_SIZE) == BUILD_ID_SIZE) {
+                                        err = 0;
+                                        break;
+                                }
+                        } else if (read(fd, bf, descsz) != descsz)
+                                break;
+                } else {
+                        int n = namesz + descsz;
+                        if (read(fd, bf, n) != n)
+                                break;
+                }
+        }
+        close(fd);
+out:
+        return err;
 }
 
 char dso__symtab_origin(const struct dso *self)
@@ -722,10 +1242,12 @@ char dso__symtab_origin(const struct dso *self)
         static const char origin[] = {
                 [DSO__ORIG_KERNEL] =   'k',
                 [DSO__ORIG_JAVA_JIT] = 'j',
+                [DSO__ORIG_BUILD_ID_CACHE] = 'B',
                 [DSO__ORIG_FEDORA] =   'f',
                 [DSO__ORIG_UBUNTU] =   'u',
                 [DSO__ORIG_BUILDID] =  'b',
                 [DSO__ORIG_DSO] =      'd',
+                [DSO__ORIG_KMODULE] =  'K',
         };
 
         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
@@ -733,60 +1255,90 @@ char dso__symtab_origin(const struct dso *self)
         return origin[self->origin];
 }
 
-int dso__load(struct dso *self, symbol_filter_t filter, int v)
+int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
         int size = PATH_MAX;
-        char *name = malloc(size), *build_id = NULL;
+        char *name;
+        u8 build_id[BUILD_ID_SIZE];
+        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
         int ret = -1;
         int fd;
 
+        dso__set_loaded(self, map->type);
+
+        if (self->kernel)
+                return dso__load_kernel_sym(self, map, filter);
+
+        name = malloc(size);
         if (!name)
                 return -1;
 
         self->adjust_symbols = 0;
 
         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
-                ret = dso__load_perf_map(self, filter, v);
+                ret = dso__load_perf_map(self, map, filter);
                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
                                          DSO__ORIG_NOT_FOUND;
                 return ret;
         }
 
-        self->origin = DSO__ORIG_FEDORA - 1;
+        self->origin = DSO__ORIG_BUILD_ID_CACHE;
 
+        if (self->has_build_id) {
+                build_id__sprintf(self->build_id, sizeof(self->build_id),
+                                  build_id_hex);
+                snprintf(name, size, "%s/%s/.build-id/%.2s/%s",
+                         getenv("HOME"), DEBUG_CACHE_DIR,
+                         build_id_hex, build_id_hex + 2);
+                goto open_file;
+        }
 more:
         do {
                 self->origin++;
                 switch (self->origin) {
                 case DSO__ORIG_FEDORA:
-                        snprintf(name, size, "/usr/lib/debug%s.debug", self->name);
+                        snprintf(name, size, "/usr/lib/debug%s.debug",
+                                 self->long_name);
                         break;
                 case DSO__ORIG_UBUNTU:
-                        snprintf(name, size, "/usr/lib/debug%s", self->name);
+                        snprintf(name, size, "/usr/lib/debug%s",
+                                 self->long_name);
                         break;
                 case DSO__ORIG_BUILDID:
-                        build_id = dso__read_build_id(self, v);
-                        if (build_id != NULL) {
+                        if (filename__read_build_id(self->long_name, build_id,
+                                                    sizeof(build_id))) {
+                                build_id__sprintf(build_id, sizeof(build_id),
+                                                  build_id_hex);
                                 snprintf(name, size,
                                          "/usr/lib/debug/.build-id/%.2s/%s.debug",
-                                        build_id, build_id + 2);
-                                free(build_id);
+                                        build_id_hex, build_id_hex + 2);
+                                if (self->has_build_id)
+                                        goto compare_build_id;
                                 break;
                         }
                         self->origin++;
                         /* Fall thru */
                 case DSO__ORIG_DSO:
-                        snprintf(name, size, "%s", self->name);
+                        snprintf(name, size, "%s", self->long_name);
                         break;
 
                 default:
                         goto out;
                 }
 
+                if (self->has_build_id) {
+                        if (filename__read_build_id(name, build_id,
+                                                    sizeof(build_id)) < 0)
+                                goto more;
+compare_build_id:
+                        if (!dso__build_id_equal(self, build_id))
+                                goto more;
+                }
+open_file:
                 fd = open(name, O_RDONLY);
         } while (fd < 0);
 
-        ret = dso__load_sym(self, fd, name, filter, v, NULL);
+        ret = dso__load_sym(self, map, name, fd, filter, 0);
         close(fd);
 
         /*
@@ -796,7 +1348,7 @@ more:
                 goto more;
 
         if (ret > 0) {
-                int nr_plt = dso__synthesize_plt_symbols(self, v);
+                int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
                 if (nr_plt > 0)
                         ret += nr_plt;
         }
@@ -807,231 +1359,608 @@ out:
         return ret;
 }
 
-static int dso__load_module(struct dso *self, struct mod_dso *mods, const char *name,
-                             symbol_filter_t filter, int v)
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                     enum map_type type, const char *name)
 {
-        struct module *mod = mod_dso__find_module(mods, name);
-        int err = 0, fd;
+        struct rb_node *nd;
 
-        if (mod == NULL || !mod->active)
-                return err;
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *map = rb_entry(nd, struct map, rb_node);
 
-        fd = open(mod->path, O_RDONLY);
+                if (map->dso && strcmp(map->dso->short_name, name) == 0)
+                        return map;
+        }
 
-        if (fd < 0)
-                return err;
+        return NULL;
+}
 
-        err = dso__load_sym(self, fd, name, filter, v, mod);
-        close(fd);
+static int dso__kernel_module_get_build_id(struct dso *self)
+{
+        char filename[PATH_MAX];
+        /*
+         * kernel module short names are of the form "[module]" and
+         * we need just "module" here.
+         */
+        const char *name = self->short_name + 1;
 
-        return err;
+        snprintf(filename, sizeof(filename),
+                 "/sys/module/%.*s/notes/.note.gnu.build-id",
+                 (int)strlen(name - 1), name);
+
+        if (sysfs__read_build_id(filename, self->build_id,
+                                 sizeof(self->build_id)) == 0)
+                self->has_build_id = true;
+
+        return 0;
 }
 
-int dso__load_modules(struct dso *self, symbol_filter_t filter, int v)
+static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirname)
 {
-        struct mod_dso *mods = mod_dso__new_dso("modules");
-        struct module *pos;
-        struct rb_node *next;
-        int err, count = 0;
+        struct dirent *dent;
+        DIR *dir = opendir(dirname);
 
-        err = mod_dso__load_modules(mods);
+        if (!dir) {
+                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
+                return -1;
+        }
 
-        if (err <= 0)
-                return err;
+        while ((dent = readdir(dir)) != NULL) {
+                char path[PATH_MAX];
+
+                if (dent->d_type == DT_DIR) {
+                        if (!strcmp(dent->d_name, ".") ||
+                            !strcmp(dent->d_name, ".."))
+                                continue;
+
+                        snprintf(path, sizeof(path), "%s/%s",
+                                 dirname, dent->d_name);
+                        if (map_groups__set_modules_path_dir(self, path) < 0)
+                                goto failure;
+                } else {
+                        char *dot = strrchr(dent->d_name, '.'),
+                             dso_name[PATH_MAX];
+                        struct map *map;
+                        char *long_name;
+
+                        if (dot == NULL || strcmp(dot, ".ko"))
+                                continue;
+                        snprintf(dso_name, sizeof(dso_name), "[%.*s]",
+                                 (int)(dot - dent->d_name), dent->d_name);
+
+                        strxfrchar(dso_name, '-', '_');
+                        map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
+                        if (map == NULL)
+                                continue;
+
+                        snprintf(path, sizeof(path), "%s/%s",
+                                 dirname, 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);
+                }
+        }
 
-        /*
-         * Iterate over modules, and load active symbols.
-         */
-        next = rb_first(&mods->mods);
-        while (next) {
-                pos = rb_entry(next, struct module, rb_node);
-                err = dso__load_module(self, mods, pos->name, filter, v);
+        return 0;
+failure:
+        closedir(dir);
+        return -1;
+}
 
-                if (err < 0)
-                        break;
+static int map_groups__set_modules_path(struct map_groups *self)
+{
+        struct utsname uts;
+        char modules_path[PATH_MAX];
 
-                next = rb_next(&pos->rb_node);
-                count += err;
-        }
+        if (uname(&uts) < 0)
+                return -1;
+
+        snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
+                 uts.release);
+
+        return map_groups__set_modules_path_dir(self, modules_path);
+}
 
-        if (err < 0) {
-                mod_dso__delete_modules(mods);
-                mod_dso__delete_self(mods);
-                return err;
+/*
+ * Constructor variant for modules (where we know from /proc/modules where
+ * they are loaded) and for vmlinux, where only after we load all the
+ * symbols we'll know where it starts and ends.
+ */
+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));
+        if (self != NULL) {
+                /*
+                 * ->end will be filled after we load all the symbols
+                 */
+                map__init(self, type, start, 0, 0, dso);
         }
 
-        return count;
+        return self;
 }
 
-static inline void dso__fill_symbol_holes(struct dso *self)
+struct map *map_groups__new_module(struct map_groups *self, u64 start,
+                                   const char *filename)
 {
-        struct symbol *prev = NULL;
-        struct rb_node *nd;
+        struct map *map;
+        struct dso *dso = __dsos__findnew(&dsos__kernel, filename);
 
-        for (nd = rb_last(&self->syms); nd; nd = rb_prev(nd)) {
-                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+        if (dso == NULL)
+                return NULL;
 
-                if (prev) {
-                        u64 hole = 0;
-                        int alias = pos->start == prev->start;
+        map = map__new2(start, dso, MAP__FUNCTION);
+        if (map == NULL)
+                return NULL;
 
-                        if (!alias)
-                                hole = prev->start - pos->end - 1;
+        dso->origin = DSO__ORIG_KMODULE;
+        map_groups__insert(self, map);
+        return map;
+}
 
-                        if (hole || alias) {
-                                if (alias)
-                                        pos->end = prev->end;
-                                else if (hole)
-                                        pos->end = prev->start - 1;
-                        }
-                }
-                prev = pos;
+static int map_groups__create_modules(struct map_groups *self)
+{
+        char *line = NULL;
+        size_t n;
+        FILE *file = fopen("/proc/modules", "r");
+        struct map *map;
+
+        if (file == NULL)
+                return -1;
+
+        while (!feof(file)) {
+                char name[PATH_MAX];
+                u64 start;
+                char *sep;
+                int line_len;
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
+
+                if (!line)
+                        goto out_failure;
+
+                line[--line_len] = '\0'; /* \n */
+
+                sep = strrchr(line, 'x');
+                if (sep == NULL)
+                        continue;
+
+                hex2u64(sep + 1, &start);
+
+                sep = strchr(line, ' ');
+                if (sep == NULL)
+                        continue;
+
+                *sep = '\0';
+
+                snprintf(name, sizeof(name), "[%s]", line);
+                map = map_groups__new_module(self, start, name);
+                if (map == NULL)
+                        goto out_delete_line;
+                dso__kernel_module_get_build_id(map->dso);
         }
+
+        free(line);
+        fclose(file);
+
+        return map_groups__set_modules_path(self);
+
+out_delete_line:
+        free(line);
+out_failure:
+        return -1;
 }
 
-static int dso__load_vmlinux(struct dso *self, const char *vmlinux,
-                             symbol_filter_t filter, int v)
+static int dso__load_vmlinux(struct dso *self, struct map *map,
+                             const char *vmlinux, symbol_filter_t filter)
 {
-        int err, fd = open(vmlinux, O_RDONLY);
+        int err = -1, fd;
+
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+
+                if (filename__read_build_id(vmlinux, build_id,
+                                            sizeof(build_id)) < 0) {
+                        pr_debug("No build_id in %s, ignoring it\n", vmlinux);
+                        return -1;
+                }
+                if (!dso__build_id_equal(self, build_id)) {
+                        char expected_build_id[BUILD_ID_SIZE * 2 + 1],
+                             vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
+
+                        build_id__sprintf(self->build_id,
+                                          sizeof(self->build_id),
+                                          expected_build_id);
+                        build_id__sprintf(build_id, sizeof(build_id),
+                                          vmlinux_build_id);
+                        pr_debug("build_id in %s is %s while expected is %s, "
+                                 "ignoring it\n", vmlinux, vmlinux_build_id,
+                                 expected_build_id);
+                        return -1;
+                }
+        }
 
+        fd = open(vmlinux, O_RDONLY);
         if (fd < 0)
                 return -1;
 
-        err = dso__load_sym(self, fd, vmlinux, filter, v, NULL);
+        dso__set_loaded(self, map->type);
+        err = dso__load_sym(self, map, vmlinux, fd, filter, 0);
+        close(fd);
 
         if (err > 0)
-                dso__fill_symbol_holes(self);
+                pr_debug("Using %s for symbols\n", vmlinux);
 
-        close(fd);
+        return err;
+}
+
+int dso__load_vmlinux_path(struct dso *self, struct map *map,
+                           symbol_filter_t filter)
+{
+        int i, err = 0;
+
+        pr_debug("Looking at the vmlinux_path (%d entries long)\n",
+                 vmlinux_path__nr_entries);
+
+        for (i = 0; i < vmlinux_path__nr_entries; ++i) {
+                err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
+                if (err > 0) {
+                        dso__set_long_name(self, strdup(vmlinux_path[i]));
+                        break;
+                }
+        }
 
         return err;
 }
 
-int dso__load_kernel(struct dso *self, const char *vmlinux,
-                     symbol_filter_t filter, int v, int use_modules)
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter)
 {
-        int err = -1;
+        int err;
+        const char *kallsyms_filename = NULL;
+        char *kallsyms_allocated_filename = NULL;
+        /*
+         * Step 1: if the user specified a vmlinux filename, use it and only
+         * it, reporting errors to the user if it cannot be used.
+         *
+         * For instance, try to analyse an ARM perf.data file _without_ a
+         * build-id, or if the user specifies the wrong path to the right
+         * vmlinux file, obviously we can't fallback to another vmlinux (a
+         * x86_86 one, on the machine where analysis is being performed, say),
+         * or worse, /proc/kallsyms.
+         *
+         * If the specified file _has_ a build-id and there is a build-id
+         * section in the perf.data file, we will still do the expected
+         * validation in dso__load_vmlinux and will bail out if they don't
+         * match.
+         */
+        if (symbol_conf.vmlinux_name != NULL) {
+                err = dso__load_vmlinux(self, map,
+                                        symbol_conf.vmlinux_name, filter);
+                goto out_try_fixup;
+        }
 
-        if (vmlinux) {
-                err = dso__load_vmlinux(self, vmlinux, filter, v);
-                if (err > 0 && use_modules) {
-                        int syms = dso__load_modules(self, filter, v);
+        if (vmlinux_path != NULL) {
+                err = dso__load_vmlinux_path(self, map, filter);
+                if (err > 0)
+                        goto out_fixup;
+        }
 
-                        if (syms < 0) {
-                                fprintf(stderr, "dso__load_modules failed!\n");
-                                return syms;
+        /*
+         * Say the kernel DSO was created when processing the build-id header table,
+         * we have a build-id, so check if it is the same as the running kernel,
+         * using it if it is.
+         */
+        if (self->has_build_id) {
+                u8 kallsyms_build_id[BUILD_ID_SIZE];
+                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
+                                         sizeof(kallsyms_build_id)) == 0) {
+                        if (dso__build_id_equal(self, kallsyms_build_id)) {
+                                kallsyms_filename = "/proc/kallsyms";
+                                goto do_kallsyms;
                         }
-                        err += syms;
                 }
-        }
+                /*
+                 * Now look if we have it on the build-id cache in
+                 * $HOME/.debug/[kernel.kallsyms].
+                 */
+                build_id__sprintf(self->build_id, sizeof(self->build_id),
+                                  sbuild_id);
+
+                if (asprintf(&kallsyms_allocated_filename,
+                             "%s/.debug/[kernel.kallsyms]/%s",
+                             getenv("HOME"), sbuild_id) == -1) {
+                        pr_err("Not enough memory for kallsyms file lookup\n");
+                        return -1;
+                }
 
-        if (err <= 0)
-                err = dso__load_kallsyms(self, filter, v);
+                kallsyms_filename = kallsyms_allocated_filename;
 
+                if (access(kallsyms_filename, F_OK)) {
+                        pr_err("No kallsyms or vmlinux with build-id %s "
+                               "was found\n", sbuild_id);
+                        free(kallsyms_allocated_filename);
+                        return -1;
+                }
+        } else {
+                /*
+                 * Last resort, if we don't have a build-id and couldn't find
+                 * any vmlinux file, try the running kernel kallsyms table.
+                 */
+                kallsyms_filename = "/proc/kallsyms";
+        }
+
+do_kallsyms:
+        err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
         if (err > 0)
-                self->origin = DSO__ORIG_KERNEL;
+                pr_debug("Using %s for symbols\n", kallsyms_filename);
+        free(kallsyms_allocated_filename);
+
+out_try_fixup:
+        if (err > 0) {
+out_fixup:
+                if (kallsyms_filename != NULL)
+                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+                map__fixup_start(map);
+                map__fixup_end(map);
+        }
 
         return err;
 }
 
-LIST_HEAD(dsos);
-struct dso      *kernel_dso;
-struct dso      *vdso;
-struct dso      *hypervisor_dso;
-
-const char      *vmlinux_name = "vmlinux";
-int             modules;
+LIST_HEAD(dsos__user);
+LIST_HEAD(dsos__kernel);
 
-static void dsos__add(struct dso *dso)
+static void dsos__add(struct list_head *head, struct dso *dso)
 {
-        list_add_tail(&dso->node, &dsos);
+        list_add_tail(&dso->node, head);
 }
 
-static struct dso *dsos__find(const char *name)
+static struct dso *dsos__find(struct list_head *head, const char *name)
 {
         struct dso *pos;
 
-        list_for_each_entry(pos, &dsos, node)
-                if (strcmp(pos->name, name) == 0)
+        list_for_each_entry(pos, head, node)
+                if (strcmp(pos->long_name, name) == 0)
                         return pos;
         return NULL;
 }
 
-struct dso *dsos__findnew(const char *name)
+struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
-        struct dso *dso = dsos__find(name);
-        int nr;
-
-        if (dso)
-                return dso;
-
-        dso = dso__new(name, 0);
-        if (!dso)
-                goto out_delete_dso;
+        struct dso *dso = dsos__find(head, name);
 
-        nr = dso__load(dso, NULL, verbose);
-        if (nr < 0) {
-                eprintf("Failed to open: %s\n", name);
-                goto out_delete_dso;
+        if (!dso) {
+                dso = dso__new(name);
+                if (dso != NULL) {
+                        dsos__add(head, dso);
+                        dso__set_basename(dso);
+                }
         }
-        if (!nr)
-                eprintf("No symbols found in: %s, maybe install a debug package?\n", name);
-
-        dsos__add(dso);
 
         return dso;
+}
 
-out_delete_dso:
-        dso__delete(dso);
-        return NULL;
+static void __dsos__fprintf(struct list_head *head, FILE *fp)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, head, node) {
+                int i;
+                for (i = 0; i < MAP__NR_TYPES; ++i)
+                        dso__fprintf(pos, i, fp);
+        }
 }
 
 void dsos__fprintf(FILE *fp)
 {
+        __dsos__fprintf(&dsos__kernel, fp);
+        __dsos__fprintf(&dsos__user, fp);
+}
+
+static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
+                                      bool with_hits)
+{
         struct dso *pos;
+        size_t ret = 0;
 
-        list_for_each_entry(pos, &dsos, node)
-                dso__fprintf(pos, fp);
+        list_for_each_entry(pos, head, node) {
+                if (with_hits && !pos->hit)
+                        continue;
+                ret += dso__fprintf_buildid(pos, fp);
+                ret += fprintf(fp, " %s\n", pos->long_name);
+        }
+        return ret;
 }
 
-static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
+size_t dsos__fprintf_buildid(FILE *fp, bool with_hits)
 {
-        return dso__find_symbol(dso, ip);
+        return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) +
+                __dsos__fprintf_buildid(&dsos__user, fp, with_hits));
 }
 
-int load_kernel(void)
+struct dso *dso__new_kernel(const char *name)
 {
-        int err;
+        struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
 
-        kernel_dso = dso__new("[kernel]", 0);
-        if (!kernel_dso)
-                return -1;
+        if (self != NULL) {
+                dso__set_short_name(self, "[kernel]");
+                self->kernel     = 1;
+        }
 
-        err = dso__load_kernel(kernel_dso, vmlinux_name, NULL, verbose, modules);
-        if (err <= 0) {
-                dso__delete(kernel_dso);
-                kernel_dso = NULL;
-        } else
-                dsos__add(kernel_dso);
+        return self;
+}
 
-        vdso = dso__new("[vdso]", 0);
-        if (!vdso)
-                return -1;
+void dso__read_running_kernel_build_id(struct dso *self)
+{
+        if (sysfs__read_build_id("/sys/kernel/notes", self->build_id,
+                                 sizeof(self->build_id)) == 0)
+                self->has_build_id = true;
+}
+
+static struct dso *dsos__create_kernel(const char *vmlinux)
+{
+        struct dso *kernel = dso__new_kernel(vmlinux);
+
+        if (kernel != NULL) {
+                dso__read_running_kernel_build_id(kernel);
+                dsos__add(&dsos__kernel, kernel);
+        }
+
+        return kernel;
+}
+
+int __map_groups__create_kernel_maps(struct map_groups *self,
+                                     struct map *vmlinux_maps[MAP__NR_TYPES],
+                                     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)
+                        return -1;
+
+                vmlinux_maps[type]->map_ip =
+                        vmlinux_maps[type]->unmap_ip = identity__map_ip;
+
+                kmap = map__kmap(vmlinux_maps[type]);
+                kmap->kmaps = self;
+                map_groups__insert(self, vmlinux_maps[type]);
+        }
+
+        return 0;
+}
+
+static void vmlinux_path__exit(void)
+{
+        while (--vmlinux_path__nr_entries >= 0) {
+                free(vmlinux_path[vmlinux_path__nr_entries]);
+                vmlinux_path[vmlinux_path__nr_entries] = NULL;
+        }
 
-        vdso->find_symbol = vdso__find_symbol;
+        free(vmlinux_path);
+        vmlinux_path = NULL;
+}
 
-        dsos__add(vdso);
+static int vmlinux_path__init(void)
+{
+        struct utsname uts;
+        char bf[PATH_MAX];
 
-        hypervisor_dso = dso__new("[hypervisor]", 0);
-        if (!hypervisor_dso)
+        if (uname(&uts) < 0)
                 return -1;
-        dsos__add(hypervisor_dso);
 
-        return err;
+        vmlinux_path = malloc(sizeof(char *) * 5);
+        if (vmlinux_path == NULL)
+                return -1;
+
+        vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
+                 uts.release);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+
+        return 0;
+
+out_fail:
+        vmlinux_path__exit();
+        return -1;
 }
 
+static int setup_list(struct strlist **list, const char *list_str,
+                      const char *list_name)
+{
+        if (list_str == NULL)
+                return 0;
+
+        *list = strlist__new(true, list_str);
+        if (!*list) {
+                pr_err("problems parsing %s list\n", list_name);
+                return -1;
+        }
+        return 0;
+}
 
-void symbol__init(void)
+int symbol__init(void)
 {
         elf_version(EV_CURRENT);
+        if (symbol_conf.sort_by_name)
+                symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
+                                          sizeof(struct symbol));
+
+        if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
+                return -1;
+
+        if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
+                pr_err("'.' is the only non valid --field-separator argument\n");
+                return -1;
+        }
+
+        if (setup_list(&symbol_conf.dso_list,
+                       symbol_conf.dso_list_str, "dso") < 0)
+                return -1;
+
+        if (setup_list(&symbol_conf.comm_list,
+                       symbol_conf.comm_list_str, "comm") < 0)
+                goto out_free_dso_list;
+
+        if (setup_list(&symbol_conf.sym_list,
+                       symbol_conf.sym_list_str, "symbol") < 0)
+                goto out_free_comm_list;
+
+        return 0;
+
+out_free_dso_list:
+        strlist__delete(symbol_conf.dso_list);
+out_free_comm_list:
+        strlist__delete(symbol_conf.comm_list);
+        return -1;
+}
+
+int map_groups__create_kernel_maps(struct map_groups *self,
+                                   struct map *vmlinux_maps[MAP__NR_TYPES])
+{
+        struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name);
+
+        if (kernel == NULL)
+                return -1;
+
+        if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0)
+                return -1;
+
+        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;
 }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 829da9edba64..f30a37428919 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -1,13 +1,15 @@
-#ifndef _PERF_SYMBOL_
-#define _PERF_SYMBOL_ 1
+#ifndef __PERF_SYMBOL
+#define __PERF_SYMBOL 1
 
 #include <linux/types.h>
+#include <stdbool.h>
 #include "types.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include "module.h"
 #include "event.h"
 
+#define DEBUG_CACHE_DIR ".debug"
+
 #ifdef HAVE_CPLUS_DEMANGLE
 extern char *cplus_demangle(const char *, int);
 
@@ -46,57 +48,125 @@ struct symbol {
         struct rb_node  rb_node;
         u64             start;
         u64             end;
-        u64             obj_start;
-        u64             hist_sum;
-        u64             *hist;
-        struct module   *module;
-        void            *priv;
         char            name[0];
 };
 
+void symbol__delete(struct symbol *self);
+
+struct strlist;
+
+struct symbol_conf {
+        unsigned short  priv_size;
+        bool            try_vmlinux_path,
+                        use_modules,
+                        sort_by_name,
+                        show_nr_samples,
+                        use_callchain,
+                        exclude_other,
+                        full_paths;
+        const char      *vmlinux_name,
+                        *field_sep;
+        char            *dso_list_str,
+                        *comm_list_str,
+                        *sym_list_str,
+                        *col_width_list_str;
+       struct strlist   *dso_list,
+                        *comm_list,
+                        *sym_list;
+};
+
+extern struct symbol_conf symbol_conf;
+
+static inline void *symbol__priv(struct symbol *self)
+{
+        return ((void *)self) - symbol_conf.priv_size;
+}
+
+struct ref_reloc_sym {
+        const char      *name;
+        u64             addr;
+        u64             unrelocated_addr;
+};
+
+struct addr_location {
+        struct thread *thread;
+        struct map    *map;
+        struct symbol *sym;
+        u64           addr;
+        char          level;
+        bool          filtered;
+};
+
 struct dso {
         struct list_head node;
-        struct rb_root   syms;
-        struct symbol    *(*find_symbol)(struct dso *, u64 ip);
-        unsigned int     sym_priv_size;
-        unsigned char    adjust_symbols;
-        unsigned char    slen_calculated;
+        struct rb_root   symbols[MAP__NR_TYPES];
+        struct rb_root   symbol_names[MAP__NR_TYPES];
+        u8               adjust_symbols:1;
+        u8               slen_calculated:1;
+        u8               has_build_id:1;
+        u8               kernel:1;
+        u8               hit:1;
         unsigned char    origin;
+        u8               sorted_by_name;
+        u8               loaded;
+        u8               build_id[BUILD_ID_SIZE];
+        const char       *short_name;
+        char             *long_name;
+        u16              long_name_len;
+        u16              short_name_len;
         char             name[0];
 };
 
-extern const char *sym_hist_filter;
-
-typedef int (*symbol_filter_t)(struct dso *self, struct symbol *sym);
-
-struct dso *dso__new(const char *name, unsigned int sym_priv_size);
+struct dso *dso__new(const char *name);
+struct dso *dso__new_kernel(const char *name);
 void dso__delete(struct dso *self);
 
-static inline void *dso__sym_priv(struct dso *self, struct symbol *sym)
+bool dso__loaded(const struct dso *self, enum map_type type);
+bool dso__sorted_by_name(const struct dso *self, enum map_type type);
+
+static inline void dso__set_loaded(struct dso *self, enum map_type type)
 {
-        return ((void *)sym) - self->sym_priv_size;
+        self->loaded |= (1 << type);
 }
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip);
+void dso__sort_by_name(struct dso *self, enum map_type type);
 
-int dso__load_kernel(struct dso *self, const char *vmlinux,
-                     symbol_filter_t filter, int verbose, int modules);
-int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose);
-int dso__load(struct dso *self, symbol_filter_t filter, int verbose);
-struct dso *dsos__findnew(const char *name);
-void dsos__fprintf(FILE *fp);
+extern struct list_head dsos__user, dsos__kernel;
 
-size_t dso__fprintf(struct dso *self, FILE *fp);
-char dso__symtab_origin(const struct dso *self);
+struct dso *__dsos__findnew(struct list_head *head, const char *name);
 
-int load_kernel(void);
+static inline struct dso *dsos__findnew(const char *name)
+{
+        return __dsos__findnew(&dsos__user, name);
+}
 
-void symbol__init(void);
+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);
 
-extern struct list_head dsos;
-extern struct dso *kernel_dso;
-extern struct dso *vdso;
-extern struct dso *hypervisor_dso;
-extern const char *vmlinux_name;
-extern int   modules;
-#endif /* _PERF_SYMBOL_ */
+size_t dso__fprintf_buildid(struct dso *self, FILE *fp);
+size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp);
+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);
+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);
+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 symbol__init(void);
+bool symbol_type__is_a(char symbol_type, enum map_type map_type);
+
+#endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 45efb5db0d19..fa968312ee7d 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -2,48 +2,151 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include "session.h"
 #include "thread.h"
 #include "util.h"
 #include "debug.h"
 
+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]);
+        }
+}
+
 static struct thread *thread__new(pid_t pid)
 {
-        struct thread *self = calloc(1, sizeof(*self));
+        struct thread *self = zalloc(sizeof(*self));
 
         if (self != NULL) {
+                map_groups__init(&self->mg);
                 self->pid = pid;
                 self->comm = malloc(32);
                 if (self->comm)
                         snprintf(self->comm, 32, ":%d", self->pid);
-                INIT_LIST_HEAD(&self->maps);
         }
 
         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;
+
         if (self->comm)
                 free(self->comm);
         self->comm = strdup(comm);
-        return self->comm ? 0 : -ENOMEM;
+        err = self->comm == NULL ? -ENOMEM : 0;
+        if (!err) {
+                self->comm_set = true;
+                map_groups__flush(&self->mg);
+        }
+        return err;
 }
 
-static size_t thread__fprintf(struct thread *self, FILE *fp)
+int thread__comm_len(struct thread *self)
+{
+        if (!self->comm_len) {
+                if (!self->comm)
+                        return 0;
+                self->comm_len = strlen(self->comm);
+        }
+
+        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 ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+        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;
+}
 
-        list_for_each_entry(pos, &self->maps, node)
-                ret += map__fprintf(pos, fp);
+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;
+}
 
-        return ret;
+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);
 }
 
-struct thread *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
+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);
+}
+
+struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
 {
-        struct rb_node **p = &threads->rb_node;
+        struct rb_node **p = &self->threads.rb_node;
         struct rb_node *parent = NULL;
         struct thread *th;
 
@@ -52,15 +155,15 @@ threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
          * so most of the time we dont have to look up
          * the full rbtree:
          */
-        if (*last_match && (*last_match)->pid == pid)
-                return *last_match;
+        if (self->last_match && self->last_match->pid == pid)
+                return self->last_match;
 
         while (*p != NULL) {
                 parent = *p;
                 th = rb_entry(parent, struct thread, rb_node);
 
                 if (th->pid == pid) {
-                        *last_match = th;
+                        self->last_match = th;
                         return th;
                 }
 
@@ -73,99 +176,159 @@ threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
         th = thread__new(pid);
         if (th != NULL) {
                 rb_link_node(&th->rb_node, parent, p);
-                rb_insert_color(&th->rb_node, threads);
-                *last_match = th;
+                rb_insert_color(&th->rb_node, &self->threads);
+                self->last_match = th;
         }
 
         return th;
 }
 
-struct thread *
-register_idle_thread(struct rb_root *threads, struct thread **last_match)
+static int map_groups__fixup_overlappings(struct map_groups *self,
+                                          struct map *map)
 {
-        struct thread *thread = threads__findnew(0, threads, last_match);
+        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 (!thread || thread__set_comm(thread, "swapper")) {
-                fprintf(stderr, "problem inserting idle task.\n");
-                exit(-1);
+                        if (after == NULL)
+                                return -ENOMEM;
+
+                        after->start = map->end + 1;
+                        map_groups__insert(self, after);
+                        if (verbose >= 2)
+                                map__fprintf(after, stderr);
+                }
         }
 
-        return thread;
+        return 0;
 }
 
-void thread__insert_map(struct thread *self, struct map *map)
+void maps__insert(struct rb_root *maps, struct map *map)
 {
-        struct map *pos, *tmp;
-
-        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
-                if (map__overlap(pos, map)) {
-                        if (verbose >= 2) {
-                                printf("overlapping maps:\n");
-                                map__fprintf(map, stdout);
-                                map__fprintf(pos, stdout);
-                        }
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        const u64 ip = map->start;
+        struct map *m;
 
-                        if (map->start <= pos->start && map->end > pos->start)
-                                pos->start = map->end;
+        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;
+        }
 
-                        if (map->end >= pos->end && map->start < pos->end)
-                                pos->end = map->start;
+        rb_link_node(&map->rb_node, parent, p);
+        rb_insert_color(&map->rb_node, maps);
+}
 
-                        if (verbose >= 2) {
-                                printf("after collision:\n");
-                                map__fprintf(pos, stdout);
-                        }
+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;
 
-                        if (pos->start >= pos->end) {
-                                list_del_init(&pos->node);
-                                free(pos);
-                        }
-                }
+        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;
         }
 
-        list_add_tail(&map->node, &self->maps);
+        return NULL;
 }
 
-int thread__fork(struct thread *self, struct thread *parent)
+void thread__insert_map(struct thread *self, struct map *map)
 {
-        struct map *map;
-
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(parent->comm);
-        if (!self->comm)
-                return -ENOMEM;
+        map_groups__fixup_overlappings(&self->mg, map);
+        map_groups__insert(&self->mg, map);
+}
 
-        list_for_each_entry(map, &parent->maps, node) {
+/*
+ * 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)
+                if (new == NULL)
                         return -ENOMEM;
-                thread__insert_map(self, new);
+                map_groups__insert(self, new);
         }
-
         return 0;
 }
 
-struct map *thread__find_map(struct thread *self, u64 ip)
+int thread__fork(struct thread *self, struct thread *parent)
 {
-        struct map *pos;
-
-        if (self == NULL)
-                return NULL;
+        int i;
 
-        list_for_each_entry(pos, &self->maps, node)
-                if (ip >= pos->start && ip <= pos->end)
-                        return pos;
+        if (parent->comm_set) {
+                if (self->comm)
+                        free(self->comm);
+                self->comm = strdup(parent->comm);
+                if (!self->comm)
+                        return -ENOMEM;
+                self->comm_set = true;
+        }
 
-        return NULL;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
+                        return -ENOMEM;
+        return 0;
 }
 
-size_t threads__fprintf(FILE *fp, struct rb_root *threads)
+size_t perf_session__fprintf(struct perf_session *self, FILE *fp)
 {
         size_t ret = 0;
         struct rb_node *nd;
 
-        for (nd = rb_first(threads); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&self->threads); nd; nd = rb_next(nd)) {
                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 
                 ret += thread__fprintf(pos, fp);
@@ -173,3 +336,15 @@ size_t threads__fprintf(FILE *fp, struct rb_root *threads)
 
         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 32aea3c1c2ad..dcf70303e58e 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -1,22 +1,87 @@
+#ifndef __PERF_THREAD_H
+#define __PERF_THREAD_H
+
 #include <linux/rbtree.h>
-#include <linux/list.h>
 #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 list_head        maps;
+        struct map_groups       mg;
         pid_t                   pid;
         char                    shortname[3];
+        bool                    comm_set;
         char                    *comm;
+        int                     comm_len;
 };
 
+void map_groups__init(struct map_groups *self);
 int thread__set_comm(struct thread *self, const char *comm);
-struct thread *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match);
-struct thread *
-register_idle_thread(struct rb_root *threads, struct thread **last_match);
+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);
-struct map *thread__find_map(struct thread *self, u64 ip);
-size_t threads__fprintf(FILE *fp, struct rb_root *threads);
+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)
+{
+        return self ? map_groups__find(&self->mg, type, addr) : NULL;
+}
+
+void thread__find_addr_map(struct thread *self,
+                           struct perf_session *session, u8 cpumode,
+                           enum map_type type, 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,
+                                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 af4b0573b37f..5ea8973ad331 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -20,6 +20,7 @@
  */
 #define _GNU_SOURCE
 #include <dirent.h>
+#include <mntent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -33,10 +34,11 @@
 #include <ctype.h>
 #include <errno.h>
 #include <stdbool.h>
+#include <linux/kernel.h>
 
 #include "../perf.h"
 #include "trace-event.h"
-
+#include "debugfs.h"
 
 #define VERSION "0.5"
 
@@ -101,32 +103,12 @@ void *malloc_or_die(unsigned int size)
 
 static const char *find_debugfs(void)
 {
-        static char debugfs[MAX_PATH+1];
-        static int debugfs_found;
-        char type[100];
-        FILE *fp;
-
-        if (debugfs_found)
-                return debugfs;
-
-        if ((fp = fopen("/proc/mounts","r")) == NULL)
-                die("Can't open /proc/mounts for read");
-
-        while (fscanf(fp, "%*s %"
-                      STR(MAX_PATH)
-                      "s %99s %*s %*d %*d\n",
-                      debugfs, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-
-        if (strcmp(type, "debugfs") != 0)
-                die("debugfs not mounted, please mount");
+        const char *path = debugfs_mount(NULL);
 
-        debugfs_found = 1;
+        if (!path)
+                die("Your kernel not support debugfs filesystem");
 
-        return debugfs;
+        return path;
 }
 
 /*
@@ -271,6 +253,8 @@ static void read_header_files(void)
         write_or_die("header_page", 12);
         write_or_die(&size, 8);
         check_size = copy_file_fd(fd);
+        close(fd);
+
         if (size != check_size)
                 die("wrong size for '%s' size=%lld read=%lld",
                     path, size, check_size);
@@ -289,6 +273,7 @@ static void read_header_files(void)
         if (size != check_size)
                 die("wrong size for '%s'", path);
         put_tracing_file(path);
+        close(fd);
 }
 
 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -317,7 +302,8 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                 die("can't read directory '%s'", sys);
 
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
@@ -334,7 +320,8 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
@@ -353,6 +340,7 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 
                 free(format);
         }
+        closedir(dir);
 }
 
 static void read_ftrace_files(struct tracepoint_path *tps)
@@ -394,26 +382,21 @@ static void read_event_files(struct tracepoint_path *tps)
                 die("can't read directory '%s'", path);
 
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
                         continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
-                sprintf(sys, "%s/%s", path, dent->d_name);
-                ret = stat(sys, &st);
-                free(sys);
-                if (ret < 0)
-                        continue;
-                if (S_ISDIR(st.st_mode))
-                        count++;
+                count++;
         }
 
         write_or_die(&count, 4);
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
@@ -422,14 +405,13 @@ static void read_event_files(struct tracepoint_path *tps)
                 sprintf(sys, "%s/%s", path, dent->d_name);
                 ret = stat(sys, &st);
                 if (ret >= 0) {
-                        if (S_ISDIR(st.st_mode)) {
-                                write_or_die(dent->d_name, strlen(dent->d_name) + 1);
-                                copy_event_system(sys, tps);
-                        }
+                        write_or_die(dent->d_name, strlen(dent->d_name) + 1);
+                        copy_event_system(sys, tps);
                 }
                 free(sys);
         }
 
+        closedir(dir);
         put_tracing_file(path);
 }
 
@@ -483,27 +465,33 @@ static struct tracepoint_path *
 get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
 {
         struct tracepoint_path path, *ppath = &path;
-        int i;
+        int i, nr_tracepoints = 0;
 
         for (i = 0; i < nb_events; i++) {
                 if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
                         continue;
+                ++nr_tracepoints;
                 ppath->next = tracepoint_id_to_path(pattrs[i].config);
                 if (!ppath->next)
                         die("%s\n", "No memory to alloc tracepoints list");
                 ppath = ppath->next;
         }
 
-        return path.next;
+        return nr_tracepoints > 0 ? path.next : NULL;
 }
-void read_tracing_data(struct perf_event_attr *pattrs, int nb_events)
+
+int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 {
         char buf[BUFSIZ];
-        struct tracepoint_path *tps;
+        struct tracepoint_path *tps = get_tracepoints_path(pattrs, nb_events);
+
+        /*
+         * What? No tracepoints? No sense writing anything here, bail out.
+         */
+        if (tps == NULL)
+                return -1;
 
-        output_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
-        if (output_fd < 0)
-                die("creating file '%s'", output_file);
+        output_fd = fd;
 
         buf[0] = 23;
         buf[1] = 8;
@@ -527,14 +515,14 @@ void read_tracing_data(struct perf_event_attr *pattrs, int nb_events)
         write_or_die(buf, 1);
 
         /* save page_size */
-        page_size = getpagesize();
+        page_size = sysconf(_SC_PAGESIZE);
         write_or_die(&page_size, 4);
 
-        tps = get_tracepoints_path(pattrs, nb_events);
-
         read_header_files();
         read_ftrace_files(tps);
         read_event_files(tps);
         read_proc_kallsyms();
         read_ftrace_printk();
+
+        return 0;
 }
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 55c9659a56e2..613c9cc90570 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -40,12 +40,19 @@ int header_page_size_size;
 int header_page_data_offset;
 int header_page_data_size;
 
+int latency_format;
+
 static char *input_buf;
 static unsigned long long input_buf_ptr;
 static unsigned long long input_buf_siz;
 
 static int cpus;
 static int long_size;
+static int is_flag_field;
+static int is_symbolic_field;
+
+static struct format_field *
+find_any_field(struct event *event, const char *name);
 
 static void init_input_buf(char *buf, unsigned long long size)
 {
@@ -170,7 +177,7 @@ void parse_proc_kallsyms(char *file, unsigned int size __unused)
                 func_count++;
         }
 
-        func_list = malloc_or_die(sizeof(*func_list) * func_count + 1);
+        func_list = malloc_or_die(sizeof(*func_list) * (func_count + 1));
 
         i = 0;
         while (list) {
@@ -284,18 +291,19 @@ void parse_ftrace_printk(char *file, unsigned int size __unused)
         char *line;
         char *next = NULL;
         char *addr_str;
-        int ret;
         int i;
 
         line = strtok_r(file, "\n", &next);
         while (line) {
+                addr_str = strsep(&line, ":");
+                if (!line) {
+                        warning("error parsing print strings");
+                        break;
+                }
                 item = malloc_or_die(sizeof(*item));
-                ret = sscanf(line, "%as : %as",
-                             (float *)(void *)&addr_str, /* workaround gcc warning */
-                             (float *)(void *)&item->printk);
                 item->addr = strtoull(addr_str, NULL, 16);
-                free(addr_str);
-
+                /* fmt still has a space, skip it */
+                item->printk = strdup(line+1);
                 item->next = list;
                 list = item;
                 line = strtok_r(NULL, "\n", &next);
@@ -522,7 +530,10 @@ static enum event_type __read_token(char **tok)
                         last_ch = ch;
                         ch = __read_char();
                         buf[i++] = ch;
-                } while (ch != quote_ch && last_ch != '\\');
+                        /* the '\' '\' will cancel itself */
+                        if (ch == '\\' && last_ch == '\\')
+                                last_ch = 0;
+                } while (ch != quote_ch || last_ch == '\\');
                 /* remove the last quote */
                 i--;
                 goto out;
@@ -610,7 +621,7 @@ static enum event_type read_token_item(char **tok)
 static int test_type(enum event_type type, enum event_type expect)
 {
         if (type != expect) {
-                die("Error: expected type %d but read %d",
+                warning("Error: expected type %d but read %d",
                     expect, type);
                 return -1;
         }
@@ -621,13 +632,13 @@ static int test_type_token(enum event_type type, char *token,
                     enum event_type expect, const char *expect_tok)
 {
         if (type != expect) {
-                die("Error: expected type %d but read %d",
+                warning("Error: expected type %d but read %d",
                     expect, type);
                 return -1;
         }
 
         if (strcmp(token, expect_tok) != 0) {
-                die("Error: expected '%s' but read '%s'",
+                warning("Error: expected '%s' but read '%s'",
                     expect_tok, token);
                 return -1;
         }
@@ -665,7 +676,7 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
 
         free_token(token);
 
-        return 0;
+        return ret;
 }
 
 static int read_expected(enum event_type expect, const char *str)
@@ -682,10 +693,10 @@ static char *event_read_name(void)
 {
         char *token;
 
-        if (read_expected(EVENT_ITEM, (char *)"name") < 0)
+        if (read_expected(EVENT_ITEM, "name") < 0)
                 return NULL;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return NULL;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -703,10 +714,10 @@ static int event_read_id(void)
         char *token;
         int id;
 
-        if (read_expected_item(EVENT_ITEM, (char *)"ID") < 0)
+        if (read_expected_item(EVENT_ITEM, "ID") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return -1;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -721,6 +732,24 @@ static int event_read_id(void)
         return -1;
 }
 
+static int field_is_string(struct format_field *field)
+{
+        if ((field->flags & FIELD_IS_ARRAY) &&
+            (!strstr(field->type, "char") || !strstr(field->type, "u8") ||
+             !strstr(field->type, "s8")))
+                return 1;
+
+        return 0;
+}
+
+static int field_is_dynamic(struct format_field *field)
+{
+        if (!strcmp(field->type, "__data_loc"))
+                return 1;
+
+        return 0;
+}
+
 static int event_read_fields(struct event *event, struct format_field **fields)
 {
         struct format_field *field = NULL;
@@ -738,7 +767,7 @@ static int event_read_fields(struct event *event, struct format_field **fields)
 
                 count++;
 
-                if (test_type_token(type, token, EVENT_ITEM, (char *)"field"))
+                if (test_type_token(type, token, EVENT_ITEM, "field"))
                         goto fail;
                 free_token(token);
 
@@ -753,7 +782,7 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                         type = read_token(&token);
                 }
 
-                if (test_type_token(type, token, EVENT_OP, (char *)":") < 0)
+                if (test_type_token(type, token, EVENT_OP, ":") < 0)
                         return -1;
 
                 if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -865,14 +894,20 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                         free(brackets);
                 }
 
-                if (test_type_token(type, token,  EVENT_OP, (char *)";"))
+                if (field_is_string(field)) {
+                        field->flags |= FIELD_IS_STRING;
+                        if (field_is_dynamic(field))
+                                field->flags |= FIELD_IS_DYNAMIC;
+                }
+
+                if (test_type_token(type, token,  EVENT_OP, ";"))
                         goto fail;
                 free_token(token);
 
-                if (read_expected(EVENT_ITEM, (char *)"offset") < 0)
+                if (read_expected(EVENT_ITEM, "offset") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_OP, (char *)":") < 0)
+                if (read_expected(EVENT_OP, ":") < 0)
                         goto fail_expect;
 
                 if (read_expect_type(EVENT_ITEM, &token))
@@ -880,13 +915,13 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                 field->offset = strtoul(token, NULL, 0);
                 free_token(token);
 
-                if (read_expected(EVENT_OP, (char *)";") < 0)
+                if (read_expected(EVENT_OP, ";") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_ITEM, (char *)"size") < 0)
+                if (read_expected(EVENT_ITEM, "size") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_OP, (char *)":") < 0)
+                if (read_expected(EVENT_OP, ":") < 0)
                         goto fail_expect;
 
                 if (read_expect_type(EVENT_ITEM, &token))
@@ -894,11 +929,34 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                 field->size = strtoul(token, NULL, 0);
                 free_token(token);
 
-                if (read_expected(EVENT_OP, (char *)";") < 0)
+                if (read_expected(EVENT_OP, ";") < 0)
                         goto fail_expect;
 
-                if (read_expect_type(EVENT_NEWLINE, &token) < 0)
-                        goto fail;
+                type = read_token(&token);
+                if (type != EVENT_NEWLINE) {
+                        /* newer versions of the kernel have a "signed" type */
+                        if (test_type_token(type, token, EVENT_ITEM, "signed"))
+                                goto fail;
+
+                        free_token(token);
+
+                        if (read_expected(EVENT_OP, ":") < 0)
+                                goto fail_expect;
+
+                        if (read_expect_type(EVENT_ITEM, &token))
+                                goto fail;
+
+                        if (strtoul(token, NULL, 0))
+                                field->flags |= FIELD_IS_SIGNED;
+
+                        free_token(token);
+                        if (read_expected(EVENT_OP, ";") < 0)
+                                goto fail_expect;
+
+                        if (read_expect_type(EVENT_NEWLINE, &token))
+                                goto fail;
+                }
+
                 free_token(token);
 
                 *fields = field;
@@ -921,10 +979,10 @@ static int event_read_format(struct event *event)
         char *token;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, (char *)"format") < 0)
+        if (read_expected_item(EVENT_ITEM, "format") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return -1;
 
         if (read_expect_type(EVENT_NEWLINE, &token))
@@ -984,7 +1042,7 @@ process_cond(struct event *event, struct print_arg *top, char **tok)
 
         *tok = NULL;
         type = process_arg(event, left, &token);
-        if (test_type_token(type, token, EVENT_OP, (char *)":"))
+        if (test_type_token(type, token, EVENT_OP, ":"))
                 goto out_free;
 
         arg->op.op = token;
@@ -1004,6 +1062,35 @@ out_free:
         return EVENT_ERROR;
 }
 
+static enum event_type
+process_array(struct event *event, struct print_arg *top, char **tok)
+{
+        struct print_arg *arg;
+        enum event_type type;
+        char *token = NULL;
+
+        arg = malloc_or_die(sizeof(*arg));
+        memset(arg, 0, sizeof(*arg));
+
+        *tok = NULL;
+        type = process_arg(event, arg, &token);
+        if (test_type_token(type, token, EVENT_OP, "]"))
+                goto out_free;
+
+        top->op.right = arg;
+
+        free_token(token);
+        type = read_token_item(&token);
+        *tok = token;
+
+        return type;
+
+out_free:
+        free_token(*tok);
+        free_arg(arg);
+        return EVENT_ERROR;
+}
+
 static int get_op_prio(char *op)
 {
         if (!op[1]) {
@@ -1128,6 +1215,8 @@ process_op(struct event *event, struct print_arg *arg, char **tok)
                    strcmp(token, "*") == 0 ||
                    strcmp(token, "^") == 0 ||
                    strcmp(token, "/") == 0 ||
+                   strcmp(token, "<") == 0 ||
+                   strcmp(token, ">") == 0 ||
                    strcmp(token, "==") == 0 ||
                    strcmp(token, "!=") == 0) {
 
@@ -1144,17 +1233,46 @@ process_op(struct event *event, struct print_arg *arg, char **tok)
 
                 right = malloc_or_die(sizeof(*right));
 
-                type = process_arg(event, right, tok);
+                type = read_token_item(&token);
+                *tok = token;
+
+                /* could just be a type pointer */
+                if ((strcmp(arg->op.op, "*") == 0) &&
+                    type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
+                        if (left->type != PRINT_ATOM)
+                                die("bad pointer type");
+                        left->atom.atom = realloc(left->atom.atom,
+                                            sizeof(left->atom.atom) + 3);
+                        strcat(left->atom.atom, " *");
+                        *arg = *left;
+                        free(arg);
+
+                        return type;
+                }
+
+                type = process_arg_token(event, right, tok, type);
 
                 arg->op.right = right;
 
+        } else if (strcmp(token, "[") == 0) {
+
+                left = malloc_or_die(sizeof(*left));
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+
+                arg->op.prio = 0;
+                type = process_array(event, arg, tok);
+
         } else {
-                die("unknown op '%s'", token);
+                warning("unknown op '%s'", token);
+                event->flags |= EVENT_FL_FAILED;
                 /* the arg is now the left side */
                 return EVENT_NONE;
         }
 
-
         if (type == EVENT_OP) {
                 int prio;
 
@@ -1178,7 +1296,7 @@ process_entry(struct event *event __unused, struct print_arg *arg,
         char *field;
         char *token;
 
-        if (read_expected(EVENT_OP, (char *)"->") < 0)
+        if (read_expected(EVENT_OP, "->") < 0)
                 return EVENT_ERROR;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -1188,6 +1306,16 @@ process_entry(struct event *event __unused, struct print_arg *arg,
         arg->type = PRINT_FIELD;
         arg->field.name = field;
 
+        if (is_flag_field) {
+                arg->field.field = find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_FLAG;
+                is_flag_field = 0;
+        } else if (is_symbolic_field) {
+                arg->field.field = find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_SYMBOLIC;
+                is_symbolic_field = 0;
+        }
+
         type = read_token(&token);
         *tok = token;
 
@@ -1338,25 +1466,25 @@ process_fields(struct event *event, struct print_flag_sym **list, char **tok)
         do {
                 free_token(token);
                 type = read_token_item(&token);
-                if (test_type_token(type, token, EVENT_OP, (char *)"{"))
+                if (test_type_token(type, token, EVENT_OP, "{"))
                         break;
 
                 arg = malloc_or_die(sizeof(*arg));
 
                 free_token(token);
                 type = process_arg(event, arg, &token);
-                if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                if (test_type_token(type, token, EVENT_DELIM, ","))
                         goto out_free;
 
                 field = malloc_or_die(sizeof(*field));
-                memset(field, 0, sizeof(field));
+                memset(field, 0, sizeof(*field));
 
                 value = arg_eval(arg);
                 field->value = strdup(value);
 
                 free_token(token);
                 type = process_arg(event, arg, &token);
-                if (test_type_token(type, token, EVENT_OP, (char *)"}"))
+                if (test_type_token(type, token, EVENT_OP, "}"))
                         goto out_free;
 
                 value = arg_eval(arg);
@@ -1391,13 +1519,13 @@ process_flags(struct event *event, struct print_arg *arg, char **tok)
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_FLAGS;
 
-        if (read_expected_item(EVENT_DELIM, (char *)"(") < 0)
+        if (read_expected_item(EVENT_DELIM, "(") < 0)
                 return EVENT_ERROR;
 
         field = malloc_or_die(sizeof(*field));
 
         type = process_arg(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
         arg->flags.field = field;
@@ -1408,11 +1536,11 @@ process_flags(struct event *event, struct print_arg *arg, char **tok)
                 type = read_token_item(&token);
         }
 
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
         type = process_fields(event, &arg->flags.flags, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)")"))
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -1434,19 +1562,19 @@ process_symbols(struct event *event, struct print_arg *arg, char **tok)
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_SYMBOL;
 
-        if (read_expected_item(EVENT_DELIM, (char *)"(") < 0)
+        if (read_expected_item(EVENT_DELIM, "(") < 0)
                 return EVENT_ERROR;
 
         field = malloc_or_die(sizeof(*field));
 
         type = process_arg(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
         arg->symbol.field = field;
 
         type = process_fields(event, &arg->symbol.symbols, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)")"))
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -1463,7 +1591,6 @@ process_paren(struct event *event, struct print_arg *arg, char **tok)
 {
         struct print_arg *item_arg;
         enum event_type type;
-        int ptr_cast = 0;
         char *token;
 
         type = process_arg(event, arg, &token);
@@ -1471,28 +1598,13 @@ process_paren(struct event *event, struct print_arg *arg, char **tok)
         if (type == EVENT_ERROR)
                 return EVENT_ERROR;
 
-        if (type == EVENT_OP) {
-                /* handle the ptr casts */
-                if (!strcmp(token, "*")) {
-                        /*
-                         * FIXME: should we zapp whitespaces before ')' ?
-                         * (may require a peek_token_item())
-                         */
-                        if (__peek_char() == ')') {
-                                ptr_cast = 1;
-                                free_token(token);
-                                type = read_token_item(&token);
-                        }
-                }
-                if (!ptr_cast) {
-                        type = process_op(event, arg, &token);
+        if (type == EVENT_OP)
+                type = process_op(event, arg, &token);
 
-                        if (type == EVENT_ERROR)
-                                return EVENT_ERROR;
-                }
-        }
+        if (type == EVENT_ERROR)
+                return EVENT_ERROR;
 
-        if (test_type_token(type, token, EVENT_DELIM, (char *)")")) {
+        if (test_type_token(type, token, EVENT_DELIM, ")")) {
                 free_token(token);
                 return EVENT_ERROR;
         }
@@ -1516,13 +1628,6 @@ process_paren(struct event *event, struct print_arg *arg, char **tok)
                 item_arg = malloc_or_die(sizeof(*item_arg));
 
                 arg->type = PRINT_TYPE;
-                if (ptr_cast) {
-                        char *old = arg->atom.atom;
-
-                        arg->atom.atom = malloc_or_die(strlen(old + 3));
-                        sprintf(arg->atom.atom, "%s *", old);
-                        free(old);
-                }
                 arg->typecast.type = arg->atom.atom;
                 arg->typecast.item = item_arg;
                 type = process_arg_token(event, item_arg, &token, type);
@@ -1540,7 +1645,7 @@ process_str(struct event *event __unused, struct print_arg *arg, char **tok)
         enum event_type type;
         char *token;
 
-        if (read_expected(EVENT_DELIM, (char *)"(") < 0)
+        if (read_expected(EVENT_DELIM, "(") < 0)
                 return EVENT_ERROR;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -1550,7 +1655,7 @@ process_str(struct event *event __unused, struct print_arg *arg, char **tok)
         arg->string.string = token;
         arg->string.offset = -1;
 
-        if (read_expected(EVENT_DELIM, (char *)")") < 0)
+        if (read_expected(EVENT_DELIM, ")") < 0)
                 return EVENT_ERROR;
 
         type = read_token(&token);
@@ -1578,9 +1683,11 @@ process_arg_token(struct event *event, struct print_arg *arg,
                         type = process_entry(event, arg, &token);
                 } else if (strcmp(token, "__print_flags") == 0) {
                         free_token(token);
+                        is_flag_field = 1;
                         type = process_flags(event, arg, &token);
                 } else if (strcmp(token, "__print_symbolic") == 0) {
                         free_token(token);
+                        is_symbolic_field = 1;
                         type = process_symbols(event, arg, &token);
                 } else if (strcmp(token, "__get_str") == 0) {
                         free_token(token);
@@ -1637,12 +1744,18 @@ process_arg_token(struct event *event, struct print_arg *arg,
 
 static int event_read_print_args(struct event *event, struct print_arg **list)
 {
-        enum event_type type;
+        enum event_type type = EVENT_ERROR;
         struct print_arg *arg;
         char *token;
         int args = 0;
 
         do {
+                if (type == EVENT_NEWLINE) {
+                        free_token(token);
+                        type = read_token_item(&token);
+                        continue;
+                }
+
                 arg = malloc_or_die(sizeof(*arg));
                 memset(arg, 0, sizeof(*arg));
 
@@ -1683,18 +1796,19 @@ static int event_read_print(struct event *event)
         char *token;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, (char *)"print") < 0)
+        if (read_expected_item(EVENT_ITEM, "print") < 0)
                 return -1;
 
-        if (read_expected(EVENT_ITEM, (char *)"fmt") < 0)
+        if (read_expected(EVENT_ITEM, "fmt") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return -1;
 
         if (read_expect_type(EVENT_DQUOTE, &token) < 0)
                 goto fail;
 
+ concat:
         event->print_fmt.format = token;
         event->print_fmt.args = NULL;
 
@@ -1704,7 +1818,22 @@ static int event_read_print(struct event *event)
         if (type == EVENT_NONE)
                 return 0;
 
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        /* Handle concatination of print lines */
+        if (type == EVENT_DQUOTE) {
+                char *cat;
+
+                cat = malloc_or_die(strlen(event->print_fmt.format) +
+                                    strlen(token) + 1);
+                strcpy(cat, event->print_fmt.format);
+                strcat(cat, token);
+                free_token(token);
+                free_token(event->print_fmt.format);
+                event->print_fmt.format = NULL;
+                token = cat;
+                goto concat;
+        }
+
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto fail;
 
         free_token(token);
@@ -1713,7 +1842,7 @@ static int event_read_print(struct event *event)
         if (ret < 0)
                 return -1;
 
-        return 0;
+        return ret;
 
  fail:
         free_token(token);
@@ -1759,7 +1888,7 @@ find_any_field(struct event *event, const char *name)
         return find_field(event, name);
 }
 
-static unsigned long long read_size(void *ptr, int size)
+unsigned long long read_size(void *ptr, int size)
 {
         switch (size) {
         case 1:
@@ -1796,6 +1925,15 @@ void *raw_field_ptr(struct event *event, const char *name, void *data)
         if (!field)
                 return NULL;
 
+        if (field->flags & FIELD_IS_DYNAMIC) {
+                int offset;
+
+                offset = *(int *)(data + field->offset);
+                offset &= 0xffff;
+
+                return data + offset;
+        }
+
         return data + field->offset;
 }
 
@@ -1822,37 +1960,67 @@ static int get_common_info(const char *type, int *offset, int *size)
         return 0;
 }
 
-int trace_parse_common_type(void *data)
+static int __parse_common(void *data, int *size, int *offset,
+                          const char *name)
 {
-        static int type_offset;
-        static int type_size;
         int ret;
 
-        if (!type_size) {
-                ret = get_common_info("common_type",
-                                      &type_offset,
-                                      &type_size);
+        if (!*size) {
+                ret = get_common_info(name, offset, size);
                 if (ret < 0)
                         return ret;
         }
-        return read_size(data + type_offset, type_size);
+        return read_size(data + *offset, *size);
 }
 
-static int parse_common_pid(void *data)
+int trace_parse_common_type(void *data)
+{
+        static int type_offset;
+        static int type_size;
+
+        return __parse_common(data, &type_size, &type_offset,
+                              "common_type");
+}
+
+int trace_parse_common_pid(void *data)
 {
         static int pid_offset;
         static int pid_size;
+
+        return __parse_common(data, &pid_size, &pid_offset,
+                              "common_pid");
+}
+
+int parse_common_pc(void *data)
+{
+        static int pc_offset;
+        static int pc_size;
+
+        return __parse_common(data, &pc_size, &pc_offset,
+                              "common_preempt_count");
+}
+
+int parse_common_flags(void *data)
+{
+        static int flags_offset;
+        static int flags_size;
+
+        return __parse_common(data, &flags_size, &flags_offset,
+                              "common_flags");
+}
+
+int parse_common_lock_depth(void *data)
+{
+        static int ld_offset;
+        static int ld_size;
         int ret;
 
-        if (!pid_size) {
-                ret = get_common_info("common_pid",
-                                      &pid_offset,
-                                      &pid_size);
-                if (ret < 0)
-                        return ret;
-        }
+        ret = __parse_common(data, &ld_size, &ld_offset,
+                             "common_lock_depth");
+        if (ret < 0)
+                return -1;
 
-        return read_size(data + pid_offset, pid_size);
+        return ret;
 }
 
 struct event *trace_find_event(int id)
@@ -1866,11 +2034,20 @@ struct event *trace_find_event(int id)
         return event;
 }
 
+struct event *trace_find_next_event(struct event *event)
+{
+        if (!event)
+                return event_list;
+
+        return event->next;
+}
+
 static unsigned long long eval_num_arg(void *data, int size,
                                    struct event *event, struct print_arg *arg)
 {
         unsigned long long val = 0;
         unsigned long long left, right;
+        struct print_arg *larg;
 
         switch (arg->type) {
         case PRINT_NULL:
@@ -1897,6 +2074,26 @@ static unsigned long long eval_num_arg(void *data, int size,
                 return 0;
                 break;
         case PRINT_OP:
+                if (strcmp(arg->op.op, "[") == 0) {
+                        /*
+                         * Arrays are special, since we don't want
+                         * to read the arg as is.
+                         */
+                        if (arg->op.left->type != PRINT_FIELD)
+                                goto default_op; /* oops, all bets off */
+                        larg = arg->op.left;
+                        if (!larg->field.field) {
+                                larg->field.field =
+                                        find_any_field(event, larg->field.name);
+                                if (!larg->field.field)
+                                        die("field %s not found", larg->field.name);
+                        }
+                        right = eval_num_arg(data, size, event, arg->op.right);
+                        val = read_size(data + larg->field.field->offset +
+                                        right * long_size, long_size);
+                        break;
+                }
+ default_op:
                 left = eval_num_arg(data, size, event, arg->op.left);
                 right = eval_num_arg(data, size, event, arg->op.right);
                 switch (arg->op.op[0]) {
@@ -1947,6 +2144,12 @@ static unsigned long long eval_num_arg(void *data, int size,
                                 die("unknown op '%s'", arg->op.op);
                         val = left == right;
                         break;
+                case '-':
+                        val = left - right;
+                        break;
+                case '+':
+                        val = left + right;
+                        break;
                 default:
                         die("unknown op '%s'", arg->op.op);
                 }
@@ -1978,7 +2181,7 @@ static const struct flag flags[] = {
         { "HRTIMER_RESTART", 1 },
 };
 
-static unsigned long long eval_flag(const char *flag)
+unsigned long long eval_flag(const char *flag)
 {
         int i;
 
@@ -2145,8 +2348,9 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                         case 'u':
                         case 'x':
                         case 'i':
-                                bptr = (void *)(((unsigned long)bptr + (long_size - 1)) &
-                                                ~(long_size - 1));
+                                /* the pointers are always 4 bytes aligned */
+                                bptr = (void *)(((unsigned long)bptr + 3) &
+                                                ~3);
                                 switch (ls) {
                                 case 0:
                                 case 1:
@@ -2270,7 +2474,27 @@ static void pretty_print(void *data, int size, struct event *event)
 
         for (; *ptr; ptr++) {
                 ls = 0;
-                if (*ptr == '%') {
+                if (*ptr == '\\') {
+                        ptr++;
+                        switch (*ptr) {
+                        case 'n':
+                                printf("\n");
+                                break;
+                        case 't':
+                                printf("\t");
+                                break;
+                        case 'r':
+                                printf("\r");
+                                break;
+                        case '\\':
+                                printf("\\");
+                                break;
+                        default:
+                                printf("%c", *ptr);
+                                break;
+                        }
+
+                } else if (*ptr == '%') {
                         saveptr = ptr;
                         show_func = 0;
  cont_process:
@@ -2377,6 +2601,41 @@ static inline int log10_cpu(int nb)
         return 1;
 }
 
+static void print_lat_fmt(void *data, int size __unused)
+{
+        unsigned int lat_flags;
+        unsigned int pc;
+        int lock_depth;
+        int hardirq;
+        int softirq;
+
+        lat_flags = parse_common_flags(data);
+        pc = parse_common_pc(data);
+        lock_depth = parse_common_lock_depth(data);
+
+        hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
+        softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
+
+        printf("%c%c%c",
+               (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+               (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
+               'X' : '.',
+               (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
+               'N' : '.',
+               (hardirq && softirq) ? 'H' :
+               hardirq ? 'h' : softirq ? 's' : '.');
+
+        if (pc)
+                printf("%x", pc);
+        else
+                printf(".");
+
+        if (lock_depth < 0)
+                printf(".");
+        else
+                printf("%d", lock_depth);
+}
+
 /* taken from Linux, written by Frederic Weisbecker */
 static void print_graph_cpu(int cpu)
 {
@@ -2452,7 +2711,7 @@ get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
         if (!(event->flags & EVENT_FL_ISFUNCRET))
                 return NULL;
 
-        pid = parse_common_pid(next->data);
+        pid = trace_parse_common_pid(next->data);
         field = find_field(event, "func");
         if (!field)
                 die("function return does not have field func");
@@ -2620,6 +2879,11 @@ pretty_print_func_ent(void *data, int size, struct event *event,
 
         printf(" | ");
 
+        if (latency_format) {
+                print_lat_fmt(data, size);
+                printf(" | ");
+        }
+
         field = find_field(event, "func");
         if (!field)
                 die("function entry does not have func field");
@@ -2663,6 +2927,11 @@ pretty_print_func_ret(void *data, int size __unused, struct event *event,
 
         printf(" | ");
 
+        if (latency_format) {
+                print_lat_fmt(data, size);
+                printf(" | ");
+        }
+
         field = find_field(event, "rettime");
         if (!field)
                 die("can't find rettime in return graph");
@@ -2724,19 +2993,30 @@ void print_event(int cpu, void *data, int size, unsigned long long nsecs,
 
         event = trace_find_event(type);
         if (!event) {
-                printf("ug! no event found for type %d\n", type);
+                warning("ug! no event found for type %d", type);
                 return;
         }
 
-        pid = parse_common_pid(data);
+        pid = trace_parse_common_pid(data);
 
         if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
                 return pretty_print_func_graph(data, size, event, cpu,
                                                pid, comm, secs, usecs);
 
-        printf("%16s-%-5d [%03d] %5lu.%09Lu: %s: ",
-               comm, pid,  cpu,
-               secs, nsecs, event->name);
+        if (latency_format) {
+                printf("%8.8s-%-5d %3d",
+                       comm, pid, cpu);
+                print_lat_fmt(data, size);
+        } else
+                printf("%16s-%-5d [%03d]", comm, pid,  cpu);
+
+        printf(" %5lu.%06lu: %s: ", secs, usecs, event->name);
+
+        if (event->flags & EVENT_FL_FAILED) {
+                printf("EVENT '%s' FAILED TO PARSE\n",
+                       event->name);
+                return;
+        }
 
         pretty_print(data, size, event);
         printf("\n");
@@ -2807,46 +3087,71 @@ static void print_args(struct print_arg *args)
         }
 }
 
-static void parse_header_field(char *type,
+static void parse_header_field(const char *field,
                                int *offset, int *size)
 {
         char *token;
+        int type;
 
-        if (read_expected(EVENT_ITEM, (char *)"field") < 0)
+        if (read_expected(EVENT_ITEM, "field") < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return;
+
         /* type */
         if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
+                goto fail;
         free_token(token);
 
-        if (read_expected(EVENT_ITEM, type) < 0)
+        if (read_expected(EVENT_ITEM, field) < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)";") < 0)
+        if (read_expected(EVENT_OP, ";") < 0)
                 return;
-        if (read_expected(EVENT_ITEM, (char *)"offset") < 0)
+        if (read_expected(EVENT_ITEM, "offset") < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return;
         if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
+                goto fail;
         *offset = atoi(token);
         free_token(token);
-        if (read_expected(EVENT_OP, (char *)";") < 0)
+        if (read_expected(EVENT_OP, ";") < 0)
                 return;
-        if (read_expected(EVENT_ITEM, (char *)"size") < 0)
+        if (read_expected(EVENT_ITEM, "size") < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return;
         if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
+                goto fail;
         *size = atoi(token);
         free_token(token);
-        if (read_expected(EVENT_OP, (char *)";") < 0)
-                return;
-        if (read_expect_type(EVENT_NEWLINE, &token) < 0)
+        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);
 }
 
@@ -2854,11 +3159,11 @@ int parse_header_page(char *buf, unsigned long size)
 {
         init_input_buf(buf, size);
 
-        parse_header_field((char *)"timestamp", &header_page_ts_offset,
+        parse_header_field("timestamp", &header_page_ts_offset,
                            &header_page_ts_size);
-        parse_header_field((char *)"commit", &header_page_size_offset,
+        parse_header_field("commit", &header_page_size_offset,
                            &header_page_size_size);
-        parse_header_field((char *)"data", &header_page_data_offset,
+        parse_header_field("data", &header_page_data_offset,
                            &header_page_data_size);
 
         return 0;
@@ -2909,6 +3214,9 @@ int parse_ftrace_file(char *buf, unsigned long size)
         if (ret < 0)
                 die("failed to read ftrace event print fmt");
 
+        /* New ftrace handles args */
+        if (ret > 0)
+                return 0;
         /*
          * The arguments for ftrace files are parsed by the fields.
          * Set up the fields as their arguments.
@@ -2926,7 +3234,7 @@ int parse_ftrace_file(char *buf, unsigned long size)
         return 0;
 }
 
-int parse_event_file(char *buf, unsigned long size, char *system__unused __unused)
+int parse_event_file(char *buf, unsigned long size, char *sys)
 {
         struct event *event;
         int ret;
@@ -2946,12 +3254,18 @@ int parse_event_file(char *buf, unsigned long size, char *system__unused __unuse
                 die("failed to read event id");
 
         ret = event_read_format(event);
-        if (ret < 0)
-                die("failed to read event format");
+        if (ret < 0) {
+                warning("failed to read event format for %s", event->name);
+                goto event_failed;
+        }
 
         ret = event_read_print(event);
-        if (ret < 0)
-                die("failed to read event print fmt");
+        if (ret < 0) {
+                warning("failed to read event print fmt for %s", event->name);
+                goto event_failed;
+        }
+
+        event->system = strdup(sys);
 
 #define PRINT_ARGS 0
         if (PRINT_ARGS && event->print_fmt.args)
@@ -2959,6 +3273,12 @@ int parse_event_file(char *buf, unsigned long size, char *system__unused __unuse
 
         add_event(event);
         return 0;
+
+ event_failed:
+        event->flags |= EVENT_FL_FAILED;
+        /* still add it even if it failed */
+        add_event(event);
+        return -1;
 }
 
 void parse_set_info(int nr_cpus, int long_sz)
@@ -2966,3 +3286,18 @@ void parse_set_info(int nr_cpus, int long_sz)
         cpus = nr_cpus;
         long_size = long_sz;
 }
+
+int common_pc(struct scripting_context *context)
+{
+        return parse_common_pc(context->event_data);
+}
+
+int common_flags(struct scripting_context *context)
+{
+        return parse_common_flags(context->event_data);
+}
+
+int common_lock_depth(struct scripting_context *context)
+{
+        return parse_common_lock_depth(context->event_data);
+}
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 1b5c847d2c22..7cd1193918c7 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -18,7 +18,7 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#define _LARGEFILE64_SOURCE
+#define _FILE_OFFSET_BITS 64
 
 #include <dirent.h>
 #include <stdio.h>
@@ -83,7 +83,7 @@ static char *read_string(void)
         char *str = NULL;
         int size = 0;
         int i;
-        int r;
+        off_t r;
 
         for (;;) {
                 r = read(input_fd, buf, BUFSIZ);
@@ -118,7 +118,7 @@ static char *read_string(void)
 
         /* move the file descriptor to the end of the string */
         r = lseek(input_fd, -(r - i), SEEK_CUR);
-        if (r < 0)
+        if (r == (off_t)-1)
                 die("lseek");
 
         if (str) {
@@ -145,8 +145,9 @@ static void read_proc_kallsyms(void)
         if (!size)
                 return;
 
-        buf = malloc_or_die(size);
+        buf = malloc_or_die(size + 1);
         read_or_die(buf, size);
+        buf[size] = '\0';
 
         parse_proc_kallsyms(buf, size);
 
@@ -281,8 +282,8 @@ static void update_cpu_data_index(int cpu)
 
 static void get_next_page(int cpu)
 {
-        off64_t save_seek;
-        off64_t ret;
+        off_t save_seek;
+        off_t ret;
 
         if (!cpu_data[cpu].page)
                 return;
@@ -297,17 +298,17 @@ static void get_next_page(int cpu)
                 update_cpu_data_index(cpu);
 
                 /* other parts of the code may expect the pointer to not move */
-                save_seek = lseek64(input_fd, 0, SEEK_CUR);
+                save_seek = lseek(input_fd, 0, SEEK_CUR);
 
-                ret = lseek64(input_fd, cpu_data[cpu].offset, SEEK_SET);
-                if (ret < 0)
+                ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
+                if (ret == (off_t)-1)
                         die("failed to lseek");
                 ret = read(input_fd, cpu_data[cpu].page, page_size);
                 if (ret < 0)
                         die("failed to read page");
 
                 /* reset the file pointer back */
-                lseek64(input_fd, save_seek, SEEK_SET);
+                lseek(input_fd, save_seek, SEEK_SET);
 
                 return;
         }
@@ -458,9 +459,8 @@ struct record *trace_read_data(int cpu)
         return data;
 }
 
-void trace_report(void)
+void trace_report(int fd)
 {
-        const char *input_file = "trace.info";
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
         char *version;
@@ -468,17 +468,15 @@ void trace_report(void)
         int show_funcs = 0;
         int show_printk = 0;
 
-        input_fd = open(input_file, O_RDONLY);
-        if (input_fd < 0)
-                die("opening '%s'\n", input_file);
+        input_fd = fd;
 
         read_or_die(buf, 3);
         if (memcmp(buf, test, 3) != 0)
-                die("not an trace data file");
+                die("no trace data in the file");
 
         read_or_die(buf, 7);
         if (memcmp(buf, "tracing", 7) != 0)
-                die("not a trace file (missing tracing)");
+                die("not a trace file (missing 'tracing' tag)");
 
         version = read_string();
         if (show_version)
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
new file mode 100644
index 000000000000..7ea983acfaea
--- /dev/null
+++ b/tools/perf/util/trace-event-scripting.c
@@ -0,0 +1,167 @@
+/*
+ * trace-event-scripting.  Scripting engine common and initialization code.
+ *
+ * Copyright (C) 2009-2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../perf.h"
+#include "util.h"
+#include "trace-event.h"
+
+struct scripting_context *scripting_context;
+
+static int stop_script_unsupported(void)
+{
+        return 0;
+}
+
+static void process_event_unsupported(int cpu __unused,
+                                      void *data __unused,
+                                      int size __unused,
+                                      unsigned long long nsecs __unused,
+                                      char *comm __unused)
+{
+}
+
+static void print_python_unsupported_msg(void)
+{
+        fprintf(stderr, "Python scripting not supported."
+                "  Install libpython and rebuild perf to enable it.\n"
+                "For example:\n  # apt-get install python-dev (ubuntu)"
+                "\n  # yum install python-devel (Fedora)"
+                "\n  etc.\n");
+}
+
+static int python_start_script_unsupported(const char *script __unused,
+                                           int argc __unused,
+                                           const char **argv __unused)
+{
+        print_python_unsupported_msg();
+
+        return -1;
+}
+
+static int python_generate_script_unsupported(const char *outfile __unused)
+{
+        print_python_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops python_scripting_unsupported_ops = {
+        .name = "Python",
+        .start_script = python_start_script_unsupported,
+        .stop_script = stop_script_unsupported,
+        .process_event = process_event_unsupported,
+        .generate_script = python_generate_script_unsupported,
+};
+
+static void register_python_scripting(struct scripting_ops *scripting_ops)
+{
+        int err;
+        err = script_spec_register("Python", scripting_ops);
+        if (err)
+                die("error registering Python script extension");
+
+        err = script_spec_register("py", scripting_ops);
+        if (err)
+                die("error registering py script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+
+#ifdef NO_LIBPYTHON
+void setup_python_scripting(void)
+{
+        register_python_scripting(&python_scripting_unsupported_ops);
+}
+#else
+struct scripting_ops python_scripting_ops;
+
+void setup_python_scripting(void)
+{
+        register_python_scripting(&python_scripting_ops);
+}
+#endif
+
+static void print_perl_unsupported_msg(void)
+{
+        fprintf(stderr, "Perl scripting not supported."
+                "  Install libperl and rebuild perf to enable it.\n"
+                "For example:\n  # apt-get install libperl-dev (ubuntu)"
+                "\n  # yum install 'perl(ExtUtils::Embed)' (Fedora)"
+                "\n  etc.\n");
+}
+
+static int perl_start_script_unsupported(const char *script __unused,
+                                         int argc __unused,
+                                         const char **argv __unused)
+{
+        print_perl_unsupported_msg();
+
+        return -1;
+}
+
+static int perl_generate_script_unsupported(const char *outfile __unused)
+{
+        print_perl_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops perl_scripting_unsupported_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script_unsupported,
+        .stop_script = stop_script_unsupported,
+        .process_event = process_event_unsupported,
+        .generate_script = perl_generate_script_unsupported,
+};
+
+static void register_perl_scripting(struct scripting_ops *scripting_ops)
+{
+        int err;
+        err = script_spec_register("Perl", scripting_ops);
+        if (err)
+                die("error registering Perl script extension");
+
+        err = script_spec_register("pl", scripting_ops);
+        if (err)
+                die("error registering pl script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+
+#ifdef NO_LIBPERL
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_unsupported_ops);
+}
+#else
+struct scripting_ops perl_scripting_ops;
+
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_ops);
+}
+#endif
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 693f815c9429..c3269b937db4 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,5 +1,5 @@
-#ifndef _TRACE_EVENTS_H
-#define _TRACE_EVENTS_H
+#ifndef __PERF_TRACE_EVENTS_H
+#define __PERF_TRACE_EVENTS_H
 
 #include "parse-events.h"
 
@@ -26,6 +26,11 @@ enum {
 enum format_flags {
         FIELD_IS_ARRAY          = 1,
         FIELD_IS_POINTER        = 2,
+        FIELD_IS_SIGNED         = 4,
+        FIELD_IS_STRING         = 8,
+        FIELD_IS_DYNAMIC        = 16,
+        FIELD_IS_FLAG           = 32,
+        FIELD_IS_SYMBOLIC       = 64,
 };
 
 struct format_field {
@@ -132,15 +137,18 @@ struct event {
         int                     flags;
         struct format           format;
         struct print_fmt        print_fmt;
+        char                    *system;
 };
 
 enum {
-        EVENT_FL_ISFTRACE       = 1,
-        EVENT_FL_ISPRINT        = 2,
-        EVENT_FL_ISBPRINT       = 4,
-        EVENT_FL_ISFUNC         = 8,
-        EVENT_FL_ISFUNCENT      = 16,
-        EVENT_FL_ISFUNCRET      = 32,
+        EVENT_FL_ISFTRACE       = 0x01,
+        EVENT_FL_ISPRINT        = 0x02,
+        EVENT_FL_ISBPRINT       = 0x04,
+        EVENT_FL_ISFUNC         = 0x08,
+        EVENT_FL_ISFUNCENT      = 0x10,
+        EVENT_FL_ISFUNCRET      = 0x20,
+
+        EVENT_FL_FAILED         = 0x80000000
 };
 
 struct record {
@@ -154,7 +162,7 @@ struct record *trace_read_data(int cpu);
 
 void parse_set_info(int nr_cpus, int long_sz);
 
-void trace_report(void);
+void trace_report(int fd);
 
 void *malloc_or_die(unsigned int size);
 
@@ -166,7 +174,7 @@ void print_funcs(void);
 void print_printk(void);
 
 int parse_ftrace_file(char *buf, unsigned long size);
-int parse_event_file(char *buf, unsigned long size, char *system);
+int parse_event_file(char *buf, unsigned long size, char *sys);
 void print_event(int cpu, void *data, int size, unsigned long long nsecs,
                   char *comm);
 
@@ -233,13 +241,53 @@ extern int header_page_size_size;
 extern int header_page_data_offset;
 extern int header_page_data_size;
 
+extern int 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);
+int parse_common_flags(void *data);
+int parse_common_lock_depth(void *data);
 struct event *trace_find_event(int id);
+struct event *trace_find_next_event(struct event *event);
+unsigned long long read_size(void *ptr, int size);
 unsigned long long
 raw_field_value(struct event *event, const char *name, void *data);
 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);
+
+/* taken from kernel/trace/trace.h */
+enum trace_flag_type {
+        TRACE_FLAG_IRQS_OFF             = 0x01,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
+        TRACE_FLAG_HARDIRQ              = 0x08,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+};
+
+struct scripting_ops {
+        const char *name;
+        int (*start_script) (const char *script, int argc, const char **argv);
+        int (*stop_script) (void);
+        void (*process_event) (int cpu, void *data, int size,
+                               unsigned long long nsecs, char *comm);
+        int (*generate_script) (const char *outfile);
+};
+
+int script_spec_register(const char *spec, struct scripting_ops *ops);
+
+void setup_perl_scripting(void);
+void setup_python_scripting(void);
+
+struct scripting_context {
+        void *event_data;
+};
 
-void read_tracing_data(struct perf_event_attr *pattrs, int nb_events);
+int common_pc(struct scripting_context *context);
+int common_flags(struct scripting_context *context);
+int common_lock_depth(struct scripting_context *context);
 
-#endif /* _TRACE_EVENTS_H */
+#endif /* __PERF_TRACE_EVENTS_H */
diff --git a/tools/perf/util/types.h b/tools/perf/util/types.h
index 5e75f9005940..7d6b8331f898 100644
--- a/tools/perf/util/types.h
+++ b/tools/perf/util/types.h
@@ -1,5 +1,5 @@
-#ifndef _PERF_TYPES_H
-#define _PERF_TYPES_H
+#ifndef __PERF_TYPES_H
+#define __PERF_TYPES_H
 
 /*
  * We define u64 as unsigned long long for every architecture
@@ -14,4 +14,4 @@ typedef signed short	   s16;
 typedef unsigned char      u8;
 typedef signed char        s8;
 
-#endif /* _PERF_TYPES_H */
+#endif /* __PERF_TYPES_H */
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
new file mode 100644
index 000000000000..f9b890fde681
--- /dev/null
+++ b/tools/perf/util/util.c
@@ -0,0 +1,94 @@
+#include "util.h"
+#include <sys/mman.h>
+
+int mkdir_p(char *path, mode_t mode)
+{
+        struct stat st;
+        int err;
+        char *d = path;
+
+        if (*d != '/')
+                return -1;
+
+        if (stat(path, &st) == 0)
+                return 0;
+
+        while (*++d == '/');
+
+        while ((d = strchr(d, '/'))) {
+                *d = '\0';
+                err = stat(path, &st) && mkdir(path, mode);
+                *d++ = '/';
+                if (err)
+                        return -1;
+                while (*d == '/')
+                        ++d;
+        }
+        return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
+}
+
+static int slow_copyfile(const char *from, const char *to)
+{
+        int err = 0;
+        char *line = NULL;
+        size_t n;
+        FILE *from_fp = fopen(from, "r"), *to_fp;
+
+        if (from_fp == NULL)
+                goto out;
+
+        to_fp = fopen(to, "w");
+        if (to_fp == NULL)
+                goto out_fclose_from;
+
+        while (getline(&line, &n, from_fp) > 0)
+                if (fputs(line, to_fp) == EOF)
+                        goto out_fclose_to;
+        err = 0;
+out_fclose_to:
+        fclose(to_fp);
+        free(line);
+out_fclose_from:
+        fclose(from_fp);
+out:
+        return err;
+}
+
+int copyfile(const char *from, const char *to)
+{
+        int fromfd, tofd;
+        struct stat st;
+        void *addr;
+        int err = -1;
+
+        if (stat(from, &st))
+                goto out;
+
+        if (st.st_size == 0) /* /proc? do it slowly... */
+                return slow_copyfile(from, to);
+
+        fromfd = open(from, O_RDONLY);
+        if (fromfd < 0)
+                goto out;
+
+        tofd = creat(to, 0755);
+        if (tofd < 0)
+                goto out_close_from;
+
+        addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fromfd, 0);
+        if (addr == MAP_FAILED)
+                goto out_close_to;
+
+        if (write(tofd, addr, st.st_size) == st.st_size)
+                err = 0;
+
+        munmap(addr, st.st_size);
+out_close_to:
+        close(tofd);
+        if (err)
+                unlink(to);
+out_close_from:
+        close(fromfd);
+out:
+        return err;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 9de2329dd44d..0f5b2a6f1080 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -84,6 +84,9 @@
 #include <iconv.h>
 #endif
 
+extern const char *graph_line;
+extern const char *graph_dotted_line;
+
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
  */
@@ -134,6 +137,15 @@ extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1,
 extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 
+#include "../../../include/linux/stringify.h"
+
+#define DIE_IF(cnd)     \
+        do { if (cnd)   \
+                die(" at (" __FILE__ ":" __stringify(__LINE__) "): "    \
+                    __stringify(cnd) "\n");                             \
+        } while (0)
+
+
 extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
 
 extern int prefixcmp(const char *str, const char *prefix);
@@ -278,17 +290,15 @@ static inline char *gitstrchrnul(const char *s, int c)
  * Wrappers:
  */
 extern char *xstrdup(const char *str);
-extern void *xmalloc(size_t size);
+extern void *xmalloc(size_t size) __attribute__((weak));
 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);
-extern void *xcalloc(size_t nmemb, size_t size);
-extern void *xmmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
-extern ssize_t xread(int fd, void *buf, size_t len);
-extern ssize_t xwrite(int fd, const void *buf, size_t len);
-extern int xdup(int fd);
-extern FILE *xfdopen(int fd, const char *mode);
-extern int xmkstemp(char *template);
+extern void *xrealloc(void *ptr, size_t size) __attribute__((weak));
+
+static inline void *zalloc(size_t size)
+{
+        return calloc(1, size);
+}
 
 static inline size_t xsize_t(off_t len)
 {
@@ -306,6 +316,7 @@ static inline int has_extension(const char *filename, const char *ext)
 #undef isascii
 #undef isspace
 #undef isdigit
+#undef isxdigit
 #undef isalpha
 #undef isprint
 #undef isalnum
@@ -323,6 +334,8 @@ extern unsigned char sane_ctype[256];
 #define isascii(x) (((x) & ~0x7f) == 0)
 #define isspace(x) sane_istest(x,GIT_SPACE)
 #define isdigit(x) sane_istest(x,GIT_DIGIT)
+#define isxdigit(x)     \
+        (sane_istest(toupper(x), GIT_ALPHA | GIT_DIGIT) && toupper(x) < 'G')
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
@@ -390,4 +403,7 @@ void git_qsort(void *base, size_t nmemb, size_t size,
 #endif
 #endif
 
+int mkdir_p(char *path, mode_t mode);
+int copyfile(const char *from, const char *to);
+
 #endif
diff --git a/tools/perf/util/values.c b/tools/perf/util/values.c
index 1c15e39f99e3..cfa55d686e3b 100644
--- a/tools/perf/util/values.c
+++ b/tools/perf/util/values.c
@@ -169,6 +169,7 @@ static void perf_read_values__display_pretty(FILE *fp,
                                 counterwidth[j], values->value[i][j]);
                 fprintf(fp, "\n");
         }
+        free(counterwidth);
 }
 
 static void perf_read_values__display_raw(FILE *fp,
diff --git a/tools/perf/util/values.h b/tools/perf/util/values.h
index cadf8cf2a590..2fa967e1a88a 100644
--- a/tools/perf/util/values.h
+++ b/tools/perf/util/values.h
@@ -1,5 +1,5 @@
-#ifndef _PERF_VALUES_H
-#define _PERF_VALUES_H
+#ifndef __PERF_VALUES_H
+#define __PERF_VALUES_H
 
 #include "types.h"
 
@@ -24,4 +24,4 @@ void perf_read_values_add_value(struct perf_read_values *values,
 void perf_read_values_display(FILE *fp, struct perf_read_values *values,
                               int raw);
 
-#endif /* _PERF_VALUES_H */
+#endif /* __PERF_VALUES_H */
diff --git a/tools/perf/util/wrapper.c b/tools/perf/util/wrapper.c
index 4574ac28396f..bf44ca85d23b 100644
--- a/tools/perf/util/wrapper.c
+++ b/tools/perf/util/wrapper.c
@@ -79,43 +79,12 @@ void *xrealloc(void *ptr, size_t size)
         return ret;
 }
 
-void *xcalloc(size_t nmemb, size_t size)
-{
-        void *ret = calloc(nmemb, size);
-        if (!ret && (!nmemb || !size))
-                ret = calloc(1, 1);
-        if (!ret) {
-                release_pack_memory(nmemb * size, -1);
-                ret = calloc(nmemb, size);
-                if (!ret && (!nmemb || !size))
-                        ret = calloc(1, 1);
-                if (!ret)
-                        die("Out of memory, calloc failed");
-        }
-        return ret;
-}
-
-void *xmmap(void *start, size_t length,
-        int prot, int flags, int fd, off_t offset)
-{
-        void *ret = mmap(start, length, prot, flags, fd, offset);
-        if (ret == MAP_FAILED) {
-                if (!length)
-                        return NULL;
-                release_pack_memory(length, fd);
-                ret = mmap(start, length, prot, flags, fd, offset);
-                if (ret == MAP_FAILED)
-                        die("Out of memory? mmap failed: %s", strerror(errno));
-        }
-        return ret;
-}
-
 /*
  * xread() is the same a read(), but it automatically restarts read()
  * operations with a recoverable error (EAGAIN and EINTR). xread()
  * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
  */
-ssize_t xread(int fd, void *buf, size_t len)
+static ssize_t xread(int fd, void *buf, size_t len)
 {
         ssize_t nr;
         while (1) {
@@ -131,7 +100,7 @@ ssize_t xread(int fd, void *buf, size_t len)
  * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
  * GUARANTEE that "len" bytes is written even if the operation is successful.
  */
-ssize_t xwrite(int fd, const void *buf, size_t len)
+static ssize_t xwrite(int fd, const void *buf, size_t len)
 {
         ssize_t nr;
         while (1) {
@@ -179,29 +148,3 @@ ssize_t write_in_full(int fd, const void *buf, size_t count)
 
         return total;
 }
-
-int xdup(int fd)
-{
-        int ret = dup(fd);
-        if (ret < 0)
-                die("dup failed: %s", strerror(errno));
-        return ret;
-}
-
-FILE *xfdopen(int fd, const char *mode)
-{
-        FILE *stream = fdopen(fd, mode);
-        if (stream == NULL)
-                die("Out of memory? fdopen failed: %s", strerror(errno));
-        return stream;
-}
-
-int xmkstemp(char *template)
-{
-        int fd;
-
-        fd = mkstemp(template);
-        if (fd < 0)
-                die("Unable to create temporary file: %s", strerror(errno));
-        return fd;
-}