perf tools: Add Intel BTS support

Intel BTS support fits within the new auxtrace infrastructure.  Recording is
supporting by identifying the Intel BTS PMU, parsing options and setting up
events.

Decoding is supported by queuing up trace data by thread and then decoding
synchronously delivering synthesized event samples into the session processing
for tools to consume.

Committer note:

E.g:

  [root@felicio ~]# perf record --per-thread -e intel_bts// ls
  anaconda-ks.cfg  apctest.output  bin  kernel-rt-3.10.0-298.rt56.171.el7.x86_64.rpm  libexec  lock_page.bpf.c  perf.data  perf.data.old
  [ perf record: Woken up 3 times to write data ]
  [ perf record: Captured and wrote 4.367 MB perf.data ]
  [root@felicio ~]# perf evlist -v
  intel_bts//: type: 6, size: 112, { sample_period, sample_freq }: 1, sample_type: IP|TID|IDENTIFIER, read_format: ID, disabled: 1, enable_on_exec: 1, sample_id_all: 1, exclude_guest: 1
  dummy:u: type: 1, size: 112, config: 0x9, { sample_period, sample_freq }: 1, sample_type: IP|TID|IDENTIFIER, read_format: ID, disabled: 1, exclude_kernel: 1, exclude_hv: 1, mmap: 1, comm: 1, enable_on_exec: 1, task: 1, sample_id_all: 1, mmap2: 1, comm_exec: 1
  [root@felicio ~]# perf script # the navigate in the pager to some interesting place:
    ls 1843 1 branches: ffffffff810a60cb flush_signal_handlers ([kernel.kallsyms]) => ffffffff8121a522 setup_new_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8121a529 setup_new_exec ([kernel.kallsyms]) => ffffffff8122fa30 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa5d do_close_on_exec ([kernel.kallsyms]) => ffffffff81767ae0 _raw_spin_lock ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff81767af4 _raw_spin_lock ([kernel.kallsyms]) => ffffffff8122fa62 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa8e do_close_on_exec ([kernel.kallsyms]) => ffffffff8122faf0 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122faf7 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fa8b do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa8e do_close_on_exec ([kernel.kallsyms]) => ffffffff8122faf0 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122faf7 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fa8b do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa8e do_close_on_exec ([kernel.kallsyms]) => ffffffff8122faf0 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122faf7 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fa8b do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa8e do_close_on_exec ([kernel.kallsyms]) => ffffffff8122faf0 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122faf7 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fa8b do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa8e do_close_on_exec ([kernel.kallsyms]) => ffffffff8122faf0 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122faf7 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fa8b do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fa8e do_close_on_exec ([kernel.kallsyms]) => ffffffff8122faf0 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122faf7 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fa8b do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fac9 do_close_on_exec ([kernel.kallsyms]) => ffffffff8122fad2 do_close_on_exec ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8122fadd do_close_on_exec ([kernel.kallsyms]) => ffffffff8120fc80 filp_close ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8120fcaf filp_close ([kernel.kallsyms]) => ffffffff8120fcb6 filp_close ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8120fcc2 filp_close ([kernel.kallsyms]) => ffffffff812547f0 dnotify_flush ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff81254823 dnotify_flush ([kernel.kallsyms]) => ffffffff8120fcc7 filp_close ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8120fccd filp_close ([kernel.kallsyms]) => ffffffff81261790 locks_remove_posix ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff812617a3 locks_remove_posix ([kernel.kallsyms]) => ffffffff812617b9 locks_remove_posix ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff812617b9 locks_remove_posix ([kernel.kallsyms]) => ffffffff8120fcd2 filp_close ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8120fcd5 filp_close ([kernel.kallsyms]) => ffffffff812142c0 fput ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff812142d6 fput ([kernel.kallsyms]) => ffffffff812142df fput ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff8121430c fput ([kernel.kallsyms]) => ffffffff810b6580 task_work_add ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff810b65ad task_work_add ([kernel.kallsyms]) => ffffffff810b65b1 task_work_add ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff810b65c1 task_work_add ([kernel.kallsyms]) => ffffffff810bc710 kick_process ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff810bc725 kick_process ([kernel.kallsyms]) => ffffffff810bc742 kick_process ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff810bc742 kick_process ([kernel.kallsyms]) => ffffffff810b65c6 task_work_add ([kernel.kallsyms])
    ls 1843 1 branches: ffffffff810b65c9 task_work_add ([kernel.kallsyms]) => ffffffff81214311 fput ([kernel.kallsyms])

Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Link: http://lkml.kernel.org/r/1437150840-31811-9-git-send-email-adrian.hunter@intel.com
[ Merged sample->time fix for bug found after first round of testing on slightly older kernel ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

4 files changed, 509 insertions, 2 deletions

diff --git a/tools/perf/arch/x86/util/Build b/tools/perf/arch/x86/util/Build
index a8be9f9d0462..2c55e1b336c5 100644
--- a/tools/perf/arch/x86/util/Build
+++ b/tools/perf/arch/x86/util/Build
@@ -10,3 +10,4 @@ libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
 
 libperf-$(CONFIG_AUXTRACE) += auxtrace.o
 libperf-$(CONFIG_AUXTRACE) += intel-pt.o
+libperf-$(CONFIG_AUXTRACE) += intel-bts.o
diff --git a/tools/perf/arch/x86/util/auxtrace.c b/tools/perf/arch/x86/util/auxtrace.c
index e7654b506312..7a7805583e3f 100644
--- a/tools/perf/arch/x86/util/auxtrace.c
+++ b/tools/perf/arch/x86/util/auxtrace.c
@@ -13,11 +13,56 @@
  *
  */
 
+#include <stdbool.h>
+
 #include "../../util/header.h"
+#include "../../util/debug.h"
+#include "../../util/pmu.h"
 #include "../../util/auxtrace.h"
 #include "../../util/intel-pt.h"
+#include "../../util/intel-bts.h"
+#include "../../util/evlist.h"
+
+static
+struct auxtrace_record *auxtrace_record__init_intel(struct perf_evlist *evlist,
+                                                    int *err)
+{
+        struct perf_pmu *intel_pt_pmu;
+        struct perf_pmu *intel_bts_pmu;
+        struct perf_evsel *evsel;
+        bool found_pt = false;
+        bool found_bts = false;
+
+        intel_pt_pmu = perf_pmu__find(INTEL_PT_PMU_NAME);
+        intel_bts_pmu = perf_pmu__find(INTEL_BTS_PMU_NAME);
+
+        if (evlist) {
+                evlist__for_each(evlist, evsel) {
+                        if (intel_pt_pmu &&
+                            evsel->attr.type == intel_pt_pmu->type)
+                                found_pt = true;
+                        if (intel_bts_pmu &&
+                            evsel->attr.type == intel_bts_pmu->type)
+                                found_bts = true;
+                }
+        }
+
+        if (found_pt && found_bts) {
+                pr_err("intel_pt and intel_bts may not be used together\n");
+                *err = -EINVAL;
+                return NULL;
+        }
+
+        if (found_pt)
+                return intel_pt_recording_init(err);
+
+        if (found_bts)
+                return intel_bts_recording_init(err);
 
-struct auxtrace_record *auxtrace_record__init(struct perf_evlist *evlist __maybe_unused,
+        return NULL;
+}
+
+struct auxtrace_record *auxtrace_record__init(struct perf_evlist *evlist,
                                               int *err)
 {
         char buffer[64];
@@ -32,7 +77,7 @@ struct auxtrace_record *auxtrace_record__init(struct perf_evlist *evlist __maybe
         }
 
         if (!strncmp(buffer, "GenuineIntel,", 13))
-                return intel_pt_recording_init(err);
+                return auxtrace_record__init_intel(evlist, err);
 
         return NULL;
 }
diff --git a/tools/perf/arch/x86/util/intel-bts.c b/tools/perf/arch/x86/util/intel-bts.c
new file mode 100644
index 000000000000..9b94ce520917
--- /dev/null
+++ b/tools/perf/arch/x86/util/intel-bts.c
@@ -0,0 +1,458 @@
+/*
+ * intel-bts.c: Intel Processor Trace support
+ * Copyright (c) 2013-2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/bitops.h>
+#include <linux/log2.h>
+
+#include "../../util/cpumap.h"
+#include "../../util/evsel.h"
+#include "../../util/evlist.h"
+#include "../../util/session.h"
+#include "../../util/util.h"
+#include "../../util/pmu.h"
+#include "../../util/debug.h"
+#include "../../util/tsc.h"
+#include "../../util/auxtrace.h"
+#include "../../util/intel-bts.h"
+
+#define KiB(x) ((x) * 1024)
+#define MiB(x) ((x) * 1024 * 1024)
+#define KiB_MASK(x) (KiB(x) - 1)
+#define MiB_MASK(x) (MiB(x) - 1)
+
+#define INTEL_BTS_DFLT_SAMPLE_SIZE      KiB(4)
+
+#define INTEL_BTS_MAX_SAMPLE_SIZE       KiB(60)
+
+struct intel_bts_snapshot_ref {
+        void    *ref_buf;
+        size_t  ref_offset;
+        bool    wrapped;
+};
+
+struct intel_bts_recording {
+        struct auxtrace_record          itr;
+        struct perf_pmu                 *intel_bts_pmu;
+        struct perf_evlist              *evlist;
+        bool                            snapshot_mode;
+        size_t                          snapshot_size;
+        int                             snapshot_ref_cnt;
+        struct intel_bts_snapshot_ref   *snapshot_refs;
+};
+
+struct branch {
+        u64 from;
+        u64 to;
+        u64 misc;
+};
+
+static size_t intel_bts_info_priv_size(struct auxtrace_record *itr __maybe_unused)
+{
+        return INTEL_BTS_AUXTRACE_PRIV_SIZE;
+}
+
+static int intel_bts_info_fill(struct auxtrace_record *itr,
+                               struct perf_session *session,
+                               struct auxtrace_info_event *auxtrace_info,
+                               size_t priv_size)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        struct perf_pmu *intel_bts_pmu = btsr->intel_bts_pmu;
+        struct perf_event_mmap_page *pc;
+        struct perf_tsc_conversion tc = { .time_mult = 0, };
+        bool cap_user_time_zero = false;
+        int err;
+
+        if (priv_size != INTEL_BTS_AUXTRACE_PRIV_SIZE)
+                return -EINVAL;
+
+        if (!session->evlist->nr_mmaps)
+                return -EINVAL;
+
+        pc = session->evlist->mmap[0].base;
+        if (pc) {
+                err = perf_read_tsc_conversion(pc, &tc);
+                if (err) {
+                        if (err != -EOPNOTSUPP)
+                                return err;
+                } else {
+                        cap_user_time_zero = tc.time_mult != 0;
+                }
+                if (!cap_user_time_zero)
+                        ui__warning("Intel BTS: TSC not available\n");
+        }
+
+        auxtrace_info->type = PERF_AUXTRACE_INTEL_BTS;
+        auxtrace_info->priv[INTEL_BTS_PMU_TYPE] = intel_bts_pmu->type;
+        auxtrace_info->priv[INTEL_BTS_TIME_SHIFT] = tc.time_shift;
+        auxtrace_info->priv[INTEL_BTS_TIME_MULT] = tc.time_mult;
+        auxtrace_info->priv[INTEL_BTS_TIME_ZERO] = tc.time_zero;
+        auxtrace_info->priv[INTEL_BTS_CAP_USER_TIME_ZERO] = cap_user_time_zero;
+        auxtrace_info->priv[INTEL_BTS_SNAPSHOT_MODE] = btsr->snapshot_mode;
+
+        return 0;
+}
+
+static int intel_bts_recording_options(struct auxtrace_record *itr,
+                                       struct perf_evlist *evlist,
+                                       struct record_opts *opts)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        struct perf_pmu *intel_bts_pmu = btsr->intel_bts_pmu;
+        struct perf_evsel *evsel, *intel_bts_evsel = NULL;
+        const struct cpu_map *cpus = evlist->cpus;
+        bool privileged = geteuid() == 0 || perf_event_paranoid() < 0;
+
+        btsr->evlist = evlist;
+        btsr->snapshot_mode = opts->auxtrace_snapshot_mode;
+
+        evlist__for_each(evlist, evsel) {
+                if (evsel->attr.type == intel_bts_pmu->type) {
+                        if (intel_bts_evsel) {
+                                pr_err("There may be only one " INTEL_BTS_PMU_NAME " event\n");
+                                return -EINVAL;
+                        }
+                        evsel->attr.freq = 0;
+                        evsel->attr.sample_period = 1;
+                        intel_bts_evsel = evsel;
+                        opts->full_auxtrace = true;
+                }
+        }
+
+        if (opts->auxtrace_snapshot_mode && !opts->full_auxtrace) {
+                pr_err("Snapshot mode (-S option) requires " INTEL_BTS_PMU_NAME " PMU event (-e " INTEL_BTS_PMU_NAME ")\n");
+                return -EINVAL;
+        }
+
+        if (!opts->full_auxtrace)
+                return 0;
+
+        if (opts->full_auxtrace && !cpu_map__empty(cpus)) {
+                pr_err(INTEL_BTS_PMU_NAME " does not support per-cpu recording\n");
+                return -EINVAL;
+        }
+
+        /* Set default sizes for snapshot mode */
+        if (opts->auxtrace_snapshot_mode) {
+                if (!opts->auxtrace_snapshot_size && !opts->auxtrace_mmap_pages) {
+                        if (privileged) {
+                                opts->auxtrace_mmap_pages = MiB(4) / page_size;
+                        } else {
+                                opts->auxtrace_mmap_pages = KiB(128) / page_size;
+                                if (opts->mmap_pages == UINT_MAX)
+                                        opts->mmap_pages = KiB(256) / page_size;
+                        }
+                } else if (!opts->auxtrace_mmap_pages && !privileged &&
+                           opts->mmap_pages == UINT_MAX) {
+                        opts->mmap_pages = KiB(256) / page_size;
+                }
+                if (!opts->auxtrace_snapshot_size)
+                        opts->auxtrace_snapshot_size =
+                                opts->auxtrace_mmap_pages * (size_t)page_size;
+                if (!opts->auxtrace_mmap_pages) {
+                        size_t sz = opts->auxtrace_snapshot_size;
+
+                        sz = round_up(sz, page_size) / page_size;
+                        opts->auxtrace_mmap_pages = roundup_pow_of_two(sz);
+                }
+                if (opts->auxtrace_snapshot_size >
+                                opts->auxtrace_mmap_pages * (size_t)page_size) {
+                        pr_err("Snapshot size %zu must not be greater than AUX area tracing mmap size %zu\n",
+                               opts->auxtrace_snapshot_size,
+                               opts->auxtrace_mmap_pages * (size_t)page_size);
+                        return -EINVAL;
+                }
+                if (!opts->auxtrace_snapshot_size || !opts->auxtrace_mmap_pages) {
+                        pr_err("Failed to calculate default snapshot size and/or AUX area tracing mmap pages\n");
+                        return -EINVAL;
+                }
+                pr_debug2("Intel BTS snapshot size: %zu\n",
+                          opts->auxtrace_snapshot_size);
+        }
+
+        /* Set default sizes for full trace mode */
+        if (opts->full_auxtrace && !opts->auxtrace_mmap_pages) {
+                if (privileged) {
+                        opts->auxtrace_mmap_pages = MiB(4) / page_size;
+                } else {
+                        opts->auxtrace_mmap_pages = KiB(128) / page_size;
+                        if (opts->mmap_pages == UINT_MAX)
+                                opts->mmap_pages = KiB(256) / page_size;
+                }
+        }
+
+        /* Validate auxtrace_mmap_pages */
+        if (opts->auxtrace_mmap_pages) {
+                size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;
+                size_t min_sz;
+
+                if (opts->auxtrace_snapshot_mode)
+                        min_sz = KiB(4);
+                else
+                        min_sz = KiB(8);
+
+                if (sz < min_sz || !is_power_of_2(sz)) {
+                        pr_err("Invalid mmap size for Intel BTS: must be at least %zuKiB and a power of 2\n",
+                               min_sz / 1024);
+                        return -EINVAL;
+                }
+        }
+
+        if (intel_bts_evsel) {
+                /*
+                 * To obtain the auxtrace buffer file descriptor, the auxtrace event
+                 * must come first.
+                 */
+                perf_evlist__to_front(evlist, intel_bts_evsel);
+                /*
+                 * In the case of per-cpu mmaps, we need the CPU on the
+                 * AUX event.
+                 */
+                if (!cpu_map__empty(cpus))
+                        perf_evsel__set_sample_bit(intel_bts_evsel, CPU);
+        }
+
+        /* Add dummy event to keep tracking */
+        if (opts->full_auxtrace) {
+                struct perf_evsel *tracking_evsel;
+                int err;
+
+                err = parse_events(evlist, "dummy:u", NULL);
+                if (err)
+                        return err;
+
+                tracking_evsel = perf_evlist__last(evlist);
+
+                perf_evlist__set_tracking_event(evlist, tracking_evsel);
+
+                tracking_evsel->attr.freq = 0;
+                tracking_evsel->attr.sample_period = 1;
+        }
+
+        return 0;
+}
+
+static int intel_bts_parse_snapshot_options(struct auxtrace_record *itr,
+                                            struct record_opts *opts,
+                                            const char *str)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        unsigned long long snapshot_size = 0;
+        char *endptr;
+
+        if (str) {
+                snapshot_size = strtoull(str, &endptr, 0);
+                if (*endptr || snapshot_size > SIZE_MAX)
+                        return -1;
+        }
+
+        opts->auxtrace_snapshot_mode = true;
+        opts->auxtrace_snapshot_size = snapshot_size;
+
+        btsr->snapshot_size = snapshot_size;
+
+        return 0;
+}
+
+static u64 intel_bts_reference(struct auxtrace_record *itr __maybe_unused)
+{
+        return rdtsc();
+}
+
+static int intel_bts_alloc_snapshot_refs(struct intel_bts_recording *btsr,
+                                         int idx)
+{
+        const size_t sz = sizeof(struct intel_bts_snapshot_ref);
+        int cnt = btsr->snapshot_ref_cnt, new_cnt = cnt * 2;
+        struct intel_bts_snapshot_ref *refs;
+
+        if (!new_cnt)
+                new_cnt = 16;
+
+        while (new_cnt <= idx)
+                new_cnt *= 2;
+
+        refs = calloc(new_cnt, sz);
+        if (!refs)
+                return -ENOMEM;
+
+        memcpy(refs, btsr->snapshot_refs, cnt * sz);
+
+        btsr->snapshot_refs = refs;
+        btsr->snapshot_ref_cnt = new_cnt;
+
+        return 0;
+}
+
+static void intel_bts_free_snapshot_refs(struct intel_bts_recording *btsr)
+{
+        int i;
+
+        for (i = 0; i < btsr->snapshot_ref_cnt; i++)
+                zfree(&btsr->snapshot_refs[i].ref_buf);
+        zfree(&btsr->snapshot_refs);
+}
+
+static void intel_bts_recording_free(struct auxtrace_record *itr)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+
+        intel_bts_free_snapshot_refs(btsr);
+        free(btsr);
+}
+
+static int intel_bts_snapshot_start(struct auxtrace_record *itr)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        struct perf_evsel *evsel;
+
+        evlist__for_each(btsr->evlist, evsel) {
+                if (evsel->attr.type == btsr->intel_bts_pmu->type)
+                        return perf_evlist__disable_event(btsr->evlist, evsel);
+        }
+        return -EINVAL;
+}
+
+static int intel_bts_snapshot_finish(struct auxtrace_record *itr)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        struct perf_evsel *evsel;
+
+        evlist__for_each(btsr->evlist, evsel) {
+                if (evsel->attr.type == btsr->intel_bts_pmu->type)
+                        return perf_evlist__enable_event(btsr->evlist, evsel);
+        }
+        return -EINVAL;
+}
+
+static bool intel_bts_first_wrap(u64 *data, size_t buf_size)
+{
+        int i, a, b;
+
+        b = buf_size >> 3;
+        a = b - 512;
+        if (a < 0)
+                a = 0;
+
+        for (i = a; i < b; i++) {
+                if (data[i])
+                        return true;
+        }
+
+        return false;
+}
+
+static int intel_bts_find_snapshot(struct auxtrace_record *itr, int idx,
+                                   struct auxtrace_mmap *mm, unsigned char *data,
+                                   u64 *head, u64 *old)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        bool wrapped;
+        int err;
+
+        pr_debug3("%s: mmap index %d old head %zu new head %zu\n",
+                  __func__, idx, (size_t)*old, (size_t)*head);
+
+        if (idx >= btsr->snapshot_ref_cnt) {
+                err = intel_bts_alloc_snapshot_refs(btsr, idx);
+                if (err)
+                        goto out_err;
+        }
+
+        wrapped = btsr->snapshot_refs[idx].wrapped;
+        if (!wrapped && intel_bts_first_wrap((u64 *)data, mm->len)) {
+                btsr->snapshot_refs[idx].wrapped = true;
+                wrapped = true;
+        }
+
+        /*
+         * In full trace mode 'head' continually increases.  However in snapshot
+         * mode 'head' is an offset within the buffer.  Here 'old' and 'head'
+         * are adjusted to match the full trace case which expects that 'old' is
+         * always less than 'head'.
+         */
+        if (wrapped) {
+                *old = *head;
+                *head += mm->len;
+        } else {
+                if (mm->mask)
+                        *old &= mm->mask;
+                else
+                        *old %= mm->len;
+                if (*old > *head)
+                        *head += mm->len;
+        }
+
+        pr_debug3("%s: wrap-around %sdetected, adjusted old head %zu adjusted new head %zu\n",
+                  __func__, wrapped ? "" : "not ", (size_t)*old, (size_t)*head);
+
+        return 0;
+
+out_err:
+        pr_err("%s: failed, error %d\n", __func__, err);
+        return err;
+}
+
+static int intel_bts_read_finish(struct auxtrace_record *itr, int idx)
+{
+        struct intel_bts_recording *btsr =
+                        container_of(itr, struct intel_bts_recording, itr);
+        struct perf_evsel *evsel;
+
+        evlist__for_each(btsr->evlist, evsel) {
+                if (evsel->attr.type == btsr->intel_bts_pmu->type)
+                        return perf_evlist__enable_event_idx(btsr->evlist,
+                                                             evsel, idx);
+        }
+        return -EINVAL;
+}
+
+struct auxtrace_record *intel_bts_recording_init(int *err)
+{
+        struct perf_pmu *intel_bts_pmu = perf_pmu__find(INTEL_BTS_PMU_NAME);
+        struct intel_bts_recording *btsr;
+
+        if (!intel_bts_pmu)
+                return NULL;
+
+        btsr = zalloc(sizeof(struct intel_bts_recording));
+        if (!btsr) {
+                *err = -ENOMEM;
+                return NULL;
+        }
+
+        btsr->intel_bts_pmu = intel_bts_pmu;
+        btsr->itr.recording_options = intel_bts_recording_options;
+        btsr->itr.info_priv_size = intel_bts_info_priv_size;
+        btsr->itr.info_fill = intel_bts_info_fill;
+        btsr->itr.free = intel_bts_recording_free;
+        btsr->itr.snapshot_start = intel_bts_snapshot_start;
+        btsr->itr.snapshot_finish = intel_bts_snapshot_finish;
+        btsr->itr.find_snapshot = intel_bts_find_snapshot;
+        btsr->itr.parse_snapshot_options = intel_bts_parse_snapshot_options;
+        btsr->itr.reference = intel_bts_reference;
+        btsr->itr.read_finish = intel_bts_read_finish;
+        btsr->itr.alignment = sizeof(struct branch);
+        return &btsr->itr;
+}
diff --git a/tools/perf/arch/x86/util/pmu.c b/tools/perf/arch/x86/util/pmu.c
index fd11cc3ce780..79fe07158d00 100644
--- a/tools/perf/arch/x86/util/pmu.c
+++ b/tools/perf/arch/x86/util/pmu.c
@@ -3,6 +3,7 @@
 #include <linux/perf_event.h>
 
 #include "../../util/intel-pt.h"
+#include "../../util/intel-bts.h"
 #include "../../util/pmu.h"
 
 struct perf_event_attr *perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
@@ -10,6 +11,8 @@ struct perf_event_attr *perf_pmu__get_default_config(struct perf_pmu *pmu __mayb
 #ifdef HAVE_AUXTRACE_SUPPORT
         if (!strcmp(pmu->name, INTEL_PT_PMU_NAME))
                 return intel_pt_pmu_default_config(pmu);
+        if (!strcmp(pmu->name, INTEL_BTS_PMU_NAME))
+                pmu->selectable = true;
 #endif
         return NULL;
 }