The auxtrace_info section contains metadata that describes the number of trace capable CPUs, their ETM version and trace configuration, including trace id values. This information is required by the trace decoder in order to properly decode the compressed trace packets. This patch adds code to read and parse this metadata, and store it for use in configuring instances of the cs-etm trace decoder.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm.c | 196 ++++++++++++++++++++++++++++++++++++++++++++++- tools/perf/util/cs-etm.h | 3 + 2 files changed, 196 insertions(+), 3 deletions(-)

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index e3f4e86..85de61e 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -118,6 +118,8 @@ static void cs_etm__free_events(struct perf_session *session)

static void cs_etm__free(struct perf_session *session) { + size_t i; + struct int_node *inode, *tmp; struct cs_etm_auxtrace *aux = container_of(session->auxtrace, struct cs_etm_auxtrace, auxtrace); @@ -125,6 +127,16 @@ static void cs_etm__free(struct perf_session *session) cs_etm__free_events(session); session->auxtrace = NULL;

+ /* First remove all traceID/CPU# nodes for the RB tree */ + intlist__for_each_entry_safe(inode, tmp, traceid_list) + intlist__remove(traceid_list, inode); + /* Then the RB tree itself */ + intlist__delete(traceid_list); + + for (i = 0; i < aux->num_cpu; i++) + zfree(&aux->metadata[i]); + + zfree(&aux->metadata); zfree(&aux); }

@@ -150,6 +162,53 @@ static int cs_etm__process_auxtrace_event(struct perf_session *session, return 0; }

+static const char * const cs_etm_global_header_fmts[] = { + [CS_HEADER_VERSION_0] = " Header version %llx\n", + [CS_PMU_TYPE_CPUS] = " PMU type/num cpus %llx\n", + [CS_ETM_SNAPSHOT] = " Snapshot %llx\n", +}; + +static const char * const cs_etm_priv_fmts[] = { + [CS_ETM_MAGIC] = " Magic number %llx\n", + [CS_ETM_CPU] = " CPU %lld\n", + [CS_ETM_ETMCR] = " ETMCR %llx\n", + [CS_ETM_ETMTRACEIDR] = " ETMTRACEIDR %llx\n", + [CS_ETM_ETMCCER] = " ETMCCER %llx\n", + [CS_ETM_ETMIDR] = " ETMIDR %llx\n", +}; + +static const char * const cs_etmv4_priv_fmts[] = { + [CS_ETM_MAGIC] = " Magic number %llx\n", + [CS_ETM_CPU] = " CPU %lld\n", + [CS_ETMV4_TRCCONFIGR] = " TRCCONFIGR %llx\n", + [CS_ETMV4_TRCTRACEIDR] = " TRCTRACEIDR %llx\n", + [CS_ETMV4_TRCIDR0] = " TRCIDR0 %llx\n", + [CS_ETMV4_TRCIDR1] = " TRCIDR1 %llx\n", + [CS_ETMV4_TRCIDR2] = " TRCIDR2 %llx\n", + [CS_ETMV4_TRCIDR8] = " TRCIDR8 %llx\n", + [CS_ETMV4_TRCAUTHSTATUS] = " TRCAUTHSTATUS %llx\n", +}; + +static void cs_etm__print_auxtrace_info(u64 *val, size_t num) +{ + unsigned int i, j, cpu; + + for (i = 0; i < CS_HEADER_VERSION_0_MAX; i++) + fprintf(stdout, cs_etm_global_header_fmts[i], val[i]); + + for (i = CS_HEADER_VERSION_0_MAX, cpu = 0; cpu < num; cpu++) { + if (val[i] == __perf_cs_etmv3_magic) + for (j = 0; j < CS_ETM_PRIV_MAX; j++, i++) + fprintf(stdout, cs_etm_priv_fmts[j], val[i]); + else if (val[i] == __perf_cs_etmv4_magic) + for (j = 0; j < CS_ETMV4_PRIV_MAX; j++, i++) + fprintf(stdout, cs_etmv4_priv_fmts[j], val[i]); + else + /* failure.. return */ + return; + } +} + int cs_etm__process_auxtrace_info(union perf_event *event, struct perf_session *session) { @@ -157,8 +216,16 @@ int cs_etm__process_auxtrace_info(union perf_event *event, size_t event_header_size = sizeof(struct perf_event_header); size_t info_header_size; size_t total_size = auxtrace_info->header.size; + size_t priv_size = 0; + size_t num_cpu; struct cs_etm_auxtrace *etm = NULL; - int err = 0; + int err = 0, idx = -1; + u64 *ptr; + u64 *hdr = NULL; + u64 **metadata = NULL; + size_t i, j, k; + unsigned int pmu_type; + struct int_node *inode;

/* * sizeof(auxtrace_info_event::type) + @@ -169,11 +236,119 @@ int cs_etm__process_auxtrace_info(union perf_event *event, if (total_size < (event_header_size + info_header_size)) return -EINVAL;

- etm = zalloc(sizeof(*etm)); + priv_size = total_size - event_header_size - info_header_size; + + /* First the global part */ + ptr = (u64 *) auxtrace_info->priv; + + if (ptr[0] != 0) + return -EINVAL;

- if (!etm) + hdr = zalloc(sizeof(*hdr) * CS_HEADER_VERSION_0_MAX); + if (!hdr) return -ENOMEM;

+ for (i = 0; i < CS_HEADER_VERSION_0_MAX; i++) + hdr[i] = ptr[i]; + num_cpu = hdr[CS_PMU_TYPE_CPUS] & 0xffffffff; + pmu_type = (unsigned int) ((hdr[CS_PMU_TYPE_CPUS] >> 32) & + 0xffffffff); + + /* + * Create an RB tree for traceID-CPU# tuple. Since the conversion has + * to be made for each packet that gets decoded, optimizing access in + * anything other than a sequential array is worth doing. + */ + traceid_list = intlist__new(NULL); + if (!traceid_list) { + err = -ENOMEM; + goto err_free_hdr; + } + + metadata = zalloc(sizeof(*metadata) * num_cpu); + if (!metadata) { + err = -ENOMEM; + goto err_free_traceid_list; + } + + /* + * The metadata is stored in the auxtrace_info section and encodes + * the configuration of the ARM embedded trace macrocell which is + * required by the trace decoder to properly decode the trace due + * to its highly compressed nature. + */ + for (j = 0; j < num_cpu; j++) { + if (ptr[i] == __perf_cs_etmv3_magic) { + metadata[j] = zalloc(sizeof(*metadata[j]) * + CS_ETM_PRIV_MAX); + if (!metadata[j]) { + err = -ENOMEM; + goto err_free_metadata; + } + for (k = 0; k < CS_ETM_PRIV_MAX; k++) + metadata[j][k] = ptr[i + k]; + + /* The traceID is our handle */ + idx = metadata[j][CS_ETM_ETMTRACEIDR]; + i += CS_ETM_PRIV_MAX; + } else if (ptr[i] == __perf_cs_etmv4_magic) { + metadata[j] = zalloc(sizeof(*metadata[j]) * + CS_ETMV4_PRIV_MAX); + if (!metadata[j]) { + err = -ENOMEM; + goto err_free_metadata; + } + for (k = 0; k < CS_ETMV4_PRIV_MAX; k++) + metadata[j][k] = ptr[i + k]; + + /* The traceID is our handle */ + idx = metadata[j][CS_ETMV4_TRCTRACEIDR]; + i += CS_ETMV4_PRIV_MAX; + } + + /* Get an RB node for this CPU */ + inode = intlist__findnew(traceid_list, idx); + + /* Something went wrong, no need to continue */ + if (!inode) { + err = PTR_ERR(inode); + goto err_free_metadata; + } + + /* + * The node for that CPU should not be taken. + * Back out if that's the case. + */ + if (inode->priv) { + err = -EINVAL; + goto err_free_metadata; + } + /* All good, associate the traceID with the CPU# */ + inode->priv = &metadata[j][CS_ETM_CPU]; + } + + /* + * Each of CS_HEADER_VERSION_0_MAX, CS_ETM_PRIV_MAX and + * CS_ETMV4_PRIV_MAX mark how many double words are in the + * global metadata, and each cpu's metadata respectively. + * The following tests if the correct number of double words was + * present in the auxtrace info section. + */ + if (i * 8 != priv_size) { + err = -EINVAL; + goto err_free_metadata; + } + + if (dump_trace) + cs_etm__print_auxtrace_info(auxtrace_info->priv, num_cpu); + + etm = zalloc(sizeof(*etm)); + + if (!etm) { + err = -ENOMEM; + goto err_free_metadata; + } + err = auxtrace_queues__init(&etm->queues); if (err) goto err_free_etm; @@ -198,6 +373,12 @@ int cs_etm__process_auxtrace_info(union perf_event *event, goto err_delete_thread; }

+ etm->num_cpu = num_cpu; + etm->pmu_type = pmu_type; + etm->snapshot_mode = (hdr[CS_ETM_SNAPSHOT] != 0); + etm->timeless_decoding = true; + etm->sampling_mode = false; + etm->metadata = metadata; etm->auxtrace_type = auxtrace_info->type;

etm->auxtrace.process_event = cs_etm__process_event; @@ -225,6 +406,15 @@ int cs_etm__process_auxtrace_info(union perf_event *event, session->auxtrace = NULL; err_free_etm: zfree(&etm); +err_free_metadata: + /* No need to check @metadata[j], free(NULL) is supported */ + for (j = 0; j < num_cpu; j++) + free(metadata[j]); + zfree(&metadata); +err_free_traceid_list: + intlist__delete(traceid_list); +err_free_hdr: + zfree(&hdr);

return err; } diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 9e43ede..fb5a2de 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -64,6 +64,9 @@ enum { CS_ETMV4_PRIV_MAX, };

+/* RB tree for quick conversion between traceID and CPUs */ +struct intlist *traceid_list; + #define KiB(x) ((x) * 1024) #define MiB(x) ((x) * 1024 * 1024)

The trace decoder library, after it has been initialized, works by being repeatedly called to process data and given a pointer into a data buffer. Each call consumes 0 or more of the buffer, and may result in one or more callbacks to the trace packet handler registered with the decoder. Multiple calls may occur as a trace stream atom can encode multiple branch events, and thus generate multiple trace packets in the decoded trace. The function returns a result code that determines whether it needs to be flushed or decoding can continue (up to the point at which the data buffer has been exhausted).

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 60 +++++++++++++++++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 5 +++ 2 files changed, 65 insertions(+)

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 e698387..b277835 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -45,3 +45,63 @@ struct cs_etm_decoder { uint32_t end_tail; struct list_head channel_list; }; + +const struct cs_etm_state * +cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, + uint64_t indx, const uint8_t *buf, + size_t len, size_t *consumed) +{ + int ret = 0; + ocsd_datapath_resp_t dp_ret = decoder->prev_return; + size_t processed = 0; + + if (!decoder) + return NULL; + + if (decoder->packet_count > 0) { + decoder->state.err = ret; + *consumed = processed; + return &decoder->state; + } + + while ((processed < len) && (ret == 0)) { + if (OCSD_DATA_RESP_IS_WAIT(dp_ret)) { + dp_ret = ocsd_dt_process_data(decoder->dcd_tree, + OCSD_OP_FLUSH, + 0, + 0, + NULL, + NULL); + break; + } else if (OCSD_DATA_RESP_IS_CONT(dp_ret)) { + uint32_t count; + + dp_ret = ocsd_dt_process_data(decoder->dcd_tree, + OCSD_OP_DATA, + indx + processed, + len - processed, + &buf[processed], + &count); + processed += count; + } else { + ret = -CS_ETM_ERR_DECODER; + } + + } + /* + * Adjust the counts of processed and previously processed + * data based on the return code and previous return code.. + */ + if (OCSD_DATA_RESP_IS_WAIT(dp_ret)) { + if (OCSD_DATA_RESP_IS_CONT(decoder->prev_return)) + decoder->prev_processed = processed; + processed = 0; + } else if (OCSD_DATA_RESP_IS_WAIT(decoder->prev_return)) { + processed = decoder->prev_processed; + decoder->prev_processed = 0; + } + *consumed = processed; + decoder->prev_return = dp_ret; + decoder->state.err = ret; + return &decoder->state; +} 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 ff4a2c6..9420f0f 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -104,4 +104,9 @@ enum { CS_ETM_OPERATION_PRINT = 1, CS_ETM_OPERATION_DECODE, }; + +const struct cs_etm_state * +cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, + uint64_t indx, const uint8_t *buf, + size_t len, size_t *consumed); #endif /* INCLUDE__CS_ETM_DECODER_H__ */

The decoder library can be configured to do full trace decoding or just parse the compressed trace stream to generate string representation of the individual trace packets that can be printed.

This patch adds code to the decoder library interface that generates basic configuration for ETMv4 trace decoding and configures the trace decoder library to perform basic packet printing for ETMv4, using a callback function registered from the coresight ETM code.

This patch contains code contributed by Mike Leach as a separate commit which had to be adjusted and distributed across several patches.

Cc: Mike Leach mike.leach@linaro.org Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 118 ++++++++++++++++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 5 + 2 files changed, 123 insertions(+)

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 9d601df..d836475 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -114,6 +114,67 @@ cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, return &decoder->state; }

+static void cs_etm_decoder__gen_etmv4_config(struct cs_etm_trace_params *params, + ocsd_etmv4_cfg *config) +{ + config->reg_configr = params->reg_configr; + config->reg_traceidr = params->reg_traceidr; + config->reg_idr0 = params->reg_idr0; + config->reg_idr1 = params->reg_idr1; + config->reg_idr2 = params->reg_idr2; + config->reg_idr8 = params->reg_idr8; + config->reg_idr9 = 0; + config->reg_idr10 = 0; + config->reg_idr11 = 0; + config->reg_idr12 = 0; + config->reg_idr13 = 0; + config->arch_ver = ARCH_V8; + config->core_prof = profile_CortexA; +} + +static ocsd_datapath_resp_t +cs_etm_decoder__etmv4i_packet_printer(const void *context, + const ocsd_datapath_op_t op, + const ocsd_trc_index_t indx, + const ocsd_etmv4_i_pkt *pkt) +{ + const size_t PACKET_STR_LEN = 1024; + ocsd_datapath_resp_t ret = OCSD_RESP_CONT; + char packet_str[PACKET_STR_LEN]; + size_t offset; + struct cs_etm_channel *channel = (struct cs_etm_channel *) context; + struct cs_etm_decoder *decoder = channel->decoder; + + sprintf(packet_str, "%ld: id[%02X] ", (long int) indx, channel->cs_id); + offset = strlen(packet_str); + + switch (op) { + case OCSD_OP_DATA: + if (ocsd_pkt_str(OCSD_PROTOCOL_ETMV4I, + (void *)pkt, packet_str + offset, + PACKET_STR_LEN - offset) != OCSD_OK) + ret = OCSD_RESP_FATAL_INVALID_PARAM; + break; + case OCSD_OP_EOT: + sprintf(packet_str, "**** END OF TRACE id[%02X] ****\n", + channel->cs_id); + break; + case OCSD_OP_FLUSH: + sprintf(packet_str, "**** FLUSH DECODER id[%02X] ****\n", + channel->cs_id); + break; + case OCSD_OP_RESET: + sprintf(packet_str, "**** RESET DECODER ****\n"); + break; + default: + break; + } + + decoder->packet_printer(packet_str); + + return ret; +} + struct cs_etm_channel *cs_etm_decoder__create_channel_item( struct cs_etm_decoder *decoder, uint8_t cs_id) @@ -129,3 +190,60 @@ struct cs_etm_channel *cs_etm_decoder__create_channel_item( list_add(&(chan->chan_list), &(decoder->channel_list)); return chan; } + +static int cs_etm_decoder__create_etmv4i_packet_printer( + struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder) +{ + ocsd_etmv4_cfg trace_config; + int ret = 0; + unsigned char CSID; /* CSID extracted from the config data */ + struct cs_etm_channel *channel; + + if (!d_params->packet_printer) + return -CS_ETM_ERR_PARAM; + + cs_etm_decoder__gen_etmv4_config(t_params, &trace_config); + + decoder->packet_printer = d_params->packet_printer; + + ret = ocsd_dt_create_decoder(decoder->dcd_tree, + OCSD_BUILTIN_DCD_ETMV4I, + OCSD_CREATE_FLG_PACKET_PROC, + (void *)&trace_config, &CSID); + + if (ret != 0) + return -CS_ETM_ERR_DECODER; + + channel = cs_etm_decoder__create_channel_item(decoder, CSID); + if (!channel) + return -CS_ETM_ERR_DECODER; + + ret = ocsd_dt_attach_packet_callback(decoder->dcd_tree, + CSID, OCSD_C_API_CB_PKT_SINK, + cs_etm_decoder__etmv4i_packet_printer, + channel); + + if (ret != 0) + return -CS_ETM_ERR_DECODER; + + return 0; +} + +int +cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder) +{ + int ret; + + if (d_params->operation == CS_ETM_OPERATION_PRINT) + ret = cs_etm_decoder__create_etmv4i_packet_printer(d_params, + t_params, + decoder); + else + ret = -CS_ETM_ERR_PARAM; + + return ret; +} 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 ab9880c..38effcb 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -114,4 +114,9 @@ const struct cs_etm_state * cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, uint64_t indx, const uint8_t *buf, size_t len, size_t *consumed); + +int +cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder); #endif /* INCLUDE__CS_ETM_DECODER_H__ */

perf report may be called with the -D option to dump the raw trace in ASCII.

This patch adds two functions. One to print the string representation of a trace packet. The other takes an auxtrace buffer and instantiates a trace decoder configured only to parse the trace stream into trace packets and print the packets using the first function. Then pushes the trace data through the instantiated decoder to generate the output.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 6 +++++ 2 files changed, 73 insertions(+)

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index d228395..45a8a15 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -82,6 +82,73 @@ struct cs_etm_queue { bool eot; };

+static void cs_etm__packet_dump(const char *pkt_string) +{ + const char *color = PERF_COLOR_BLUE; + + color_fprintf(stdout, color, " %s\n", pkt_string); + fflush(stdout); +} + +void cs_etm__dump_event(struct cs_etm_auxtrace *etm, + struct auxtrace_buffer *buffer) +{ + const char *color = PERF_COLOR_BLUE; + struct cs_etm_decoder_params d_params; + struct cs_etm_trace_params *t_params; + struct cs_etm_decoder *decoder; + size_t buffer_used = 0; + size_t i; + + fprintf(stdout, "\n"); + color_fprintf(stdout, color, + ". ... CoreSight ETM Trace data: size %zu bytes\n", + buffer->size); + + /* Use metadata to fill in trace parameters for trace decoder */ + t_params = zalloc(sizeof(*t_params) * etm->num_cpu); + for (i = 0; i < etm->num_cpu; i++) { + t_params[i].protocol = CS_ETM_PROTO_ETMV4i; + t_params[i].reg_idr0 = etm->metadata[i][CS_ETMV4_TRCIDR0]; + t_params[i].reg_idr1 = etm->metadata[i][CS_ETMV4_TRCIDR1]; + t_params[i].reg_idr2 = etm->metadata[i][CS_ETMV4_TRCIDR2]; + t_params[i].reg_idr8 = etm->metadata[i][CS_ETMV4_TRCIDR8]; + t_params[i].reg_configr = etm->metadata[i][CS_ETMV4_TRCCONFIGR]; + t_params[i].reg_traceidr = + etm->metadata[i][CS_ETMV4_TRCTRACEIDR]; + } + + /* Set decoder parameters to simply print the trace packets */ + d_params.packet_printer = cs_etm__packet_dump; + d_params.operation = CS_ETM_OPERATION_PRINT; + d_params.formatted = true; + d_params.fsyncs = false; + d_params.hsyncs = false; + d_params.frame_aligned = true; + + decoder = cs_etm_decoder__new(etm->num_cpu, &d_params, t_params); + + zfree(&t_params); + + if (!decoder) + return; + do { + size_t consumed; + const struct cs_etm_state *state; + + state = cs_etm_decoder__process_data_block( + decoder, buffer->offset, + &((uint8_t *)buffer->data)[buffer_used], + buffer->size - buffer_used, &consumed); + if (state && state->err) + break; + + buffer_used += consumed; + } while (buffer_used < buffer->size); + + cs_etm_decoder__free(decoder); +} + static int cs_etm__flush_events(struct perf_session *session, struct perf_tool *tool) { diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index fb5a2de..6139280 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -90,4 +90,10 @@ static inline int cs_etm__process_auxtrace_info(union perf_event *event, } #endif

+struct cs_etm_auxtrace; +struct auxtrace_buffer; + +void cs_etm__dump_event(struct cs_etm_auxtrace *etm, + struct auxtrace_buffer *buffer); + #endif

The trace decoder library requires access to the instruction opcodes of the program that was traced in order to be able to decode the trace stream into a series of executed instruction ranges.

This patch implements a function that will be used by the trace decoder interface to enable the trace decoder library to access instruction opcodes stored in DSOs.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 4 ++++ 2 files changed, 53 insertions(+)

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 7f12406..354f3b5 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -208,6 +208,55 @@ static void cs_etm__free(struct perf_session *session) zfree(&aux); }

+uint32_t cs_etm__mem_access(struct cs_etm_queue *etmq, + uint64_t address, + size_t size, + uint8_t *buffer) +{ + struct addr_location al; + uint64_t offset; + struct thread *thread; + struct machine *machine; + uint8_t cpumode; + int len; + + if (!etmq) + return -1; + + machine = etmq->etm->machine; + if (address >= etmq->etm->kernel_start) + cpumode = PERF_RECORD_MISC_KERNEL; + else + cpumode = PERF_RECORD_MISC_USER; + + thread = etmq->thread; + if (!thread) { + if (cpumode != PERF_RECORD_MISC_KERNEL) + return -EINVAL; + thread = etmq->etm->unknown_thread; + } + + thread__find_addr_map(thread, cpumode, MAP__FUNCTION, address, &al); + + if (!al.map || !al.map->dso) + return 0; + + if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR && + dso__data_status_seen(al.map->dso, DSO_DATA_STATUS_SEEN_ITRACE)) + return 0; + + offset = al.map->map_ip(al.map, address); + + map__load(al.map); + + len = dso__data_read_offset(al.map->dso, machine, offset, buffer, size); + + if (len <= 0) + return 0; + + return len; +} + static int cs_etm__process_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample, diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 6139280..d0205a3 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -96,4 +96,8 @@ struct auxtrace_buffer; void cs_etm__dump_event(struct cs_etm_auxtrace *etm, struct auxtrace_buffer *buffer);

+struct cs_etm_queue; + +uint32_t cs_etm__mem_access(struct cs_etm_queue *etmq, uint64_t address, + size_t size, uint8_t *buffer); #endif

Auxtrace events are associated with auxtrace_queues. The auxtrace queues are extended using the "priv" field to point to a cs-etm specific structure associated with each queue.

This patch adds functions to allocate and free these structures, including instantiating the trace decoder library interface, and providing the function used to register a memory access function with the decoder library.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 32 ++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 4 ++ tools/perf/util/cs-etm.c | 80 +++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 4 ++ 4 files changed, 120 insertions(+)

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 1345eda..cfd18ec 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -54,6 +54,38 @@ struct cs_etm_decoder { struct list_head channel_list; };

+static uint32_t cs_etm_decoder__mem_access(const void *context, + const ocsd_vaddr_t address, + const ocsd_mem_space_acc_t mem_space, + const uint32_t req_size, + uint8_t *buffer) +{ + struct cs_etm_decoder *decoder = (struct cs_etm_decoder *) context; + (void) mem_space; + + return decoder->mem_access(decoder->state.data, + address, + req_size, + buffer); +} + +int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, + uint64_t start, uint64_t end, + cs_etm_mem_cb_type cb_func) +{ + int err; + + decoder->mem_access = cb_func; + err = ocsd_dt_add_callback_mem_acc(decoder->dcd_tree, start, end, + OCSD_MEM_SPACE_ANY, + cs_etm_decoder__mem_access, + decoder); + if (err) + return -CS_ETM_ERR_DECODER; + + return 0; +} + const struct cs_etm_state * cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, uint64_t indx, const uint8_t *buf, 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 daaa217..b53dbed 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -122,6 +122,10 @@ cs_etm_decoder__new(uint32_t num_cpu,

void cs_etm_decoder__free(struct cs_etm_decoder *decoder);

+int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, + uint64_t start, uint64_t end, + cs_etm_mem_cb_type cb_func); + int cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, struct cs_etm_trace_params *t_params, diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 527733a..62556a7 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -165,6 +165,8 @@ static void cs_etm__free_queue(void *priv) return;

thread__zput(etmq->thread); + cs_etm_decoder__free(etmq->decoder); + zfree(&etmq->event_buf); free(etmq); }

@@ -208,6 +210,84 @@ static void cs_etm__free(struct perf_session *session) zfree(&aux); }

+struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm, + unsigned int queue_nr) +{ + struct cs_etm_decoder_params d_params; + struct cs_etm_trace_params *t_params; + struct cs_etm_queue *etmq; + size_t i; + + etmq = zalloc(sizeof(*etmq)); + if (!etmq) + return NULL; + + etmq->event_buf = malloc(PERF_SAMPLE_MAX_SIZE); + if (!etmq->event_buf) + goto out_free; + + etmq->etm = etm; + etmq->queue_nr = queue_nr; + etmq->pid = -1; + etmq->tid = -1; + etmq->cpu = -1; + etmq->stop = false; + + /* Use metadata to fill in trace parameters for trace decoder */ + t_params = zalloc(sizeof(*t_params) * etm->num_cpu); + + if (!t_params) + goto out_free; + + for (i = 0; i < etm->num_cpu; i++) { + t_params[i].reg_idr0 = etm->metadata[i][CS_ETMV4_TRCIDR0]; + t_params[i].reg_idr1 = etm->metadata[i][CS_ETMV4_TRCIDR1]; + t_params[i].reg_idr2 = etm->metadata[i][CS_ETMV4_TRCIDR2]; + t_params[i].reg_idr8 = etm->metadata[i][CS_ETMV4_TRCIDR8]; + t_params[i].reg_configr = etm->metadata[i][CS_ETMV4_TRCCONFIGR]; + t_params[i].reg_traceidr = + etm->metadata[i][CS_ETMV4_TRCTRACEIDR]; + t_params[i].protocol = CS_ETM_PROTO_ETMV4i; + } + + /* Set decoder parameters to simply print the trace packets */ + d_params.packet_printer = cs_etm__packet_dump; + d_params.operation = CS_ETM_OPERATION_DECODE; + d_params.formatted = true; + d_params.fsyncs = false; + d_params.hsyncs = false; + d_params.frame_aligned = true; + d_params.data = etmq; + + etmq->decoder = cs_etm_decoder__new(etm->num_cpu, &d_params, t_params); + + zfree(&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; + + etmq->offset = 0; + etmq->eot = false; + + return etmq; + +out_free_decoder: + cs_etm_decoder__free(etmq->decoder); +out_free: + zfree(&etmq->event_buf); + free(etmq); + return NULL; +} + struct cs_etm_queue *cs_etm__cpu_to_etmq(struct cs_etm_auxtrace *etm, int cpu) { int q, j; diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 846cd48..0bb35d6 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -102,4 +102,8 @@ uint32_t cs_etm__mem_access(struct cs_etm_queue *etmq, uint64_t address, size_t size, uint8_t *buffer);

struct cs_etm_queue *cs_etm__cpu_to_etmq(struct cs_etm_auxtrace *etm, int cpu); + +struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm, + unsigned int queue_nr); + #endif

Each decoded trace sample encodes the execution of a sequence of instructions between to "waypoints", typically a branch target and the next taken branch. This sample has to be converted into a perf sample struct before it can be passed on to the perf subsystem.

This patch adds two functions that take a decoded trace packet and populate the perf sample structure and pass it on to perf session event processing. It also adds a function in the decoder library interface to return a decoded trace packet.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 21 ++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 3 ++ tools/perf/util/cs-etm.c | 64 +++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 2 + 4 files changed, 90 insertions(+)

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 cfd18ec..e46ce59 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -86,6 +86,27 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, return 0; }

+int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder, + struct cs_etm_packet *packet) +{ + if (!decoder) + return -CS_ETM_ERR_PARAM; + + if (decoder->packet_count == 0) + return -CS_ETM_ERR_NODATA; + + if (!packet) + return -CS_ETM_ERR_PARAM; + + *packet = decoder->packet_buffer[decoder->head]; + + decoder->head = (decoder->head + 1) & (MAX_BUFFER - 1); + + decoder->packet_count--; + + return 0; +} + const struct cs_etm_state * cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, uint64_t indx, const uint8_t *buf, 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 b53dbed..259059b 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -126,6 +126,9 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, uint64_t start, uint64_t end, cs_etm_mem_cb_type cb_func);

+int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder, + struct cs_etm_packet *packet); + int cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, struct cs_etm_trace_params *t_params, diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 0516301..72c4c9d 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -334,6 +334,70 @@ static int cs_etm__setup_queues(struct cs_etm_auxtrace *etm) return 0; }

+/* + * The cs etm packet encodes an instruction range between a branch target + * and the next taken branch. Generate sample accordingly. + */ +static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq, + struct cs_etm_packet *packet) +{ + int ret = 0; + struct cs_etm_auxtrace *etm = etmq->etm; + union perf_event *event = etmq->event_buf; + struct perf_sample sample = {.ip = 0,}; + uint64_t start_addr = packet->start_addr; + uint64_t end_addr = packet->end_addr; + + event->sample.header.type = PERF_RECORD_SAMPLE; + event->sample.header.misc = PERF_RECORD_MISC_USER; + event->sample.header.size = sizeof(struct perf_event_header); + + sample.ip = start_addr; + sample.pid = etmq->pid; + sample.tid = etmq->tid; + sample.addr = end_addr; + sample.id = etmq->etm->instructions_id; + sample.stream_id = etmq->etm->instructions_id; + /* approximate the period to be the number of words in the range */ + sample.period = (end_addr - start_addr) >> 2; + sample.cpu = packet->cpu; + sample.flags = 0; + sample.insn_len = 1; + sample.cpumode = event->header.misc; + + ret = perf_session__deliver_synth_event(etm->session, event, &sample); + + if (ret) + pr_err( + "CS ETM Trace: failed to deliver instruction event, error %d\n", + ret); + + return ret; +} + +int cs_etm__sample(struct cs_etm_queue *etmq) +{ + struct cs_etm_packet packet; + int err; + + err = cs_etm_decoder__get_packet(etmq->decoder, &packet); + /* if there is no sample, it returns err = -1, no real error */ + if (err) + return err; + + /* + * if the packet contains an instruction range, generate + * an instruction sequence event + */ + if (packet.sample_type & CS_ETM_RANGE) { + err = cs_etm__synth_instruction_sample(etmq, &packet); + if (err) + return err; + } + + return 0; +} + int cs_etm__update_queues(struct cs_etm_auxtrace *etm) { if (etm->queues.new_data) { diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index d1cb049..aa7e0d4 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -108,4 +108,6 @@ struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm,

int cs_etm__update_queues(struct cs_etm_auxtrace *etm);

+int cs_etm__sample(struct cs_etm_queue *etmq); + #endif

The trace is decoded by a separate trace decoder library. This patch adds a function that gets a block of trace data and calls the decoder library interface code to decode the trace data. The decoded trace packets are returned in calls to call-back functions that were passed in when the decoder was configured.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 15 +++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 2 ++ tools/perf/util/cs-etm.c | 44 +++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 2 ++ 4 files changed, 63 insertions(+)

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 e46ce59..4853ee0 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -86,6 +86,21 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, return 0; }

+int cs_etm_decoder__reset(struct cs_etm_decoder *decoder) +{ + ocsd_datapath_resp_t dp_ret; + + if (!decoder) + return -CS_ETM_ERR_PARAM; + + dp_ret = ocsd_dt_process_data(decoder->dcd_tree, OCSD_OP_RESET, + 0, 0, NULL, NULL); + if (OCSD_DATA_RESP_IS_FATAL(dp_ret)) + return -CS_ETM_ERR_DECODER; + + return 0; +} + int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder, struct cs_etm_packet *packet) { 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 259059b..640953a 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -129,6 +129,8 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder, struct cs_etm_packet *packet);

+int cs_etm_decoder__reset(struct cs_etm_decoder *decoder); + int cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, struct cs_etm_trace_params *t_params, diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 936eecd..57bee72 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -476,6 +476,50 @@ int cs_etm__sample(struct cs_etm_queue *etmq) return 0; }

+int cs_etm__run_decoder(struct cs_etm_queue *etmq) +{ + struct cs_etm_buffer buffer; + size_t buffer_used; + int err = 0; + + /* Go through each buffer in the queue and decode them one by one */ +more: + buffer_used = 0; + memset(&buffer, 0, sizeof(buffer)); + err = cs_etm__get_trace(&buffer, etmq); + if (err <= 0) + return err; + /* + * cannot assume consecutive blocks in the data file are contiguous + * trace as will have start/stopped. Reset the decoder to force re-sync + */ + err = cs_etm_decoder__reset(etmq->decoder); + if (err != 0) + return err; + + /* run trace decoder until buffer consumed or end of trace */ + do { + size_t processed = 0; + + etmq->state = cs_etm_decoder__process_data_block( + etmq->decoder, + etmq->offset, + &buffer.buf[buffer_used], + buffer.len - buffer_used, + &processed); + err = (!etmq->state) ? -1 : etmq->state->err; + etmq->offset += processed; + buffer_used += processed; + if (err) + return err; + cs_etm__sample(etmq); + + } while (!etmq->eot && (buffer.len > buffer_used)); + +goto more; + return err; +} + int cs_etm__update_queues(struct cs_etm_auxtrace *etm) { if (etm->queues.new_data) { diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 54d667c..9bf0c2b 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -114,4 +114,6 @@ int cs_etm__sample(struct cs_etm_queue *etmq); int cs_etm__get_trace(struct cs_etm_buffer *buff, struct cs_etm_queue *etmq);

+int cs_etm__run_decoder(struct cs_etm_queue *etmq); + #endif

Each perf event is passed to the coresight etm event processing function, so that coresight specific functionality can be invoked.

This patch adds the coresight etm event processing function which manages the handling of the events that need special handling for trace decoding.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 3 -- tools/perf/util/cs-etm.c | 45 ++++++++++++++++++++++--- 2 files changed, 40 insertions(+), 8 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 4853ee0..e93135e1 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -90,9 +90,6 @@ int cs_etm_decoder__reset(struct cs_etm_decoder *decoder) { ocsd_datapath_resp_t dp_ret;

- if (!decoder) - return -CS_ETM_ERR_PARAM; - dp_ret = ocsd_dt_process_data(decoder->dcd_tree, OCSD_OP_RESET, 0, 0, NULL, NULL); if (OCSD_DATA_RESP_IS_FATAL(dp_ret)) diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index e82236f..36c1ee2 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -31,6 +31,7 @@ #include "evlist.h" #include "intlist.h" #include "machine.h" +#include "map.h" #include "perf.h" #include "thread.h" #include "thread_map.h" @@ -706,11 +707,45 @@ static int cs_etm__process_event(struct perf_session *session, struct perf_sample *sample, struct perf_tool *tool) { - (void) session; - (void) event; - (void) sample; - (void) tool; - return 0; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + struct cs_etm_queue *etmq; + u64 timestamp; + int err = 0; + + if (dump_trace) + return 0; + + if (!tool->ordered_events) { + pr_err("CoreSight ETM Trace requires ordered events\n"); + return -EINVAL; + } + + if (sample->time && (sample->time != (u64) -1)) + timestamp = sample->time; + else + timestamp = 0; + + if (timestamp || etm->timeless_decoding) { + err = cs_etm__update_queues(etm); + if (err) + return err; + } + + etmq = cs_etm__cpu_to_etmq(etm, sample->cpu); + if (!etmq) + return -1; + + if (etm->timeless_decoding) { + if (event->header.type == PERF_RECORD_EXIT) + err = cs_etm__process_timeless_queues(etm, + event->fork.tid, + sample->time); + } else if (timestamp) + err = cs_etm__process_queues(etm, timestamp); + + return err; }

static int cs_etm__process_auxtrace_event(struct perf_session *session,

This patch adds the functions needed to generate configuration for the instruction events that are generated from the trace decoding, including which fields are populated. In particular this is for hardware instruction events.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+)

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 6b02126..43fffdb 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -497,6 +497,105 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq, return ret; }

+struct cs_etm_synth { + struct perf_tool dummy_tool; + struct perf_session *session; +}; + +static int cs_etm__event_synth(struct perf_tool *tool, + union perf_event *event, + struct perf_sample *sample, + struct machine *machine) +{ + struct cs_etm_synth *cs_etm_synth = + container_of(tool, struct cs_etm_synth, dummy_tool); + + (void) sample; + (void) machine; + + return perf_session__deliver_synth_event(cs_etm_synth->session, + event, NULL); +} + +static int cs_etm__synth_event(struct perf_session *session, + struct perf_event_attr *attr, u64 id) +{ + struct cs_etm_synth cs_etm_synth; + + memset(&cs_etm_synth, 0, sizeof(struct cs_etm_synth)); + cs_etm_synth.session = session; + + return perf_event__synthesize_attr(&cs_etm_synth.dummy_tool, attr, 1, + &id, cs_etm__event_synth); +} + +static int cs_etm__synth_events(struct cs_etm_auxtrace *etm, + struct perf_session *session) +{ + struct perf_evlist *evlist = session->evlist; + struct perf_evsel *evsel; + struct perf_event_attr attr; + bool found = false; + u64 id; + int err; + + evlist__for_each_entry(evlist, evsel) { + if (evsel->attr.type == etm->pmu_type) { + found = true; + break; + } + } + + if (!found) { + pr_debug("No selected events with CoreSight Trace data\n"); + return 0; + } + + memset(&attr, 0, sizeof(struct perf_event_attr)); + attr.size = sizeof(struct perf_event_attr); + attr.type = PERF_TYPE_HARDWARE; + attr.sample_type = evsel->attr.sample_type & PERF_SAMPLE_MASK; + attr.sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID | + PERF_SAMPLE_PERIOD; + if (etm->timeless_decoding) + attr.sample_type &= ~(u64)PERF_SAMPLE_TIME; + else + attr.sample_type |= PERF_SAMPLE_TIME; + + attr.exclude_user = evsel->attr.exclude_user; + attr.exclude_kernel = evsel->attr.exclude_kernel; + attr.exclude_hv = evsel->attr.exclude_hv; + attr.exclude_host = evsel->attr.exclude_host; + attr.exclude_guest = evsel->attr.exclude_guest; + attr.sample_id_all = evsel->attr.sample_id_all; + attr.read_format = evsel->attr.read_format; + + /* create new id val to be a fixed offset from evsel id */ + id = evsel->id[0] + 1000000000; + + if (!id) + id = 1; + + if (etm->synth_opts.instructions) { + attr.config = PERF_COUNT_HW_INSTRUCTIONS; + attr.sample_period = etm->synth_opts.period; + etm->instructions_sample_period = attr.sample_period; + err = cs_etm__synth_event(session, &attr, id); + + if (err) { + pr_err("%s: failed to synthesize 'instructions' event type\n", + __func__); + return err; + } + etm->sample_instructions = true; + etm->instructions_sample_type = attr.sample_type; + etm->instructions_id = id; + } + + etm->synth_needs_swap = evsel->needs_swap; + return 0; +} + int cs_etm__sample(struct cs_etm_queue *etmq) { struct cs_etm_packet packet; @@ -1038,6 +1137,20 @@ int cs_etm__process_auxtrace_info(union perf_event *event, if (dump_trace) return 0;

+ if (session->itrace_synth_opts && session->itrace_synth_opts->set) + etm->synth_opts = *session->itrace_synth_opts; + else + itrace_synth_opts__set_default(&etm->synth_opts); + + etm->synth_opts.branches = false; + etm->synth_opts.callchain = false; + etm->synth_opts.calls = false; + etm->synth_opts.returns = false; + + err = cs_etm__synth_events(etm, session); + if (err) + goto err_delete_thread; + err = auxtrace_queues__process_index(&etm->queues, session); if (err) goto err_delete_thread;

The full decode of a coresight trace requires the decoder library be properly configured, with a "generic" packet handler function. The packets are emitted into a buffer with a delay so as to be able to add additional information to the most recently decoded packet to encode information about taking/returning from interrupts/exceptions.

This patch adds the code to configure the trace decoder for full packet decode, provides the function to handle the trace packets, buffer, and annotate them when necessary.

Signed-off-by: Tor Jeremiassen tor@ti.com --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 164 ++++++++++++++++++++++++ 1 file changed, 164 insertions(+)

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 e79d597..e32f7af 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -23,6 +23,7 @@ #include "cs-etm-decoder.h" #include "c_api/opencsd_c_api.h" #include "etmv4/trc_pkt_types_etmv4.h" +#include "intlist.h" #include "ocsd_if_types.h" #include "util.h"

@@ -86,6 +87,24 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, return 0; }

+static int cs_etm_decoder__flush_packet(struct cs_etm_decoder *decoder) +{ + int err = 0; + + if (!decoder) + return -CS_ETM_ERR_PARAM; + + if (decoder->packet_count >= MAX_BUFFER - 1) + return -CS_ETM_ERR_OVERFLOW; + + if (decoder->tail != decoder->end_tail) { + decoder->tail = (decoder->tail + 1) & (MAX_BUFFER - 1); + decoder->packet_count++; + } + + return err; +} + int cs_etm_decoder__reset(struct cs_etm_decoder *decoder) { ocsd_datapath_resp_t dp_ret; @@ -214,6 +233,120 @@ static void cs_etm_decoder__gen_etmv4_config(struct cs_etm_trace_params *params, config->core_prof = profile_CortexA; }

+static int cs_etm_decoder__buffer_packet(struct cs_etm_decoder *decoder, + const ocsd_generic_trace_elem *elem, + const uint8_t trace_chan_id, + enum cs_etm_sample_type sample_type) +{ + int err = 0; + uint32_t et = 0; + struct int_node *inode = NULL; + + if (!decoder) + return -CS_ETM_ERR_PARAM; + + if (decoder->packet_count >= MAX_BUFFER - 1) + return -CS_ETM_ERR_OVERFLOW; + + err = cs_etm_decoder__flush_packet(decoder); + + if (err) + return err; + + et = decoder->end_tail; + /* Search the RB tree for the cpu associated with this traceID */ + inode = intlist__find(traceid_list, trace_chan_id); + if (!inode) + return PTR_ERR(inode); + + decoder->packet_buffer[et].sample_type = sample_type; + decoder->packet_buffer[et].start_addr = elem->st_addr; + decoder->packet_buffer[et].end_addr = elem->en_addr; + decoder->packet_buffer[et].exc = false; + decoder->packet_buffer[et].exc_ret = false; + decoder->packet_buffer[et].cpu = *((int *)inode->priv); + + et = (et + 1) & (MAX_BUFFER - 1); + + decoder->end_tail = et; + + return err; +} + +static int cs_etm_decoder__mark_exception(struct cs_etm_decoder *decoder) +{ + int err = 0; + + if (!decoder) + return -CS_ETM_ERR_PARAM; + + decoder->packet_buffer[decoder->end_tail].exc = true; + + return err; +} + +static int cs_etm_decoder__mark_exception_return(struct cs_etm_decoder *decoder) +{ + int err = 0; + + if (!decoder) + return -CS_ETM_ERR_PARAM; + + decoder->packet_buffer[decoder->end_tail].exc_ret = true; + + return err; +} + +static ocsd_datapath_resp_t cs_etm_decoder__gen_trace_elem_printer( + const void *context, + const ocsd_trc_index_t indx, + const uint8_t trace_chan_id, + const ocsd_generic_trace_elem *elem) +{ + ocsd_datapath_resp_t resp = OCSD_RESP_CONT; + struct cs_etm_decoder *decoder = (struct cs_etm_decoder *) context; + + (void) indx; + (void) trace_chan_id; + + switch (elem->elem_type) { + case OCSD_GEN_TRC_ELEM_UNKNOWN: + break; + case OCSD_GEN_TRC_ELEM_NO_SYNC: + decoder->trace_on = false; + break; + case OCSD_GEN_TRC_ELEM_TRACE_ON: + decoder->trace_on = true; + break; + case OCSD_GEN_TRC_ELEM_INSTR_RANGE: + cs_etm_decoder__buffer_packet(decoder, elem, + trace_chan_id, CS_ETM_RANGE); + resp = OCSD_RESP_WAIT; + break; + case OCSD_GEN_TRC_ELEM_EXCEPTION: + cs_etm_decoder__mark_exception(decoder); + break; + case OCSD_GEN_TRC_ELEM_EXCEPTION_RET: + cs_etm_decoder__mark_exception_return(decoder); + break; + case OCSD_GEN_TRC_ELEM_PE_CONTEXT: + case OCSD_GEN_TRC_ELEM_EO_TRACE: + case OCSD_GEN_TRC_ELEM_ADDR_NACC: + case OCSD_GEN_TRC_ELEM_TIMESTAMP: + case OCSD_GEN_TRC_ELEM_CYCLE_COUNT: + case OCSD_GEN_TRC_ELEM_ADDR_UNKNOWN: + case OCSD_GEN_TRC_ELEM_EVENT: + case OCSD_GEN_TRC_ELEM_SWTRACE: + case OCSD_GEN_TRC_ELEM_CUSTOM: + default: + break; + } + + decoder->state.err = 0; + + return resp; +} + static ocsd_datapath_resp_t cs_etm_decoder__etmv4i_packet_printer(const void *context, const ocsd_datapath_op_t op, @@ -313,6 +446,33 @@ static int cs_etm_decoder__create_etmv4i_packet_printer( return 0; }

+static int cs_etm_decoder__create_etmv4i_packet_decoder( + struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder) +{ + ocsd_etmv4_cfg trace_config; + int ret = 0; + unsigned char CSID; /* CSID extracted from the config data */ + + decoder->packet_printer = d_params->packet_printer; + + cs_etm_decoder__gen_etmv4_config(t_params, &trace_config); + + ret = ocsd_dt_create_decoder(decoder->dcd_tree, + OCSD_BUILTIN_DCD_ETMV4I, + OCSD_CREATE_FLG_FULL_DECODER, + (void *)&trace_config, &CSID); + + if (ret != 0) + return -CS_ETM_ERR_DECODER; + + ret = ocsd_dt_set_gen_elem_outfn(decoder->dcd_tree, + cs_etm_decoder__gen_trace_elem_printer, + decoder); + return ret; +} + int cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, struct cs_etm_trace_params *t_params, @@ -324,6 +484,10 @@ cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, ret = cs_etm_decoder__create_etmv4i_packet_printer(d_params, t_params, decoder); + else if (d_params->operation == CS_ETM_OPERATION_DECODE) + ret = cs_etm_decoder__create_etmv4i_packet_decoder(d_params, + t_params, + decoder); else ret = -CS_ETM_ERR_PARAM;

On Fri, Sep 22, 2017 at 04:03:19AM -0500, Tor Jeremiassen wrote:

The auxtrace_info section contains metadata that describes the number of trace capable CPUs, their ETM version and trace configuration, including trace id values. This information is required by the trace decoder in order to properly decode the compressed trace packets. This patch adds code to read and parse this metadata, and store it for use in configuring instances of the cs-etm trace decoder.

Signed-off-by: Tor Jeremiassen tor@ti.com

tools/perf/util/cs-etm.c | 196 ++++++++++++++++++++++++++++++++++++++++++++++- tools/perf/util/cs-etm.h | 3 + 2 files changed, 196 insertions(+), 3 deletions(-)

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index e3f4e86..85de61e 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -118,6 +118,8 @@ static void cs_etm__free_events(struct perf_session *session) static void cs_etm__free(struct perf_session *session) {

• size_t i;
• struct int_node *inode, *tmp; struct cs_etm_auxtrace *aux = container_of(session->auxtrace, struct cs_etm_auxtrace, auxtrace);

@@ -125,6 +127,16 @@ static void cs_etm__free(struct perf_session *session) cs_etm__free_events(session); session->auxtrace = NULL;

• /* First remove all traceID/CPU# nodes for the RB tree */
• intlist__for_each_entry_safe(inode, tmp, traceid_list)

• intlist__remove(traceid_list, inode);
  

• /* Then the RB tree itself */
• intlist__delete(traceid_list);
• for (i = 0; i < aux->num_cpu; i++)

• zfree(&aux->metadata[i]);
  

• zfree(&aux->metadata); zfree(&aux);

} @@ -150,6 +162,53 @@ static int cs_etm__process_auxtrace_event(struct perf_session *session, return 0; } +static const char * const cs_etm_global_header_fmts[] = {

• [CS_HEADER_VERSION_0] = " Header version %llx\n",
• [CS_PMU_TYPE_CPUS] = " PMU type/num cpus %llx\n",
• [CS_ETM_SNAPSHOT] = " Snapshot %llx\n",

+};

+static const char * const cs_etm_priv_fmts[] = {

• [CS_ETM_MAGIC] = " Magic number %llx\n",
• [CS_ETM_CPU] = " CPU %lld\n",
• [CS_ETM_ETMCR] = " ETMCR %llx\n",
• [CS_ETM_ETMTRACEIDR] = " ETMTRACEIDR %llx\n",
• [CS_ETM_ETMCCER] = " ETMCCER %llx\n",
• [CS_ETM_ETMIDR] = " ETMIDR %llx\n",

+};

+static const char * const cs_etmv4_priv_fmts[] = {

• [CS_ETM_MAGIC] = " Magic number %llx\n",
• [CS_ETM_CPU] = " CPU %lld\n",
• [CS_ETMV4_TRCCONFIGR] = " TRCCONFIGR %llx\n",
• [CS_ETMV4_TRCTRACEIDR] = " TRCTRACEIDR %llx\n",
• [CS_ETMV4_TRCIDR0] = " TRCIDR0 %llx\n",
• [CS_ETMV4_TRCIDR1] = " TRCIDR1 %llx\n",
• [CS_ETMV4_TRCIDR2] = " TRCIDR2 %llx\n",
• [CS_ETMV4_TRCIDR8] = " TRCIDR8 %llx\n",
• [CS_ETMV4_TRCAUTHSTATUS] = " TRCAUTHSTATUS %llx\n",

+};

+static void cs_etm__print_auxtrace_info(u64 *val, size_t num) +{

• unsigned int i, j, cpu;
• for (i = 0; i < CS_HEADER_VERSION_0_MAX; i++)

• fprintf(stdout, cs_etm_global_header_fmts[i], val[i]);
  

• for (i = CS_HEADER_VERSION_0_MAX, cpu = 0; cpu < num; cpu++) {

• if (val[i] == __perf_cs_etmv3_magic)
  

• 	for (j = 0; j < CS_ETM_PRIV_MAX; j++, i++)
  

• 		fprintf(stdout, cs_etm_priv_fmts[j], val[i]);
  

• else if (val[i] == __perf_cs_etmv4_magic)
  

• 	for (j = 0; j < CS_ETMV4_PRIV_MAX; j++, i++)
  

• 		fprintf(stdout, cs_etmv4_priv_fmts[j], val[i]);
  

• else
  

• 	/* failure.. return */
  

• 	return;
  

• }

+}

int cs_etm__process_auxtrace_info(union perf_event *event, struct perf_session *session) { @@ -157,8 +216,16 @@ int cs_etm__process_auxtrace_info(union perf_event *event, size_t event_header_size = sizeof(struct perf_event_header); size_t info_header_size; size_t total_size = auxtrace_info->header.size;

• size_t priv_size = 0;
• size_t num_cpu;

I moved those to int.

struct cs_etm_auxtrace *etm = NULL;

• int err = 0;

• int err = 0, idx = -1;
• u64 *ptr;
• u64 *hdr = NULL;
• u64 **metadata = NULL;
• size_t i, j, k;

Same here.

• unsigned int pmu_type;
• struct int_node *inode;

/* * sizeof(auxtrace_info_event::type) + @@ -169,11 +236,119 @@ int cs_etm__process_auxtrace_info(union perf_event *event, if (total_size < (event_header_size + info_header_size)) return -EINVAL;

• etm = zalloc(sizeof(*etm));

• priv_size = total_size - event_header_size - info_header_size;
• /* First the global part */
• ptr = (u64 *) auxtrace_info->priv;
• if (ptr[0] != 0)

• return -EINVAL;
  

• if (!etm)

• hdr = zalloc(sizeof(*hdr) * CS_HEADER_VERSION_0_MAX);
• if (!hdr) return -ENOMEM;

• for (i = 0; i < CS_HEADER_VERSION_0_MAX; i++)

• hdr[i] = ptr[i];
  

• num_cpu = hdr[CS_PMU_TYPE_CPUS] & 0xffffffff;
• pmu_type = (unsigned int) ((hdr[CS_PMU_TYPE_CPUS] >> 32) &

• 		    0xffffffff);
  

• /*

• * Create an RB tree for traceID-CPU# tuple. Since the conversion has
  

• * to be made for each packet that gets decoded, optimizing access in
  

• * anything other than a sequential array is worth doing.
  

• */
  

• traceid_list = intlist__new(NULL);
• if (!traceid_list) {

• err = -ENOMEM;
  

• goto err_free_hdr;
  

• }
• metadata = zalloc(sizeof(*metadata) * num_cpu);
• if (!metadata) {

• err = -ENOMEM;
  

• goto err_free_traceid_list;
  

• }
• /*

• * The metadata is stored in the auxtrace_info section and encodes
  

• * the configuration of the ARM embedded trace macrocell which is
  

• * required by the trace decoder to properly decode the trace due
  

• * to its highly compressed nature.
  

• */
  

• for (j = 0; j < num_cpu; j++) {

• if (ptr[i] == __perf_cs_etmv3_magic) {
  

• 	metadata[j] = zalloc(sizeof(*metadata[j]) *
  

• 			     CS_ETM_PRIV_MAX);
  

• 	if (!metadata[j]) {
  

• 		err = -ENOMEM;
  

• 		goto err_free_metadata;
  

• 	}
  

• 	for (k = 0; k < CS_ETM_PRIV_MAX; k++)
  

• 		metadata[j][k] = ptr[i + k];
  

• 	/* The traceID is our handle */
  

• 	idx = metadata[j][CS_ETM_ETMTRACEIDR];
  

• 	i += CS_ETM_PRIV_MAX;
  

• } else if (ptr[i] == __perf_cs_etmv4_magic) {
  

• 	metadata[j] = zalloc(sizeof(*metadata[j]) *
  

• 			     CS_ETMV4_PRIV_MAX);
  

• 	if (!metadata[j]) {
  

• 		err = -ENOMEM;
  

• 		goto err_free_metadata;
  

• 	}
  

• 	for (k = 0; k < CS_ETMV4_PRIV_MAX; k++)
  

• 		metadata[j][k] = ptr[i + k];
  

• 	/* The traceID is our handle */
  

• 	idx = metadata[j][CS_ETMV4_TRCTRACEIDR];
  

• 	i += CS_ETMV4_PRIV_MAX;
  

• }
  

• /* Get an RB node for this CPU */
  

• inode = intlist__findnew(traceid_list, idx);
  

• /* Something went wrong, no need to continue */
  

• if (!inode) {
  

• 	err = PTR_ERR(inode);
  

• 	goto err_free_metadata;
  

• }
  

• /*
  

•  * The node for that CPU should not be taken.
  

•  * Back out if that's the case.
  

•  */
  

• if (inode->priv) {
  

• 	err = -EINVAL;
  

• 	goto err_free_metadata;
  

• }
  

• /* All good, associate the traceID with the CPU# */
  

• inode->priv = &metadata[j][CS_ETM_CPU];
  

• }
• /*

• * Each of CS_HEADER_VERSION_0_MAX, CS_ETM_PRIV_MAX and
  

• * CS_ETMV4_PRIV_MAX mark how many double words are in the
  

• * global metadata, and each cpu's metadata respectively.
  

• * The following tests if the correct number of double words was
  

• * present in the auxtrace info section.
  

• */
  

• if (i * 8 != priv_size) {

• err = -EINVAL;
  

• goto err_free_metadata;
  

• }
• if (dump_trace)

• cs_etm__print_auxtrace_info(auxtrace_info->priv, num_cpu);
  

• etm = zalloc(sizeof(*etm));
• if (!etm) {

• err = -ENOMEM;
  

• goto err_free_metadata;
  

• }
• err = auxtrace_queues__init(&etm->queues); if (err) goto err_free_etm;

@@ -198,6 +373,12 @@ int cs_etm__process_auxtrace_info(union perf_event *event, goto err_delete_thread; }

• etm->num_cpu = num_cpu;
• etm->pmu_type = pmu_type;
• etm->snapshot_mode = (hdr[CS_ETM_SNAPSHOT] != 0);
• etm->timeless_decoding = true;
• etm->sampling_mode = false;
• etm->metadata = metadata; etm->auxtrace_type = auxtrace_info->type;

etm->auxtrace.process_event = cs_etm__process_event; @@ -225,6 +406,15 @@ int cs_etm__process_auxtrace_info(union perf_event *event, session->auxtrace = NULL; err_free_etm: zfree(&etm); +err_free_metadata:

• /* No need to check @metadata[j], free(NULL) is supported */
• for (j = 0; j < num_cpu; j++)

• free(metadata[j]);
  

• zfree(&metadata);

+err_free_traceid_list:

• intlist__delete(traceid_list);

+err_free_hdr:

• zfree(&hdr);

return err; } diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 9e43ede..fb5a2de 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -64,6 +64,9 @@ enum { CS_ETMV4_PRIV_MAX, }; +/* RB tree for quick conversion between traceID and CPUs */ +struct intlist *traceid_list;

#define KiB(x) ((x) * 1024) #define MiB(x) ((x) * 1024 * 1024) -- 2.7.4

---

CoreSight mailing list CoreSight@lists.linaro.org https://lists.linaro.org/mailman/listinfo/coresight

On Fri, Sep 22, 2017 at 04:03:21AM -0500, Tor Jeremiassen wrote:

The trace decoder library, after it has been initialized, works by being repeatedly called to process data and given a pointer into a data buffer. Each call consumes 0 or more of the buffer, and may result in one or more callbacks to the trace packet handler registered with the decoder. Multiple calls may occur as a trace stream atom can encode multiple branch events, and thus generate multiple trace packets in the decoded trace. The function returns a result code that determines whether it needs to be flushed or decoding can continue (up to the point at which the data buffer has been exhausted).

Signed-off-by: Tor Jeremiassen tor@ti.com

tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 60 +++++++++++++++++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 5 +++ 2 files changed, 65 insertions(+)

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 e698387..b277835 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -45,3 +45,63 @@ struct cs_etm_decoder { uint32_t end_tail; struct list_head channel_list; };

+const struct cs_etm_state * +cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder,

• 		   uint64_t indx, const uint8_t *buf,
  

• 		   size_t len, size_t *consumed)
  

+{

• int ret = 0;
• ocsd_datapath_resp_t dp_ret = decoder->prev_return;
• size_t processed = 0;
• if (!decoder)

• return NULL;
  

• if (decoder->packet_count > 0) {

• decoder->state.err = ret;
  

• *consumed = processed;
  

• return &decoder->state;
  

• }
• while ((processed < len) && (ret == 0)) {

• if (OCSD_DATA_RESP_IS_WAIT(dp_ret)) {
  

• 	dp_ret = ocsd_dt_process_data(decoder->dcd_tree,
  

• 				      OCSD_OP_FLUSH,
  

• 				      0,
  

• 				      0,
  

• 				      NULL,
  

• 				      NULL);
  

• 	break;
  

• } else if (OCSD_DATA_RESP_IS_CONT(dp_ret)) {
  

• 	uint32_t count;
  

• 	dp_ret = ocsd_dt_process_data(decoder->dcd_tree,
  

• 				      OCSD_OP_DATA,
  

• 				      indx + processed,
  

• 				      len - processed,
  

• 				      &buf[processed],
  

• 				      &count);
  

• 	processed += count;
  

• } else {
  

• 	ret = -CS_ETM_ERR_DECODER;
  

• }
  

I removed the extra line.

• }

I added a new line here.

• /*

• * Adjust the counts of processed and previously processed
  

• * data based on the return code and previous return code..
  

• */
  

• if (OCSD_DATA_RESP_IS_WAIT(dp_ret)) {

• if (OCSD_DATA_RESP_IS_CONT(decoder->prev_return))
  

• 	decoder->prev_processed = processed;
  

• processed = 0;
  

• } else if (OCSD_DATA_RESP_IS_WAIT(decoder->prev_return)) {

• processed = decoder->prev_processed;
  

• decoder->prev_processed = 0;
  

• }

here

• *consumed = processed;
• decoder->prev_return = dp_ret;
• decoder->state.err = ret;

and here.

• return &decoder->state;

+} 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 ff4a2c6..9420f0f 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -104,4 +104,9 @@ enum { CS_ETM_OPERATION_PRINT = 1, CS_ETM_OPERATION_DECODE, };

+const struct cs_etm_state * +cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder,

• 		   uint64_t indx, const uint8_t *buf,
  

• 		   size_t len, size_t *consumed);
  

#endif /* INCLUDE__CS_ETM_DECODER_H__ */

2.7.4

---

CoreSight mailing list CoreSight@lists.linaro.org https://lists.linaro.org/mailman/listinfo/coresight

On Fri, Sep 22, 2017 at 04:03:23AM -0500, Tor Jeremiassen wrote:

The decoder library can be configured to do full trace decoding or just parse the compressed trace stream to generate string representation of the individual trace packets that can be printed.

This patch adds code to the decoder library interface that generates basic configuration for ETMv4 trace decoding and configures the trace decoder library to perform basic packet printing for ETMv4, using a callback function registered from the coresight ETM code.

This patch contains code contributed by Mike Leach as a separate commit which had to be adjusted and distributed across several patches.

Cc: Mike Leach mike.leach@linaro.org Signed-off-by: Tor Jeremiassen tor@ti.com

---

tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 118 ++++++++++++++++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 5 + 2 files changed, 123 insertions(+)

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 9d601df..d836475 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -114,6 +114,67 @@ cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, return &decoder->state; } +static void cs_etm_decoder__gen_etmv4_config(struct cs_etm_trace_params *params,

• 			     ocsd_etmv4_cfg *config)
  

+{

• config->reg_configr = params->reg_configr;
• config->reg_traceidr = params->reg_traceidr;
• config->reg_idr0 = params->reg_idr0;
• config->reg_idr1 = params->reg_idr1;
• config->reg_idr2 = params->reg_idr2;
• config->reg_idr8 = params->reg_idr8;
• config->reg_idr9 = 0;
• config->reg_idr10 = 0;
• config->reg_idr11 = 0;
• config->reg_idr12 = 0;
• config->reg_idr13 = 0;
• config->arch_ver = ARCH_V8;
• config->core_prof = profile_CortexA;

+}

+static ocsd_datapath_resp_t +cs_etm_decoder__etmv4i_packet_printer(const void *context,

• 		      const ocsd_datapath_op_t op,
  

• 		      const ocsd_trc_index_t indx,
  

• 		      const ocsd_etmv4_i_pkt *pkt)
  

+{

• const size_t PACKET_STR_LEN = 1024;
• ocsd_datapath_resp_t ret = OCSD_RESP_CONT;
• char packet_str[PACKET_STR_LEN];
• size_t offset;
• struct cs_etm_channel *channel = (struct cs_etm_channel *) context;
• struct cs_etm_decoder *decoder = channel->decoder;
• sprintf(packet_str, "%ld: id[%02X] ", (long int) indx, channel->cs_id);
• offset = strlen(packet_str);
• switch (op) {
• case OCSD_OP_DATA:

• if (ocsd_pkt_str(OCSD_PROTOCOL_ETMV4I,
  

• 		 (void *)pkt, packet_str + offset,
  

• 		 PACKET_STR_LEN - offset) != OCSD_OK)
  

• 	ret = OCSD_RESP_FATAL_INVALID_PARAM;
  

• break;
  

• case OCSD_OP_EOT:

• sprintf(packet_str, "**** END OF TRACE id[%02X] ****\n",
  

• 	channel->cs_id);
  

• break;
  

• case OCSD_OP_FLUSH:

• sprintf(packet_str, "**** FLUSH DECODER id[%02X] ****\n",
  

• 	channel->cs_id);
  

• break;
  

• case OCSD_OP_RESET:

• sprintf(packet_str, "**** RESET DECODER ****\n");
  

• break;
  

• default:

• break;
  

• }
• decoder->packet_printer(packet_str);
• return ret;

+}

struct cs_etm_channel *cs_etm_decoder__create_channel_item( struct cs_etm_decoder *decoder, uint8_t cs_id) @@ -129,3 +190,60 @@ struct cs_etm_channel *cs_etm_decoder__create_channel_item( list_add(&(chan->chan_list), &(decoder->channel_list)); return chan; }

+static int cs_etm_decoder__create_etmv4i_packet_printer(

• 			struct cs_etm_decoder_params *d_params,
  

• 			struct cs_etm_trace_params *t_params,
  

• 			struct cs_etm_decoder *decoder)
  

+{

• ocsd_etmv4_cfg trace_config;
• int ret = 0;
• unsigned char CSID; /* CSID extracted from the config data */
• struct cs_etm_channel *channel;
• if (!d_params->packet_printer)

• return -CS_ETM_ERR_PARAM;
  

• cs_etm_decoder__gen_etmv4_config(t_params, &trace_config);
• decoder->packet_printer = d_params->packet_printer;
• ret = ocsd_dt_create_decoder(decoder->dcd_tree,

• 		     OCSD_BUILTIN_DCD_ETMV4I,
  

• 		     OCSD_CREATE_FLG_PACKET_PROC,
  

• 		     (void *)&trace_config, &CSID);
  

• if (ret != 0)

• return -CS_ETM_ERR_DECODER;
  

• channel = cs_etm_decoder__create_channel_item(decoder, CSID);
• if (!channel)

• return -CS_ETM_ERR_DECODER;
  

• ret = ocsd_dt_attach_packet_callback(decoder->dcd_tree,

• 			  CSID, OCSD_C_API_CB_PKT_SINK,
  

• 			  cs_etm_decoder__etmv4i_packet_printer,
  

• 			  channel);
  

• if (ret != 0)

• return -CS_ETM_ERR_DECODER;
  

• return 0;

+}

+int +cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params,

• 		      struct cs_etm_trace_params *t_params,
  

• 		      struct cs_etm_decoder *decoder)
  

+{

• int ret;
• if (d_params->operation == CS_ETM_OPERATION_PRINT)

• ret = cs_etm_decoder__create_etmv4i_packet_printer(d_params,
  

• 						   t_params,
  

• 						   decoder);
  

• else

• ret = -CS_ETM_ERR_PARAM;
  

• return ret;

+} 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 ab9880c..38effcb 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -114,4 +114,9 @@ const struct cs_etm_state * cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, uint64_t indx, const uint8_t *buf, size_t len, size_t *consumed);

+int +cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params,

• 		      struct cs_etm_trace_params *t_params,
  

• 		      struct cs_etm_decoder *decoder);
  

#endif /* INCLUDE__CS_ETM_DECODER_H__ */

Other than making this patch apply because of previous modifications, nothing in this one changed.

-- 2.7.4

---

CoreSight mailing list CoreSight@lists.linaro.org https://lists.linaro.org/mailman/listinfo/coresight

On Fri, Sep 22, 2017 at 04:03:27AM -0500, Tor Jeremiassen wrote:

The trace decoder library requires access to the instruction opcodes of the program that was traced in order to be able to decode the trace stream into a series of executed instruction ranges.

This patch implements a function that will be used by the trace decoder interface to enable the trace decoder library to access instruction opcodes stored in DSOs.

Signed-off-by: Tor Jeremiassen tor@ti.com

tools/perf/util/cs-etm.c | 49 ++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 4 ++++ 2 files changed, 53 insertions(+)

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 7f12406..354f3b5 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -208,6 +208,55 @@ static void cs_etm__free(struct perf_session *session) zfree(&aux); } +uint32_t cs_etm__mem_access(struct cs_etm_queue *etmq,

• 	    uint64_t address,
  

• 	    size_t size,
  

• 	    uint8_t *buffer)
  

+{

• struct addr_location al;
• uint64_t offset;
• struct thread *thread;
• struct machine *machine;
• uint8_t cpumode;
• int len;
• if (!etmq)

• return -1;
  

• machine = etmq->etm->machine;
• if (address >= etmq->etm->kernel_start)

• cpumode = PERF_RECORD_MISC_KERNEL;
  

• else

• cpumode = PERF_RECORD_MISC_USER;
  

• thread = etmq->thread;
• if (!thread) {

• if (cpumode != PERF_RECORD_MISC_KERNEL)
  

• 	return -EINVAL;
  

• thread = etmq->etm->unknown_thread;
  

• }
• thread__find_addr_map(thread, cpumode, MAP__FUNCTION, address, &al);
• if (!al.map || !al.map->dso)

• return 0;
  

• if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR &&

•    dso__data_status_seen(al.map->dso, DSO_DATA_STATUS_SEEN_ITRACE))
  

• return 0;
  

• offset = al.map->map_ip(al.map, address);
• map__load(al.map);
• len = dso__data_read_offset(al.map->dso, machine, offset, buffer, size);
• if (len <= 0)

• return 0;
  

• return len;

+}

static int cs_etm__process_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample, diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 6139280..d0205a3 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -96,4 +96,8 @@ struct auxtrace_buffer; void cs_etm__dump_event(struct cs_etm_auxtrace *etm, struct auxtrace_buffer *buffer); +struct cs_etm_queue;

I moved this up with the other struct declaration.

+uint32_t cs_etm__mem_access(struct cs_etm_queue *etmq, uint64_t address,

• 	    size_t size, uint8_t *buffer);
  

#endif

2.7.4

---

CoreSight mailing list CoreSight@lists.linaro.org https://lists.linaro.org/mailman/listinfo/coresight

On Fri, Sep 22, 2017 at 04:03:31AM -0500, Tor Jeremiassen wrote:

Each decoded trace sample encodes the execution of a sequence of instructions between to "waypoints", typically a branch target and the next taken branch. This sample has to be converted into a perf sample struct before it can be passed on to the perf subsystem.

This patch adds two functions that take a decoded trace packet and populate the perf sample structure and pass it on to perf session event processing. It also adds a function in the decoder library interface to return a decoded trace packet.

Is it me or the title of the patch doesn't really match the description? Am I missing something?

Signed-off-by: Tor Jeremiassen tor@ti.com

tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 21 ++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 3 ++ tools/perf/util/cs-etm.c | 64 +++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 2 + 4 files changed, 90 insertions(+)

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 cfd18ec..e46ce59 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -86,6 +86,27 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, return 0; } +int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder,

• 	       struct cs_etm_packet *packet)
  

+{

• if (!decoder)

• return -CS_ETM_ERR_PARAM;
  

• if (decoder->packet_count == 0)

• return -CS_ETM_ERR_NODATA;
  

• if (!packet)

• return -CS_ETM_ERR_PARAM;
  

• *packet = decoder->packet_buffer[decoder->head];
• decoder->head = (decoder->head + 1) & (MAX_BUFFER - 1);
• decoder->packet_count--;
• return 0;

+}

const struct cs_etm_state * cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, uint64_t indx, const uint8_t *buf, 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 b53dbed..259059b 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -126,6 +126,9 @@ int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, uint64_t start, uint64_t end, cs_etm_mem_cb_type cb_func); +int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder,

• 	       struct cs_etm_packet *packet);
  

int cs_etm_decoder__create_etmv4i_decoder(struct cs_etm_decoder_params *d_params, struct cs_etm_trace_params *t_params, diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 0516301..72c4c9d 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -334,6 +334,70 @@ static int cs_etm__setup_queues(struct cs_etm_auxtrace *etm) return 0; } +/*

• • The cs etm packet encodes an instruction range between a branch target
• • and the next taken branch. Generate sample accordingly.
• */

+static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq,

• 			    struct cs_etm_packet *packet)
  

+{

• int ret = 0;
• struct cs_etm_auxtrace *etm = etmq->etm;
• union perf_event *event = etmq->event_buf;
• struct perf_sample sample = {.ip = 0,};
• uint64_t start_addr = packet->start_addr;
• uint64_t end_addr = packet->end_addr;
• event->sample.header.type = PERF_RECORD_SAMPLE;
• event->sample.header.misc = PERF_RECORD_MISC_USER;
• event->sample.header.size = sizeof(struct perf_event_header);
• sample.ip = start_addr;
• sample.pid = etmq->pid;
• sample.tid = etmq->tid;
• sample.addr = end_addr;
• sample.id = etmq->etm->instructions_id;
• sample.stream_id = etmq->etm->instructions_id;
• /* approximate the period to be the number of words in the range */
• sample.period = (end_addr - start_addr) >> 2;
• sample.cpu = packet->cpu;
• sample.flags = 0;
• sample.insn_len = 1;
• sample.cpumode = event->header.misc;
• ret = perf_session__deliver_synth_event(etm->session, event, &sample);
• if (ret)

• pr_err(
  

• "CS ETM Trace: failed to deliver instruction event, error %d\n",
  

• ret);
  

• return ret;

+}

+int cs_etm__sample(struct cs_etm_queue *etmq) +{

• struct cs_etm_packet packet;
• int err;
• err = cs_etm_decoder__get_packet(etmq->decoder, &packet);
• /* if there is no sample, it returns err = -1, no real error */
• if (err)

• return err;
  

• /*

• * if the packet contains an instruction range, generate
  

• * an instruction sequence event
  

• */
  

• if (packet.sample_type & CS_ETM_RANGE) {

• err = cs_etm__synth_instruction_sample(etmq, &packet);
  

• if (err)
  

• 	return err;
  

• }
• return 0;

+}

int cs_etm__update_queues(struct cs_etm_auxtrace *etm) { if (etm->queues.new_data) { diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index d1cb049..aa7e0d4 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -108,4 +108,6 @@ struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm, int cs_etm__update_queues(struct cs_etm_auxtrace *etm); +int cs_etm__sample(struct cs_etm_queue *etmq);

#endif

2.7.4

---

CoreSight mailing list CoreSight@lists.linaro.org https://lists.linaro.org/mailman/listinfo/coresight

On Fri, Sep 22, 2017 at 04:03:35AM -0500, Tor Jeremiassen wrote:

Each perf event is passed to the coresight etm event processing function, so that coresight specific functionality can be invoked.

This patch adds the coresight etm event processing function which manages the handling of the events that need special handling for trace decoding.

Signed-off-by: Tor Jeremiassen tor@ti.com

tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 3 -- tools/perf/util/cs-etm.c | 45 ++++++++++++++++++++++--- 2 files changed, 40 insertions(+), 8 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 4853ee0..e93135e1 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -90,9 +90,6 @@ int cs_etm_decoder__reset(struct cs_etm_decoder *decoder) { ocsd_datapath_resp_t dp_ret;

• if (!decoder)

• return -CS_ETM_ERR_PARAM;
  

• dp_ret = ocsd_dt_process_data(decoder->dcd_tree, OCSD_OP_RESET, 0, 0, NULL, NULL); if (OCSD_DATA_RESP_IS_FATAL(dp_ret))

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index e82236f..36c1ee2 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -31,6 +31,7 @@ #include "evlist.h" #include "intlist.h" #include "machine.h" +#include "map.h" #include "perf.h" #include "thread.h" #include "thread_map.h" @@ -706,11 +707,45 @@ static int cs_etm__process_event(struct perf_session *session, struct perf_sample *sample, struct perf_tool *tool) {

• (void) session;
• (void) event;
• (void) sample;
• (void) tool;
• return 0;

• struct cs_etm_auxtrace *etm = container_of(session->auxtrace,

• 				   struct cs_etm_auxtrace,
  

• 				   auxtrace);
  

• struct cs_etm_queue *etmq;
• u64 timestamp;
• int err = 0;
• if (dump_trace)

• return 0;
  

• if (!tool->ordered_events) {

• pr_err("CoreSight ETM Trace requires ordered events\n");
  

• return -EINVAL;
  

• }
• if (sample->time && (sample->time != (u64) -1))

• timestamp = sample->time;
  

• else

• timestamp = 0;
  

• if (timestamp || etm->timeless_decoding) {

• err = cs_etm__update_queues(etm);
  

• if (err)
  

• 	return err;
  

• }

In the original work the code below is conditional to a PERF_RECORD_MMAP2 event type. How is it that we don't need that anymore? Just curious...

Thanks, Mathieu

• etmq = cs_etm__cpu_to_etmq(etm, sample->cpu);
• if (!etmq)

• return -1;
  

• if (etm->timeless_decoding) {

• if (event->header.type == PERF_RECORD_EXIT)
  

• 	err = cs_etm__process_timeless_queues(etm,
  

• 					      event->fork.tid,
  

• 					      sample->time);
  

• } else if (timestamp)

• err = cs_etm__process_queues(etm, timestamp);
  

• return err;

} static int cs_etm__process_auxtrace_event(struct perf_session *session, -- 2.7.4

---

CoreSight mailing list CoreSight@lists.linaro.org https://lists.linaro.org/mailman/listinfo/coresight