[PATCH 28/34] perf cs-etm: Create timestamp decoders
From: James Clark
Date: Wed Nov 18 2026 - 11:31:33 EST
Create a packet-only decode tree for each queue when ordered timestamp
decoding is enabled.
Signed-off-by: James Clark <james.clark@xxxxxxxxxx>
---
tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 253 +++++++++++++++++-------
tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 2 +-
tools/perf/util/cs-etm.c | 8 +-
3 files changed, 188 insertions(+), 75 deletions(-)
diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c
index 685d8d75912f..56de6c76de68 100644
--- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c
+++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c
@@ -10,6 +10,7 @@
#include <linux/coresight-pmu.h>
#include <linux/err.h>
#include <linux/list.h>
+#include <linux/overflow.h>
#include <linux/zalloc.h>
#include <stdlib.h>
#include <opencsd/c_api/opencsd_c_api.h>
@@ -54,6 +55,7 @@ struct cs_etm_packet_decoder {
struct cs_etm_decoder base;
cs_etm_mem_cb_type mem_access;
struct cs_etm_traceid_ctxt *traceid_ctxt;
+ struct cs_etm_timestamp_decoder *timestamp_decoder;
};
struct cs_etm_timestamp_source {
@@ -65,6 +67,7 @@ struct cs_etm_timestamp_decoder {
struct cs_etm_decoder base;
u64 timestamp; /* Raw trace timestamp. */
u64 timestamp_search_index;
+ u64 timestamp_decode_index;
u32 timestamp_packet_count;
struct cs_etm_timestamp_source sources[];
};
@@ -98,17 +101,37 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_packet_decoder *decoder,
return 0;
}
-int cs_etm_decoder__reset(struct cs_etm_packet_decoder *decoder)
+static int cs_etm_decoder__reset_core(struct cs_etm_decoder *core)
{
ocsd_datapath_resp_t dp_ret;
- decoder->base.prev_return = OCSD_RESP_CONT;
- decoder->base.suppress_printing = true;
- dp_ret = ocsd_dt_process_data(decoder->base.dcd_tree, OCSD_OP_RESET,
+ core->prev_return = OCSD_RESP_CONT;
+ core->suppress_printing = true;
+ dp_ret = ocsd_dt_process_data(core->dcd_tree, OCSD_OP_RESET,
0, 0, NULL, NULL);
- decoder->base.suppress_printing = false;
- if (OCSD_DATA_RESP_IS_FATAL(dp_ret))
- return -1;
+ core->suppress_printing = false;
+ return OCSD_DATA_RESP_IS_FATAL(dp_ret) ? -1 : 0;
+}
+
+static int cs_etm_timestamp_decoder__reset(struct cs_etm_timestamp_decoder *decoder,
+ u64 index)
+{
+ decoder->timestamp_search_index = 0;
+ decoder->timestamp_decode_index = index;
+ decoder->timestamp_packet_count = 0;
+ return cs_etm_decoder__reset_core(&decoder->base);
+}
+
+int cs_etm_decoder__reset(struct cs_etm_packet_decoder *decoder, u64 index)
+{
+ int ret;
+
+ ret = cs_etm_decoder__reset_core(&decoder->base);
+ if (ret)
+ return ret;
+
+ if (decoder->timestamp_decoder)
+ return cs_etm_timestamp_decoder__reset(decoder->timestamp_decoder, index);
return 0;
}
@@ -234,6 +257,42 @@ cs_etm_decoder__init_def_logger_printing(struct cs_etm_decoder_params *d_params,
return 0;
}
+static int cs_etm_decoder__init_core(struct cs_etm_decoder *decoder,
+ struct cs_etm_decoder_params *d_params)
+{
+ ocsd_dcd_tree_src_t format;
+ u32 flags;
+ int ret;
+
+ decoder->data = d_params->data;
+ decoder->prev_return = OCSD_RESP_CONT;
+ format = (d_params->formatted ? OCSD_TRC_SRC_FRAME_FORMATTED :
+ OCSD_TRC_SRC_SINGLE);
+ flags = 0;
+ flags |= (d_params->fsyncs ? OCSD_DFRMTR_HAS_FSYNCS : 0);
+ flags |= (d_params->hsyncs ? OCSD_DFRMTR_HAS_HSYNCS : 0);
+ flags |= (d_params->frame_aligned ? OCSD_DFRMTR_FRAME_MEM_ALIGN : 0);
+
+ /*
+ * Drivers may add barrier frames when used with perf, set up to
+ * handle this. Barriers const of FSYNC packet repeated 4 times.
+ */
+ flags |= OCSD_DFRMTR_RESET_ON_4X_FSYNC;
+
+ /* Create decode tree for the data source */
+ decoder->dcd_tree = ocsd_create_dcd_tree(format, flags);
+
+ if (decoder->dcd_tree == 0)
+ return -1;
+
+ /* init library print logging support */
+ ret = cs_etm_decoder__init_def_logger_printing(d_params, decoder);
+ if (ret != 0)
+ return ret;
+
+ return 0;
+}
+
static ocsd_datapath_resp_t
cs_etm_decoder__do_hard_timestamp(struct cs_etm_queue *etmq,
const ocsd_generic_trace_elem *elem,
@@ -533,7 +592,7 @@ static ocsd_datapath_resp_t cs_etm_decoder__gen_trace_elem_printer(
return resp;
}
-static ocsd_datapath_resp_t __maybe_unused
+static ocsd_datapath_resp_t
cs_etm_decoder__timestamp(const void *context, const ocsd_datapath_op_t op,
const ocsd_trc_index_t indx, const void *packet)
{
@@ -592,73 +651,149 @@ cs_etm_decoder__timestamp(const void *context, const ocsd_datapath_op_t op,
}
static int
-cs_etm_decoder__create_etm_decoder(struct cs_etm_decoder_params *d_params,
+cs_etm_decoder__create_etm_decoder(struct cs_etm_decoder *decoder,
struct cs_etm_trace_params *t_params,
- struct cs_etm_packet_decoder *decoder)
+ int flags, u8 *csid)
{
ocsd_etmv3_cfg config_etmv3;
ocsd_etmv4_cfg trace_config_etmv4;
ocsd_ete_cfg trace_config_ete;
void *trace_config;
- u8 csid;
switch (t_params->protocol) {
case CS_ETM_PROTO_ETMV3:
case CS_ETM_PROTO_PTM:
- csid = (t_params->etmv3.reg_idr & CORESIGHT_TRACE_ID_VAL_MASK);
+ *csid = (t_params->etmv3.reg_idr & CORESIGHT_TRACE_ID_VAL_MASK);
cs_etm_decoder__gen_etmv3_config(t_params, &config_etmv3);
- decoder->base.decoder_name = (t_params->protocol == CS_ETM_PROTO_ETMV3) ?
+ decoder->decoder_name = (t_params->protocol == CS_ETM_PROTO_ETMV3) ?
OCSD_BUILTIN_DCD_ETMV3 :
OCSD_BUILTIN_DCD_PTM;
trace_config = &config_etmv3;
break;
case CS_ETM_PROTO_ETMV4i:
- csid = (t_params->etmv4.reg_traceidr & CORESIGHT_TRACE_ID_VAL_MASK);
+ *csid = (t_params->etmv4.reg_traceidr & CORESIGHT_TRACE_ID_VAL_MASK);
cs_etm_decoder__gen_etmv4_config(t_params, &trace_config_etmv4);
- decoder->base.decoder_name = OCSD_BUILTIN_DCD_ETMV4I;
+ decoder->decoder_name = OCSD_BUILTIN_DCD_ETMV4I;
trace_config = &trace_config_etmv4;
break;
case CS_ETM_PROTO_ETE:
- csid = (t_params->ete.reg_traceidr & CORESIGHT_TRACE_ID_VAL_MASK);
+ *csid = (t_params->ete.reg_traceidr & CORESIGHT_TRACE_ID_VAL_MASK);
cs_etm_decoder__gen_ete_config(t_params, &trace_config_ete);
- decoder->base.decoder_name = OCSD_BUILTIN_DCD_ETE;
+ decoder->decoder_name = OCSD_BUILTIN_DCD_ETE;
trace_config = &trace_config_ete;
break;
default:
return -1;
}
+ return ocsd_dt_create_decoder(decoder->dcd_tree, decoder->decoder_name,
+ flags, trace_config, csid);
+}
+
+static void cs_etm_decoder__free_core(struct cs_etm_decoder *core)
+{
+ ocsd_destroy_dcd_tree(core->dcd_tree);
+ core->dcd_tree = NULL;
+}
+
+static void cs_etm_timestamp_decoder__zfree(struct cs_etm_timestamp_decoder **decoder)
+{
+ if (!*decoder)
+ return;
+
+ cs_etm_decoder__free_core(&(*decoder)->base);
+ zfree(decoder);
+}
+
+static int
+cs_etm_decoder__create_timestamp_decoders(int decoders, struct cs_etm_decoder_params *d_params,
+ struct cs_etm_trace_params t_params[],
+ struct cs_etm_timestamp_decoder *decoder)
+{
+ int i;
+
+ if (cs_etm_decoder__init_core(&decoder->base, d_params))
+ return -1;
+
+ for (i = 0; i < decoders; i++) {
+ struct cs_etm_timestamp_source *source = &decoder->sources[i];
+ u8 csid;
+
+ source->decoder = decoder;
+ source->protocol = t_params[i].protocol;
+ if (cs_etm_decoder__create_etm_decoder(&decoder->base, &t_params[i],
+ OCSD_CREATE_FLG_PACKET_PROC,
+ &csid))
+ return -1;
+ if (ocsd_dt_attach_packet_callback(decoder->base.dcd_tree, csid,
+ OCSD_C_API_CB_PKT_SINK,
+ (void *)cs_etm_decoder__timestamp,
+ source))
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+cs_etm_decoder__create_packet_decoders(int decoders, struct cs_etm_decoder_params *d_params,
+ struct cs_etm_trace_params t_params[],
+ struct cs_etm_packet_decoder *decoder)
+{
+ int decode_flags = OCSD_CREATE_FLG_PACKET_PROC;
+ int i;
+
+ if (cs_etm_decoder__init_core(&decoder->base, d_params))
+ return -1;
+
if (d_params->operation == CS_ETM_OPERATION_DECODE) {
- int decode_flags = OCSD_CREATE_FLG_FULL_DECODER;
+ decode_flags = OCSD_CREATE_FLG_FULL_DECODER;
#ifdef OCSD_OPFLG_N_UNCOND_DIR_BR_CHK
decode_flags |= OCSD_OPFLG_N_UNCOND_DIR_BR_CHK | OCSD_OPFLG_CHK_RANGE_CONTINUE |
ETM4_OPFLG_PKTDEC_AA64_OPCODE_CHK;
#endif
- if (ocsd_dt_create_decoder(decoder->base.dcd_tree,
- decoder->base.decoder_name,
- decode_flags,
- trace_config, &csid))
- return -1;
+ } else if (d_params->operation != CS_ETM_OPERATION_PRINT) {
+ return -1;
+ }
- if (ocsd_dt_set_gen_elem_outfn(decoder->base.dcd_tree,
- cs_etm_decoder__gen_trace_elem_printer,
- decoder))
- return -1;
+ for (i = 0; i < decoders; i++) {
+ u8 csid;
- return 0;
- } else if (d_params->operation == CS_ETM_OPERATION_PRINT) {
- if (ocsd_dt_create_decoder(decoder->base.dcd_tree, decoder->base.decoder_name,
- OCSD_CREATE_FLG_PACKET_PROC,
- trace_config, &csid))
+ if (cs_etm_decoder__create_etm_decoder(&decoder->base, &t_params[i],
+ decode_flags, &csid))
return -1;
-
- if (ocsd_dt_set_pkt_protocol_printer(decoder->base.dcd_tree, csid, CS_PKT_MON))
+ if (d_params->operation == CS_ETM_OPERATION_PRINT &&
+ ocsd_dt_set_pkt_protocol_printer(decoder->base.dcd_tree, csid, CS_PKT_MON))
return -1;
-
- return 0;
}
- return -1;
+ if (d_params->operation == CS_ETM_OPERATION_DECODE &&
+ ocsd_dt_set_gen_elem_outfn(decoder->base.dcd_tree,
+ cs_etm_decoder__gen_trace_elem_printer,
+ decoder))
+ return -1;
+
+ return 0;
+}
+
+static struct cs_etm_timestamp_decoder *
+cs_etm_timestamp_decoder__new(int decoders, struct cs_etm_decoder_params *d_params,
+ struct cs_etm_trace_params t_params[])
+{
+ struct cs_etm_timestamp_decoder *decoder;
+
+ decoder = zalloc(struct_size(decoder, sources, decoders));
+ if (!decoder)
+ return NULL;
+
+ if (cs_etm_decoder__create_timestamp_decoders(decoders, d_params, t_params, decoder))
+ goto err_free_decoder;
+
+ return decoder;
+
+err_free_decoder:
+ cs_etm_timestamp_decoder__zfree(&decoder);
+ return NULL;
}
struct cs_etm_packet_decoder *
@@ -666,49 +801,22 @@ cs_etm_decoder__new(int decoders, struct cs_etm_decoder_params *d_params,
struct cs_etm_trace_params t_params[])
{
struct cs_etm_packet_decoder *decoder;
- ocsd_dcd_tree_src_t format;
- u32 flags;
- int i, ret;
if ((!t_params) || (!d_params))
return NULL;
decoder = zalloc(sizeof(*decoder));
-
if (!decoder)
return NULL;
- decoder->base.data = d_params->data;
- decoder->base.prev_return = OCSD_RESP_CONT;
- format = (d_params->formatted ? OCSD_TRC_SRC_FRAME_FORMATTED :
- OCSD_TRC_SRC_SINGLE);
- flags = 0;
- flags |= (d_params->fsyncs ? OCSD_DFRMTR_HAS_FSYNCS : 0);
- flags |= (d_params->hsyncs ? OCSD_DFRMTR_HAS_HSYNCS : 0);
- flags |= (d_params->frame_aligned ? OCSD_DFRMTR_FRAME_MEM_ALIGN : 0);
-
- /*
- * Drivers may add barrier frames when used with perf, set up to
- * handle this. Barriers const of FSYNC packet repeated 4 times.
- */
- flags |= OCSD_DFRMTR_RESET_ON_4X_FSYNC;
-
- /* Create decode tree for the data source */
- decoder->base.dcd_tree = ocsd_create_dcd_tree(format, flags);
-
- if (decoder->base.dcd_tree == 0)
+ if (cs_etm_decoder__create_packet_decoders(decoders, d_params, t_params, decoder))
goto err_free_decoder;
- /* init library print logging support */
- ret = cs_etm_decoder__init_def_logger_printing(d_params, &decoder->base);
- if (ret != 0)
- goto err_free_decoder;
-
- for (i = 0; i < decoders; i++) {
- ret = cs_etm_decoder__create_etm_decoder(d_params,
- &t_params[i],
- decoder);
- if (ret != 0)
+ if (d_params->operation == CS_ETM_OPERATION_DECODE &&
+ cs_etm__has_timestamps(decoder->base.data)) {
+ decoder->timestamp_decoder = cs_etm_timestamp_decoder__new(decoders, d_params,
+ t_params);
+ if (!decoder->timestamp_decoder)
goto err_free_decoder;
}
@@ -776,8 +884,9 @@ void cs_etm_decoder__zfree(struct cs_etm_packet_decoder **decoder)
if (!(*decoder))
return;
- ocsd_destroy_dcd_tree((*decoder)->base.dcd_tree);
- (*decoder)->base.dcd_tree = NULL;
+ cs_etm_timestamp_decoder__zfree(&(*decoder)->timestamp_decoder);
+
+ cs_etm_decoder__free_core(&(*decoder)->base);
zfree(decoder);
}
diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h
index 376feffd6558..125696520625 100644
--- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h
+++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h
@@ -104,7 +104,7 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_packet_decoder *decoder,
cs_etm_mem_cb_type cb_func);
-int cs_etm_decoder__reset(struct cs_etm_packet_decoder *decoder);
+int cs_etm_decoder__reset(struct cs_etm_packet_decoder *decoder, u64 index);
const char *cs_etm_decoder__get_name(struct cs_etm_packet_decoder *decoder);
#endif /* INCLUDE__CS_ETM_DECODER_H__ */
diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c
index 6bd833d9ed81..d275d3701165 100644
--- a/tools/perf/util/cs-etm.c
+++ b/tools/perf/util/cs-etm.c
@@ -845,7 +845,7 @@ static void cs_etm__dump_event(struct cs_etm_queue *etmq,
buffer_used += consumed;
} while (buffer_used < buffer->size);
- cs_etm_decoder__reset(etmq->decoder);
+ cs_etm_decoder__reset(etmq->decoder, etmq->offset);
}
static int cs_etm__flush_events(struct perf_session *session,
@@ -877,6 +877,9 @@ static void cs_etm__free_traceid_ctxts(struct cs_etm_queue *etmq)
struct cs_etm_traceid_ctxt *tidc;
struct intlist *traceid_ctxts_list = etmq->traceid_ctxts_list;
+ if (!traceid_ctxts_list)
+ return;
+
intlist__for_each_entry_safe(inode, tmp, traceid_ctxts_list) {
priv = (uintptr_t)inode->priv;
idx = priv;
@@ -2085,7 +2088,7 @@ static int cs_etm__get_data_block(struct cs_etm_queue *etmq)
* We cannot assume consecutive blocks in the data file
* are contiguous, reset the decoder to force re-sync.
*/
- ret = cs_etm_decoder__reset(etmq->decoder);
+ ret = cs_etm_decoder__reset(etmq->decoder, etmq->offset);
if (ret)
return ret;
@@ -3251,6 +3254,7 @@ static int cs_etm__create_queue_decoders(struct cs_etm_queue *etmq)
out_free_decoder:
cs_etm_decoder__zfree(&etmq->decoder);
+ cs_etm__free_traceid_ctxts(etmq);
out_free:
zfree(&t_params);
return -EINVAL;
--
2.43.0