]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - tools/perf/util/auxtrace.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf tools: Including missing inttypes.h header
[mirror_ubuntu-focal-kernel.git] / tools / perf / util / auxtrace.c
1 /*
2 * auxtrace.c: AUX area 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 <inttypes.h>
17 #include <sys/types.h>
18 #include <sys/mman.h>
19 #include <stdbool.h>
20 #include <ctype.h>
21 #include <string.h>
22 #include <limits.h>
23 #include <errno.h>
24
25 #include <linux/kernel.h>
26 #include <linux/perf_event.h>
27 #include <linux/types.h>
28 #include <linux/bitops.h>
29 #include <linux/log2.h>
30 #include <linux/string.h>
31
32 #include <sys/param.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <limits.h>
37 #include <errno.h>
38 #include <linux/list.h>
39
40 #include "../perf.h"
41 #include "util.h"
42 #include "evlist.h"
43 #include "dso.h"
44 #include "map.h"
45 #include "pmu.h"
46 #include "evsel.h"
47 #include "cpumap.h"
48 #include "thread_map.h"
49 #include "asm/bug.h"
50 #include "symbol/kallsyms.h"
51 #include "auxtrace.h"
52
53 #include <linux/hash.h>
54
55 #include "event.h"
56 #include "session.h"
57 #include "debug.h"
58 #include <subcmd/parse-options.h>
59
60 #include "intel-pt.h"
61 #include "intel-bts.h"
62
63 int auxtrace_mmap__mmap(struct auxtrace_mmap *mm,
64 struct auxtrace_mmap_params *mp,
65 void *userpg, int fd)
66 {
67 struct perf_event_mmap_page *pc = userpg;
68
69 WARN_ONCE(mm->base, "Uninitialized auxtrace_mmap\n");
70
71 mm->userpg = userpg;
72 mm->mask = mp->mask;
73 mm->len = mp->len;
74 mm->prev = 0;
75 mm->idx = mp->idx;
76 mm->tid = mp->tid;
77 mm->cpu = mp->cpu;
78
79 if (!mp->len) {
80 mm->base = NULL;
81 return 0;
82 }
83
84 #if BITS_PER_LONG != 64 && !defined(HAVE_SYNC_COMPARE_AND_SWAP_SUPPORT)
85 pr_err("Cannot use AUX area tracing mmaps\n");
86 return -1;
87 #endif
88
89 pc->aux_offset = mp->offset;
90 pc->aux_size = mp->len;
91
92 mm->base = mmap(NULL, mp->len, mp->prot, MAP_SHARED, fd, mp->offset);
93 if (mm->base == MAP_FAILED) {
94 pr_debug2("failed to mmap AUX area\n");
95 mm->base = NULL;
96 return -1;
97 }
98
99 return 0;
100 }
101
102 void auxtrace_mmap__munmap(struct auxtrace_mmap *mm)
103 {
104 if (mm->base) {
105 munmap(mm->base, mm->len);
106 mm->base = NULL;
107 }
108 }
109
110 void auxtrace_mmap_params__init(struct auxtrace_mmap_params *mp,
111 off_t auxtrace_offset,
112 unsigned int auxtrace_pages,
113 bool auxtrace_overwrite)
114 {
115 if (auxtrace_pages) {
116 mp->offset = auxtrace_offset;
117 mp->len = auxtrace_pages * (size_t)page_size;
118 mp->mask = is_power_of_2(mp->len) ? mp->len - 1 : 0;
119 mp->prot = PROT_READ | (auxtrace_overwrite ? 0 : PROT_WRITE);
120 pr_debug2("AUX area mmap length %zu\n", mp->len);
121 } else {
122 mp->len = 0;
123 }
124 }
125
126 void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params *mp,
127 struct perf_evlist *evlist, int idx,
128 bool per_cpu)
129 {
130 mp->idx = idx;
131
132 if (per_cpu) {
133 mp->cpu = evlist->cpus->map[idx];
134 if (evlist->threads)
135 mp->tid = thread_map__pid(evlist->threads, 0);
136 else
137 mp->tid = -1;
138 } else {
139 mp->cpu = -1;
140 mp->tid = thread_map__pid(evlist->threads, idx);
141 }
142 }
143
144 #define AUXTRACE_INIT_NR_QUEUES 32
145
146 static struct auxtrace_queue *auxtrace_alloc_queue_array(unsigned int nr_queues)
147 {
148 struct auxtrace_queue *queue_array;
149 unsigned int max_nr_queues, i;
150
151 max_nr_queues = UINT_MAX / sizeof(struct auxtrace_queue);
152 if (nr_queues > max_nr_queues)
153 return NULL;
154
155 queue_array = calloc(nr_queues, sizeof(struct auxtrace_queue));
156 if (!queue_array)
157 return NULL;
158
159 for (i = 0; i < nr_queues; i++) {
160 INIT_LIST_HEAD(&queue_array[i].head);
161 queue_array[i].priv = NULL;
162 }
163
164 return queue_array;
165 }
166
167 int auxtrace_queues__init(struct auxtrace_queues *queues)
168 {
169 queues->nr_queues = AUXTRACE_INIT_NR_QUEUES;
170 queues->queue_array = auxtrace_alloc_queue_array(queues->nr_queues);
171 if (!queues->queue_array)
172 return -ENOMEM;
173 return 0;
174 }
175
176 static int auxtrace_queues__grow(struct auxtrace_queues *queues,
177 unsigned int new_nr_queues)
178 {
179 unsigned int nr_queues = queues->nr_queues;
180 struct auxtrace_queue *queue_array;
181 unsigned int i;
182
183 if (!nr_queues)
184 nr_queues = AUXTRACE_INIT_NR_QUEUES;
185
186 while (nr_queues && nr_queues < new_nr_queues)
187 nr_queues <<= 1;
188
189 if (nr_queues < queues->nr_queues || nr_queues < new_nr_queues)
190 return -EINVAL;
191
192 queue_array = auxtrace_alloc_queue_array(nr_queues);
193 if (!queue_array)
194 return -ENOMEM;
195
196 for (i = 0; i < queues->nr_queues; i++) {
197 list_splice_tail(&queues->queue_array[i].head,
198 &queue_array[i].head);
199 queue_array[i].priv = queues->queue_array[i].priv;
200 }
201
202 queues->nr_queues = nr_queues;
203 queues->queue_array = queue_array;
204
205 return 0;
206 }
207
208 static void *auxtrace_copy_data(u64 size, struct perf_session *session)
209 {
210 int fd = perf_data_file__fd(session->file);
211 void *p;
212 ssize_t ret;
213
214 if (size > SSIZE_MAX)
215 return NULL;
216
217 p = malloc(size);
218 if (!p)
219 return NULL;
220
221 ret = readn(fd, p, size);
222 if (ret != (ssize_t)size) {
223 free(p);
224 return NULL;
225 }
226
227 return p;
228 }
229
230 static int auxtrace_queues__add_buffer(struct auxtrace_queues *queues,
231 unsigned int idx,
232 struct auxtrace_buffer *buffer)
233 {
234 struct auxtrace_queue *queue;
235 int err;
236
237 if (idx >= queues->nr_queues) {
238 err = auxtrace_queues__grow(queues, idx + 1);
239 if (err)
240 return err;
241 }
242
243 queue = &queues->queue_array[idx];
244
245 if (!queue->set) {
246 queue->set = true;
247 queue->tid = buffer->tid;
248 queue->cpu = buffer->cpu;
249 } else if (buffer->cpu != queue->cpu || buffer->tid != queue->tid) {
250 pr_err("auxtrace queue conflict: cpu %d, tid %d vs cpu %d, tid %d\n",
251 queue->cpu, queue->tid, buffer->cpu, buffer->tid);
252 return -EINVAL;
253 }
254
255 buffer->buffer_nr = queues->next_buffer_nr++;
256
257 list_add_tail(&buffer->list, &queue->head);
258
259 queues->new_data = true;
260 queues->populated = true;
261
262 return 0;
263 }
264
265 /* Limit buffers to 32MiB on 32-bit */
266 #define BUFFER_LIMIT_FOR_32_BIT (32 * 1024 * 1024)
267
268 static int auxtrace_queues__split_buffer(struct auxtrace_queues *queues,
269 unsigned int idx,
270 struct auxtrace_buffer *buffer)
271 {
272 u64 sz = buffer->size;
273 bool consecutive = false;
274 struct auxtrace_buffer *b;
275 int err;
276
277 while (sz > BUFFER_LIMIT_FOR_32_BIT) {
278 b = memdup(buffer, sizeof(struct auxtrace_buffer));
279 if (!b)
280 return -ENOMEM;
281 b->size = BUFFER_LIMIT_FOR_32_BIT;
282 b->consecutive = consecutive;
283 err = auxtrace_queues__add_buffer(queues, idx, b);
284 if (err) {
285 auxtrace_buffer__free(b);
286 return err;
287 }
288 buffer->data_offset += BUFFER_LIMIT_FOR_32_BIT;
289 sz -= BUFFER_LIMIT_FOR_32_BIT;
290 consecutive = true;
291 }
292
293 buffer->size = sz;
294 buffer->consecutive = consecutive;
295
296 return 0;
297 }
298
299 static int auxtrace_queues__add_event_buffer(struct auxtrace_queues *queues,
300 struct perf_session *session,
301 unsigned int idx,
302 struct auxtrace_buffer *buffer)
303 {
304 if (session->one_mmap) {
305 buffer->data = buffer->data_offset - session->one_mmap_offset +
306 session->one_mmap_addr;
307 } else if (perf_data_file__is_pipe(session->file)) {
308 buffer->data = auxtrace_copy_data(buffer->size, session);
309 if (!buffer->data)
310 return -ENOMEM;
311 buffer->data_needs_freeing = true;
312 } else if (BITS_PER_LONG == 32 &&
313 buffer->size > BUFFER_LIMIT_FOR_32_BIT) {
314 int err;
315
316 err = auxtrace_queues__split_buffer(queues, idx, buffer);
317 if (err)
318 return err;
319 }
320
321 return auxtrace_queues__add_buffer(queues, idx, buffer);
322 }
323
324 int auxtrace_queues__add_event(struct auxtrace_queues *queues,
325 struct perf_session *session,
326 union perf_event *event, off_t data_offset,
327 struct auxtrace_buffer **buffer_ptr)
328 {
329 struct auxtrace_buffer *buffer;
330 unsigned int idx;
331 int err;
332
333 buffer = zalloc(sizeof(struct auxtrace_buffer));
334 if (!buffer)
335 return -ENOMEM;
336
337 buffer->pid = -1;
338 buffer->tid = event->auxtrace.tid;
339 buffer->cpu = event->auxtrace.cpu;
340 buffer->data_offset = data_offset;
341 buffer->offset = event->auxtrace.offset;
342 buffer->reference = event->auxtrace.reference;
343 buffer->size = event->auxtrace.size;
344 idx = event->auxtrace.idx;
345
346 err = auxtrace_queues__add_event_buffer(queues, session, idx, buffer);
347 if (err)
348 goto out_err;
349
350 if (buffer_ptr)
351 *buffer_ptr = buffer;
352
353 return 0;
354
355 out_err:
356 auxtrace_buffer__free(buffer);
357 return err;
358 }
359
360 static int auxtrace_queues__add_indexed_event(struct auxtrace_queues *queues,
361 struct perf_session *session,
362 off_t file_offset, size_t sz)
363 {
364 union perf_event *event;
365 int err;
366 char buf[PERF_SAMPLE_MAX_SIZE];
367
368 err = perf_session__peek_event(session, file_offset, buf,
369 PERF_SAMPLE_MAX_SIZE, &event, NULL);
370 if (err)
371 return err;
372
373 if (event->header.type == PERF_RECORD_AUXTRACE) {
374 if (event->header.size < sizeof(struct auxtrace_event) ||
375 event->header.size != sz) {
376 err = -EINVAL;
377 goto out;
378 }
379 file_offset += event->header.size;
380 err = auxtrace_queues__add_event(queues, session, event,
381 file_offset, NULL);
382 }
383 out:
384 return err;
385 }
386
387 void auxtrace_queues__free(struct auxtrace_queues *queues)
388 {
389 unsigned int i;
390
391 for (i = 0; i < queues->nr_queues; i++) {
392 while (!list_empty(&queues->queue_array[i].head)) {
393 struct auxtrace_buffer *buffer;
394
395 buffer = list_entry(queues->queue_array[i].head.next,
396 struct auxtrace_buffer, list);
397 list_del(&buffer->list);
398 auxtrace_buffer__free(buffer);
399 }
400 }
401
402 zfree(&queues->queue_array);
403 queues->nr_queues = 0;
404 }
405
406 static void auxtrace_heapify(struct auxtrace_heap_item *heap_array,
407 unsigned int pos, unsigned int queue_nr,
408 u64 ordinal)
409 {
410 unsigned int parent;
411
412 while (pos) {
413 parent = (pos - 1) >> 1;
414 if (heap_array[parent].ordinal <= ordinal)
415 break;
416 heap_array[pos] = heap_array[parent];
417 pos = parent;
418 }
419 heap_array[pos].queue_nr = queue_nr;
420 heap_array[pos].ordinal = ordinal;
421 }
422
423 int auxtrace_heap__add(struct auxtrace_heap *heap, unsigned int queue_nr,
424 u64 ordinal)
425 {
426 struct auxtrace_heap_item *heap_array;
427
428 if (queue_nr >= heap->heap_sz) {
429 unsigned int heap_sz = AUXTRACE_INIT_NR_QUEUES;
430
431 while (heap_sz <= queue_nr)
432 heap_sz <<= 1;
433 heap_array = realloc(heap->heap_array,
434 heap_sz * sizeof(struct auxtrace_heap_item));
435 if (!heap_array)
436 return -ENOMEM;
437 heap->heap_array = heap_array;
438 heap->heap_sz = heap_sz;
439 }
440
441 auxtrace_heapify(heap->heap_array, heap->heap_cnt++, queue_nr, ordinal);
442
443 return 0;
444 }
445
446 void auxtrace_heap__free(struct auxtrace_heap *heap)
447 {
448 zfree(&heap->heap_array);
449 heap->heap_cnt = 0;
450 heap->heap_sz = 0;
451 }
452
453 void auxtrace_heap__pop(struct auxtrace_heap *heap)
454 {
455 unsigned int pos, last, heap_cnt = heap->heap_cnt;
456 struct auxtrace_heap_item *heap_array;
457
458 if (!heap_cnt)
459 return;
460
461 heap->heap_cnt -= 1;
462
463 heap_array = heap->heap_array;
464
465 pos = 0;
466 while (1) {
467 unsigned int left, right;
468
469 left = (pos << 1) + 1;
470 if (left >= heap_cnt)
471 break;
472 right = left + 1;
473 if (right >= heap_cnt) {
474 heap_array[pos] = heap_array[left];
475 return;
476 }
477 if (heap_array[left].ordinal < heap_array[right].ordinal) {
478 heap_array[pos] = heap_array[left];
479 pos = left;
480 } else {
481 heap_array[pos] = heap_array[right];
482 pos = right;
483 }
484 }
485
486 last = heap_cnt - 1;
487 auxtrace_heapify(heap_array, pos, heap_array[last].queue_nr,
488 heap_array[last].ordinal);
489 }
490
491 size_t auxtrace_record__info_priv_size(struct auxtrace_record *itr,
492 struct perf_evlist *evlist)
493 {
494 if (itr)
495 return itr->info_priv_size(itr, evlist);
496 return 0;
497 }
498
499 static int auxtrace_not_supported(void)
500 {
501 pr_err("AUX area tracing is not supported on this architecture\n");
502 return -EINVAL;
503 }
504
505 int auxtrace_record__info_fill(struct auxtrace_record *itr,
506 struct perf_session *session,
507 struct auxtrace_info_event *auxtrace_info,
508 size_t priv_size)
509 {
510 if (itr)
511 return itr->info_fill(itr, session, auxtrace_info, priv_size);
512 return auxtrace_not_supported();
513 }
514
515 void auxtrace_record__free(struct auxtrace_record *itr)
516 {
517 if (itr)
518 itr->free(itr);
519 }
520
521 int auxtrace_record__snapshot_start(struct auxtrace_record *itr)
522 {
523 if (itr && itr->snapshot_start)
524 return itr->snapshot_start(itr);
525 return 0;
526 }
527
528 int auxtrace_record__snapshot_finish(struct auxtrace_record *itr)
529 {
530 if (itr && itr->snapshot_finish)
531 return itr->snapshot_finish(itr);
532 return 0;
533 }
534
535 int auxtrace_record__find_snapshot(struct auxtrace_record *itr, int idx,
536 struct auxtrace_mmap *mm,
537 unsigned char *data, u64 *head, u64 *old)
538 {
539 if (itr && itr->find_snapshot)
540 return itr->find_snapshot(itr, idx, mm, data, head, old);
541 return 0;
542 }
543
544 int auxtrace_record__options(struct auxtrace_record *itr,
545 struct perf_evlist *evlist,
546 struct record_opts *opts)
547 {
548 if (itr)
549 return itr->recording_options(itr, evlist, opts);
550 return 0;
551 }
552
553 u64 auxtrace_record__reference(struct auxtrace_record *itr)
554 {
555 if (itr)
556 return itr->reference(itr);
557 return 0;
558 }
559
560 int auxtrace_parse_snapshot_options(struct auxtrace_record *itr,
561 struct record_opts *opts, const char *str)
562 {
563 if (!str)
564 return 0;
565
566 if (itr)
567 return itr->parse_snapshot_options(itr, opts, str);
568
569 pr_err("No AUX area tracing to snapshot\n");
570 return -EINVAL;
571 }
572
573 struct auxtrace_record *__weak
574 auxtrace_record__init(struct perf_evlist *evlist __maybe_unused, int *err)
575 {
576 *err = 0;
577 return NULL;
578 }
579
580 static int auxtrace_index__alloc(struct list_head *head)
581 {
582 struct auxtrace_index *auxtrace_index;
583
584 auxtrace_index = malloc(sizeof(struct auxtrace_index));
585 if (!auxtrace_index)
586 return -ENOMEM;
587
588 auxtrace_index->nr = 0;
589 INIT_LIST_HEAD(&auxtrace_index->list);
590
591 list_add_tail(&auxtrace_index->list, head);
592
593 return 0;
594 }
595
596 void auxtrace_index__free(struct list_head *head)
597 {
598 struct auxtrace_index *auxtrace_index, *n;
599
600 list_for_each_entry_safe(auxtrace_index, n, head, list) {
601 list_del(&auxtrace_index->list);
602 free(auxtrace_index);
603 }
604 }
605
606 static struct auxtrace_index *auxtrace_index__last(struct list_head *head)
607 {
608 struct auxtrace_index *auxtrace_index;
609 int err;
610
611 if (list_empty(head)) {
612 err = auxtrace_index__alloc(head);
613 if (err)
614 return NULL;
615 }
616
617 auxtrace_index = list_entry(head->prev, struct auxtrace_index, list);
618
619 if (auxtrace_index->nr >= PERF_AUXTRACE_INDEX_ENTRY_COUNT) {
620 err = auxtrace_index__alloc(head);
621 if (err)
622 return NULL;
623 auxtrace_index = list_entry(head->prev, struct auxtrace_index,
624 list);
625 }
626
627 return auxtrace_index;
628 }
629
630 int auxtrace_index__auxtrace_event(struct list_head *head,
631 union perf_event *event, off_t file_offset)
632 {
633 struct auxtrace_index *auxtrace_index;
634 size_t nr;
635
636 auxtrace_index = auxtrace_index__last(head);
637 if (!auxtrace_index)
638 return -ENOMEM;
639
640 nr = auxtrace_index->nr;
641 auxtrace_index->entries[nr].file_offset = file_offset;
642 auxtrace_index->entries[nr].sz = event->header.size;
643 auxtrace_index->nr += 1;
644
645 return 0;
646 }
647
648 static int auxtrace_index__do_write(int fd,
649 struct auxtrace_index *auxtrace_index)
650 {
651 struct auxtrace_index_entry ent;
652 size_t i;
653
654 for (i = 0; i < auxtrace_index->nr; i++) {
655 ent.file_offset = auxtrace_index->entries[i].file_offset;
656 ent.sz = auxtrace_index->entries[i].sz;
657 if (writen(fd, &ent, sizeof(ent)) != sizeof(ent))
658 return -errno;
659 }
660 return 0;
661 }
662
663 int auxtrace_index__write(int fd, struct list_head *head)
664 {
665 struct auxtrace_index *auxtrace_index;
666 u64 total = 0;
667 int err;
668
669 list_for_each_entry(auxtrace_index, head, list)
670 total += auxtrace_index->nr;
671
672 if (writen(fd, &total, sizeof(total)) != sizeof(total))
673 return -errno;
674
675 list_for_each_entry(auxtrace_index, head, list) {
676 err = auxtrace_index__do_write(fd, auxtrace_index);
677 if (err)
678 return err;
679 }
680
681 return 0;
682 }
683
684 static int auxtrace_index__process_entry(int fd, struct list_head *head,
685 bool needs_swap)
686 {
687 struct auxtrace_index *auxtrace_index;
688 struct auxtrace_index_entry ent;
689 size_t nr;
690
691 if (readn(fd, &ent, sizeof(ent)) != sizeof(ent))
692 return -1;
693
694 auxtrace_index = auxtrace_index__last(head);
695 if (!auxtrace_index)
696 return -1;
697
698 nr = auxtrace_index->nr;
699 if (needs_swap) {
700 auxtrace_index->entries[nr].file_offset =
701 bswap_64(ent.file_offset);
702 auxtrace_index->entries[nr].sz = bswap_64(ent.sz);
703 } else {
704 auxtrace_index->entries[nr].file_offset = ent.file_offset;
705 auxtrace_index->entries[nr].sz = ent.sz;
706 }
707
708 auxtrace_index->nr = nr + 1;
709
710 return 0;
711 }
712
713 int auxtrace_index__process(int fd, u64 size, struct perf_session *session,
714 bool needs_swap)
715 {
716 struct list_head *head = &session->auxtrace_index;
717 u64 nr;
718
719 if (readn(fd, &nr, sizeof(u64)) != sizeof(u64))
720 return -1;
721
722 if (needs_swap)
723 nr = bswap_64(nr);
724
725 if (sizeof(u64) + nr * sizeof(struct auxtrace_index_entry) > size)
726 return -1;
727
728 while (nr--) {
729 int err;
730
731 err = auxtrace_index__process_entry(fd, head, needs_swap);
732 if (err)
733 return -1;
734 }
735
736 return 0;
737 }
738
739 static int auxtrace_queues__process_index_entry(struct auxtrace_queues *queues,
740 struct perf_session *session,
741 struct auxtrace_index_entry *ent)
742 {
743 return auxtrace_queues__add_indexed_event(queues, session,
744 ent->file_offset, ent->sz);
745 }
746
747 int auxtrace_queues__process_index(struct auxtrace_queues *queues,
748 struct perf_session *session)
749 {
750 struct auxtrace_index *auxtrace_index;
751 struct auxtrace_index_entry *ent;
752 size_t i;
753 int err;
754
755 list_for_each_entry(auxtrace_index, &session->auxtrace_index, list) {
756 for (i = 0; i < auxtrace_index->nr; i++) {
757 ent = &auxtrace_index->entries[i];
758 err = auxtrace_queues__process_index_entry(queues,
759 session,
760 ent);
761 if (err)
762 return err;
763 }
764 }
765 return 0;
766 }
767
768 struct auxtrace_buffer *auxtrace_buffer__next(struct auxtrace_queue *queue,
769 struct auxtrace_buffer *buffer)
770 {
771 if (buffer) {
772 if (list_is_last(&buffer->list, &queue->head))
773 return NULL;
774 return list_entry(buffer->list.next, struct auxtrace_buffer,
775 list);
776 } else {
777 if (list_empty(&queue->head))
778 return NULL;
779 return list_entry(queue->head.next, struct auxtrace_buffer,
780 list);
781 }
782 }
783
784 void *auxtrace_buffer__get_data(struct auxtrace_buffer *buffer, int fd)
785 {
786 size_t adj = buffer->data_offset & (page_size - 1);
787 size_t size = buffer->size + adj;
788 off_t file_offset = buffer->data_offset - adj;
789 void *addr;
790
791 if (buffer->data)
792 return buffer->data;
793
794 addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, file_offset);
795 if (addr == MAP_FAILED)
796 return NULL;
797
798 buffer->mmap_addr = addr;
799 buffer->mmap_size = size;
800
801 buffer->data = addr + adj;
802
803 return buffer->data;
804 }
805
806 void auxtrace_buffer__put_data(struct auxtrace_buffer *buffer)
807 {
808 if (!buffer->data || !buffer->mmap_addr)
809 return;
810 munmap(buffer->mmap_addr, buffer->mmap_size);
811 buffer->mmap_addr = NULL;
812 buffer->mmap_size = 0;
813 buffer->data = NULL;
814 buffer->use_data = NULL;
815 }
816
817 void auxtrace_buffer__drop_data(struct auxtrace_buffer *buffer)
818 {
819 auxtrace_buffer__put_data(buffer);
820 if (buffer->data_needs_freeing) {
821 buffer->data_needs_freeing = false;
822 zfree(&buffer->data);
823 buffer->use_data = NULL;
824 buffer->size = 0;
825 }
826 }
827
828 void auxtrace_buffer__free(struct auxtrace_buffer *buffer)
829 {
830 auxtrace_buffer__drop_data(buffer);
831 free(buffer);
832 }
833
834 void auxtrace_synth_error(struct auxtrace_error_event *auxtrace_error, int type,
835 int code, int cpu, pid_t pid, pid_t tid, u64 ip,
836 const char *msg)
837 {
838 size_t size;
839
840 memset(auxtrace_error, 0, sizeof(struct auxtrace_error_event));
841
842 auxtrace_error->header.type = PERF_RECORD_AUXTRACE_ERROR;
843 auxtrace_error->type = type;
844 auxtrace_error->code = code;
845 auxtrace_error->cpu = cpu;
846 auxtrace_error->pid = pid;
847 auxtrace_error->tid = tid;
848 auxtrace_error->ip = ip;
849 strlcpy(auxtrace_error->msg, msg, MAX_AUXTRACE_ERROR_MSG);
850
851 size = (void *)auxtrace_error->msg - (void *)auxtrace_error +
852 strlen(auxtrace_error->msg) + 1;
853 auxtrace_error->header.size = PERF_ALIGN(size, sizeof(u64));
854 }
855
856 int perf_event__synthesize_auxtrace_info(struct auxtrace_record *itr,
857 struct perf_tool *tool,
858 struct perf_session *session,
859 perf_event__handler_t process)
860 {
861 union perf_event *ev;
862 size_t priv_size;
863 int err;
864
865 pr_debug2("Synthesizing auxtrace information\n");
866 priv_size = auxtrace_record__info_priv_size(itr, session->evlist);
867 ev = zalloc(sizeof(struct auxtrace_info_event) + priv_size);
868 if (!ev)
869 return -ENOMEM;
870
871 ev->auxtrace_info.header.type = PERF_RECORD_AUXTRACE_INFO;
872 ev->auxtrace_info.header.size = sizeof(struct auxtrace_info_event) +
873 priv_size;
874 err = auxtrace_record__info_fill(itr, session, &ev->auxtrace_info,
875 priv_size);
876 if (err)
877 goto out_free;
878
879 err = process(tool, ev, NULL, NULL);
880 out_free:
881 free(ev);
882 return err;
883 }
884
885 static bool auxtrace__dont_decode(struct perf_session *session)
886 {
887 return !session->itrace_synth_opts ||
888 session->itrace_synth_opts->dont_decode;
889 }
890
891 int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused,
892 union perf_event *event,
893 struct perf_session *session)
894 {
895 enum auxtrace_type type = event->auxtrace_info.type;
896
897 if (dump_trace)
898 fprintf(stdout, " type: %u\n", type);
899
900 switch (type) {
901 case PERF_AUXTRACE_INTEL_PT:
902 return intel_pt_process_auxtrace_info(event, session);
903 case PERF_AUXTRACE_INTEL_BTS:
904 return intel_bts_process_auxtrace_info(event, session);
905 case PERF_AUXTRACE_CS_ETM:
906 case PERF_AUXTRACE_UNKNOWN:
907 default:
908 return -EINVAL;
909 }
910 }
911
912 s64 perf_event__process_auxtrace(struct perf_tool *tool,
913 union perf_event *event,
914 struct perf_session *session)
915 {
916 s64 err;
917
918 if (dump_trace)
919 fprintf(stdout, " size: %#"PRIx64" offset: %#"PRIx64" ref: %#"PRIx64" idx: %u tid: %d cpu: %d\n",
920 event->auxtrace.size, event->auxtrace.offset,
921 event->auxtrace.reference, event->auxtrace.idx,
922 event->auxtrace.tid, event->auxtrace.cpu);
923
924 if (auxtrace__dont_decode(session))
925 return event->auxtrace.size;
926
927 if (!session->auxtrace || event->header.type != PERF_RECORD_AUXTRACE)
928 return -EINVAL;
929
930 err = session->auxtrace->process_auxtrace_event(session, event, tool);
931 if (err < 0)
932 return err;
933
934 return event->auxtrace.size;
935 }
936
937 #define PERF_ITRACE_DEFAULT_PERIOD_TYPE PERF_ITRACE_PERIOD_NANOSECS
938 #define PERF_ITRACE_DEFAULT_PERIOD 100000
939 #define PERF_ITRACE_DEFAULT_CALLCHAIN_SZ 16
940 #define PERF_ITRACE_MAX_CALLCHAIN_SZ 1024
941 #define PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ 64
942 #define PERF_ITRACE_MAX_LAST_BRANCH_SZ 1024
943
944 void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts)
945 {
946 synth_opts->instructions = true;
947 synth_opts->branches = true;
948 synth_opts->transactions = true;
949 synth_opts->errors = true;
950 synth_opts->period_type = PERF_ITRACE_DEFAULT_PERIOD_TYPE;
951 synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
952 synth_opts->callchain_sz = PERF_ITRACE_DEFAULT_CALLCHAIN_SZ;
953 synth_opts->last_branch_sz = PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ;
954 synth_opts->initial_skip = 0;
955 }
956
957 /*
958 * Please check tools/perf/Documentation/perf-script.txt for information
959 * about the options parsed here, which is introduced after this cset,
960 * when support in 'perf script' for these options is introduced.
961 */
962 int itrace_parse_synth_opts(const struct option *opt, const char *str,
963 int unset)
964 {
965 struct itrace_synth_opts *synth_opts = opt->value;
966 const char *p;
967 char *endptr;
968 bool period_type_set = false;
969 bool period_set = false;
970
971 synth_opts->set = true;
972
973 if (unset) {
974 synth_opts->dont_decode = true;
975 return 0;
976 }
977
978 if (!str) {
979 itrace_synth_opts__set_default(synth_opts);
980 return 0;
981 }
982
983 for (p = str; *p;) {
984 switch (*p++) {
985 case 'i':
986 synth_opts->instructions = true;
987 while (*p == ' ' || *p == ',')
988 p += 1;
989 if (isdigit(*p)) {
990 synth_opts->period = strtoull(p, &endptr, 10);
991 period_set = true;
992 p = endptr;
993 while (*p == ' ' || *p == ',')
994 p += 1;
995 switch (*p++) {
996 case 'i':
997 synth_opts->period_type =
998 PERF_ITRACE_PERIOD_INSTRUCTIONS;
999 period_type_set = true;
1000 break;
1001 case 't':
1002 synth_opts->period_type =
1003 PERF_ITRACE_PERIOD_TICKS;
1004 period_type_set = true;
1005 break;
1006 case 'm':
1007 synth_opts->period *= 1000;
1008 /* Fall through */
1009 case 'u':
1010 synth_opts->period *= 1000;
1011 /* Fall through */
1012 case 'n':
1013 if (*p++ != 's')
1014 goto out_err;
1015 synth_opts->period_type =
1016 PERF_ITRACE_PERIOD_NANOSECS;
1017 period_type_set = true;
1018 break;
1019 case '\0':
1020 goto out;
1021 default:
1022 goto out_err;
1023 }
1024 }
1025 break;
1026 case 'b':
1027 synth_opts->branches = true;
1028 break;
1029 case 'x':
1030 synth_opts->transactions = true;
1031 break;
1032 case 'e':
1033 synth_opts->errors = true;
1034 break;
1035 case 'd':
1036 synth_opts->log = true;
1037 break;
1038 case 'c':
1039 synth_opts->branches = true;
1040 synth_opts->calls = true;
1041 break;
1042 case 'r':
1043 synth_opts->branches = true;
1044 synth_opts->returns = true;
1045 break;
1046 case 'g':
1047 synth_opts->callchain = true;
1048 synth_opts->callchain_sz =
1049 PERF_ITRACE_DEFAULT_CALLCHAIN_SZ;
1050 while (*p == ' ' || *p == ',')
1051 p += 1;
1052 if (isdigit(*p)) {
1053 unsigned int val;
1054
1055 val = strtoul(p, &endptr, 10);
1056 p = endptr;
1057 if (!val || val > PERF_ITRACE_MAX_CALLCHAIN_SZ)
1058 goto out_err;
1059 synth_opts->callchain_sz = val;
1060 }
1061 break;
1062 case 'l':
1063 synth_opts->last_branch = true;
1064 synth_opts->last_branch_sz =
1065 PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ;
1066 while (*p == ' ' || *p == ',')
1067 p += 1;
1068 if (isdigit(*p)) {
1069 unsigned int val;
1070
1071 val = strtoul(p, &endptr, 10);
1072 p = endptr;
1073 if (!val ||
1074 val > PERF_ITRACE_MAX_LAST_BRANCH_SZ)
1075 goto out_err;
1076 synth_opts->last_branch_sz = val;
1077 }
1078 break;
1079 case 's':
1080 synth_opts->initial_skip = strtoul(p, &endptr, 10);
1081 if (p == endptr)
1082 goto out_err;
1083 p = endptr;
1084 break;
1085 case ' ':
1086 case ',':
1087 break;
1088 default:
1089 goto out_err;
1090 }
1091 }
1092 out:
1093 if (synth_opts->instructions) {
1094 if (!period_type_set)
1095 synth_opts->period_type =
1096 PERF_ITRACE_DEFAULT_PERIOD_TYPE;
1097 if (!period_set)
1098 synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
1099 }
1100
1101 return 0;
1102
1103 out_err:
1104 pr_err("Bad Instruction Tracing options '%s'\n", str);
1105 return -EINVAL;
1106 }
1107
1108 static const char * const auxtrace_error_type_name[] = {
1109 [PERF_AUXTRACE_ERROR_ITRACE] = "instruction trace",
1110 };
1111
1112 static const char *auxtrace_error_name(int type)
1113 {
1114 const char *error_type_name = NULL;
1115
1116 if (type < PERF_AUXTRACE_ERROR_MAX)
1117 error_type_name = auxtrace_error_type_name[type];
1118 if (!error_type_name)
1119 error_type_name = "unknown AUX";
1120 return error_type_name;
1121 }
1122
1123 size_t perf_event__fprintf_auxtrace_error(union perf_event *event, FILE *fp)
1124 {
1125 struct auxtrace_error_event *e = &event->auxtrace_error;
1126 int ret;
1127
1128 ret = fprintf(fp, " %s error type %u",
1129 auxtrace_error_name(e->type), e->type);
1130 ret += fprintf(fp, " cpu %d pid %d tid %d ip %#"PRIx64" code %u: %s\n",
1131 e->cpu, e->pid, e->tid, e->ip, e->code, e->msg);
1132 return ret;
1133 }
1134
1135 void perf_session__auxtrace_error_inc(struct perf_session *session,
1136 union perf_event *event)
1137 {
1138 struct auxtrace_error_event *e = &event->auxtrace_error;
1139
1140 if (e->type < PERF_AUXTRACE_ERROR_MAX)
1141 session->evlist->stats.nr_auxtrace_errors[e->type] += 1;
1142 }
1143
1144 void events_stats__auxtrace_error_warn(const struct events_stats *stats)
1145 {
1146 int i;
1147
1148 for (i = 0; i < PERF_AUXTRACE_ERROR_MAX; i++) {
1149 if (!stats->nr_auxtrace_errors[i])
1150 continue;
1151 ui__warning("%u %s errors\n",
1152 stats->nr_auxtrace_errors[i],
1153 auxtrace_error_name(i));
1154 }
1155 }
1156
1157 int perf_event__process_auxtrace_error(struct perf_tool *tool __maybe_unused,
1158 union perf_event *event,
1159 struct perf_session *session)
1160 {
1161 if (auxtrace__dont_decode(session))
1162 return 0;
1163
1164 perf_event__fprintf_auxtrace_error(event, stdout);
1165 return 0;
1166 }
1167
1168 static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
1169 struct auxtrace_record *itr,
1170 struct perf_tool *tool, process_auxtrace_t fn,
1171 bool snapshot, size_t snapshot_size)
1172 {
1173 u64 head, old = mm->prev, offset, ref;
1174 unsigned char *data = mm->base;
1175 size_t size, head_off, old_off, len1, len2, padding;
1176 union perf_event ev;
1177 void *data1, *data2;
1178
1179 if (snapshot) {
1180 head = auxtrace_mmap__read_snapshot_head(mm);
1181 if (auxtrace_record__find_snapshot(itr, mm->idx, mm, data,
1182 &head, &old))
1183 return -1;
1184 } else {
1185 head = auxtrace_mmap__read_head(mm);
1186 }
1187
1188 if (old == head)
1189 return 0;
1190
1191 pr_debug3("auxtrace idx %d old %#"PRIx64" head %#"PRIx64" diff %#"PRIx64"\n",
1192 mm->idx, old, head, head - old);
1193
1194 if (mm->mask) {
1195 head_off = head & mm->mask;
1196 old_off = old & mm->mask;
1197 } else {
1198 head_off = head % mm->len;
1199 old_off = old % mm->len;
1200 }
1201
1202 if (head_off > old_off)
1203 size = head_off - old_off;
1204 else
1205 size = mm->len - (old_off - head_off);
1206
1207 if (snapshot && size > snapshot_size)
1208 size = snapshot_size;
1209
1210 ref = auxtrace_record__reference(itr);
1211
1212 if (head > old || size <= head || mm->mask) {
1213 offset = head - size;
1214 } else {
1215 /*
1216 * When the buffer size is not a power of 2, 'head' wraps at the
1217 * highest multiple of the buffer size, so we have to subtract
1218 * the remainder here.
1219 */
1220 u64 rem = (0ULL - mm->len) % mm->len;
1221
1222 offset = head - size - rem;
1223 }
1224
1225 if (size > head_off) {
1226 len1 = size - head_off;
1227 data1 = &data[mm->len - len1];
1228 len2 = head_off;
1229 data2 = &data[0];
1230 } else {
1231 len1 = size;
1232 data1 = &data[head_off - len1];
1233 len2 = 0;
1234 data2 = NULL;
1235 }
1236
1237 if (itr->alignment) {
1238 unsigned int unwanted = len1 % itr->alignment;
1239
1240 len1 -= unwanted;
1241 size -= unwanted;
1242 }
1243
1244 /* padding must be written by fn() e.g. record__process_auxtrace() */
1245 padding = size & 7;
1246 if (padding)
1247 padding = 8 - padding;
1248
1249 memset(&ev, 0, sizeof(ev));
1250 ev.auxtrace.header.type = PERF_RECORD_AUXTRACE;
1251 ev.auxtrace.header.size = sizeof(ev.auxtrace);
1252 ev.auxtrace.size = size + padding;
1253 ev.auxtrace.offset = offset;
1254 ev.auxtrace.reference = ref;
1255 ev.auxtrace.idx = mm->idx;
1256 ev.auxtrace.tid = mm->tid;
1257 ev.auxtrace.cpu = mm->cpu;
1258
1259 if (fn(tool, &ev, data1, len1, data2, len2))
1260 return -1;
1261
1262 mm->prev = head;
1263
1264 if (!snapshot) {
1265 auxtrace_mmap__write_tail(mm, head);
1266 if (itr->read_finish) {
1267 int err;
1268
1269 err = itr->read_finish(itr, mm->idx);
1270 if (err < 0)
1271 return err;
1272 }
1273 }
1274
1275 return 1;
1276 }
1277
1278 int auxtrace_mmap__read(struct auxtrace_mmap *mm, struct auxtrace_record *itr,
1279 struct perf_tool *tool, process_auxtrace_t fn)
1280 {
1281 return __auxtrace_mmap__read(mm, itr, tool, fn, false, 0);
1282 }
1283
1284 int auxtrace_mmap__read_snapshot(struct auxtrace_mmap *mm,
1285 struct auxtrace_record *itr,
1286 struct perf_tool *tool, process_auxtrace_t fn,
1287 size_t snapshot_size)
1288 {
1289 return __auxtrace_mmap__read(mm, itr, tool, fn, true, snapshot_size);
1290 }
1291
1292 /**
1293 * struct auxtrace_cache - hash table to implement a cache
1294 * @hashtable: the hashtable
1295 * @sz: hashtable size (number of hlists)
1296 * @entry_size: size of an entry
1297 * @limit: limit the number of entries to this maximum, when reached the cache
1298 * is dropped and caching begins again with an empty cache
1299 * @cnt: current number of entries
1300 * @bits: hashtable size (@sz = 2^@bits)
1301 */
1302 struct auxtrace_cache {
1303 struct hlist_head *hashtable;
1304 size_t sz;
1305 size_t entry_size;
1306 size_t limit;
1307 size_t cnt;
1308 unsigned int bits;
1309 };
1310
1311 struct auxtrace_cache *auxtrace_cache__new(unsigned int bits, size_t entry_size,
1312 unsigned int limit_percent)
1313 {
1314 struct auxtrace_cache *c;
1315 struct hlist_head *ht;
1316 size_t sz, i;
1317
1318 c = zalloc(sizeof(struct auxtrace_cache));
1319 if (!c)
1320 return NULL;
1321
1322 sz = 1UL << bits;
1323
1324 ht = calloc(sz, sizeof(struct hlist_head));
1325 if (!ht)
1326 goto out_free;
1327
1328 for (i = 0; i < sz; i++)
1329 INIT_HLIST_HEAD(&ht[i]);
1330
1331 c->hashtable = ht;
1332 c->sz = sz;
1333 c->entry_size = entry_size;
1334 c->limit = (c->sz * limit_percent) / 100;
1335 c->bits = bits;
1336
1337 return c;
1338
1339 out_free:
1340 free(c);
1341 return NULL;
1342 }
1343
1344 static void auxtrace_cache__drop(struct auxtrace_cache *c)
1345 {
1346 struct auxtrace_cache_entry *entry;
1347 struct hlist_node *tmp;
1348 size_t i;
1349
1350 if (!c)
1351 return;
1352
1353 for (i = 0; i < c->sz; i++) {
1354 hlist_for_each_entry_safe(entry, tmp, &c->hashtable[i], hash) {
1355 hlist_del(&entry->hash);
1356 auxtrace_cache__free_entry(c, entry);
1357 }
1358 }
1359
1360 c->cnt = 0;
1361 }
1362
1363 void auxtrace_cache__free(struct auxtrace_cache *c)
1364 {
1365 if (!c)
1366 return;
1367
1368 auxtrace_cache__drop(c);
1369 free(c->hashtable);
1370 free(c);
1371 }
1372
1373 void *auxtrace_cache__alloc_entry(struct auxtrace_cache *c)
1374 {
1375 return malloc(c->entry_size);
1376 }
1377
1378 void auxtrace_cache__free_entry(struct auxtrace_cache *c __maybe_unused,
1379 void *entry)
1380 {
1381 free(entry);
1382 }
1383
1384 int auxtrace_cache__add(struct auxtrace_cache *c, u32 key,
1385 struct auxtrace_cache_entry *entry)
1386 {
1387 if (c->limit && ++c->cnt > c->limit)
1388 auxtrace_cache__drop(c);
1389
1390 entry->key = key;
1391 hlist_add_head(&entry->hash, &c->hashtable[hash_32(key, c->bits)]);
1392
1393 return 0;
1394 }
1395
1396 void *auxtrace_cache__lookup(struct auxtrace_cache *c, u32 key)
1397 {
1398 struct auxtrace_cache_entry *entry;
1399 struct hlist_head *hlist;
1400
1401 if (!c)
1402 return NULL;
1403
1404 hlist = &c->hashtable[hash_32(key, c->bits)];
1405 hlist_for_each_entry(entry, hlist, hash) {
1406 if (entry->key == key)
1407 return entry;
1408 }
1409
1410 return NULL;
1411 }
1412
1413 static void addr_filter__free_str(struct addr_filter *filt)
1414 {
1415 free(filt->str);
1416 filt->action = NULL;
1417 filt->sym_from = NULL;
1418 filt->sym_to = NULL;
1419 filt->filename = NULL;
1420 filt->str = NULL;
1421 }
1422
1423 static struct addr_filter *addr_filter__new(void)
1424 {
1425 struct addr_filter *filt = zalloc(sizeof(*filt));
1426
1427 if (filt)
1428 INIT_LIST_HEAD(&filt->list);
1429
1430 return filt;
1431 }
1432
1433 static void addr_filter__free(struct addr_filter *filt)
1434 {
1435 if (filt)
1436 addr_filter__free_str(filt);
1437 free(filt);
1438 }
1439
1440 static void addr_filters__add(struct addr_filters *filts,
1441 struct addr_filter *filt)
1442 {
1443 list_add_tail(&filt->list, &filts->head);
1444 filts->cnt += 1;
1445 }
1446
1447 static void addr_filters__del(struct addr_filters *filts,
1448 struct addr_filter *filt)
1449 {
1450 list_del_init(&filt->list);
1451 filts->cnt -= 1;
1452 }
1453
1454 void addr_filters__init(struct addr_filters *filts)
1455 {
1456 INIT_LIST_HEAD(&filts->head);
1457 filts->cnt = 0;
1458 }
1459
1460 void addr_filters__exit(struct addr_filters *filts)
1461 {
1462 struct addr_filter *filt, *n;
1463
1464 list_for_each_entry_safe(filt, n, &filts->head, list) {
1465 addr_filters__del(filts, filt);
1466 addr_filter__free(filt);
1467 }
1468 }
1469
1470 static int parse_num_or_str(char **inp, u64 *num, const char **str,
1471 const char *str_delim)
1472 {
1473 *inp += strspn(*inp, " ");
1474
1475 if (isdigit(**inp)) {
1476 char *endptr;
1477
1478 if (!num)
1479 return -EINVAL;
1480 errno = 0;
1481 *num = strtoull(*inp, &endptr, 0);
1482 if (errno)
1483 return -errno;
1484 if (endptr == *inp)
1485 return -EINVAL;
1486 *inp = endptr;
1487 } else {
1488 size_t n;
1489
1490 if (!str)
1491 return -EINVAL;
1492 *inp += strspn(*inp, " ");
1493 *str = *inp;
1494 n = strcspn(*inp, str_delim);
1495 if (!n)
1496 return -EINVAL;
1497 *inp += n;
1498 if (**inp) {
1499 **inp = '\0';
1500 *inp += 1;
1501 }
1502 }
1503 return 0;
1504 }
1505
1506 static int parse_action(struct addr_filter *filt)
1507 {
1508 if (!strcmp(filt->action, "filter")) {
1509 filt->start = true;
1510 filt->range = true;
1511 } else if (!strcmp(filt->action, "start")) {
1512 filt->start = true;
1513 } else if (!strcmp(filt->action, "stop")) {
1514 filt->start = false;
1515 } else if (!strcmp(filt->action, "tracestop")) {
1516 filt->start = false;
1517 filt->range = true;
1518 filt->action += 5; /* Change 'tracestop' to 'stop' */
1519 } else {
1520 return -EINVAL;
1521 }
1522 return 0;
1523 }
1524
1525 static int parse_sym_idx(char **inp, int *idx)
1526 {
1527 *idx = -1;
1528
1529 *inp += strspn(*inp, " ");
1530
1531 if (**inp != '#')
1532 return 0;
1533
1534 *inp += 1;
1535
1536 if (**inp == 'g' || **inp == 'G') {
1537 *inp += 1;
1538 *idx = 0;
1539 } else {
1540 unsigned long num;
1541 char *endptr;
1542
1543 errno = 0;
1544 num = strtoul(*inp, &endptr, 0);
1545 if (errno)
1546 return -errno;
1547 if (endptr == *inp || num > INT_MAX)
1548 return -EINVAL;
1549 *inp = endptr;
1550 *idx = num;
1551 }
1552
1553 return 0;
1554 }
1555
1556 static int parse_addr_size(char **inp, u64 *num, const char **str, int *idx)
1557 {
1558 int err = parse_num_or_str(inp, num, str, " ");
1559
1560 if (!err && *str)
1561 err = parse_sym_idx(inp, idx);
1562
1563 return err;
1564 }
1565
1566 static int parse_one_filter(struct addr_filter *filt, const char **filter_inp)
1567 {
1568 char *fstr;
1569 int err;
1570
1571 filt->str = fstr = strdup(*filter_inp);
1572 if (!fstr)
1573 return -ENOMEM;
1574
1575 err = parse_num_or_str(&fstr, NULL, &filt->action, " ");
1576 if (err)
1577 goto out_err;
1578
1579 err = parse_action(filt);
1580 if (err)
1581 goto out_err;
1582
1583 err = parse_addr_size(&fstr, &filt->addr, &filt->sym_from,
1584 &filt->sym_from_idx);
1585 if (err)
1586 goto out_err;
1587
1588 fstr += strspn(fstr, " ");
1589
1590 if (*fstr == '/') {
1591 fstr += 1;
1592 err = parse_addr_size(&fstr, &filt->size, &filt->sym_to,
1593 &filt->sym_to_idx);
1594 if (err)
1595 goto out_err;
1596 filt->range = true;
1597 }
1598
1599 fstr += strspn(fstr, " ");
1600
1601 if (*fstr == '@') {
1602 fstr += 1;
1603 err = parse_num_or_str(&fstr, NULL, &filt->filename, " ,");
1604 if (err)
1605 goto out_err;
1606 }
1607
1608 fstr += strspn(fstr, " ,");
1609
1610 *filter_inp += fstr - filt->str;
1611
1612 return 0;
1613
1614 out_err:
1615 addr_filter__free_str(filt);
1616
1617 return err;
1618 }
1619
1620 int addr_filters__parse_bare_filter(struct addr_filters *filts,
1621 const char *filter)
1622 {
1623 struct addr_filter *filt;
1624 const char *fstr = filter;
1625 int err;
1626
1627 while (*fstr) {
1628 filt = addr_filter__new();
1629 err = parse_one_filter(filt, &fstr);
1630 if (err) {
1631 addr_filter__free(filt);
1632 addr_filters__exit(filts);
1633 return err;
1634 }
1635 addr_filters__add(filts, filt);
1636 }
1637
1638 return 0;
1639 }
1640
1641 struct sym_args {
1642 const char *name;
1643 u64 start;
1644 u64 size;
1645 int idx;
1646 int cnt;
1647 bool started;
1648 bool global;
1649 bool selected;
1650 bool duplicate;
1651 bool near;
1652 };
1653
1654 static bool kern_sym_match(struct sym_args *args, const char *name, char type)
1655 {
1656 /* A function with the same name, and global or the n'th found or any */
1657 return symbol_type__is_a(type, MAP__FUNCTION) &&
1658 !strcmp(name, args->name) &&
1659 ((args->global && isupper(type)) ||
1660 (args->selected && ++(args->cnt) == args->idx) ||
1661 (!args->global && !args->selected));
1662 }
1663
1664 static int find_kern_sym_cb(void *arg, const char *name, char type, u64 start)
1665 {
1666 struct sym_args *args = arg;
1667
1668 if (args->started) {
1669 if (!args->size)
1670 args->size = start - args->start;
1671 if (args->selected) {
1672 if (args->size)
1673 return 1;
1674 } else if (kern_sym_match(args, name, type)) {
1675 args->duplicate = true;
1676 return 1;
1677 }
1678 } else if (kern_sym_match(args, name, type)) {
1679 args->started = true;
1680 args->start = start;
1681 }
1682
1683 return 0;
1684 }
1685
1686 static int print_kern_sym_cb(void *arg, const char *name, char type, u64 start)
1687 {
1688 struct sym_args *args = arg;
1689
1690 if (kern_sym_match(args, name, type)) {
1691 pr_err("#%d\t0x%"PRIx64"\t%c\t%s\n",
1692 ++args->cnt, start, type, name);
1693 args->near = true;
1694 } else if (args->near) {
1695 args->near = false;
1696 pr_err("\t\twhich is near\t\t%s\n", name);
1697 }
1698
1699 return 0;
1700 }
1701
1702 static int sym_not_found_error(const char *sym_name, int idx)
1703 {
1704 if (idx > 0) {
1705 pr_err("N'th occurrence (N=%d) of symbol '%s' not found.\n",
1706 idx, sym_name);
1707 } else if (!idx) {
1708 pr_err("Global symbol '%s' not found.\n", sym_name);
1709 } else {
1710 pr_err("Symbol '%s' not found.\n", sym_name);
1711 }
1712 pr_err("Note that symbols must be functions.\n");
1713
1714 return -EINVAL;
1715 }
1716
1717 static int find_kern_sym(const char *sym_name, u64 *start, u64 *size, int idx)
1718 {
1719 struct sym_args args = {
1720 .name = sym_name,
1721 .idx = idx,
1722 .global = !idx,
1723 .selected = idx > 0,
1724 };
1725 int err;
1726
1727 *start = 0;
1728 *size = 0;
1729
1730 err = kallsyms__parse("/proc/kallsyms", &args, find_kern_sym_cb);
1731 if (err < 0) {
1732 pr_err("Failed to parse /proc/kallsyms\n");
1733 return err;
1734 }
1735
1736 if (args.duplicate) {
1737 pr_err("Multiple kernel symbols with name '%s'\n", sym_name);
1738 args.cnt = 0;
1739 kallsyms__parse("/proc/kallsyms", &args, print_kern_sym_cb);
1740 pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
1741 sym_name);
1742 pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
1743 return -EINVAL;
1744 }
1745
1746 if (!args.started) {
1747 pr_err("Kernel symbol lookup: ");
1748 return sym_not_found_error(sym_name, idx);
1749 }
1750
1751 *start = args.start;
1752 *size = args.size;
1753
1754 return 0;
1755 }
1756
1757 static int find_entire_kern_cb(void *arg, const char *name __maybe_unused,
1758 char type, u64 start)
1759 {
1760 struct sym_args *args = arg;
1761
1762 if (!symbol_type__is_a(type, MAP__FUNCTION))
1763 return 0;
1764
1765 if (!args->started) {
1766 args->started = true;
1767 args->start = start;
1768 }
1769 /* Don't know exactly where the kernel ends, so we add a page */
1770 args->size = round_up(start, page_size) + page_size - args->start;
1771
1772 return 0;
1773 }
1774
1775 static int addr_filter__entire_kernel(struct addr_filter *filt)
1776 {
1777 struct sym_args args = { .started = false };
1778 int err;
1779
1780 err = kallsyms__parse("/proc/kallsyms", &args, find_entire_kern_cb);
1781 if (err < 0 || !args.started) {
1782 pr_err("Failed to parse /proc/kallsyms\n");
1783 return err;
1784 }
1785
1786 filt->addr = args.start;
1787 filt->size = args.size;
1788
1789 return 0;
1790 }
1791
1792 static int check_end_after_start(struct addr_filter *filt, u64 start, u64 size)
1793 {
1794 if (start + size >= filt->addr)
1795 return 0;
1796
1797 if (filt->sym_from) {
1798 pr_err("Symbol '%s' (0x%"PRIx64") comes before '%s' (0x%"PRIx64")\n",
1799 filt->sym_to, start, filt->sym_from, filt->addr);
1800 } else {
1801 pr_err("Symbol '%s' (0x%"PRIx64") comes before address 0x%"PRIx64")\n",
1802 filt->sym_to, start, filt->addr);
1803 }
1804
1805 return -EINVAL;
1806 }
1807
1808 static int addr_filter__resolve_kernel_syms(struct addr_filter *filt)
1809 {
1810 bool no_size = false;
1811 u64 start, size;
1812 int err;
1813
1814 if (symbol_conf.kptr_restrict) {
1815 pr_err("Kernel addresses are restricted. Unable to resolve kernel symbols.\n");
1816 return -EINVAL;
1817 }
1818
1819 if (filt->sym_from && !strcmp(filt->sym_from, "*"))
1820 return addr_filter__entire_kernel(filt);
1821
1822 if (filt->sym_from) {
1823 err = find_kern_sym(filt->sym_from, &start, &size,
1824 filt->sym_from_idx);
1825 if (err)
1826 return err;
1827 filt->addr = start;
1828 if (filt->range && !filt->size && !filt->sym_to) {
1829 filt->size = size;
1830 no_size = !size;
1831 }
1832 }
1833
1834 if (filt->sym_to) {
1835 err = find_kern_sym(filt->sym_to, &start, &size,
1836 filt->sym_to_idx);
1837 if (err)
1838 return err;
1839
1840 err = check_end_after_start(filt, start, size);
1841 if (err)
1842 return err;
1843 filt->size = start + size - filt->addr;
1844 no_size = !size;
1845 }
1846
1847 /* The very last symbol in kallsyms does not imply a particular size */
1848 if (no_size) {
1849 pr_err("Cannot determine size of symbol '%s'\n",
1850 filt->sym_to ? filt->sym_to : filt->sym_from);
1851 return -EINVAL;
1852 }
1853
1854 return 0;
1855 }
1856
1857 static struct dso *load_dso(const char *name)
1858 {
1859 struct map *map;
1860 struct dso *dso;
1861
1862 map = dso__new_map(name);
1863 if (!map)
1864 return NULL;
1865
1866 map__load(map);
1867
1868 dso = dso__get(map->dso);
1869
1870 map__put(map);
1871
1872 return dso;
1873 }
1874
1875 static bool dso_sym_match(struct symbol *sym, const char *name, int *cnt,
1876 int idx)
1877 {
1878 /* Same name, and global or the n'th found or any */
1879 return !arch__compare_symbol_names(name, sym->name) &&
1880 ((!idx && sym->binding == STB_GLOBAL) ||
1881 (idx > 0 && ++*cnt == idx) ||
1882 idx < 0);
1883 }
1884
1885 static void print_duplicate_syms(struct dso *dso, const char *sym_name)
1886 {
1887 struct symbol *sym;
1888 bool near = false;
1889 int cnt = 0;
1890
1891 pr_err("Multiple symbols with name '%s'\n", sym_name);
1892
1893 sym = dso__first_symbol(dso, MAP__FUNCTION);
1894 while (sym) {
1895 if (dso_sym_match(sym, sym_name, &cnt, -1)) {
1896 pr_err("#%d\t0x%"PRIx64"\t%c\t%s\n",
1897 ++cnt, sym->start,
1898 sym->binding == STB_GLOBAL ? 'g' :
1899 sym->binding == STB_LOCAL ? 'l' : 'w',
1900 sym->name);
1901 near = true;
1902 } else if (near) {
1903 near = false;
1904 pr_err("\t\twhich is near\t\t%s\n", sym->name);
1905 }
1906 sym = dso__next_symbol(sym);
1907 }
1908
1909 pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
1910 sym_name);
1911 pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
1912 }
1913
1914 static int find_dso_sym(struct dso *dso, const char *sym_name, u64 *start,
1915 u64 *size, int idx)
1916 {
1917 struct symbol *sym;
1918 int cnt = 0;
1919
1920 *start = 0;
1921 *size = 0;
1922
1923 sym = dso__first_symbol(dso, MAP__FUNCTION);
1924 while (sym) {
1925 if (*start) {
1926 if (!*size)
1927 *size = sym->start - *start;
1928 if (idx > 0) {
1929 if (*size)
1930 return 1;
1931 } else if (dso_sym_match(sym, sym_name, &cnt, idx)) {
1932 print_duplicate_syms(dso, sym_name);
1933 return -EINVAL;
1934 }
1935 } else if (dso_sym_match(sym, sym_name, &cnt, idx)) {
1936 *start = sym->start;
1937 *size = sym->end - sym->start;
1938 }
1939 sym = dso__next_symbol(sym);
1940 }
1941
1942 if (!*start)
1943 return sym_not_found_error(sym_name, idx);
1944
1945 return 0;
1946 }
1947
1948 static int addr_filter__entire_dso(struct addr_filter *filt, struct dso *dso)
1949 {
1950 struct symbol *first_sym = dso__first_symbol(dso, MAP__FUNCTION);
1951 struct symbol *last_sym = dso__last_symbol(dso, MAP__FUNCTION);
1952
1953 if (!first_sym || !last_sym) {
1954 pr_err("Failed to determine filter for %s\nNo symbols found.\n",
1955 filt->filename);
1956 return -EINVAL;
1957 }
1958
1959 filt->addr = first_sym->start;
1960 filt->size = last_sym->end - first_sym->start;
1961
1962 return 0;
1963 }
1964
1965 static int addr_filter__resolve_syms(struct addr_filter *filt)
1966 {
1967 u64 start, size;
1968 struct dso *dso;
1969 int err = 0;
1970
1971 if (!filt->sym_from && !filt->sym_to)
1972 return 0;
1973
1974 if (!filt->filename)
1975 return addr_filter__resolve_kernel_syms(filt);
1976
1977 dso = load_dso(filt->filename);
1978 if (!dso) {
1979 pr_err("Failed to load symbols from: %s\n", filt->filename);
1980 return -EINVAL;
1981 }
1982
1983 if (filt->sym_from && !strcmp(filt->sym_from, "*")) {
1984 err = addr_filter__entire_dso(filt, dso);
1985 goto put_dso;
1986 }
1987
1988 if (filt->sym_from) {
1989 err = find_dso_sym(dso, filt->sym_from, &start, &size,
1990 filt->sym_from_idx);
1991 if (err)
1992 goto put_dso;
1993 filt->addr = start;
1994 if (filt->range && !filt->size && !filt->sym_to)
1995 filt->size = size;
1996 }
1997
1998 if (filt->sym_to) {
1999 err = find_dso_sym(dso, filt->sym_to, &start, &size,
2000 filt->sym_to_idx);
2001 if (err)
2002 goto put_dso;
2003
2004 err = check_end_after_start(filt, start, size);
2005 if (err)
2006 return err;
2007
2008 filt->size = start + size - filt->addr;
2009 }
2010
2011 put_dso:
2012 dso__put(dso);
2013
2014 return err;
2015 }
2016
2017 static char *addr_filter__to_str(struct addr_filter *filt)
2018 {
2019 char filename_buf[PATH_MAX];
2020 const char *at = "";
2021 const char *fn = "";
2022 char *filter;
2023 int err;
2024
2025 if (filt->filename) {
2026 at = "@";
2027 fn = realpath(filt->filename, filename_buf);
2028 if (!fn)
2029 return NULL;
2030 }
2031
2032 if (filt->range) {
2033 err = asprintf(&filter, "%s 0x%"PRIx64"/0x%"PRIx64"%s%s",
2034 filt->action, filt->addr, filt->size, at, fn);
2035 } else {
2036 err = asprintf(&filter, "%s 0x%"PRIx64"%s%s",
2037 filt->action, filt->addr, at, fn);
2038 }
2039
2040 return err < 0 ? NULL : filter;
2041 }
2042
2043 static int parse_addr_filter(struct perf_evsel *evsel, const char *filter,
2044 int max_nr)
2045 {
2046 struct addr_filters filts;
2047 struct addr_filter *filt;
2048 int err;
2049
2050 addr_filters__init(&filts);
2051
2052 err = addr_filters__parse_bare_filter(&filts, filter);
2053 if (err)
2054 goto out_exit;
2055
2056 if (filts.cnt > max_nr) {
2057 pr_err("Error: number of address filters (%d) exceeds maximum (%d)\n",
2058 filts.cnt, max_nr);
2059 err = -EINVAL;
2060 goto out_exit;
2061 }
2062
2063 list_for_each_entry(filt, &filts.head, list) {
2064 char *new_filter;
2065
2066 err = addr_filter__resolve_syms(filt);
2067 if (err)
2068 goto out_exit;
2069
2070 new_filter = addr_filter__to_str(filt);
2071 if (!new_filter) {
2072 err = -ENOMEM;
2073 goto out_exit;
2074 }
2075
2076 if (perf_evsel__append_addr_filter(evsel, new_filter)) {
2077 err = -ENOMEM;
2078 goto out_exit;
2079 }
2080 }
2081
2082 out_exit:
2083 addr_filters__exit(&filts);
2084
2085 if (err) {
2086 pr_err("Failed to parse address filter: '%s'\n", filter);
2087 pr_err("Filter format is: filter|start|stop|tracestop <start symbol or address> [/ <end symbol or size>] [@<file name>]\n");
2088 pr_err("Where multiple filters are separated by space or comma.\n");
2089 }
2090
2091 return err;
2092 }
2093
2094 static struct perf_pmu *perf_evsel__find_pmu(struct perf_evsel *evsel)
2095 {
2096 struct perf_pmu *pmu = NULL;
2097
2098 while ((pmu = perf_pmu__scan(pmu)) != NULL) {
2099 if (pmu->type == evsel->attr.type)
2100 break;
2101 }
2102
2103 return pmu;
2104 }
2105
2106 static int perf_evsel__nr_addr_filter(struct perf_evsel *evsel)
2107 {
2108 struct perf_pmu *pmu = perf_evsel__find_pmu(evsel);
2109 int nr_addr_filters = 0;
2110
2111 if (!pmu)
2112 return 0;
2113
2114 perf_pmu__scan_file(pmu, "nr_addr_filters", "%d", &nr_addr_filters);
2115
2116 return nr_addr_filters;
2117 }
2118
2119 int auxtrace_parse_filters(struct perf_evlist *evlist)
2120 {
2121 struct perf_evsel *evsel;
2122 char *filter;
2123 int err, max_nr;
2124
2125 evlist__for_each_entry(evlist, evsel) {
2126 filter = evsel->filter;
2127 max_nr = perf_evsel__nr_addr_filter(evsel);
2128 if (!filter || !max_nr)
2129 continue;
2130 evsel->filter = NULL;
2131 err = parse_addr_filter(evsel, filter, max_nr);
2132 free(filter);
2133 if (err)
2134 return err;
2135 pr_debug("Address filter: %s\n", evsel->filter);
2136 }
2137
2138 return 0;
2139 }
Ubuntu Focal Linux kernel mirror