Re: [RFC 08/17] perf tools: Introduce the concept of trace ID queues

On Wed, Apr 03, 2019 at 05:42:19PM +0800, Leo Yan wrote:

On Wed, Mar 06, 2019 at 03:59:33PM -0700, Mathieu Poirier wrote:

...

In and ideal world there is one CPU per cs_etm_queue and as such, one trace

s/and/an

Ok

...

ID per cs_etm_queue. In the real world CoreSight topologies allow multiple CPUs to use the same sink, which translates to multiple trace IDs per cs_etm_queue.

To deal with this a new cs_etm_traceid_queue structure is introduced to enclose all the information related to a single trace ID, allowing a cs_etm_queue to handle traces generated by any number of CPUs.

Signed-off-by: Mathieu Poirier mathieu.poirier@linaro.org

.../perf/util/cs-etm-decoder/cs-etm-decoder.c | 4 +- tools/perf/util/cs-etm.c | 368 +++++++++++------- tools/perf/util/cs-etm.h | 15 +- 3 files changed, 237 insertions(+), 150 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 12f97e1ff945..275c72264820 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -412,8 +412,8 @@ static ocsd_datapath_resp_t cs_etm_decoder__gen_trace_elem_printer( struct cs_etm_queue *etmq = decoder->data; struct cs_etm_packet_queue *packet_queue;

• /* First get the packet queue */
• packet_queue = cs_etm__etmq_get_packet_queue(etmq);

• /* First get the packet queue for this traceID */
• packet_queue = cs_etm__etmq_get_packet_queue(etmq, trace_chan_id); if (!packet_queue) return OCSD_RESP_FATAL_SYS_ERR;

diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 5a9ebbf31614..7d862d26c107 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -60,25 +60,30 @@ struct cs_etm_auxtrace { unsigned int pmu_type; }; +struct cs_etm_traceid_queue {

• u8 trace_chan_id;
• u64 period_instructions;
• size_t last_branch_pos;
• union perf_event *event_buf;
• struct branch_stack *last_branch;
• struct branch_stack *last_branch_rb;
• struct cs_etm_packet *prev_packet;
• struct cs_etm_packet *packet;
• struct cs_etm_packet_queue packet_queue;

+};

struct cs_etm_queue { struct cs_etm_auxtrace *etm; struct thread *thread; struct cs_etm_decoder *decoder; struct auxtrace_buffer *buffer;

• union perf_event *event_buf; unsigned int queue_nr; pid_t pid, tid; int cpu; u64 offset;
• u64 period_instructions;
• struct branch_stack *last_branch;
• struct branch_stack *last_branch_rb;
• size_t last_branch_pos;
• struct cs_etm_packet *prev_packet;
• struct cs_etm_packet *packet; const unsigned char *buf; size_t buf_len, buf_used;
• struct cs_etm_packet_queue packet_queue;

• struct cs_etm_traceid_queue *traceid_queues;

}; static int cs_etm__update_queues(struct cs_etm_auxtrace *etm); @@ -150,10 +155,96 @@ static void cs_etm__clear_packet_queue(struct cs_etm_packet_queue *queue) } } +static int cs_etm__init_traceid_queue(struct cs_etm_queue *etmq,

• 		      struct cs_etm_traceid_queue *tidq,
  

• 		      u8 trace_chan_id)
  

+{

• int rc = -ENOMEM;
• struct cs_etm_auxtrace *etm = etmq->etm;
• cs_etm__clear_packet_queue(&tidq->packet_queue);
• tidq->trace_chan_id = trace_chan_id;
• tidq->packet = zalloc(sizeof(struct cs_etm_packet));
• if (!tidq->packet)

• goto out;
  

• if (etm->synth_opts.last_branch || etm->sample_branches) {

• tidq->prev_packet = zalloc(sizeof(struct cs_etm_packet));
  

• if (!tidq->prev_packet)
  

• 	goto out_free;
  

• }
• if (etm->synth_opts.last_branch) {

• size_t sz = sizeof(struct branch_stack);
  

• sz += etm->synth_opts.last_branch_sz *
  

•       sizeof(struct branch_entry);
  

• tidq->last_branch = zalloc(sz);
  

• if (!tidq->last_branch)
  

• 	goto out_free;
  

• tidq->last_branch_rb = zalloc(sz);
  

• if (!tidq->last_branch_rb)
  

• 	goto out_free;
  

• }
• tidq->event_buf = malloc(PERF_SAMPLE_MAX_SIZE);
• if (!tidq->event_buf)

• goto out_free;
  

• return 0;

+out_free:

• zfree(&tidq->last_branch_rb);
• zfree(&tidq->last_branch);
• zfree(&tidq->prev_packet);
• zfree(&tidq->packet);

+out:

• return rc;

+}

+static struct cs_etm_traceid_queue +*cs_etm__etmq_get_traceid_queue(struct cs_etm_queue *etmq, u8 trace_chan_id) +{

• struct cs_etm_traceid_queue *tidq;
• struct cs_etm_auxtrace *etm = etmq->etm;
• if (!etm->timeless_decoding)

• return NULL;
  

• tidq = etmq->traceid_queues;
• if (tidq)

• return tidq;
  

• tidq = calloc(CS_ETM_PACKET_QUEUE_NR, sizeof(*tidq));
• if (!tidq)

• return NULL;
  

Since CS_ETM_PACKET_QUEUE_NR is defined as 1, so just curious if this macro will be changed to other values later? Otherwise, seems to me to directly use malloc(sizeof(*tidq)) will be more directive.

I think I had different plans for that define when I started but looking back now there is hardly any reason to having it around. I have removed it to favour a combination of malloc/memset.

...

• if (cs_etm__init_traceid_queue(etmq, tidq, trace_chan_id))

• goto out_free;
  

• etmq->traceid_queues = tidq;
• return etmq->traceid_queues;

+out_free:

• free(tidq);
• return NULL;

+}

struct cs_etm_packet_queue -*cs_etm__etmq_get_packet_queue(struct cs_etm_queue *etmq) +*cs_etm__etmq_get_packet_queue(struct cs_etm_queue *etmq, u8 trace_chan_id) {

• return &etmq->packet_queue;

• struct cs_etm_traceid_queue *tidq;
• tidq = cs_etm__etmq_get_traceid_queue(etmq, trace_chan_id);
• if (tidq)

• return &tidq->packet_queue;
  

• return NULL;

} static void cs_etm__packet_dump(const char *pkt_string) @@ -327,11 +418,12 @@ static void cs_etm__free_queue(void *priv) thread__zput(etmq->thread); cs_etm_decoder__free(etmq->decoder);

• zfree(&etmq->event_buf);
• zfree(&etmq->last_branch);
• zfree(&etmq->last_branch_rb);
• zfree(&etmq->prev_packet);
• zfree(&etmq->packet);

• zfree(&etmq->traceid_queues->event_buf);
• zfree(&etmq->traceid_queues->last_branch);
• zfree(&etmq->traceid_queues->last_branch_rb);
• zfree(&etmq->traceid_queues->prev_packet);
• zfree(&etmq->traceid_queues->packet);
• zfree(&etmq->traceid_queues); free(etmq);

} @@ -443,39 +535,11 @@ static struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm) struct cs_etm_decoder_params d_params; struct cs_etm_trace_params *t_params = NULL; struct cs_etm_queue *etmq;

• size_t szp = sizeof(struct cs_etm_packet);

etmq = zalloc(sizeof(*etmq)); if (!etmq) return NULL;

• etmq->packet = zalloc(szp);
• if (!etmq->packet)

• goto out_free;
  

• if (etm->synth_opts.last_branch || etm->sample_branches) {

• etmq->prev_packet = zalloc(szp);
  

• if (!etmq->prev_packet)
  

• 	goto out_free;
  

• }
• if (etm->synth_opts.last_branch) {

• size_t sz = sizeof(struct branch_stack);
  

• sz += etm->synth_opts.last_branch_sz *
  

•       sizeof(struct branch_entry);
  

• etmq->last_branch = zalloc(sz);
  

• if (!etmq->last_branch)
  

• 	goto out_free;
  

• etmq->last_branch_rb = zalloc(sz);
  

• if (!etmq->last_branch_rb)
  

• 	goto out_free;
  

• }
• etmq->event_buf = malloc(PERF_SAMPLE_MAX_SIZE);
• if (!etmq->event_buf)

• goto out_free;
  

• /* Use metadata to fill in trace parameters for trace decoder */ t_params = zalloc(sizeof(*t_params) * etm->num_cpu);

@@ -510,12 +574,6 @@ static struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm) out_free_decoder: cs_etm_decoder__free(etmq->decoder); out_free:

• zfree(&t_params);
• zfree(&etmq->event_buf);
• zfree(&etmq->last_branch);
• zfree(&etmq->last_branch_rb);
• zfree(&etmq->prev_packet);
• zfree(&etmq->packet); free(etmq);

return NULL; @@ -545,8 +603,6 @@ static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm, etmq->tid = queue->tid; etmq->pid = -1; etmq->offset = 0;

• etmq->period_instructions = 0;
• cs_etm__clear_packet_queue(&etmq->packet_queue);

out: return ret; @@ -579,10 +635,12 @@ static int cs_etm__update_queues(struct cs_etm_auxtrace *etm) return 0; } -static inline void cs_etm__copy_last_branch_rb(struct cs_etm_queue *etmq) +static inline +void cs_etm__copy_last_branch_rb(struct cs_etm_queue *etmq,

• 		 struct cs_etm_traceid_queue *tidq)
  

{

• struct branch_stack *bs_src = etmq->last_branch_rb;
• struct branch_stack *bs_dst = etmq->last_branch;

• struct branch_stack *bs_src = tidq->last_branch_rb;
• struct branch_stack *bs_dst = tidq->last_branch; size_t nr = 0;

/* @@ -602,9 +660,9 @@ static inline void cs_etm__copy_last_branch_rb(struct cs_etm_queue *etmq) * two steps. First, copy the branches from the most recently inserted * branch ->last_branch_pos until the end of bs_src->entries buffer. */

• nr = etmq->etm->synth_opts.last_branch_sz - etmq->last_branch_pos;

• nr = etmq->etm->synth_opts.last_branch_sz - tidq->last_branch_pos; memcpy(&bs_dst->entries[0],

•       &bs_src->entries[etmq->last_branch_pos],
  

•       &bs_src->entries[tidq->last_branch_pos],
      sizeof(struct branch_entry) * nr);
  

/* @@ -617,14 +675,15 @@ static inline void cs_etm__copy_last_branch_rb(struct cs_etm_queue *etmq) if (bs_src->nr >= etmq->etm->synth_opts.last_branch_sz) { memcpy(&bs_dst->entries[nr], &bs_src->entries[0],

•        sizeof(struct branch_entry) * etmq->last_branch_pos);
  

•        sizeof(struct branch_entry) * tidq->last_branch_pos);
  

  }

} -static inline void cs_etm__reset_last_branch_rb(struct cs_etm_queue *etmq) +static inline +void cs_etm__reset_last_branch_rb(struct cs_etm_traceid_queue *tidq) {

• etmq->last_branch_pos = 0;
• etmq->last_branch_rb->nr = 0;

• tidq->last_branch_pos = 0;
• tidq->last_branch_rb->nr = 0;

} static inline int cs_etm__t32_instr_size(struct cs_etm_queue *etmq, @@ -677,9 +736,10 @@ static inline u64 cs_etm__instr_addr(struct cs_etm_queue *etmq, return packet->start_addr + offset * 4; } -static void cs_etm__update_last_branch_rb(struct cs_etm_queue *etmq) +static void cs_etm__update_last_branch_rb(struct cs_etm_queue *etmq,

• 			  struct cs_etm_traceid_queue *tidq)
  

{

• struct branch_stack *bs = etmq->last_branch_rb;

• struct branch_stack *bs = tidq->last_branch_rb; struct branch_entry *be;

/* @@ -688,14 +748,14 @@ static void cs_etm__update_last_branch_rb(struct cs_etm_queue *etmq) * buffer down. After writing the first element of the stack, move the * insert position back to the end of the buffer. */

• if (!etmq->last_branch_pos)

• etmq->last_branch_pos = etmq->etm->synth_opts.last_branch_sz;
  

• if (!tidq->last_branch_pos)

• tidq->last_branch_pos = etmq->etm->synth_opts.last_branch_sz;
  

• etmq->last_branch_pos -= 1;

• tidq->last_branch_pos -= 1;

• be = &bs->entries[etmq->last_branch_pos];
• be->from = cs_etm__last_executed_instr(etmq->prev_packet);
• be->to = cs_etm__first_executed_instr(etmq->packet);

• be = &bs->entries[tidq->last_branch_pos];
• be->from = cs_etm__last_executed_instr(tidq->prev_packet);
• be->to = cs_etm__first_executed_instr(tidq->packet); /* No support for mispredict */ be->flags.mispred = 0; be->flags.predicted = 1;

@@ -779,11 +839,12 @@ static void cs_etm__set_pid_tid_cpu(struct cs_etm_auxtrace *etm, } static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq,

• 			    struct cs_etm_traceid_queue *tidq,
  		    u64 addr, u64 period)
  

{ int ret = 0; struct cs_etm_auxtrace *etm = etmq->etm;

• union perf_event *event = etmq->event_buf;

• union perf_event *event = tidq->event_buf; struct perf_sample sample = {.ip = 0,};

event->sample.header.type = PERF_RECORD_SAMPLE; @@ -796,14 +857,14 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq, sample.id = etmq->etm->instructions_id; sample.stream_id = etmq->etm->instructions_id; sample.period = period;

• sample.cpu = etmq->packet->cpu;
• sample.flags = etmq->prev_packet->flags;

• sample.cpu = tidq->packet->cpu;
• sample.flags = tidq->prev_packet->flags; sample.insn_len = 1; sample.cpumode = event->sample.header.misc;

if (etm->synth_opts.last_branch) {

• cs_etm__copy_last_branch_rb(etmq);
  

• sample.branch_stack = etmq->last_branch;
  

• cs_etm__copy_last_branch_rb(etmq, tidq);
  

• sample.branch_stack = tidq->last_branch;
  

  }

if (etm->synth_opts.inject) { @@ -821,7 +882,7 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq, ret); if (etm->synth_opts.last_branch)

• cs_etm__reset_last_branch_rb(etmq);
  

• cs_etm__reset_last_branch_rb(tidq);
  

return ret; } @@ -830,19 +891,20 @@ static int cs_etm__synth_instruction_sample(struct cs_etm_queue *etmq,

• 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_branch_sample(struct cs_etm_queue *etmq) +static int cs_etm__synth_branch_sample(struct cs_etm_queue *etmq,

• 		       struct cs_etm_traceid_queue *tidq)
  

{ int ret = 0; struct cs_etm_auxtrace *etm = etmq->etm; struct perf_sample sample = {.ip = 0,};

• union perf_event *event = etmq->event_buf;

• union perf_event *event = tidq->event_buf; struct dummy_branch_stack { u64 nr; struct branch_entry entries; } dummy_bs; u64 ip;

• ip = cs_etm__last_executed_instr(etmq->prev_packet);

• ip = cs_etm__last_executed_instr(tidq->prev_packet);

event->sample.header.type = PERF_RECORD_SAMPLE; event->sample.header.misc = cs_etm__cpu_mode(etmq, ip); @@ -851,12 +913,12 @@ static int cs_etm__synth_branch_sample(struct cs_etm_queue *etmq) sample.ip = ip; sample.pid = etmq->pid; sample.tid = etmq->tid;

• sample.addr = cs_etm__first_executed_instr(etmq->packet);

• sample.addr = cs_etm__first_executed_instr(tidq->packet); sample.id = etmq->etm->branches_id; sample.stream_id = etmq->etm->branches_id; sample.period = 1;

• sample.cpu = etmq->packet->cpu;
• sample.flags = etmq->prev_packet->flags;

• sample.cpu = tidq->packet->cpu;
• sample.flags = tidq->prev_packet->flags; sample.cpumode = event->sample.header.misc;

/* @@ -999,34 +1061,35 @@ static int cs_etm__synth_events(struct cs_etm_auxtrace *etm, return 0; } -static int cs_etm__sample(struct cs_etm_queue *etmq) +static int cs_etm__sample(struct cs_etm_queue *etmq,

• 	  struct cs_etm_traceid_queue *tidq)
  

{ struct cs_etm_auxtrace *etm = etmq->etm; struct cs_etm_packet *tmp; int ret;

• u64 instrs_executed = etmq->packet->instr_count;

• u64 instrs_executed = tidq->packet->instr_count;

• etmq->period_instructions += instrs_executed;

• tidq->period_instructions += instrs_executed;

/* * Record a branch when the last instruction in * PREV_PACKET is a branch. */ if (etm->synth_opts.last_branch &&

•    etmq->prev_packet &&
  

•    etmq->prev_packet->sample_type == CS_ETM_RANGE &&
  

•    etmq->prev_packet->last_instr_taken_branch)
  

• cs_etm__update_last_branch_rb(etmq);
  

•    tidq->prev_packet &&
  

•    tidq->prev_packet->sample_type == CS_ETM_RANGE &&
  

•    tidq->prev_packet->last_instr_taken_branch)
  

• cs_etm__update_last_branch_rb(etmq, tidq);
  

if (etm->sample_instructions &&

•    etmq->period_instructions >= etm->instructions_sample_period) {
  

•    tidq->period_instructions >= etm->instructions_sample_period) {
  

  /*
  • Emit instruction sample periodically
  • TODO: allow period to be defined in cycles and clock time
  */

/* Get number of instructions executed after the sample point */

• u64 instrs_over = etmq->period_instructions -
  

• u64 instrs_over = tidq->period_instructions -
  etm->instructions_sample_period;
  

/* @@ -1035,31 +1098,31 @@ static int cs_etm__sample(struct cs_etm_queue *etmq) * executed, but PC has not advanced to next instruction) */ u64 offset = (instrs_executed - instrs_over - 1);

• u64 addr = cs_etm__instr_addr(etmq, etmq->packet, offset);
  

• u64 addr = cs_etm__instr_addr(etmq, tidq->packet, offset);
  

ret = cs_etm__synth_instruction_sample(

• 	etmq, addr, etm->instructions_sample_period);
  

• 	etmq, tidq, addr, etm->instructions_sample_period);
  

  if (ret) return ret;

/* Carry remaining instructions into next sample period */

• etmq->period_instructions = instrs_over;
  

• tidq->period_instructions = instrs_over;
  

  }

• if (etm->sample_branches && etmq->prev_packet) {

• if (etm->sample_branches && tidq->prev_packet) { bool generate_sample = false;

/* Generate sample for tracing on packet */

• if (etmq->prev_packet->sample_type == CS_ETM_DISCONTINUITY)
  

• if (tidq->prev_packet->sample_type == CS_ETM_DISCONTINUITY)
  generate_sample = true;
  

/* Generate sample for branch taken packet */

• if (etmq->prev_packet->sample_type == CS_ETM_RANGE &&
  

•     etmq->prev_packet->last_instr_taken_branch)
  

• if (tidq->prev_packet->sample_type == CS_ETM_RANGE &&
  

•     tidq->prev_packet->last_instr_taken_branch)
  generate_sample = true;
  

if (generate_sample) {

• 	ret = cs_etm__synth_branch_sample(etmq);
  

• 	ret = cs_etm__synth_branch_sample(etmq, tidq);
  if (ret)
  	return ret;
  

  }

@@ -1070,15 +1133,15 @@ static int cs_etm__sample(struct cs_etm_queue *etmq) * Swap PACKET with PREV_PACKET: PACKET becomes PREV_PACKET for * the next incoming packet. */

• tmp = etmq->packet;
  

• etmq->packet = etmq->prev_packet;
  

• etmq->prev_packet = tmp;
  

• tmp = tidq->packet;
  

• tidq->packet = tidq->prev_packet;
  

• tidq->prev_packet = tmp;
  

  }

return 0; } -static int cs_etm__exception(struct cs_etm_queue *etmq) +static int cs_etm__exception(struct cs_etm_traceid_queue *tidq) { /* * When the exception packet is inserted, whether the last instruction @@ -1091,27 +1154,28 @@ static int cs_etm__exception(struct cs_etm_queue *etmq) * swap PACKET with PREV_PACKET. This keeps PREV_PACKET to be useful * for generating instruction and branch samples. */

• if (etmq->prev_packet->sample_type == CS_ETM_RANGE)

• etmq->prev_packet->last_instr_taken_branch = true;
  

• if (tidq->prev_packet->sample_type == CS_ETM_RANGE)

• tidq->prev_packet->last_instr_taken_branch = true;
  

return 0; } -static int cs_etm__flush(struct cs_etm_queue *etmq) +static int cs_etm__flush(struct cs_etm_queue *etmq,

• 	 struct cs_etm_traceid_queue *tidq)
  

{ int err = 0; struct cs_etm_auxtrace *etm = etmq->etm; struct cs_etm_packet *tmp;

• if (!etmq->prev_packet)

• if (!tidq->prev_packet) return 0;

/* Handle start tracing packet */

• if (etmq->prev_packet->sample_type == CS_ETM_EMPTY)

• if (tidq->prev_packet->sample_type == CS_ETM_EMPTY) goto swap_packet;

if (etmq->etm->synth_opts.last_branch &&

•    etmq->prev_packet->sample_type == CS_ETM_RANGE) {
  

•    tidq->prev_packet->sample_type == CS_ETM_RANGE) {
  

  /*
  • Generate a last branch event for the branches left in the
  • circular buffer at the end of the trace.

@@ -1119,21 +1183,21 @@ static int cs_etm__flush(struct cs_etm_queue *etmq) * Use the address of the end of the last reported execution * range */

• u64 addr = cs_etm__last_executed_instr(etmq->prev_packet);
  

• u64 addr = cs_etm__last_executed_instr(tidq->prev_packet);
  

err = cs_etm__synth_instruction_sample(

• 	etmq, addr,
  

• 	etmq->period_instructions);
  

• 	etmq, tidq, addr,
  

• 	tidq->period_instructions);
  

  if (err) return err;

• etmq->period_instructions = 0;
  

• tidq->period_instructions = 0;
  

} if (etm->sample_branches &&

•    etmq->prev_packet->sample_type == CS_ETM_RANGE) {
  

• err = cs_etm__synth_branch_sample(etmq);
  

•    tidq->prev_packet->sample_type == CS_ETM_RANGE) {
  

• err = cs_etm__synth_branch_sample(etmq, tidq);
  

  if (err) return err; }

@@ -1144,15 +1208,16 @@ static int cs_etm__flush(struct cs_etm_queue *etmq) * Swap PACKET with PREV_PACKET: PACKET becomes PREV_PACKET for * the next incoming packet. */

• tmp = etmq->packet;
  

• etmq->packet = etmq->prev_packet;
  

• etmq->prev_packet = tmp;
  

• tmp = tidq->packet;
  

• tidq->packet = tidq->prev_packet;
  

• tidq->prev_packet = tmp;
  

  }

return err; } -static int cs_etm__end_block(struct cs_etm_queue *etmq) +static int cs_etm__end_block(struct cs_etm_queue *etmq,

• 	     struct cs_etm_traceid_queue *tidq)
  

{ int err; @@ -1166,20 +1231,20 @@ static int cs_etm__end_block(struct cs_etm_queue *etmq) * the trace. */ if (etmq->etm->synth_opts.last_branch &&

•    etmq->prev_packet->sample_type == CS_ETM_RANGE) {
  

•    tidq->prev_packet->sample_type == CS_ETM_RANGE) {
  

  /*
  • Use the address of the end of the last reported execution
  • range.
  */

• u64 addr = cs_etm__last_executed_instr(etmq->prev_packet);
  

• u64 addr = cs_etm__last_executed_instr(tidq->prev_packet);
  

err = cs_etm__synth_instruction_sample(

• 	etmq, addr,
  

• 	etmq->period_instructions);
  

• 	etmq, tidq, addr,
  

• 	tidq->period_instructions);
  

  if (err) return err;

• etmq->period_instructions = 0;
  

• tidq->period_instructions = 0;
  

  }

return 0; @@ -1278,10 +1343,11 @@ static bool cs_etm__is_svc_instr(struct cs_etm_queue *etmq, return false; } -static bool cs_etm__is_syscall(struct cs_etm_queue *etmq, u64 magic) +static bool cs_etm__is_syscall(struct cs_etm_queue *etmq,

• 	       struct cs_etm_traceid_queue *tidq, u64 magic)
  

{

• struct cs_etm_packet *packet = etmq->packet;
• struct cs_etm_packet *prev_packet = etmq->prev_packet;

• struct cs_etm_packet *packet = tidq->packet;
• struct cs_etm_packet *prev_packet = tidq->prev_packet;

if (magic == __perf_cs_etmv3_magic) if (packet->exception_number == CS_ETMV3_EXC_SVC) @@ -1302,9 +1368,10 @@ static bool cs_etm__is_syscall(struct cs_etm_queue *etmq, u64 magic) return false; } -static bool cs_etm__is_async_exception(struct cs_etm_queue *etmq, u64 magic) +static bool cs_etm__is_async_exception(struct cs_etm_traceid_queue *tidq,

• 		       u64 magic)
  

{

• struct cs_etm_packet *packet = etmq->packet;

• struct cs_etm_packet *packet = tidq->packet;

if (magic == __perf_cs_etmv3_magic) if (packet->exception_number == CS_ETMV3_EXC_DEBUG_HALT || @@ -1327,10 +1394,12 @@ static bool cs_etm__is_async_exception(struct cs_etm_queue *etmq, u64 magic) return false; } -static bool cs_etm__is_sync_exception(struct cs_etm_queue *etmq, u64 magic) +static bool cs_etm__is_sync_exception(struct cs_etm_queue *etmq,

• 		      struct cs_etm_traceid_queue *tidq,
  

• 		      u64 magic)
  

{

• struct cs_etm_packet *packet = etmq->packet;
• struct cs_etm_packet *prev_packet = etmq->prev_packet;

• struct cs_etm_packet *packet = tidq->packet;
• struct cs_etm_packet *prev_packet = tidq->prev_packet;

if (magic == __perf_cs_etmv3_magic) if (packet->exception_number == CS_ETMV3_EXC_SMC || @@ -1373,10 +1442,11 @@ static bool cs_etm__is_sync_exception(struct cs_etm_queue *etmq, u64 magic) return false; } -static int cs_etm__set_sample_flags(struct cs_etm_queue *etmq) +static int cs_etm__set_sample_flags(struct cs_etm_queue *etmq,

• 		    struct cs_etm_traceid_queue *tidq)
  

{

• struct cs_etm_packet *packet = etmq->packet;
• struct cs_etm_packet *prev_packet = etmq->prev_packet;

• struct cs_etm_packet *packet = tidq->packet;
• struct cs_etm_packet *prev_packet = tidq->prev_packet; u64 magic; int ret;

@@ -1478,7 +1548,7 @@ static int cs_etm__set_sample_flags(struct cs_etm_queue *etmq) return ret; /* The exception is for system call. */

• if (cs_etm__is_syscall(etmq, magic))
  

• if (cs_etm__is_syscall(etmq, tidq, magic))
  packet->flags = PERF_IP_FLAG_BRANCH |
  		PERF_IP_FLAG_CALL |
  		PERF_IP_FLAG_SYSCALLRET;
  

@@ -1486,7 +1556,7 @@ static int cs_etm__set_sample_flags(struct cs_etm_queue *etmq) * The exceptions are triggered by external signals from bus, * interrupt controller, debug module, PE reset or halt. */

• else if (cs_etm__is_async_exception(etmq, magic))
  

• else if (cs_etm__is_async_exception(tidq, magic))
  packet->flags = PERF_IP_FLAG_BRANCH |
  		PERF_IP_FLAG_CALL |
  		PERF_IP_FLAG_ASYNC |
  

@@ -1495,7 +1565,7 @@ static int cs_etm__set_sample_flags(struct cs_etm_queue *etmq) * Otherwise, exception is caused by trap, instruction & * data fault, or alignment errors. */

• else if (cs_etm__is_sync_exception(etmq, magic))
  

• else if (cs_etm__is_sync_exception(etmq, tidq, magic))
  packet->flags = PERF_IP_FLAG_BRANCH |
  		PERF_IP_FLAG_CALL |
  		PERF_IP_FLAG_INTERRUPT;
  

@@ -1577,17 +1647,18 @@ static int cs_etm__decode_data_block(struct cs_etm_queue *etmq) return ret; } -static int cs_etm__process_decoder_queue(struct cs_etm_queue *etmq) +static int cs_etm__process_traceid_queue(struct cs_etm_queue *etmq,

• 			 struct cs_etm_traceid_queue *tidq)
  

{ int ret; struct cs_etm_packet_queue *packet_queue;

• packet_queue = cs_etm__etmq_get_packet_queue(etmq);

• packet_queue = &tidq->packet_queue;

/* Process each packet in this chunk */ while (1) {

Indention?

That is a rebase gone wrong from a previous patchset. I fixed it now.

...

	ret = cs_etm_decoder__get_packet(packet_queue,

• 					 etmq->packet);
  

• 					 tidq->packet);
  if (ret <= 0)
  	/*
  	 * Stop processing this chunk on
  

@@ -1602,18 +1673,18 @@ static int cs_etm__process_decoder_queue(struct cs_etm_queue *etmq) * prior to switch() statement to use address * information before packets swapping. */

• 	ret = cs_etm__set_sample_flags(etmq);
  

• 	ret = cs_etm__set_sample_flags(etmq, tidq);
  if (ret < 0)
  	break;
  

• 	switch (etmq->packet->sample_type) {
  

• 	switch (tidq->packet->sample_type) {
  case CS_ETM_RANGE:
  	/*
  	 * If the packet contains an instruction
  	 * range, generate instruction sequence
  	 * events.
  	 */
  

• 		cs_etm__sample(etmq);
  

• 		cs_etm__sample(etmq, tidq);
  	break;
  case CS_ETM_EXCEPTION:
  case CS_ETM_EXCEPTION_RET:
  

@@ -1622,14 +1693,14 @@ static int cs_etm__process_decoder_queue(struct cs_etm_queue *etmq) * make sure the previous instruction * range packet to be handled properly. */

• 		cs_etm__exception(etmq);
  

• 		cs_etm__exception(tidq);
  	break;
  case CS_ETM_DISCONTINUITY:
  	/*
  	 * Discontinuity in trace, flush
  	 * previous branch stack
  	 */
  

• 		cs_etm__flush(etmq);
  

• 		cs_etm__flush(etmq, tidq);
  	break;
  case CS_ETM_EMPTY:
  	/*
  

@@ -1649,6 +1720,11 @@ static int cs_etm__process_decoder_queue(struct cs_etm_queue *etmq) static int cs_etm__run_decoder(struct cs_etm_queue *etmq) { int err = 0;

• struct cs_etm_traceid_queue *tidq;
• tidq = cs_etm__etmq_get_traceid_queue(etmq, CS_ETM_PER_THREAD_TRACEID);
• if (!tidq)

• return -EINVAL;
  

I am confused by this. For CPU wide trace case, since every CPU has its own trace id and the trace id is not the same with CS_ETM_PER_THREAD_TRACEID; if so we create the queue with trace id = CS_ETM_PER_THREAD_TRACEID, will this queue be redundant and cannot be used for any CPU in system?

Furthermore, we can see this 'tidq' will be always used by below decoding loop, should the 'tidq' be dynamically updated based on latest tracing data generated from different CPU?

Function cs_etm__run_decoder() is used only in cs_etm__process_timeless_queues(). For CPU-wide scenarios function cs_etm__process_queues() is called.

...

/* Go through each buffer in the queue and decode them one by one */ while (1) { @@ -1667,13 +1743,13 @@ static int cs_etm__run_decoder(struct cs_etm_queue *etmq) * an error occurs other than hoping the next one will * be better. */

• 	err = cs_etm__process_decoder_queue(etmq);
  

• 	err = cs_etm__process_traceid_queue(etmq, tidq);
  

} while (etmq->buf_len); if (err == 0) /* Flush any remaining branch stack entries */

• 	err = cs_etm__end_block(etmq);
  

• 	err = cs_etm__end_block(etmq, tidq);
  

  }

return err; diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index b6d0e0d0c43f..0dfc79a678f8 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -137,6 +137,16 @@ struct cs_etm_packet { #define CS_ETM_PACKET_MAX_BUFFER 1024 #define CS_ETM_PACKET_QUEUE_NR 1 +/*

• • When working with per-thread scenarios the process under trace can
• • be scheduled on any CPU and as such, more than one traceID may be
• • associated with the same process. Since a traceID of '0' is illegal
• • as per the CoreSight architecture, use that specific value to
• • identify the queue where all packets (with any traceID) are
• • aggregated.
• */

+#define CS_ETM_PER_THREAD_TRACEID 0

struct cs_etm_packet_queue { u32 packet_count; u32 head; @@ -173,7 +183,7 @@ int cs_etm__process_auxtrace_info(union perf_event *event, struct perf_session *session); int cs_etm__get_cpu(u8 trace_chan_id, int *cpu); struct cs_etm_packet_queue -*cs_etm__etmq_get_packet_queue(struct cs_etm_queue *etmq); +*cs_etm__etmq_get_packet_queue(struct cs_etm_queue *etmq, u8 trace_chan_id); #else static inline int cs_etm__process_auxtrace_info(union perf_event *event __maybe_unused, @@ -189,7 +199,8 @@ static inline int cs_etm__get_cpu(u8 trace_chan_id __maybe_unused, } static inline struct cs_etm_packet_queue *cs_etm__etmq_get_packet_queue(

• 		struct cs_etm_queue *etmq __maybe_unused)
  

• 		struct cs_etm_queue *etmq __maybe_unused,
  

• 		u8 trace_chan_id __maybe_unused)
  

{ return NULL; } -- 2.17.1