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