Create a packet-only decode tree for each queue when ordered timestamp decoding is enabled.
Signed-off-by: James Clark james.clark@linaro.org --- 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;