Skip to contentSkip to conversation

coresight: Use per-sink trace ID maps for Perf sessions

PATCH Superseded James Clark 4 participants 28 messages Jun 4, 2024 – Jun 10, 2024

Subsystems (5)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover coresight: Use per-sink trace ID maps for Perf sessions

This will allow sessions with more than CORESIGHT_TRACE_IDS_MAX ETMs as long as there are fewer than that many ETMs connected to each sink.

Each sink owns its own trace ID map, and any Perf session connecting to that sink will allocate from it, even if the sink is currently in use by other users. This is similar to the existing behavior where the dynamic trace IDs are constant as long as there is any concurrent Perf session active. It's not completely optimal because slightly more IDs will be used than necessary, but the optimal solution involves tracking the PIDs of each session and allocating ID maps based on the session owner. This is difficult to do with the combination of per-thread and per-cpu modes and some scheduling issues. The complexity of this isn't likely to worth it because even with multiple users they'd just see a difference in the ordering of ID allocations rather than hitting any limits (unless the hardware does have too many ETMs connected to one sink).

Per-thread mode works but only until there are any overlapping IDs, at which point Perf will error out. Both per-thread mode and sysfs mode are left to future changes, but both can be added on top of this initial implementation and only sysfs mode requires further driver changes.

The HW_ID version field hasn't been bumped in order to not break Perf which already has an error condition for other values of that field. Instead a new minor version has been added which signifies that there are new fields but the old fields are backwards compatible.

Changes since V1:

* Rename coresight_device.perf_id_map to perf_sink_id_map.
* Instead of outputting a HW_ID for each reachable ETM, output the sink ID and continue to output only the HW_ID once for each mapping.
* Keep the first two Perf patches so that it applies cleanly on coresight-next, although they have been applied on perf-tools-next
* Add new *_map() functions to the trace ID public API instead of modifying existing ones.
* Collapse "coresight: Pass trace ID map into source enable" into "coresight: Use per-sink trace ID maps for Perf sessions" because the first commit relied on the default map being accessible which is no longer necessary due to the previous bullet point.

James Clark (16):
perf cs-etm: Print error for new PERF_RECORD_AUX_OUTPUT_HW_ID versions perf auxtrace: Allow number of queues to be specified
perf: cs-etm: Create decoders after both AUX and HW_ID search passes
perf: cs-etm: Allocate queues for all CPUs
perf: cs-etm: Move traceid_list to each queue
perf: cs-etm: Create decoders based on the trace ID mappings
perf: cs-etm: Support version 0.1 of HW_ID packets
coresight: Remove unused ETM Perf stubs
coresight: Clarify comments around the PID of the sink owner
coresight: Move struct coresight_trace_id_map to common header
coresight: Expose map arguments in trace ID API
coresight: Make CPU id map a property of a trace ID map
coresight: Use per-sink trace ID maps for Perf sessions
coresight: Remove pending trace ID release mechanism
coresight: Re-emit trace IDs when the sink changes in per-thread mode
coresight: Emit sink ID in the HW_ID packets

 drivers/hwtracing/coresight/coresight-core.c  |  36 +-
 drivers/hwtracing/coresight/coresight-dummy.c |   3 +-
 .../hwtracing/coresight/coresight-etm-perf.c  |  50 +-
 .../hwtracing/coresight/coresight-etm-perf.h  |  20 +-
 .../coresight/coresight-etm3x-core.c          |   9 +-
 .../coresight/coresight-etm4x-core.c          |   9 +-
 drivers/hwtracing/coresight/coresight-priv.h  |   1 +
 drivers/hwtracing/coresight/coresight-stm.c   |   3 +-
 drivers/hwtracing/coresight/coresight-sysfs.c |   3 +-
 .../hwtracing/coresight/coresight-tmc-etr.c   |   5 +-
 drivers/hwtracing/coresight/coresight-tmc.h   |   5 +-
 drivers/hwtracing/coresight/coresight-tpdm.c  |   3 +-
 .../hwtracing/coresight/coresight-trace-id.c  | 109 ++--
 .../hwtracing/coresight/coresight-trace-id.h  |  70 +-
 include/linux/coresight-pmu.h                 |  17 +-
 include/linux/coresight.h                     |  20 +-
 tools/include/linux/coresight-pmu.h           |  17 +-
 tools/perf/util/auxtrace.c                    |   9 +-
 tools/perf/util/auxtrace.h                    |   1 +
 .../perf/util/cs-etm-decoder/cs-etm-decoder.c |  28 +-
 tools/perf/util/cs-etm.c                      | 603 ++++++++++++------
 tools/perf/util/cs-etm.h                      |   2 +-
 22 files changed, 628 insertions(+), 395 deletions(-)
Signature · 1 line
2.34.1
#1 lore raw

PATCH v2 1/16 perf cs-etm: Print error for new PERF_RECORD_AUX_OUTPUT_HW_ID versions

The likely fix for this is to update Perf so print a helpful message.

---
 tools/perf/util/cs-etm.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
tools/perf/util/cs-etm.c +4 -1
index d65d7485886c..32818bd7cd17 100644
@@ -335,8 +335,11 @@ static int cs_etm__process_aux_output_hw_id(struct perf_session *session,
 	trace_chan_id = FIELD_GET(CS_AUX_HW_ID_TRACE_ID_MASK, hw_id);
 
 	/* check that we can handle this version */
-	if (version > CS_AUX_HW_ID_CURR_VERSION)
+	if (version > CS_AUX_HW_ID_CURR_VERSION) {
+		pr_err("CS ETM Trace: PERF_RECORD_AUX_OUTPUT_HW_ID version %d not supported. Please update Perf.\n",
+		       version);
 		return -EINVAL;
+	}
 
 	/* get access to the etm metadata */
 	etm = container_of(session->auxtrace, struct cs_etm_auxtrace, auxtrace);
Signature · 1 line
2.34.1
#2 lore raw

PATCH v2 2/16 perf auxtrace: Allow number of queues to be specified

In reply to James Clark

Currently it's only possible to initialize with the default number of queues and then use auxtrace_queues__add_event() to grow the array. But that's problematic if you don't have a real event to pass into that function yet.

The queues hold a void *priv member to store custom state, and for Coresight we want to create decoders upfront before receiving data, so add a new function that allows pre-allocating queues. One reason to do this is because we might need to store metadata (HW_ID events) that effects other queues, but never actually receive auxtrace data on that queue.

---
 tools/perf/util/auxtrace.c | 9 +++++++--
 tools/perf/util/auxtrace.h | 1 +
 2 files changed, 8 insertions(+), 2 deletions(-)
tools/perf/util/auxtrace.c +7 -2
index 3684e6009b63..563b6c4fca31 100644
@@ -218,15 +218,20 @@ static struct auxtrace_queue *auxtrace_alloc_queue_array(unsigned int nr_queues)
 	return queue_array;
 }
 
-int auxtrace_queues__init(struct auxtrace_queues *queues)
+int auxtrace_queues__init_nr(struct auxtrace_queues *queues, int nr_queues)
 {
-	queues->nr_queues = AUXTRACE_INIT_NR_QUEUES;
+	queues->nr_queues = nr_queues;
 	queues->queue_array = auxtrace_alloc_queue_array(queues->nr_queues);
 	if (!queues->queue_array)
 		return -ENOMEM;
 	return 0;
 }
 
+int auxtrace_queues__init(struct auxtrace_queues *queues)
+{
+	return auxtrace_queues__init_nr(queues, AUXTRACE_INIT_NR_QUEUES);
+}
+
 static int auxtrace_queues__grow(struct auxtrace_queues *queues,
 				 unsigned int new_nr_queues)
 {
tools/perf/util/auxtrace.h +1 -0
index 55702215a82d..8a6ec9565835 100644
@@ -521,6 +521,7 @@ int auxtrace_mmap__read_snapshot(struct mmap *map,
 				 struct perf_tool *tool, process_auxtrace_t fn,
 				 size_t snapshot_size);
 
+int auxtrace_queues__init_nr(struct auxtrace_queues *queues, int nr_queues);
 int auxtrace_queues__init(struct auxtrace_queues *queues);
 int auxtrace_queues__add_event(struct auxtrace_queues *queues,
 			       struct perf_session *session,
Signature · 1 line
2.34.1
reviewer Acked-by on v2 2/16
#3 lore raw

Re: [PATCH v2 02/16] perf auxtrace: Allow number of queues to be specified

Quoted 5 lines · James Clark

Currently it's only possible to initialize with the default number of queues and then use auxtrace_queues__add_event() to grow the array. But that's problematic if you don't have a real event to pass into that function yet.

Quoted 8 lines

The queues hold a void *priv member to store custom state, and for Coresight we want to create decoders upfront before receiving data, so add a new function that allows pre-allocating queues. One reason to do this is because we might need to store metadata (HW_ID events) that effects other queues, but never actually receive auxtrace data on that queue.

Again ;-)

Quoted 44 lines
---
 tools/perf/util/auxtrace.c | 9 +++++++--
 tools/perf/util/auxtrace.h | 1 +
 2 files changed, 8 insertions(+), 2 deletions(-)
tools/perf/util/auxtrace.c +7 -2
index 3684e6009b63..563b6c4fca31 100644
@@ -218,15 +218,20 @@ static struct auxtrace_queue *auxtrace_alloc_queue_array(unsigned int nr_queues)
 	return queue_array;
 }
 
-int auxtrace_queues__init(struct auxtrace_queues *queues)
+int auxtrace_queues__init_nr(struct auxtrace_queues *queues, int nr_queues)
 {
-	queues->nr_queues = AUXTRACE_INIT_NR_QUEUES;
+	queues->nr_queues = nr_queues;
 	queues->queue_array = auxtrace_alloc_queue_array(queues->nr_queues);
 	if (!queues->queue_array)
 		return -ENOMEM;
 	return 0;
 }
 
+int auxtrace_queues__init(struct auxtrace_queues *queues)
+{
+	return auxtrace_queues__init_nr(queues, AUXTRACE_INIT_NR_QUEUES);
+}
+
 static int auxtrace_queues__grow(struct auxtrace_queues *queues,
 				 unsigned int new_nr_queues)
 {
tools/perf/util/auxtrace.h +1 -0
index 55702215a82d..8a6ec9565835 100644
@@ -521,6 +521,7 @@ int auxtrace_mmap__read_snapshot(struct mmap *map,
 				 struct perf_tool *tool, process_auxtrace_t fn,
 				 size_t snapshot_size);
 
+int auxtrace_queues__init_nr(struct auxtrace_queues *queues, int nr_queues);
 int auxtrace_queues__init(struct auxtrace_queues *queues);
 int auxtrace_queues__add_event(struct auxtrace_queues *queues,
 			       struct perf_session *session,
#4 lore raw

Re: [PATCH v2 02/16] perf auxtrace: Allow number of queues to be specified

Quoted 13 lines · Adrian Hunter
Quoted 12 lines · James Clark

Currently it's only possible to initialize with the default number of queues and then use auxtrace_queues__add_event() to grow the array. But that's problematic if you don't have a real event to pass into that function yet.

The queues hold a void *priv member to store custom state, and for Coresight we want to create decoders upfront before receiving data, so add a new function that allows pre-allocating queues. One reason to do this is because we might need to store metadata (HW_ID events) that effects other queues, but never actually receive auxtrace data on that queue.

Quoted 6 lines
Quoted 1 line

Again ;-)

Oops yeah I should have picked that up. This one was already applied to perf-tools-next as well.

Thanks

Quoted 45 lines
Quoted 44 lines
---
 tools/perf/util/auxtrace.c | 9 +++++++--
 tools/perf/util/auxtrace.h | 1 +
 2 files changed, 8 insertions(+), 2 deletions(-)
tools/perf/util/auxtrace.c +7 -2
index 3684e6009b63..563b6c4fca31 100644
@@ -218,15 +218,20 @@ static struct auxtrace_queue *auxtrace_alloc_queue_array(unsigned int nr_queues)
 	return queue_array;
 }
 
-int auxtrace_queues__init(struct auxtrace_queues *queues)
+int auxtrace_queues__init_nr(struct auxtrace_queues *queues, int nr_queues)
 {
-	queues->nr_queues = AUXTRACE_INIT_NR_QUEUES;
+	queues->nr_queues = nr_queues;
 	queues->queue_array = auxtrace_alloc_queue_array(queues->nr_queues);
 	if (!queues->queue_array)
 		return -ENOMEM;
 	return 0;
 }
 
+int auxtrace_queues__init(struct auxtrace_queues *queues)
+{
+	return auxtrace_queues__init_nr(queues, AUXTRACE_INIT_NR_QUEUES);
+}
+
 static int auxtrace_queues__grow(struct auxtrace_queues *queues,
 				 unsigned int new_nr_queues)
 {
tools/perf/util/auxtrace.h +1 -0
index 55702215a82d..8a6ec9565835 100644
@@ -521,6 +521,7 @@ int auxtrace_mmap__read_snapshot(struct mmap *map,
 				 struct perf_tool *tool, process_auxtrace_t fn,
 				 size_t snapshot_size);
 
+int auxtrace_queues__init_nr(struct auxtrace_queues *queues, int nr_queues);
 int auxtrace_queues__init(struct auxtrace_queues *queues);
 int auxtrace_queues__add_event(struct auxtrace_queues *queues,
 			       struct perf_session *session,
#5 lore raw

PATCH v2 3/16 perf: cs-etm: Create decoders after both AUX and HW_ID search passes

In reply to James Clark

Both of these passes gather information about how to create the decoders. AUX records determine formatted/unformatted, and the HW_IDs determine the traceID/metadata mappings. Therefore it makes sense to cache the information and wait until both passes are over until creating the decoders, rather than creating them at the first HW_ID found. This will allow a simplification of the creation process where cs_etm_queue->traceid_list will exclusively used to create the decoders, rather than the current two methods depending on whether the trace is formatted or not.

Previously the sample CPU from the AUX record was used to initialize the decoder CPU, but actually sample CPU == AUX queue index in per-CPU mode, so saving the sample CPU isn't required. Similarly formatted/unformatted was used upfront to create the decoders, but now it's cached until later.

---
 tools/perf/util/cs-etm.c | 167 ++++++++++++++++++++++++---------------
 1 file changed, 102 insertions(+), 65 deletions(-)
tools/perf/util/cs-etm.c +102 -65
index 32818bd7cd17..f09004c4ba44 100644
@@ -103,6 +103,7 @@ struct cs_etm_queue {
 	struct auxtrace_buffer *buffer;
 	unsigned int queue_nr;
 	u8 pending_timestamp_chan_id;
+	bool formatted;
 	u64 offset;
 	const unsigned char *buf;
 	size_t buf_len, buf_used;
@@ -738,8 +739,7 @@ static int cs_etm__init_trace_params(struct cs_etm_trace_params *t_params,
 
 static int cs_etm__init_decoder_params(struct cs_etm_decoder_params *d_params,
 				       struct cs_etm_queue *etmq,
-				       enum cs_etm_decoder_operation mode,
-				       bool formatted)
+				       enum cs_etm_decoder_operation mode)
 {
 	int ret = -EINVAL;
 
@@ -749,7 +749,7 @@ static int cs_etm__init_decoder_params(struct cs_etm_decoder_params *d_params,
 	d_params->packet_printer = cs_etm__packet_dump;
 	d_params->operation = mode;
 	d_params->data = etmq;
-	d_params->formatted = formatted;
+	d_params->formatted = etmq->formatted;
 	d_params->fsyncs = false;
 	d_params->hsyncs = false;
 	d_params->frame_aligned = true;
@@ -1041,81 +1041,34 @@ static u32 cs_etm__mem_access(struct cs_etm_queue *etmq, u8 trace_chan_id,
 	return ret;
 }
 
-static struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm,
-						bool formatted, int sample_cpu)
+static struct cs_etm_queue *cs_etm__alloc_queue(void)
 {
-	struct cs_etm_decoder_params d_params;
-	struct cs_etm_trace_params  *t_params = NULL;
-	struct cs_etm_queue *etmq;
-	/*
-	 * Each queue can only contain data from one CPU when unformatted, so only one decoder is
-	 * needed.
-	 */
-	int decoders = formatted ? etm->num_cpu : 1;
-
-	etmq = zalloc(sizeof(*etmq));
+	struct cs_etm_queue *etmq = zalloc(sizeof(*etmq));
 	if (!etmq)
 		return NULL;
 
 	etmq->traceid_queues_list = intlist__new(NULL);
 	if (!etmq->traceid_queues_list)
-		goto out_free;
-
-	/* Use metadata to fill in trace parameters for trace decoder */
-	t_params = zalloc(sizeof(*t_params) * decoders);
+		free(etmq);
 
-	if (!t_params)
-		goto out_free;
-
-	if (cs_etm__init_trace_params(t_params, etm, formatted, sample_cpu, decoders))
-		goto out_free;
-
-	/* Set decoder parameters to decode trace packets */
-	if (cs_etm__init_decoder_params(&d_params, etmq,
-					dump_trace ? CS_ETM_OPERATION_PRINT :
-						     CS_ETM_OPERATION_DECODE,
-					formatted))
-		goto out_free;
-
-	etmq->decoder = cs_etm_decoder__new(decoders, &d_params,
-					    t_params);
-
-	if (!etmq->decoder)
-		goto out_free;
-
-	/*
-	 * Register a function to handle all memory accesses required by
-	 * the trace decoder library.
-	 */
-	if (cs_etm_decoder__add_mem_access_cb(etmq->decoder,
-					      0x0L, ((u64) -1L),
-					      cs_etm__mem_access))
-		goto out_free_decoder;
-
-	zfree(&t_params);
 	return etmq;
-
-out_free_decoder:
-	cs_etm_decoder__free(etmq->decoder);
-out_free:
-	intlist__delete(etmq->traceid_queues_list);
-	free(etmq);
-
-	return NULL;
 }
 
 static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm,
 			       struct auxtrace_queue *queue,
-			       unsigned int queue_nr,
-			       bool formatted,
-			       int sample_cpu)
+			       unsigned int queue_nr, bool formatted)
 {
 	struct cs_etm_queue *etmq = queue->priv;
 
+	if (etmq && formatted != etmq->formatted) {
+		pr_err("CS_ETM: mixed formatted and unformatted trace not supported\n");
+		return -EINVAL;
+	}
+
 	if (list_empty(&queue->head) || etmq)
 		return 0;
 
-	etmq = cs_etm__alloc_queue(etm, formatted, sample_cpu);
+	etmq = cs_etm__alloc_queue();
 
 	if (!etmq)
 		return -ENOMEM;
@@ -1123,7 +1076,9 @@ static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm,
 	queue->priv = etmq;
 	etmq->etm = etm;
 	etmq->queue_nr = queue_nr;
+	queue->cpu = queue_nr; /* Placeholder, may be reset to -1 in per-thread mode */
 	etmq->offset = 0;
+	etmq->formatted = formatted;
 
 	return 0;
 }
@@ -2843,7 +2798,7 @@ static int cs_etm__process_auxtrace_event(struct perf_session *session,
 		 * formatted in piped mode (true).
 		 */
 		err = cs_etm__setup_queue(etm, &etm->queues.queue_array[idx],
-					  idx, true, -1);
+					  idx, true);
 		if (err)
 			return err;
 
@@ -3048,8 +3003,8 @@ static int cs_etm__queue_aux_fragment(struct perf_session *session, off_t file_o
 
 		idx = auxtrace_event->idx;
 		formatted = !(aux_event->flags & PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW);
-		return cs_etm__setup_queue(etm, &etm->queues.queue_array[idx],
-					   idx, formatted, sample->cpu);
+
+		return cs_etm__setup_queue(etm, &etm->queues.queue_array[idx], idx, formatted);
 	}
 
 	/* Wasn't inside this buffer, but there were no parse errors. 1 == 'not found' */
@@ -3233,6 +3188,84 @@ static int cs_etm__clear_unused_trace_ids_metadata(int num_cpu, u64 **metadata)
 	return 0;
 }
 
+/*
+ * Use the data gathered by the peeks for HW_ID (trace ID mappings) and AUX
+ * (formatted or not) packets to create the decoders.
+ */
+static int cs_etm__create_queue_decoders(struct cs_etm_queue *etmq)
+{
+	struct cs_etm_decoder_params d_params;
+
+	/*
+	 * Each queue can only contain data from one CPU when unformatted, so only one decoder is
+	 * needed.
+	 */
+	int decoders = etmq->formatted ? etmq->etm->num_cpu : 1;
+
+	/* Use metadata to fill in trace parameters for trace decoder */
+	struct cs_etm_trace_params  *t_params = zalloc(sizeof(*t_params) * decoders);
+
+	if (!t_params)
+		goto out_free;
+
+	if (cs_etm__init_trace_params(t_params, etmq->etm, etmq->formatted,
+				      etmq->queue_nr, decoders))
+		goto out_free;
+
+	/* Set decoder parameters to decode trace packets */
+	if (cs_etm__init_decoder_params(&d_params, etmq,
+					dump_trace ? CS_ETM_OPERATION_PRINT :
+						     CS_ETM_OPERATION_DECODE))
+		goto out_free;
+
+	etmq->decoder = cs_etm_decoder__new(decoders, &d_params,
+					    t_params);
+
+	if (!etmq->decoder)
+		goto out_free;
+
+	/*
+	 * Register a function to handle all memory accesses required by
+	 * the trace decoder library.
+	 */
+	if (cs_etm_decoder__add_mem_access_cb(etmq->decoder,
+					      0x0L, ((u64) -1L),
+					      cs_etm__mem_access))
+		goto out_free_decoder;
+
+	zfree(&t_params);
+	return 0;
+
+out_free_decoder:
+	cs_etm_decoder__free(etmq->decoder);
+out_free:
+	zfree(&t_params);
+	return -EINVAL;
+}
+
+static int cs_etm__create_decoders(struct cs_etm_auxtrace *etm)
+{
+	struct auxtrace_queues *queues = &etm->queues;
+
+	for (unsigned int i = 0; i < queues->nr_queues; i++) {
+		bool empty = list_empty(&queues->queue_array[i].head);
+		struct cs_etm_queue *etmq = queues->queue_array[i].priv;
+		int ret;
+
+		/*
+		 * Don't create decoders for empty queues, mainly because
+		 * etmq->formatted is unknown for empty queues.
+		 */
+		if (empty)
+			continue;
+
+		ret = cs_etm__create_queue_decoders(etmq);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
 int cs_etm__process_auxtrace_info_full(union perf_event *event,
 				       struct perf_session *session)
 {
@@ -3396,6 +3429,10 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
 	if (err)
 		goto err_free_queues;
 
+	err = cs_etm__queue_aux_records(session);
+	if (err)
+		goto err_free_queues;
+
 	/*
 	 * Map Trace ID values to CPU metadata.
 	 *
@@ -3418,7 +3455,7 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
 	 * flags if present.
 	 */
 
-	/* first scan for AUX_OUTPUT_HW_ID records to map trace ID values to CPU metadata */
+	/* Scan for AUX_OUTPUT_HW_ID records to map trace ID values to CPU metadata */
 	aux_hw_id_found = 0;
 	err = perf_session__peek_events(session, session->header.data_offset,
 					session->header.data_size,
@@ -3436,7 +3473,7 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
 	if (err)
 		goto err_free_queues;
 
-	err = cs_etm__queue_aux_records(session);
+	err = cs_etm__create_decoders(etm);
 	if (err)
 		goto err_free_queues;
 
Signature · 1 line
2.34.1
#6 lore raw

PATCH v2 4/16 perf: cs-etm: Allocate queues for all CPUs

In reply to James Clark

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.

---
 tools/perf/util/cs-etm.c | 55 ++++++++++++++++++++--------------------
 1 file changed, 27 insertions(+), 28 deletions(-)
tools/perf/util/cs-etm.c +27 -28
index f09004c4ba44..e40dfd09d3ed 100644
@@ -104,6 +104,7 @@ struct cs_etm_queue {
 	unsigned int queue_nr;
 	u8 pending_timestamp_chan_id;
 	bool formatted;
+	bool formatted_set;
 	u64 offset;
 	const unsigned char *buf;
 	size_t buf_len, buf_used;
@@ -1056,16 +1057,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, bool formatted)
+			       unsigned int queue_nr)
 {
 	struct cs_etm_queue *etmq = queue->priv;
 
-	if (etmq && formatted != etmq->formatted) {
-		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();
@@ -1078,7 +1074,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->formatted = formatted;
 
 	return 0;
 }
@@ -2791,17 +2786,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, true);
-		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);
@@ -2918,7 +2902,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;
 	bool formatted;
 
 	struct cs_etm_auxtrace *etm = container_of(session->auxtrace,
@@ -2985,6 +2968,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.
@@ -3001,10 +2986,14 @@ static int cs_etm__queue_aux_fragment(struct perf_session *session, off_t file_o
 		if (err)
 			return err;
 
-		idx = auxtrace_event->idx;
 		formatted = !(aux_event->flags & PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW);
-
-		return cs_etm__setup_queue(etm, &etm->queues.queue_array[idx], idx, formatted);
+		if (etmq->formatted_set && formatted != etmq->formatted) {
+			pr_err("CS_ETM: mixed formatted and unformatted trace not supported\n");
+			return -EINVAL;
+		}
+		etmq->formatted = formatted;
+		etmq->formatted_set = true;
+		return 0;
 	}
 
 	/* Wasn't inside this buffer, but there were no parse errors. 1 == 'not found' */
@@ -3256,6 +3245,7 @@ static int cs_etm__create_decoders(struct cs_etm_auxtrace *etm)
 		 * Don't create decoders for empty queues, mainly because
 		 * etmq->formatted is unknown for empty queues.
 		 */
+		assert(empty == !etmq->formatted_set);
 		if (empty)
 			continue;
 
@@ -3275,10 +3265,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;
 
@@ -3309,7 +3299,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,
@@ -3333,6 +3323,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];
 	}
 
 	/*
@@ -3362,10 +3355,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 {
@@ -3487,7 +3486,7 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
 	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:
Signature · 1 line
2.34.1
#7 lore raw

PATCH v2 5/16 perf: cs-etm: Move traceid_list to each queue

In reply to James Clark

The global list won't work for per-sink trace ID allocations, so put a list in each queue where the IDs will be unique to that queue.

To keep the same behavior as before, for version 0 of the HW_ID packets, copy all the HW_ID mappings into all queues.

This change doesn't effect the decoders, only trace ID lookups on the Perf side. The decoders are still created with global mappings which will be fixed in a later commit.

---
 .../perf/util/cs-etm-decoder/cs-etm-decoder.c |  28 +--
 tools/perf/util/cs-etm.c                      | 195 ++++++++++--------
 tools/perf/util/cs-etm.h                      |   2 +-
 3 files changed, 126 insertions(+), 99 deletions(-)
tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +16 -12
index e917985bbbe6..0c9c48cedbf1 100644
@@ -388,7 +388,8 @@ cs_etm_decoder__reset_timestamp(struct cs_etm_packet_queue *packet_queue)
 }
 
 static ocsd_datapath_resp_t
-cs_etm_decoder__buffer_packet(struct cs_etm_packet_queue *packet_queue,
+cs_etm_decoder__buffer_packet(struct cs_etm_queue *etmq,
+			      struct cs_etm_packet_queue *packet_queue,
 			      const u8 trace_chan_id,
 			      enum cs_etm_sample_type sample_type)
 {
@@ -398,7 +399,7 @@ cs_etm_decoder__buffer_packet(struct cs_etm_packet_queue *packet_queue,
 	if (packet_queue->packet_count >= CS_ETM_PACKET_MAX_BUFFER - 1)
 		return OCSD_RESP_FATAL_SYS_ERR;
 
-	if (cs_etm__get_cpu(trace_chan_id, &cpu) < 0)
+	if (cs_etm__get_cpu(etmq, trace_chan_id, &cpu) < 0)
 		return OCSD_RESP_FATAL_SYS_ERR;
 
 	et = packet_queue->tail;
@@ -436,7 +437,7 @@ cs_etm_decoder__buffer_range(struct cs_etm_queue *etmq,
 	int ret = 0;
 	struct cs_etm_packet *packet;
 
-	ret = cs_etm_decoder__buffer_packet(packet_queue, trace_chan_id,
+	ret = cs_etm_decoder__buffer_packet(etmq, packet_queue, trace_chan_id,
 					    CS_ETM_RANGE);
 	if (ret != OCSD_RESP_CONT && ret != OCSD_RESP_WAIT)
 		return ret;
@@ -496,7 +497,8 @@ cs_etm_decoder__buffer_range(struct cs_etm_queue *etmq,
 }
 
 static ocsd_datapath_resp_t
-cs_etm_decoder__buffer_discontinuity(struct cs_etm_packet_queue *queue,
+cs_etm_decoder__buffer_discontinuity(struct cs_etm_queue *etmq,
+				     struct cs_etm_packet_queue *queue,
 				     const uint8_t trace_chan_id)
 {
 	/*
@@ -504,18 +506,19 @@ cs_etm_decoder__buffer_discontinuity(struct cs_etm_packet_queue *queue,
 	 * reset time statistics.
 	 */
 	cs_etm_decoder__reset_timestamp(queue);
-	return cs_etm_decoder__buffer_packet(queue, trace_chan_id,
+	return cs_etm_decoder__buffer_packet(etmq, queue, trace_chan_id,
 					     CS_ETM_DISCONTINUITY);
 }
 
 static ocsd_datapath_resp_t
-cs_etm_decoder__buffer_exception(struct cs_etm_packet_queue *queue,
+cs_etm_decoder__buffer_exception(struct cs_etm_queue *etmq,
+				 struct cs_etm_packet_queue *queue,
 				 const ocsd_generic_trace_elem *elem,
 				 const uint8_t trace_chan_id)
 {	int ret = 0;
 	struct cs_etm_packet *packet;
 
-	ret = cs_etm_decoder__buffer_packet(queue, trace_chan_id,
+	ret = cs_etm_decoder__buffer_packet(etmq, queue, trace_chan_id,
 					    CS_ETM_EXCEPTION);
 	if (ret != OCSD_RESP_CONT && ret != OCSD_RESP_WAIT)
 		return ret;
@@ -527,10 +530,11 @@ cs_etm_decoder__buffer_exception(struct cs_etm_packet_queue *queue,
 }
 
 static ocsd_datapath_resp_t
-cs_etm_decoder__buffer_exception_ret(struct cs_etm_packet_queue *queue,
+cs_etm_decoder__buffer_exception_ret(struct cs_etm_queue *etmq,
+				     struct cs_etm_packet_queue *queue,
 				     const uint8_t trace_chan_id)
 {
-	return cs_etm_decoder__buffer_packet(queue, trace_chan_id,
+	return cs_etm_decoder__buffer_packet(etmq, queue, trace_chan_id,
 					     CS_ETM_EXCEPTION_RET);
 }
 
@@ -599,7 +603,7 @@ static ocsd_datapath_resp_t cs_etm_decoder__gen_trace_elem_printer(
 	case OCSD_GEN_TRC_ELEM_EO_TRACE:
 	case OCSD_GEN_TRC_ELEM_NO_SYNC:
 	case OCSD_GEN_TRC_ELEM_TRACE_ON:
-		resp = cs_etm_decoder__buffer_discontinuity(packet_queue,
+		resp = cs_etm_decoder__buffer_discontinuity(etmq, packet_queue,
 							    trace_chan_id);
 		break;
 	case OCSD_GEN_TRC_ELEM_INSTR_RANGE:
@@ -607,11 +611,11 @@ static ocsd_datapath_resp_t cs_etm_decoder__gen_trace_elem_printer(
 						    trace_chan_id);
 		break;
 	case OCSD_GEN_TRC_ELEM_EXCEPTION:
-		resp = cs_etm_decoder__buffer_exception(packet_queue, elem,
+		resp = cs_etm_decoder__buffer_exception(etmq, packet_queue, elem,
 							trace_chan_id);
 		break;
 	case OCSD_GEN_TRC_ELEM_EXCEPTION_RET:
-		resp = cs_etm_decoder__buffer_exception_ret(packet_queue,
+		resp = cs_etm_decoder__buffer_exception_ret(etmq, packet_queue,
 							    trace_chan_id);
 		break;
 	case OCSD_GEN_TRC_ELEM_TIMESTAMP:
tools/perf/util/cs-etm.c +109 -86

337 lines not on this page · raw message

tools/perf/util/cs-etm.h +1 -1
index 4696267a32f0..f4f69f7cc0f3 100644
@@ -252,7 +252,7 @@ enum cs_etm_pid_fmt {
 
 #ifdef HAVE_CSTRACE_SUPPORT
 #include <opencsd/ocsd_if_types.h>
-int cs_etm__get_cpu(u8 trace_chan_id, int *cpu);
+int cs_etm__get_cpu(struct cs_etm_queue *etmq, u8 trace_chan_id, int *cpu);
 enum cs_etm_pid_fmt cs_etm__get_pid_fmt(struct cs_etm_queue *etmq);
 int cs_etm__etmq_set_tid_el(struct cs_etm_queue *etmq, pid_t tid,
 			    u8 trace_chan_id, ocsd_ex_level el);
Signature · 1 line
2.34.1
#8 lore raw

PATCH v2 6/16 perf: cs-etm: Create decoders based on the trace ID mappings

In reply to James Clark

Now that each queue has a unique set of trace ID mappings, use this list to create the decoders. This also works the same way for unformatted where a single dummy entry is added into the trace ID list.

Previously each queue would have a decoder created for each traced CPU on the system but this won't work anymore because CPUs can have overlapping trace IDs.

---
 tools/perf/util/cs-etm.c | 143 +++++++++++++++++++++++----------------
 1 file changed, 85 insertions(+), 58 deletions(-)
tools/perf/util/cs-etm.c +85 -58
index be858aed26c4..73fc0ab2fb09 100644
@@ -268,6 +268,10 @@ static int cs_etm__map_trace_id_v0(struct cs_etm_auxtrace *etm, u8 trace_chan_id
 		int ret;
 		struct cs_etm_queue *etmq = etm->queues.queue_array[i].priv;
 
+		/* Ignore HW_IDs on unformatted queues */
+		if (etmq->formatted_set && !etmq->formatted)
+			continue;
+
 		ret = cs_etm__insert_trace_id_node(etmq, trace_chan_id,
 						   cpu_metadata);
 		if (ret)
@@ -673,80 +677,58 @@ static void cs_etm__packet_dump(const char *pkt_string)
 }
 
 static void cs_etm__set_trace_param_etmv3(struct cs_etm_trace_params *t_params,
-					  struct cs_etm_auxtrace *etm, int t_idx,
-					  int m_idx, u32 etmidr)
+					  u64 *metadata, u32 etmidr)
 {
-	u64 **metadata = etm->metadata;
-
-	t_params[t_idx].protocol = cs_etm__get_v7_protocol_version(etmidr);
-	t_params[t_idx].etmv3.reg_ctrl = metadata[m_idx][CS_ETM_ETMCR];
-	t_params[t_idx].etmv3.reg_trc_id = metadata[m_idx][CS_ETM_ETMTRACEIDR];
+	t_params->protocol = cs_etm__get_v7_protocol_version(etmidr);
+	t_params->etmv3.reg_ctrl = metadata[CS_ETM_ETMCR];
+	t_params->etmv3.reg_trc_id = metadata[CS_ETM_ETMTRACEIDR];
 }
 
 static void cs_etm__set_trace_param_etmv4(struct cs_etm_trace_params *t_params,
-					  struct cs_etm_auxtrace *etm, int t_idx,
-					  int m_idx)
+					  u64 *metadata)
 {
-	u64 **metadata = etm->metadata;
-
-	t_params[t_idx].protocol = CS_ETM_PROTO_ETMV4i;
-	t_params[t_idx].etmv4.reg_idr0 = metadata[m_idx][CS_ETMV4_TRCIDR0];
-	t_params[t_idx].etmv4.reg_idr1 = metadata[m_idx][CS_ETMV4_TRCIDR1];
-	t_params[t_idx].etmv4.reg_idr2 = metadata[m_idx][CS_ETMV4_TRCIDR2];
-	t_params[t_idx].etmv4.reg_idr8 = metadata[m_idx][CS_ETMV4_TRCIDR8];
-	t_params[t_idx].etmv4.reg_configr = metadata[m_idx][CS_ETMV4_TRCCONFIGR];
-	t_params[t_idx].etmv4.reg_traceidr = metadata[m_idx][CS_ETMV4_TRCTRACEIDR];
+	t_params->protocol = CS_ETM_PROTO_ETMV4i;
+	t_params->etmv4.reg_idr0 = metadata[CS_ETMV4_TRCIDR0];
+	t_params->etmv4.reg_idr1 = metadata[CS_ETMV4_TRCIDR1];
+	t_params->etmv4.reg_idr2 = metadata[CS_ETMV4_TRCIDR2];
+	t_params->etmv4.reg_idr8 = metadata[CS_ETMV4_TRCIDR8];
+	t_params->etmv4.reg_configr = metadata[CS_ETMV4_TRCCONFIGR];
+	t_params->etmv4.reg_traceidr = metadata[CS_ETMV4_TRCTRACEIDR];
 }
 
 static void cs_etm__set_trace_param_ete(struct cs_etm_trace_params *t_params,
-					  struct cs_etm_auxtrace *etm, int t_idx,
-					  int m_idx)
+					u64 *metadata)
 {
-	u64 **metadata = etm->metadata;
-
-	t_params[t_idx].protocol = CS_ETM_PROTO_ETE;
-	t_params[t_idx].ete.reg_idr0 = metadata[m_idx][CS_ETE_TRCIDR0];
-	t_params[t_idx].ete.reg_idr1 = metadata[m_idx][CS_ETE_TRCIDR1];
-	t_params[t_idx].ete.reg_idr2 = metadata[m_idx][CS_ETE_TRCIDR2];
-	t_params[t_idx].ete.reg_idr8 = metadata[m_idx][CS_ETE_TRCIDR8];
-	t_params[t_idx].ete.reg_configr = metadata[m_idx][CS_ETE_TRCCONFIGR];
-	t_params[t_idx].ete.reg_traceidr = metadata[m_idx][CS_ETE_TRCTRACEIDR];
-	t_params[t_idx].ete.reg_devarch = metadata[m_idx][CS_ETE_TRCDEVARCH];
+	t_params->protocol = CS_ETM_PROTO_ETE;
+	t_params->ete.reg_idr0 = metadata[CS_ETE_TRCIDR0];
+	t_params->ete.reg_idr1 = metadata[CS_ETE_TRCIDR1];
+	t_params->ete.reg_idr2 = metadata[CS_ETE_TRCIDR2];
+	t_params->ete.reg_idr8 = metadata[CS_ETE_TRCIDR8];
+	t_params->ete.reg_configr = metadata[CS_ETE_TRCCONFIGR];
+	t_params->ete.reg_traceidr = metadata[CS_ETE_TRCTRACEIDR];
+	t_params->ete.reg_devarch = metadata[CS_ETE_TRCDEVARCH];
 }
 
 static int cs_etm__init_trace_params(struct cs_etm_trace_params *t_params,
-				     struct cs_etm_auxtrace *etm,
-				     bool formatted,
-				     int sample_cpu,
-				     int decoders)
-{
-	int t_idx, m_idx;
-	u32 etmidr;
-	u64 architecture;
-
-	for (t_idx = 0; t_idx < decoders; t_idx++) {
-		if (formatted)
-			m_idx = t_idx;
-		else {
-			m_idx = get_cpu_data_idx(etm, sample_cpu);
-			if (m_idx == -1) {
-				pr_warning("CS_ETM: unknown CPU, falling back to first metadata\n");
-				m_idx = 0;
-			}
-		}
+				     struct cs_etm_queue *etmq)
+{
+	struct int_node *inode;
 
-		architecture = etm->metadata[m_idx][CS_ETM_MAGIC];
+	intlist__for_each_entry(inode, etmq->traceid_list) {
+		u64 *metadata = inode->priv;
+		u64 architecture = metadata[CS_ETM_MAGIC];
+		u32 etmidr;
 
 		switch (architecture) {
 		case __perf_cs_etmv3_magic:
-			etmidr = etm->metadata[m_idx][CS_ETM_ETMIDR];
-			cs_etm__set_trace_param_etmv3(t_params, etm, t_idx, m_idx, etmidr);
+			etmidr = metadata[CS_ETM_ETMIDR];
+			cs_etm__set_trace_param_etmv3(t_params++, metadata, etmidr);
 			break;
 		case __perf_cs_etmv4_magic:
-			cs_etm__set_trace_param_etmv4(t_params, etm, t_idx, m_idx);
+			cs_etm__set_trace_param_etmv4(t_params++, metadata);
 			break;
 		case __perf_cs_ete_magic:
-			cs_etm__set_trace_param_ete(t_params, etm, t_idx, m_idx);
+			cs_etm__set_trace_param_ete(t_params++, metadata);
 			break;
 		default:
 			return -EINVAL;
@@ -2918,6 +2900,42 @@ static u64 *cs_etm__create_meta_blk(u64 *buff_in, int *buff_in_offset,
 	return metadata;
 }
 
+/*
+ * traceid_list is used to create decoders and give them the trace ID
+ * mappings. In unformatted mode just insert one entry for the sample
+ * CPU so the decoder knows which settings to use.
+ */
+static int cs_etm__map_trace_ids_unformatted(struct cs_etm_auxtrace *etm)
+{
+	for (unsigned int i = 0; i < etm->queues.nr_queues; ++i) {
+		int ret;
+		struct cs_etm_queue *etmq;
+		u8 trace_chan_id;
+		u64 *cpu_data;
+
+		etmq = etm->queues.queue_array[i].priv;
+		if (!etmq->formatted_set || etmq->formatted)
+			continue;
+
+		/* Giving it a real ID doesn't do much but can help with debugging */
+		trace_chan_id = CORESIGHT_LEGACY_CPU_TRACE_ID(i);
+		cpu_data = get_cpu_data(etm, i);
+		if (cpu_data == NULL) {
+			pr_warning("CS_ETM: unknown CPU, falling back to first metadata\n");
+			cpu_data = etm->metadata[0];
+		}
+
+		ret = cs_etm__insert_trace_id_node(etmq, trace_chan_id, cpu_data);
+		if (ret)
+			return ret;
+
+		ret = cs_etm__metadata_set_trace_id(trace_chan_id, cpu_data);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
 /**
  * Puts a fragment of an auxtrace buffer into the auxtrace queues based
  * on the bounds of aux_event, if it matches with the buffer that's at
@@ -3220,21 +3238,26 @@ static int cs_etm__clear_unused_trace_ids_metadata(int num_cpu, u64 **metadata)
 static int cs_etm__create_queue_decoders(struct cs_etm_queue *etmq)
 {
 	struct cs_etm_decoder_params d_params;
+	struct cs_etm_trace_params  *t_params;
+	int decoders = intlist__nr_entries(etmq->traceid_list);
 
 	/*
 	 * Each queue can only contain data from one CPU when unformatted, so only one decoder is
 	 * needed.
 	 */
-	int decoders = etmq->formatted ? etmq->etm->num_cpu : 1;
+	if (etmq->formatted_set && !etmq->formatted)
+		assert(decoders == 1);
+
+	if (decoders == 0)
+		return 0;
 
 	/* Use metadata to fill in trace parameters for trace decoder */
-	struct cs_etm_trace_params  *t_params = zalloc(sizeof(*t_params) * decoders);
+	t_params = zalloc(sizeof(*t_params) * decoders);
 
 	if (!t_params)
 		goto out_free;
 
-	if (cs_etm__init_trace_params(t_params, etmq->etm, etmq->formatted,
-				      etmq->queue_nr, decoders))
+	if (cs_etm__init_trace_params(t_params, etmq))
 		goto out_free;
 
 	/* Set decoder parameters to decode trace packets */
@@ -3497,6 +3520,10 @@ int cs_etm__process_auxtrace_info_full(union perf_event *event,
 	if (err)
 		goto err_free_queues;
 
+	err = cs_etm__map_trace_ids_unformatted(etm);
+	if (err)
+		goto err_free_queues;
+
 	err = cs_etm__create_decoders(etm);
 	if (err)
 		goto err_free_queues;
Signature · 1 line
2.34.1
#9 lore raw

PATCH v2 7/16 perf: cs-etm: Support version 0.1 of HW_ID packets

In reply to James Clark

v0.1 HW_ID packets have a new field that describes which sink each CPU writes to. Use the sink ID to link trace ID maps to each other so that mappings are shared wherever the sink is shared.

Also update the error message to show that overlapping IDs aren't an error in per-thread mode, just not supported. In the future we can use the CPU ID from the AUX records, or watch for changing sink IDs on HW_ID packets to use the correct decoders.

---
 tools/include/linux/coresight-pmu.h |  17 ++++-
 tools/perf/util/cs-etm.c            | 110 +++++++++++++++++++++++++---
 2 files changed, 113 insertions(+), 14 deletions(-)
tools/include/linux/coresight-pmu.h +13 -4
index 51ac441a37c3..89b0ac0014b0 100644
@@ -49,12 +49,21 @@
  * Interpretation of the PERF_RECORD_AUX_OUTPUT_HW_ID payload.
  * Used to associate a CPU with the CoreSight Trace ID.
  * [07:00] - Trace ID - uses 8 bits to make value easy to read in file.
- * [59:08] - Unused (SBZ)
- * [63:60] - Version
+ * [39:08] - Sink ID - as reported in /sys/bus/event_source/devices/cs_etm/sinks/
+ *	      Added in minor version 1.
+ * [55:40] - Unused (SBZ)
+ * [59:56] - Minor Version - previously existing fields are compatible with
+ *	      all minor versions.
+ * [63:60] - Major Version - previously existing fields mean different things
+ *	      in new major versions.
  */
 #define CS_AUX_HW_ID_TRACE_ID_MASK	GENMASK_ULL(7, 0)
-#define CS_AUX_HW_ID_VERSION_MASK	GENMASK_ULL(63, 60)
+#define CS_AUX_HW_ID_SINK_ID_MASK	GENMASK_ULL(39, 8)
 
-#define CS_AUX_HW_ID_CURR_VERSION 0
+#define CS_AUX_HW_ID_MINOR_VERSION_MASK	GENMASK_ULL(59, 56)
+#define CS_AUX_HW_ID_MAJOR_VERSION_MASK	GENMASK_ULL(63, 60)
+
+#define CS_AUX_HW_ID_MAJOR_VERSION 0
+#define CS_AUX_HW_ID_MINOR_VERSION 1
 
 #endif
tools/perf/util/cs-etm.c +100 -10

167 lines not on this page · raw message

Signature · 1 line
2.34.1
#10 lore raw

PATCH v2 8/16 coresight: Remove unused ETM Perf stubs

In reply to James Clark

This file is never included anywhere if CONFIG_CORESIGHT is not set so they are unused and aren't currently compile tested with any config so remove them.

---
 .../hwtracing/coresight/coresight-etm-perf.h   | 18 ------------------
 1 file changed, 18 deletions(-)
drivers/hwtracing/coresight/coresight-etm-perf.h +0 -18
index bebbadee2ceb..744531158d6b 100644
@@ -62,7 +62,6 @@ struct etm_event_data {
 	struct list_head * __percpu *path;
 };
 
-#if IS_ENABLED(CONFIG_CORESIGHT)
 int etm_perf_symlink(struct coresight_device *csdev, bool link);
 int etm_perf_add_symlink_sink(struct coresight_device *csdev);
 void etm_perf_del_symlink_sink(struct coresight_device *csdev);
@@ -77,23 +76,6 @@ static inline void *etm_perf_sink_config(struct perf_output_handle *handle)
 int etm_perf_add_symlink_cscfg(struct device *dev,
 			       struct cscfg_config_desc *config_desc);
 void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *config_desc);
-#else
-static inline int etm_perf_symlink(struct coresight_device *csdev, bool link)
-{ return -EINVAL; }
-int etm_perf_add_symlink_sink(struct coresight_device *csdev)
-{ return -EINVAL; }
-void etm_perf_del_symlink_sink(struct coresight_device *csdev) {}
-static inline void *etm_perf_sink_config(struct perf_output_handle *handle)
-{
-	return NULL;
-}
-int etm_perf_add_symlink_cscfg(struct device *dev,
-			       struct cscfg_config_desc *config_desc)
-{ return -EINVAL; }
-void etm_perf_del_symlink_cscfg(struct cscfg_config_desc *config_desc) {}
-
-#endif /* CONFIG_CORESIGHT */
-
 int __init etm_perf_init(void);
 void etm_perf_exit(void);
 
Signature · 1 line
2.34.1
#11 lore raw

PATCH v2 9/16 coresight: Clarify comments around the PID of the sink owner

In reply to James Clark

"Process being monitored" and "pid of the process to monitor" imply that this would be the same PID if there were two sessions targeting the same process. But this is actually the PID of the process that did the Perf event open call, rather than the target of the session. So update the comments to make this clearer.

---
 drivers/hwtracing/coresight/coresight-tmc-etr.c | 5 +++--
 drivers/hwtracing/coresight/coresight-tmc.h     | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)
drivers/hwtracing/coresight/coresight-tmc-etr.c +3 -2
index e75428fa1592..8962fc27d04f 100644
@@ -36,7 +36,8 @@ struct etr_buf_hw {
  * etr_perf_buffer - Perf buffer used for ETR
  * @drvdata		- The ETR drvdaga this buffer has been allocated for.
  * @etr_buf		- Actual buffer used by the ETR
- * @pid			- The PID this etr_perf_buffer belongs to.
+ * @pid			- The PID of the session owner that etr_perf_buffer
+ *			  belongs to.
  * @snaphost		- Perf session mode
  * @nr_pages		- Number of pages in the ring buffer.
  * @pages		- Array of Pages in the ring buffer.
@@ -1662,7 +1663,7 @@ static int tmc_enable_etr_sink_perf(struct coresight_device *csdev, void *data)
 		goto unlock_out;
 	}
 
-	/* Get a handle on the pid of the process to monitor */
+	/* Get a handle on the pid of the session owner */
 	pid = etr_perf->pid;
 
 	/* Do not proceed if this device is associated with another session */
drivers/hwtracing/coresight/coresight-tmc.h +3 -2
index c77763b49de0..2671926be62a 100644
@@ -171,8 +171,9 @@ struct etr_buf {
  * @csdev:	component vitals needed by the framework.
  * @miscdev:	specifics to handle "/dev/xyz.tmc" entry.
  * @spinlock:	only one at a time pls.
- * @pid:	Process ID of the process being monitored by the session
- *		that is using this component.
+ * @pid:	Process ID of the process that owns the session that is using
+ *		this component. For example this would be the pid of the Perf
+ *		process.
  * @buf:	Snapshot of the trace data for ETF/ETB.
  * @etr_buf:	details of buffer used in TMC-ETR
  * @len:	size of the available trace for ETF/ETB.
Signature · 1 line
2.34.1
#12 lore raw

PATCH v2 10/16 coresight: Move struct coresight_trace_id_map to common header

In reply to James Clark

The trace ID maps will need to be created and stored by the core and Perf code so move the definition up to the common header.

---
 .../hwtracing/coresight/coresight-trace-id.c  |  1 +
 .../hwtracing/coresight/coresight-trace-id.h  | 19 -------------------
 include/linux/coresight.h                     | 18 ++++++++++++++++++
 3 files changed, 19 insertions(+), 19 deletions(-)
drivers/hwtracing/coresight/coresight-trace-id.c +1 -0
index af5b4ef59cea..19005b5b4dc4 100644
@@ -3,6 +3,7 @@
  * Copyright (c) 2022, Linaro Limited, All rights reserved.
  * Author: Mike Leach <[email protected]>
  */
+#include <linux/coresight.h>
 #include <linux/coresight-pmu.h>
 #include <linux/cpumask.h>
 #include <linux/kernel.h>
drivers/hwtracing/coresight/coresight-trace-id.h +0 -19
index 3797777d367e..49438a96fcc6 100644
@@ -32,10 +32,6 @@
 #include <linux/bitops.h>
 #include <linux/types.h>
 
-
-/* architecturally we have 128 IDs some of which are reserved */
-#define CORESIGHT_TRACE_IDS_MAX 128
-
 /* ID 0 is reserved */
 #define CORESIGHT_TRACE_ID_RES_0 0
 
@@ -46,21 +42,6 @@
 #define IS_VALID_CS_TRACE_ID(id)	\
 	((id > CORESIGHT_TRACE_ID_RES_0) && (id < CORESIGHT_TRACE_ID_RES_TOP))
 
-/**
- * Trace ID map.
- *
- * @used_ids:	Bitmap to register available (bit = 0) and in use (bit = 1) IDs.
- *		Initialised so that the reserved IDs are permanently marked as
- *		in use.
- * @pend_rel_ids: CPU IDs that have been released by the trace source but not
- *		  yet marked as available, to allow re-allocation to the same
- *		  CPU during a perf session.
- */
-struct coresight_trace_id_map {
-	DECLARE_BITMAP(used_ids, CORESIGHT_TRACE_IDS_MAX);
-	DECLARE_BITMAP(pend_rel_ids, CORESIGHT_TRACE_IDS_MAX);
-};
-
 /* Allocate and release IDs for a single default trace ID map */
 
 /**
include/linux/coresight.h +18 -0
index f09ace92176e..c16c61a8411d 100644
@@ -218,6 +218,24 @@ struct coresight_sysfs_link {
 	const char *target_name;
 };
 
+/* architecturally we have 128 IDs some of which are reserved */
+#define CORESIGHT_TRACE_IDS_MAX 128
+
+/**
+ * Trace ID map.
+ *
+ * @used_ids:	Bitmap to register available (bit = 0) and in use (bit = 1) IDs.
+ *		Initialised so that the reserved IDs are permanently marked as
+ *		in use.
+ * @pend_rel_ids: CPU IDs that have been released by the trace source but not
+ *		  yet marked as available, to allow re-allocation to the same
+ *		  CPU during a perf session.
+ */
+struct coresight_trace_id_map {
+	DECLARE_BITMAP(used_ids, CORESIGHT_TRACE_IDS_MAX);
+	DECLARE_BITMAP(pend_rel_ids, CORESIGHT_TRACE_IDS_MAX);
+};
+
 /**
  * struct coresight_device - representation of a device as used by the framework
  * @pdata:	Platform data with device connections associated to this device.
Signature · 1 line
2.34.1
#13 lore raw

PATCH v2 11/16 coresight: Expose map arguments in trace ID API

In reply to James Clark

The trace ID API is currently hard coded to always use the global map. Add public versions that allow the map to be passed in so that Perf mode can use per-sink maps. Keep the non-map versions so that sysfs mode can continue to use the default global map.

System ID functions are unchanged because they will always use the default map.

---
 .../hwtracing/coresight/coresight-trace-id.c  | 36 ++++++++++++++-----
 .../hwtracing/coresight/coresight-trace-id.h  | 20 +++++++++--
 2 files changed, 45 insertions(+), 11 deletions(-)
drivers/hwtracing/coresight/coresight-trace-id.c +27 -9
index 19005b5b4dc4..5561989a03fa 100644
@@ -12,7 +12,7 @@
 
 #include "coresight-trace-id.h"
 
-/* Default trace ID map. Used on systems that don't require per sink mappings */
+/* Default trace ID map. Used in sysfs mode and for system sources */
 static struct coresight_trace_id_map id_map_default;
 
 /* maintain a record of the mapping of IDs and pending releases per cpu */
@@ -47,7 +47,7 @@ static void coresight_trace_id_dump_table(struct coresight_trace_id_map *id_map,
 #endif
 
 /* unlocked read of current trace ID value for given CPU */
-static int _coresight_trace_id_read_cpu_id(int cpu)
+static int _coresight_trace_id_read_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
 {
 	return atomic_read(&per_cpu(cpu_id, cpu));
 }
@@ -152,7 +152,7 @@ static void coresight_trace_id_release_all_pending(void)
 	DUMP_ID_MAP(id_map);
 }
 
-static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
+static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
 {
 	unsigned long flags;
 	int id;
@@ -160,7 +160,7 @@ static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_
 	spin_lock_irqsave(&id_map_lock, flags);
 
 	/* check for existing allocation for this CPU */
-	id = _coresight_trace_id_read_cpu_id(cpu);
+	id = _coresight_trace_id_read_cpu_id(cpu, id_map);
 	if (id)
 		goto get_cpu_id_clr_pend;
 
@@ -196,13 +196,13 @@ static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_
 	return id;
 }
 
-static void coresight_trace_id_map_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
+static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
 {
 	unsigned long flags;
 	int id;
 
 	/* check for existing allocation for this CPU */
-	id = _coresight_trace_id_read_cpu_id(cpu);
+	id = _coresight_trace_id_read_cpu_id(cpu, id_map);
 	if (!id)
 		return;
 
@@ -254,22 +254,40 @@ static void coresight_trace_id_map_put_system_id(struct coresight_trace_id_map *
 
 int coresight_trace_id_get_cpu_id(int cpu)
 {
-	return coresight_trace_id_map_get_cpu_id(cpu, &id_map_default);
+	return _coresight_trace_id_get_cpu_id(cpu, &id_map_default);
 }
 EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id);
 
+int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
+{
+	return _coresight_trace_id_get_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id_map);
+
 void coresight_trace_id_put_cpu_id(int cpu)
 {
-	coresight_trace_id_map_put_cpu_id(cpu, &id_map_default);
+	_coresight_trace_id_put_cpu_id(cpu, &id_map_default);
 }
 EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id);
 
+void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
+{
+	_coresight_trace_id_put_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id_map);
+
 int coresight_trace_id_read_cpu_id(int cpu)
 {
-	return _coresight_trace_id_read_cpu_id(cpu);
+	return _coresight_trace_id_read_cpu_id(cpu, &id_map_default);
 }
 EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id);
 
+int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
+{
+	return _coresight_trace_id_read_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id_map);
+
 int coresight_trace_id_get_system_id(void)
 {
 	return coresight_trace_id_map_get_system_id(&id_map_default);
drivers/hwtracing/coresight/coresight-trace-id.h +18 -2
index 49438a96fcc6..840babdd0794 100644
@@ -42,8 +42,6 @@
 #define IS_VALID_CS_TRACE_ID(id)	\
 	((id > CORESIGHT_TRACE_ID_RES_0) && (id < CORESIGHT_TRACE_ID_RES_TOP))
 
-/* Allocate and release IDs for a single default trace ID map */
-
 /**
  * Read and optionally allocate a CoreSight trace ID and associate with a CPU.
  *
@@ -59,6 +57,12 @@
  */
 int coresight_trace_id_get_cpu_id(int cpu);
 
+/**
+ * Version of coresight_trace_id_get_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
 /**
  * Release an allocated trace ID associated with the CPU.
  *
@@ -72,6 +76,12 @@ int coresight_trace_id_get_cpu_id(int cpu);
  */
 void coresight_trace_id_put_cpu_id(int cpu);
 
+/**
+ * Version of coresight_trace_id_put_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
 /**
  * Read the current allocated CoreSight Trace ID value for the CPU.
  *
@@ -92,6 +102,12 @@ void coresight_trace_id_put_cpu_id(int cpu);
  */
 int coresight_trace_id_read_cpu_id(int cpu);
 
+/**
+ * Version of coresight_trace_id_read_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
 /**
  * Allocate a CoreSight trace ID for a system component.
  *
Signature · 1 line
2.34.1
maintainer
#14 lore raw

Re: [PATCH v2 11/16] coresight: Expose map arguments in trace ID API

Quoted 46 lines · James Clark

The trace ID API is currently hard coded to always use the global map. Add public versions that allow the map to be passed in so that Perf mode can use per-sink maps. Keep the non-map versions so that sysfs mode can continue to use the default global map.

System ID functions are unchanged because they will always use the default map.

---
  .../hwtracing/coresight/coresight-trace-id.c  | 36 ++++++++++++++-----
  .../hwtracing/coresight/coresight-trace-id.h  | 20 +++++++++--
  2 files changed, 45 insertions(+), 11 deletions(-)
drivers/hwtracing/coresight/coresight-trace-id.c +3 -3
index 19005b5b4dc4..5561989a03fa 100644
@@ -12,7 +12,7 @@
 
  #include "coresight-trace-id.h"
 
-/* Default trace ID map. Used on systems that don't require per sink mappings */
+/* Default trace ID map. Used in sysfs mode and for system sources */
  static struct coresight_trace_id_map id_map_default;
 
  /* maintain a record of the mapping of IDs and pending releases per cpu */
@@ -47,7 +47,7 @@ static void coresight_trace_id_dump_table(struct coresight_trace_id_map *id_map,
  #endif
 
  /* unlocked read of current trace ID value for given CPU */
-static int _coresight_trace_id_read_cpu_id(int cpu)
+static int _coresight_trace_id_read_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
  {
  	return atomic_read(&per_cpu(cpu_id, cpu));
  }
@@ -152,7 +152,7 @@ static void coresight_trace_id_release_all_pending(void)
  	DUMP_ID_MAP(id_map);
  }
 
-static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
+static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
  {
  	unsigned long flags;
  	int id;

drivers/hwtracing/coresight/coresight-trace-id.c static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_ · line 160

Quoted 1 line
drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
@@ -160,7 +160,7 @@ static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_
  	spin_lock_irqsave(&id_map_lock, flags);

Could we also reduce the contention on the id_map_lock, by moving the spinlock per map ? It can be a separate patch.

This patch as such looks good to me.

Suzuki

Quoted 119 lines
drivers/hwtracing/coresight/coresight-trace-id.c +24 -6
  	/* check for existing allocation for this CPU */
-	id = _coresight_trace_id_read_cpu_id(cpu);
+	id = _coresight_trace_id_read_cpu_id(cpu, id_map);
  	if (id)
  		goto get_cpu_id_clr_pend;
 
@@ -196,13 +196,13 @@ static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_
  	return id;
  }
 
-static void coresight_trace_id_map_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
+static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
  {
  	unsigned long flags;
  	int id;
 
  	/* check for existing allocation for this CPU */
-	id = _coresight_trace_id_read_cpu_id(cpu);
+	id = _coresight_trace_id_read_cpu_id(cpu, id_map);
  	if (!id)
  		return;
 
@@ -254,22 +254,40 @@ static void coresight_trace_id_map_put_system_id(struct coresight_trace_id_map *
 
  int coresight_trace_id_get_cpu_id(int cpu)
  {
-	return coresight_trace_id_map_get_cpu_id(cpu, &id_map_default);
+	return _coresight_trace_id_get_cpu_id(cpu, &id_map_default);
  }
  EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id);
 
+int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
+{
+	return _coresight_trace_id_get_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id_map);
+
  void coresight_trace_id_put_cpu_id(int cpu)
  {
-	coresight_trace_id_map_put_cpu_id(cpu, &id_map_default);
+	_coresight_trace_id_put_cpu_id(cpu, &id_map_default);
  }
  EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id);
 
+void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
+{
+	_coresight_trace_id_put_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id_map);
+
  int coresight_trace_id_read_cpu_id(int cpu)
  {
-	return _coresight_trace_id_read_cpu_id(cpu);
+	return _coresight_trace_id_read_cpu_id(cpu, &id_map_default);
  }
  EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id);
 
+int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)
+{
+	return _coresight_trace_id_read_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id_map);
+
  int coresight_trace_id_get_system_id(void)
  {
  	return coresight_trace_id_map_get_system_id(&id_map_default);
drivers/hwtracing/coresight/coresight-trace-id.h +18 -2
index 49438a96fcc6..840babdd0794 100644
@@ -42,8 +42,6 @@
  #define IS_VALID_CS_TRACE_ID(id)	\
  	((id > CORESIGHT_TRACE_ID_RES_0) && (id < CORESIGHT_TRACE_ID_RES_TOP))
 
-/* Allocate and release IDs for a single default trace ID map */
-
  /**
   * Read and optionally allocate a CoreSight trace ID and associate with a CPU.
   *
@@ -59,6 +57,12 @@
   */
  int coresight_trace_id_get_cpu_id(int cpu);
 
+/**
+ * Version of coresight_trace_id_get_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
  /**
   * Release an allocated trace ID associated with the CPU.
   *
@@ -72,6 +76,12 @@ int coresight_trace_id_get_cpu_id(int cpu);
   */
  void coresight_trace_id_put_cpu_id(int cpu);
 
+/**
+ * Version of coresight_trace_id_put_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
  /**
   * Read the current allocated CoreSight Trace ID value for the CPU.
   *
@@ -92,6 +102,12 @@ void coresight_trace_id_put_cpu_id(int cpu);
   */
  int coresight_trace_id_read_cpu_id(int cpu);
 
+/**
+ * Version of coresight_trace_id_read_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
  /**
   * Allocate a CoreSight trace ID for a system component.
   *
#15 lore raw

Re: [PATCH v2 11/16] coresight: Expose map arguments in trace ID API

Quoted 56 lines · Suzuki K Poulose
Quoted 49 lines · James Clark

The trace ID API is currently hard coded to always use the global map. Add public versions that allow the map to be passed in so that Perf mode can use per-sink maps. Keep the non-map versions so that sysfs mode can continue to use the default global map.

System ID functions are unchanged because they will always use the default map.

---
  .../hwtracing/coresight/coresight-trace-id.c  | 36 ++++++++++++++----- .../hwtracing/coresight/coresight-trace-id.h  | 20 +++++++++--

  2 files changed, 45 insertions(+), 11 deletions(-)
drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
index 19005b5b4dc4..5561989a03fa 100644
@@ -12,7 +12,7 @@
     #include "coresight-trace-id.h"

  -/* Default trace ID map. Used on systems that don't require per sink mappings */
+/* Default trace ID map. Used in sysfs mode and for system sources */ static struct coresight_trace_id_map id_map_default;
    /* maintain a record of the mapping of IDs and pending releases per cpu */

drivers/hwtracing/coresight/coresight-trace-id.c +1 -1
@@ -47,7 +47,7 @@ static void coresight_trace_id_dump_table(struct
 coresight_trace_id_map *id_map,
   #endif
     /* unlocked read of current trace ID value for given CPU */
-static int _coresight_trace_id_read_cpu_id(int cpu)
+static int _coresight_trace_id_read_cpu_id(int cpu, struct
 coresight_trace_id_map *id_map)
   {
       return atomic_read(&per_cpu(cpu_id, cpu));

  }

drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
@@ -152,7 +152,7 @@ static void
 coresight_trace_id_release_all_pending(void)
       DUMP_ID_MAP(id_map);
   }

  -static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
+static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
  {
      unsigned long flags;
      int id;

drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
@@ -160,7 +160,7 @@ static int coresight_trace_id_map_get_cpu_id(int
Quoted 2 lines

cpu, struct coresight_trace_id_
      spin_lock_irqsave(&id_map_lock, flags);

Could we also reduce the contention on the id_map_lock, by moving the spinlock per map ? It can be a separate patch.

Quoted 5 lines

This patch as such looks good to me.

Suzuki

Good point yes we can do that.

Quoted 123 lines
Quoted 122 lines

        /* check for existing allocation for this CPU */
-    id = _coresight_trace_id_read_cpu_id(cpu);
+    id = _coresight_trace_id_read_cpu_id(cpu, id_map);
      if (id)
          goto get_cpu_id_clr_pend;
  @@ -196,13 +196,13 @@ static int coresight_trace_id_map_get_cpu_id(int cpu, struct coresight_trace_id_ return id;
  }
  -static void coresight_trace_id_map_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
+static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
  {
      unsigned long flags;
      int id;
        /* check for existing allocation for this CPU */
-    id = _coresight_trace_id_read_cpu_id(cpu);
+    id = _coresight_trace_id_read_cpu_id(cpu, id_map);
      if (!id)
          return;
  @@ -254,22 +254,40 @@ static void coresight_trace_id_map_put_system_id(struct coresight_trace_id_map * int coresight_trace_id_get_cpu_id(int cpu)
  {
-    return coresight_trace_id_map_get_cpu_id(cpu, &id_map_default); +    return _coresight_trace_id_get_cpu_id(cpu, &id_map_default); }
  EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id);
  +int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)

drivers/hwtracing/coresight/coresight-trace-id.c +5 -0
+{
+    return _coresight_trace_id_get_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_get_cpu_id_map);
+

  void coresight_trace_id_put_cpu_id(int cpu)
  {
-    coresight_trace_id_map_put_cpu_id(cpu, &id_map_default); +    _coresight_trace_id_put_cpu_id(cpu, &id_map_default); } EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id); +void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)

drivers/hwtracing/coresight/coresight-trace-id.c +5 -0
+{
+    _coresight_trace_id_put_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_put_cpu_id_map);
+

  int coresight_trace_id_read_cpu_id(int cpu)
  {
-    return _coresight_trace_id_read_cpu_id(cpu);
+    return _coresight_trace_id_read_cpu_id(cpu, &id_map_default); }
  EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id); +int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map)

drivers/hwtracing/coresight/coresight-trace-id.c +5 -0
+{
+    return _coresight_trace_id_read_cpu_id(cpu, id_map);
+}
+EXPORT_SYMBOL_GPL(coresight_trace_id_read_cpu_id_map);
+

  int coresight_trace_id_get_system_id(void)
  {
      return coresight_trace_id_map_get_system_id(&id_map_default);

drivers/hwtracing/coresight/coresight-trace-id.h +0 -0
index 49438a96fcc6..840babdd0794 100644
@@ -42,8 +42,6 @@
   #define IS_VALID_CS_TRACE_ID(id)    \

      ((id > CORESIGHT_TRACE_ID_RES_0) && (id < CORESIGHT_TRACE_ID_RES_TOP))
  -/* Allocate and release IDs for a single default trace ID map */ -
  /**
   * Read and optionally allocate a CoreSight trace ID and associate with a CPU.
   *

drivers/hwtracing/coresight/coresight-trace-id.h +0 -0
@@ -59,6 +57,12 @@
    */
   int coresight_trace_id_get_cpu_id(int cpu);

  +/**
+ * Version of coresight_trace_id_get_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
  /**
   * Release an allocated trace ID associated with the CPU. *

drivers/hwtracing/coresight/coresight-trace-id.h +0 -0
@@ -72,6 +76,12 @@ int coresight_trace_id_get_cpu_id(int cpu);
    */
   void coresight_trace_id_put_cpu_id(int cpu);

  +/**
+ * Version of coresight_trace_id_put_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+void coresight_trace_id_put_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
  /**
   * Read the current allocated CoreSight Trace ID value for the CPU. *

drivers/hwtracing/coresight/coresight-trace-id.h +0 -0
@@ -92,6 +102,12 @@ void coresight_trace_id_put_cpu_id(int cpu);
    */
   int coresight_trace_id_read_cpu_id(int cpu);

  +/**
+ * Version of coresight_trace_id_read_cpu_id() that allows the ID map to operate
+ * on to be provided.
+ */
+int coresight_trace_id_read_cpu_id_map(int cpu, struct coresight_trace_id_map *id_map);
+
  /**
   * Allocate a CoreSight trace ID for a system component. *

#16 lore raw

PATCH v2 12/16 coresight: Make CPU id map a property of a trace ID map

In reply to James Clark

The global CPU ID mappings won't work for per-sink ID maps so move it to the ID map struct. coresight_trace_id_release_all_pending() is hard coded to operate on the default map, but once Perf sessions use their own maps the pending release mechanism will be deleted. So it doesn't need to be extended to accept a trace ID map argument at this point.

---
 drivers/hwtracing/coresight/coresight-trace-id.c | 16 +++++++++-------
 include/linux/coresight.h                        |  1 +
 2 files changed, 10 insertions(+), 7 deletions(-)
drivers/hwtracing/coresight/coresight-trace-id.c +9 -7
index 5561989a03fa..8a777c0af6ea 100644
@@ -13,10 +13,12 @@
 #include "coresight-trace-id.h"
 
 /* Default trace ID map. Used in sysfs mode and for system sources */
-static struct coresight_trace_id_map id_map_default;
+static DEFINE_PER_CPU(atomic_t, id_map_default_cpu_ids) = ATOMIC_INIT(0);
+static struct coresight_trace_id_map id_map_default = {
+	.cpu_map = &id_map_default_cpu_ids
+};
 
-/* maintain a record of the mapping of IDs and pending releases per cpu */
-static DEFINE_PER_CPU(atomic_t, cpu_id) = ATOMIC_INIT(0);
+/* maintain a record of the pending releases per cpu */
 static cpumask_t cpu_id_release_pending;
 
 /* perf session active counter */
@@ -49,7 +51,7 @@ static void coresight_trace_id_dump_table(struct coresight_trace_id_map *id_map,
 /* unlocked read of current trace ID value for given CPU */
 static int _coresight_trace_id_read_cpu_id(int cpu, struct coresight_trace_id_map *id_map)
 {
-	return atomic_read(&per_cpu(cpu_id, cpu));
+	return atomic_read(per_cpu_ptr(id_map->cpu_map, cpu));
 }
 
 /* look for next available odd ID, return 0 if none found */
@@ -145,7 +147,7 @@ static void coresight_trace_id_release_all_pending(void)
 		clear_bit(bit, id_map->pend_rel_ids);
 	}
 	for_each_cpu(cpu, &cpu_id_release_pending) {
-		atomic_set(&per_cpu(cpu_id, cpu), 0);
+		atomic_set(per_cpu_ptr(id_map_default.cpu_map, cpu), 0);
 		cpumask_clear_cpu(cpu, &cpu_id_release_pending);
 	}
 	spin_unlock_irqrestore(&id_map_lock, flags);
@@ -181,7 +183,7 @@ static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map
 		goto get_cpu_id_out_unlock;
 
 	/* allocate the new id to the cpu */
-	atomic_set(&per_cpu(cpu_id, cpu), id);
+	atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), id);
 
 get_cpu_id_clr_pend:
 	/* we are (re)using this ID - so ensure it is not marked for release */
@@ -215,7 +217,7 @@ static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_ma
 	} else {
 		/* otherwise clear id */
 		coresight_trace_id_free(id, id_map);
-		atomic_set(&per_cpu(cpu_id, cpu), 0);
+		atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);
 	}
 
 	spin_unlock_irqrestore(&id_map_lock, flags);
include/linux/coresight.h +1 -0
index c16c61a8411d..7d62b88bfb5c 100644
@@ -234,6 +234,7 @@ struct coresight_sysfs_link {
 struct coresight_trace_id_map {
 	DECLARE_BITMAP(used_ids, CORESIGHT_TRACE_IDS_MAX);
 	DECLARE_BITMAP(pend_rel_ids, CORESIGHT_TRACE_IDS_MAX);
+	atomic_t __percpu *cpu_map;
 };
 
 /**
Signature · 1 line
2.34.1
#17 lore raw

PATCH v2 13/16 coresight: Use per-sink trace ID maps for Perf sessions

In reply to James Clark

This will allow sessions with more than CORESIGHT_TRACE_IDS_MAX ETMs as long as there are fewer than that many ETMs connected to each sink.

Each sink owns its own trace ID map, and any Perf session connecting to that sink will allocate from it, even if the sink is currently in use by other users. This is similar to the existing behavior where the dynamic trace IDs are constant as long as there is any concurrent Perf session active. It's not completely optimal because slightly more IDs will be used than necessary, but the optimal solution involves tracking the PIDs of each session and allocating ID maps based on the session owner. This is difficult to do with the combination of per-thread and per-cpu modes and some scheduling issues. The complexity of this isn't likely to worth it because even with multiple users they'd just see a difference in the ordering of ID allocations rather than hitting any limits (unless the hardware does have too many ETMs connected to one sink).

---
 drivers/hwtracing/coresight/coresight-core.c      | 10 ++++++++++
 drivers/hwtracing/coresight/coresight-dummy.c     |  3 ++-
 drivers/hwtracing/coresight/coresight-etm-perf.c  | 15 ++++++++++-----
 .../hwtracing/coresight/coresight-etm3x-core.c    |  9 +++++----
 .../hwtracing/coresight/coresight-etm4x-core.c    |  9 +++++----
 drivers/hwtracing/coresight/coresight-stm.c       |  3 ++-
 drivers/hwtracing/coresight/coresight-sysfs.c     |  3 ++-
 drivers/hwtracing/coresight/coresight-tpdm.c      |  3 ++-
 include/linux/coresight.h                         |  3 ++-
 9 files changed, 40 insertions(+), 18 deletions(-)
drivers/hwtracing/coresight/coresight-core.c +10 -0
index 9fc6f6b863e0..d5aaeafe5c7d 100644
@@ -902,6 +902,7 @@ static void coresight_device_release(struct device *dev)
 	struct coresight_device *csdev = to_coresight_device(dev);
 
 	fwnode_handle_put(csdev->dev.fwnode);
+	free_percpu(csdev->perf_sink_id_map.cpu_map);
 	kfree(csdev);
 }
 
@@ -1159,6 +1160,14 @@ struct coresight_device *coresight_register(struct coresight_desc *desc)
 	csdev->dev.fwnode = fwnode_handle_get(dev_fwnode(desc->dev));
 	dev_set_name(&csdev->dev, "%s", desc->name);
 
+	if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
+	    csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
+		csdev->perf_sink_id_map.cpu_map = alloc_percpu(atomic_t);
+		if (!csdev->perf_sink_id_map.cpu_map) {
+			ret = -ENOMEM;
+			goto err_out;
+		}
+	}
 	/*
 	 * Make sure the device registration and the connection fixup
 	 * are synchronised, so that we don't see uninitialised devices
@@ -1216,6 +1225,7 @@ struct coresight_device *coresight_register(struct coresight_desc *desc)
 err_out:
 	/* Cleanup the connection information */
 	coresight_release_platform_data(NULL, desc->dev, desc->pdata);
+	kfree(csdev);
 	return ERR_PTR(ret);
 }
 EXPORT_SYMBOL_GPL(coresight_register);
drivers/hwtracing/coresight/coresight-dummy.c +2 -1
index ac70c0b491be..1f1b9ad160f6 100644
@@ -21,7 +21,8 @@ DEFINE_CORESIGHT_DEVLIST(source_devs, "dummy_source");
 DEFINE_CORESIGHT_DEVLIST(sink_devs, "dummy_sink");
 
 static int dummy_source_enable(struct coresight_device *csdev,
-			       struct perf_event *event, enum cs_mode mode)
+			       struct perf_event *event, enum cs_mode mode,
+			       __maybe_unused struct coresight_trace_id_map *id_map)
 {
 	dev_dbg(csdev->dev.parent, "Dummy source enabled\n");
 
drivers/hwtracing/coresight/coresight-etm-perf.c +10 -5
index c0c60e6a1703..7fb55dafb639 100644
@@ -229,10 +229,13 @@ static void free_event_data(struct work_struct *work)
 		struct list_head **ppath;
 
 		ppath = etm_event_cpu_path_ptr(event_data, cpu);
-		if (!(IS_ERR_OR_NULL(*ppath)))
+		if (!(IS_ERR_OR_NULL(*ppath))) {
+			struct coresight_device *sink = coresight_get_sink(*ppath);
+
+			coresight_trace_id_put_cpu_id_map(cpu, &sink->perf_sink_id_map);
 			coresight_release_path(*ppath);
+		}
 		*ppath = NULL;
-		coresight_trace_id_put_cpu_id(cpu);
 	}
 
 	/* mark perf event as done for trace id allocator */
@@ -401,7 +404,7 @@ static void *etm_setup_aux(struct perf_event *event, void **pages,
 		}
 
 		/* ensure we can allocate a trace ID for this CPU */
-		trace_id = coresight_trace_id_get_cpu_id(cpu);
+		trace_id = coresight_trace_id_get_cpu_id_map(cpu, &sink->perf_sink_id_map);
 		if (!IS_VALID_CS_TRACE_ID(trace_id)) {
 			cpumask_clear_cpu(cpu, mask);
 			coresight_release_path(path);
@@ -495,7 +498,8 @@ static void etm_event_start(struct perf_event *event, int flags)
 		goto fail_end_stop;
 
 	/* Finally enable the tracer */
-	if (source_ops(csdev)->enable(csdev, event, CS_MODE_PERF))
+	if (source_ops(csdev)->enable(csdev, event, CS_MODE_PERF,
+				      &sink->perf_sink_id_map))
 		goto fail_disable_path;
 
 	/*
@@ -507,7 +511,8 @@ static void etm_event_start(struct perf_event *event, int flags)
 		hw_id = FIELD_PREP(CS_AUX_HW_ID_VERSION_MASK,
 				   CS_AUX_HW_ID_CURR_VERSION);
 		hw_id |= FIELD_PREP(CS_AUX_HW_ID_TRACE_ID_MASK,
-				    coresight_trace_id_read_cpu_id(cpu));
+				    coresight_trace_id_read_cpu_id_map(cpu,
+								       &sink->perf_sink_id_map));
 		perf_report_aux_output_id(event, hw_id);
 	}
 
drivers/hwtracing/coresight/coresight-etm3x-core.c +5 -4
index 9d5c1391ffb1..65cf7456426a 100644
@@ -481,7 +481,8 @@ void etm_release_trace_id(struct etm_drvdata *drvdata)
 }
 
 static int etm_enable_perf(struct coresight_device *csdev,
-			   struct perf_event *event)
+			   struct perf_event *event,
+			   struct coresight_trace_id_map *id_map)
 {
 	struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 	int trace_id;
@@ -500,7 +501,7 @@ static int etm_enable_perf(struct coresight_device *csdev,
 	 * with perf locks - we know the ID cannot change until perf shuts down
 	 * the session
 	 */
-	trace_id = coresight_trace_id_read_cpu_id(drvdata->cpu);
+	trace_id = coresight_trace_id_read_cpu_id_map(drvdata->cpu, id_map);
 	if (!IS_VALID_CS_TRACE_ID(trace_id)) {
 		dev_err(&drvdata->csdev->dev, "Failed to set trace ID for %s on CPU%d\n",
 			dev_name(&drvdata->csdev->dev), drvdata->cpu);
@@ -553,7 +554,7 @@ static int etm_enable_sysfs(struct coresight_device *csdev)
 }
 
 static int etm_enable(struct coresight_device *csdev, struct perf_event *event,
-		      enum cs_mode mode)
+		      enum cs_mode mode, struct coresight_trace_id_map *id_map)
 {
 	int ret;
 	struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
@@ -568,7 +569,7 @@ static int etm_enable(struct coresight_device *csdev, struct perf_event *event,
 		ret = etm_enable_sysfs(csdev);
 		break;
 	case CS_MODE_PERF:
-		ret = etm_enable_perf(csdev, event);
+		ret = etm_enable_perf(csdev, event, id_map);
 		break;
 	default:
 		ret = -EINVAL;
drivers/hwtracing/coresight/coresight-etm4x-core.c +5 -4
index a0bdfabddbc6..fcd0f9ba562d 100644
@@ -752,7 +752,8 @@ static int etm4_parse_event_config(struct coresight_device *csdev,
 }
 
 static int etm4_enable_perf(struct coresight_device *csdev,
-			    struct perf_event *event)
+			    struct perf_event *event,
+			    struct coresight_trace_id_map *id_map)
 {
 	int ret = 0, trace_id;
 	struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
@@ -775,7 +776,7 @@ static int etm4_enable_perf(struct coresight_device *csdev,
 	 * with perf locks - we know the ID cannot change until perf shuts down
 	 * the session
 	 */
-	trace_id = coresight_trace_id_read_cpu_id(drvdata->cpu);
+	trace_id = coresight_trace_id_read_cpu_id_map(drvdata->cpu, id_map);
 	if (!IS_VALID_CS_TRACE_ID(trace_id)) {
 		dev_err(&drvdata->csdev->dev, "Failed to set trace ID for %s on CPU%d\n",
 			dev_name(&drvdata->csdev->dev), drvdata->cpu);
@@ -837,7 +838,7 @@ static int etm4_enable_sysfs(struct coresight_device *csdev)
 }
 
 static int etm4_enable(struct coresight_device *csdev, struct perf_event *event,
-		       enum cs_mode mode)
+		       enum cs_mode mode, struct coresight_trace_id_map *id_map)
 {
 	int ret;
 
@@ -851,7 +852,7 @@ static int etm4_enable(struct coresight_device *csdev, struct perf_event *event,
 		ret = etm4_enable_sysfs(csdev);
 		break;
 	case CS_MODE_PERF:
-		ret = etm4_enable_perf(csdev, event);
+		ret = etm4_enable_perf(csdev, event, id_map);
 		break;
 	default:
 		ret = -EINVAL;
drivers/hwtracing/coresight/coresight-stm.c +2 -1
index e1c62820dfda..a80ad1de4c23 100644
@@ -194,7 +194,8 @@ static void stm_enable_hw(struct stm_drvdata *drvdata)
 }
 
 static int stm_enable(struct coresight_device *csdev, struct perf_event *event,
-		      enum cs_mode mode)
+		      enum cs_mode mode,
+		      __maybe_unused struct coresight_trace_id_map *trace_id)
 {
 	struct stm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 
drivers/hwtracing/coresight/coresight-sysfs.c +2 -1
index 1e67cc7758d7..a01c9e54e2ed 100644
@@ -9,6 +9,7 @@
 #include <linux/kernel.h>
 
 #include "coresight-priv.h"
+#include "coresight-trace-id.h"
 
 /*
  * Use IDR to map the hash of the source's device name
@@ -63,7 +64,7 @@ static int coresight_enable_source_sysfs(struct coresight_device *csdev,
 	 */
 	lockdep_assert_held(&coresight_mutex);
 	if (coresight_get_mode(csdev) != CS_MODE_SYSFS) {
-		ret = source_ops(csdev)->enable(csdev, data, mode);
+		ret = source_ops(csdev)->enable(csdev, data, mode, NULL);
 		if (ret)
 			return ret;
 	}
drivers/hwtracing/coresight/coresight-tpdm.c +2 -1
index a9708ab0d488..0376ad326a2f 100644
@@ -439,7 +439,8 @@ static void __tpdm_enable(struct tpdm_drvdata *drvdata)
 }
 
 static int tpdm_enable(struct coresight_device *csdev, struct perf_event *event,
-		       enum cs_mode mode)
+		       enum cs_mode mode,
+		       __maybe_unused struct coresight_trace_id_map *id_map)
 {
 	struct tpdm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 
include/linux/coresight.h +2 -1
index 7d62b88bfb5c..9c3067e2e38b 100644
@@ -290,6 +290,7 @@ struct coresight_device {
 	bool sysfs_sink_activated;
 	struct dev_ext_attribute *ea;
 	struct coresight_device *def_sink;
+	struct coresight_trace_id_map perf_sink_id_map;
 	/* sysfs links between components */
 	int nr_links;
 	bool has_conns_grp;
@@ -384,7 +385,7 @@ struct coresight_ops_link {
 struct coresight_ops_source {
 	int (*cpu_id)(struct coresight_device *csdev);
 	int (*enable)(struct coresight_device *csdev, struct perf_event *event,
-		      enum cs_mode mode);
+		      enum cs_mode mode, struct coresight_trace_id_map *id_map);
 	void (*disable)(struct coresight_device *csdev,
 			struct perf_event *event);
 };
Signature · 1 line
2.34.1
maintainer
#18 lore raw

Hi James

Quoted 15 lines · James Clark

This will allow sessions with more than CORESIGHT_TRACE_IDS_MAX ETMs as long as there are fewer than that many ETMs connected to each sink.

Each sink owns its own trace ID map, and any Perf session connecting to that sink will allocate from it, even if the sink is currently in use by other users. This is similar to the existing behavior where the dynamic trace IDs are constant as long as there is any concurrent Perf session active. It's not completely optimal because slightly more IDs will be used than necessary, but the optimal solution involves tracking the PIDs of each session and allocating ID maps based on the session owner. This is difficult to do with the combination of per-thread and per-cpu modes and some scheduling issues. The complexity of this isn't likely to worth it because even with multiple users they'd just see a difference in the ordering of ID allocations rather than hitting any limits (unless the hardware does have too many ETMs connected to one sink).

Please find my comments below.

Quoted 42 lines
---
  drivers/hwtracing/coresight/coresight-core.c      | 10 ++++++++++
  drivers/hwtracing/coresight/coresight-dummy.c     |  3 ++-
  drivers/hwtracing/coresight/coresight-etm-perf.c  | 15 ++++++++++-----
  .../hwtracing/coresight/coresight-etm3x-core.c    |  9 +++++----
  .../hwtracing/coresight/coresight-etm4x-core.c    |  9 +++++----
  drivers/hwtracing/coresight/coresight-stm.c       |  3 ++-
  drivers/hwtracing/coresight/coresight-sysfs.c     |  3 ++-
  drivers/hwtracing/coresight/coresight-tpdm.c      |  3 ++-
  include/linux/coresight.h                         |  3 ++-
  9 files changed, 40 insertions(+), 18 deletions(-)
drivers/hwtracing/coresight/coresight-core.c +9 -0
index 9fc6f6b863e0..d5aaeafe5c7d 100644
@@ -902,6 +902,7 @@ static void coresight_device_release(struct device *dev)
  	struct coresight_device *csdev = to_coresight_device(dev);
 
  	fwnode_handle_put(csdev->dev.fwnode);
+	free_percpu(csdev->perf_sink_id_map.cpu_map);
  	kfree(csdev);
  }
 
@@ -1159,6 +1160,14 @@ struct coresight_device *coresight_register(struct coresight_desc *desc)
  	csdev->dev.fwnode = fwnode_handle_get(dev_fwnode(desc->dev));
  	dev_set_name(&csdev->dev, "%s", desc->name);
 
+	if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
+	    csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
+		csdev->perf_sink_id_map.cpu_map = alloc_percpu(atomic_t);
+		if (!csdev->perf_sink_id_map.cpu_map) {
+			ret = -ENOMEM;
+			goto err_out;
+		}
+	}
  	/*
  	 * Make sure the device registration and the connection fixup
  	 * are synchronised, so that we don't see uninitialised devices

drivers/hwtracing/coresight/coresight-core.c struct coresight_device *coresight_register(struct coresight_desc *desc) · line 1228

Quoted 4 lines
drivers/hwtracing/coresight/coresight-core.c +1 -0
@@ -1216,6 +1225,7 @@ struct coresight_device *coresight_register(struct coresight_desc *desc)
  err_out:
  	/* Cleanup the connection information */
  	coresight_release_platform_data(NULL, desc->dev, desc->pdata);
+	kfree(csdev);

This hunk looked suspicious to me and is problematic. If we fail to register the device with "device_register()", we already free the csdev, via coresight_device_release() triggered via the device_put(),
(See comments in that case) and we could trigger a double free of the csdev with this change.

I would recommend, you free the "csdev" in the above case, if we fail to allocate the percpu storage and fall through.

Quoted 210 lines
drivers/hwtracing/coresight/coresight-core.c +0 -0
  	return ERR_PTR(ret);
  }
  EXPORT_SYMBOL_GPL(coresight_register);
drivers/hwtracing/coresight/coresight-dummy.c +2 -1
index ac70c0b491be..1f1b9ad160f6 100644
@@ -21,7 +21,8 @@ DEFINE_CORESIGHT_DEVLIST(source_devs, "dummy_source");
  DEFINE_CORESIGHT_DEVLIST(sink_devs, "dummy_sink");
 
  static int dummy_source_enable(struct coresight_device *csdev,
-			       struct perf_event *event, enum cs_mode mode)
+			       struct perf_event *event, enum cs_mode mode,
+			       __maybe_unused struct coresight_trace_id_map *id_map)
  {
  	dev_dbg(csdev->dev.parent, "Dummy source enabled\n");
 
drivers/hwtracing/coresight/coresight-etm-perf.c +10 -5
index c0c60e6a1703..7fb55dafb639 100644
@@ -229,10 +229,13 @@ static void free_event_data(struct work_struct *work)
  		struct list_head **ppath;
 
  		ppath = etm_event_cpu_path_ptr(event_data, cpu);
-		if (!(IS_ERR_OR_NULL(*ppath)))
+		if (!(IS_ERR_OR_NULL(*ppath))) {
+			struct coresight_device *sink = coresight_get_sink(*ppath);
+
+			coresight_trace_id_put_cpu_id_map(cpu, &sink->perf_sink_id_map);
  			coresight_release_path(*ppath);
+		}
  		*ppath = NULL;
-		coresight_trace_id_put_cpu_id(cpu);
  	}
 
  	/* mark perf event as done for trace id allocator */
@@ -401,7 +404,7 @@ static void *etm_setup_aux(struct perf_event *event, void **pages,
  		}
 
  		/* ensure we can allocate a trace ID for this CPU */
-		trace_id = coresight_trace_id_get_cpu_id(cpu);
+		trace_id = coresight_trace_id_get_cpu_id_map(cpu, &sink->perf_sink_id_map);
  		if (!IS_VALID_CS_TRACE_ID(trace_id)) {
  			cpumask_clear_cpu(cpu, mask);
  			coresight_release_path(path);
@@ -495,7 +498,8 @@ static void etm_event_start(struct perf_event *event, int flags)
  		goto fail_end_stop;
 
  	/* Finally enable the tracer */
-	if (source_ops(csdev)->enable(csdev, event, CS_MODE_PERF))
+	if (source_ops(csdev)->enable(csdev, event, CS_MODE_PERF,
+				      &sink->perf_sink_id_map))
  		goto fail_disable_path;
 
  	/*
@@ -507,7 +511,8 @@ static void etm_event_start(struct perf_event *event, int flags)
  		hw_id = FIELD_PREP(CS_AUX_HW_ID_VERSION_MASK,
  				   CS_AUX_HW_ID_CURR_VERSION);
  		hw_id |= FIELD_PREP(CS_AUX_HW_ID_TRACE_ID_MASK,
-				    coresight_trace_id_read_cpu_id(cpu));
+				    coresight_trace_id_read_cpu_id_map(cpu,
+								       &sink->perf_sink_id_map));
  		perf_report_aux_output_id(event, hw_id);
  	}
 
drivers/hwtracing/coresight/coresight-etm3x-core.c +5 -4
index 9d5c1391ffb1..65cf7456426a 100644
@@ -481,7 +481,8 @@ void etm_release_trace_id(struct etm_drvdata *drvdata)
  }
 
  static int etm_enable_perf(struct coresight_device *csdev,
-			   struct perf_event *event)
+			   struct perf_event *event,
+			   struct coresight_trace_id_map *id_map)
  {
  	struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
  	int trace_id;
@@ -500,7 +501,7 @@ static int etm_enable_perf(struct coresight_device *csdev,
  	 * with perf locks - we know the ID cannot change until perf shuts down
  	 * the session
  	 */
-	trace_id = coresight_trace_id_read_cpu_id(drvdata->cpu);
+	trace_id = coresight_trace_id_read_cpu_id_map(drvdata->cpu, id_map);
  	if (!IS_VALID_CS_TRACE_ID(trace_id)) {
  		dev_err(&drvdata->csdev->dev, "Failed to set trace ID for %s on CPU%d\n",
  			dev_name(&drvdata->csdev->dev), drvdata->cpu);
@@ -553,7 +554,7 @@ static int etm_enable_sysfs(struct coresight_device *csdev)
  }
 
  static int etm_enable(struct coresight_device *csdev, struct perf_event *event,
-		      enum cs_mode mode)
+		      enum cs_mode mode, struct coresight_trace_id_map *id_map)
  {
  	int ret;
  	struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
@@ -568,7 +569,7 @@ static int etm_enable(struct coresight_device *csdev, struct perf_event *event,
  		ret = etm_enable_sysfs(csdev);
  		break;
  	case CS_MODE_PERF:
-		ret = etm_enable_perf(csdev, event);
+		ret = etm_enable_perf(csdev, event, id_map);
  		break;
  	default:
  		ret = -EINVAL;
drivers/hwtracing/coresight/coresight-etm4x-core.c +5 -4
index a0bdfabddbc6..fcd0f9ba562d 100644
@@ -752,7 +752,8 @@ static int etm4_parse_event_config(struct coresight_device *csdev,
  }
 
  static int etm4_enable_perf(struct coresight_device *csdev,
-			    struct perf_event *event)
+			    struct perf_event *event,
+			    struct coresight_trace_id_map *id_map)
  {
  	int ret = 0, trace_id;
  	struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
@@ -775,7 +776,7 @@ static int etm4_enable_perf(struct coresight_device *csdev,
  	 * with perf locks - we know the ID cannot change until perf shuts down
  	 * the session
  	 */
-	trace_id = coresight_trace_id_read_cpu_id(drvdata->cpu);
+	trace_id = coresight_trace_id_read_cpu_id_map(drvdata->cpu, id_map);
  	if (!IS_VALID_CS_TRACE_ID(trace_id)) {
  		dev_err(&drvdata->csdev->dev, "Failed to set trace ID for %s on CPU%d\n",
  			dev_name(&drvdata->csdev->dev), drvdata->cpu);
@@ -837,7 +838,7 @@ static int etm4_enable_sysfs(struct coresight_device *csdev)
  }
 
  static int etm4_enable(struct coresight_device *csdev, struct perf_event *event,
-		       enum cs_mode mode)
+		       enum cs_mode mode, struct coresight_trace_id_map *id_map)
  {
  	int ret;
 
@@ -851,7 +852,7 @@ static int etm4_enable(struct coresight_device *csdev, struct perf_event *event,
  		ret = etm4_enable_sysfs(csdev);
  		break;
  	case CS_MODE_PERF:
-		ret = etm4_enable_perf(csdev, event);
+		ret = etm4_enable_perf(csdev, event, id_map);
  		break;
  	default:
  		ret = -EINVAL;
drivers/hwtracing/coresight/coresight-stm.c +2 -1
index e1c62820dfda..a80ad1de4c23 100644
@@ -194,7 +194,8 @@ static void stm_enable_hw(struct stm_drvdata *drvdata)
  }
 
  static int stm_enable(struct coresight_device *csdev, struct perf_event *event,
-		      enum cs_mode mode)
+		      enum cs_mode mode,
+		      __maybe_unused struct coresight_trace_id_map *trace_id)
  {
  	struct stm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 
drivers/hwtracing/coresight/coresight-sysfs.c +2 -1
index 1e67cc7758d7..a01c9e54e2ed 100644
@@ -9,6 +9,7 @@
  #include <linux/kernel.h>
 
  #include "coresight-priv.h"
+#include "coresight-trace-id.h"
 
  /*
   * Use IDR to map the hash of the source's device name
@@ -63,7 +64,7 @@ static int coresight_enable_source_sysfs(struct coresight_device *csdev,
  	 */
  	lockdep_assert_held(&coresight_mutex);
  	if (coresight_get_mode(csdev) != CS_MODE_SYSFS) {
-		ret = source_ops(csdev)->enable(csdev, data, mode);
+		ret = source_ops(csdev)->enable(csdev, data, mode, NULL);
  		if (ret)
  			return ret;
  	}
drivers/hwtracing/coresight/coresight-tpdm.c +2 -1
index a9708ab0d488..0376ad326a2f 100644
@@ -439,7 +439,8 @@ static void __tpdm_enable(struct tpdm_drvdata *drvdata)
  }
 
  static int tpdm_enable(struct coresight_device *csdev, struct perf_event *event,
-		       enum cs_mode mode)
+		       enum cs_mode mode,
+		       __maybe_unused struct coresight_trace_id_map *id_map)
  {
  	struct tpdm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 
include/linux/coresight.h +1 -0
index 7d62b88bfb5c..9c3067e2e38b 100644
@@ -290,6 +290,7 @@ struct coresight_device {
  	bool sysfs_sink_activated;
  	struct dev_ext_attribute *ea;
  	struct coresight_device *def_sink;
+	struct coresight_trace_id_map perf_sink_id_map;
  	/* sysfs links between components */
  	int nr_links;
  	bool has_conns_grp;

include/linux/coresight.h struct coresight_ops_link { · line 388

Quoted 5 lines
include/linux/coresight.h +1 -1
@@ -384,7 +385,7 @@ struct coresight_ops_link {
  struct coresight_ops_source {
  	int (*cpu_id)(struct coresight_device *csdev);
  	int (*enable)(struct coresight_device *csdev, struct perf_event *event,
-		      enum cs_mode mode);
+		      enum cs_mode mode, struct coresight_trace_id_map *id_map);

I am slightly concerned by this change. We already pass down "event" for a generic "enable" call back which serves both SYSFS & PERF. Now we are adding one more, just for the PERF usage. Ideally, it is possible to pass a single argument, e.g. perf_aux_output_handle which can fetch you
all the required infor for "enable".

i.e, hanlde->event, perf_get_aux(handle) -> event_data. We could even
add a helper to find the trace_id map from the handle, which could hide the implementation details from the backend drivers.

e.g.,

etm_perf_get_trace_id_map(handle) -> {
event_data = perf_get_aux()
path = per_cpu(event_data->path)
sink = sink_from_path(path)
return trace_id of the sink;
}

That said, we if we intend to extend the usage of trace_id_map for sysfs, this may be fine as is.

Suzuki

Quoted 3 lines
include/linux/coresight.h +0 -0
  	void (*disable)(struct coresight_device *csdev,
  			struct perf_event *event);
  };
#19 lore raw
Quoted 329 lines · Suzuki K Poulose

Hi James

Quoted 15 lines · James Clark

This will allow sessions with more than CORESIGHT_TRACE_IDS_MAX ETMs as long as there are fewer than that many ETMs connected to each sink.

Each sink owns its own trace ID map, and any Perf session connecting to that sink will allocate from it, even if the sink is currently in use by other users. This is similar to the existing behavior where the dynamic trace IDs are constant as long as there is any concurrent Perf session active. It's not completely optimal because slightly more IDs will be used than necessary, but the optimal solution involves tracking the PIDs of each session and allocating ID maps based on the session owner. This is difficult to do with the combination of per-thread and per-cpu modes and some scheduling issues. The complexity of this isn't likely to worth it because even with multiple users they'd just see a difference in the ordering of ID allocations rather than hitting any limits (unless the hardware does have too many ETMs connected to one sink).

Please find my comments below.

Quoted 43 lines

---
  drivers/hwtracing/coresight/coresight-core.c      | 10 ++++++++++ drivers/hwtracing/coresight/coresight-dummy.c     |  3 ++- drivers/hwtracing/coresight/coresight-etm-perf.c  | 15 ++++++++++----- .../hwtracing/coresight/coresight-etm3x-core.c    |  9 +++++---- .../hwtracing/coresight/coresight-etm4x-core.c    |  9 +++++---- drivers/hwtracing/coresight/coresight-stm.c       |  3 ++- drivers/hwtracing/coresight/coresight-sysfs.c     |  3 ++- drivers/hwtracing/coresight/coresight-tpdm.c      |  3 ++- include/linux/coresight.h                         |  3 ++-

  9 files changed, 40 insertions(+), 18 deletions(-)
drivers/hwtracing/coresight/coresight-core.c +1 -0
index 9fc6f6b863e0..d5aaeafe5c7d 100644
@@ -902,6 +902,7 @@ static void coresight_device_release(struct device
 *dev)
       struct coresight_device *csdev = to_coresight_device(dev);
         fwnode_handle_put(csdev->dev.fwnode);
+    free_percpu(csdev->perf_sink_id_map.cpu_map);
       kfree(csdev);
   }

  @@ -1159,6 +1160,14 @@ struct coresight_device *coresight_register(struct coresight_desc *desc) csdev->dev.fwnode = fwnode_handle_get(dev_fwnode(desc->dev)); dev_set_name(&csdev->dev, "%s", desc->name);
  +    if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
+        csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
+        csdev->perf_sink_id_map.cpu_map = alloc_percpu(atomic_t); +        if (!csdev->perf_sink_id_map.cpu_map) {
+            ret = -ENOMEM;
+            goto err_out;
+        }
+    }
      /*
       * Make sure the device registration and the connection fixup
       * are synchronised, so that we don't see uninitialised devices

drivers/hwtracing/coresight/coresight-core.c +0 -0
@@ -1216,6 +1225,7 @@ struct coresight_device
 *coresight_register(struct coresight_desc *desc)
Quoted 4 lines

  err_out:
      /* Cleanup the connection information */ coresight_release_platform_data(NULL, desc->dev, desc->pdata); +    kfree(csdev);

This hunk looked suspicious to me and is problematic. If we fail to register the device with "device_register()", we already free the csdev, via coresight_device_release() triggered via the device_put(), (See comments in that case) and we could trigger a double free of the csdev with this change.

I would recommend, you free the "csdev" in the above case, if we fail to allocate the percpu storage and fall through.

Quoted 225 lines

      return ERR_PTR(ret);
  }
  EXPORT_SYMBOL_GPL(coresight_register);

drivers/hwtracing/coresight/coresight-dummy.c +2 -1
index ac70c0b491be..1f1b9ad160f6 100644
@@ -21,7 +21,8 @@ DEFINE_CORESIGHT_DEVLIST(source_devs, "dummy_source");
   DEFINE_CORESIGHT_DEVLIST(sink_devs, "dummy_sink");
     static int dummy_source_enable(struct coresight_device *csdev,
-                   struct perf_event *event, enum cs_mode mode)
+                   struct perf_event *event, enum cs_mode mode,
+                   __maybe_unused struct coresight_trace_id_map *id_map)
   {
       dev_dbg(csdev->dev.parent, "Dummy source enabled\n");

  diff --git a/drivers/hwtracing/coresight/coresight-etm-perf.c b/drivers/hwtracing/coresight/coresight-etm-perf.c index c0c60e6a1703..7fb55dafb639 100644

drivers/hwtracing/coresight/coresight-etm-perf.c +6 -3
@@ -229,10 +229,13 @@ static void free_event_data(struct work_struct
 *work)
           struct list_head **ppath;
             ppath = etm_event_cpu_path_ptr(event_data, cpu);
-        if (!(IS_ERR_OR_NULL(*ppath)))
+        if (!(IS_ERR_OR_NULL(*ppath))) {
+            struct coresight_device *sink = coresight_get_sink(*ppath);
+
+            coresight_trace_id_put_cpu_id_map(cpu,
 &sink->perf_sink_id_map);
               coresight_release_path(*ppath);
+        }
           *ppath = NULL;
-        coresight_trace_id_put_cpu_id(cpu);
       }
         /* mark perf event as done for trace id allocator */
@@ -401,7 +404,7 @@ static void *etm_setup_aux(struct perf_event
 *event, void **pages,
           }
             /* ensure we can allocate a trace ID for this CPU */
-        trace_id = coresight_trace_id_get_cpu_id(cpu);
+        trace_id = coresight_trace_id_get_cpu_id_map(cpu,
 &sink->perf_sink_id_map);
           if (!IS_VALID_CS_TRACE_ID(trace_id)) {
               cpumask_clear_cpu(cpu, mask);

              coresight_release_path(path);

drivers/hwtracing/coresight/coresight-etm-perf.c +4 -2
@@ -495,7 +498,8 @@ static void etm_event_start(struct perf_event
 *event, int flags)
           goto fail_end_stop;
         /* Finally enable the tracer */
-    if (source_ops(csdev)->enable(csdev, event, CS_MODE_PERF))
+    if (source_ops(csdev)->enable(csdev, event, CS_MODE_PERF,
+                      &sink->perf_sink_id_map))
           goto fail_disable_path;
         /*
@@ -507,7 +511,8 @@ static void etm_event_start(struct perf_event
 *event, int flags)
           hw_id = FIELD_PREP(CS_AUX_HW_ID_VERSION_MASK,
                      CS_AUX_HW_ID_CURR_VERSION);
           hw_id |= FIELD_PREP(CS_AUX_HW_ID_TRACE_ID_MASK,
-                    coresight_trace_id_read_cpu_id(cpu));
+                    coresight_trace_id_read_cpu_id_map(cpu,
+                                       &sink->perf_sink_id_map));
           perf_report_aux_output_id(event, hw_id);
       }

  diff --git a/drivers/hwtracing/coresight/coresight-etm3x-core.c b/drivers/hwtracing/coresight/coresight-etm3x-core.c index 9d5c1391ffb1..65cf7456426a 100644

drivers/hwtracing/coresight/coresight-etm3x-core.c +2 -1
@@ -481,7 +481,8 @@ void etm_release_trace_id(struct etm_drvdata
 *drvdata)
   }
     static int etm_enable_perf(struct coresight_device *csdev,
-               struct perf_event *event)
+               struct perf_event *event,
+               struct coresight_trace_id_map *id_map)
   {
       struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
       int trace_id;
@@ -500,7 +501,7 @@ static int etm_enable_perf(struct coresight_device
 *csdev,
        * with perf locks - we know the ID cannot change until perf

shuts down
       * the session
       */
-    trace_id = coresight_trace_id_read_cpu_id(drvdata->cpu); +    trace_id = coresight_trace_id_read_cpu_id_map(drvdata->cpu, id_map); if (!IS_VALID_CS_TRACE_ID(trace_id)) { dev_err(&drvdata->csdev->dev, "Failed to set trace ID for %s on CPU%d\n",
              dev_name(&drvdata->csdev->dev), drvdata->cpu);

drivers/hwtracing/coresight/coresight-etm3x-core.c +0 -0
@@ -553,7 +554,7 @@ static int etm_enable_sysfs(struct
 coresight_device *csdev)
   }

    static int etm_enable(struct coresight_device *csdev, struct perf_event *event,
-              enum cs_mode mode)
+              enum cs_mode mode, struct coresight_trace_id_map *id_map) {
      int ret;
      struct etm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);

drivers/hwtracing/coresight/coresight-etm3x-core.c +0 -0
@@ -568,7 +569,7 @@ static int etm_enable(struct coresight_device
 *csdev, struct perf_event *event,
           ret = etm_enable_sysfs(csdev);
           break;

      case CS_MODE_PERF:
-        ret = etm_enable_perf(csdev, event); +        ret = etm_enable_perf(csdev, event, id_map); break;
      default:
          ret = -EINVAL;

drivers/hwtracing/coresight/coresight-etm4x-core.c +2 -1
index a0bdfabddbc6..fcd0f9ba562d 100644
@@ -752,7 +752,8 @@ static int etm4_parse_event_config(struct
 coresight_device *csdev,
   }
     static int etm4_enable_perf(struct coresight_device *csdev,
-                struct perf_event *event)
+                struct perf_event *event,
+                struct coresight_trace_id_map *id_map)
   {
       int ret = 0, trace_id;
       struct etmv4_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
@@ -775,7 +776,7 @@ static int etm4_enable_perf(struct
 coresight_device *csdev,
        * with perf locks - we know the ID cannot change until perf

shuts down
       * the session
       */
-    trace_id = coresight_trace_id_read_cpu_id(drvdata->cpu); +    trace_id = coresight_trace_id_read_cpu_id_map(drvdata->cpu, id_map); if (!IS_VALID_CS_TRACE_ID(trace_id)) { dev_err(&drvdata->csdev->dev, "Failed to set trace ID for %s on CPU%d\n",
              dev_name(&drvdata->csdev->dev), drvdata->cpu);

drivers/hwtracing/coresight/coresight-etm4x-core.c +0 -0
@@ -837,7 +838,7 @@ static int etm4_enable_sysfs(struct
 coresight_device *csdev)
   }

    static int etm4_enable(struct coresight_device *csdev, struct perf_event *event,
-               enum cs_mode mode)
+               enum cs_mode mode, struct coresight_trace_id_map *id_map) {
      int ret;
  @@ -851,7 +852,7 @@ static int etm4_enable(struct coresight_device *csdev, struct perf_event *event,
          ret = etm4_enable_sysfs(csdev);
          break;
      case CS_MODE_PERF:
-        ret = etm4_enable_perf(csdev, event);
+        ret = etm4_enable_perf(csdev, event, id_map);
          break;
      default:
          ret = -EINVAL;

drivers/hwtracing/coresight/coresight-stm.c +0 -0
index e1c62820dfda..a80ad1de4c23 100644
@@ -194,7 +194,8 @@ static void stm_enable_hw(struct stm_drvdata
 *drvdata)
   }

    static int stm_enable(struct coresight_device *csdev, struct perf_event *event,
-              enum cs_mode mode)
+              enum cs_mode mode,
+              __maybe_unused struct coresight_trace_id_map *trace_id) {
      struct stm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); diff --git a/drivers/hwtracing/coresight/coresight-sysfs.c b/drivers/hwtracing/coresight/coresight-sysfs.c
index 1e67cc7758d7..a01c9e54e2ed 100644

drivers/hwtracing/coresight/coresight-sysfs.c +2 -1
@@ -9,6 +9,7 @@
   #include <linux/kernel.h>
     #include "coresight-priv.h"
+#include "coresight-trace-id.h"
     /*
    * Use IDR to map the hash of the source's device name
@@ -63,7 +64,7 @@ static int coresight_enable_source_sysfs(struct
 coresight_device *csdev,
        */
       lockdep_assert_held(&coresight_mutex);
       if (coresight_get_mode(csdev) != CS_MODE_SYSFS) {
-        ret = source_ops(csdev)->enable(csdev, data, mode);
+        ret = source_ops(csdev)->enable(csdev, data, mode, NULL);
           if (ret)
               return ret;

      }

drivers/hwtracing/coresight/coresight-tpdm.c +0 -0
index a9708ab0d488..0376ad326a2f 100644
@@ -439,7 +439,8 @@ static void __tpdm_enable(struct tpdm_drvdata
 *drvdata)
   }

    static int tpdm_enable(struct coresight_device *csdev, struct perf_event *event,
-               enum cs_mode mode)
+               enum cs_mode mode,
+               __maybe_unused struct coresight_trace_id_map *id_map) {
      struct tpdm_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent); diff --git a/include/linux/coresight.h b/include/linux/coresight.h index 7d62b88bfb5c..9c3067e2e38b 100644

include/linux/coresight.h +1 -0
@@ -290,6 +290,7 @@ struct coresight_device {
       bool sysfs_sink_activated;
       struct dev_ext_attribute *ea;
       struct coresight_device *def_sink;
+    struct coresight_trace_id_map perf_sink_id_map;
       /* sysfs links between components */
       int nr_links;
       bool has_conns_grp;
@@ -384,7 +385,7 @@ struct coresight_ops_link {
   struct coresight_ops_source {
       int (*cpu_id)(struct coresight_device *csdev);
Quoted 4 lines

      int (*enable)(struct coresight_device *csdev, struct perf_event *event,
-              enum cs_mode mode);
+              enum cs_mode mode, struct coresight_trace_id_map *id_map);

I am slightly concerned by this change. We already pass down "event" for a generic "enable" call back which serves both SYSFS & PERF. Now we are adding one more, just for the PERF usage. Ideally, it is possible to pass a single argument, e.g. perf_aux_output_handle which can fetch you all the required infor for "enable".

 i.e, hanlde->event, perf_get_aux(handle) -> event_data. We could even add a helper to find the trace_id map from the handle, which could hide the implementation details from the backend drivers.

e.g.,

etm_perf_get_trace_id_map(handle) -> {
  event_data = perf_get_aux()
  path = per_cpu(event_data->path)
  sink = sink_from_path(path)
  return trace_id of the sink;
}

Quoted 4 lines

That said, we if we intend to extend the usage of trace_id_map for sysfs, this may be fine as is.

Suzuki

Yeah, that's what I was getting at here [1]. I added it so that sysfs can use the same argument if we add per-sink IDs for sysfs (which seems inevitable because of the core count limitation). Adding it to the perf_event doesn't help for sysfs. And having a common argument will be more obvious and straightforward than having to dig it out of different places.

[1]:
https://lore.kernel.org/linux-perf-users/[email protected]/

Quoted 6 lines
Quoted 5 lines

      void (*disable)(struct coresight_device *csdev, struct perf_event *event);
  };

#20 lore raw

PATCH v2 14/16 coresight: Remove pending trace ID release mechanism

In reply to James Clark

Pending the release of IDs was a way of managing concurrent sysfs and Perf sessions in a single global ID map. Perf may have finished while sysfs hadn't, and Perf shouldn't release the IDs in use by sysfs and vice versa.

Now that Perf uses its own exclusive ID maps, pending release doesn't result in any different behavior than just releasing all IDs when the last Perf session finishes. As part of the per-sink trace ID change, we would have still had to make the pending mechanism work on a per-sink basis, due to the overlapping ID allocations, so instead of making that more complicated, just remove it.

---
 .../hwtracing/coresight/coresight-etm-perf.c  | 11 ++--
 .../hwtracing/coresight/coresight-trace-id.c  | 62 +++++--------------
 .../hwtracing/coresight/coresight-trace-id.h  | 31 +++++-----
 include/linux/coresight.h                     |  6 +-
 4 files changed, 34 insertions(+), 76 deletions(-)
drivers/hwtracing/coresight/coresight-etm-perf.c +4 -7
index 7fb55dafb639..17cafa1a7f18 100644
@@ -232,15 +232,14 @@ static void free_event_data(struct work_struct *work)
 		if (!(IS_ERR_OR_NULL(*ppath))) {
 			struct coresight_device *sink = coresight_get_sink(*ppath);
 
-			coresight_trace_id_put_cpu_id_map(cpu, &sink->perf_sink_id_map);
+			/* mark perf event as done for trace id allocator */
+			coresight_trace_id_perf_stop(&sink->perf_sink_id_map);
+
 			coresight_release_path(*ppath);
 		}
 		*ppath = NULL;
 	}
 
-	/* mark perf event as done for trace id allocator */
-	coresight_trace_id_perf_stop();
-
 	free_percpu(event_data->path);
 	kfree(event_data);
 }
@@ -328,9 +327,6 @@ static void *etm_setup_aux(struct perf_event *event, void **pages,
 		sink = user_sink = coresight_get_sink_by_id(id);
 	}
 
-	/* tell the trace ID allocator that a perf event is starting up */
-	coresight_trace_id_perf_start();
-
 	/* check if user wants a coresight configuration selected */
 	cfg_hash = (u32)((event->attr.config2 & GENMASK_ULL(63, 32)) >> 32);
 	if (cfg_hash) {
@@ -404,6 +400,7 @@ static void *etm_setup_aux(struct perf_event *event, void **pages,
 		}
 
 		/* ensure we can allocate a trace ID for this CPU */
+		coresight_trace_id_perf_start(&sink->perf_sink_id_map);
 		trace_id = coresight_trace_id_get_cpu_id_map(cpu, &sink->perf_sink_id_map);
 		if (!IS_VALID_CS_TRACE_ID(trace_id)) {
 			cpumask_clear_cpu(cpu, mask);
drivers/hwtracing/coresight/coresight-trace-id.c +14 -48

110 lines not on this page · raw message

drivers/hwtracing/coresight/coresight-trace-id.h +14 -17
index 840babdd0794..9aae50a553ca 100644
@@ -17,9 +17,10 @@
  * released when done.
  *
  * In order to ensure that a consistent cpu / ID matching is maintained
- * throughout a perf cs_etm event session - a session in progress flag will
- * be maintained, and released IDs not cleared until the perf session is
- * complete. This allows the same CPU to be re-allocated its prior ID.
+ * throughout a perf cs_etm event session - a session in progress flag will be
+ * maintained for each sink, and IDs are cleared when all the perf sessions
+ * complete. This allows the same CPU to be re-allocated its prior ID when
+ * events are scheduled in and out.
  *
  *
  * Trace ID maps will be created and initialised to prevent architecturally
@@ -66,11 +67,7 @@ int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id
 /**
  * Release an allocated trace ID associated with the CPU.
  *
- * This will release the CoreSight trace ID associated with the CPU,
- * unless a perf session is in operation.
- *
- * If a perf session is in operation then the ID will be marked as pending
- * release.
+ * This will release the CoreSight trace ID associated with the CPU.
  *
  * @cpu: The CPU index to release the associated trace ID.
  */
@@ -133,21 +130,21 @@ void coresight_trace_id_put_system_id(int id);
 /**
  * Notify the Trace ID allocator that a perf session is starting.
  *
- * Increase the perf session reference count - called by perf when setting up
- * a trace event.
+ * Increase the perf session reference count - called by perf when setting up a
+ * trace event.
  *
- * This reference count is used by the ID allocator to ensure that trace IDs
- * associated with a CPU cannot change or be released during a perf session.
+ * Perf sessions never free trace IDs to ensure that the ID associated with a
+ * CPU cannot change during their and other's concurrent sessions. Instead,
+ * this refcount is used so that the last event to finish always frees all IDs.
  */
-void coresight_trace_id_perf_start(void);
+void coresight_trace_id_perf_start(struct coresight_trace_id_map *id_map);
 
 /**
  * Notify the ID allocator that a perf session is stopping.
  *
- * Decrease the perf session reference count.
- * if this causes the count to go to zero, then all Trace IDs marked as pending
- * release, will be released.
+ * Decrease the perf session reference count. If this causes the count to go to
+ * zero, then all Trace IDs will be released.
  */
-void coresight_trace_id_perf_stop(void);
+void coresight_trace_id_perf_stop(struct coresight_trace_id_map *id_map);
 
 #endif /* _CORESIGHT_TRACE_ID_H */
include/linux/coresight.h +2 -4
index 9c3067e2e38b..197949fd2c35 100644
@@ -227,14 +227,12 @@ struct coresight_sysfs_link {
  * @used_ids:	Bitmap to register available (bit = 0) and in use (bit = 1) IDs.
  *		Initialised so that the reserved IDs are permanently marked as
  *		in use.
- * @pend_rel_ids: CPU IDs that have been released by the trace source but not
- *		  yet marked as available, to allow re-allocation to the same
- *		  CPU during a perf session.
+ * @perf_cs_etm_session_active: Number of Perf sessions using this ID map.
  */
 struct coresight_trace_id_map {
 	DECLARE_BITMAP(used_ids, CORESIGHT_TRACE_IDS_MAX);
-	DECLARE_BITMAP(pend_rel_ids, CORESIGHT_TRACE_IDS_MAX);
 	atomic_t __percpu *cpu_map;
+	atomic_t perf_cs_etm_session_active;
 };
 
 /**
Signature · 1 line
2.34.1
maintainer
#21 lore raw

Re: [PATCH v2 14/16] coresight: Remove pending trace ID release mechanism

Quoted 11 lines · James Clark

Pending the release of IDs was a way of managing concurrent sysfs and Perf sessions in a single global ID map. Perf may have finished while sysfs hadn't, and Perf shouldn't release the IDs in use by sysfs and vice versa.

Now that Perf uses its own exclusive ID maps, pending release doesn't result in any different behavior than just releasing all IDs when the last Perf session finishes. As part of the per-sink trace ID change, we would have still had to make the pending mechanism work on a per-sink basis, due to the overlapping ID allocations, so instead of making that more complicated, just remove it.

minor nit: Given that we drastically changed the meaing of the perf_session_start/stop calls to, grab a refcount on idmap, drop refcount, should we rename those helpers as such :

coresight_trace_id_map_get() / _put() ?

Quoted 43 lines
---
  .../hwtracing/coresight/coresight-etm-perf.c  | 11 ++--
  .../hwtracing/coresight/coresight-trace-id.c  | 62 +++++--------------
  .../hwtracing/coresight/coresight-trace-id.h  | 31 +++++-----
  include/linux/coresight.h                     |  6 +-
  4 files changed, 34 insertions(+), 76 deletions(-)
drivers/hwtracing/coresight/coresight-etm-perf.c +3 -7
index 7fb55dafb639..17cafa1a7f18 100644
@@ -232,15 +232,14 @@ static void free_event_data(struct work_struct *work)
  		if (!(IS_ERR_OR_NULL(*ppath))) {
  			struct coresight_device *sink = coresight_get_sink(*ppath);
 
-			coresight_trace_id_put_cpu_id_map(cpu, &sink->perf_sink_id_map);
+			/* mark perf event as done for trace id allocator */
+			coresight_trace_id_perf_stop(&sink->perf_sink_id_map);
+
  			coresight_release_path(*ppath);
  		}
  		*ppath = NULL;
  	}
 
-	/* mark perf event as done for trace id allocator */
-	coresight_trace_id_perf_stop();
-
  	free_percpu(event_data->path);
  	kfree(event_data);
  }
@@ -328,9 +327,6 @@ static void *etm_setup_aux(struct perf_event *event, void **pages,
  		sink = user_sink = coresight_get_sink_by_id(id);
  	}
 
-	/* tell the trace ID allocator that a perf event is starting up */
-	coresight_trace_id_perf_start();
-
  	/* check if user wants a coresight configuration selected */
  	cfg_hash = (u32)((event->attr.config2 & GENMASK_ULL(63, 32)) >> 32);
  	if (cfg_hash) {

drivers/hwtracing/coresight/coresight-etm-perf.c static void *etm_setup_aux(struct perf_event *event, void **pages, · line 406

Quoted 7 lines
drivers/hwtracing/coresight/coresight-etm-perf.c +1 -0
@@ -404,6 +400,7 @@ static void *etm_setup_aux(struct perf_event *event, void **pages,
  		}
 
  		/* ensure we can allocate a trace ID for this CPU */
+		coresight_trace_id_perf_start(&sink->perf_sink_id_map);
  		trace_id = coresight_trace_id_get_cpu_id_map(cpu, &sink->perf_sink_id_map);
  		if (!IS_VALID_CS_TRACE_ID(trace_id)) {
  			cpumask_clear_cpu(cpu, mask);

I think we are leaking a reference above, if the allocation of trace id
fails. i.e., we don't drop the refcount here, nor we do that in free_event_dat() since the ppath is set to NULL in case of failure ?

Quoted 24 lines
drivers/hwtracing/coresight/coresight-trace-id.c +0 -9
index 8a777c0af6ea..acb99ccf96b5 100644
@@ -18,12 +18,6 @@ static struct coresight_trace_id_map id_map_default = {
  	.cpu_map = &id_map_default_cpu_ids
  };
 
-/* maintain a record of the pending releases per cpu */
-static cpumask_t cpu_id_release_pending;
-
-/* perf session active counter */
-static atomic_t perf_cs_etm_session_active = ATOMIC_INIT(0);
-
  /* lock to protect id_map and cpu data  */
  static DEFINE_SPINLOCK(id_map_lock);
 
@@ -122,34 +116,18 @@ static void coresight_trace_id_free(int id, struct coresight_trace_id_map *id_ma
  	clear_bit(id, id_map->used_ids);
  }
 
-static void coresight_trace_id_set_pend_rel(int id, struct coresight_trace_id_map *id_map)
-{
-	if (WARN(!IS_VALID_CS_TRACE_ID(id), "Invalid Trace ID %d\n", id))

drivers/hwtracing/coresight/coresight-trace-id.c static void coresight_trace_id_free(int id, struct coresight_trace_id_map *id_ma · line 120

Quoted 10 lines
drivers/hwtracing/coresight/coresight-trace-id.c +1 -8
-		return;
-	set_bit(id, id_map->pend_rel_ids);
-}
-
  /*
- * release all pending IDs for all current maps & clear CPU associations
- *
- * This currently operates on the default id map, but may be extended to
- * operate on all registered id maps if per sink id maps are used.
+ * release all IDs and clear CPU associations

minor nit:

* Release all IDs and clear CPU associations.

Quoted 11 lines
drivers/hwtracing/coresight/coresight-trace-id.c +2 -4
   */
-static void coresight_trace_id_release_all_pending(void)
+static void coresight_trace_id_release_all(struct coresight_trace_id_map *id_map)
  {
-	struct coresight_trace_id_map *id_map = &id_map_default;
  	unsigned long flags;
-	int cpu, bit;
+	int cpu;
 
  	spin_lock_irqsave(&id_map_lock, flags);
-	for_each_set_bit(bit, id_map->pend_rel_ids, CORESIGHT_TRACE_ID_RES_TOP) {

drivers/hwtracing/coresight/coresight-trace-id.c static void coresight_trace_id_free(int id, struct coresight_trace_id_map *id_ma · line 130

Quoted 10 lines
drivers/hwtracing/coresight/coresight-trace-id.c +3 -7
-		clear_bit(bit, id_map->used_ids);
-		clear_bit(bit, id_map->pend_rel_ids);
-	}
-	for_each_cpu(cpu, &cpu_id_release_pending) {
-		atomic_set(per_cpu_ptr(id_map_default.cpu_map, cpu), 0);
-		cpumask_clear_cpu(cpu, &cpu_id_release_pending);
-	}
+	bitmap_zero(id_map->used_ids, CORESIGHT_TRACE_IDS_MAX);
+	for_each_possible_cpu(cpu)
+		atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);

Do we ever read these values without spinlock ? Do they need to be atomic ?

Quoted 29 lines
drivers/hwtracing/coresight/coresight-trace-id.c +1 -7
  	spin_unlock_irqrestore(&id_map_lock, flags);
  	DUMP_ID_MAP(id_map);
  }
@@ -164,7 +142,7 @@ static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map
  	/* check for existing allocation for this CPU */
  	id = _coresight_trace_id_read_cpu_id(cpu, id_map);
  	if (id)
-		goto get_cpu_id_clr_pend;
+		goto get_cpu_id_out_unlock;
 
  	/*
  	 * Find a new ID.
@@ -185,11 +163,6 @@ static int _coresight_trace_id_get_cpu_id(int cpu, struct coresight_trace_id_map
  	/* allocate the new id to the cpu */
  	atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), id);
 
-get_cpu_id_clr_pend:
-	/* we are (re)using this ID - so ensure it is not marked for release */
-	cpumask_clear_cpu(cpu, &cpu_id_release_pending);
-	clear_bit(id, id_map->pend_rel_ids);
-
  get_cpu_id_out_unlock:
  	spin_unlock_irqrestore(&id_map_lock, flags);
 
@@ -210,15 +183,8 @@ static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_ma
 
  	spin_lock_irqsave(&id_map_lock, flags);
 
-	if (atomic_read(&perf_cs_etm_session_active)) {

drivers/hwtracing/coresight/coresight-trace-id.c static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_ma · line 187

Quoted 10 lines
drivers/hwtracing/coresight/coresight-trace-id.c +2 -8
-		/* set release at pending if perf still active */
-		coresight_trace_id_set_pend_rel(id, id_map);
-		cpumask_set_cpu(cpu, &cpu_id_release_pending);
-	} else {
-		/* otherwise clear id */
-		coresight_trace_id_free(id, id_map);
-		atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);
-	}
+	coresight_trace_id_free(id, id_map);
+	atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);

Can we do this unconditionally now ? What is another session has reserved this id for the same CPU and that gets scheduled later ? We should simply stop doing the "put_cpu_id()" and instead rely
on the perf_session_stop()/(or the suggested trace_id_map_put())
to free the ids and clear everything.

Quoted 96 lines
drivers/hwtracing/coresight/coresight-trace-id.c +5 -5
  	spin_unlock_irqrestore(&id_map_lock, flags);
  	DUMP_ID_CPU(cpu, id);
@@ -302,17 +268,17 @@ void coresight_trace_id_put_system_id(int id)
  }
  EXPORT_SYMBOL_GPL(coresight_trace_id_put_system_id);
 
-void coresight_trace_id_perf_start(void)
+void coresight_trace_id_perf_start(struct coresight_trace_id_map *id_map)
  {
-	atomic_inc(&perf_cs_etm_session_active);
+	atomic_inc(&id_map->perf_cs_etm_session_active);
  	PERF_SESSION(atomic_read(&perf_cs_etm_session_active));
  }
  EXPORT_SYMBOL_GPL(coresight_trace_id_perf_start);
 
-void coresight_trace_id_perf_stop(void)
+void coresight_trace_id_perf_stop(struct coresight_trace_id_map *id_map)
  {
-	if (!atomic_dec_return(&perf_cs_etm_session_active))
-		coresight_trace_id_release_all_pending();
+	if (!atomic_dec_return(&id_map->perf_cs_etm_session_active))
+		coresight_trace_id_release_all(id_map);
  	PERF_SESSION(atomic_read(&perf_cs_etm_session_active));
  }
  EXPORT_SYMBOL_GPL(coresight_trace_id_perf_stop);
drivers/hwtracing/coresight/coresight-trace-id.h +14 -17
index 840babdd0794..9aae50a553ca 100644
@@ -17,9 +17,10 @@
   * released when done.
   *
   * In order to ensure that a consistent cpu / ID matching is maintained
- * throughout a perf cs_etm event session - a session in progress flag will
- * be maintained, and released IDs not cleared until the perf session is
- * complete. This allows the same CPU to be re-allocated its prior ID.
+ * throughout a perf cs_etm event session - a session in progress flag will be
+ * maintained for each sink, and IDs are cleared when all the perf sessions
+ * complete. This allows the same CPU to be re-allocated its prior ID when
+ * events are scheduled in and out.
   *
   *
   * Trace ID maps will be created and initialised to prevent architecturally
@@ -66,11 +67,7 @@ int coresight_trace_id_get_cpu_id_map(int cpu, struct coresight_trace_id_map *id
  /**
   * Release an allocated trace ID associated with the CPU.
   *
- * This will release the CoreSight trace ID associated with the CPU,
- * unless a perf session is in operation.
- *
- * If a perf session is in operation then the ID will be marked as pending
- * release.
+ * This will release the CoreSight trace ID associated with the CPU.
   *
   * @cpu: The CPU index to release the associated trace ID.
   */
@@ -133,21 +130,21 @@ void coresight_trace_id_put_system_id(int id);
  /**
   * Notify the Trace ID allocator that a perf session is starting.
   *
- * Increase the perf session reference count - called by perf when setting up
- * a trace event.
+ * Increase the perf session reference count - called by perf when setting up a
+ * trace event.
   *
- * This reference count is used by the ID allocator to ensure that trace IDs
- * associated with a CPU cannot change or be released during a perf session.
+ * Perf sessions never free trace IDs to ensure that the ID associated with a
+ * CPU cannot change during their and other's concurrent sessions. Instead,
+ * this refcount is used so that the last event to finish always frees all IDs.
   */
-void coresight_trace_id_perf_start(void);
+void coresight_trace_id_perf_start(struct coresight_trace_id_map *id_map);
 
  /**
   * Notify the ID allocator that a perf session is stopping.
   *
- * Decrease the perf session reference count.
- * if this causes the count to go to zero, then all Trace IDs marked as pending
- * release, will be released.
+ * Decrease the perf session reference count. If this causes the count to go to
+ * zero, then all Trace IDs will be released.
   */
-void coresight_trace_id_perf_stop(void);
+void coresight_trace_id_perf_stop(struct coresight_trace_id_map *id_map);
 
  #endif /* _CORESIGHT_TRACE_ID_H */
include/linux/coresight.h +0 -0
index 9c3067e2e38b..197949fd2c35 100644
@@ -227,14 +227,12 @@ struct coresight_sysfs_link {
   * @used_ids:	Bitmap to register available (bit = 0) and in use (bit = 1) IDs.
   *		Initialised so that the reserved IDs are permanently marked as
   *		in use.

include/linux/coresight.h struct coresight_sysfs_link { · line 235

Quoted 10 lines
include/linux/coresight.h +2 -4
- * @pend_rel_ids: CPU IDs that have been released by the trace source but not
- *		  yet marked as available, to allow re-allocation to the same
- *		  CPU during a perf session.
+ * @perf_cs_etm_session_active: Number of Perf sessions using this ID map.
   */
  struct coresight_trace_id_map {
  	DECLARE_BITMAP(used_ids, CORESIGHT_TRACE_IDS_MAX);
-	DECLARE_BITMAP(pend_rel_ids, CORESIGHT_TRACE_IDS_MAX);
  	atomic_t __percpu *cpu_map;
+	atomic_t perf_cs_etm_session_active;

minor nit: this could simply be :

	atomic_t map_refcnt;

i.e., number of references to the trace_id map ?

Suzuki

#22 lore raw

Re: [PATCH v2 14/16] coresight: Remove pending trace ID release mechanism

Quoted 13 lines · Suzuki K Poulose
Quoted 11 lines · James Clark

Pending the release of IDs was a way of managing concurrent sysfs and Perf sessions in a single global ID map. Perf may have finished while sysfs hadn't, and Perf shouldn't release the IDs in use by sysfs and vice versa.

Now that Perf uses its own exclusive ID maps, pending release doesn't result in any different behavior than just releasing all IDs when the last Perf session finishes. As part of the per-sink trace ID change, we would have still had to make the pending mechanism work on a per-sink basis, due to the overlapping ID allocations, so instead of making that more complicated, just remove it.

Quoted 7 lines

minor nit: Given that we drastically changed the meaing of the perf_session_start/stop calls to, grab a refcount on idmap, drop refcount, should we rename those helpers as such :

coresight_trace_id_map_get() / _put() ?

I don't mind keeping it as coresight_trace_id_perf_start() because it's not used in the global map and I can't see it being used for sysfs in the future either. It's something quite specific to Perf so it's more self documenting this way.

Quoted 49 lines
Quoted 49 lines

---

  .../hwtracing/coresight/coresight-etm-perf.c  | 11 ++--
  .../hwtracing/coresight/coresight-trace-id.c  | 62 +++++--------------
  .../hwtracing/coresight/coresight-trace-id.h  | 31 +++++-----
  include/linux/coresight.h                     |  6 +-
  4 files changed, 34 insertions(+), 76 deletions(-)
drivers/hwtracing/coresight/coresight-etm-perf.c +3 -0
index 7fb55dafb639..17cafa1a7f18 100644
@@ -232,15 +232,14 @@ static void free_event_data(struct work_struct
 *work)
           if (!(IS_ERR_OR_NULL(*ppath))) {
               struct coresight_device *sink = coresight_get_sink(*ppath);
   -            coresight_trace_id_put_cpu_id_map(cpu,
 &sink->perf_sink_id_map);
+            /* mark perf event as done for trace id allocator */
+            coresight_trace_id_perf_stop(&sink->perf_sink_id_map);
+
               coresight_release_path(*ppath);
           }
           *ppath = NULL;
       }

  -    /* mark perf event as done for trace id allocator */ -    coresight_trace_id_perf_stop();
-
      free_percpu(event_data->path); kfree(event_data);
  }

drivers/hwtracing/coresight/coresight-etm-perf.c +0 -0
@@ -328,9 +327,6 @@ static void *etm_setup_aux(struct perf_event
 *event, void **pages,
           sink = user_sink = coresight_get_sink_by_id(id);
       }

  -    /* tell the trace ID allocator that a perf event is starting up */ -    coresight_trace_id_perf_start();
-
      /* check if user wants a coresight configuration selected */ cfg_hash = (u32)((event->attr.config2 & GENMASK_ULL(63, 32)) >> 32);
      if (cfg_hash) {

drivers/hwtracing/coresight/coresight-etm-perf.c +1 -0
@@ -404,6 +400,7 @@ static void *etm_setup_aux(struct perf_event
 *event, void **pages,
           }
             /* ensure we can allocate a trace ID for this CPU */
+        coresight_trace_id_perf_start(&sink->perf_sink_id_map);
Quoted 10 lines
Quoted 4 lines
drivers/hwtracing/coresight/coresight-etm-perf.c +0 -0
           trace_id = coresight_trace_id_get_cpu_id_map(cpu,
 &sink->perf_sink_id_map);
           if (!IS_VALID_CS_TRACE_ID(trace_id)) {

              cpumask_clear_cpu(cpu, mask);

I think we are leaking a reference above, if the allocation of trace id fails. i.e., we don't drop the refcount here, nor we do that in free_event_dat() since the ppath is set to NULL in case of failure ?

Nice catch. I'll move the perf_start() call to where path is assigned because that's what guards the perf_stop() call in free_event_data(). Rather than add an extra perf_stop() call.

Quoted 39 lines
Quoted 30 lines
drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
index 8a777c0af6ea..acb99ccf96b5 100644
@@ -18,12 +18,6 @@ static struct coresight_trace_id_map id_map_default
 = {

      .cpu_map = &id_map_default_cpu_ids
  };
  -/* maintain a record of the pending releases per cpu */

drivers/hwtracing/coresight/coresight-trace-id.c +0 -5
-static cpumask_t cpu_id_release_pending;
-
-/* perf session active counter */
-static atomic_t perf_cs_etm_session_active = ATOMIC_INIT(0);
-

  /* lock to protect id_map and cpu data  */
  static DEFINE_SPINLOCK(id_map_lock);
  @@ -122,34 +116,18 @@ static void coresight_trace_id_free(int id, struct coresight_trace_id_map *id_ma
      clear_bit(id, id_map->used_ids);
  }
  -static void coresight_trace_id_set_pend_rel(int id, struct coresight_trace_id_map *id_map)

drivers/hwtracing/coresight/coresight-trace-id.c +0 -6
-{
-    if (WARN(!IS_VALID_CS_TRACE_ID(id), "Invalid Trace ID %d\n", id))
-        return;
-    set_bit(id, id_map->pend_rel_ids);
-}
-
Quoted 6 lines

  /*
- * release all pending IDs for all current maps & clear CPU associations
- *
- * This currently operates on the default id map, but may be extended to
- * operate on all registered id maps if per sink id maps are used.
+ * release all IDs and clear CPU associations

minor nit:

Quoted 2 lines

    * Release all IDs and clear CPU associations.

Done

Quoted 16 lines
Quoted 16 lines

   */

drivers/hwtracing/coresight/coresight-trace-id.c +1 -1
-static void coresight_trace_id_release_all_pending(void)
+static void coresight_trace_id_release_all(struct

coresight_trace_id_map *id_map)
  {
-    struct coresight_trace_id_map *id_map = &id_map_default; unsigned long flags;
-    int cpu, bit;
+    int cpu;
        spin_lock_irqsave(&id_map_lock, flags);
-    for_each_set_bit(bit, id_map->pend_rel_ids, CORESIGHT_TRACE_ID_RES_TOP) {
-        clear_bit(bit, id_map->used_ids);
-        clear_bit(bit, id_map->pend_rel_ids);
-    }
-    for_each_cpu(cpu, &cpu_id_release_pending) {

Quoted 9 lines
Quoted 6 lines

-        atomic_set(per_cpu_ptr(id_map_default.cpu_map, cpu), 0); -        cpumask_clear_cpu(cpu, &cpu_id_release_pending); -    }
+    bitmap_zero(id_map->used_ids, CORESIGHT_TRACE_IDS_MAX); +    for_each_possible_cpu(cpu)
+        atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);

Do we ever read these values without spinlock ? Do they need to be atomic ?

Yeah they're still read in a few places without taking the lock. Specifically because reading and checking if it's valid is so easy to do without locking.

Quoted 36 lines
Quoted 36 lines

      spin_unlock_irqrestore(&id_map_lock, flags); DUMP_ID_MAP(id_map);
  }

drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
@@ -164,7 +142,7 @@ static int _coresight_trace_id_get_cpu_id(int cpu,

struct coresight_trace_id_map
      /* check for existing allocation for this CPU */ id = _coresight_trace_id_read_cpu_id(cpu, id_map); if (id)
-        goto get_cpu_id_clr_pend;
+        goto get_cpu_id_out_unlock;
        /*
       * Find a new ID.

drivers/hwtracing/coresight/coresight-trace-id.c +0 -0
@@ -185,11 +163,6 @@ static int _coresight_trace_id_get_cpu_id(int

cpu, struct coresight_trace_id_map
      /* allocate the new id to the cpu */ atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), id); -get_cpu_id_clr_pend:
-    /* we are (re)using this ID - so ensure it is not marked for release */
-    cpumask_clear_cpu(cpu, &cpu_id_release_pending);
-    clear_bit(id, id_map->pend_rel_ids);
-
  get_cpu_id_out_unlock:
      spin_unlock_irqrestore(&id_map_lock, flags);
  @@ -210,15 +183,8 @@ static void _coresight_trace_id_put_cpu_id(int cpu, struct coresight_trace_id_ma spin_lock_irqsave(&id_map_lock, flags);
  -    if (atomic_read(&perf_cs_etm_session_active)) {
-        /* set release at pending if perf still active */ -        coresight_trace_id_set_pend_rel(id, id_map);
-        cpumask_set_cpu(cpu, &cpu_id_release_pending);
-    } else {
-        /* otherwise clear id */
-        coresight_trace_id_free(id, id_map);
-        atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0); -    }

Quoted 9 lines
Quoted 2 lines

+    coresight_trace_id_free(id, id_map);
+    atomic_set(per_cpu_ptr(id_map->cpu_map, cpu), 0);

Can we do this unconditionally now ? What is another session has reserved this id for the same CPU and that gets scheduled later ? We should simply stop doing the "put_cpu_id()" and instead rely on the perf_session_stop()/(or the suggested trace_id_map_put()) to free the ids and clear everything.

We do do it unconditionally, the Perf code doesn't call put() anymore. Only sysfs does but it still needs to because it uses the global map so this function can't be dropped completely.

Quoted 129 lines
Quoted 117 lines

        spin_unlock_irqrestore(&id_map_lock, flags); DUMP_ID_CPU(cpu, id);

drivers/hwtracing/coresight/coresight-trace-id.c +5 -3
@@ -302,17 +268,17 @@ void coresight_trace_id_put_system_id(int id)
   }
   EXPORT_SYMBOL_GPL(coresight_trace_id_put_system_id);
   -void coresight_trace_id_perf_start(void)
+void coresight_trace_id_perf_start(struct coresight_trace_id_map
 *id_map)
   {
-    atomic_inc(&perf_cs_etm_session_active);
+    atomic_inc(&id_map->perf_cs_etm_session_active);
       PERF_SESSION(atomic_read(&perf_cs_etm_session_active));
   }
   EXPORT_SYMBOL_GPL(coresight_trace_id_perf_start);
   -void coresight_trace_id_perf_stop(void)
+void coresight_trace_id_perf_stop(struct coresight_trace_id_map *id_map)
   {
-    if (!atomic_dec_return(&perf_cs_etm_session_active))
-        coresight_trace_id_release_all_pending();
+    if (!atomic_dec_return(&id_map->perf_cs_etm_session_active))
+        coresight_trace_id_release_all(id_map);
       PERF_SESSION(atomic_read(&perf_cs_etm_session_active));
   }

  EXPORT_SYMBOL_GPL(coresight_trace_id_perf_stop);

drivers/hwtracing/coresight/coresight-trace-id.h +0 -1
index 840babdd0794..9aae50a553ca 100644
@@ -17,9 +17,10 @@
    * released when done.
    *
    * In order to ensure that a consistent cpu / ID matching is maintained
- * throughout a perf cs_etm event session - a session in progress

flag will
- * be maintained, and released IDs not cleared until the perf session is
- * complete. This allows the same CPU to be re-allocated its prior ID.
+ * throughout a perf cs_etm event session - a session in progress flag will be
+ * maintained for each sink, and IDs are cleared when all the perf sessions
+ * complete. This allows the same CPU to be re-allocated its prior ID when
+ * events are scheduled in and out.
   *
   *
   * Trace ID maps will be created and initialised to prevent architecturally

drivers/hwtracing/coresight/coresight-trace-id.h +0 -0
@@ -66,11 +67,7 @@ int coresight_trace_id_get_cpu_id_map(int cpu,

struct coresight_trace_id_map *id
  /**
   * Release an allocated trace ID associated with the CPU. *
- * This will release the CoreSight trace ID associated with the CPU,
- * unless a perf session is in operation.
- *
- * If a perf session is in operation then the ID will be marked as pending
- * release.
+ * This will release the CoreSight trace ID associated with the CPU. *
   * @cpu: The CPU index to release the associated trace ID. */

drivers/hwtracing/coresight/coresight-trace-id.h +0 -1
@@ -133,21 +130,21 @@ void coresight_trace_id_put_system_id(int id);
   /**
    * Notify the Trace ID allocator that a perf session is starting.
    *
- * Increase the perf session reference count - called by perf when

setting up
- * a trace event.
+ * Increase the perf session reference count - called by perf when setting up a
+ * trace event.
   *
- * This reference count is used by the ID allocator to ensure that trace IDs
- * associated with a CPU cannot change or be released during a perf session.
+ * Perf sessions never free trace IDs to ensure that the ID associated with a
+ * CPU cannot change during their and other's concurrent sessions. Instead,
+ * this refcount is used so that the last event to finish always frees all IDs.
   */

drivers/hwtracing/coresight/coresight-trace-id.h +1 -1
-void coresight_trace_id_perf_start(void);
+void coresight_trace_id_perf_start(struct coresight_trace_id_map

*id_map);
    /**
   * Notify the ID allocator that a perf session is stopping. *
- * Decrease the perf session reference count.
- * if this causes the count to go to zero, then all Trace IDs marked as pending
- * release, will be released.
+ * Decrease the perf session reference count. If this causes the count to go to
+ * zero, then all Trace IDs will be released.
   */

drivers/hwtracing/coresight/coresight-trace-id.h +1 -1
-void coresight_trace_id_perf_stop(void);
+void coresight_trace_id_perf_stop(struct coresight_trace_id_map

*id_map);
    #endif /* _CORESIGHT_TRACE_ID_H */

include/linux/coresight.h +0 -0
index 9c3067e2e38b..197949fd2c35 100644
@@ -227,14 +227,12 @@ struct coresight_sysfs_link {
    * @used_ids:    Bitmap to register available (bit = 0) and in use

(bit = 1) IDs.
   *        Initialised so that the reserved IDs are permanently marked as
   *        in use.
- * @pend_rel_ids: CPU IDs that have been released by the trace source but not
- *          yet marked as available, to allow re-allocation to the same
- *          CPU during a perf session.

Quoted 8 lines

+ * @perf_cs_etm_session_active: Number of Perf sessions using this ID map.
   */
  struct coresight_trace_id_map {
      DECLARE_BITMAP(used_ids, CORESIGHT_TRACE_IDS_MAX);
-    DECLARE_BITMAP(pend_rel_ids, CORESIGHT_TRACE_IDS_MAX); atomic_t __percpu *cpu_map;
+    atomic_t perf_cs_etm_session_active;

minor nit: this could simply be :
    atomic_t map_refcnt;

Quoted 3 lines

i.e., number of references to the trace_id map ?

Suzuki

As I mentioned above I think it's clearer to keep this labelled with Perf as long is it's still only used for Perf. I'd agree to rename it at the point when it is a more generic refcnt though. Not sure what you think?

James

#23 lore raw

PATCH v2 15/16 coresight: Re-emit trace IDs when the sink changes in per-thread mode

In reply to James Clark

In per-cpu mode there are multiple aux buffers and each one has a fixed sink, so the hw ID mappings which only need to be emitted once for each buffer, even with the new per-sink trace ID pools.

But in per-thread mode there is only a single buffer which can be written to from any sink with now potentially overlapping trace IDs, so hw ID mappings need to be re-emitted every time the sink changes.

This will require a change in Perf to track this so it knows which decode tree to use for each segment of the buffer. In theory it's also possible to look at the CPU ID on the AUX records, but this is more consistent with the existing system, and allows for correct decode using either mechanism.

---
 drivers/hwtracing/coresight/coresight-etm-perf.c | 14 ++++++++++++++
 drivers/hwtracing/coresight/coresight-etm-perf.h |  2 ++
 2 files changed, 16 insertions(+)
drivers/hwtracing/coresight/coresight-etm-perf.c +14 -0
index 17cafa1a7f18..b6f505b50e67 100644
@@ -499,6 +499,20 @@ static void etm_event_start(struct perf_event *event, int flags)
 				      &sink->perf_sink_id_map))
 		goto fail_disable_path;
 
+	/*
+	 * In per-cpu mode there are multiple aux buffers and each one has a
+	 * fixed sink, so the hw ID mappings which only need to be emitted once
+	 * for each buffer.
+	 *
+	 * But in per-thread mode there is only a single buffer which can be
+	 * written to from any sink with potentially overlapping trace IDs, so
+	 * hw ID mappings need to be re-emitted every time the sink changes.
+	 */
+	if (event->cpu == -1 && event_data->last_sink_hwid != sink) {
+		cpumask_clear(&event_data->aux_hwid_done);
+		event_data->last_sink_hwid = sink;
+	}
+
 	/*
 	 * output cpu / trace ID in perf record, once for the lifetime
 	 * of the event.
drivers/hwtracing/coresight/coresight-etm-perf.h +2 -0
index 744531158d6b..bd4553b2a1ec 100644
@@ -52,6 +52,7 @@ struct etm_filters {
  * @snk_config:		The sink configuration.
  * @cfg_hash:		The hash id of any coresight config selected.
  * @path:		An array of path, each slot for one CPU.
+ * @last_sink_hwid:	Last sink that a hwid was emitted for.
  */
 struct etm_event_data {
 	struct work_struct work;
@@ -60,6 +61,7 @@ struct etm_event_data {
 	void *snk_config;
 	u32 cfg_hash;
 	struct list_head * __percpu *path;
+	struct coresight_device *last_sink_hwid;
 };
 
 int etm_perf_symlink(struct coresight_device *csdev, bool link);
Signature · 1 line
2.34.1
maintainer
#24 lore raw

Re: [PATCH v2 15/16] coresight: Re-emit trace IDs when the sink changes in per-thread mode

Quoted 31 lines · James Clark

In per-cpu mode there are multiple aux buffers and each one has a fixed sink, so the hw ID mappings which only need to be emitted once for each buffer, even with the new per-sink trace ID pools.

But in per-thread mode there is only a single buffer which can be written to from any sink with now potentially overlapping trace IDs, so hw ID mappings need to be re-emitted every time the sink changes.

This will require a change in Perf to track this so it knows which decode tree to use for each segment of the buffer. In theory it's also possible to look at the CPU ID on the AUX records, but this is more consistent with the existing system, and allows for correct decode using either mechanism.

---
  drivers/hwtracing/coresight/coresight-etm-perf.c | 14 ++++++++++++++
  drivers/hwtracing/coresight/coresight-etm-perf.h |  2 ++
  2 files changed, 16 insertions(+)
drivers/hwtracing/coresight/coresight-etm-perf.c +3 -0
index 17cafa1a7f18..b6f505b50e67 100644
@@ -499,6 +499,20 @@ static void etm_event_start(struct perf_event *event, int flags)
  				      &sink->perf_sink_id_map))
  		goto fail_disable_path;
 
+	/*
+	 * In per-cpu mode there are multiple aux buffers and each one has a
+	 * fixed sink, so the hw ID mappings which only need to be emitted once

drivers/hwtracing/coresight/coresight-etm-perf.c static void etm_event_start(struct perf_event *event, int flags) · line 514

Quoted 10 lines
drivers/hwtracing/coresight/coresight-etm-perf.c +10 -0
+	 * for each buffer.
+	 *
+	 * But in per-thread mode there is only a single buffer which can be
+	 * written to from any sink with potentially overlapping trace IDs, so
+	 * hw ID mappings need to be re-emitted every time the sink changes.
+	 */
+	if (event->cpu == -1 && event_data->last_sink_hwid != sink) {
+		cpumask_clear(&event_data->aux_hwid_done);
+		event_data->last_sink_hwid = sink;
+	}

I am wondering if we really need this patch, as we have the sinkid in the HWID already ? We would emit the packet for each CPU only once and that wouldn't change the HWID ?

Suzuki

Quoted 24 lines
drivers/hwtracing/coresight/coresight-etm-perf.c +1 -0
+
  	/*
  	 * output cpu / trace ID in perf record, once for the lifetime
  	 * of the event.
drivers/hwtracing/coresight/coresight-etm-perf.h +2 -0
index 744531158d6b..bd4553b2a1ec 100644
@@ -52,6 +52,7 @@ struct etm_filters {
   * @snk_config:		The sink configuration.
   * @cfg_hash:		The hash id of any coresight config selected.
   * @path:		An array of path, each slot for one CPU.
+ * @last_sink_hwid:	Last sink that a hwid was emitted for.
   */
  struct etm_event_data {
  	struct work_struct work;
@@ -60,6 +61,7 @@ struct etm_event_data {
  	void *snk_config;
  	u32 cfg_hash;
  	struct list_head * __percpu *path;
+	struct coresight_device *last_sink_hwid;
  };
 
  int etm_perf_symlink(struct coresight_device *csdev, bool link);
#25 lore raw

Re: [PATCH v2 15/16] coresight: Re-emit trace IDs when the sink changes in per-thread mode

Quoted 50 lines · Suzuki K Poulose
Quoted 36 lines · James Clark

In per-cpu mode there are multiple aux buffers and each one has a fixed sink, so the hw ID mappings which only need to be emitted once for each buffer, even with the new per-sink trace ID pools.

But in per-thread mode there is only a single buffer which can be written to from any sink with now potentially overlapping trace IDs, so hw ID mappings need to be re-emitted every time the sink changes.

This will require a change in Perf to track this so it knows which decode tree to use for each segment of the buffer. In theory it's also possible to look at the CPU ID on the AUX records, but this is more consistent with the existing system, and allows for correct decode using either mechanism.

---
  drivers/hwtracing/coresight/coresight-etm-perf.c | 14 ++++++++++++++ drivers/hwtracing/coresight/coresight-etm-perf.h |  2 ++

  2 files changed, 16 insertions(+)
drivers/hwtracing/coresight/coresight-etm-perf.c +0 -0
index 17cafa1a7f18..b6f505b50e67 100644
@@ -499,6 +499,20 @@ static void etm_event_start(struct perf_event
 *event, int flags)
                         &sink->perf_sink_id_map))
           goto fail_disable_path;

  +    /*
+     * In per-cpu mode there are multiple aux buffers and each one has a +     * fixed sink, so the hw ID mappings which only need to be emitted once
+     * for each buffer.
+     *
+     * But in per-thread mode there is only a single buffer which can be

Quoted 8 lines

+     * written to from any sink with potentially overlapping trace IDs, so
+     * hw ID mappings need to be re-emitted every time the sink changes. +     */
+    if (event->cpu == -1 && event_data->last_sink_hwid != sink) { +        cpumask_clear(&event_data->aux_hwid_done);
+        event_data->last_sink_hwid = sink;
+    }

I am wondering if we really need this patch, as we have the sinkid in the HWID already ? We would emit the packet for each CPU only once and that wouldn't change the HWID ?

Quoted 3 lines

Suzuki

It would be needed for per-thread mode if we didn't have the CPU sample bit set on AUX records. Because otherwise you wouldn't know when the process had moved to a new sink with new mappings. But I suppose this is redundant information now that the CPU bit is set on AUX records so I can remove this.

I was thinking it might be nice if a tool _only_ wanted to look at HWIDs then it could do the decode correctly with just that. If we remove this then tools will always have to set the CPU sample bit, but it's pretty much required anyway and Perf was already doing it.

James

#26 lore raw

PATCH v2 16/16 coresight: Emit sink ID in the HW_ID packets

In reply to James Clark

For Perf to be able to decode when per-sink trace IDs are used, emit the sink that's being written to for each ETM.

Perf currently errors out if it sees a newer packet version so instead of bumping it, add a new minor version field. This can be used to signify new versions that have backwards compatible fields. Considering this change is only for high core count machines, it doesn't make sense to make a breaking change for everyone.

---
 drivers/hwtracing/coresight/coresight-core.c  | 26 ++++++++++---------
 .../hwtracing/coresight/coresight-etm-perf.c  | 16 ++++++++----
 drivers/hwtracing/coresight/coresight-priv.h  |  1 +
 include/linux/coresight-pmu.h                 | 17 +++++++++---
 4 files changed, 39 insertions(+), 21 deletions(-)
drivers/hwtracing/coresight/coresight-core.c +14 -12
index d5aaeafe5c7d..b6a88df582e0 100644
@@ -487,23 +487,25 @@ struct coresight_device *coresight_get_sink(struct list_head *path)
 	return csdev;
 }
 
+u32 coresight_get_sink_id(struct coresight_device *csdev)
+{
+	if (!csdev->ea)
+		return 0;
+
+	/*
+	 * See function etm_perf_add_symlink_sink() to know where
+	 * this comes from.
+	 */
+	return (u32) (unsigned long) csdev->ea->var;
+}
+
 static int coresight_sink_by_id(struct device *dev, const void *data)
 {
 	struct coresight_device *csdev = to_coresight_device(dev);
-	unsigned long hash;
 
 	if (csdev->type == CORESIGHT_DEV_TYPE_SINK ||
-	     csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
-
-		if (!csdev->ea)
-			return 0;
-		/*
-		 * See function etm_perf_add_symlink_sink() to know where
-		 * this comes from.
-		 */
-		hash = (unsigned long)csdev->ea->var;
-
-		if ((u32)hash == *(u32 *)data)
+	    csdev->type == CORESIGHT_DEV_TYPE_LINKSINK) {
+		if (coresight_get_sink_id(csdev) == *(u32 *)data)
 			return 1;
 	}
 
drivers/hwtracing/coresight/coresight-etm-perf.c +11 -5
index b6f505b50e67..a3a4d07a763f 100644
@@ -453,6 +453,7 @@ static void etm_event_start(struct perf_event *event, int flags)
 	struct coresight_device *sink, *csdev = per_cpu(csdev_src, cpu);
 	struct list_head *path;
 	u64 hw_id;
+	u8 trace_id;
 
 	if (!csdev)
 		goto fail;
@@ -519,11 +520,16 @@ static void etm_event_start(struct perf_event *event, int flags)
 	 */
 	if (!cpumask_test_cpu(cpu, &event_data->aux_hwid_done)) {
 		cpumask_set_cpu(cpu, &event_data->aux_hwid_done);
-		hw_id = FIELD_PREP(CS_AUX_HW_ID_VERSION_MASK,
-				   CS_AUX_HW_ID_CURR_VERSION);
-		hw_id |= FIELD_PREP(CS_AUX_HW_ID_TRACE_ID_MASK,
-				    coresight_trace_id_read_cpu_id_map(cpu,
-								       &sink->perf_sink_id_map));
+
+		trace_id = coresight_trace_id_read_cpu_id_map(cpu, &sink->perf_sink_id_map);
+
+		hw_id = FIELD_PREP(CS_AUX_HW_ID_MAJOR_VERSION_MASK,
+				CS_AUX_HW_ID_MAJOR_VERSION);
+		hw_id |= FIELD_PREP(CS_AUX_HW_ID_MINOR_VERSION_MASK,
+				CS_AUX_HW_ID_MINOR_VERSION);
+		hw_id |= FIELD_PREP(CS_AUX_HW_ID_TRACE_ID_MASK, trace_id);
+		hw_id |= FIELD_PREP(CS_AUX_HW_ID_SINK_ID_MASK, coresight_get_sink_id(sink));
+
 		perf_report_aux_output_id(event, hw_id);
 	}
 
drivers/hwtracing/coresight/coresight-priv.h +1 -0
index 61a46d3bdcc8..05f891ca6b5c 100644
@@ -148,6 +148,7 @@ int coresight_make_links(struct coresight_device *orig,
 			 struct coresight_device *target);
 void coresight_remove_links(struct coresight_device *orig,
 			    struct coresight_connection *conn);
+u32 coresight_get_sink_id(struct coresight_device *csdev);
 
 #if IS_ENABLED(CONFIG_CORESIGHT_SOURCE_ETM3X)
 extern int etm_readl_cp14(u32 off, unsigned int *val);
include/linux/coresight-pmu.h +13 -4
index 51ac441a37c3..89b0ac0014b0 100644
@@ -49,12 +49,21 @@
  * Interpretation of the PERF_RECORD_AUX_OUTPUT_HW_ID payload.
  * Used to associate a CPU with the CoreSight Trace ID.
  * [07:00] - Trace ID - uses 8 bits to make value easy to read in file.
- * [59:08] - Unused (SBZ)
- * [63:60] - Version
+ * [39:08] - Sink ID - as reported in /sys/bus/event_source/devices/cs_etm/sinks/
+ *	      Added in minor version 1.
+ * [55:40] - Unused (SBZ)
+ * [59:56] - Minor Version - previously existing fields are compatible with
+ *	      all minor versions.
+ * [63:60] - Major Version - previously existing fields mean different things
+ *	      in new major versions.
  */
 #define CS_AUX_HW_ID_TRACE_ID_MASK	GENMASK_ULL(7, 0)
-#define CS_AUX_HW_ID_VERSION_MASK	GENMASK_ULL(63, 60)
+#define CS_AUX_HW_ID_SINK_ID_MASK	GENMASK_ULL(39, 8)
 
-#define CS_AUX_HW_ID_CURR_VERSION 0
+#define CS_AUX_HW_ID_MINOR_VERSION_MASK	GENMASK_ULL(59, 56)
+#define CS_AUX_HW_ID_MAJOR_VERSION_MASK	GENMASK_ULL(63, 60)
+
+#define CS_AUX_HW_ID_MAJOR_VERSION 0
+#define CS_AUX_HW_ID_MINOR_VERSION 1
 
 #endif
Signature · 1 line
2.34.1
reviewer Tested-by on the v2 series
#27 lore raw
In reply to James Clark
Quoted 2 lines · James Clark

This will allow sessions with more than CORESIGHT_TRACE_IDS_MAX ETMs as long as there are fewer than that many ETMs connected to each sink.

I tested this patch set on Hikey960 with below combinations:

- Only applied the kernel patches;
- Only applied the perf tool patches;
- Applied both the kernel and perf tool patches.

All of them can pass the test for perf record and perf report commands, I think this patch series is promised on Armv8 platform with small amount of CPUs.

As you said that there might be a concern for running this patch set on a system with big amount of CPUs. Once you think it's ready for merging, please share at here.

Thanks,
Leo