perf arm-spe: Support hardware-based PID tracing

If ARM SPE traces contains CONTEXT packets with TID info, use these
values for tracking the TID of samples. Otherwise fall back to using
context switch events and display a message warning to the user of
possible timing inaccuracies [1].

[1] https://lore.kernel.org/lkml/f877cfa6-9b25-6445-3806-ca44a4042eaf@arm.com/

Signed-off-by: German Gomez <german.gomez@arm.com>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: John Garry <john.garry@huawei.com>
Cc: Leo Yan <leo.yan@linaro.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Poirier <mathieu.poirier@linaro.org>
Cc: Will Deacon <will@kernel.org>
Cc: linux-arm-kernel@lists.infradead.org
Link: https://lore.kernel.org/r/20211111133625.193568-5-german.gomez@arm.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/arm-spe.c b/tools/perf/util/arm-spe.c
index 9e3a6c54801d52fcb74d6aa518a7a8763686349c..4748bcfe61de4e6c61cbc5e73147247d877bb805 100644 (file)
--- a/tools/perf/util/arm-spe.c
+++ b/tools/perf/util/arm-spe.c
@@ -71,6 +71,7 @@ struct arm_spe {
        u64                             kernel_start;
 
        unsigned long                   num_events;
+       u8                              use_ctx_pkt_for_pid;
 };
 
 struct arm_spe_queue {
@@ -226,6 +227,44 @@ static inline u8 arm_spe_cpumode(struct arm_spe *spe, u64 ip)
                PERF_RECORD_MISC_USER;
 }
 
+static void arm_spe_set_pid_tid_cpu(struct arm_spe *spe,
+                                   struct auxtrace_queue *queue)
+{
+       struct arm_spe_queue *speq = queue->priv;
+       pid_t tid;
+
+       tid = machine__get_current_tid(spe->machine, speq->cpu);
+       if (tid != -1) {
+               speq->tid = tid;
+               thread__zput(speq->thread);
+       } else
+               speq->tid = queue->tid;
+
+       if ((!speq->thread) && (speq->tid != -1)) {
+               speq->thread = machine__find_thread(spe->machine, -1,
+                                                   speq->tid);
+       }
+
+       if (speq->thread) {
+               speq->pid = speq->thread->pid_;
+               if (queue->cpu == -1)
+                       speq->cpu = speq->thread->cpu;
+       }
+}
+
+static int arm_spe_set_tid(struct arm_spe_queue *speq, pid_t tid)
+{
+       struct arm_spe *spe = speq->spe;
+       int err = machine__set_current_tid(spe->machine, speq->cpu, -1, tid);
+
+       if (err)
+               return err;
+
+       arm_spe_set_pid_tid_cpu(spe, &spe->queues.queue_array[speq->queue_nr]);
+
+       return 0;
+}
+
 static void arm_spe_prep_sample(struct arm_spe *spe,
                                struct arm_spe_queue *speq,
                                union perf_event *event,
@@ -460,6 +499,19 @@ static int arm_spe_run_decoder(struct arm_spe_queue *speq, u64 *timestamp)
                 * can correlate samples between Arm SPE trace data and other
                 * perf events with correct time ordering.
                 */
+
+               /*
+                * Update pid/tid info.
+                */
+               record = &speq->decoder->record;
+               if (!spe->timeless_decoding && record->context_id != (u64)-1) {
+                       ret = arm_spe_set_tid(speq, record->context_id);
+                       if (ret)
+                               return ret;
+
+                       spe->use_ctx_pkt_for_pid = true;
+               }
+
                ret = arm_spe_sample(speq);
                if (ret)
                        return ret;
@@ -586,31 +638,6 @@ static bool arm_spe__is_timeless_decoding(struct arm_spe *spe)
        return timeless_decoding;
 }
 
-static void arm_spe_set_pid_tid_cpu(struct arm_spe *spe,
-                                   struct auxtrace_queue *queue)
-{
-       struct arm_spe_queue *speq = queue->priv;
-       pid_t tid;
-
-       tid = machine__get_current_tid(spe->machine, speq->cpu);
-       if (tid != -1) {
-               speq->tid = tid;
-               thread__zput(speq->thread);
-       } else
-               speq->tid = queue->tid;
-
-       if ((!speq->thread) && (speq->tid != -1)) {
-               speq->thread = machine__find_thread(spe->machine, -1,
-                                                   speq->tid);
-       }
-
-       if (speq->thread) {
-               speq->pid = speq->thread->pid_;
-               if (queue->cpu == -1)
-                       speq->cpu = speq->thread->cpu;
-       }
-}
-
 static int arm_spe_process_queues(struct arm_spe *spe, u64 timestamp)
 {
        unsigned int queue_nr;
@@ -641,7 +668,12 @@ static int arm_spe_process_queues(struct arm_spe *spe, u64 timestamp)
                        ts = timestamp;
                }
 
-               arm_spe_set_pid_tid_cpu(spe, queue);
+               /*
+                * A previous context-switch event has set pid/tid in the machine's context, so
+                * here we need to update the pid/tid in the thread and SPE queue.
+                */
+               if (!spe->use_ctx_pkt_for_pid)
+                       arm_spe_set_pid_tid_cpu(spe, queue);
 
                ret = arm_spe_run_decoder(speq, &ts);
                if (ret < 0) {
@@ -740,8 +772,9 @@ static int arm_spe_process_event(struct perf_session *session,
                if (err)
                        return err;
 
-               if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE ||
-                   event->header.type == PERF_RECORD_SWITCH)
+               if (!spe->use_ctx_pkt_for_pid &&
+                   (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE ||
+                   event->header.type == PERF_RECORD_SWITCH))
                        err = arm_spe_context_switch(spe, event, sample);
        }
 
@@ -808,7 +841,15 @@ static int arm_spe_flush(struct perf_session *session __maybe_unused,
                return arm_spe_process_timeless_queues(spe, -1,
                                MAX_TIMESTAMP - 1);
 
-       return arm_spe_process_queues(spe, MAX_TIMESTAMP);
+       ret = arm_spe_process_queues(spe, MAX_TIMESTAMP);
+       if (ret)
+               return ret;
+
+       if (!spe->use_ctx_pkt_for_pid)
+               ui__warning("Arm SPE CONTEXT packets not found in the traces.\n"
+                           "Matching of TIDs to SPE events could be inaccurate.\n");
+
+       return 0;
 }
 
 static void arm_spe_free_queue(void *priv)