7 files changed, 310 insertions, 4 deletions

diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index c5f6515f0723..6d4bbde066fd 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -122,6 +122,18 @@ static s64 perf_event__repipe_auxtrace(struct perf_tool *tool,
                                                   tool);
         int ret;
 
+        if (!inject->output.is_pipe) {
+                off_t offset;
+
+                offset = lseek(inject->output.fd, 0, SEEK_CUR);
+                if (offset == -1)
+                        return -errno;
+                ret = auxtrace_index__auxtrace_event(&session->auxtrace_index,
+                                                     event, offset);
+                if (ret < 0)
+                        return ret;
+        }
+
         if (perf_data_file__is_pipe(session->file) || !session->one_mmap) {
                 ret = output_bytes(inject, event, event->header.size);
                 if (ret < 0)
@@ -487,6 +499,9 @@ static int __cmd_inject(struct perf_inject *inject)
                 output_data_offset = 4096;
         }
 
+        if (!inject->itrace_synth_opts.set)
+                auxtrace_index__free(&session->auxtrace_index);
+
         if (!file_out->is_pipe)
                 lseek(fd, output_data_offset, SEEK_SET);
 
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 4c9aaa1f688a..c8c784c430b6 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -117,9 +117,24 @@ static int record__process_auxtrace(struct perf_tool *tool,
                                     size_t len1, void *data2, size_t len2)
 {
         struct record *rec = container_of(tool, struct record, tool);
+        struct perf_data_file *file = &rec->file;
         size_t padding;
         u8 pad[8] = {0};
 
+        if (!perf_data_file__is_pipe(file)) {
+                off_t file_offset;
+                int fd = perf_data_file__fd(file);
+                int err;
+
+                file_offset = lseek(fd, 0, SEEK_CUR);
+                if (file_offset == -1)
+                        return -1;
+                err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
+                                                     event, file_offset);
+                if (err)
+                        return err;
+        }
+
         /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
         padding = (len1 + len2) & 7;
         if (padding)
diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
index 3cd89eca1e88..28ce134a61ad 100644
--- a/tools/perf/util/auxtrace.c
+++ b/tools/perf/util/auxtrace.c
@@ -344,6 +344,33 @@ out_err:
         return err;
 }
 
+static int auxtrace_queues__add_indexed_event(struct auxtrace_queues *queues,
+                                              struct perf_session *session,
+                                              off_t file_offset, size_t sz)
+{
+        union perf_event *event;
+        int err;
+        char buf[PERF_SAMPLE_MAX_SIZE];
+
+        err = perf_session__peek_event(session, file_offset, buf,
+                                       PERF_SAMPLE_MAX_SIZE, &event, NULL);
+        if (err)
+                return err;
+
+        if (event->header.type == PERF_RECORD_AUXTRACE) {
+                if (event->header.size < sizeof(struct auxtrace_event) ||
+                    event->header.size != sz) {
+                        err = -EINVAL;
+                        goto out;
+                }
+                file_offset += event->header.size;
+                err = auxtrace_queues__add_event(queues, session, event,
+                                                 file_offset, NULL);
+        }
+out:
+        return err;
+}
+
 void auxtrace_queues__free(struct auxtrace_queues *queues)
 {
         unsigned int i;
@@ -500,6 +527,194 @@ auxtrace_record__init(struct perf_evlist *evlist __maybe_unused, int *err)
         return NULL;
 }
 
+static int auxtrace_index__alloc(struct list_head *head)
+{
+        struct auxtrace_index *auxtrace_index;
+
+        auxtrace_index = malloc(sizeof(struct auxtrace_index));
+        if (!auxtrace_index)
+                return -ENOMEM;
+
+        auxtrace_index->nr = 0;
+        INIT_LIST_HEAD(&auxtrace_index->list);
+
+        list_add_tail(&auxtrace_index->list, head);
+
+        return 0;
+}
+
+void auxtrace_index__free(struct list_head *head)
+{
+        struct auxtrace_index *auxtrace_index, *n;
+
+        list_for_each_entry_safe(auxtrace_index, n, head, list) {
+                list_del(&auxtrace_index->list);
+                free(auxtrace_index);
+        }
+}
+
+static struct auxtrace_index *auxtrace_index__last(struct list_head *head)
+{
+        struct auxtrace_index *auxtrace_index;
+        int err;
+
+        if (list_empty(head)) {
+                err = auxtrace_index__alloc(head);
+                if (err)
+                        return NULL;
+        }
+
+        auxtrace_index = list_entry(head->prev, struct auxtrace_index, list);
+
+        if (auxtrace_index->nr >= PERF_AUXTRACE_INDEX_ENTRY_COUNT) {
+                err = auxtrace_index__alloc(head);
+                if (err)
+                        return NULL;
+                auxtrace_index = list_entry(head->prev, struct auxtrace_index,
+                                            list);
+        }
+
+        return auxtrace_index;
+}
+
+int auxtrace_index__auxtrace_event(struct list_head *head,
+                                   union perf_event *event, off_t file_offset)
+{
+        struct auxtrace_index *auxtrace_index;
+        size_t nr;
+
+        auxtrace_index = auxtrace_index__last(head);
+        if (!auxtrace_index)
+                return -ENOMEM;
+
+        nr = auxtrace_index->nr;
+        auxtrace_index->entries[nr].file_offset = file_offset;
+        auxtrace_index->entries[nr].sz = event->header.size;
+        auxtrace_index->nr += 1;
+
+        return 0;
+}
+
+static int auxtrace_index__do_write(int fd,
+                                    struct auxtrace_index *auxtrace_index)
+{
+        struct auxtrace_index_entry ent;
+        size_t i;
+
+        for (i = 0; i < auxtrace_index->nr; i++) {
+                ent.file_offset = auxtrace_index->entries[i].file_offset;
+                ent.sz = auxtrace_index->entries[i].sz;
+                if (writen(fd, &ent, sizeof(ent)) != sizeof(ent))
+                        return -errno;
+        }
+        return 0;
+}
+
+int auxtrace_index__write(int fd, struct list_head *head)
+{
+        struct auxtrace_index *auxtrace_index;
+        u64 total = 0;
+        int err;
+
+        list_for_each_entry(auxtrace_index, head, list)
+                total += auxtrace_index->nr;
+
+        if (writen(fd, &total, sizeof(total)) != sizeof(total))
+                return -errno;
+
+        list_for_each_entry(auxtrace_index, head, list) {
+                err = auxtrace_index__do_write(fd, auxtrace_index);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int auxtrace_index__process_entry(int fd, struct list_head *head,
+                                         bool needs_swap)
+{
+        struct auxtrace_index *auxtrace_index;
+        struct auxtrace_index_entry ent;
+        size_t nr;
+
+        if (readn(fd, &ent, sizeof(ent)) != sizeof(ent))
+                return -1;
+
+        auxtrace_index = auxtrace_index__last(head);
+        if (!auxtrace_index)
+                return -1;
+
+        nr = auxtrace_index->nr;
+        if (needs_swap) {
+                auxtrace_index->entries[nr].file_offset =
+                                                bswap_64(ent.file_offset);
+                auxtrace_index->entries[nr].sz = bswap_64(ent.sz);
+        } else {
+                auxtrace_index->entries[nr].file_offset = ent.file_offset;
+                auxtrace_index->entries[nr].sz = ent.sz;
+        }
+
+        auxtrace_index->nr = nr + 1;
+
+        return 0;
+}
+
+int auxtrace_index__process(int fd, u64 size, struct perf_session *session,
+                            bool needs_swap)
+{
+        struct list_head *head = &session->auxtrace_index;
+        u64 nr;
+
+        if (readn(fd, &nr, sizeof(u64)) != sizeof(u64))
+                return -1;
+
+        if (needs_swap)
+                nr = bswap_64(nr);
+
+        if (sizeof(u64) + nr * sizeof(struct auxtrace_index_entry) > size)
+                return -1;
+
+        while (nr--) {
+                int err;
+
+                err = auxtrace_index__process_entry(fd, head, needs_swap);
+                if (err)
+                        return -1;
+        }
+
+        return 0;
+}
+
+static int auxtrace_queues__process_index_entry(struct auxtrace_queues *queues,
+                                                struct perf_session *session,
+                                                struct auxtrace_index_entry *ent)
+{
+        return auxtrace_queues__add_indexed_event(queues, session,
+                                                  ent->file_offset, ent->sz);
+}
+
+int auxtrace_queues__process_index(struct auxtrace_queues *queues,
+                                   struct perf_session *session)
+{
+        struct auxtrace_index *auxtrace_index;
+        struct auxtrace_index_entry *ent;
+        size_t i;
+        int err;
+
+        list_for_each_entry(auxtrace_index, &session->auxtrace_index, list) {
+                for (i = 0; i < auxtrace_index->nr; i++) {
+                        ent = &auxtrace_index->entries[i];
+                        err = auxtrace_queues__process_index_entry(queues,
+                                                                   session,
+                                                                   ent);
+                        if (err)
+                                return err;
+                }
+        }
+        return 0;
+}
+
 struct auxtrace_buffer *auxtrace_buffer__next(struct auxtrace_queue *queue,
                                               struct auxtrace_buffer *buffer)
 {
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 53b60a64a693..b9e4b9d66f5e 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -80,6 +80,32 @@ struct itrace_synth_opts {
 };
 
 /**
+ * struct auxtrace_index_entry - indexes a AUX area tracing event within a
+ *                               perf.data file.
+ * @file_offset: offset within the perf.data file
+ * @sz: size of the event
+ */
+struct auxtrace_index_entry {
+        u64                     file_offset;
+        u64                     sz;
+};
+
+#define PERF_AUXTRACE_INDEX_ENTRY_COUNT 256
+
+/**
+ * struct auxtrace_index - index of AUX area tracing events within a perf.data
+ *                         file.
+ * @list: linking a number of arrays of entries
+ * @nr: number of entries
+ * @entries: array of entries
+ */
+struct auxtrace_index {
+        struct list_head        list;
+        size_t                  nr;
+        struct auxtrace_index_entry entries[PERF_AUXTRACE_INDEX_ENTRY_COUNT];
+};
+
+/**
  * struct auxtrace - session callbacks to allow AUX area data decoding.
  * @process_event: lets the decoder see all session events
  * @flush_events: process any remaining data
@@ -321,6 +347,8 @@ int auxtrace_queues__add_event(struct auxtrace_queues *queues,
                                union perf_event *event, off_t data_offset,
                                struct auxtrace_buffer **buffer_ptr);
 void auxtrace_queues__free(struct auxtrace_queues *queues);
+int auxtrace_queues__process_index(struct auxtrace_queues *queues,
+                                   struct perf_session *session);
 struct auxtrace_buffer *auxtrace_buffer__next(struct auxtrace_queue *queue,
                                               struct auxtrace_buffer *buffer);
 void *auxtrace_buffer__get_data(struct auxtrace_buffer *buffer, int fd);
@@ -361,6 +389,13 @@ int auxtrace_record__info_fill(struct auxtrace_record *itr,
 void auxtrace_record__free(struct auxtrace_record *itr);
 u64 auxtrace_record__reference(struct auxtrace_record *itr);
 
+int auxtrace_index__auxtrace_event(struct list_head *head, union perf_event *event,
+                                   off_t file_offset);
+int auxtrace_index__write(int fd, struct list_head *head);
+int auxtrace_index__process(int fd, u64 size, struct perf_session *session,
+                            bool needs_swap);
+void auxtrace_index__free(struct list_head *head);
+
 void auxtrace_synth_error(struct auxtrace_error_event *auxtrace_error, int type,
                           int code, int cpu, pid_t pid, pid_t tid, u64 ip,
                           const char *msg);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 589c28028379..3f0d809d853a 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -869,11 +869,18 @@ static int write_branch_stack(int fd __maybe_unused,
         return 0;
 }
 
-static int write_auxtrace(int fd __maybe_unused,
-                          struct perf_header *h __maybe_unused,
+static int write_auxtrace(int fd, struct perf_header *h,
                           struct perf_evlist *evlist __maybe_unused)
 {
-        return 0;
+        struct perf_session *session;
+        int err;
+
+        session = container_of(h, struct perf_session, header);
+
+        err = auxtrace_index__write(fd, &session->auxtrace_index);
+        if (err < 0)
+                pr_err("Failed to write auxtrace index\n");
+        return err;
 }
 
 static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
@@ -1834,6 +1841,22 @@ out_free:
         return ret;
 }
 
+static int process_auxtrace(struct perf_file_section *section,
+                            struct perf_header *ph, int fd,
+                            void *data __maybe_unused)
+{
+        struct perf_session *session;
+        int err;
+
+        session = container_of(ph, struct perf_session, header);
+
+        err = auxtrace_index__process(fd, section->size, session,
+                                      ph->needs_swap);
+        if (err < 0)
+                pr_err("Failed to process auxtrace index\n");
+        return err;
+}
+
 struct feature_ops {
         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
         void (*print)(struct perf_header *h, int fd, FILE *fp);
@@ -1874,7 +1897,7 @@ static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
         FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
         FEAT_OPP(HEADER_GROUP_DESC,     group_desc),
-        FEAT_OPA(HEADER_AUXTRACE,       auxtrace),
+        FEAT_OPP(HEADER_AUXTRACE,       auxtrace),
 };
 
 struct header_print_data {
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 90fa5674ccb4..b6972b118bc2 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -120,6 +120,7 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
 
         session->repipe = repipe;
         session->tool   = tool;
+        INIT_LIST_HEAD(&session->auxtrace_index);
         machines__init(&session->machines);
         ordered_events__init(&session->ordered_events, ordered_events__deliver_event);
 
@@ -187,6 +188,7 @@ static void perf_session_env__delete(struct perf_session_env *env)
 void perf_session__delete(struct perf_session *session)
 {
         auxtrace__free(session);
+        auxtrace_index__free(&session->auxtrace_index);
         perf_session__destroy_kernel_maps(session);
         perf_session__delete_threads(session);
         perf_session_env__delete(&session->header.env);
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 9ed51353a3d7..b44afc75d1cc 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -24,6 +24,7 @@ struct perf_session {
         struct perf_evlist      *evlist;
         struct auxtrace         *auxtrace;
         struct itrace_synth_opts *itrace_synth_opts;
+        struct list_head        auxtrace_index;
         struct trace_event      tevent;
         bool                    repipe;
         bool                    one_mmap;