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

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

User visible changes:

- Fix ordering of kernel/user entries in 'caller' mode, where the kernel and
  user parts were being correctly inverted but kept in place wrt each other,
  i.e. 'callee' (k1, k2, u3, u4) became 'caller' (k2, k1, u4, u3) when it
  should be 'caller' (u4, u3, k2, k1) (Chris Phlipot)

- In 'perf trace' don't print the raw arg syscall args for a syscall that has
  no arguments, like gettid(). This was happening because just checking if
  the syscall args list is NULL may mean that there are no args (e.g.: gettid)
  or that there is no tracepoint info (e.g.: clone) (Arnaldo Carvalho de Melo)

- Add extra output of counter values with 'perf stat -vv' (Andi Kleen)

Infrastructure changes:

- Expose callchain db export via the python API (Chris Phlipot)

Code reorganization:

- Move some more syscall arg beautifiers from the 'perf trace' main file to
  separate files in tools/perf/trace/beauty/, to reduce the main file line
  count (Arnaldo Carvalho de Melo)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

15 files changed, 575 insertions, 348 deletions

diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 1f19f2f999c8..5645a8361de6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -298,6 +298,14 @@ static int read_counter(struct perf_evsel *counter)
                                         return -1;
                                 }
                         }
+
+                        if (verbose > 1) {
+                                fprintf(stat_config.output,
+                                        "%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
+                                                perf_evsel__name(counter),
+                                                cpu,
+                                                count->val, count->ena, count->run);
+                        }
                 }
         }
 
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 66aa2a00414b..709963740f9a 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -40,7 +40,6 @@
 
 #include <libaudit.h> /* FIXME: Still needed for audit_errno_to_name */
 #include <stdlib.h>
-#include <linux/futex.h>
 #include <linux/err.h>
 #include <linux/seccomp.h>
 #include <linux/filter.h>
@@ -401,49 +400,6 @@ static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
 
 #define SCA_FLOCK syscall_arg__scnprintf_flock
 
-static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
-{
-        enum syscall_futex_args {
-                SCF_UADDR   = (1 << 0),
-                SCF_OP      = (1 << 1),
-                SCF_VAL     = (1 << 2),
-                SCF_TIMEOUT = (1 << 3),
-                SCF_UADDR2  = (1 << 4),
-                SCF_VAL3    = (1 << 5),
-        };
-        int op = arg->val;
-        int cmd = op & FUTEX_CMD_MASK;
-        size_t printed = 0;
-
-        switch (cmd) {
-#define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
-        P_FUTEX_OP(WAIT);           arg->mask |= SCF_VAL3|SCF_UADDR2;             break;
-        P_FUTEX_OP(WAKE);           arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
-        P_FUTEX_OP(FD);             arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
-        P_FUTEX_OP(REQUEUE);        arg->mask |= SCF_VAL3|SCF_TIMEOUT;            break;
-        P_FUTEX_OP(CMP_REQUEUE);    arg->mask |= SCF_TIMEOUT;                     break;
-        P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT;                     break;
-        P_FUTEX_OP(WAKE_OP);                                                      break;
-        P_FUTEX_OP(LOCK_PI);        arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
-        P_FUTEX_OP(UNLOCK_PI);      arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
-        P_FUTEX_OP(TRYLOCK_PI);     arg->mask |= SCF_VAL3|SCF_UADDR2;             break;
-        P_FUTEX_OP(WAIT_BITSET);    arg->mask |= SCF_UADDR2;                      break;
-        P_FUTEX_OP(WAKE_BITSET);    arg->mask |= SCF_UADDR2;                      break;
-        P_FUTEX_OP(WAIT_REQUEUE_PI);                                              break;
-        default: printed = scnprintf(bf, size, "%#x", cmd);                       break;
-        }
-
-        if (op & FUTEX_PRIVATE_FLAG)
-                printed += scnprintf(bf + printed, size - printed, "|PRIV");
-
-        if (op & FUTEX_CLOCK_REALTIME)
-                printed += scnprintf(bf + printed, size - printed, "|CLKRT");
-
-        return printed;
-}
-
-#define SCA_FUTEX_OP  syscall_arg__scnprintf_futex_op
-
 static const char *bpf_cmd[] = {
         "MAP_CREATE", "MAP_LOOKUP_ELEM", "MAP_UPDATE_ELEM", "MAP_DELETE_ELEM",
         "MAP_GET_NEXT_KEY", "PROG_LOAD",
@@ -542,62 +498,6 @@ static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
 
 #define SCA_FILENAME syscall_arg__scnprintf_filename
 
-static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
-                                               struct syscall_arg *arg)
-{
-        int printed = 0, flags = arg->val;
-
-        if (!(flags & O_CREAT))
-                arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
-
-        if (flags == 0)
-                return scnprintf(bf, size, "RDONLY");
-#define P_FLAG(n) \
-        if (flags & O_##n) { \
-                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
-                flags &= ~O_##n; \
-        }
-
-        P_FLAG(APPEND);
-        P_FLAG(ASYNC);
-        P_FLAG(CLOEXEC);
-        P_FLAG(CREAT);
-        P_FLAG(DIRECT);
-        P_FLAG(DIRECTORY);
-        P_FLAG(EXCL);
-        P_FLAG(LARGEFILE);
-        P_FLAG(NOATIME);
-        P_FLAG(NOCTTY);
-#ifdef O_NONBLOCK
-        P_FLAG(NONBLOCK);
-#elif O_NDELAY
-        P_FLAG(NDELAY);
-#endif
-#ifdef O_PATH
-        P_FLAG(PATH);
-#endif
-        P_FLAG(RDWR);
-#ifdef O_DSYNC
-        if ((flags & O_SYNC) == O_SYNC)
-                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
-        else {
-                P_FLAG(DSYNC);
-        }
-#else
-        P_FLAG(SYNC);
-#endif
-        P_FLAG(TRUNC);
-        P_FLAG(WRONLY);
-#undef P_FLAG
-
-        if (flags)
-                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
-
-        return printed;
-}
-
-#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
-
 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
                                                 struct syscall_arg *arg)
 {
@@ -621,59 +521,6 @@ static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
 
 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
 
-static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
-{
-        int sig = arg->val;
-
-        switch (sig) {
-#define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
-        P_SIGNUM(HUP);
-        P_SIGNUM(INT);
-        P_SIGNUM(QUIT);
-        P_SIGNUM(ILL);
-        P_SIGNUM(TRAP);
-        P_SIGNUM(ABRT);
-        P_SIGNUM(BUS);
-        P_SIGNUM(FPE);
-        P_SIGNUM(KILL);
-        P_SIGNUM(USR1);
-        P_SIGNUM(SEGV);
-        P_SIGNUM(USR2);
-        P_SIGNUM(PIPE);
-        P_SIGNUM(ALRM);
-        P_SIGNUM(TERM);
-        P_SIGNUM(CHLD);
-        P_SIGNUM(CONT);
-        P_SIGNUM(STOP);
-        P_SIGNUM(TSTP);
-        P_SIGNUM(TTIN);
-        P_SIGNUM(TTOU);
-        P_SIGNUM(URG);
-        P_SIGNUM(XCPU);
-        P_SIGNUM(XFSZ);
-        P_SIGNUM(VTALRM);
-        P_SIGNUM(PROF);
-        P_SIGNUM(WINCH);
-        P_SIGNUM(IO);
-        P_SIGNUM(PWR);
-        P_SIGNUM(SYS);
-#ifdef SIGEMT
-        P_SIGNUM(EMT);
-#endif
-#ifdef SIGSTKFLT
-        P_SIGNUM(STKFLT);
-#endif
-#ifdef SIGSWI
-        P_SIGNUM(SWI);
-#endif
-        default: break;
-        }
-
-        return scnprintf(bf, size, "%#x", sig);
-}
-
-#define SCA_SIGNUM syscall_arg__scnprintf_signum
-
 #if defined(__i386__) || defined(__x86_64__)
 /*
  * FIXME: Make this available to all arches.
@@ -787,12 +634,15 @@ static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
           .arg_parm      = { [arg] = &strarray__##array, }
 
 #include "trace/beauty/eventfd.c"
-#include "trace/beauty/pid.c"
+#include "trace/beauty/futex_op.c"
 #include "trace/beauty/mmap.c"
 #include "trace/beauty/mode_t.c"
 #include "trace/beauty/msg_flags.c"
+#include "trace/beauty/open_flags.c"
 #include "trace/beauty/perf_event_open.c"
+#include "trace/beauty/pid.c"
 #include "trace/beauty/sched_policy.c"
+#include "trace/beauty/signum.c"
 #include "trace/beauty/socket_type.c"
 #include "trace/beauty/waitid_options.c"
 
@@ -1606,7 +1456,12 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                                                      "%ld", val);
                         }
                 }
-        } else {
+        } else if (IS_ERR(sc->tp_format)) {
+                /*
+                 * If we managed to read the tracepoint /format file, then we
+                 * may end up not having any args, like with gettid(), so only
+                 * print the raw args when we didn't manage to read it.
+                 */
                 int i = 0;
 
                 while (i < 6) {
diff --git a/tools/perf/scripts/python/export-to-postgresql.py b/tools/perf/scripts/python/export-to-postgresql.py
index 6f0ca6873c17..7656ff8aa066 100644
--- a/tools/perf/scripts/python/export-to-postgresql.py
+++ b/tools/perf/scripts/python/export-to-postgresql.py
@@ -223,11 +223,14 @@ sys.path.append(os.environ['PERF_EXEC_PATH'] + \
 
 perf_db_export_mode = True
 perf_db_export_calls = False
+perf_db_export_callchains = False
+
 
 def usage():
-        print >> sys.stderr, "Usage is: export-to-postgresql.py <database name> [<columns>] [<calls>]"
+        print >> sys.stderr, "Usage is: export-to-postgresql.py <database name> [<columns>] [<calls>] [<callchains>]"
         print >> sys.stderr, "where:    columns         'all' or 'branches'"
-        print >> sys.stderr, "          calls           'calls' => create calls table"
+        print >> sys.stderr, "          calls           'calls' => create calls and call_paths table"
+        print >> sys.stderr, "          callchains      'callchains' => create call_paths table"
         raise Exception("Too few arguments")
 
 if (len(sys.argv) < 2):
@@ -245,9 +248,11 @@ if columns not in ("all", "branches"):
 
 branches = (columns == "branches")
 
-if (len(sys.argv) >= 4):
-        if (sys.argv[3] == "calls"):
+for i in range(3,len(sys.argv)):
+        if (sys.argv[i] == "calls"):
                 perf_db_export_calls = True
+        elif (sys.argv[i] == "callchains"):
+                perf_db_export_callchains = True
         else:
                 usage()
 
@@ -358,14 +363,16 @@ else:
                 'transaction    bigint,'
                 'data_src       bigint,'
                 'branch_type    integer,'
-                'in_tx          boolean)')
+                'in_tx          boolean,'
+                'call_path_id   bigint)')
 
-if perf_db_export_calls:
+if perf_db_export_calls or perf_db_export_callchains:
         do_query(query, 'CREATE TABLE call_paths ('
                 'id             bigint          NOT NULL,'
                 'parent_id      bigint,'
                 'symbol_id      bigint,'
                 'ip             bigint)')
+if perf_db_export_calls:
         do_query(query, 'CREATE TABLE calls ('
                 'id             bigint          NOT NULL,'
                 'thread_id      bigint,'
@@ -427,7 +434,7 @@ do_query(query, 'CREATE VIEW comm_threads_view AS '
                 '(SELECT tid FROM threads WHERE id = thread_id) AS tid'
         ' FROM comm_threads')
 
-if perf_db_export_calls:
+if perf_db_export_calls or perf_db_export_callchains:
         do_query(query, 'CREATE VIEW call_paths_view AS '
                 'SELECT '
                         'c.id,'
@@ -443,6 +450,7 @@ if perf_db_export_calls:
                         '(SELECT dso_id FROM symbols WHERE id = p.symbol_id) AS parent_dso_id,'
                         '(SELECT dso FROM symbols_view  WHERE id = p.symbol_id) AS parent_dso_short_name'
                 ' FROM call_paths c INNER JOIN call_paths p ON p.id = c.parent_id')
+if perf_db_export_calls:
         do_query(query, 'CREATE VIEW calls_view AS '
                 'SELECT '
                         'calls.id,'
@@ -540,8 +548,9 @@ dso_file		= open_output_file("dso_table.bin")
 symbol_file             = open_output_file("symbol_table.bin")
 branch_type_file        = open_output_file("branch_type_table.bin")
 sample_file             = open_output_file("sample_table.bin")
-if perf_db_export_calls:
+if perf_db_export_calls or perf_db_export_callchains:
         call_path_file          = open_output_file("call_path_table.bin")
+if perf_db_export_calls:
         call_file               = open_output_file("call_table.bin")
 
 def trace_begin():
@@ -553,8 +562,8 @@ def trace_begin():
         comm_table(0, "unknown")
         dso_table(0, 0, "unknown", "unknown", "")
         symbol_table(0, 0, 0, 0, 0, "unknown")
-        sample_table(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-        if perf_db_export_calls:
+        sample_table(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+        if perf_db_export_calls or perf_db_export_callchains:
                 call_path_table(0, 0, 0, 0)
 
 unhandled_count = 0
@@ -570,8 +579,9 @@ def trace_end():
         copy_output_file(symbol_file,           "symbols")
         copy_output_file(branch_type_file,      "branch_types")
         copy_output_file(sample_file,           "samples")
-        if perf_db_export_calls:
+        if perf_db_export_calls or perf_db_export_callchains:
                 copy_output_file(call_path_file,        "call_paths")
+        if perf_db_export_calls:
                 copy_output_file(call_file,             "calls")
 
         print datetime.datetime.today(), "Removing intermediate files..."
@@ -584,8 +594,9 @@ def trace_end():
         remove_output_file(symbol_file)
         remove_output_file(branch_type_file)
         remove_output_file(sample_file)
-        if perf_db_export_calls:
+        if perf_db_export_calls or perf_db_export_callchains:
                 remove_output_file(call_path_file)
+        if perf_db_export_calls:
                 remove_output_file(call_file)
         os.rmdir(output_dir_name)
         print datetime.datetime.today(), "Adding primary keys"
@@ -598,8 +609,9 @@ def trace_end():
         do_query(query, 'ALTER TABLE symbols         ADD PRIMARY KEY (id)')
         do_query(query, 'ALTER TABLE branch_types    ADD PRIMARY KEY (id)')
         do_query(query, 'ALTER TABLE samples         ADD PRIMARY KEY (id)')
-        if perf_db_export_calls:
+        if perf_db_export_calls or perf_db_export_callchains:
                 do_query(query, 'ALTER TABLE call_paths      ADD PRIMARY KEY (id)')
+        if perf_db_export_calls:
                 do_query(query, 'ALTER TABLE calls           ADD PRIMARY KEY (id)')
 
         print datetime.datetime.today(), "Adding foreign keys"
@@ -622,10 +634,11 @@ def trace_end():
                                         'ADD CONSTRAINT symbolfk   FOREIGN KEY (symbol_id)    REFERENCES symbols    (id),'
                                         'ADD CONSTRAINT todsofk    FOREIGN KEY (to_dso_id)    REFERENCES dsos       (id),'
                                         'ADD CONSTRAINT tosymbolfk FOREIGN KEY (to_symbol_id) REFERENCES symbols    (id)')
-        if perf_db_export_calls:
+        if perf_db_export_calls or perf_db_export_callchains:
                 do_query(query, 'ALTER TABLE call_paths '
                                         'ADD CONSTRAINT parentfk    FOREIGN KEY (parent_id)    REFERENCES call_paths (id),'
                                         'ADD CONSTRAINT symbolfk    FOREIGN KEY (symbol_id)    REFERENCES symbols    (id)')
+        if perf_db_export_calls:
                 do_query(query, 'ALTER TABLE calls '
                                         'ADD CONSTRAINT threadfk    FOREIGN KEY (thread_id)    REFERENCES threads    (id),'
                                         'ADD CONSTRAINT commfk      FOREIGN KEY (comm_id)      REFERENCES comms      (id),'
@@ -693,11 +706,11 @@ def branch_type_table(branch_type, name, *x):
         value = struct.pack(fmt, 2, 4, branch_type, n, name)
         branch_type_file.write(value)
 
-def sample_table(sample_id, evsel_id, machine_id, thread_id, comm_id, dso_id, symbol_id, sym_offset, ip, time, cpu, to_dso_id, to_symbol_id, to_sym_offset, to_ip, period, weight, transaction, data_src, branch_type, in_tx, *x):
+def sample_table(sample_id, evsel_id, machine_id, thread_id, comm_id, dso_id, symbol_id, sym_offset, ip, time, cpu, to_dso_id, to_symbol_id, to_sym_offset, to_ip, period, weight, transaction, data_src, branch_type, in_tx, call_path_id, *x):
         if branches:
-                value = struct.pack("!hiqiqiqiqiqiqiqiqiqiqiiiqiqiqiqiiiB", 17, 8, sample_id, 8, evsel_id, 8, machine_id, 8, thread_id, 8, comm_id, 8, dso_id, 8, symbol_id, 8, sym_offset, 8, ip, 8, time, 4, cpu, 8, to_dso_id, 8, to_symbol_id, 8, to_sym_offset, 8, to_ip, 4, branch_type, 1, in_tx)
+                value = struct.pack("!hiqiqiqiqiqiqiqiqiqiqiiiqiqiqiqiiiBiq", 18, 8, sample_id, 8, evsel_id, 8, machine_id, 8, thread_id, 8, comm_id, 8, dso_id, 8, symbol_id, 8, sym_offset, 8, ip, 8, time, 4, cpu, 8, to_dso_id, 8, to_symbol_id, 8, to_sym_offset, 8, to_ip, 4, branch_type, 1, in_tx, 8, call_path_id)
         else:
-                value = struct.pack("!hiqiqiqiqiqiqiqiqiqiqiiiqiqiqiqiqiqiqiqiiiB", 21, 8, sample_id, 8, evsel_id, 8, machine_id, 8, thread_id, 8, comm_id, 8, dso_id, 8, symbol_id, 8, sym_offset, 8, ip, 8, time, 4, cpu, 8, to_dso_id, 8, to_symbol_id, 8, to_sym_offset, 8, to_ip, 8, period, 8, weight, 8, transaction, 8, data_src, 4, branch_type, 1, in_tx)
+                value = struct.pack("!hiqiqiqiqiqiqiqiqiqiqiiiqiqiqiqiqiqiqiqiiiBiq", 22, 8, sample_id, 8, evsel_id, 8, machine_id, 8, thread_id, 8, comm_id, 8, dso_id, 8, symbol_id, 8, sym_offset, 8, ip, 8, time, 4, cpu, 8, to_dso_id, 8, to_symbol_id, 8, to_sym_offset, 8, to_ip, 8, period, 8, weight, 8, transaction, 8, data_src, 4, branch_type, 1, in_tx, 8, call_path_id)
         sample_file.write(value)
 
 def call_path_table(cp_id, parent_id, symbol_id, ip, *x):
diff --git a/tools/perf/trace/beauty/futex_op.c b/tools/perf/trace/beauty/futex_op.c
new file mode 100644
index 000000000000..e2476211f22d
--- /dev/null
+++ b/tools/perf/trace/beauty/futex_op.c
@@ -0,0 +1,44 @@
+#include <linux/futex.h>
+
+static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
+{
+        enum syscall_futex_args {
+                SCF_UADDR   = (1 << 0),
+                SCF_OP      = (1 << 1),
+                SCF_VAL     = (1 << 2),
+                SCF_TIMEOUT = (1 << 3),
+                SCF_UADDR2  = (1 << 4),
+                SCF_VAL3    = (1 << 5),
+        };
+        int op = arg->val;
+        int cmd = op & FUTEX_CMD_MASK;
+        size_t printed = 0;
+
+        switch (cmd) {
+#define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
+        P_FUTEX_OP(WAIT);           arg->mask |= SCF_VAL3|SCF_UADDR2;             break;
+        P_FUTEX_OP(WAKE);           arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(FD);             arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(REQUEUE);        arg->mask |= SCF_VAL3|SCF_TIMEOUT;            break;
+        P_FUTEX_OP(CMP_REQUEUE);    arg->mask |= SCF_TIMEOUT;                     break;
+        P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT;                     break;
+        P_FUTEX_OP(WAKE_OP);                                                      break;
+        P_FUTEX_OP(LOCK_PI);        arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(UNLOCK_PI);      arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(TRYLOCK_PI);     arg->mask |= SCF_VAL3|SCF_UADDR2;             break;
+        P_FUTEX_OP(WAIT_BITSET);    arg->mask |= SCF_UADDR2;                      break;
+        P_FUTEX_OP(WAKE_BITSET);    arg->mask |= SCF_UADDR2;                      break;
+        P_FUTEX_OP(WAIT_REQUEUE_PI);                                              break;
+        default: printed = scnprintf(bf, size, "%#x", cmd);                       break;
+        }
+
+        if (op & FUTEX_PRIVATE_FLAG)
+                printed += scnprintf(bf + printed, size - printed, "|PRIV");
+
+        if (op & FUTEX_CLOCK_REALTIME)
+                printed += scnprintf(bf + printed, size - printed, "|CLKRT");
+
+        return printed;
+}
+
+#define SCA_FUTEX_OP  syscall_arg__scnprintf_futex_op
diff --git a/tools/perf/trace/beauty/open_flags.c b/tools/perf/trace/beauty/open_flags.c
new file mode 100644
index 000000000000..0f3679e0cdcf
--- /dev/null
+++ b/tools/perf/trace/beauty/open_flags.c
@@ -0,0 +1,56 @@
+
+static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
+                                               struct syscall_arg *arg)
+{
+        int printed = 0, flags = arg->val;
+
+        if (!(flags & O_CREAT))
+                arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
+
+        if (flags == 0)
+                return scnprintf(bf, size, "RDONLY");
+#define P_FLAG(n) \
+        if (flags & O_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                flags &= ~O_##n; \
+        }
+
+        P_FLAG(APPEND);
+        P_FLAG(ASYNC);
+        P_FLAG(CLOEXEC);
+        P_FLAG(CREAT);
+        P_FLAG(DIRECT);
+        P_FLAG(DIRECTORY);
+        P_FLAG(EXCL);
+        P_FLAG(LARGEFILE);
+        P_FLAG(NOATIME);
+        P_FLAG(NOCTTY);
+#ifdef O_NONBLOCK
+        P_FLAG(NONBLOCK);
+#elif O_NDELAY
+        P_FLAG(NDELAY);
+#endif
+#ifdef O_PATH
+        P_FLAG(PATH);
+#endif
+        P_FLAG(RDWR);
+#ifdef O_DSYNC
+        if ((flags & O_SYNC) == O_SYNC)
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
+        else {
+                P_FLAG(DSYNC);
+        }
+#else
+        P_FLAG(SYNC);
+#endif
+        P_FLAG(TRUNC);
+        P_FLAG(WRONLY);
+#undef P_FLAG
+
+        if (flags)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
+
+        return printed;
+}
+
+#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
diff --git a/tools/perf/trace/beauty/signum.c b/tools/perf/trace/beauty/signum.c
new file mode 100644
index 000000000000..d3b0b1fab077
--- /dev/null
+++ b/tools/perf/trace/beauty/signum.c
@@ -0,0 +1,53 @@
+
+static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
+{
+        int sig = arg->val;
+
+        switch (sig) {
+#define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
+        P_SIGNUM(HUP);
+        P_SIGNUM(INT);
+        P_SIGNUM(QUIT);
+        P_SIGNUM(ILL);
+        P_SIGNUM(TRAP);
+        P_SIGNUM(ABRT);
+        P_SIGNUM(BUS);
+        P_SIGNUM(FPE);
+        P_SIGNUM(KILL);
+        P_SIGNUM(USR1);
+        P_SIGNUM(SEGV);
+        P_SIGNUM(USR2);
+        P_SIGNUM(PIPE);
+        P_SIGNUM(ALRM);
+        P_SIGNUM(TERM);
+        P_SIGNUM(CHLD);
+        P_SIGNUM(CONT);
+        P_SIGNUM(STOP);
+        P_SIGNUM(TSTP);
+        P_SIGNUM(TTIN);
+        P_SIGNUM(TTOU);
+        P_SIGNUM(URG);
+        P_SIGNUM(XCPU);
+        P_SIGNUM(XFSZ);
+        P_SIGNUM(VTALRM);
+        P_SIGNUM(PROF);
+        P_SIGNUM(WINCH);
+        P_SIGNUM(IO);
+        P_SIGNUM(PWR);
+        P_SIGNUM(SYS);
+#ifdef SIGEMT
+        P_SIGNUM(EMT);
+#endif
+#ifdef SIGSTKFLT
+        P_SIGNUM(STKFLT);
+#endif
+#ifdef SIGSWI
+        P_SIGNUM(SWI);
+#endif
+        default: break;
+        }
+
+        return scnprintf(bf, size, "%#x", sig);
+}
+
+#define SCA_SIGNUM syscall_arg__scnprintf_signum
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
index 90229a88f969..027bb2b89d7f 100644
--- a/tools/perf/util/Build
+++ b/tools/perf/util/Build
@@ -74,6 +74,7 @@ libperf-y += srcline.o
 libperf-y += data.o
 libperf-y += tsc.o
 libperf-y += cloexec.o
+libperf-y += call-path.o
 libperf-y += thread-stack.o
 libperf-$(CONFIG_AUXTRACE) += auxtrace.o
 libperf-$(CONFIG_AUXTRACE) += intel-pt-decoder/
diff --git a/tools/perf/util/call-path.c b/tools/perf/util/call-path.c
new file mode 100644
index 000000000000..904a17052e38
--- /dev/null
+++ b/tools/perf/util/call-path.c
@@ -0,0 +1,122 @@
+/*
+ * call-path.h: Manipulate a tree data structure containing function call paths
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ */
+
+#include <linux/rbtree.h>
+#include <linux/list.h>
+
+#include "util.h"
+#include "call-path.h"
+
+static void call_path__init(struct call_path *cp, struct call_path *parent,
+                            struct symbol *sym, u64 ip, bool in_kernel)
+{
+        cp->parent = parent;
+        cp->sym = sym;
+        cp->ip = sym ? 0 : ip;
+        cp->db_id = 0;
+        cp->in_kernel = in_kernel;
+        RB_CLEAR_NODE(&cp->rb_node);
+        cp->children = RB_ROOT;
+}
+
+struct call_path_root *call_path_root__new(void)
+{
+        struct call_path_root *cpr;
+
+        cpr = zalloc(sizeof(struct call_path_root));
+        if (!cpr)
+                return NULL;
+        call_path__init(&cpr->call_path, NULL, NULL, 0, false);
+        INIT_LIST_HEAD(&cpr->blocks);
+        return cpr;
+}
+
+void call_path_root__free(struct call_path_root *cpr)
+{
+        struct call_path_block *pos, *n;
+
+        list_for_each_entry_safe(pos, n, &cpr->blocks, node) {
+                list_del(&pos->node);
+                free(pos);
+        }
+        free(cpr);
+}
+
+static struct call_path *call_path__new(struct call_path_root *cpr,
+                                        struct call_path *parent,
+                                        struct symbol *sym, u64 ip,
+                                        bool in_kernel)
+{
+        struct call_path_block *cpb;
+        struct call_path *cp;
+        size_t n;
+
+        if (cpr->next < cpr->sz) {
+                cpb = list_last_entry(&cpr->blocks, struct call_path_block,
+                                      node);
+        } else {
+                cpb = zalloc(sizeof(struct call_path_block));
+                if (!cpb)
+                        return NULL;
+                list_add_tail(&cpb->node, &cpr->blocks);
+                cpr->sz += CALL_PATH_BLOCK_SIZE;
+        }
+
+        n = cpr->next++ & CALL_PATH_BLOCK_MASK;
+        cp = &cpb->cp[n];
+
+        call_path__init(cp, parent, sym, ip, in_kernel);
+
+        return cp;
+}
+
+struct call_path *call_path__findnew(struct call_path_root *cpr,
+                                     struct call_path *parent,
+                                     struct symbol *sym, u64 ip, u64 ks)
+{
+        struct rb_node **p;
+        struct rb_node *node_parent = NULL;
+        struct call_path *cp;
+        bool in_kernel = ip >= ks;
+
+        if (sym)
+                ip = 0;
+
+        if (!parent)
+                return call_path__new(cpr, parent, sym, ip, in_kernel);
+
+        p = &parent->children.rb_node;
+        while (*p != NULL) {
+                node_parent = *p;
+                cp = rb_entry(node_parent, struct call_path, rb_node);
+
+                if (cp->sym == sym && cp->ip == ip)
+                        return cp;
+
+                if (sym < cp->sym || (sym == cp->sym && ip < cp->ip))
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        cp = call_path__new(cpr, parent, sym, ip, in_kernel);
+        if (!cp)
+                return NULL;
+
+        rb_link_node(&cp->rb_node, node_parent, p);
+        rb_insert_color(&cp->rb_node, &parent->children);
+
+        return cp;
+}
diff --git a/tools/perf/util/call-path.h b/tools/perf/util/call-path.h
new file mode 100644
index 000000000000..477f6d03b659
--- /dev/null
+++ b/tools/perf/util/call-path.h
@@ -0,0 +1,77 @@
+/*
+ * call-path.h: Manipulate a tree data structure containing function call paths
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ *
+ */
+
+#ifndef __PERF_CALL_PATH_H
+#define __PERF_CALL_PATH_H
+
+#include <sys/types.h>
+
+#include <linux/types.h>
+#include <linux/rbtree.h>
+
+/**
+ * struct call_path - node in list of calls leading to a function call.
+ * @parent: call path to the parent function call
+ * @sym: symbol of function called
+ * @ip: only if sym is null, the ip of the function
+ * @db_id: id used for db-export
+ * @in_kernel: whether function is a in the kernel
+ * @rb_node: node in parent's tree of called functions
+ * @children: tree of call paths of functions called
+ *
+ * In combination with the call_return structure, the call_path structure
+ * defines a context-sensitve call-graph.
+ */
+struct call_path {
+        struct call_path *parent;
+        struct symbol *sym;
+        u64 ip;
+        u64 db_id;
+        bool in_kernel;
+        struct rb_node rb_node;
+        struct rb_root children;
+};
+
+#define CALL_PATH_BLOCK_SHIFT 8
+#define CALL_PATH_BLOCK_SIZE (1 << CALL_PATH_BLOCK_SHIFT)
+#define CALL_PATH_BLOCK_MASK (CALL_PATH_BLOCK_SIZE - 1)
+
+struct call_path_block {
+        struct call_path cp[CALL_PATH_BLOCK_SIZE];
+        struct list_head node;
+};
+
+/**
+ * struct call_path_root - root of all call paths.
+ * @call_path: root call path
+ * @blocks: list of blocks to store call paths
+ * @next: next free space
+ * @sz: number of spaces
+ */
+struct call_path_root {
+        struct call_path call_path;
+        struct list_head blocks;
+        size_t next;
+        size_t sz;
+};
+
+struct call_path_root *call_path_root__new(void);
+void call_path_root__free(struct call_path_root *cpr);
+
+struct call_path *call_path__findnew(struct call_path_root *cpr,
+                                     struct call_path *parent,
+                                     struct symbol *sym, u64 ip, u64 ks);
+
+#endif
diff --git a/tools/perf/util/db-export.c b/tools/perf/util/db-export.c
index 049438d51b9a..f8e3057ae3b1 100644
--- a/tools/perf/util/db-export.c
+++ b/tools/perf/util/db-export.c
@@ -23,6 +23,8 @@
 #include "event.h"
 #include "util.h"
 #include "thread-stack.h"
+#include "callchain.h"
+#include "call-path.h"
 #include "db-export.h"
 
 struct deferred_export {
@@ -276,6 +278,79 @@ static int db_ids_from_al(struct db_export *dbe, struct addr_location *al,
         return 0;
 }
 
+static struct call_path *call_path_from_sample(struct db_export *dbe,
+                                               struct machine *machine,
+                                               struct thread *thread,
+                                               struct perf_sample *sample,
+                                               struct perf_evsel *evsel)
+{
+        u64 kernel_start = machine__kernel_start(machine);
+        struct call_path *current = &dbe->cpr->call_path;
+        enum chain_order saved_order = callchain_param.order;
+        int err;
+
+        if (!symbol_conf.use_callchain || !sample->callchain)
+                return NULL;
+
+        /*
+         * Since the call path tree must be built starting with the root, we
+         * must use ORDER_CALL for call chain resolution, in order to process
+         * the callchain starting with the root node and ending with the leaf.
+         */
+        callchain_param.order = ORDER_CALLER;
+        err = thread__resolve_callchain(thread, &callchain_cursor, evsel,
+                                        sample, NULL, NULL,
+                                        sysctl_perf_event_max_stack);
+        if (err) {
+                callchain_param.order = saved_order;
+                return NULL;
+        }
+        callchain_cursor_commit(&callchain_cursor);
+
+        while (1) {
+                struct callchain_cursor_node *node;
+                struct addr_location al;
+                u64 dso_db_id = 0, sym_db_id = 0, offset = 0;
+
+                memset(&al, 0, sizeof(al));
+
+                node = callchain_cursor_current(&callchain_cursor);
+                if (!node)
+                        break;
+                /*
+                 * Handle export of symbol and dso for this node by
+                 * constructing an addr_location struct and then passing it to
+                 * db_ids_from_al() to perform the export.
+                 */
+                al.sym = node->sym;
+                al.map = node->map;
+                al.machine = machine;
+                if (al.map)
+                        al.addr = al.map->map_ip(al.map, node->ip);
+                else
+                        al.addr = node->ip;
+
+                db_ids_from_al(dbe, &al, &dso_db_id, &sym_db_id, &offset);
+
+                /* add node to the call path tree if it doesn't exist */
+                current = call_path__findnew(dbe->cpr, current,
+                                             al.sym, node->ip,
+                                             kernel_start);
+
+                callchain_cursor_advance(&callchain_cursor);
+        }
+
+        /* Reset the callchain order to its prior value. */
+        callchain_param.order = saved_order;
+
+        if (current == &dbe->cpr->call_path) {
+                /* Bail because the callchain was empty. */
+                return NULL;
+        }
+
+        return current;
+}
+
 int db_export__branch_type(struct db_export *dbe, u32 branch_type,
                            const char *name)
 {
@@ -329,6 +404,16 @@ int db_export__sample(struct db_export *dbe, union perf_event *event,
         if (err)
                 goto out_put;
 
+        if (dbe->cpr) {
+                struct call_path *cp = call_path_from_sample(dbe, al->machine,
+                                                             thread, sample,
+                                                             evsel);
+                if (cp) {
+                        db_export__call_path(dbe, cp);
+                        es.call_path_id = cp->db_id;
+                }
+        }
+
         if ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
             sample_addr_correlates_sym(&evsel->attr)) {
                 struct addr_location addr_al;
diff --git a/tools/perf/util/db-export.h b/tools/perf/util/db-export.h
index 25e22fd76aca..67bc6b8ad2d6 100644
--- a/tools/perf/util/db-export.h
+++ b/tools/perf/util/db-export.h
@@ -27,6 +27,7 @@ struct dso;
 struct perf_sample;
 struct addr_location;
 struct call_return_processor;
+struct call_path_root;
 struct call_path;
 struct call_return;
 
@@ -43,6 +44,7 @@ struct export_sample {
         u64                     addr_dso_db_id;
         u64                     addr_sym_db_id;
         u64                     addr_offset; /* addr offset from symbol start */
+        u64                     call_path_id;
 };
 
 struct db_export {
@@ -64,6 +66,7 @@ struct db_export {
         int (*export_call_return)(struct db_export *dbe,
                                   struct call_return *cr);
         struct call_return_processor *crp;
+        struct call_path_root *cpr;
         u64 evsel_last_db_id;
         u64 machine_last_db_id;
         u64 thread_last_db_id;
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 8c7bf4dbd479..639a2903065e 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -1817,8 +1817,6 @@ static int thread__resolve_callchain_sample(struct thread *thread,
         int skip_idx = -1;
         int first_call = 0;
 
-        callchain_cursor_reset(cursor);
-
         if (perf_evsel__has_branch_callstack(evsel)) {
                 err = resolve_lbr_callchain_sample(thread, cursor, sample, parent,
                                                    root_al, max_stack);
@@ -1929,20 +1927,12 @@ static int unwind_entry(struct unwind_entry *entry, void *arg)
                                        entry->map, entry->sym);
 }
 
-int thread__resolve_callchain(struct thread *thread,
-                              struct callchain_cursor *cursor,
-                              struct perf_evsel *evsel,
-                              struct perf_sample *sample,
-                              struct symbol **parent,
-                              struct addr_location *root_al,
-                              int max_stack)
+static int thread__resolve_callchain_unwind(struct thread *thread,
+                                            struct callchain_cursor *cursor,
+                                            struct perf_evsel *evsel,
+                                            struct perf_sample *sample,
+                                            int max_stack)
 {
-        int ret = thread__resolve_callchain_sample(thread, cursor, evsel,
-                                                   sample, parent,
-                                                   root_al, max_stack);
-        if (ret)
-                return ret;
-
         /* Can we do dwarf post unwind? */
         if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
               (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
@@ -1955,7 +1945,43 @@ int thread__resolve_callchain(struct thread *thread,
 
         return unwind__get_entries(unwind_entry, cursor,
                                    thread, sample, max_stack);
+}
 
+int thread__resolve_callchain(struct thread *thread,
+                              struct callchain_cursor *cursor,
+                              struct perf_evsel *evsel,
+                              struct perf_sample *sample,
+                              struct symbol **parent,
+                              struct addr_location *root_al,
+                              int max_stack)
+{
+        int ret = 0;
+
+        callchain_cursor_reset(&callchain_cursor);
+
+        if (callchain_param.order == ORDER_CALLEE) {
+                ret = thread__resolve_callchain_sample(thread, cursor,
+                                                       evsel, sample,
+                                                       parent, root_al,
+                                                       max_stack);
+                if (ret)
+                        return ret;
+                ret = thread__resolve_callchain_unwind(thread, cursor,
+                                                       evsel, sample,
+                                                       max_stack);
+        } else {
+                ret = thread__resolve_callchain_unwind(thread, cursor,
+                                                       evsel, sample,
+                                                       max_stack);
+                if (ret)
+                        return ret;
+                ret = thread__resolve_callchain_sample(thread, cursor,
+                                                       evsel, sample,
+                                                       parent, root_al,
+                                                       max_stack);
+        }
+
+        return ret;
 }
 
 int machine__for_each_thread(struct machine *machine,
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 525eb49e7ba6..091bce67844c 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -41,6 +41,7 @@
 #include "../thread-stack.h"
 #include "../trace-event.h"
 #include "../machine.h"
+#include "../call-path.h"
 #include "thread_map.h"
 #include "cpumap.h"
 #include "stat.h"
@@ -681,7 +682,7 @@ static int python_export_sample(struct db_export *dbe,
         struct tables *tables = container_of(dbe, struct tables, dbe);
         PyObject *t;
 
-        t = tuple_new(21);
+        t = tuple_new(22);
 
         tuple_set_u64(t, 0, es->db_id);
         tuple_set_u64(t, 1, es->evsel->db_id);
@@ -704,6 +705,7 @@ static int python_export_sample(struct db_export *dbe,
         tuple_set_u64(t, 18, es->sample->data_src);
         tuple_set_s32(t, 19, es->sample->flags & PERF_BRANCH_MASK);
         tuple_set_s32(t, 20, !!(es->sample->flags & PERF_IP_FLAG_IN_TX));
+        tuple_set_u64(t, 21, es->call_path_id);
 
         call_object(tables->sample_handler, t, "sample_table");
 
@@ -998,8 +1000,10 @@ static void set_table_handlers(struct tables *tables)
 {
         const char *perf_db_export_mode = "perf_db_export_mode";
         const char *perf_db_export_calls = "perf_db_export_calls";
-        PyObject *db_export_mode, *db_export_calls;
+        const char *perf_db_export_callchains = "perf_db_export_callchains";
+        PyObject *db_export_mode, *db_export_calls, *db_export_callchains;
         bool export_calls = false;
+        bool export_callchains = false;
         int ret;
 
         memset(tables, 0, sizeof(struct tables));
@@ -1016,6 +1020,7 @@ static void set_table_handlers(struct tables *tables)
         if (!ret)
                 return;
 
+        /* handle export calls */
         tables->dbe.crp = NULL;
         db_export_calls = PyDict_GetItemString(main_dict, perf_db_export_calls);
         if (db_export_calls) {
@@ -1033,6 +1038,33 @@ static void set_table_handlers(struct tables *tables)
                         Py_FatalError("failed to create calls processor");
         }
 
+        /* handle export callchains */
+        tables->dbe.cpr = NULL;
+        db_export_callchains = PyDict_GetItemString(main_dict,
+                                                    perf_db_export_callchains);
+        if (db_export_callchains) {
+                ret = PyObject_IsTrue(db_export_callchains);
+                if (ret == -1)
+                        handler_call_die(perf_db_export_callchains);
+                export_callchains = !!ret;
+        }
+
+        if (export_callchains) {
+                /*
+                 * Attempt to use the call path root from the call return
+                 * processor, if the call return processor is in use. Otherwise,
+                 * we allocate a new call path root. This prevents exporting
+                 * duplicate call path ids when both are in use simultaniously.
+                 */
+                if (tables->dbe.crp)
+                        tables->dbe.cpr = tables->dbe.crp->cpr;
+                else
+                        tables->dbe.cpr = call_path_root__new();
+
+                if (!tables->dbe.cpr)
+                        Py_FatalError("failed to create calls processor");
+        }
+
         tables->db_export_mode = true;
         /*
          * Reserve per symbol space for symbol->db_id via symbol__priv()
diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c
index 679688e70ae7..825086aa9a08 100644
--- a/tools/perf/util/thread-stack.c
+++ b/tools/perf/util/thread-stack.c
@@ -22,44 +22,9 @@
 #include "debug.h"
 #include "symbol.h"
 #include "comm.h"
+#include "call-path.h"
 #include "thread-stack.h"
 
-#define CALL_PATH_BLOCK_SHIFT 8
-#define CALL_PATH_BLOCK_SIZE (1 << CALL_PATH_BLOCK_SHIFT)
-#define CALL_PATH_BLOCK_MASK (CALL_PATH_BLOCK_SIZE - 1)
-
-struct call_path_block {
-        struct call_path cp[CALL_PATH_BLOCK_SIZE];
-        struct list_head node;
-};
-
-/**
- * struct call_path_root - root of all call paths.
- * @call_path: root call path
- * @blocks: list of blocks to store call paths
- * @next: next free space
- * @sz: number of spaces
- */
-struct call_path_root {
-        struct call_path call_path;
-        struct list_head blocks;
-        size_t next;
-        size_t sz;
-};
-
-/**
- * struct call_return_processor - provides a call-back to consume call-return
- *                                information.
- * @cpr: call path root
- * @process: call-back that accepts call/return information
- * @data: anonymous data for call-back
- */
-struct call_return_processor {
-        struct call_path_root *cpr;
-        int (*process)(struct call_return *cr, void *data);
-        void *data;
-};
-
 #define STACK_GROWTH 2048
 
 /**
@@ -335,108 +300,6 @@ void thread_stack__sample(struct thread *thread, struct ip_callchain *chain,
                 chain->ips[i] = thread->ts->stack[thread->ts->cnt - i].ret_addr;
 }
 
-static void call_path__init(struct call_path *cp, struct call_path *parent,
-                            struct symbol *sym, u64 ip, bool in_kernel)
-{
-        cp->parent = parent;
-        cp->sym = sym;
-        cp->ip = sym ? 0 : ip;
-        cp->db_id = 0;
-        cp->in_kernel = in_kernel;
-        RB_CLEAR_NODE(&cp->rb_node);
-        cp->children = RB_ROOT;
-}
-
-static struct call_path_root *call_path_root__new(void)
-{
-        struct call_path_root *cpr;
-
-        cpr = zalloc(sizeof(struct call_path_root));
-        if (!cpr)
-                return NULL;
-        call_path__init(&cpr->call_path, NULL, NULL, 0, false);
-        INIT_LIST_HEAD(&cpr->blocks);
-        return cpr;
-}
-
-static void call_path_root__free(struct call_path_root *cpr)
-{
-        struct call_path_block *pos, *n;
-
-        list_for_each_entry_safe(pos, n, &cpr->blocks, node) {
-                list_del(&pos->node);
-                free(pos);
-        }
-        free(cpr);
-}
-
-static struct call_path *call_path__new(struct call_path_root *cpr,
-                                        struct call_path *parent,
-                                        struct symbol *sym, u64 ip,
-                                        bool in_kernel)
-{
-        struct call_path_block *cpb;
-        struct call_path *cp;
-        size_t n;
-
-        if (cpr->next < cpr->sz) {
-                cpb = list_last_entry(&cpr->blocks, struct call_path_block,
-                                      node);
-        } else {
-                cpb = zalloc(sizeof(struct call_path_block));
-                if (!cpb)
-                        return NULL;
-                list_add_tail(&cpb->node, &cpr->blocks);
-                cpr->sz += CALL_PATH_BLOCK_SIZE;
-        }
-
-        n = cpr->next++ & CALL_PATH_BLOCK_MASK;
-        cp = &cpb->cp[n];
-
-        call_path__init(cp, parent, sym, ip, in_kernel);
-
-        return cp;
-}
-
-static struct call_path *call_path__findnew(struct call_path_root *cpr,
-                                            struct call_path *parent,
-                                            struct symbol *sym, u64 ip, u64 ks)
-{
-        struct rb_node **p;
-        struct rb_node *node_parent = NULL;
-        struct call_path *cp;
-        bool in_kernel = ip >= ks;
-
-        if (sym)
-                ip = 0;
-
-        if (!parent)
-                return call_path__new(cpr, parent, sym, ip, in_kernel);
-
-        p = &parent->children.rb_node;
-        while (*p != NULL) {
-                node_parent = *p;
-                cp = rb_entry(node_parent, struct call_path, rb_node);
-
-                if (cp->sym == sym && cp->ip == ip)
-                        return cp;
-
-                if (sym < cp->sym || (sym == cp->sym && ip < cp->ip))
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        cp = call_path__new(cpr, parent, sym, ip, in_kernel);
-        if (!cp)
-                return NULL;
-
-        rb_link_node(&cp->rb_node, node_parent, p);
-        rb_insert_color(&cp->rb_node, &parent->children);
-
-        return cp;
-}
-
 struct call_return_processor *
 call_return_processor__new(int (*process)(struct call_return *cr, void *data),
                            void *data)
diff --git a/tools/perf/util/thread-stack.h b/tools/perf/util/thread-stack.h
index e1528f1374c3..ad44c7944b8e 100644
--- a/tools/perf/util/thread-stack.h
+++ b/tools/perf/util/thread-stack.h
@@ -19,17 +19,16 @@
 #include <sys/types.h>
 
 #include <linux/types.h>
-#include <linux/rbtree.h>
 
 struct thread;
 struct comm;
 struct ip_callchain;
 struct symbol;
 struct dso;
-struct call_return_processor;
 struct comm;
 struct perf_sample;
 struct addr_location;
+struct call_path;
 
 /*
  * Call/Return flags.
@@ -69,26 +68,16 @@ struct call_return {
 };
 
 /**
- * struct call_path - node in list of calls leading to a function call.
- * @parent: call path to the parent function call
- * @sym: symbol of function called
- * @ip: only if sym is null, the ip of the function
- * @db_id: id used for db-export
- * @in_kernel: whether function is a in the kernel
- * @rb_node: node in parent's tree of called functions
- * @children: tree of call paths of functions called
- *
- * In combination with the call_return structure, the call_path structure
- * defines a context-sensitve call-graph.
+ * struct call_return_processor - provides a call-back to consume call-return
+ *                                information.
+ * @cpr: call path root
+ * @process: call-back that accepts call/return information
+ * @data: anonymous data for call-back
  */
-struct call_path {
-        struct call_path *parent;
-        struct symbol *sym;
-        u64 ip;
-        u64 db_id;
-        bool in_kernel;
-        struct rb_node rb_node;
-        struct rb_root children;
+struct call_return_processor {
+        struct call_path_root *cpr;
+        int (*process)(struct call_return *cr, void *data);
+        void *data;
 };
 
 int thread_stack__event(struct thread *thread, u32 flags, u64 from_ip,