1 files changed, 231 insertions, 0 deletions

diff --git a/tools/perf/util/arm-spe.c b/tools/perf/util/arm-spe.c
new file mode 100644
index 000000000000..6067267cc76c
--- /dev/null
+++ b/tools/perf/util/arm-spe.c
@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Arm Statistical Profiling Extensions (SPE) support
+ * Copyright (c) 2017-2018, Arm Ltd.
+ */
+
+#include <endian.h>
+#include <errno.h>
+#include <byteswap.h>
+#include <inttypes.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/bitops.h>
+#include <linux/log2.h>
+
+#include "cpumap.h"
+#include "color.h"
+#include "evsel.h"
+#include "evlist.h"
+#include "machine.h"
+#include "session.h"
+#include "util.h"
+#include "thread.h"
+#include "debug.h"
+#include "auxtrace.h"
+#include "arm-spe.h"
+#include "arm-spe-pkt-decoder.h"
+
+struct arm_spe {
+        struct auxtrace                 auxtrace;
+        struct auxtrace_queues          queues;
+        struct auxtrace_heap            heap;
+        u32                             auxtrace_type;
+        struct perf_session             *session;
+        struct machine                  *machine;
+        u32                             pmu_type;
+};
+
+struct arm_spe_queue {
+        struct arm_spe          *spe;
+        unsigned int            queue_nr;
+        struct auxtrace_buffer  *buffer;
+        bool                    on_heap;
+        bool                    done;
+        pid_t                   pid;
+        pid_t                   tid;
+        int                     cpu;
+};
+
+static void arm_spe_dump(struct arm_spe *spe __maybe_unused,
+                         unsigned char *buf, size_t len)
+{
+        struct arm_spe_pkt packet;
+        size_t pos = 0;
+        int ret, pkt_len, i;
+        char desc[ARM_SPE_PKT_DESC_MAX];
+        const char *color = PERF_COLOR_BLUE;
+
+        color_fprintf(stdout, color,
+                      ". ... ARM SPE data: size %zu bytes\n",
+                      len);
+
+        while (len) {
+                ret = arm_spe_get_packet(buf, len, &packet);
+                if (ret > 0)
+                        pkt_len = ret;
+                else
+                        pkt_len = 1;
+                printf(".");
+                color_fprintf(stdout, color, "  %08x: ", pos);
+                for (i = 0; i < pkt_len; i++)
+                        color_fprintf(stdout, color, " %02x", buf[i]);
+                for (; i < 16; i++)
+                        color_fprintf(stdout, color, "   ");
+                if (ret > 0) {
+                        ret = arm_spe_pkt_desc(&packet, desc,
+                                               ARM_SPE_PKT_DESC_MAX);
+                        if (ret > 0)
+                                color_fprintf(stdout, color, " %s\n", desc);
+                } else {
+                        color_fprintf(stdout, color, " Bad packet!\n");
+                }
+                pos += pkt_len;
+                buf += pkt_len;
+                len -= pkt_len;
+        }
+}
+
+static void arm_spe_dump_event(struct arm_spe *spe, unsigned char *buf,
+                               size_t len)
+{
+        printf(".\n");
+        arm_spe_dump(spe, buf, len);
+}
+
+static int arm_spe_process_event(struct perf_session *session __maybe_unused,
+                                 union perf_event *event __maybe_unused,
+                                 struct perf_sample *sample __maybe_unused,
+                                 struct perf_tool *tool __maybe_unused)
+{
+        return 0;
+}
+
+static int arm_spe_process_auxtrace_event(struct perf_session *session,
+                                          union perf_event *event,
+                                          struct perf_tool *tool __maybe_unused)
+{
+        struct arm_spe *spe = container_of(session->auxtrace, struct arm_spe,
+                                             auxtrace);
+        struct auxtrace_buffer *buffer;
+        off_t data_offset;
+        int fd = perf_data__fd(session->data);
+        int err;
+
+        if (perf_data__is_pipe(session->data)) {
+                data_offset = 0;
+        } else {
+                data_offset = lseek(fd, 0, SEEK_CUR);
+                if (data_offset == -1)
+                        return -errno;
+        }
+
+        err = auxtrace_queues__add_event(&spe->queues, session, event,
+                                         data_offset, &buffer);
+        if (err)
+                return err;
+
+        /* Dump here now we have copied a piped trace out of the pipe */
+        if (dump_trace) {
+                if (auxtrace_buffer__get_data(buffer, fd)) {
+                        arm_spe_dump_event(spe, buffer->data,
+                                             buffer->size);
+                        auxtrace_buffer__put_data(buffer);
+                }
+        }
+
+        return 0;
+}
+
+static int arm_spe_flush(struct perf_session *session __maybe_unused,
+                         struct perf_tool *tool __maybe_unused)
+{
+        return 0;
+}
+
+static void arm_spe_free_queue(void *priv)
+{
+        struct arm_spe_queue *speq = priv;
+
+        if (!speq)
+                return;
+        free(speq);
+}
+
+static void arm_spe_free_events(struct perf_session *session)
+{
+        struct arm_spe *spe = container_of(session->auxtrace, struct arm_spe,
+                                             auxtrace);
+        struct auxtrace_queues *queues = &spe->queues;
+        unsigned int i;
+
+        for (i = 0; i < queues->nr_queues; i++) {
+                arm_spe_free_queue(queues->queue_array[i].priv);
+                queues->queue_array[i].priv = NULL;
+        }
+        auxtrace_queues__free(queues);
+}
+
+static void arm_spe_free(struct perf_session *session)
+{
+        struct arm_spe *spe = container_of(session->auxtrace, struct arm_spe,
+                                             auxtrace);
+
+        auxtrace_heap__free(&spe->heap);
+        arm_spe_free_events(session);
+        session->auxtrace = NULL;
+        free(spe);
+}
+
+static const char * const arm_spe_info_fmts[] = {
+        [ARM_SPE_PMU_TYPE]              = "  PMU Type           %"PRId64"\n",
+};
+
+static void arm_spe_print_info(u64 *arr)
+{
+        if (!dump_trace)
+                return;
+
+        fprintf(stdout, arm_spe_info_fmts[ARM_SPE_PMU_TYPE], arr[ARM_SPE_PMU_TYPE]);
+}
+
+int arm_spe_process_auxtrace_info(union perf_event *event,
+                                  struct perf_session *session)
+{
+        struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
+        size_t min_sz = sizeof(u64) * ARM_SPE_PMU_TYPE;
+        struct arm_spe *spe;
+        int err;
+
+        if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
+                                        min_sz)
+                return -EINVAL;
+
+        spe = zalloc(sizeof(struct arm_spe));
+        if (!spe)
+                return -ENOMEM;
+
+        err = auxtrace_queues__init(&spe->queues);
+        if (err)
+                goto err_free;
+
+        spe->session = session;
+        spe->machine = &session->machines.host; /* No kvm support */
+        spe->auxtrace_type = auxtrace_info->type;
+        spe->pmu_type = auxtrace_info->priv[ARM_SPE_PMU_TYPE];
+
+        spe->auxtrace.process_event = arm_spe_process_event;
+        spe->auxtrace.process_auxtrace_event = arm_spe_process_auxtrace_event;
+        spe->auxtrace.flush_events = arm_spe_flush;
+        spe->auxtrace.free_events = arm_spe_free_events;
+        spe->auxtrace.free = arm_spe_free;
+        session->auxtrace = &spe->auxtrace;
+
+        arm_spe_print_info(&auxtrace_info->priv[0]);
+
+        return 0;
+
+err_free:
+        free(spe);
+        return err;
+}