1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <endian.h>
17#include <errno.h>
18#include <byteswap.h>
19#include <inttypes.h>
20#include <linux/kernel.h>
21#include <linux/types.h>
22#include <linux/bitops.h>
23#include <linux/log2.h>
24
25#include "cpumap.h"
26#include "color.h"
27#include "evsel.h"
28#include "evlist.h"
29#include "machine.h"
30#include "session.h"
31#include "util.h"
32#include "thread.h"
33#include "thread-stack.h"
34#include "debug.h"
35#include "tsc.h"
36#include "auxtrace.h"
37#include "intel-pt-decoder/intel-pt-insn-decoder.h"
38#include "intel-bts.h"
39
40#define MAX_TIMESTAMP (~0ULL)
41
42#define INTEL_BTS_ERR_NOINSN 5
43#define INTEL_BTS_ERR_LOST 9
44
45#if __BYTE_ORDER == __BIG_ENDIAN
46#define le64_to_cpu bswap_64
47#else
48#define le64_to_cpu
49#endif
50
51struct intel_bts {
52 struct auxtrace auxtrace;
53 struct auxtrace_queues queues;
54 struct auxtrace_heap heap;
55 u32 auxtrace_type;
56 struct perf_session *session;
57 struct machine *machine;
58 bool sampling_mode;
59 bool snapshot_mode;
60 bool data_queued;
61 u32 pmu_type;
62 struct perf_tsc_conversion tc;
63 bool cap_user_time_zero;
64 struct itrace_synth_opts synth_opts;
65 bool sample_branches;
66 u32 branches_filter;
67 u64 branches_sample_type;
68 u64 branches_id;
69 size_t branches_event_size;
70 unsigned long num_events;
71};
72
73struct intel_bts_queue {
74 struct intel_bts *bts;
75 unsigned int queue_nr;
76 struct auxtrace_buffer *buffer;
77 bool on_heap;
78 bool done;
79 pid_t pid;
80 pid_t tid;
81 int cpu;
82 u64 time;
83 struct intel_pt_insn intel_pt_insn;
84 u32 sample_flags;
85};
86
87struct branch {
88 u64 from;
89 u64 to;
90 u64 misc;
91};
92
93static void intel_bts_dump(struct intel_bts *bts __maybe_unused,
94 unsigned char *buf, size_t len)
95{
96 struct branch *branch;
97 size_t i, pos = 0, br_sz = sizeof(struct branch), sz;
98 const char *color = PERF_COLOR_BLUE;
99
100 color_fprintf(stdout, color,
101 ". ... Intel BTS data: size %zu bytes\n",
102 len);
103
104 while (len) {
105 if (len >= br_sz)
106 sz = br_sz;
107 else
108 sz = len;
109 printf(".");
110 color_fprintf(stdout, color, " %08x: ", pos);
111 for (i = 0; i < sz; i++)
112 color_fprintf(stdout, color, " %02x", buf[i]);
113 for (; i < br_sz; i++)
114 color_fprintf(stdout, color, " ");
115 if (len >= br_sz) {
116 branch = (struct branch *)buf;
117 color_fprintf(stdout, color, " %"PRIx64" -> %"PRIx64" %s\n",
118 le64_to_cpu(branch->from),
119 le64_to_cpu(branch->to),
120 le64_to_cpu(branch->misc) & 0x10 ?
121 "pred" : "miss");
122 } else {
123 color_fprintf(stdout, color, " Bad record!\n");
124 }
125 pos += sz;
126 buf += sz;
127 len -= sz;
128 }
129}
130
131static void intel_bts_dump_event(struct intel_bts *bts, unsigned char *buf,
132 size_t len)
133{
134 printf(".\n");
135 intel_bts_dump(bts, buf, len);
136}
137
138static int intel_bts_lost(struct intel_bts *bts, struct perf_sample *sample)
139{
140 union perf_event event;
141 int err;
142
143 auxtrace_synth_error(&event.auxtrace_error, PERF_AUXTRACE_ERROR_ITRACE,
144 INTEL_BTS_ERR_LOST, sample->cpu, sample->pid,
145 sample->tid, 0, "Lost trace data");
146
147 err = perf_session__deliver_synth_event(bts->session, &event, NULL);
148 if (err)
149 pr_err("Intel BTS: failed to deliver error event, error %d\n",
150 err);
151
152 return err;
153}
154
155static struct intel_bts_queue *intel_bts_alloc_queue(struct intel_bts *bts,
156 unsigned int queue_nr)
157{
158 struct intel_bts_queue *btsq;
159
160 btsq = zalloc(sizeof(struct intel_bts_queue));
161 if (!btsq)
162 return NULL;
163
164 btsq->bts = bts;
165 btsq->queue_nr = queue_nr;
166 btsq->pid = -1;
167 btsq->tid = -1;
168 btsq->cpu = -1;
169
170 return btsq;
171}
172
173static int intel_bts_setup_queue(struct intel_bts *bts,
174 struct auxtrace_queue *queue,
175 unsigned int queue_nr)
176{
177 struct intel_bts_queue *btsq = queue->priv;
178
179 if (list_empty(&queue->head))
180 return 0;
181
182 if (!btsq) {
183 btsq = intel_bts_alloc_queue(bts, queue_nr);
184 if (!btsq)
185 return -ENOMEM;
186 queue->priv = btsq;
187
188 if (queue->cpu != -1)
189 btsq->cpu = queue->cpu;
190 btsq->tid = queue->tid;
191 }
192
193 if (bts->sampling_mode)
194 return 0;
195
196 if (!btsq->on_heap && !btsq->buffer) {
197 int ret;
198
199 btsq->buffer = auxtrace_buffer__next(queue, NULL);
200 if (!btsq->buffer)
201 return 0;
202
203 ret = auxtrace_heap__add(&bts->heap, queue_nr,
204 btsq->buffer->reference);
205 if (ret)
206 return ret;
207 btsq->on_heap = true;
208 }
209
210 return 0;
211}
212
213static int intel_bts_setup_queues(struct intel_bts *bts)
214{
215 unsigned int i;
216 int ret;
217
218 for (i = 0; i < bts->queues.nr_queues; i++) {
219 ret = intel_bts_setup_queue(bts, &bts->queues.queue_array[i],
220 i);
221 if (ret)
222 return ret;
223 }
224 return 0;
225}
226
227static inline int intel_bts_update_queues(struct intel_bts *bts)
228{
229 if (bts->queues.new_data) {
230 bts->queues.new_data = false;
231 return intel_bts_setup_queues(bts);
232 }
233 return 0;
234}
235
236static unsigned char *intel_bts_find_overlap(unsigned char *buf_a, size_t len_a,
237 unsigned char *buf_b, size_t len_b)
238{
239 size_t offs, len;
240
241 if (len_a > len_b)
242 offs = len_a - len_b;
243 else
244 offs = 0;
245
246 for (; offs < len_a; offs += sizeof(struct branch)) {
247 len = len_a - offs;
248 if (!memcmp(buf_a + offs, buf_b, len))
249 return buf_b + len;
250 }
251
252 return buf_b;
253}
254
255static int intel_bts_do_fix_overlap(struct auxtrace_queue *queue,
256 struct auxtrace_buffer *b)
257{
258 struct auxtrace_buffer *a;
259 void *start;
260
261 if (b->list.prev == &queue->head)
262 return 0;
263 a = list_entry(b->list.prev, struct auxtrace_buffer, list);
264 start = intel_bts_find_overlap(a->data, a->size, b->data, b->size);
265 if (!start)
266 return -EINVAL;
267 b->use_size = b->data + b->size - start;
268 b->use_data = start;
269 return 0;
270}
271
272static int intel_bts_synth_branch_sample(struct intel_bts_queue *btsq,
273 struct branch *branch)
274{
275 int ret;
276 struct intel_bts *bts = btsq->bts;
277 union perf_event event;
278 struct perf_sample sample = { .ip = 0, };
279
280 if (bts->synth_opts.initial_skip &&
281 bts->num_events++ <= bts->synth_opts.initial_skip)
282 return 0;
283
284 event.sample.header.type = PERF_RECORD_SAMPLE;
285 event.sample.header.misc = PERF_RECORD_MISC_USER;
286 event.sample.header.size = sizeof(struct perf_event_header);
287
288 sample.cpumode = PERF_RECORD_MISC_USER;
289 sample.ip = le64_to_cpu(branch->from);
290 sample.pid = btsq->pid;
291 sample.tid = btsq->tid;
292 sample.addr = le64_to_cpu(branch->to);
293 sample.id = btsq->bts->branches_id;
294 sample.stream_id = btsq->bts->branches_id;
295 sample.period = 1;
296 sample.cpu = btsq->cpu;
297 sample.flags = btsq->sample_flags;
298 sample.insn_len = btsq->intel_pt_insn.length;
299 memcpy(sample.insn, btsq->intel_pt_insn.buf, INTEL_PT_INSN_BUF_SZ);
300
301 if (bts->synth_opts.inject) {
302 event.sample.header.size = bts->branches_event_size;
303 ret = perf_event__synthesize_sample(&event,
304 bts->branches_sample_type,
305 0, &sample);
306 if (ret)
307 return ret;
308 }
309
310 ret = perf_session__deliver_synth_event(bts->session, &event, &sample);
311 if (ret)
312 pr_err("Intel BTS: failed to deliver branch event, error %d\n",
313 ret);
314
315 return ret;
316}
317
318static int intel_bts_get_next_insn(struct intel_bts_queue *btsq, u64 ip)
319{
320 struct machine *machine = btsq->bts->machine;
321 struct thread *thread;
322 struct addr_location al;
323 unsigned char buf[INTEL_PT_INSN_BUF_SZ];
324 ssize_t len;
325 int x86_64;
326 uint8_t cpumode;
327 int err = -1;
328
329 if (machine__kernel_ip(machine, ip))
330 cpumode = PERF_RECORD_MISC_KERNEL;
331 else
332 cpumode = PERF_RECORD_MISC_USER;
333
334 thread = machine__find_thread(machine, -1, btsq->tid);
335 if (!thread)
336 return -1;
337
338 if (!thread__find_map(thread, cpumode, ip, &al) || !al.map->dso)
339 goto out_put;
340
341 len = dso__data_read_addr(al.map->dso, al.map, machine, ip, buf,
342 INTEL_PT_INSN_BUF_SZ);
343 if (len <= 0)
344 goto out_put;
345
346
347 map__load(al.map);
348
349 x86_64 = al.map->dso->is_64_bit;
350
351 if (intel_pt_get_insn(buf, len, x86_64, &btsq->intel_pt_insn))
352 goto out_put;
353
354 err = 0;
355out_put:
356 thread__put(thread);
357 return err;
358}
359
360static int intel_bts_synth_error(struct intel_bts *bts, int cpu, pid_t pid,
361 pid_t tid, u64 ip)
362{
363 union perf_event event;
364 int err;
365
366 auxtrace_synth_error(&event.auxtrace_error, PERF_AUXTRACE_ERROR_ITRACE,
367 INTEL_BTS_ERR_NOINSN, cpu, pid, tid, ip,
368 "Failed to get instruction");
369
370 err = perf_session__deliver_synth_event(bts->session, &event, NULL);
371 if (err)
372 pr_err("Intel BTS: failed to deliver error event, error %d\n",
373 err);
374
375 return err;
376}
377
378static int intel_bts_get_branch_type(struct intel_bts_queue *btsq,
379 struct branch *branch)
380{
381 int err;
382
383 if (!branch->from) {
384 if (branch->to)
385 btsq->sample_flags = PERF_IP_FLAG_BRANCH |
386 PERF_IP_FLAG_TRACE_BEGIN;
387 else
388 btsq->sample_flags = 0;
389 btsq->intel_pt_insn.length = 0;
390 } else if (!branch->to) {
391 btsq->sample_flags = PERF_IP_FLAG_BRANCH |
392 PERF_IP_FLAG_TRACE_END;
393 btsq->intel_pt_insn.length = 0;
394 } else {
395 err = intel_bts_get_next_insn(btsq, branch->from);
396 if (err) {
397 btsq->sample_flags = 0;
398 btsq->intel_pt_insn.length = 0;
399 if (!btsq->bts->synth_opts.errors)
400 return 0;
401 err = intel_bts_synth_error(btsq->bts, btsq->cpu,
402 btsq->pid, btsq->tid,
403 branch->from);
404 return err;
405 }
406 btsq->sample_flags = intel_pt_insn_type(btsq->intel_pt_insn.op);
407
408 if (!machine__kernel_ip(btsq->bts->machine, branch->from) &&
409 machine__kernel_ip(btsq->bts->machine, branch->to) &&
410 btsq->sample_flags != (PERF_IP_FLAG_BRANCH |
411 PERF_IP_FLAG_CALL |
412 PERF_IP_FLAG_SYSCALLRET))
413 btsq->sample_flags = PERF_IP_FLAG_BRANCH |
414 PERF_IP_FLAG_CALL |
415 PERF_IP_FLAG_ASYNC |
416 PERF_IP_FLAG_INTERRUPT;
417 }
418
419 return 0;
420}
421
422static int intel_bts_process_buffer(struct intel_bts_queue *btsq,
423 struct auxtrace_buffer *buffer,
424 struct thread *thread)
425{
426 struct branch *branch;
427 size_t sz, bsz = sizeof(struct branch);
428 u32 filter = btsq->bts->branches_filter;
429 int err = 0;
430
431 if (buffer->use_data) {
432 sz = buffer->use_size;
433 branch = buffer->use_data;
434 } else {
435 sz = buffer->size;
436 branch = buffer->data;
437 }
438
439 if (!btsq->bts->sample_branches)
440 return 0;
441
442 for (; sz > bsz; branch += 1, sz -= bsz) {
443 if (!branch->from && !branch->to)
444 continue;
445 intel_bts_get_branch_type(btsq, branch);
446 if (btsq->bts->synth_opts.thread_stack)
447 thread_stack__event(thread, btsq->sample_flags,
448 le64_to_cpu(branch->from),
449 le64_to_cpu(branch->to),
450 btsq->intel_pt_insn.length,
451 buffer->buffer_nr + 1);
452 if (filter && !(filter & btsq->sample_flags))
453 continue;
454 err = intel_bts_synth_branch_sample(btsq, branch);
455 if (err)
456 break;
457 }
458 return err;
459}
460
461static int intel_bts_process_queue(struct intel_bts_queue *btsq, u64 *timestamp)
462{
463 struct auxtrace_buffer *buffer = btsq->buffer, *old_buffer = buffer;
464 struct auxtrace_queue *queue;
465 struct thread *thread;
466 int err;
467
468 if (btsq->done)
469 return 1;
470
471 if (btsq->pid == -1) {
472 thread = machine__find_thread(btsq->bts->machine, -1,
473 btsq->tid);
474 if (thread)
475 btsq->pid = thread->pid_;
476 } else {
477 thread = machine__findnew_thread(btsq->bts->machine, btsq->pid,
478 btsq->tid);
479 }
480
481 queue = &btsq->bts->queues.queue_array[btsq->queue_nr];
482
483 if (!buffer)
484 buffer = auxtrace_buffer__next(queue, NULL);
485
486 if (!buffer) {
487 if (!btsq->bts->sampling_mode)
488 btsq->done = 1;
489 err = 1;
490 goto out_put;
491 }
492
493
494 if (buffer->consecutive) {
495 err = -EINVAL;
496 goto out_put;
497 }
498
499 if (!buffer->data) {
500 int fd = perf_data__fd(btsq->bts->session->data);
501
502 buffer->data = auxtrace_buffer__get_data(buffer, fd);
503 if (!buffer->data) {
504 err = -ENOMEM;
505 goto out_put;
506 }
507 }
508
509 if (btsq->bts->snapshot_mode && !buffer->consecutive &&
510 intel_bts_do_fix_overlap(queue, buffer)) {
511 err = -ENOMEM;
512 goto out_put;
513 }
514
515 if (!btsq->bts->synth_opts.callchain &&
516 !btsq->bts->synth_opts.thread_stack && thread &&
517 (!old_buffer || btsq->bts->sampling_mode ||
518 (btsq->bts->snapshot_mode && !buffer->consecutive)))
519 thread_stack__set_trace_nr(thread, buffer->buffer_nr + 1);
520
521 err = intel_bts_process_buffer(btsq, buffer, thread);
522
523 auxtrace_buffer__drop_data(buffer);
524
525 btsq->buffer = auxtrace_buffer__next(queue, buffer);
526 if (btsq->buffer) {
527 if (timestamp)
528 *timestamp = btsq->buffer->reference;
529 } else {
530 if (!btsq->bts->sampling_mode)
531 btsq->done = 1;
532 }
533out_put:
534 thread__put(thread);
535 return err;
536}
537
538static int intel_bts_flush_queue(struct intel_bts_queue *btsq)
539{
540 u64 ts = 0;
541 int ret;
542
543 while (1) {
544 ret = intel_bts_process_queue(btsq, &ts);
545 if (ret < 0)
546 return ret;
547 if (ret)
548 break;
549 }
550 return 0;
551}
552
553static int intel_bts_process_tid_exit(struct intel_bts *bts, pid_t tid)
554{
555 struct auxtrace_queues *queues = &bts->queues;
556 unsigned int i;
557
558 for (i = 0; i < queues->nr_queues; i++) {
559 struct auxtrace_queue *queue = &bts->queues.queue_array[i];
560 struct intel_bts_queue *btsq = queue->priv;
561
562 if (btsq && btsq->tid == tid)
563 return intel_bts_flush_queue(btsq);
564 }
565 return 0;
566}
567
568static int intel_bts_process_queues(struct intel_bts *bts, u64 timestamp)
569{
570 while (1) {
571 unsigned int queue_nr;
572 struct auxtrace_queue *queue;
573 struct intel_bts_queue *btsq;
574 u64 ts = 0;
575 int ret;
576
577 if (!bts->heap.heap_cnt)
578 return 0;
579
580 if (bts->heap.heap_array[0].ordinal > timestamp)
581 return 0;
582
583 queue_nr = bts->heap.heap_array[0].queue_nr;
584 queue = &bts->queues.queue_array[queue_nr];
585 btsq = queue->priv;
586
587 auxtrace_heap__pop(&bts->heap);
588
589 ret = intel_bts_process_queue(btsq, &ts);
590 if (ret < 0) {
591 auxtrace_heap__add(&bts->heap, queue_nr, ts);
592 return ret;
593 }
594
595 if (!ret) {
596 ret = auxtrace_heap__add(&bts->heap, queue_nr, ts);
597 if (ret < 0)
598 return ret;
599 } else {
600 btsq->on_heap = false;
601 }
602 }
603
604 return 0;
605}
606
607static int intel_bts_process_event(struct perf_session *session,
608 union perf_event *event,
609 struct perf_sample *sample,
610 struct perf_tool *tool)
611{
612 struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
613 auxtrace);
614 u64 timestamp;
615 int err;
616
617 if (dump_trace)
618 return 0;
619
620 if (!tool->ordered_events) {
621 pr_err("Intel BTS requires ordered events\n");
622 return -EINVAL;
623 }
624
625 if (sample->time && sample->time != (u64)-1)
626 timestamp = perf_time_to_tsc(sample->time, &bts->tc);
627 else
628 timestamp = 0;
629
630 err = intel_bts_update_queues(bts);
631 if (err)
632 return err;
633
634 err = intel_bts_process_queues(bts, timestamp);
635 if (err)
636 return err;
637 if (event->header.type == PERF_RECORD_EXIT) {
638 err = intel_bts_process_tid_exit(bts, event->fork.tid);
639 if (err)
640 return err;
641 }
642
643 if (event->header.type == PERF_RECORD_AUX &&
644 (event->aux.flags & PERF_AUX_FLAG_TRUNCATED) &&
645 bts->synth_opts.errors)
646 err = intel_bts_lost(bts, sample);
647
648 return err;
649}
650
651static int intel_bts_process_auxtrace_event(struct perf_session *session,
652 union perf_event *event,
653 struct perf_tool *tool __maybe_unused)
654{
655 struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
656 auxtrace);
657
658 if (bts->sampling_mode)
659 return 0;
660
661 if (!bts->data_queued) {
662 struct auxtrace_buffer *buffer;
663 off_t data_offset;
664 int fd = perf_data__fd(session->data);
665 int err;
666
667 if (perf_data__is_pipe(session->data)) {
668 data_offset = 0;
669 } else {
670 data_offset = lseek(fd, 0, SEEK_CUR);
671 if (data_offset == -1)
672 return -errno;
673 }
674
675 err = auxtrace_queues__add_event(&bts->queues, session, event,
676 data_offset, &buffer);
677 if (err)
678 return err;
679
680
681 if (dump_trace) {
682 if (auxtrace_buffer__get_data(buffer, fd)) {
683 intel_bts_dump_event(bts, buffer->data,
684 buffer->size);
685 auxtrace_buffer__put_data(buffer);
686 }
687 }
688 }
689
690 return 0;
691}
692
693static int intel_bts_flush(struct perf_session *session,
694 struct perf_tool *tool __maybe_unused)
695{
696 struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
697 auxtrace);
698 int ret;
699
700 if (dump_trace || bts->sampling_mode)
701 return 0;
702
703 if (!tool->ordered_events)
704 return -EINVAL;
705
706 ret = intel_bts_update_queues(bts);
707 if (ret < 0)
708 return ret;
709
710 return intel_bts_process_queues(bts, MAX_TIMESTAMP);
711}
712
713static void intel_bts_free_queue(void *priv)
714{
715 struct intel_bts_queue *btsq = priv;
716
717 if (!btsq)
718 return;
719 free(btsq);
720}
721
722static void intel_bts_free_events(struct perf_session *session)
723{
724 struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
725 auxtrace);
726 struct auxtrace_queues *queues = &bts->queues;
727 unsigned int i;
728
729 for (i = 0; i < queues->nr_queues; i++) {
730 intel_bts_free_queue(queues->queue_array[i].priv);
731 queues->queue_array[i].priv = NULL;
732 }
733 auxtrace_queues__free(queues);
734}
735
736static void intel_bts_free(struct perf_session *session)
737{
738 struct intel_bts *bts = container_of(session->auxtrace, struct intel_bts,
739 auxtrace);
740
741 auxtrace_heap__free(&bts->heap);
742 intel_bts_free_events(session);
743 session->auxtrace = NULL;
744 free(bts);
745}
746
747struct intel_bts_synth {
748 struct perf_tool dummy_tool;
749 struct perf_session *session;
750};
751
752static int intel_bts_event_synth(struct perf_tool *tool,
753 union perf_event *event,
754 struct perf_sample *sample __maybe_unused,
755 struct machine *machine __maybe_unused)
756{
757 struct intel_bts_synth *intel_bts_synth =
758 container_of(tool, struct intel_bts_synth, dummy_tool);
759
760 return perf_session__deliver_synth_event(intel_bts_synth->session,
761 event, NULL);
762}
763
764static int intel_bts_synth_event(struct perf_session *session,
765 struct perf_event_attr *attr, u64 id)
766{
767 struct intel_bts_synth intel_bts_synth;
768
769 memset(&intel_bts_synth, 0, sizeof(struct intel_bts_synth));
770 intel_bts_synth.session = session;
771
772 return perf_event__synthesize_attr(&intel_bts_synth.dummy_tool, attr, 1,
773 &id, intel_bts_event_synth);
774}
775
776static int intel_bts_synth_events(struct intel_bts *bts,
777 struct perf_session *session)
778{
779 struct perf_evlist *evlist = session->evlist;
780 struct perf_evsel *evsel;
781 struct perf_event_attr attr;
782 bool found = false;
783 u64 id;
784 int err;
785
786 evlist__for_each_entry(evlist, evsel) {
787 if (evsel->attr.type == bts->pmu_type && evsel->ids) {
788 found = true;
789 break;
790 }
791 }
792
793 if (!found) {
794 pr_debug("There are no selected events with Intel BTS data\n");
795 return 0;
796 }
797
798 memset(&attr, 0, sizeof(struct perf_event_attr));
799 attr.size = sizeof(struct perf_event_attr);
800 attr.type = PERF_TYPE_HARDWARE;
801 attr.sample_type = evsel->attr.sample_type & PERF_SAMPLE_MASK;
802 attr.sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID |
803 PERF_SAMPLE_PERIOD;
804 attr.sample_type &= ~(u64)PERF_SAMPLE_TIME;
805 attr.sample_type &= ~(u64)PERF_SAMPLE_CPU;
806 attr.exclude_user = evsel->attr.exclude_user;
807 attr.exclude_kernel = evsel->attr.exclude_kernel;
808 attr.exclude_hv = evsel->attr.exclude_hv;
809 attr.exclude_host = evsel->attr.exclude_host;
810 attr.exclude_guest = evsel->attr.exclude_guest;
811 attr.sample_id_all = evsel->attr.sample_id_all;
812 attr.read_format = evsel->attr.read_format;
813
814 id = evsel->id[0] + 1000000000;
815 if (!id)
816 id = 1;
817
818 if (bts->synth_opts.branches) {
819 attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
820 attr.sample_period = 1;
821 attr.sample_type |= PERF_SAMPLE_ADDR;
822 pr_debug("Synthesizing 'branches' event with id %" PRIu64 " sample type %#" PRIx64 "\n",
823 id, (u64)attr.sample_type);
824 err = intel_bts_synth_event(session, &attr, id);
825 if (err) {
826 pr_err("%s: failed to synthesize 'branches' event type\n",
827 __func__);
828 return err;
829 }
830 bts->sample_branches = true;
831 bts->branches_sample_type = attr.sample_type;
832 bts->branches_id = id;
833
834
835
836
837 bts->branches_event_size = sizeof(struct sample_event) +
838 __perf_evsel__sample_size(attr.sample_type);
839 }
840
841 return 0;
842}
843
844static const char * const intel_bts_info_fmts[] = {
845 [INTEL_BTS_PMU_TYPE] = " PMU Type %"PRId64"\n",
846 [INTEL_BTS_TIME_SHIFT] = " Time Shift %"PRIu64"\n",
847 [INTEL_BTS_TIME_MULT] = " Time Muliplier %"PRIu64"\n",
848 [INTEL_BTS_TIME_ZERO] = " Time Zero %"PRIu64"\n",
849 [INTEL_BTS_CAP_USER_TIME_ZERO] = " Cap Time Zero %"PRId64"\n",
850 [INTEL_BTS_SNAPSHOT_MODE] = " Snapshot mode %"PRId64"\n",
851};
852
853static void intel_bts_print_info(u64 *arr, int start, int finish)
854{
855 int i;
856
857 if (!dump_trace)
858 return;
859
860 for (i = start; i <= finish; i++)
861 fprintf(stdout, intel_bts_info_fmts[i], arr[i]);
862}
863
864int intel_bts_process_auxtrace_info(union perf_event *event,
865 struct perf_session *session)
866{
867 struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
868 size_t min_sz = sizeof(u64) * INTEL_BTS_SNAPSHOT_MODE;
869 struct intel_bts *bts;
870 int err;
871
872 if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
873 min_sz)
874 return -EINVAL;
875
876 bts = zalloc(sizeof(struct intel_bts));
877 if (!bts)
878 return -ENOMEM;
879
880 err = auxtrace_queues__init(&bts->queues);
881 if (err)
882 goto err_free;
883
884 bts->session = session;
885 bts->machine = &session->machines.host;
886 bts->auxtrace_type = auxtrace_info->type;
887 bts->pmu_type = auxtrace_info->priv[INTEL_BTS_PMU_TYPE];
888 bts->tc.time_shift = auxtrace_info->priv[INTEL_BTS_TIME_SHIFT];
889 bts->tc.time_mult = auxtrace_info->priv[INTEL_BTS_TIME_MULT];
890 bts->tc.time_zero = auxtrace_info->priv[INTEL_BTS_TIME_ZERO];
891 bts->cap_user_time_zero =
892 auxtrace_info->priv[INTEL_BTS_CAP_USER_TIME_ZERO];
893 bts->snapshot_mode = auxtrace_info->priv[INTEL_BTS_SNAPSHOT_MODE];
894
895 bts->sampling_mode = false;
896
897 bts->auxtrace.process_event = intel_bts_process_event;
898 bts->auxtrace.process_auxtrace_event = intel_bts_process_auxtrace_event;
899 bts->auxtrace.flush_events = intel_bts_flush;
900 bts->auxtrace.free_events = intel_bts_free_events;
901 bts->auxtrace.free = intel_bts_free;
902 session->auxtrace = &bts->auxtrace;
903
904 intel_bts_print_info(&auxtrace_info->priv[0], INTEL_BTS_PMU_TYPE,
905 INTEL_BTS_SNAPSHOT_MODE);
906
907 if (dump_trace)
908 return 0;
909
910 if (session->itrace_synth_opts && session->itrace_synth_opts->set) {
911 bts->synth_opts = *session->itrace_synth_opts;
912 } else {
913 itrace_synth_opts__set_default(&bts->synth_opts);
914 if (session->itrace_synth_opts)
915 bts->synth_opts.thread_stack =
916 session->itrace_synth_opts->thread_stack;
917 }
918
919 if (bts->synth_opts.calls)
920 bts->branches_filter |= PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC |
921 PERF_IP_FLAG_TRACE_END;
922 if (bts->synth_opts.returns)
923 bts->branches_filter |= PERF_IP_FLAG_RETURN |
924 PERF_IP_FLAG_TRACE_BEGIN;
925
926 err = intel_bts_synth_events(bts, session);
927 if (err)
928 goto err_free_queues;
929
930 err = auxtrace_queues__process_index(&bts->queues, session);
931 if (err)
932 goto err_free_queues;
933
934 if (bts->queues.populated)
935 bts->data_queued = true;
936
937 return 0;
938
939err_free_queues:
940 auxtrace_queues__free(&bts->queues);
941 session->auxtrace = NULL;
942err_free:
943 free(bts);
944 return err;
945}
946
