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