perf aslr: Strip sample registers

Extend the ASLR tool stripping helpers to drop register dump payloads
by masking out the relevant perf_event_attr fields (sample_regs_user,
sample_regs_intr) when the delegated tool is handling the data.

struct aslr_evsel_priv maintains the original perf_event_attr values
and is looked up via the evsel_orig_attrs hashmap so that sample sizes
can be properly parsed even when bits are stripped from the pipeline.
This is critical for bounded array copying within aslr_tool__process_sample,
which relies on orig_sample_type to determine exactly which fields were
captured by the kernel before any stripping occurred.

This allows us to keep samples that would otherwise be dropped because
they contain registers, while still obfuscating the registers.

Committer notes:

Moved now used variables from the previous patch:

        struct aslr_evsel_priv *priv = NULL;
        u64 orig_sample_type;
        u64 orig_regs_user;
        u64 orig_regs_intr;

Assisted-by: Antigravity:gemini-3.1-pro
Co-developed-by: Gabriel Marin <gmx@google.com>
Signed-off-by: Gabriel Marin <gmx@google.com>
Signed-off-by: Ian Rogers <irogers@google.com>
Tested-by: James Clark <james.clark@linaro.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 8bb37095e2de6172bd600b7859a52f3c8f08e803..6d6cce4765a7f7627f8dbdbc998ba0cb145fe597 100644 (file)
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -248,7 +248,7 @@ static int perf_event__repipe_attr(const struct perf_tool *tool,
                if (!aslr_event)
                        return -ENOMEM;
                memcpy(aslr_event, event, event->header.size);
-               aslr_tool__strip_attr_event(aslr_event, pevlist);
+               aslr_tool__strip_attr_event(aslr_event, *pevlist);
                event = aslr_event;
        }
 
@@ -297,6 +297,7 @@ static int perf_event__repipe_attr(const struct perf_tool *tool,
        attr.size = sizeof(struct perf_event_attr);
        attr.sample_type &= ~PERF_SAMPLE_AUX;
 
+
        if (inject->itrace_synth_opts.add_last_branch) {
                attr.sample_type |= PERF_SAMPLE_BRANCH_STACK;
                attr.branch_sample_type |= PERF_SAMPLE_BRANCH_HW_INDEX;
@@ -2617,6 +2618,10 @@ static int __cmd_inject(struct perf_inject *inject)
                                evsel->core.attr.exclude_callchain_user = 0;
                        }
                }
+
+               if (inject->aslr)
+                       aslr_tool__strip_evlist(inject->session->tool, session->evlist);
+
                session->header.data_offset = output_data_offset;
                session->header.data_size = inject->bytes_written;
                perf_session__inject_header(session, session->evlist, fd, &inj_fc.fc,
@@ -2875,6 +2880,18 @@ int cmd_inject(int argc, const char **argv)
        if (zstd_init(&(inject.session->zstd_data), 0) < 0)
                pr_warning("Decompression initialization failed.\n");
 
+       if (inject.aslr) {
+               struct evsel *evsel;
+
+               evlist__for_each_entry(inject.session->evlist, evsel) {
+                       ret = aslr_tool__cache_orig_attrs(tool, evsel);
+                       if (ret) {
+                               pr_err("Failed to cache original attributes: %d\n", ret);
+                               goto out_delete;
+                       }
+               }
+       }
+
        /* Save original section info before feature bits change */
        ret = save_section_info(&inject);
        if (ret)
@@ -2893,10 +2910,17 @@ int cmd_inject(int argc, const char **argv)
                 * the input.
                 */
                if (!data.is_pipe) {
+                       if (inject.aslr)
+                               aslr_tool__strip_evlist(tool, inject.session->evlist);
+
                        ret = perf_event__synthesize_for_pipe(&inject.tool,
                                                              inject.session,
                                                              &inject.output,
                                                              perf_event__repipe);
+
+                       if (inject.aslr)
+                               aslr_tool__restore_evlist(tool, inject.session->evlist);
+
                        if (ret < 0)
                                goto out_delete;
                }
@@ -2961,8 +2985,6 @@ int cmd_inject(int argc, const char **argv)
                goto out_delete;
 
        ret = __cmd_inject(&inject);
-       if (inject.aslr)
-               aslr_tool__strip_evlist(tool, inject.session->evlist);
 
        guest_session__exit(&inject.guest_session);
 

diff --git a/tools/perf/util/aslr.c b/tools/perf/util/aslr.c
index d0760ca8926da74d60ba334216e82747bc22d8b6..a946fff2ac4dd4b45249f4c5c4d97b17830a60fd 100644 (file)
--- a/tools/perf/util/aslr.c
+++ b/tools/perf/util/aslr.c
@@ -18,6 +18,7 @@
 #include <internal/lib.h>  /* page_size */
 #include <linux/compiler.h>
 #include <linux/zalloc.h>
+#include <errno.h>
 #include <inttypes.h>
 #include <unistd.h>
 #include <byteswap.h>
@@ -46,6 +47,23 @@ struct aslr_mapping {
        u64 remap_start;
 };
 
+struct aslr_evsel_priv {
+       u64 orig_sample_type;
+       u64 orig_sample_regs_user;
+       u64 orig_sample_regs_intr;
+       int orig_sample_size;
+};
+
+static size_t evsel_hash(long key, void *ctx __maybe_unused)
+{
+       return (size_t)key;
+}
+
+static bool evsel_equal(long key1, long key2, void *ctx __maybe_unused)
+{
+       return key1 == key2;
+}
+
 struct process_top_address {
        u64 remapped_max;
 };
@@ -60,6 +78,11 @@ struct aslr_tool {
        struct hashmap remap_addresses;
        /** @top_addresses: mapping from process to max remapped address. */
        struct hashmap top_addresses;
+       /**
+        * @evsel_orig_attrs: mapping from evsel pointer to its original
+        *                    unstripped sample_type and registers bitmasks.
+        */
+       struct hashmap evsel_orig_attrs;
 };
 
 static const pid_t kernel_pid = -1;
@@ -123,6 +146,8 @@ static u64 aslr_tool__remap_address(struct aslr_tool *aslr,
        u64 *remapped_invariant_ptr = NULL;
        u64 remap_addr = 0;
        u8 effective_cpumode = cpumode;
+       struct dso *dso;
+       const char *dso_name;
 
        if (!aslr_thread)
                return 0; /* No thread. */
@@ -148,9 +173,15 @@ static u64 aslr_tool__remap_address(struct aslr_tool *aslr,
                }
        }
 
+       dso = map__dso(al.map);
+       dso_name = dso ? dso__long_name(dso) : NULL;
+
        key.machine = maps__machine(thread__maps(aslr_thread));
-       key.dso = map__dso(al.map);
-       key.invariant = map__start(al.map) - map__pgoff(al.map);
+       key.dso = dso;
+       if (dso && !is_anon_memory(dso_name) && !is_no_dso_memory(dso_name))
+               key.invariant = map__start(al.map) - map__pgoff(al.map);
+       else
+               key.invariant = map__start(al.map);
        key.pid = (effective_cpumode == PERF_RECORD_MISC_KERNEL ||
                   effective_cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ?
                  kernel_pid : thread__pid(aslr_thread);
@@ -676,6 +707,7 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
        struct aslr_tool *aslr;
        struct perf_tool *delegate;
        int ret;
+       int orig_sample_size;
        u64 sample_type;
        struct thread *thread;
        struct machine *aslr_machine;
@@ -688,6 +720,10 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
        u64 addr;
        size_t i;
        size_t j;
+       struct aslr_evsel_priv *priv = NULL;
+       u64 orig_sample_type;
+       u64 orig_regs_user;
+       u64 orig_regs_intr;
 
        del_tool = container_of(tool, struct delegate_tool, tool);
        aslr = container_of(del_tool, struct aslr_tool, tool);
@@ -697,7 +733,24 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                return delegate->sample(delegate, event, sample, machine);
 
        ret = -EFAULT;
-       sample_type = evsel->core.attr.sample_type;
+
+       if (hashmap__find(&aslr->evsel_orig_attrs, evsel, &priv)) {
+               orig_sample_type = priv->orig_sample_type;
+               orig_regs_user = priv->orig_sample_regs_user;
+               orig_regs_intr = priv->orig_sample_regs_intr;
+       } else {
+               orig_sample_type = evsel->core.attr.sample_type;
+               orig_regs_user = evsel->core.attr.sample_regs_user;
+               orig_regs_intr = evsel->core.attr.sample_regs_intr;
+       }
+
+       orig_sample_size = evsel->sample_size;
+
+       sample_type = orig_sample_type;
+       sample_type &= ~PERF_SAMPLE_REGS_USER;
+       sample_type &= ~PERF_SAMPLE_REGS_INTR;
+       sample_type &= ASLR_SUPPORTED_SAMPLE_TYPE;
+
        max_i = (event->header.size - sizeof(struct perf_event_header)) / sizeof(__u64);
        max_j = (PERF_SAMPLE_MAX_SIZE - sizeof(struct perf_event_header)) / sizeof(__u64);
        new_event = (union perf_event *)aslr->event_copy;
@@ -748,11 +801,11 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                i++; \
        } while (0)
 
-       if (sample_type & PERF_SAMPLE_IDENTIFIER)
+       if (orig_sample_type & PERF_SAMPLE_IDENTIFIER)
                COPY_U64(); /* id */
-       if (sample_type & PERF_SAMPLE_IP)
+       if (orig_sample_type & PERF_SAMPLE_IP)
                REMAP_U64(sample->ip);
-       if (sample_type & PERF_SAMPLE_TID) {
+       if (orig_sample_type & PERF_SAMPLE_TID) {
                union {
                        u64 val64;
                        u32 val32[2];
@@ -767,19 +820,19 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                out_array[j++] = u.val64;
                i++;
        }
-       if (sample_type & PERF_SAMPLE_TIME)
+       if (orig_sample_type & PERF_SAMPLE_TIME)
                COPY_U64(); /* time */
-       if (sample_type & PERF_SAMPLE_ADDR)
+       if (orig_sample_type & PERF_SAMPLE_ADDR)
                REMAP_U64(sample->addr);
-       if (sample_type & PERF_SAMPLE_ID)
+       if (orig_sample_type & PERF_SAMPLE_ID)
                COPY_U64(); /* id */
-       if (sample_type & PERF_SAMPLE_STREAM_ID)
+       if (orig_sample_type & PERF_SAMPLE_STREAM_ID)
                COPY_U64(); /* stream_id */
-       if (sample_type & PERF_SAMPLE_CPU)
+       if (orig_sample_type & PERF_SAMPLE_CPU)
                COPY_U64(); /* cpu, res */
-       if (sample_type & PERF_SAMPLE_PERIOD)
+       if (orig_sample_type & PERF_SAMPLE_PERIOD)
                COPY_U64(); /* period */
-       if (sample_type & PERF_SAMPLE_READ) {
+       if (orig_sample_type & PERF_SAMPLE_READ) {
                if ((evsel->core.attr.read_format & PERF_FORMAT_GROUP) == 0) {
                        COPY_U64(); /* value */
                        if (evsel->core.attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
@@ -812,7 +865,7 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                        }
                }
        }
-       if (sample_type & PERF_SAMPLE_CALLCHAIN) {
+       if (orig_sample_type & PERF_SAMPLE_CALLCHAIN) {
                u64 nr;
 
                if (CHECK_BOUNDS(1, 1)) {
@@ -878,7 +931,7 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                        out_array[j++] = addr;
                }
        }
-       if (sample_type & PERF_SAMPLE_RAW) {
+       if (orig_sample_type & PERF_SAMPLE_RAW) {
                size_t bytes = sizeof(u32) + sample->raw_size;
                size_t u64_words = (bytes + 7) / 8;
 
@@ -897,7 +950,7 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                ret = 0;
                goto out_put;
        }
-       if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
+       if (orig_sample_type & PERF_SAMPLE_BRANCH_STACK) {
                u64 nr;
 
                if (CHECK_BOUNDS(1, 1)) {
@@ -938,19 +991,25 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                                COPY_U64();
                }
        }
-       if (sample_type & PERF_SAMPLE_REGS_USER) {
+       if (orig_sample_type & PERF_SAMPLE_REGS_USER) {
+               u64 abi;
+
                if (CHECK_BOUNDS(1, 0)) {
                        ret = -EFAULT;
                        goto out_put;
                }
-               /* abi */
-               COPY_U64();
-               /* TODO: can this be less conservative? */
-               pr_debug("Dropping regs user sample as possible ASLR leak\n");
-               ret = 0;
-               goto out_put;
+               abi = in_array[i++];
+               if (abi != PERF_SAMPLE_REGS_ABI_NONE) {
+                       u64 nr = hweight64(orig_regs_user);
+
+                       if (nr > max_i - i) {
+                               ret = -EFAULT;
+                               goto out_put;
+                       }
+                       i += nr;
+               }
        }
-       if (sample_type & PERF_SAMPLE_STACK_USER) {
+       if (orig_sample_type & PERF_SAMPLE_STACK_USER) {
                u64 size;
 
                if (CHECK_BOUNDS(1, 1)) {
@@ -980,39 +1039,45 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
                ret = 0;
                goto out_put;
        }
-       if (sample_type & PERF_SAMPLE_WEIGHT_TYPE)
+       if (orig_sample_type & PERF_SAMPLE_WEIGHT_TYPE)
                COPY_U64(); /* perf_sample_weight */
-       if (sample_type & PERF_SAMPLE_DATA_SRC)
+       if (orig_sample_type & PERF_SAMPLE_DATA_SRC)
                COPY_U64(); /* data_src */
-       if (sample_type & PERF_SAMPLE_TRANSACTION)
+       if (orig_sample_type & PERF_SAMPLE_TRANSACTION)
                COPY_U64(); /* transaction */
-       if (sample_type & PERF_SAMPLE_REGS_INTR) {
+       if (orig_sample_type & PERF_SAMPLE_REGS_INTR) {
+               u64 abi;
+
                if (CHECK_BOUNDS(1, 0)) {
                        ret = -EFAULT;
                        goto out_put;
                }
-               /* abi */
-               COPY_U64();
-               /* TODO: can this be less conservative? */
-               pr_debug("Dropping interrupt register sample as possible ASLR leak\n");
-               ret = 0;
-               goto out_put;
+               abi = in_array[i++];
+               if (abi != PERF_SAMPLE_REGS_ABI_NONE) {
+                       u64 nr = hweight64(orig_regs_intr);
+
+                       if (nr > max_i - i) {
+                               ret = -EFAULT;
+                               goto out_put;
+                       }
+                       i += nr;
+               }
        }
-       if (sample_type & PERF_SAMPLE_PHYS_ADDR) {
+       if (orig_sample_type & PERF_SAMPLE_PHYS_ADDR) {
                COPY_U64(); /* phys_addr */
                /* TODO: can this be less conservative? */
                pr_debug("Dropping physical address sample as possible ASLR leak\n");
                ret = 0;
                goto out_put;
        }
-       if (sample_type & PERF_SAMPLE_CGROUP)
+       if (orig_sample_type & PERF_SAMPLE_CGROUP)
                COPY_U64(); /* cgroup */
-       if (sample_type & PERF_SAMPLE_DATA_PAGE_SIZE)
+       if (orig_sample_type & PERF_SAMPLE_DATA_PAGE_SIZE)
                COPY_U64(); /* data_page_size */
-       if (sample_type & PERF_SAMPLE_CODE_PAGE_SIZE)
+       if (orig_sample_type & PERF_SAMPLE_CODE_PAGE_SIZE)
                COPY_U64(); /* code_page_size */
 
-       if (sample_type & PERF_SAMPLE_AUX) {
+       if (orig_sample_type & PERF_SAMPLE_AUX) {
                u64 size;
 
                if (CHECK_BOUNDS(1, 1)) {
@@ -1052,11 +1117,20 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
        }
 
        new_event->sample.header.size = sizeof(struct perf_event_header) + j * sizeof(u64);
-
+       /* Temporarily override evsel attributes to match the stripped new_event format! */
+       evsel->sample_size = __evsel__sample_size(sample_type);
+       evsel->core.attr.sample_type = sample_type;
+       evsel->core.attr.sample_regs_user = 0;
+       evsel->core.attr.sample_regs_intr = 0;
        perf_sample__init(&new_sample, /*all=*/ true);
        ret = __evsel__parse_sample(evsel, new_event, &new_sample, /*needs_swap=*/false);
 
        if (ret) {
+               /* Restore original attributes immediately if parsing fails */
+               evsel->sample_size = orig_sample_size;
+               evsel->core.attr.sample_type = orig_sample_type;
+               evsel->core.attr.sample_regs_user = orig_regs_user;
+               evsel->core.attr.sample_regs_intr = orig_regs_intr;
                perf_sample__exit(&new_sample);
                goto out_put;
        }
@@ -1065,6 +1139,12 @@ static int aslr_tool__process_sample(const struct perf_tool *tool,
        ret = delegate->sample(delegate, new_event, &new_sample, machine);
        perf_sample__exit(&new_sample);
 
+       /* Restore original attributes so trace ingestion never desynchronizes! */
+       evsel->sample_size = orig_sample_size;
+       evsel->core.attr.sample_type = orig_sample_type;
+       evsel->core.attr.sample_regs_user = orig_regs_user;
+       evsel->core.attr.sample_regs_intr = orig_regs_intr;
+
 out_put:
        thread__put(thread);
        return ret;
@@ -1118,15 +1198,22 @@ static int aslr_tool__process_auxtrace_error(const struct perf_tool *tool __mayb
        return 0;
 }
 
-
-void aslr_tool__strip_attr_event(union perf_event *event, struct evlist **pevlist __maybe_unused)
+void aslr_tool__strip_attr_event(union perf_event *event, struct evlist *evlist)
 {
        u32 attr_size;
 
+       if (!evlist)
+               return;
+
        attr_size = event->attr.attr.size ?: PERF_ATTR_SIZE_VER0;
 
        if (attr_size >= (offsetof(struct perf_event_attr, sample_type) + sizeof(u64))) {
                event->attr.attr.sample_type &= ASLR_SUPPORTED_SAMPLE_TYPE;
+
+               if (attr_size >= (offsetof(struct perf_event_attr, sample_regs_user) + sizeof(u64)))
+                       event->attr.attr.sample_regs_user = 0;
+               if (attr_size >= (offsetof(struct perf_event_attr, sample_regs_intr) + sizeof(u64)))
+                       event->attr.attr.sample_regs_intr = 0;
        }
 
        if (attr_size >= (offsetof(struct perf_event_attr, type) + sizeof(u32))) {
@@ -1150,28 +1237,6 @@ void aslr_tool__strip_attr_event(union perf_event *event, struct evlist **pevlis
        }
 }
 
-void aslr_tool__strip_evlist(struct perf_tool *tool __maybe_unused,
-                            struct evlist *evlist)
-{
-       struct evsel *evsel;
-
-       evlist__for_each_entry(evlist, evsel) {
-               evsel->core.attr.sample_type &= ASLR_SUPPORTED_SAMPLE_TYPE;
-
-               if (evsel->core.attr.type == PERF_TYPE_BREAKPOINT)
-                       evsel->core.attr.bp_addr = 0;
-               else if (evsel->core.attr.type >= PERF_TYPE_MAX) {
-                       struct perf_pmu *pmu = perf_pmus__find_by_type(evsel->core.attr.type);
-
-                       if (pmu && (!strcmp(pmu->name, "kprobe") ||
-                                   !strcmp(pmu->name, "uprobe"))) {
-                               evsel->core.attr.config1 = 0;
-                               evsel->core.attr.config2 = 0;
-                       }
-               }
-       }
-}
-
 static void aslr_tool__init(struct aslr_tool *aslr, struct perf_tool *delegate)
 {
        delegate_tool__init(&aslr->tool, delegate);
@@ -1185,6 +1250,9 @@ static void aslr_tool__init(struct aslr_tool *aslr, struct perf_tool *delegate)
        hashmap__init(&aslr->top_addresses,
                      top_addresses__hash, top_addresses__equal,
                      /*ctx=*/NULL);
+       hashmap__init(&aslr->evsel_orig_attrs,
+                     evsel_hash, evsel_equal,
+                     /*ctx=*/NULL);
 
        aslr->tool.tool.sample  = aslr_tool__process_sample;
        /* read - reads a counter, okay to delegate. */
@@ -1247,9 +1315,13 @@ void aslr_tool__delete(struct perf_tool *tool)
                zfree(&cur->pkey);
                zfree(&cur->pvalue);
        }
+       hashmap__for_each_entry(&aslr->evsel_orig_attrs, cur, bkt) {
+               zfree(&cur->pvalue);
+       }
 
        hashmap__clear(&aslr->remap_addresses);
        hashmap__clear(&aslr->top_addresses);
+       hashmap__clear(&aslr->evsel_orig_attrs);
        aslr_tool__destroy_machines_priv(&aslr->machines);
        machines__destroy_kernel_maps(&aslr->machines);
 
@@ -1263,3 +1335,69 @@ void aslr_tool__delete(struct perf_tool *tool)
        machines__exit(&aslr->machines);
        free(aslr);
 }
+
+int aslr_tool__cache_orig_attrs(struct perf_tool *tool, struct evsel *evsel)
+{
+       struct delegate_tool *del_tool = container_of(tool, struct delegate_tool, tool);
+       struct aslr_tool *aslr = container_of(del_tool, struct aslr_tool, tool);
+       struct aslr_evsel_priv *priv = zalloc(sizeof(*priv));
+       int err;
+
+       if (!priv)
+               return -ENOMEM;
+
+       priv->orig_sample_type = evsel->core.attr.sample_type;
+       priv->orig_sample_regs_user = evsel->core.attr.sample_regs_user;
+       priv->orig_sample_regs_intr = evsel->core.attr.sample_regs_intr;
+       priv->orig_sample_size = evsel->sample_size;
+
+       err = hashmap__add(&aslr->evsel_orig_attrs, evsel, priv);
+       if (err) {
+               free(priv);
+               return err;
+       }
+       return 0;
+}
+
+void aslr_tool__strip_evlist(const struct perf_tool *tool __maybe_unused, struct evlist *evlist)
+{
+       struct evsel *evsel;
+
+       evlist__for_each_entry(evlist, evsel) {
+               evsel->core.attr.sample_type &= ASLR_SUPPORTED_SAMPLE_TYPE;
+               evsel->core.attr.sample_regs_user = 0;
+               evsel->core.attr.sample_regs_intr = 0;
+               evsel->sample_size = __evsel__sample_size(evsel->core.attr.sample_type);
+               evsel__calc_id_pos(evsel);
+
+               if (evsel->core.attr.type == PERF_TYPE_BREAKPOINT) {
+                       evsel->core.attr.bp_addr = 0;
+               } else if (evsel->core.attr.type >= PERF_TYPE_MAX) {
+                       struct perf_pmu *pmu = perf_pmus__find_by_type(evsel->core.attr.type);
+
+                       if (pmu && (!strcmp(pmu->name, "kprobe") ||
+                                   !strcmp(pmu->name, "uprobe"))) {
+                               evsel->core.attr.config1 = 0;
+                               evsel->core.attr.config2 = 0;
+                       }
+               }
+       }
+}
+
+void aslr_tool__restore_evlist(const struct perf_tool *tool, struct evlist *evlist)
+{
+       const struct delegate_tool *del_tool = container_of(tool, const struct delegate_tool, tool);
+       const struct aslr_tool *aslr = container_of(del_tool, const struct aslr_tool, tool);
+       struct evsel *evsel;
+       struct aslr_evsel_priv *priv;
+
+       evlist__for_each_entry(evlist, evsel) {
+               if (hashmap__find(&aslr->evsel_orig_attrs, evsel, &priv)) {
+                       evsel->core.attr.sample_type = priv->orig_sample_type;
+                       evsel->core.attr.sample_regs_user = priv->orig_sample_regs_user;
+                       evsel->core.attr.sample_regs_intr = priv->orig_sample_regs_intr;
+                       evsel->sample_size = priv->orig_sample_size;
+                       evsel__calc_id_pos(evsel);
+               }
+       }
+}

diff --git a/tools/perf/util/aslr.h b/tools/perf/util/aslr.h
index 2b82f711bc67667671a821f664f126fe87bc462b..522e31c8e2c04d8a24354c2d691610e0a5c30539 100644 (file)
--- a/tools/perf/util/aslr.h
+++ b/tools/perf/util/aslr.h
@@ -34,8 +34,11 @@ struct evlist;
 union perf_event;
 
 struct perf_tool *aslr_tool__new(struct perf_tool *delegate);
-void aslr_tool__delete(struct perf_tool *aslr);
-void aslr_tool__strip_attr_event(union perf_event *event, struct evlist **pevlist);
-void aslr_tool__strip_evlist(struct perf_tool *tool, struct evlist *evlist);
+void aslr_tool__delete(struct perf_tool *tool);
+
+void aslr_tool__strip_attr_event(union perf_event *event, struct evlist *evlist);
+int aslr_tool__cache_orig_attrs(struct perf_tool *tool, struct evsel *evsel);
+void aslr_tool__strip_evlist(const struct perf_tool *tool, struct evlist *evlist);
+void aslr_tool__restore_evlist(const struct perf_tool *tool, struct evlist *evlist);
 
 #endif /* __PERF_ASLR_H */