perf: cs-etm: Allocate queues for all CPUs

Make cs_etm__setup_queue() setup a queue even if it's empty, and
pre-allocate queues based on the max CPU that was recorded. In per-CPU
mode aux queues are indexed based on CPU ID even if all CPUs aren't
recorded, sparse queue arrays aren't used.

This will allow HW_IDs to be saved even if no aux data was received in
that queue without having to call cs_etm__setup_queue() from two
different places.

Reviewed-by: Mike Leach <mike.leach@linaro.org>
Signed-off-by: James Clark <james.clark@arm.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Alexandre Torgue <alexandre.torgue@foss.st.com>
Cc: Anshuman Khandual <anshuman.khandual@arm.com>
Cc: Ganapatrao Kulkarni <gankulkarni@os.amperecomputing.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Leo Yan <leo.yan@linux.dev>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Maxime Coquelin <mcoquelin.stm32@gmail.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Suzuki Poulouse <suzuki.poulose@arm.com>
Cc: Will Deacon <will@kernel.org>
Link: https://lore.kernel.org/r/20240722101202.26915-3-james.clark@linaro.org
Signed-off-by: James Clark <james.clark@linaro.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c
index 0915a4356fb32ca27ef00a9523cb137c53ba43e0..03df8894a90097ca99d54cd1fd13f12e3babf902 100644 (file)
--- a/tools/perf/util/cs-etm.c
+++ b/tools/perf/util/cs-etm.c
@@ -1062,16 +1062,11 @@ static struct cs_etm_queue *cs_etm__alloc_queue(void)
 
 static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm,
                               struct auxtrace_queue *queue,
-                              unsigned int queue_nr, enum cs_etm_format format)
+                              unsigned int queue_nr)
 {
        struct cs_etm_queue *etmq = queue->priv;
 
-       if (etmq && format != etmq->format) {
-               pr_err("CS_ETM: mixed formatted and unformatted trace not supported\n");
-               return -EINVAL;
-       }
-
-       if (list_empty(&queue->head) || etmq)
+       if (etmq)
                return 0;
 
        etmq = cs_etm__alloc_queue();
@@ -1084,7 +1079,6 @@ static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm,
        etmq->queue_nr = queue_nr;
        queue->cpu = queue_nr; /* Placeholder, may be reset to -1 in per-thread mode */
        etmq->offset = 0;
-       etmq->format = format;
 
        return 0;
 }
@@ -2772,17 +2766,6 @@ static int cs_etm__process_auxtrace_event(struct perf_session *session,
                if (err)
                        return err;
 
-               /*
-                * Knowing if the trace is formatted or not requires a lookup of
-                * the aux record so only works in non-piped mode where data is
-                * queued in cs_etm__queue_aux_records(). Always assume
-                * formatted in piped mode (true).
-                */
-               err = cs_etm__setup_queue(etm, &etm->queues.queue_array[idx],
-                                         idx, FORMATTED);
-               if (err)
-                       return err;
-
                if (dump_trace)
                        if (auxtrace_buffer__get_data(buffer, fd)) {
                                cs_etm__dump_event(etm->queues.queue_array[idx].priv, buffer);
@@ -2899,7 +2882,6 @@ static int cs_etm__queue_aux_fragment(struct perf_session *session, off_t file_o
        struct perf_record_auxtrace *auxtrace_event;
        union perf_event auxtrace_fragment;
        __u64 aux_offset, aux_size;
-       __u32 idx;
        enum cs_etm_format format;
 
        struct cs_etm_auxtrace *etm = container_of(session->auxtrace,
@@ -2966,6 +2948,8 @@ static int cs_etm__queue_aux_fragment(struct perf_session *session, off_t file_o
 
        if (aux_offset >= auxtrace_event->offset &&
            aux_offset + aux_size <= auxtrace_event->offset + auxtrace_event->size) {
+               struct cs_etm_queue *etmq = etm->queues.queue_array[auxtrace_event->idx].priv;
+
                /*
                 * If this AUX event was inside this buffer somewhere, create a new auxtrace event
                 * based on the sizes of the aux event, and queue that fragment.
@@ -2982,11 +2966,14 @@ static int cs_etm__queue_aux_fragment(struct perf_session *session, off_t file_o
                if (err)
                        return err;
 
-               idx = auxtrace_event->idx;
                format = (aux_event->flags & PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW) ?
                                UNFORMATTED : FORMATTED;
-
-               return cs_etm__setup_queue(etm, &etm->queues.queue_array[idx], idx, format);
+               if (etmq->format != UNSET && format != etmq->format) {
+                       pr_err("CS_ETM: mixed formatted and unformatted trace not supported\n");
+                       return -EINVAL;
+               }
+               etmq->format = format;
+               return 0;
        }
 
        /* Wasn't inside this buffer, but there were no parse errors. 1 == 'not found' */
@@ -3238,6 +3225,7 @@ static int cs_etm__create_decoders(struct cs_etm_auxtrace *etm)
                 * Don't create decoders for empty queues, mainly because
                 * etmq->format is unknown for empty queues.
                 */
+               assert(empty == (etmq->format == UNSET));
                if (empty)
                        continue;
 
@@ -3257,10 +3245,10 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
        int event_header_size = sizeof(struct perf_event_header);
        int total_size = auxtrace_info->header.size;
        int priv_size = 0;
-       int num_cpu;
+       int num_cpu, max_cpu = 0;
        int err = 0;
        int aux_hw_id_found;
-       int i, j;
+       int i;
        u64 *ptr = NULL;
        u64 **metadata = NULL;
 
@@ -3291,7 +3279,7 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
         * required by the trace decoder to properly decode the trace due
         * to its highly compressed nature.
         */
-       for (j = 0; j < num_cpu; j++) {
+       for (int j = 0; j < num_cpu; j++) {
                if (ptr[i] == __perf_cs_etmv3_magic) {
                        metadata[j] =
                                cs_etm__create_meta_blk(ptr, &i,
@@ -3315,6 +3303,9 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
                        err = -ENOMEM;
                        goto err_free_metadata;
                }
+
+               if ((int) metadata[j][CS_ETM_CPU] > max_cpu)
+                       max_cpu = metadata[j][CS_ETM_CPU];
        }
 
        /*
@@ -3344,10 +3335,16 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
         */
        etm->pid_fmt = cs_etm__init_pid_fmt(metadata[0]);
 
-       err = auxtrace_queues__init(&etm->queues);
+       err = auxtrace_queues__init_nr(&etm->queues, max_cpu + 1);
        if (err)
                goto err_free_etm;
 
+       for (unsigned int j = 0; j < etm->queues.nr_queues; ++j) {
+               err = cs_etm__setup_queue(etm, &etm->queues.queue_array[j], j);
+               if (err)
+                       goto err_free_queues;
+       }
+
        if (session->itrace_synth_opts->set) {
                etm->synth_opts = *session->itrace_synth_opts;
        } else {
@@ -3469,7 +3466,7 @@ err_free_etm:
        zfree(&etm);
 err_free_metadata:
        /* No need to check @metadata[j], free(NULL) is supported */
-       for (j = 0; j < num_cpu; j++)
+       for (int j = 0; j < num_cpu; j++)
                zfree(&metadata[j]);
        zfree(&metadata);
 err_free_traceid_list: