42 files changed, 834 insertions, 376 deletions

diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index be5ad87b6c3d..10a279871251 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -141,6 +141,14 @@ OPTIONS
 
         Default: fractal,0.5,callee,function.
 
+--max-stack::
+        Set the stack depth limit when parsing the callchain, anything
+        beyond the specified depth will be ignored. This is a trade-off
+        between information loss and faster processing especially for
+        workloads that can have a very long callchain stack.
+
+        Default: 127
+
 -G::
 --inverted::
         alias for inverted caller based call graph.
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index f65777c1f723..c16a09e2f182 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -158,6 +158,14 @@ Default is to monitor all CPUS.
 
         Default: fractal,0.5,callee.
 
+--max-stack::
+        Set the stack depth limit when parsing the callchain, anything
+        beyond the specified depth will be ignored. This is a trade-off
+        between information loss and faster processing especially for
+        workloads that can have a very long callchain stack.
+
+        Default: 127
+
 --ignore-callees=<regex>::
         Ignore callees of the function(s) matching the given regex.
         This has the effect of collecting the callers of each such
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 54139c6457f8..7b0497f95a75 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -97,6 +97,10 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
         Show a summary of syscalls by thread with min, max, and average times (in
     msec) and relative stddev.
 
+--tool_stats::
+        Show tool stats such as number of times fd->pathname was discovered thru
+        hooking the open syscall return + vfs_getname or via reading /proc/pid/fd, etc.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script[1]
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index c873e039aafb..326a26e5fc1c 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -365,6 +365,7 @@ LIB_OBJS += $(OUTPUT)util/vdso.o
 LIB_OBJS += $(OUTPUT)util/stat.o
 LIB_OBJS += $(OUTPUT)util/record.o
 LIB_OBJS += $(OUTPUT)util/srcline.o
+LIB_OBJS += $(OUTPUT)util/data.o
 
 LIB_OBJS += $(OUTPUT)ui/setup.o
 LIB_OBJS += $(OUTPUT)ui/helpline.o
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 64fa01cfc34d..d4c83c60b9b2 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -1120,7 +1120,7 @@ static void *worker_thread(void *__tdata)
                 /* Check whether our max runtime timed out: */
                 if (g->p.nr_secs) {
                         timersub(&stop, &start0, &diff);
-                        if (diff.tv_sec >= g->p.nr_secs) {
+                        if ((u32)diff.tv_sec >= g->p.nr_secs) {
                                 g->stop_work = true;
                                 break;
                         }
@@ -1167,7 +1167,7 @@ static void *worker_thread(void *__tdata)
                         runtime_ns_max += diff.tv_usec * 1000;
 
                         if (details >= 0) {
-                                printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016lx]\n",
+                                printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016"PRIx64"]\n",
                                         process_nr, thread_nr, runtime_ns_max / bytes_done, val);
                         }
                         fflush(stdout);
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 94f9a8e78117..03cfa592071f 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -28,6 +28,7 @@
 #include "util/hist.h"
 #include "util/session.h"
 #include "util/tool.h"
+#include "util/data.h"
 #include "arch/common.h"
 
 #include <dlfcn.h>
@@ -199,9 +200,13 @@ static int __cmd_annotate(struct perf_annotate *ann)
         struct perf_session *session;
         struct perf_evsel *pos;
         u64 total_nr_samples;
+        struct perf_data_file file = {
+                .path  = input_name,
+                .mode  = PERF_DATA_MODE_READ,
+                .force = ann->force,
+        };
 
-        session = perf_session__new(input_name, O_RDONLY,
-                                    ann->force, false, &ann->tool);
+        session = perf_session__new(&file, false, &ann->tool);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -254,7 +259,7 @@ static int __cmd_annotate(struct perf_annotate *ann)
         }
 
         if (total_nr_samples == 0) {
-                ui__error("The %s file has no samples!\n", session->filename);
+                ui__error("The %s file has no samples!\n", file.path);
                 goto out_delete;
         }
 
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index 8140b7b249fa..cfede86161d8 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -221,8 +221,12 @@ static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused)
 
 static int build_id_cache__fprintf_missing(const char *filename, bool force, FILE *fp)
 {
-        struct perf_session *session = perf_session__new(filename, O_RDONLY,
-                                                         force, false, NULL);
+        struct perf_data_file file = {
+                .path  = filename,
+                .mode  = PERF_DATA_MODE_READ,
+                .force = force,
+        };
+        struct perf_session *session = perf_session__new(&file, false, NULL);
         if (session == NULL)
                 return -1;
 
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index e74366a13218..ed3873b3e238 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -15,6 +15,7 @@
 #include "util/parse-options.h"
 #include "util/session.h"
 #include "util/symbol.h"
+#include "util/data.h"
 
 static int sysfs__fprintf_build_id(FILE *fp)
 {
@@ -52,6 +53,11 @@ static bool dso__skip_buildid(struct dso *dso, int with_hits)
 static int perf_session__list_build_ids(bool force, bool with_hits)
 {
         struct perf_session *session;
+        struct perf_data_file file = {
+                .path  = input_name,
+                .mode  = PERF_DATA_MODE_READ,
+                .force = force,
+        };
 
         symbol__elf_init();
         /*
@@ -60,15 +66,14 @@ static int perf_session__list_build_ids(bool force, bool with_hits)
         if (filename__fprintf_build_id(input_name, stdout))
                 goto out;
 
-        session = perf_session__new(input_name, O_RDONLY, force, false,
-                                    &build_id__mark_dso_hit_ops);
+        session = perf_session__new(&file, false, &build_id__mark_dso_hit_ops);
         if (session == NULL)
                 return -1;
         /*
          * in pipe-mode, the only way to get the buildids is to parse
          * the record stream. Buildids are stored as RECORD_HEADER_BUILD_ID
          */
-        if (with_hits || session->fd_pipe)
+        if (with_hits || perf_data_file__is_pipe(&file))
                 perf_session__process_events(session, &build_id__mark_dso_hit_ops);
 
         perf_session__fprintf_dsos_buildid(session, stdout, dso__skip_buildid, with_hits);
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 2a78dc806c39..419d27dd708b 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -16,6 +16,7 @@
 #include "util/sort.h"
 #include "util/symbol.h"
 #include "util/util.h"
+#include "util/data.h"
 
 #include <stdlib.h>
 #include <math.h>
@@ -42,7 +43,7 @@ struct diff_hpp_fmt {
 
 struct data__file {
         struct perf_session     *session;
-        const char              *file;
+        struct perf_data_file   file;
         int                      idx;
         struct hists            *hists;
         struct diff_hpp_fmt      fmt[PERF_HPP_DIFF__MAX_INDEX];
@@ -601,7 +602,7 @@ static void data__fprintf(void)
 
         data__for_each_file(i, d)
                 fprintf(stdout, "#  [%d] %s %s\n",
-                        d->idx, d->file,
+                        d->idx, d->file.path,
                         !d->idx ? "(Baseline)" : "");
 
         fprintf(stdout, "#\n");
@@ -663,17 +664,16 @@ static int __cmd_diff(void)
         int ret = -EINVAL, i;
 
         data__for_each_file(i, d) {
-                d->session = perf_session__new(d->file, O_RDONLY, force,
-                                               false, &tool);
+                d->session = perf_session__new(&d->file, false, &tool);
                 if (!d->session) {
-                        pr_err("Failed to open %s\n", d->file);
+                        pr_err("Failed to open %s\n", d->file.path);
                         ret = -ENOMEM;
                         goto out_delete;
                 }
 
                 ret = perf_session__process_events(d->session, &tool);
                 if (ret) {
-                        pr_err("Failed to process %s\n", d->file);
+                        pr_err("Failed to process %s\n", d->file.path);
                         goto out_delete;
                 }
 
@@ -1016,7 +1016,12 @@ static int data_init(int argc, const char **argv)
                 return -ENOMEM;
 
         data__for_each_file(i, d) {
-                d->file = use_default ? defaults[i] : argv[i];
+                struct perf_data_file *file = &d->file;
+
+                file->path  = use_default ? defaults[i] : argv[i];
+                file->mode  = PERF_DATA_MODE_READ,
+                file->force = force,
+
                 d->idx  = i;
         }
 
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index 05bd9dfe875c..20b0f12763b0 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -14,13 +14,18 @@
 #include "util/parse-events.h"
 #include "util/parse-options.h"
 #include "util/session.h"
+#include "util/data.h"
 
 static int __cmd_evlist(const char *file_name, struct perf_attr_details *details)
 {
         struct perf_session *session;
         struct perf_evsel *pos;
+        struct perf_data_file file = {
+                .path = file_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
 
-        session = perf_session__new(file_name, O_RDONLY, 0, false, NULL);
+        session = perf_session__new(&file, 0, NULL);
         if (session == NULL)
                 return -ENOMEM;
 
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index f51a9637f69b..4aa6d7850bcc 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -15,6 +15,7 @@
 #include "util/tool.h"
 #include "util/debug.h"
 #include "util/build-id.h"
+#include "util/data.h"
 
 #include "util/parse-options.h"
 
@@ -345,6 +346,10 @@ static int __cmd_inject(struct perf_inject *inject)
 {
         struct perf_session *session;
         int ret = -EINVAL;
+        struct perf_data_file file = {
+                .path = inject->input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
 
         signal(SIGINT, sig_handler);
 
@@ -355,7 +360,7 @@ static int __cmd_inject(struct perf_inject *inject)
                 inject->tool.tracing_data = perf_event__repipe_tracing_data;
         }
 
-        session = perf_session__new(inject->input_name, O_RDONLY, false, true, &inject->tool);
+        session = perf_session__new(&file, true, &inject->tool);
         if (session == NULL)
                 return -ENOMEM;
 
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 9b5f077fee5b..1126382659a9 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -13,6 +13,7 @@
 
 #include "util/parse-options.h"
 #include "util/trace-event.h"
+#include "util/data.h"
 
 #include "util/debug.h"
 
@@ -486,8 +487,12 @@ static int __cmd_kmem(void)
                 { "kmem:kfree",                 perf_evsel__process_free_event, },
                 { "kmem:kmem_cache_free",       perf_evsel__process_free_event, },
         };
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false, &perf_kmem);
+        session = perf_session__new(&file, false, &perf_kmem);
         if (session == NULL)
                 return -ENOMEM;
 
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index cfa0b7979914..188bb29b373f 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -17,6 +17,7 @@
 #include "util/tool.h"
 #include "util/stat.h"
 #include "util/top.h"
+#include "util/data.h"
 
 #include <sys/prctl.h>
 #include <sys/timerfd.h>
@@ -1215,10 +1216,13 @@ static int read_events(struct perf_kvm_stat *kvm)
                 .comm                   = perf_event__process_comm,
                 .ordered_samples        = true,
         };
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
 
         kvm->tool = eops;
-        kvm->session = perf_session__new(kvm->file_name, O_RDONLY, 0, false,
-                                         &kvm->tool);
+        kvm->session = perf_session__new(&file, false, &kvm->tool);
         if (!kvm->session) {
                 pr_err("Initializing perf session failed\n");
                 return -EINVAL;
@@ -1450,6 +1454,9 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
                 "perf kvm stat live [<options>]",
                 NULL
         };
+        struct perf_data_file file = {
+                .mode = PERF_DATA_MODE_WRITE,
+        };
 
 
         /* event handling */
@@ -1514,7 +1521,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
         /*
          * perf session
          */
-        kvm->session = perf_session__new(NULL, O_WRONLY, false, false, &kvm->tool);
+        kvm->session = perf_session__new(&file, false, &kvm->tool);
         if (kvm->session == NULL) {
                 err = -ENOMEM;
                 goto out;
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 6a9076f165f4..33c7253295b9 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -15,6 +15,7 @@
 #include "util/debug.h"
 #include "util/session.h"
 #include "util/tool.h"
+#include "util/data.h"
 
 #include <sys/types.h>
 #include <sys/prctl.h>
@@ -853,8 +854,12 @@ static int __cmd_report(bool display_info)
                 .comm            = perf_event__process_comm,
                 .ordered_samples = true,
         };
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false, &eops);
+        session = perf_session__new(&file, false, &eops);
         if (!session) {
                 pr_err("Initializing perf session failed\n");
                 return -ENOMEM;
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 253133a6251d..31c00f186da1 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -5,6 +5,7 @@
 #include "util/trace-event.h"
 #include "util/tool.h"
 #include "util/session.h"
+#include "util/data.h"
 
 #define MEM_OPERATION_LOAD      "load"
 #define MEM_OPERATION_STORE     "store"
@@ -119,10 +120,14 @@ static int process_sample_event(struct perf_tool *tool,
 
 static int report_raw_events(struct perf_mem *mem)
 {
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
         int err = -EINVAL;
         int ret;
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY,
-                                                         0, false, &mem->tool);
+        struct perf_session *session = perf_session__new(&file, false,
+                                                         &mem->tool);
 
         if (session == NULL)
                 return -ENOMEM;
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 92ca5419073b..ab8d15e6e8cc 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -24,6 +24,7 @@
 #include "util/symbol.h"
 #include "util/cpumap.h"
 #include "util/thread_map.h"
+#include "util/data.h"
 
 #include <unistd.h>
 #include <sched.h>
@@ -65,11 +66,10 @@ struct perf_record {
         struct perf_tool        tool;
         struct perf_record_opts opts;
         u64                     bytes_written;
-        const char              *output_name;
+        struct perf_data_file   file;
         struct perf_evlist      *evlist;
         struct perf_session     *session;
         const char              *progname;
-        int                     output;
         int                     realtime_prio;
         bool                    no_buildid;
         bool                    no_buildid_cache;
@@ -84,11 +84,13 @@ static void advance_output(struct perf_record *rec, size_t size)
 
 static int write_output(struct perf_record *rec, void *buf, size_t size)
 {
+        struct perf_data_file *file = &rec->file;
+
         while (size) {
-                int ret = write(rec->output, buf, size);
+                int ret = write(file->fd, buf, size);
 
                 if (ret < 0) {
-                        pr_err("failed to write\n");
+                        pr_err("failed to write perf data, error: %m\n");
                         return -1;
                 }
 
@@ -248,13 +250,14 @@ out:
 
 static int process_buildids(struct perf_record *rec)
 {
-        u64 size = lseek(rec->output, 0, SEEK_CUR);
+        struct perf_data_file *file  = &rec->file;
+        struct perf_session *session = rec->session;
 
+        u64 size = lseek(file->fd, 0, SEEK_CUR);
         if (size == 0)
                 return 0;
 
-        rec->session->fd = rec->output;
-        return __perf_session__process_events(rec->session, rec->post_processing_offset,
+        return __perf_session__process_events(session, rec->post_processing_offset,
                                               size - rec->post_processing_offset,
                                               size, &build_id__mark_dso_hit_ops);
 }
@@ -262,17 +265,18 @@ static int process_buildids(struct perf_record *rec)
 static void perf_record__exit(int status, void *arg)
 {
         struct perf_record *rec = arg;
+        struct perf_data_file *file = &rec->file;
 
         if (status != 0)
                 return;
 
-        if (!rec->opts.pipe_output) {
+        if (!file->is_pipe) {
                 rec->session->header.data_size += rec->bytes_written;
 
                 if (!rec->no_buildid)
                         process_buildids(rec);
                 perf_session__write_header(rec->session, rec->evlist,
-                                           rec->output, true);
+                                           file->fd, true);
                 perf_session__delete(rec->session);
                 perf_evlist__delete(rec->evlist);
                 symbol__exit();
@@ -340,16 +344,14 @@ out:
 
 static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 {
-        struct stat st;
-        int flags;
-        int err, output, feat;
+        int err, feat;
         unsigned long waking = 0;
         const bool forks = argc > 0;
         struct machine *machine;
         struct perf_tool *tool = &rec->tool;
         struct perf_record_opts *opts = &rec->opts;
         struct perf_evlist *evsel_list = rec->evlist;
-        const char *output_name = rec->output_name;
+        struct perf_data_file *file = &rec->file;
         struct perf_session *session;
         bool disabled = false;
 
@@ -361,39 +363,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         signal(SIGUSR1, sig_handler);
         signal(SIGTERM, sig_handler);
 
-        if (!output_name) {
-                if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
-                        opts->pipe_output = true;
-                else
-                        rec->output_name = output_name = "perf.data";
-        }
-        if (output_name) {
-                if (!strcmp(output_name, "-"))
-                        opts->pipe_output = true;
-                else if (!stat(output_name, &st) && st.st_size) {
-                        char oldname[PATH_MAX];
-                        snprintf(oldname, sizeof(oldname), "%s.old",
-                                 output_name);
-                        unlink(oldname);
-                        rename(output_name, oldname);
-                }
-        }
-
-        flags = O_CREAT|O_RDWR|O_TRUNC;
-
-        if (opts->pipe_output)
-                output = STDOUT_FILENO;
-        else
-                output = open(output_name, flags, S_IRUSR | S_IWUSR);
-        if (output < 0) {
-                perror("failed to create output file");
-                return -1;
-        }
-
-        rec->output = output;
-
-        session = perf_session__new(output_name, O_WRONLY,
-                                    true, false, NULL);
+        session = perf_session__new(file, false, NULL);
         if (session == NULL) {
                 pr_err("Not enough memory for reading perf file header\n");
                 return -1;
@@ -415,7 +385,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 
         if (forks) {
                 err = perf_evlist__prepare_workload(evsel_list, &opts->target,
-                                                    argv, opts->pipe_output,
+                                                    argv, file->is_pipe,
                                                     true);
                 if (err < 0) {
                         pr_err("Couldn't run the workload!\n");
@@ -436,13 +406,13 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
          */
         on_exit(perf_record__exit, rec);
 
-        if (opts->pipe_output) {
-                err = perf_header__write_pipe(output);
+        if (file->is_pipe) {
+                err = perf_header__write_pipe(file->fd);
                 if (err < 0)
                         goto out_delete_session;
         } else {
                 err = perf_session__write_header(session, evsel_list,
-                                                 output, false);
+                                                 file->fd, false);
                 if (err < 0)
                         goto out_delete_session;
         }
@@ -455,11 +425,11 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                 goto out_delete_session;
         }
 
-        rec->post_processing_offset = lseek(output, 0, SEEK_CUR);
+        rec->post_processing_offset = lseek(file->fd, 0, SEEK_CUR);
 
         machine = &session->machines.host;
 
-        if (opts->pipe_output) {
+        if (file->is_pipe) {
                 err = perf_event__synthesize_attrs(tool, session,
                                                    process_synthesized_event);
                 if (err < 0) {
@@ -476,7 +446,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                          * return this more properly and also
                          * propagate errors that now are calling die()
                          */
-                        err = perf_event__synthesize_tracing_data(tool, output, evsel_list,
+                        err = perf_event__synthesize_tracing_data(tool, file->fd, evsel_list,
                                                                   process_synthesized_event);
                         if (err <= 0) {
                                 pr_err("Couldn't record tracing data.\n");
@@ -583,7 +553,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         fprintf(stderr,
                 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
                 (double)rec->bytes_written / 1024.0 / 1024.0,
-                output_name,
+                file->path,
                 rec->bytes_written / 24);
 
         return 0;
@@ -845,7 +815,7 @@ const struct option record_options[] = {
         OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
                     "list of cpus to monitor"),
         OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
-        OPT_STRING('o', "output", &record.output_name, "file",
+        OPT_STRING('o', "output", &record.file.path, "file",
                     "output file name"),
         OPT_BOOLEAN('i', "no-inherit", &record.opts.no_inherit,
                     "child tasks do not inherit counters"),
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 21b5c2f54c2a..81addcabb356 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -33,6 +33,7 @@
 #include "util/thread.h"
 #include "util/sort.h"
 #include "util/hist.h"
+#include "util/data.h"
 #include "arch/common.h"
 
 #include <dlfcn.h>
@@ -48,6 +49,7 @@ struct perf_report {
         bool                    show_threads;
         bool                    inverted_callchain;
         bool                    mem_mode;
+        int                     max_stack;
         struct perf_read_values show_threads_values;
         const char              *pretty_printing_style;
         const char              *cpu_list;
@@ -89,7 +91,8 @@ static int perf_report__add_mem_hist_entry(struct perf_tool *tool,
         if ((sort__has_parent || symbol_conf.use_callchain) &&
             sample->callchain) {
                 err = machine__resolve_callchain(machine, evsel, al->thread,
-                                                 sample, &parent, al);
+                                                 sample, &parent, al,
+                                                 rep->max_stack);
                 if (err)
                         return err;
         }
@@ -180,7 +183,8 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
         if ((sort__has_parent || symbol_conf.use_callchain)
             && sample->callchain) {
                 err = machine__resolve_callchain(machine, evsel, al->thread,
-                                                 sample, &parent, al);
+                                                 sample, &parent, al,
+                                                 rep->max_stack);
                 if (err)
                         return err;
         }
@@ -243,18 +247,21 @@ out:
         return err;
 }
 
-static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
+static int perf_evsel__add_hist_entry(struct perf_tool *tool,
+                                      struct perf_evsel *evsel,
                                       struct addr_location *al,
                                       struct perf_sample *sample,
                                       struct machine *machine)
 {
+        struct perf_report *rep = container_of(tool, struct perf_report, tool);
         struct symbol *parent = NULL;
         int err = 0;
         struct hist_entry *he;
 
         if ((sort__has_parent || symbol_conf.use_callchain) && sample->callchain) {
                 err = machine__resolve_callchain(machine, evsel, al->thread,
-                                                 sample, &parent, al);
+                                                 sample, &parent, al,
+                                                 rep->max_stack);
                 if (err)
                         return err;
         }
@@ -331,7 +338,8 @@ static int process_sample_event(struct perf_tool *tool,
                 if (al.map != NULL)
                         al.map->dso->hit = 1;
 
-                ret = perf_evsel__add_hist_entry(evsel, &al, sample, machine);
+                ret = perf_evsel__add_hist_entry(tool, evsel, &al, sample,
+                                                 machine);
                 if (ret < 0)
                         pr_debug("problem incrementing symbol period, skipping event\n");
         }
@@ -367,8 +375,9 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
 {
         struct perf_session *self = rep->session;
         u64 sample_type = perf_evlist__combined_sample_type(self->evlist);
+        bool is_pipe = perf_data_file__is_pipe(self->file);
 
-        if (!self->fd_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
+        if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
                         ui__error("Selected --sort parent, but no "
                                     "callchain data. Did you call "
@@ -391,7 +400,7 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
         }
 
         if (sort__mode == SORT_MODE__BRANCH) {
-                if (!self->fd_pipe &&
+                if (!is_pipe &&
                     !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
                         ui__error("Selected -b but no branch data. "
                                   "Did you call perf record without -b?\n");
@@ -487,6 +496,7 @@ static int __cmd_report(struct perf_report *rep)
         struct map *kernel_map;
         struct kmap *kernel_kmap;
         const char *help = "For a higher level overview, try: perf report --sort comm,dso";
+        struct perf_data_file *file = session->file;
 
         signal(SIGINT, sig_handler);
 
@@ -571,7 +581,7 @@ static int __cmd_report(struct perf_report *rep)
                 return 0;
 
         if (nr_samples == 0) {
-                ui__error("The %s file has no samples!\n", session->filename);
+                ui__error("The %s file has no samples!\n", file->path);
                 return 0;
         }
 
@@ -769,6 +779,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                         .ordered_samples = true,
                         .ordering_requires_timestamps = true,
                 },
+                .max_stack               = PERF_MAX_STACK_DEPTH,
                 .pretty_printing_style   = "normal",
         };
         const struct option options[] = {
@@ -809,6 +820,10 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_CALLBACK_DEFAULT('g', "call-graph", &report, "output_type,min_percent[,print_limit],call_order",
                      "Display callchains using output_type (graph, flat, fractal, or none) , min percent threshold, optional print limit, callchain order, key (function or address). "
                      "Default: fractal,0.5,callee,function", &parse_callchain_opt, callchain_default_opt),
+        OPT_INTEGER(0, "max-stack", &report.max_stack,
+                    "Set the maximum stack depth when parsing the callchain, "
+                    "anything beyond the specified depth will be ignored. "
+                    "Default: " __stringify(PERF_MAX_STACK_DEPTH)),
         OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,
                     "alias for inverted call graph"),
         OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
@@ -857,6 +872,9 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                      "Don't show entries under that percent", parse_percent_limit),
         OPT_END()
         };
+        struct perf_data_file file = {
+                .mode  = PERF_DATA_MODE_READ,
+        };
 
         perf_config(perf_report_config, &report);
 
@@ -886,9 +904,11 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                 perf_hpp__init();
         }
 
+        file.path  = input_name;
+        file.force = report.force;
+
 repeat:
-        session = perf_session__new(input_name, O_RDONLY,
-                                    report.force, false, &report.tool);
+        session = perf_session__new(&file, false, &report.tool);
         if (session == NULL)
                 return -ENOMEM;
 
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index d8c51b2f263f..5a46b102eb08 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -1446,8 +1446,12 @@ static int perf_sched__read_events(struct perf_sched *sched,
                 { "sched:sched_migrate_task", process_sched_migrate_task_event, },
         };
         struct perf_session *session;
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false, &sched->tool);
+        session = perf_session__new(&file, false, &sched->tool);
         if (session == NULL) {
                 pr_debug("No Memory for session\n");
                 return -1;
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 9c333ff3dfeb..27de6068049d 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -15,6 +15,7 @@
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/sort.h"
+#include "util/data.h"
 #include <linux/bitmap.h>
 
 static char const               *script_name;
@@ -409,7 +410,9 @@ static void print_sample_bts(union perf_event *event,
         printf(" => ");
 
         /* print branch_to information */
-        if (PRINT_FIELD(ADDR))
+        if (PRINT_FIELD(ADDR) ||
+            ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
+             !output[attr->type].user_set))
                 print_sample_addr(event, sample, machine, thread, attr);
 
         printf("\n");
@@ -1113,10 +1116,14 @@ int find_scripts(char **scripts_array, char **scripts_path_array)
         char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
         DIR *scripts_dir, *lang_dir;
         struct perf_session *session;
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
         char *temp;
         int i = 0;
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false, NULL);
+        session = perf_session__new(&file, false, NULL);
         if (!session)
                 return -1;
 
@@ -1317,12 +1324,17 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                 "perf script [<options>] <top-script> [script-args]",
                 NULL
         };
+        struct perf_data_file file = {
+                .mode = PERF_DATA_MODE_READ,
+        };
 
         setup_scripting();
 
         argc = parse_options(argc, argv, options, script_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
 
+        file.path = input_name;
+
         if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
                 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
                 if (!rec_script_path)
@@ -1486,8 +1498,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
         if (!script_name)
                 setup_pager();
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false,
-                                    &perf_script);
+        session = perf_session__new(&file, false, &perf_script);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -1514,7 +1525,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                         return -1;
                 }
 
-                input = open(session->filename, O_RDONLY);      /* input_name */
+                input = open(file.path, O_RDONLY);      /* input_name */
                 if (input < 0) {
                         perror("failed to open file");
                         return -1;
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index c2e02319347a..e11c61d9bda4 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -36,6 +36,7 @@
 #include "util/session.h"
 #include "util/svghelper.h"
 #include "util/tool.h"
+#include "util/data.h"
 
 #define SUPPORT_OLD_POWER_EVENTS 1
 #define PWR_EVENT_EXIT -1
@@ -990,8 +991,13 @@ static int __cmd_timechart(const char *output_name)
                 { "power:power_frequency",      process_sample_power_frequency },
 #endif
         };
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY,
-                                                         0, false, &perf_timechart);
+        struct perf_data_file file = {
+                .path = input_name,
+                .mode = PERF_DATA_MODE_READ,
+        };
+
+        struct perf_session *session = perf_session__new(&file, false,
+                                                         &perf_timechart);
         int ret = -EINVAL;
 
         if (session == NULL)
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 65c49b2f51c1..386d83324a8d 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -770,7 +770,8 @@ static void perf_event__process_sample(struct perf_tool *tool,
                     sample->callchain) {
                         err = machine__resolve_callchain(machine, evsel,
                                                          al.thread, sample,
-                                                         &parent, &al);
+                                                         &parent, &al,
+                                                         top->max_stack);
                         if (err)
                                 return;
                 }
@@ -929,11 +930,8 @@ static int __cmd_top(struct perf_top *top)
         struct perf_record_opts *opts = &top->record_opts;
         pthread_t thread;
         int ret;
-        /*
-         * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
-         * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
-         */
-        top->session = perf_session__new(NULL, O_WRONLY, false, false, NULL);
+
+        top->session = perf_session__new(NULL, false, NULL);
         if (top->session == NULL)
                 return -ENOMEM;
 
@@ -1050,10 +1048,11 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                         .user_freq      = UINT_MAX,
                         .user_interval  = ULLONG_MAX,
                         .freq           = 4000, /* 4 KHz */
-                        .target              = {
+                        .target         = {
                                 .uses_mmap   = true,
                         },
                 },
+                .max_stack           = PERF_MAX_STACK_DEPTH,
                 .sym_pcnt_filter     = 5,
         };
         struct perf_record_opts *opts = &top.record_opts;
@@ -1112,6 +1111,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_CALLBACK_DEFAULT('G', "call-graph", &top.record_opts,
                              "mode[,dump_size]", record_callchain_help,
                              &parse_callchain_opt, "fp"),
+        OPT_INTEGER(0, "max-stack", &top.max_stack,
+                    "Set the maximum stack depth when parsing the callchain. "
+                    "Default: " __stringify(PERF_MAX_STACK_DEPTH)),
         OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
                    "ignore callees of these functions in call graphs",
                    report_parse_ignore_callees_opt),
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index d0f91fe755a3..fa620bc1db69 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -951,7 +951,10 @@ fail:
 
 struct trace {
         struct perf_tool        tool;
-        int                     audit_machine;
+        struct {
+                int             machine;
+                int             open_id;
+        }                       audit;
         struct {
                 int             max;
                 struct syscall  *table;
@@ -965,40 +968,24 @@ struct trace {
         struct strlist          *ev_qualifier;
         bool                    not_ev_qualifier;
         bool                    live;
+        const char              *last_vfs_getname;
         struct intlist          *tid_list;
         struct intlist          *pid_list;
         bool                    sched;
         bool                    multiple_threads;
         bool                    summary;
         bool                    show_comm;
+        bool                    show_tool_stats;
         double                  duration_filter;
         double                  runtime_ms;
+        struct {
+                u64             vfs_getname, proc_getname;
+        } stats;
 };
 
-static int thread__read_fd_path(struct thread *thread, int fd)
+static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
 {
         struct thread_trace *ttrace = thread->priv;
-        char linkname[PATH_MAX], pathname[PATH_MAX];
-        struct stat st;
-        int ret;
-
-        if (thread->pid_ == thread->tid) {
-                scnprintf(linkname, sizeof(linkname),
-                          "/proc/%d/fd/%d", thread->pid_, fd);
-        } else {
-                scnprintf(linkname, sizeof(linkname),
-                          "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
-        }
-
-        if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
-                return -1;
-
-        ret = readlink(linkname, pathname, sizeof(pathname));
-
-        if (ret < 0 || ret > st.st_size)
-                return -1;
-
-        pathname[ret] = '\0';
 
         if (fd > ttrace->paths.max) {
                 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
@@ -1022,7 +1009,34 @@ static int thread__read_fd_path(struct thread *thread, int fd)
         return ttrace->paths.table[fd] != NULL ? 0 : -1;
 }
 
-static const char *thread__fd_path(struct thread *thread, int fd, bool live)
+static int thread__read_fd_path(struct thread *thread, int fd)
+{
+        char linkname[PATH_MAX], pathname[PATH_MAX];
+        struct stat st;
+        int ret;
+
+        if (thread->pid_ == thread->tid) {
+                scnprintf(linkname, sizeof(linkname),
+                          "/proc/%d/fd/%d", thread->pid_, fd);
+        } else {
+                scnprintf(linkname, sizeof(linkname),
+                          "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
+        }
+
+        if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
+                return -1;
+
+        ret = readlink(linkname, pathname, sizeof(pathname));
+
+        if (ret < 0 || ret > st.st_size)
+                return -1;
+
+        pathname[ret] = '\0';
+        return trace__set_fd_pathname(thread, fd, pathname);
+}
+
+static const char *thread__fd_path(struct thread *thread, int fd,
+                                   struct trace *trace)
 {
         struct thread_trace *ttrace = thread->priv;
 
@@ -1032,9 +1046,13 @@ static const char *thread__fd_path(struct thread *thread, int fd, bool live)
         if (fd < 0)
                 return NULL;
 
-        if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL) &&
-            (!live || thread__read_fd_path(thread, fd)))
-                return NULL;
+        if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL))
+                if (!trace->live)
+                        return NULL;
+                ++trace->stats.proc_getname;
+                if (thread__read_fd_path(thread, fd)) {
+                        return NULL;
+        }
 
         return ttrace->paths.table[fd];
 }
@@ -1044,7 +1062,7 @@ static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
 {
         int fd = arg->val;
         size_t printed = scnprintf(bf, size, "%d", fd);
-        const char *path = thread__fd_path(arg->thread, fd, arg->trace->live);
+        const char *path = thread__fd_path(arg->thread, fd, arg->trace);
 
         if (path)
                 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
@@ -1080,10 +1098,12 @@ static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
 }
 
 static bool done = false;
+static bool interrupted = false;
 
-static void sig_handler(int sig __maybe_unused)
+static void sig_handler(int sig)
 {
         done = true;
+        interrupted = sig == SIGINT;
 }
 
 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
@@ -1181,7 +1201,7 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 {
         char tp_name[128];
         struct syscall *sc;
-        const char *name = audit_syscall_to_name(id, trace->audit_machine);
+        const char *name = audit_syscall_to_name(id, trace->audit.machine);
 
         if (name == NULL)
                 return -1;
@@ -1445,6 +1465,12 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
 
         ret = perf_evsel__intval(evsel, sample, "ret");
 
+        if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
+                trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
+                trace->last_vfs_getname = NULL;
+                ++trace->stats.vfs_getname;
+        }
+
         ttrace = thread->priv;
 
         ttrace->exit_time = sample->time;
@@ -1489,6 +1515,13 @@ out:
         return 0;
 }
 
+static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
+                              struct perf_sample *sample)
+{
+        trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
+        return 0;
+}
+
 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
                                      struct perf_sample *sample)
 {
@@ -1611,6 +1644,22 @@ static int trace__record(int argc, const char **argv)
 
 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
 
+static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname",
+                                                     evlist->nr_entries);
+        if (evsel == NULL)
+                return;
+
+        if (perf_evsel__field(evsel, "pathname") == NULL) {
+                perf_evsel__delete(evsel);
+                return;
+        }
+
+        evsel->handler.func = trace__vfs_getname;
+        perf_evlist__add(evlist, evsel);
+}
+
 static int trace__run(struct trace *trace, int argc, const char **argv)
 {
         struct perf_evlist *evlist = perf_evlist__new();
@@ -1630,6 +1679,8 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
                 perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_exit", trace__sys_exit))
                 goto out_error_tp;
 
+        perf_evlist__add_vfs_getname(evlist);
+
         if (trace->sched &&
                 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
                                 trace__sched_stat_runtime))
@@ -1662,10 +1713,8 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
         }
 
         err = perf_evlist__open(evlist);
-        if (err < 0) {
-                fprintf(trace->output, "Couldn't create the events: %s\n", strerror(errno));
-                goto out_delete_maps;
-        }
+        if (err < 0)
+                goto out_error_open;
 
         err = perf_evlist__mmap(evlist, UINT_MAX, false);
         if (err < 0) {
@@ -1722,26 +1771,35 @@ again:
                         handler = evsel->handler.func;
                         handler(trace, evsel, &sample);
 
-                        if (done)
-                                goto out_unmap_evlist;
+                        if (interrupted)
+                                goto out_disable;
                 }
         }
 
         if (trace->nr_events == before) {
-                if (done)
-                        goto out_unmap_evlist;
+                int timeout = done ? 100 : -1;
 
-                poll(evlist->pollfd, evlist->nr_fds, -1);
+                if (poll(evlist->pollfd, evlist->nr_fds, timeout) > 0)
+                        goto again;
+        } else {
+                goto again;
         }
 
-        if (done)
-                perf_evlist__disable(evlist);
+out_disable:
+        perf_evlist__disable(evlist);
 
-        goto again;
+        if (!err) {
+                if (trace->summary)
+                        trace__fprintf_thread_summary(trace, trace->output);
 
-out_unmap_evlist:
-        if (!err && trace->summary)
-                trace__fprintf_thread_summary(trace, trace->output);
+                if (trace->show_tool_stats) {
+                        fprintf(trace->output, "Stats:\n "
+                                               " vfs_getname : %" PRIu64 "\n"
+                                               " proc_getname: %" PRIu64 "\n",
+                                trace->stats.vfs_getname,
+                                trace->stats.proc_getname);
+                }
+        }
 
         perf_evlist__munmap(evlist);
 out_close_evlist:
@@ -1753,38 +1811,33 @@ out_delete_evlist:
 out:
         trace->live = false;
         return err;
+{
+        char errbuf[BUFSIZ];
+
 out_error_tp:
-        switch(errno) {
-        case ENOENT:
-                fputs("Error:\tUnable to find debugfs\n"
-                      "Hint:\tWas your kernel was compiled with debugfs support?\n"
-                      "Hint:\tIs the debugfs filesystem mounted?\n"
-                      "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'\n",
-                      trace->output);
-                break;
-        case EACCES:
-                fprintf(trace->output,
-                        "Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"
-                        "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
-                        debugfs_mountpoint, debugfs_mountpoint);
-                break;
-        default: {
-                char bf[256];
-                fprintf(trace->output, "Can't trace: %s\n",
-                        strerror_r(errno, bf, sizeof(bf)));
-        }
-                break;
-        }
+        perf_evlist__strerror_tp(evlist, errno, errbuf, sizeof(errbuf));
+        goto out_error;
+
+out_error_open:
+        perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
+
+out_error:
+        fprintf(trace->output, "%s\n", errbuf);
         goto out_delete_evlist;
 }
+}
 
 static int trace__replay(struct trace *trace)
 {
         const struct perf_evsel_str_handler handlers[] = {
                 { "raw_syscalls:sys_enter",  trace__sys_enter, },
                 { "raw_syscalls:sys_exit",   trace__sys_exit, },
+                { "probe:vfs_getname",       trace__vfs_getname, },
+        };
+        struct perf_data_file file = {
+                .path  = input_name,
+                .mode  = PERF_DATA_MODE_READ,
         };
-
         struct perf_session *session;
         int err = -1;
 
@@ -1807,8 +1860,7 @@ static int trace__replay(struct trace *trace)
         if (symbol__init() < 0)
                 return -1;
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false,
-                                    &trace->tool);
+        session = perf_session__new(&file, false, &trace->tool);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -1992,7 +2044,10 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
                 NULL
         };
         struct trace trace = {
-                .audit_machine = audit_detect_machine(),
+                .audit = {
+                        .machine = audit_detect_machine(),
+                        .open_id = audit_name_to_syscall("open", trace.audit.machine),
+                },
                 .syscalls = {
                         . max = -1,
                 },
@@ -2014,6 +2069,7 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
         const struct option trace_options[] = {
         OPT_BOOLEAN(0, "comm", &trace.show_comm,
                     "show the thread COMM next to its id"),
+        OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
         OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
                     "list of events to trace"),
         OPT_STRING('o', "output", &output_name, "file", "output file name"),
diff --git a/tools/perf/config/feature-checks/test-on-exit.c b/tools/perf/config/feature-checks/test-on-exit.c
index 8f64ed3a58d9..8e88b16e6ded 100644
--- a/tools/perf/config/feature-checks/test-on-exit.c
+++ b/tools/perf/config/feature-checks/test-on-exit.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <stdlib.h>
 
 static void exit_fn(int status, void *__data)
 {
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 84502e88488b..f61c230beec4 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -220,7 +220,6 @@ struct perf_record_opts {
         bool         no_delay;
         bool         no_inherit;
         bool         no_samples;
-        bool         pipe_output;
         bool         raw_samples;
         bool         sample_address;
         bool         sample_weight;
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 482f68081cd8..e3970e3eaacf 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -21,12 +21,6 @@
 
 __thread struct callchain_cursor callchain_cursor;
 
-#define chain_for_each_child(child, parent)     \
-        list_for_each_entry(child, &parent->children, siblings)
-
-#define chain_for_each_child_safe(child, next, parent)  \
-        list_for_each_entry_safe(child, next, &parent->children, siblings)
-
 static void
 rb_insert_callchain(struct rb_root *root, struct callchain_node *chain,
                     enum chain_mode mode)
@@ -71,10 +65,16 @@ static void
 __sort_chain_flat(struct rb_root *rb_root, struct callchain_node *node,
                   u64 min_hit)
 {
+        struct rb_node *n;
         struct callchain_node *child;
 
-        chain_for_each_child(child, node)
+        n = rb_first(&node->rb_root_in);
+        while (n) {
+                child = rb_entry(n, struct callchain_node, rb_node_in);
+                n = rb_next(n);
+
                 __sort_chain_flat(rb_root, child, min_hit);
+        }
 
         if (node->hit && node->hit >= min_hit)
                 rb_insert_callchain(rb_root, node, CHAIN_FLAT);
@@ -94,11 +94,16 @@ sort_chain_flat(struct rb_root *rb_root, struct callchain_root *root,
 static void __sort_chain_graph_abs(struct callchain_node *node,
                                    u64 min_hit)
 {
+        struct rb_node *n;
         struct callchain_node *child;
 
         node->rb_root = RB_ROOT;
+        n = rb_first(&node->rb_root_in);
+
+        while (n) {
+                child = rb_entry(n, struct callchain_node, rb_node_in);
+                n = rb_next(n);
 
-        chain_for_each_child(child, node) {
                 __sort_chain_graph_abs(child, min_hit);
                 if (callchain_cumul_hits(child) >= min_hit)
                         rb_insert_callchain(&node->rb_root, child,
@@ -117,13 +122,18 @@ sort_chain_graph_abs(struct rb_root *rb_root, struct callchain_root *chain_root,
 static void __sort_chain_graph_rel(struct callchain_node *node,
                                    double min_percent)
 {
+        struct rb_node *n;
         struct callchain_node *child;
         u64 min_hit;
 
         node->rb_root = RB_ROOT;
         min_hit = ceil(node->children_hit * min_percent);
 
-        chain_for_each_child(child, node) {
+        n = rb_first(&node->rb_root_in);
+        while (n) {
+                child = rb_entry(n, struct callchain_node, rb_node_in);
+                n = rb_next(n);
+
                 __sort_chain_graph_rel(child, min_percent);
                 if (callchain_cumul_hits(child) >= min_hit)
                         rb_insert_callchain(&node->rb_root, child,
@@ -173,19 +183,26 @@ create_child(struct callchain_node *parent, bool inherit_children)
                 return NULL;
         }
         new->parent = parent;
-        INIT_LIST_HEAD(&new->children);
         INIT_LIST_HEAD(&new->val);
 
         if (inherit_children) {
-                struct callchain_node *next;
+                struct rb_node *n;
+                struct callchain_node *child;
+
+                new->rb_root_in = parent->rb_root_in;
+                parent->rb_root_in = RB_ROOT;
 
-                list_splice(&parent->children, &new->children);
-                INIT_LIST_HEAD(&parent->children);
+                n = rb_first(&new->rb_root_in);
+                while (n) {
+                        child = rb_entry(n, struct callchain_node, rb_node_in);
+                        child->parent = new;
+                        n = rb_next(n);
+                }
 
-                chain_for_each_child(next, new)
-                        next->parent = new;
+                /* make it the first child */
+                rb_link_node(&new->rb_node_in, NULL, &parent->rb_root_in.rb_node);
+                rb_insert_color(&new->rb_node_in, &parent->rb_root_in);
         }
-        list_add_tail(&new->siblings, &parent->children);
 
         return new;
 }
@@ -223,7 +240,7 @@ fill_node(struct callchain_node *node, struct callchain_cursor *cursor)
         }
 }
 
-static void
+static struct callchain_node *
 add_child(struct callchain_node *parent,
           struct callchain_cursor *cursor,
           u64 period)
@@ -235,6 +252,19 @@ add_child(struct callchain_node *parent,
 
         new->children_hit = 0;
         new->hit = period;
+        return new;
+}
+
+static s64 match_chain(struct callchain_cursor_node *node,
+                      struct callchain_list *cnode)
+{
+        struct symbol *sym = node->sym;
+
+        if (cnode->ms.sym && sym &&
+            callchain_param.key == CCKEY_FUNCTION)
+                return cnode->ms.sym->start - sym->start;
+        else
+                return cnode->ip - node->ip;
 }
 
 /*
@@ -272,9 +302,33 @@ split_add_child(struct callchain_node *parent,
 
         /* create a new child for the new branch if any */
         if (idx_total < cursor->nr) {
+                struct callchain_node *first;
+                struct callchain_list *cnode;
+                struct callchain_cursor_node *node;
+                struct rb_node *p, **pp;
+
                 parent->hit = 0;
-                add_child(parent, cursor, period);
                 parent->children_hit += period;
+
+                node = callchain_cursor_current(cursor);
+                new = add_child(parent, cursor, period);
+
+                /*
+                 * This is second child since we moved parent's children
+                 * to new (first) child above.
+                 */
+                p = parent->rb_root_in.rb_node;
+                first = rb_entry(p, struct callchain_node, rb_node_in);
+                cnode = list_first_entry(&first->val, struct callchain_list,
+                                         list);
+
+                if (match_chain(node, cnode) < 0)
+                        pp = &p->rb_left;
+                else
+                        pp = &p->rb_right;
+
+                rb_link_node(&new->rb_node_in, p, pp);
+                rb_insert_color(&new->rb_node_in, &parent->rb_root_in);
         } else {
                 parent->hit = period;
         }
@@ -291,16 +345,40 @@ append_chain_children(struct callchain_node *root,
                       u64 period)
 {
         struct callchain_node *rnode;
+        struct callchain_cursor_node *node;
+        struct rb_node **p = &root->rb_root_in.rb_node;
+        struct rb_node *parent = NULL;
+
+        node = callchain_cursor_current(cursor);
+        if (!node)
+                return;
 
         /* lookup in childrens */
-        chain_for_each_child(rnode, root) {
-                unsigned int ret = append_chain(rnode, cursor, period);
+        while (*p) {
+                s64 ret;
+                struct callchain_list *cnode;
 
-                if (!ret)
+                parent = *p;
+                rnode = rb_entry(parent, struct callchain_node, rb_node_in);
+                cnode = list_first_entry(&rnode->val, struct callchain_list,
+                                         list);
+
+                /* just check first entry */
+                ret = match_chain(node, cnode);
+                if (ret == 0) {
+                        append_chain(rnode, cursor, period);
                         goto inc_children_hit;
+                }
+
+                if (ret < 0)
+                        p = &parent->rb_left;
+                else
+                        p = &parent->rb_right;
         }
         /* nothing in children, add to the current node */
-        add_child(root, cursor, period);
+        rnode = add_child(root, cursor, period);
+        rb_link_node(&rnode->rb_node_in, parent, p);
+        rb_insert_color(&rnode->rb_node_in, &root->rb_root_in);
 
 inc_children_hit:
         root->children_hit += period;
@@ -325,28 +403,20 @@ append_chain(struct callchain_node *root,
          */
         list_for_each_entry(cnode, &root->val, list) {
                 struct callchain_cursor_node *node;
-                struct symbol *sym;
 
                 node = callchain_cursor_current(cursor);
                 if (!node)
                         break;
 
-                sym = node->sym;
-
-                if (cnode->ms.sym && sym &&
-                    callchain_param.key == CCKEY_FUNCTION) {
-                        if (cnode->ms.sym->start != sym->start)
-                                break;
-                } else if (cnode->ip != node->ip)
+                if (match_chain(node, cnode) != 0)
                         break;
 
-                if (!found)
-                        found = true;
+                found = true;
 
                 callchain_cursor_advance(cursor);
         }
 
-        /* matches not, relay on the parent */
+        /* matches not, relay no the parent */
         if (!found) {
                 cursor->curr = curr_snap;
                 cursor->pos = start;
@@ -395,8 +465,9 @@ merge_chain_branch(struct callchain_cursor *cursor,
                    struct callchain_node *dst, struct callchain_node *src)
 {
         struct callchain_cursor_node **old_last = cursor->last;
-        struct callchain_node *child, *next_child;
+        struct callchain_node *child;
         struct callchain_list *list, *next_list;
+        struct rb_node *n;
         int old_pos = cursor->nr;
         int err = 0;
 
@@ -412,12 +483,16 @@ merge_chain_branch(struct callchain_cursor *cursor,
                 append_chain_children(dst, cursor, src->hit);
         }
 
-        chain_for_each_child_safe(child, next_child, src) {
+        n = rb_first(&src->rb_root_in);
+        while (n) {
+                child = container_of(n, struct callchain_node, rb_node_in);
+                n = rb_next(n);
+                rb_erase(&child->rb_node_in, &src->rb_root_in);
+
                 err = merge_chain_branch(cursor, dst, child);
                 if (err)
                         break;
 
-                list_del(&child->siblings);
                 free(child);
         }
 
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 2b585bc308cf..7bb36022377f 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -21,11 +21,11 @@ enum chain_order {
 
 struct callchain_node {
         struct callchain_node   *parent;
-        struct list_head        siblings;
-        struct list_head        children;
         struct list_head        val;
-        struct rb_node          rb_node; /* to sort nodes in an rbtree */
-        struct rb_root          rb_root; /* sorted tree of children */
+        struct rb_node          rb_node_in; /* to insert nodes in an rbtree */
+        struct rb_node          rb_node;    /* to sort nodes in an output tree */
+        struct rb_root          rb_root_in; /* input tree of children */
+        struct rb_root          rb_root;    /* sorted output tree of children */
         unsigned int            val_nr;
         u64                     hit;
         u64                     children_hit;
@@ -86,13 +86,12 @@ extern __thread struct callchain_cursor callchain_cursor;
 
 static inline void callchain_init(struct callchain_root *root)
 {
-        INIT_LIST_HEAD(&root->node.siblings);
-        INIT_LIST_HEAD(&root->node.children);
         INIT_LIST_HEAD(&root->node.val);
 
         root->node.parent = NULL;
         root->node.hit = 0;
         root->node.children_hit = 0;
+        root->node.rb_root_in = RB_ROOT;
         root->max_depth = 0;
 }
 
diff --git a/tools/perf/util/data.c b/tools/perf/util/data.c
new file mode 100644
index 000000000000..7d09faf85cf1
--- /dev/null
+++ b/tools/perf/util/data.c
@@ -0,0 +1,120 @@
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "data.h"
+#include "util.h"
+
+static bool check_pipe(struct perf_data_file *file)
+{
+        struct stat st;
+        bool is_pipe = false;
+        int fd = perf_data_file__is_read(file) ?
+                 STDIN_FILENO : STDOUT_FILENO;
+
+        if (!file->path) {
+                if (!fstat(fd, &st) && S_ISFIFO(st.st_mode))
+                        is_pipe = true;
+        } else {
+                if (!strcmp(file->path, "-"))
+                        is_pipe = true;
+        }
+
+        if (is_pipe)
+                file->fd = fd;
+
+        return file->is_pipe = is_pipe;
+}
+
+static int check_backup(struct perf_data_file *file)
+{
+        struct stat st;
+
+        if (!stat(file->path, &st) && st.st_size) {
+                /* TODO check errors properly */
+                char oldname[PATH_MAX];
+                snprintf(oldname, sizeof(oldname), "%s.old",
+                         file->path);
+                unlink(oldname);
+                rename(file->path, oldname);
+        }
+
+        return 0;
+}
+
+static int open_file_read(struct perf_data_file *file)
+{
+        struct stat st;
+        int fd;
+
+        fd = open(file->path, O_RDONLY);
+        if (fd < 0) {
+                int err = errno;
+
+                pr_err("failed to open %s: %s", file->path, strerror(err));
+                if (err == ENOENT && !strcmp(file->path, "perf.data"))
+                        pr_err("  (try 'perf record' first)");
+                pr_err("\n");
+                return -err;
+        }
+
+        if (fstat(fd, &st) < 0)
+                goto out_close;
+
+        if (!file->force && st.st_uid && (st.st_uid != geteuid())) {
+                pr_err("file %s not owned by current user or root\n",
+                       file->path);
+                goto out_close;
+        }
+
+        if (!st.st_size) {
+                pr_info("zero-sized file (%s), nothing to do!\n",
+                        file->path);
+                goto out_close;
+        }
+
+        file->size = st.st_size;
+        return fd;
+
+ out_close:
+        close(fd);
+        return -1;
+}
+
+static int open_file_write(struct perf_data_file *file)
+{
+        if (check_backup(file))
+                return -1;
+
+        return open(file->path, O_CREAT|O_RDWR|O_TRUNC, S_IRUSR|S_IWUSR);
+}
+
+static int open_file(struct perf_data_file *file)
+{
+        int fd;
+
+        fd = perf_data_file__is_read(file) ?
+             open_file_read(file) : open_file_write(file);
+
+        file->fd = fd;
+        return fd < 0 ? -1 : 0;
+}
+
+int perf_data_file__open(struct perf_data_file *file)
+{
+        if (check_pipe(file))
+                return 0;
+
+        if (!file->path)
+                file->path = "perf.data";
+
+        return open_file(file);
+}
+
+void perf_data_file__close(struct perf_data_file *file)
+{
+        close(file->fd);
+}
diff --git a/tools/perf/util/data.h b/tools/perf/util/data.h
new file mode 100644
index 000000000000..8c2df80152a5
--- /dev/null
+++ b/tools/perf/util/data.h
@@ -0,0 +1,48 @@
+#ifndef __PERF_DATA_H
+#define __PERF_DATA_H
+
+#include <stdbool.h>
+
+enum perf_data_mode {
+        PERF_DATA_MODE_WRITE,
+        PERF_DATA_MODE_READ,
+};
+
+struct perf_data_file {
+        const char *path;
+        int fd;
+        bool is_pipe;
+        bool force;
+        unsigned long size;
+        enum perf_data_mode mode;
+};
+
+static inline bool perf_data_file__is_read(struct perf_data_file *file)
+{
+        return file->mode == PERF_DATA_MODE_READ;
+}
+
+static inline bool perf_data_file__is_write(struct perf_data_file *file)
+{
+        return file->mode == PERF_DATA_MODE_WRITE;
+}
+
+static inline int perf_data_file__is_pipe(struct perf_data_file *file)
+{
+        return file->is_pipe;
+}
+
+static inline int perf_data_file__fd(struct perf_data_file *file)
+{
+        return file->fd;
+}
+
+static inline unsigned long perf_data_file__size(struct perf_data_file *file)
+{
+        return file->size;
+}
+
+int perf_data_file__open(struct perf_data_file *file);
+void perf_data_file__close(struct perf_data_file *file);
+
+#endif /* __PERF_DATA_H */
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index cb9523f50a37..85c4c80bcac8 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -608,9 +608,36 @@ static int __perf_evlist__mmap(struct perf_evlist *evlist,
         return 0;
 }
 
-static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int mask)
+static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
+                                       int prot, int mask, int cpu, int thread,
+                                       int *output)
 {
         struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                int fd = FD(evsel, cpu, thread);
+
+                if (*output == -1) {
+                        *output = fd;
+                        if (__perf_evlist__mmap(evlist, idx, prot, mask,
+                                                *output) < 0)
+                                return -1;
+                } else {
+                        if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
+                                return -1;
+                }
+
+                if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
+                    perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
+                        return -1;
+        }
+
+        return 0;
+}
+
+static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot,
+                                     int mask)
+{
         int cpu, thread;
         int nr_cpus = cpu_map__nr(evlist->cpus);
         int nr_threads = thread_map__nr(evlist->threads);
@@ -620,23 +647,9 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
                 int output = -1;
 
                 for (thread = 0; thread < nr_threads; thread++) {
-                        list_for_each_entry(evsel, &evlist->entries, node) {
-                                int fd = FD(evsel, cpu, thread);
-
-                                if (output == -1) {
-                                        output = fd;
-                                        if (__perf_evlist__mmap(evlist, cpu,
-                                                                prot, mask, output) < 0)
-                                                goto out_unmap;
-                                } else {
-                                        if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
-                                                goto out_unmap;
-                                }
-
-                                if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
-                                    perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
-                                        goto out_unmap;
-                        }
+                        if (perf_evlist__mmap_per_evsel(evlist, cpu, prot, mask,
+                                                        cpu, thread, &output))
+                                goto out_unmap;
                 }
         }
 
@@ -648,9 +661,9 @@ out_unmap:
         return -1;
 }
 
-static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, int mask)
+static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot,
+                                        int mask)
 {
-        struct perf_evsel *evsel;
         int thread;
         int nr_threads = thread_map__nr(evlist->threads);
 
@@ -658,23 +671,9 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
         for (thread = 0; thread < nr_threads; thread++) {
                 int output = -1;
 
-                list_for_each_entry(evsel, &evlist->entries, node) {
-                        int fd = FD(evsel, 0, thread);
-
-                        if (output == -1) {
-                                output = fd;
-                                if (__perf_evlist__mmap(evlist, thread,
-                                                        prot, mask, output) < 0)
-                                        goto out_unmap;
-                        } else {
-                                if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
-                                        goto out_unmap;
-                        }
-
-                        if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
-                            perf_evlist__id_add_fd(evlist, evsel, 0, thread, fd) < 0)
-                                goto out_unmap;
-                }
+                if (perf_evlist__mmap_per_evsel(evlist, thread, prot, mask, 0,
+                                                thread, &output))
+                        goto out_unmap;
         }
 
         return 0;
@@ -738,20 +737,17 @@ int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str,
         return 0;
 }
 
-/** perf_evlist__mmap - Create per cpu maps to receive events
- *
- * @evlist - list of events
- * @pages - map length in pages
- * @overwrite - overwrite older events?
- *
- * If overwrite is false the user needs to signal event consuption using:
- *
- *      struct perf_mmap *m = &evlist->mmap[cpu];
- *      unsigned int head = perf_mmap__read_head(m);
+/**
+ * perf_evlist__mmap - Create mmaps to receive events.
+ * @evlist: list of events
+ * @pages: map length in pages
+ * @overwrite: overwrite older events?
  *
- *      perf_mmap__write_tail(m, head)
+ * If @overwrite is %false the user needs to signal event consumption using
+ * perf_mmap__write_tail().  Using perf_evlist__mmap_read() does this
+ * automatically.
  *
- * Using perf_evlist__read_on_cpu does this automatically.
+ * Return: %0 on success, negative error code otherwise.
  */
 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
                       bool overwrite)
@@ -769,7 +765,7 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
 
         evlist->overwrite = overwrite;
         evlist->mmap_len = perf_evlist__mmap_size(pages);
-        pr_debug("mmap size %luB\n", evlist->mmap_len);
+        pr_debug("mmap size %zuB\n", evlist->mmap_len);
         mask = evlist->mmap_len - page_size - 1;
 
         list_for_each_entry(evsel, &evlist->entries, node) {
@@ -1126,3 +1122,66 @@ size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
 
         return printed + fprintf(fp, "\n");;
 }
+
+int perf_evlist__strerror_tp(struct perf_evlist *evlist __maybe_unused,
+                             int err, char *buf, size_t size)
+{
+        char sbuf[128];
+
+        switch (err) {
+        case ENOENT:
+                scnprintf(buf, size, "%s",
+                          "Error:\tUnable to find debugfs\n"
+                          "Hint:\tWas your kernel was compiled with debugfs support?\n"
+                          "Hint:\tIs the debugfs filesystem mounted?\n"
+                          "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");
+                break;
+        case EACCES:
+                scnprintf(buf, size,
+                          "Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"
+                          "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
+                          debugfs_mountpoint, debugfs_mountpoint);
+                break;
+        default:
+                scnprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
+                break;
+        }
+
+        return 0;
+}
+
+int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
+                               int err, char *buf, size_t size)
+{
+        int printed, value;
+        char sbuf[128], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
+
+        switch (err) {
+        case EACCES:
+        case EPERM:
+                printed = scnprintf(buf, size,
+                                    "Error:\t%s.\n"
+                                    "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);
+
+                if (filename__read_int("/proc/sys/kernel/perf_event_paranoid", &value))
+                        break;
+
+                printed += scnprintf(buf + printed, size - printed, "\nHint:\t");
+
+                if (value >= 2) {
+                        printed += scnprintf(buf + printed, size - printed,
+                                             "For your workloads it needs to be <= 1\nHint:\t");
+                }
+                printed += scnprintf(buf + printed, size - printed,
+                                     "For system wide tracing it needs to be set to -1");
+
+                printed += scnprintf(buf + printed, size - printed,
+                                    ".\nHint:\tThe current value is %d.", value);
+                break;
+        default:
+                scnprintf(buf, size, "%s", emsg);
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 722618f84c53..7f8f1aeb9cfe 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -168,6 +168,9 @@ static inline struct perf_evsel *perf_evlist__last(struct perf_evlist *evlist)
 
 size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp);
 
+int perf_evlist__strerror_tp(struct perf_evlist *evlist, int err, char *buf, size_t size);
+int perf_evlist__strerror_open(struct perf_evlist *evlist, int err, char *buf, size_t size);
+
 static inline unsigned int perf_mmap__read_head(struct perf_mmap *mm)
 {
         struct perf_event_mmap_page *pc = mm->base;
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index bfebc1ea3c51..ec0cc1e21c62 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -986,6 +986,7 @@ static size_t perf_event_attr__fprintf(struct perf_event_attr *attr, FILE *fp)
         ret += PRINT_ATTR2(exclude_host, exclude_guest);
         ret += PRINT_ATTR2N("excl.callchain_kern", exclude_callchain_kernel,
                             "excl.callchain_user", exclude_callchain_user);
+        ret += PRINT_ATTR_U32(mmap2);
 
         ret += PRINT_ATTR_U32(wakeup_events);
         ret += PRINT_ATTR_U32(wakeup_watermark);
@@ -1217,6 +1218,7 @@ static int perf_evsel__parse_id_sample(const struct perf_evsel *evsel,
 
                 sample->pid = u.val32[0];
                 sample->tid = u.val32[1];
+                array--;
         }
 
         return 0;
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index c3e5a3b817ab..26d9520a0c1b 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -22,6 +22,7 @@
 #include "vdso.h"
 #include "strbuf.h"
 #include "build-id.h"
+#include "data.h"
 
 static bool no_buildid_cache = false;
 
@@ -2189,7 +2190,7 @@ int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
 {
         struct header_print_data hd;
         struct perf_header *header = &session->header;
-        int fd = session->fd;
+        int fd = perf_data_file__fd(session->file);
         hd.fp = fp;
         hd.full = full;
 
@@ -2650,7 +2651,8 @@ static int perf_header__read_pipe(struct perf_session *session)
         struct perf_header *header = &session->header;
         struct perf_pipe_file_header f_header;
 
-        if (perf_file_header__read_pipe(&f_header, header, session->fd,
+        if (perf_file_header__read_pipe(&f_header, header,
+                                        perf_data_file__fd(session->file),
                                         session->repipe) < 0) {
                 pr_debug("incompatible file format\n");
                 return -EINVAL;
@@ -2751,18 +2753,19 @@ static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
 
 int perf_session__read_header(struct perf_session *session)
 {
+        struct perf_data_file *file = session->file;
         struct perf_header *header = &session->header;
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         u64                     f_id;
         int nr_attrs, nr_ids, i, j;
-        int fd = session->fd;
+        int fd = perf_data_file__fd(file);
 
         session->evlist = perf_evlist__new();
         if (session->evlist == NULL)
                 return -ENOMEM;
 
-        if (session->fd_pipe)
+        if (perf_data_file__is_pipe(file))
                 return perf_header__read_pipe(session);
 
         if (perf_file_header__read(&f_header, header, fd) < 0)
@@ -2777,7 +2780,7 @@ int perf_session__read_header(struct perf_session *session)
         if (f_header.data.size == 0) {
                 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
                            "Was the 'perf record' command properly terminated?\n",
-                           session->filename);
+                           file->path);
         }
 
         nr_attrs = f_header.attrs.size / f_header.attr_size;
@@ -2990,18 +2993,19 @@ int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
                                      struct perf_session *session)
 {
         ssize_t size_read, padding, size = event->tracing_data.size;
-        off_t offset = lseek(session->fd, 0, SEEK_CUR);
+        int fd = perf_data_file__fd(session->file);
+        off_t offset = lseek(fd, 0, SEEK_CUR);
         char buf[BUFSIZ];
 
         /* setup for reading amidst mmap */
-        lseek(session->fd, offset + sizeof(struct tracing_data_event),
+        lseek(fd, offset + sizeof(struct tracing_data_event),
               SEEK_SET);
 
-        size_read = trace_report(session->fd, &session->pevent,
+        size_read = trace_report(fd, &session->pevent,
                                  session->repipe);
         padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
 
-        if (readn(session->fd, buf, padding) < 0) {
+        if (readn(fd, buf, padding) < 0) {
                 pr_err("%s: reading input file", __func__);
                 return -1;
         }
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 6b861aefd99a..ea93425cce95 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -1253,10 +1253,12 @@ static int machine__resolve_callchain_sample(struct machine *machine,
                                              struct thread *thread,
                                              struct ip_callchain *chain,
                                              struct symbol **parent,
-                                             struct addr_location *root_al)
+                                             struct addr_location *root_al,
+                                             int max_stack)
 {
         u8 cpumode = PERF_RECORD_MISC_USER;
-        unsigned int i;
+        int chain_nr = min(max_stack, (int)chain->nr);
+        int i;
         int err;
 
         callchain_cursor_reset(&callchain_cursor);
@@ -1266,7 +1268,7 @@ static int machine__resolve_callchain_sample(struct machine *machine,
                 return 0;
         }
 
-        for (i = 0; i < chain->nr; i++) {
+        for (i = 0; i < chain_nr; i++) {
                 u64 ip;
                 struct addr_location al;
 
@@ -1338,12 +1340,14 @@ int machine__resolve_callchain(struct machine *machine,
                                struct thread *thread,
                                struct perf_sample *sample,
                                struct symbol **parent,
-                               struct addr_location *root_al)
+                               struct addr_location *root_al,
+                               int max_stack)
 {
         int ret;
 
         ret = machine__resolve_callchain_sample(machine, thread,
-                                                sample->callchain, parent, root_al);
+                                                sample->callchain, parent,
+                                                root_al, max_stack);
         if (ret)
                 return ret;
 
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index d44c09bdc45e..4c1f5d567f54 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -92,7 +92,8 @@ int machine__resolve_callchain(struct machine *machine,
                                struct thread *thread,
                                struct perf_sample *sample,
                                struct symbol **parent,
-                               struct addr_location *root_al);
+                               struct addr_location *root_al,
+                               int max_stack);
 
 /*
  * Default guest kernel is defined by parameter --guestkallsyms
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 98125319b158..c90e55cf7e82 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -998,8 +998,10 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (debugfs_valid_mountpoint(tracing_events_path))
+        if (debugfs_valid_mountpoint(tracing_events_path)) {
+                printf("  [ Tracepoints not available: %s ]\n", strerror(errno));
                 return;
+        }
 
         sys_dir = opendir(tracing_events_path);
         if (!sys_dir)
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index a85e4ae5f3ac..c0c9795c4f02 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -282,7 +282,7 @@ static void perl_process_tracepoint(union perf_event *perf_event __maybe_unused,
 
         event = find_cache_event(evsel);
         if (!event)
-                die("ug! no event found for type %" PRIu64, evsel->attr.config);
+                die("ug! no event found for type %" PRIu64, (u64)evsel->attr.config);
 
         pid = raw_field_value(event, "common_pid", data);
 
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index d1e449534b33..854c5aa4db0d 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -16,73 +16,34 @@
 #include "perf_regs.h"
 #include "vdso.h"
 
-static int perf_session__open(struct perf_session *self, bool force)
+static int perf_session__open(struct perf_session *self)
 {
-        struct stat input_stat;
-
-        if (!strcmp(self->filename, "-")) {
-                self->fd_pipe = true;
-                self->fd = STDIN_FILENO;
-
-                if (perf_session__read_header(self) < 0)
-                        pr_err("incompatible file format (rerun with -v to learn more)");
-
-                return 0;
-        }
-
-        self->fd = open(self->filename, O_RDONLY);
-        if (self->fd < 0) {
-                int err = errno;
-
-                pr_err("failed to open %s: %s", self->filename, strerror(err));
-                if (err == ENOENT && !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;
-        }
+        struct perf_data_file *file = self->file;
 
         if (perf_session__read_header(self) < 0) {
                 pr_err("incompatible file format (rerun with -v to learn more)");
-                goto out_close;
+                return -1;
         }
 
+        if (perf_data_file__is_pipe(file))
+                return 0;
+
         if (!perf_evlist__valid_sample_type(self->evlist)) {
                 pr_err("non matching sample_type");
-                goto out_close;
+                return -1;
         }
 
         if (!perf_evlist__valid_sample_id_all(self->evlist)) {
                 pr_err("non matching sample_id_all");
-                goto out_close;
+                return -1;
         }
 
         if (!perf_evlist__valid_read_format(self->evlist)) {
                 pr_err("non matching read_format");
-                goto out_close;
+                return -1;
         }
 
-        self->size = input_stat.st_size;
         return 0;
-
-out_close:
-        close(self->fd);
-        self->fd = -1;
-        return -1;
 }
 
 void perf_session__set_id_hdr_size(struct perf_session *session)
@@ -106,39 +67,36 @@ static void perf_session__destroy_kernel_maps(struct perf_session *self)
         machines__destroy_kernel_maps(&self->machines);
 }
 
-struct perf_session *perf_session__new(const char *filename, int mode,
-                                       bool force, bool repipe,
-                                       struct perf_tool *tool)
+struct perf_session *perf_session__new(struct perf_data_file *file,
+                                       bool repipe, struct perf_tool *tool)
 {
         struct perf_session *self;
-        struct stat st;
-        size_t len;
-
-        if (!filename || !strlen(filename)) {
-                if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
-                        filename = "-";
-                else
-                        filename = "perf.data";
-        }
 
-        len = strlen(filename);
-        self = zalloc(sizeof(*self) + len);
-
-        if (self == NULL)
+        self = zalloc(sizeof(*self));
+        if (!self)
                 goto out;
 
-        memcpy(self->filename, filename, len);
         self->repipe = repipe;
         INIT_LIST_HEAD(&self->ordered_samples.samples);
         INIT_LIST_HEAD(&self->ordered_samples.sample_cache);
         INIT_LIST_HEAD(&self->ordered_samples.to_free);
         machines__init(&self->machines);
 
-        if (mode == O_RDONLY) {
-                if (perf_session__open(self, force) < 0)
+        if (file) {
+                if (perf_data_file__open(file))
                         goto out_delete;
-                perf_session__set_id_hdr_size(self);
-        } else if (mode == O_WRONLY) {
+
+                self->file = file;
+
+                if (perf_data_file__is_read(file)) {
+                        if (perf_session__open(self) < 0)
+                                goto out_close;
+
+                        perf_session__set_id_hdr_size(self);
+                }
+        }
+
+        if (!file || perf_data_file__is_write(file)) {
                 /*
                  * In O_RDONLY mode this will be performed when reading the
                  * kernel MMAP event, in perf_event__process_mmap().
@@ -153,10 +111,13 @@ struct perf_session *perf_session__new(const char *filename, int mode,
                 tool->ordered_samples = false;
         }
 
-out:
         return self;
-out_delete:
+
+ out_close:
+        perf_data_file__close(file);
+ out_delete:
         perf_session__delete(self);
+ out:
         return NULL;
 }
 
@@ -193,7 +154,8 @@ void perf_session__delete(struct perf_session *self)
         perf_session__delete_threads(self);
         perf_session_env__delete(&self->header.env);
         machines__exit(&self->machines);
-        close(self->fd);
+        if (self->file)
+                perf_data_file__close(self->file);
         free(self);
         vdso__exit();
 }
@@ -453,6 +415,9 @@ void perf_event__attr_swap(struct perf_event_attr *attr)
         attr->bp_type           = bswap_32(attr->bp_type);
         attr->bp_addr           = bswap_64(attr->bp_addr);
         attr->bp_len            = bswap_64(attr->bp_len);
+        attr->branch_sample_type = bswap_64(attr->branch_sample_type);
+        attr->sample_regs_user   = bswap_64(attr->sample_regs_user);
+        attr->sample_stack_user  = bswap_32(attr->sample_stack_user);
 
         swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));
 }
@@ -1047,6 +1012,7 @@ static int perf_session_deliver_event(struct perf_session *session,
 static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
                                             struct perf_tool *tool, u64 file_offset)
 {
+        int fd = perf_data_file__fd(session->file);
         int err;
 
         dump_event(session, event, file_offset, NULL);
@@ -1060,7 +1026,7 @@ static int perf_session__process_user_event(struct perf_session *session, union
                 return err;
         case PERF_RECORD_HEADER_TRACING_DATA:
                 /* setup for reading amidst mmap */
-                lseek(session->fd, file_offset, SEEK_SET);
+                lseek(fd, file_offset, SEEK_SET);
                 return tool->tracing_data(tool, event, session);
         case PERF_RECORD_HEADER_BUILD_ID:
                 return tool->build_id(tool, event, session);
@@ -1186,6 +1152,7 @@ volatile int session_done;
 static int __perf_session__process_pipe_events(struct perf_session *self,
                                                struct perf_tool *tool)
 {
+        int fd = perf_data_file__fd(self->file);
         union perf_event *event;
         uint32_t size, cur_size = 0;
         void *buf = NULL;
@@ -1204,7 +1171,7 @@ static int __perf_session__process_pipe_events(struct perf_session *self,
                 return -errno;
 more:
         event = buf;
-        err = readn(self->fd, event, sizeof(struct perf_event_header));
+        err = readn(fd, event, sizeof(struct perf_event_header));
         if (err <= 0) {
                 if (err == 0)
                         goto done;
@@ -1236,7 +1203,7 @@ more:
         p += sizeof(struct perf_event_header);
 
         if (size - sizeof(struct perf_event_header)) {
-                err = readn(self->fd, p, size - sizeof(struct perf_event_header));
+                err = readn(fd, p, size - sizeof(struct perf_event_header));
                 if (err <= 0) {
                         if (err == 0) {
                                 pr_err("unexpected end of event stream\n");
@@ -1263,7 +1230,9 @@ more:
         if (!session_done())
                 goto more;
 done:
-        err = 0;
+        /* do the final flush for ordered samples */
+        self->ordered_samples.next_flush = ULLONG_MAX;
+        err = flush_sample_queue(self, tool);
 out_err:
         free(buf);
         perf_session__warn_about_errors(self, tool);
@@ -1315,6 +1284,7 @@ int __perf_session__process_events(struct perf_session *session,
                                    u64 data_offset, u64 data_size,
                                    u64 file_size, struct perf_tool *tool)
 {
+        int fd = perf_data_file__fd(session->file);
         u64 head, page_offset, file_offset, file_pos, progress_next;
         int err, mmap_prot, mmap_flags, map_idx = 0;
         size_t  mmap_size;
@@ -1347,7 +1317,7 @@ int __perf_session__process_events(struct perf_session *session,
                 mmap_flags = MAP_PRIVATE;
         }
 remap:
-        buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, session->fd,
+        buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
                    file_offset);
         if (buf == MAP_FAILED) {
                 pr_err("failed to mmap file\n");
@@ -1392,13 +1362,13 @@ more:
                                     "Processing events...");
         }
 
-        err = 0;
         if (session_done())
-                goto out_err;
+                goto out;
 
         if (file_pos < file_size)
                 goto more;
 
+out:
         /* do the final flush for ordered samples */
         session->ordered_samples.next_flush = ULLONG_MAX;
         err = flush_sample_queue(session, tool);
@@ -1412,16 +1382,17 @@ out_err:
 int perf_session__process_events(struct perf_session *self,
                                  struct perf_tool *tool)
 {
+        u64 size = perf_data_file__size(self->file);
         int err;
 
         if (perf_session__register_idle_thread(self) == NULL)
                 return -ENOMEM;
 
-        if (!self->fd_pipe)
+        if (!perf_data_file__is_pipe(self->file))
                 err = __perf_session__process_events(self,
                                                      self->header.data_offset,
                                                      self->header.data_size,
-                                                     self->size, tool);
+                                                     size, tool);
         else
                 err = __perf_session__process_pipe_events(self, tool);
 
@@ -1541,7 +1512,8 @@ void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
         if (symbol_conf.use_callchain && sample->callchain) {
 
                 if (machine__resolve_callchain(machine, evsel, al.thread,
-                                               sample, NULL, NULL) != 0) {
+                                               sample, NULL, NULL,
+                                               PERF_MAX_STACK_DEPTH) != 0) {
                         if (verbose)
                                 error("Failed to resolve callchain. Skipping\n");
                         return;
@@ -1645,13 +1617,14 @@ int perf_session__cpu_bitmap(struct perf_session *session,
 void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
                                 bool full)
 {
+        int fd = perf_data_file__fd(session->file);
         struct stat st;
         int ret;
 
         if (session == NULL || fp == NULL)
                 return;
 
-        ret = fstat(session->fd, &st);
+        ret = fstat(fd, &st);
         if (ret == -1)
                 return;
 
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 04bf7373a7e5..27c74d38b868 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -7,6 +7,7 @@
 #include "machine.h"
 #include "symbol.h"
 #include "thread.h"
+#include "data.h"
 #include <linux/rbtree.h>
 #include <linux/perf_event.h>
 
@@ -29,16 +30,13 @@ struct ordered_samples {
 
 struct perf_session {
         struct perf_header      header;
-        unsigned long           size;
         struct machines         machines;
         struct perf_evlist      *evlist;
         struct pevent           *pevent;
         struct events_stats     stats;
-        int                     fd;
-        bool                    fd_pipe;
         bool                    repipe;
         struct ordered_samples  ordered_samples;
-        char                    filename[1];
+        struct perf_data_file   *file;
 };
 
 #define PRINT_IP_OPT_IP         (1<<0)
@@ -49,9 +47,8 @@ struct perf_session {
 
 struct perf_tool;
 
-struct perf_session *perf_session__new(const char *filename, int mode,
-                                       bool force, bool repipe,
-                                       struct perf_tool *tool);
+struct perf_session *perf_session__new(struct perf_data_file *file,
+                                       bool repipe, struct perf_tool *tool);
 void perf_session__delete(struct perf_session *session);
 
 void perf_event_header__bswap(struct perf_event_header *self);
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 32c56377e008..1f9821db9e77 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -182,9 +182,19 @@ static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
 static int64_t
 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 {
+        int64_t ret;
+
         if (!left->ms.sym && !right->ms.sym)
                 return right->level - left->level;
 
+        /*
+         * comparing symbol address alone is not enough since it's a
+         * relative address within a dso.
+         */
+        ret = sort__dso_cmp(left, right);
+        if (ret != 0)
+                return ret;
+
         return _sort__sym_cmp(left->ms.sym, right->ms.sym);
 }
 
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index b554ffc462b6..88cfeaff600b 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -24,6 +24,7 @@ struct perf_top {
         u64                exact_samples;
         u64                guest_us_samples, guest_kernel_samples;
         int                print_entries, count_filter, delay_secs;
+        int                max_stack;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
         bool               use_tui, use_stdio;
         bool               kptr_restrict_warned;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 8dc8cf39f4ed..c25e57b3acb2 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -394,3 +394,20 @@ unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
 
         return (unsigned long) -1;
 }
+
+int filename__read_int(const char *filename, int *value)
+{
+        char line[64];
+        int fd = open(filename, O_RDONLY), err = -1;
+
+        if (fd < 0)
+                return -1;
+
+        if (read(fd, line, sizeof(line)) > 0) {
+                *value = atoi(line);
+                err = 0;
+        }
+
+        close(fd);
+        return err;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 42dfba70fbfc..c8f362daba87 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -305,4 +305,6 @@ struct dso;
 
 char *get_srcline(struct dso *dso, unsigned long addr);
 void free_srcline(char *srcline);
+
+int filename__read_int(const char *filename, int *value);
 #endif /* GIT_COMPAT_UTIL_H */