2 * auxtrace.c: AUX area trace support
3 * Copyright (c) 2013-2015, Intel Corporation.
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.
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
17 #include <sys/types.h>
24 #include <linux/kernel.h>
25 #include <linux/perf_event.h>
26 #include <linux/types.h>
27 #include <linux/bitops.h>
28 #include <linux/log2.h>
29 #include <linux/string.h>
31 #include <sys/param.h>
37 #include <linux/list.h>
47 #include "thread_map.h"
51 #include <linux/hash.h>
56 #include <subcmd/parse-options.h>
59 #include "intel-bts.h"
61 #include "sane_ctype.h"
62 #include "symbol/kallsyms.h"
64 int auxtrace_mmap__mmap(struct auxtrace_mmap
*mm
,
65 struct auxtrace_mmap_params
*mp
,
68 struct perf_event_mmap_page
*pc
= userpg
;
70 WARN_ONCE(mm
->base
, "Uninitialized auxtrace_mmap\n");
85 #if BITS_PER_LONG != 64 && !defined(HAVE_SYNC_COMPARE_AND_SWAP_SUPPORT)
86 pr_err("Cannot use AUX area tracing mmaps\n");
90 pc
->aux_offset
= mp
->offset
;
91 pc
->aux_size
= mp
->len
;
93 mm
->base
= mmap(NULL
, mp
->len
, mp
->prot
, MAP_SHARED
, fd
, mp
->offset
);
94 if (mm
->base
== MAP_FAILED
) {
95 pr_debug2("failed to mmap AUX area\n");
103 void auxtrace_mmap__munmap(struct auxtrace_mmap
*mm
)
106 munmap(mm
->base
, mm
->len
);
111 void auxtrace_mmap_params__init(struct auxtrace_mmap_params
*mp
,
112 off_t auxtrace_offset
,
113 unsigned int auxtrace_pages
,
114 bool auxtrace_overwrite
)
116 if (auxtrace_pages
) {
117 mp
->offset
= auxtrace_offset
;
118 mp
->len
= auxtrace_pages
* (size_t)page_size
;
119 mp
->mask
= is_power_of_2(mp
->len
) ? mp
->len
- 1 : 0;
120 mp
->prot
= PROT_READ
| (auxtrace_overwrite
? 0 : PROT_WRITE
);
121 pr_debug2("AUX area mmap length %zu\n", mp
->len
);
127 void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params
*mp
,
128 struct perf_evlist
*evlist
, int idx
,
134 mp
->cpu
= evlist
->cpus
->map
[idx
];
136 mp
->tid
= thread_map__pid(evlist
->threads
, 0);
141 mp
->tid
= thread_map__pid(evlist
->threads
, idx
);
145 #define AUXTRACE_INIT_NR_QUEUES 32
147 static struct auxtrace_queue
*auxtrace_alloc_queue_array(unsigned int nr_queues
)
149 struct auxtrace_queue
*queue_array
;
150 unsigned int max_nr_queues
, i
;
152 max_nr_queues
= UINT_MAX
/ sizeof(struct auxtrace_queue
);
153 if (nr_queues
> max_nr_queues
)
156 queue_array
= calloc(nr_queues
, sizeof(struct auxtrace_queue
));
160 for (i
= 0; i
< nr_queues
; i
++) {
161 INIT_LIST_HEAD(&queue_array
[i
].head
);
162 queue_array
[i
].priv
= NULL
;
168 int auxtrace_queues__init(struct auxtrace_queues
*queues
)
170 queues
->nr_queues
= AUXTRACE_INIT_NR_QUEUES
;
171 queues
->queue_array
= auxtrace_alloc_queue_array(queues
->nr_queues
);
172 if (!queues
->queue_array
)
177 static int auxtrace_queues__grow(struct auxtrace_queues
*queues
,
178 unsigned int new_nr_queues
)
180 unsigned int nr_queues
= queues
->nr_queues
;
181 struct auxtrace_queue
*queue_array
;
185 nr_queues
= AUXTRACE_INIT_NR_QUEUES
;
187 while (nr_queues
&& nr_queues
< new_nr_queues
)
190 if (nr_queues
< queues
->nr_queues
|| nr_queues
< new_nr_queues
)
193 queue_array
= auxtrace_alloc_queue_array(nr_queues
);
197 for (i
= 0; i
< queues
->nr_queues
; i
++) {
198 list_splice_tail(&queues
->queue_array
[i
].head
,
199 &queue_array
[i
].head
);
200 queue_array
[i
].priv
= queues
->queue_array
[i
].priv
;
203 queues
->nr_queues
= nr_queues
;
204 queues
->queue_array
= queue_array
;
209 static void *auxtrace_copy_data(u64 size
, struct perf_session
*session
)
211 int fd
= perf_data_file__fd(session
->file
);
215 if (size
> SSIZE_MAX
)
222 ret
= readn(fd
, p
, size
);
223 if (ret
!= (ssize_t
)size
) {
231 static int auxtrace_queues__add_buffer(struct auxtrace_queues
*queues
,
233 struct auxtrace_buffer
*buffer
)
235 struct auxtrace_queue
*queue
;
238 if (idx
>= queues
->nr_queues
) {
239 err
= auxtrace_queues__grow(queues
, idx
+ 1);
244 queue
= &queues
->queue_array
[idx
];
248 queue
->tid
= buffer
->tid
;
249 queue
->cpu
= buffer
->cpu
;
250 } else if (buffer
->cpu
!= queue
->cpu
|| buffer
->tid
!= queue
->tid
) {
251 pr_err("auxtrace queue conflict: cpu %d, tid %d vs cpu %d, tid %d\n",
252 queue
->cpu
, queue
->tid
, buffer
->cpu
, buffer
->tid
);
256 buffer
->buffer_nr
= queues
->next_buffer_nr
++;
258 list_add_tail(&buffer
->list
, &queue
->head
);
260 queues
->new_data
= true;
261 queues
->populated
= true;
266 /* Limit buffers to 32MiB on 32-bit */
267 #define BUFFER_LIMIT_FOR_32_BIT (32 * 1024 * 1024)
269 static int auxtrace_queues__split_buffer(struct auxtrace_queues
*queues
,
271 struct auxtrace_buffer
*buffer
)
273 u64 sz
= buffer
->size
;
274 bool consecutive
= false;
275 struct auxtrace_buffer
*b
;
278 while (sz
> BUFFER_LIMIT_FOR_32_BIT
) {
279 b
= memdup(buffer
, sizeof(struct auxtrace_buffer
));
282 b
->size
= BUFFER_LIMIT_FOR_32_BIT
;
283 b
->consecutive
= consecutive
;
284 err
= auxtrace_queues__add_buffer(queues
, idx
, b
);
286 auxtrace_buffer__free(b
);
289 buffer
->data_offset
+= BUFFER_LIMIT_FOR_32_BIT
;
290 sz
-= BUFFER_LIMIT_FOR_32_BIT
;
295 buffer
->consecutive
= consecutive
;
300 static int auxtrace_queues__add_event_buffer(struct auxtrace_queues
*queues
,
301 struct perf_session
*session
,
303 struct auxtrace_buffer
*buffer
)
305 if (session
->one_mmap
) {
306 buffer
->data
= buffer
->data_offset
- session
->one_mmap_offset
+
307 session
->one_mmap_addr
;
308 } else if (perf_data_file__is_pipe(session
->file
)) {
309 buffer
->data
= auxtrace_copy_data(buffer
->size
, session
);
312 buffer
->data_needs_freeing
= true;
313 } else if (BITS_PER_LONG
== 32 &&
314 buffer
->size
> BUFFER_LIMIT_FOR_32_BIT
) {
317 err
= auxtrace_queues__split_buffer(queues
, idx
, buffer
);
322 return auxtrace_queues__add_buffer(queues
, idx
, buffer
);
325 static bool filter_cpu(struct perf_session
*session
, int cpu
)
327 unsigned long *cpu_bitmap
= session
->itrace_synth_opts
->cpu_bitmap
;
329 return cpu_bitmap
&& cpu
!= -1 && !test_bit(cpu
, cpu_bitmap
);
332 int auxtrace_queues__add_event(struct auxtrace_queues
*queues
,
333 struct perf_session
*session
,
334 union perf_event
*event
, off_t data_offset
,
335 struct auxtrace_buffer
**buffer_ptr
)
337 struct auxtrace_buffer
*buffer
;
341 if (filter_cpu(session
, event
->auxtrace
.cpu
))
344 buffer
= zalloc(sizeof(struct auxtrace_buffer
));
349 buffer
->tid
= event
->auxtrace
.tid
;
350 buffer
->cpu
= event
->auxtrace
.cpu
;
351 buffer
->data_offset
= data_offset
;
352 buffer
->offset
= event
->auxtrace
.offset
;
353 buffer
->reference
= event
->auxtrace
.reference
;
354 buffer
->size
= event
->auxtrace
.size
;
355 idx
= event
->auxtrace
.idx
;
357 err
= auxtrace_queues__add_event_buffer(queues
, session
, idx
, buffer
);
362 *buffer_ptr
= buffer
;
367 auxtrace_buffer__free(buffer
);
371 static int auxtrace_queues__add_indexed_event(struct auxtrace_queues
*queues
,
372 struct perf_session
*session
,
373 off_t file_offset
, size_t sz
)
375 union perf_event
*event
;
377 char buf
[PERF_SAMPLE_MAX_SIZE
];
379 err
= perf_session__peek_event(session
, file_offset
, buf
,
380 PERF_SAMPLE_MAX_SIZE
, &event
, NULL
);
384 if (event
->header
.type
== PERF_RECORD_AUXTRACE
) {
385 if (event
->header
.size
< sizeof(struct auxtrace_event
) ||
386 event
->header
.size
!= sz
) {
390 file_offset
+= event
->header
.size
;
391 err
= auxtrace_queues__add_event(queues
, session
, event
,
398 void auxtrace_queues__free(struct auxtrace_queues
*queues
)
402 for (i
= 0; i
< queues
->nr_queues
; i
++) {
403 while (!list_empty(&queues
->queue_array
[i
].head
)) {
404 struct auxtrace_buffer
*buffer
;
406 buffer
= list_entry(queues
->queue_array
[i
].head
.next
,
407 struct auxtrace_buffer
, list
);
408 list_del(&buffer
->list
);
409 auxtrace_buffer__free(buffer
);
413 zfree(&queues
->queue_array
);
414 queues
->nr_queues
= 0;
417 static void auxtrace_heapify(struct auxtrace_heap_item
*heap_array
,
418 unsigned int pos
, unsigned int queue_nr
,
424 parent
= (pos
- 1) >> 1;
425 if (heap_array
[parent
].ordinal
<= ordinal
)
427 heap_array
[pos
] = heap_array
[parent
];
430 heap_array
[pos
].queue_nr
= queue_nr
;
431 heap_array
[pos
].ordinal
= ordinal
;
434 int auxtrace_heap__add(struct auxtrace_heap
*heap
, unsigned int queue_nr
,
437 struct auxtrace_heap_item
*heap_array
;
439 if (queue_nr
>= heap
->heap_sz
) {
440 unsigned int heap_sz
= AUXTRACE_INIT_NR_QUEUES
;
442 while (heap_sz
<= queue_nr
)
444 heap_array
= realloc(heap
->heap_array
,
445 heap_sz
* sizeof(struct auxtrace_heap_item
));
448 heap
->heap_array
= heap_array
;
449 heap
->heap_sz
= heap_sz
;
452 auxtrace_heapify(heap
->heap_array
, heap
->heap_cnt
++, queue_nr
, ordinal
);
457 void auxtrace_heap__free(struct auxtrace_heap
*heap
)
459 zfree(&heap
->heap_array
);
464 void auxtrace_heap__pop(struct auxtrace_heap
*heap
)
466 unsigned int pos
, last
, heap_cnt
= heap
->heap_cnt
;
467 struct auxtrace_heap_item
*heap_array
;
474 heap_array
= heap
->heap_array
;
478 unsigned int left
, right
;
480 left
= (pos
<< 1) + 1;
481 if (left
>= heap_cnt
)
484 if (right
>= heap_cnt
) {
485 heap_array
[pos
] = heap_array
[left
];
488 if (heap_array
[left
].ordinal
< heap_array
[right
].ordinal
) {
489 heap_array
[pos
] = heap_array
[left
];
492 heap_array
[pos
] = heap_array
[right
];
498 auxtrace_heapify(heap_array
, pos
, heap_array
[last
].queue_nr
,
499 heap_array
[last
].ordinal
);
502 size_t auxtrace_record__info_priv_size(struct auxtrace_record
*itr
,
503 struct perf_evlist
*evlist
)
506 return itr
->info_priv_size(itr
, evlist
);
510 static int auxtrace_not_supported(void)
512 pr_err("AUX area tracing is not supported on this architecture\n");
516 int auxtrace_record__info_fill(struct auxtrace_record
*itr
,
517 struct perf_session
*session
,
518 struct auxtrace_info_event
*auxtrace_info
,
522 return itr
->info_fill(itr
, session
, auxtrace_info
, priv_size
);
523 return auxtrace_not_supported();
526 void auxtrace_record__free(struct auxtrace_record
*itr
)
532 int auxtrace_record__snapshot_start(struct auxtrace_record
*itr
)
534 if (itr
&& itr
->snapshot_start
)
535 return itr
->snapshot_start(itr
);
539 int auxtrace_record__snapshot_finish(struct auxtrace_record
*itr
)
541 if (itr
&& itr
->snapshot_finish
)
542 return itr
->snapshot_finish(itr
);
546 int auxtrace_record__find_snapshot(struct auxtrace_record
*itr
, int idx
,
547 struct auxtrace_mmap
*mm
,
548 unsigned char *data
, u64
*head
, u64
*old
)
550 if (itr
&& itr
->find_snapshot
)
551 return itr
->find_snapshot(itr
, idx
, mm
, data
, head
, old
);
555 int auxtrace_record__options(struct auxtrace_record
*itr
,
556 struct perf_evlist
*evlist
,
557 struct record_opts
*opts
)
560 return itr
->recording_options(itr
, evlist
, opts
);
564 u64
auxtrace_record__reference(struct auxtrace_record
*itr
)
567 return itr
->reference(itr
);
571 int auxtrace_parse_snapshot_options(struct auxtrace_record
*itr
,
572 struct record_opts
*opts
, const char *str
)
578 return itr
->parse_snapshot_options(itr
, opts
, str
);
580 pr_err("No AUX area tracing to snapshot\n");
584 struct auxtrace_record
*__weak
585 auxtrace_record__init(struct perf_evlist
*evlist __maybe_unused
, int *err
)
591 static int auxtrace_index__alloc(struct list_head
*head
)
593 struct auxtrace_index
*auxtrace_index
;
595 auxtrace_index
= malloc(sizeof(struct auxtrace_index
));
599 auxtrace_index
->nr
= 0;
600 INIT_LIST_HEAD(&auxtrace_index
->list
);
602 list_add_tail(&auxtrace_index
->list
, head
);
607 void auxtrace_index__free(struct list_head
*head
)
609 struct auxtrace_index
*auxtrace_index
, *n
;
611 list_for_each_entry_safe(auxtrace_index
, n
, head
, list
) {
612 list_del(&auxtrace_index
->list
);
613 free(auxtrace_index
);
617 static struct auxtrace_index
*auxtrace_index__last(struct list_head
*head
)
619 struct auxtrace_index
*auxtrace_index
;
622 if (list_empty(head
)) {
623 err
= auxtrace_index__alloc(head
);
628 auxtrace_index
= list_entry(head
->prev
, struct auxtrace_index
, list
);
630 if (auxtrace_index
->nr
>= PERF_AUXTRACE_INDEX_ENTRY_COUNT
) {
631 err
= auxtrace_index__alloc(head
);
634 auxtrace_index
= list_entry(head
->prev
, struct auxtrace_index
,
638 return auxtrace_index
;
641 int auxtrace_index__auxtrace_event(struct list_head
*head
,
642 union perf_event
*event
, off_t file_offset
)
644 struct auxtrace_index
*auxtrace_index
;
647 auxtrace_index
= auxtrace_index__last(head
);
651 nr
= auxtrace_index
->nr
;
652 auxtrace_index
->entries
[nr
].file_offset
= file_offset
;
653 auxtrace_index
->entries
[nr
].sz
= event
->header
.size
;
654 auxtrace_index
->nr
+= 1;
659 static int auxtrace_index__do_write(int fd
,
660 struct auxtrace_index
*auxtrace_index
)
662 struct auxtrace_index_entry ent
;
665 for (i
= 0; i
< auxtrace_index
->nr
; i
++) {
666 ent
.file_offset
= auxtrace_index
->entries
[i
].file_offset
;
667 ent
.sz
= auxtrace_index
->entries
[i
].sz
;
668 if (writen(fd
, &ent
, sizeof(ent
)) != sizeof(ent
))
674 int auxtrace_index__write(int fd
, struct list_head
*head
)
676 struct auxtrace_index
*auxtrace_index
;
680 list_for_each_entry(auxtrace_index
, head
, list
)
681 total
+= auxtrace_index
->nr
;
683 if (writen(fd
, &total
, sizeof(total
)) != sizeof(total
))
686 list_for_each_entry(auxtrace_index
, head
, list
) {
687 err
= auxtrace_index__do_write(fd
, auxtrace_index
);
695 static int auxtrace_index__process_entry(int fd
, struct list_head
*head
,
698 struct auxtrace_index
*auxtrace_index
;
699 struct auxtrace_index_entry ent
;
702 if (readn(fd
, &ent
, sizeof(ent
)) != sizeof(ent
))
705 auxtrace_index
= auxtrace_index__last(head
);
709 nr
= auxtrace_index
->nr
;
711 auxtrace_index
->entries
[nr
].file_offset
=
712 bswap_64(ent
.file_offset
);
713 auxtrace_index
->entries
[nr
].sz
= bswap_64(ent
.sz
);
715 auxtrace_index
->entries
[nr
].file_offset
= ent
.file_offset
;
716 auxtrace_index
->entries
[nr
].sz
= ent
.sz
;
719 auxtrace_index
->nr
= nr
+ 1;
724 int auxtrace_index__process(int fd
, u64 size
, struct perf_session
*session
,
727 struct list_head
*head
= &session
->auxtrace_index
;
730 if (readn(fd
, &nr
, sizeof(u64
)) != sizeof(u64
))
736 if (sizeof(u64
) + nr
* sizeof(struct auxtrace_index_entry
) > size
)
742 err
= auxtrace_index__process_entry(fd
, head
, needs_swap
);
750 static int auxtrace_queues__process_index_entry(struct auxtrace_queues
*queues
,
751 struct perf_session
*session
,
752 struct auxtrace_index_entry
*ent
)
754 return auxtrace_queues__add_indexed_event(queues
, session
,
755 ent
->file_offset
, ent
->sz
);
758 int auxtrace_queues__process_index(struct auxtrace_queues
*queues
,
759 struct perf_session
*session
)
761 struct auxtrace_index
*auxtrace_index
;
762 struct auxtrace_index_entry
*ent
;
766 list_for_each_entry(auxtrace_index
, &session
->auxtrace_index
, list
) {
767 for (i
= 0; i
< auxtrace_index
->nr
; i
++) {
768 ent
= &auxtrace_index
->entries
[i
];
769 err
= auxtrace_queues__process_index_entry(queues
,
779 struct auxtrace_buffer
*auxtrace_buffer__next(struct auxtrace_queue
*queue
,
780 struct auxtrace_buffer
*buffer
)
783 if (list_is_last(&buffer
->list
, &queue
->head
))
785 return list_entry(buffer
->list
.next
, struct auxtrace_buffer
,
788 if (list_empty(&queue
->head
))
790 return list_entry(queue
->head
.next
, struct auxtrace_buffer
,
795 void *auxtrace_buffer__get_data(struct auxtrace_buffer
*buffer
, int fd
)
797 size_t adj
= buffer
->data_offset
& (page_size
- 1);
798 size_t size
= buffer
->size
+ adj
;
799 off_t file_offset
= buffer
->data_offset
- adj
;
805 addr
= mmap(NULL
, size
, PROT_READ
, MAP_SHARED
, fd
, file_offset
);
806 if (addr
== MAP_FAILED
)
809 buffer
->mmap_addr
= addr
;
810 buffer
->mmap_size
= size
;
812 buffer
->data
= addr
+ adj
;
817 void auxtrace_buffer__put_data(struct auxtrace_buffer
*buffer
)
819 if (!buffer
->data
|| !buffer
->mmap_addr
)
821 munmap(buffer
->mmap_addr
, buffer
->mmap_size
);
822 buffer
->mmap_addr
= NULL
;
823 buffer
->mmap_size
= 0;
825 buffer
->use_data
= NULL
;
828 void auxtrace_buffer__drop_data(struct auxtrace_buffer
*buffer
)
830 auxtrace_buffer__put_data(buffer
);
831 if (buffer
->data_needs_freeing
) {
832 buffer
->data_needs_freeing
= false;
833 zfree(&buffer
->data
);
834 buffer
->use_data
= NULL
;
839 void auxtrace_buffer__free(struct auxtrace_buffer
*buffer
)
841 auxtrace_buffer__drop_data(buffer
);
845 void auxtrace_synth_error(struct auxtrace_error_event
*auxtrace_error
, int type
,
846 int code
, int cpu
, pid_t pid
, pid_t tid
, u64 ip
,
851 memset(auxtrace_error
, 0, sizeof(struct auxtrace_error_event
));
853 auxtrace_error
->header
.type
= PERF_RECORD_AUXTRACE_ERROR
;
854 auxtrace_error
->type
= type
;
855 auxtrace_error
->code
= code
;
856 auxtrace_error
->cpu
= cpu
;
857 auxtrace_error
->pid
= pid
;
858 auxtrace_error
->tid
= tid
;
859 auxtrace_error
->ip
= ip
;
860 strlcpy(auxtrace_error
->msg
, msg
, MAX_AUXTRACE_ERROR_MSG
);
862 size
= (void *)auxtrace_error
->msg
- (void *)auxtrace_error
+
863 strlen(auxtrace_error
->msg
) + 1;
864 auxtrace_error
->header
.size
= PERF_ALIGN(size
, sizeof(u64
));
867 int perf_event__synthesize_auxtrace_info(struct auxtrace_record
*itr
,
868 struct perf_tool
*tool
,
869 struct perf_session
*session
,
870 perf_event__handler_t process
)
872 union perf_event
*ev
;
876 pr_debug2("Synthesizing auxtrace information\n");
877 priv_size
= auxtrace_record__info_priv_size(itr
, session
->evlist
);
878 ev
= zalloc(sizeof(struct auxtrace_info_event
) + priv_size
);
882 ev
->auxtrace_info
.header
.type
= PERF_RECORD_AUXTRACE_INFO
;
883 ev
->auxtrace_info
.header
.size
= sizeof(struct auxtrace_info_event
) +
885 err
= auxtrace_record__info_fill(itr
, session
, &ev
->auxtrace_info
,
890 err
= process(tool
, ev
, NULL
, NULL
);
896 static bool auxtrace__dont_decode(struct perf_session
*session
)
898 return !session
->itrace_synth_opts
||
899 session
->itrace_synth_opts
->dont_decode
;
902 int perf_event__process_auxtrace_info(struct perf_tool
*tool __maybe_unused
,
903 union perf_event
*event
,
904 struct perf_session
*session
)
906 enum auxtrace_type type
= event
->auxtrace_info
.type
;
909 fprintf(stdout
, " type: %u\n", type
);
912 case PERF_AUXTRACE_INTEL_PT
:
913 return intel_pt_process_auxtrace_info(event
, session
);
914 case PERF_AUXTRACE_INTEL_BTS
:
915 return intel_bts_process_auxtrace_info(event
, session
);
916 case PERF_AUXTRACE_CS_ETM
:
917 case PERF_AUXTRACE_UNKNOWN
:
923 s64
perf_event__process_auxtrace(struct perf_tool
*tool
,
924 union perf_event
*event
,
925 struct perf_session
*session
)
930 fprintf(stdout
, " size: %#"PRIx64
" offset: %#"PRIx64
" ref: %#"PRIx64
" idx: %u tid: %d cpu: %d\n",
931 event
->auxtrace
.size
, event
->auxtrace
.offset
,
932 event
->auxtrace
.reference
, event
->auxtrace
.idx
,
933 event
->auxtrace
.tid
, event
->auxtrace
.cpu
);
935 if (auxtrace__dont_decode(session
))
936 return event
->auxtrace
.size
;
938 if (!session
->auxtrace
|| event
->header
.type
!= PERF_RECORD_AUXTRACE
)
941 err
= session
->auxtrace
->process_auxtrace_event(session
, event
, tool
);
945 return event
->auxtrace
.size
;
948 #define PERF_ITRACE_DEFAULT_PERIOD_TYPE PERF_ITRACE_PERIOD_NANOSECS
949 #define PERF_ITRACE_DEFAULT_PERIOD 100000
950 #define PERF_ITRACE_DEFAULT_CALLCHAIN_SZ 16
951 #define PERF_ITRACE_MAX_CALLCHAIN_SZ 1024
952 #define PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ 64
953 #define PERF_ITRACE_MAX_LAST_BRANCH_SZ 1024
955 void itrace_synth_opts__set_default(struct itrace_synth_opts
*synth_opts
)
957 synth_opts
->instructions
= true;
958 synth_opts
->branches
= true;
959 synth_opts
->transactions
= true;
960 synth_opts
->ptwrites
= true;
961 synth_opts
->pwr_events
= true;
962 synth_opts
->errors
= true;
963 synth_opts
->period_type
= PERF_ITRACE_DEFAULT_PERIOD_TYPE
;
964 synth_opts
->period
= PERF_ITRACE_DEFAULT_PERIOD
;
965 synth_opts
->callchain_sz
= PERF_ITRACE_DEFAULT_CALLCHAIN_SZ
;
966 synth_opts
->last_branch_sz
= PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ
;
967 synth_opts
->initial_skip
= 0;
971 * Please check tools/perf/Documentation/perf-script.txt for information
972 * about the options parsed here, which is introduced after this cset,
973 * when support in 'perf script' for these options is introduced.
975 int itrace_parse_synth_opts(const struct option
*opt
, const char *str
,
978 struct itrace_synth_opts
*synth_opts
= opt
->value
;
981 bool period_type_set
= false;
982 bool period_set
= false;
984 synth_opts
->set
= true;
987 synth_opts
->dont_decode
= true;
992 itrace_synth_opts__set_default(synth_opts
);
999 synth_opts
->instructions
= true;
1000 while (*p
== ' ' || *p
== ',')
1003 synth_opts
->period
= strtoull(p
, &endptr
, 10);
1006 while (*p
== ' ' || *p
== ',')
1010 synth_opts
->period_type
=
1011 PERF_ITRACE_PERIOD_INSTRUCTIONS
;
1012 period_type_set
= true;
1015 synth_opts
->period_type
=
1016 PERF_ITRACE_PERIOD_TICKS
;
1017 period_type_set
= true;
1020 synth_opts
->period
*= 1000;
1023 synth_opts
->period
*= 1000;
1028 synth_opts
->period_type
=
1029 PERF_ITRACE_PERIOD_NANOSECS
;
1030 period_type_set
= true;
1040 synth_opts
->branches
= true;
1043 synth_opts
->transactions
= true;
1046 synth_opts
->ptwrites
= true;
1049 synth_opts
->pwr_events
= true;
1052 synth_opts
->errors
= true;
1055 synth_opts
->log
= true;
1058 synth_opts
->branches
= true;
1059 synth_opts
->calls
= true;
1062 synth_opts
->branches
= true;
1063 synth_opts
->returns
= true;
1066 synth_opts
->callchain
= true;
1067 synth_opts
->callchain_sz
=
1068 PERF_ITRACE_DEFAULT_CALLCHAIN_SZ
;
1069 while (*p
== ' ' || *p
== ',')
1074 val
= strtoul(p
, &endptr
, 10);
1076 if (!val
|| val
> PERF_ITRACE_MAX_CALLCHAIN_SZ
)
1078 synth_opts
->callchain_sz
= val
;
1082 synth_opts
->last_branch
= true;
1083 synth_opts
->last_branch_sz
=
1084 PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ
;
1085 while (*p
== ' ' || *p
== ',')
1090 val
= strtoul(p
, &endptr
, 10);
1093 val
> PERF_ITRACE_MAX_LAST_BRANCH_SZ
)
1095 synth_opts
->last_branch_sz
= val
;
1099 synth_opts
->initial_skip
= strtoul(p
, &endptr
, 10);
1112 if (synth_opts
->instructions
) {
1113 if (!period_type_set
)
1114 synth_opts
->period_type
=
1115 PERF_ITRACE_DEFAULT_PERIOD_TYPE
;
1117 synth_opts
->period
= PERF_ITRACE_DEFAULT_PERIOD
;
1123 pr_err("Bad Instruction Tracing options '%s'\n", str
);
1127 static const char * const auxtrace_error_type_name
[] = {
1128 [PERF_AUXTRACE_ERROR_ITRACE
] = "instruction trace",
1131 static const char *auxtrace_error_name(int type
)
1133 const char *error_type_name
= NULL
;
1135 if (type
< PERF_AUXTRACE_ERROR_MAX
)
1136 error_type_name
= auxtrace_error_type_name
[type
];
1137 if (!error_type_name
)
1138 error_type_name
= "unknown AUX";
1139 return error_type_name
;
1142 size_t perf_event__fprintf_auxtrace_error(union perf_event
*event
, FILE *fp
)
1144 struct auxtrace_error_event
*e
= &event
->auxtrace_error
;
1147 ret
= fprintf(fp
, " %s error type %u",
1148 auxtrace_error_name(e
->type
), e
->type
);
1149 ret
+= fprintf(fp
, " cpu %d pid %d tid %d ip %#"PRIx64
" code %u: %s\n",
1150 e
->cpu
, e
->pid
, e
->tid
, e
->ip
, e
->code
, e
->msg
);
1154 void perf_session__auxtrace_error_inc(struct perf_session
*session
,
1155 union perf_event
*event
)
1157 struct auxtrace_error_event
*e
= &event
->auxtrace_error
;
1159 if (e
->type
< PERF_AUXTRACE_ERROR_MAX
)
1160 session
->evlist
->stats
.nr_auxtrace_errors
[e
->type
] += 1;
1163 void events_stats__auxtrace_error_warn(const struct events_stats
*stats
)
1167 for (i
= 0; i
< PERF_AUXTRACE_ERROR_MAX
; i
++) {
1168 if (!stats
->nr_auxtrace_errors
[i
])
1170 ui__warning("%u %s errors\n",
1171 stats
->nr_auxtrace_errors
[i
],
1172 auxtrace_error_name(i
));
1176 int perf_event__process_auxtrace_error(struct perf_tool
*tool __maybe_unused
,
1177 union perf_event
*event
,
1178 struct perf_session
*session
)
1180 if (auxtrace__dont_decode(session
))
1183 perf_event__fprintf_auxtrace_error(event
, stdout
);
1187 static int __auxtrace_mmap__read(struct auxtrace_mmap
*mm
,
1188 struct auxtrace_record
*itr
,
1189 struct perf_tool
*tool
, process_auxtrace_t fn
,
1190 bool snapshot
, size_t snapshot_size
)
1192 u64 head
, old
= mm
->prev
, offset
, ref
;
1193 unsigned char *data
= mm
->base
;
1194 size_t size
, head_off
, old_off
, len1
, len2
, padding
;
1195 union perf_event ev
;
1196 void *data1
, *data2
;
1199 head
= auxtrace_mmap__read_snapshot_head(mm
);
1200 if (auxtrace_record__find_snapshot(itr
, mm
->idx
, mm
, data
,
1204 head
= auxtrace_mmap__read_head(mm
);
1210 pr_debug3("auxtrace idx %d old %#"PRIx64
" head %#"PRIx64
" diff %#"PRIx64
"\n",
1211 mm
->idx
, old
, head
, head
- old
);
1214 head_off
= head
& mm
->mask
;
1215 old_off
= old
& mm
->mask
;
1217 head_off
= head
% mm
->len
;
1218 old_off
= old
% mm
->len
;
1221 if (head_off
> old_off
)
1222 size
= head_off
- old_off
;
1224 size
= mm
->len
- (old_off
- head_off
);
1226 if (snapshot
&& size
> snapshot_size
)
1227 size
= snapshot_size
;
1229 ref
= auxtrace_record__reference(itr
);
1231 if (head
> old
|| size
<= head
|| mm
->mask
) {
1232 offset
= head
- size
;
1235 * When the buffer size is not a power of 2, 'head' wraps at the
1236 * highest multiple of the buffer size, so we have to subtract
1237 * the remainder here.
1239 u64 rem
= (0ULL - mm
->len
) % mm
->len
;
1241 offset
= head
- size
- rem
;
1244 if (size
> head_off
) {
1245 len1
= size
- head_off
;
1246 data1
= &data
[mm
->len
- len1
];
1251 data1
= &data
[head_off
- len1
];
1256 if (itr
->alignment
) {
1257 unsigned int unwanted
= len1
% itr
->alignment
;
1263 /* padding must be written by fn() e.g. record__process_auxtrace() */
1266 padding
= 8 - padding
;
1268 memset(&ev
, 0, sizeof(ev
));
1269 ev
.auxtrace
.header
.type
= PERF_RECORD_AUXTRACE
;
1270 ev
.auxtrace
.header
.size
= sizeof(ev
.auxtrace
);
1271 ev
.auxtrace
.size
= size
+ padding
;
1272 ev
.auxtrace
.offset
= offset
;
1273 ev
.auxtrace
.reference
= ref
;
1274 ev
.auxtrace
.idx
= mm
->idx
;
1275 ev
.auxtrace
.tid
= mm
->tid
;
1276 ev
.auxtrace
.cpu
= mm
->cpu
;
1278 if (fn(tool
, &ev
, data1
, len1
, data2
, len2
))
1284 auxtrace_mmap__write_tail(mm
, head
);
1285 if (itr
->read_finish
) {
1288 err
= itr
->read_finish(itr
, mm
->idx
);
1297 int auxtrace_mmap__read(struct auxtrace_mmap
*mm
, struct auxtrace_record
*itr
,
1298 struct perf_tool
*tool
, process_auxtrace_t fn
)
1300 return __auxtrace_mmap__read(mm
, itr
, tool
, fn
, false, 0);
1303 int auxtrace_mmap__read_snapshot(struct auxtrace_mmap
*mm
,
1304 struct auxtrace_record
*itr
,
1305 struct perf_tool
*tool
, process_auxtrace_t fn
,
1306 size_t snapshot_size
)
1308 return __auxtrace_mmap__read(mm
, itr
, tool
, fn
, true, snapshot_size
);
1312 * struct auxtrace_cache - hash table to implement a cache
1313 * @hashtable: the hashtable
1314 * @sz: hashtable size (number of hlists)
1315 * @entry_size: size of an entry
1316 * @limit: limit the number of entries to this maximum, when reached the cache
1317 * is dropped and caching begins again with an empty cache
1318 * @cnt: current number of entries
1319 * @bits: hashtable size (@sz = 2^@bits)
1321 struct auxtrace_cache
{
1322 struct hlist_head
*hashtable
;
1330 struct auxtrace_cache
*auxtrace_cache__new(unsigned int bits
, size_t entry_size
,
1331 unsigned int limit_percent
)
1333 struct auxtrace_cache
*c
;
1334 struct hlist_head
*ht
;
1337 c
= zalloc(sizeof(struct auxtrace_cache
));
1343 ht
= calloc(sz
, sizeof(struct hlist_head
));
1347 for (i
= 0; i
< sz
; i
++)
1348 INIT_HLIST_HEAD(&ht
[i
]);
1352 c
->entry_size
= entry_size
;
1353 c
->limit
= (c
->sz
* limit_percent
) / 100;
1363 static void auxtrace_cache__drop(struct auxtrace_cache
*c
)
1365 struct auxtrace_cache_entry
*entry
;
1366 struct hlist_node
*tmp
;
1372 for (i
= 0; i
< c
->sz
; i
++) {
1373 hlist_for_each_entry_safe(entry
, tmp
, &c
->hashtable
[i
], hash
) {
1374 hlist_del(&entry
->hash
);
1375 auxtrace_cache__free_entry(c
, entry
);
1382 void auxtrace_cache__free(struct auxtrace_cache
*c
)
1387 auxtrace_cache__drop(c
);
1392 void *auxtrace_cache__alloc_entry(struct auxtrace_cache
*c
)
1394 return malloc(c
->entry_size
);
1397 void auxtrace_cache__free_entry(struct auxtrace_cache
*c __maybe_unused
,
1403 int auxtrace_cache__add(struct auxtrace_cache
*c
, u32 key
,
1404 struct auxtrace_cache_entry
*entry
)
1406 if (c
->limit
&& ++c
->cnt
> c
->limit
)
1407 auxtrace_cache__drop(c
);
1410 hlist_add_head(&entry
->hash
, &c
->hashtable
[hash_32(key
, c
->bits
)]);
1415 void *auxtrace_cache__lookup(struct auxtrace_cache
*c
, u32 key
)
1417 struct auxtrace_cache_entry
*entry
;
1418 struct hlist_head
*hlist
;
1423 hlist
= &c
->hashtable
[hash_32(key
, c
->bits
)];
1424 hlist_for_each_entry(entry
, hlist
, hash
) {
1425 if (entry
->key
== key
)
1432 static void addr_filter__free_str(struct addr_filter
*filt
)
1435 filt
->action
= NULL
;
1436 filt
->sym_from
= NULL
;
1437 filt
->sym_to
= NULL
;
1438 filt
->filename
= NULL
;
1442 static struct addr_filter
*addr_filter__new(void)
1444 struct addr_filter
*filt
= zalloc(sizeof(*filt
));
1447 INIT_LIST_HEAD(&filt
->list
);
1452 static void addr_filter__free(struct addr_filter
*filt
)
1455 addr_filter__free_str(filt
);
1459 static void addr_filters__add(struct addr_filters
*filts
,
1460 struct addr_filter
*filt
)
1462 list_add_tail(&filt
->list
, &filts
->head
);
1466 static void addr_filters__del(struct addr_filters
*filts
,
1467 struct addr_filter
*filt
)
1469 list_del_init(&filt
->list
);
1473 void addr_filters__init(struct addr_filters
*filts
)
1475 INIT_LIST_HEAD(&filts
->head
);
1479 void addr_filters__exit(struct addr_filters
*filts
)
1481 struct addr_filter
*filt
, *n
;
1483 list_for_each_entry_safe(filt
, n
, &filts
->head
, list
) {
1484 addr_filters__del(filts
, filt
);
1485 addr_filter__free(filt
);
1489 static int parse_num_or_str(char **inp
, u64
*num
, const char **str
,
1490 const char *str_delim
)
1492 *inp
+= strspn(*inp
, " ");
1494 if (isdigit(**inp
)) {
1500 *num
= strtoull(*inp
, &endptr
, 0);
1511 *inp
+= strspn(*inp
, " ");
1513 n
= strcspn(*inp
, str_delim
);
1525 static int parse_action(struct addr_filter
*filt
)
1527 if (!strcmp(filt
->action
, "filter")) {
1530 } else if (!strcmp(filt
->action
, "start")) {
1532 } else if (!strcmp(filt
->action
, "stop")) {
1533 filt
->start
= false;
1534 } else if (!strcmp(filt
->action
, "tracestop")) {
1535 filt
->start
= false;
1537 filt
->action
+= 5; /* Change 'tracestop' to 'stop' */
1544 static int parse_sym_idx(char **inp
, int *idx
)
1548 *inp
+= strspn(*inp
, " ");
1555 if (**inp
== 'g' || **inp
== 'G') {
1563 num
= strtoul(*inp
, &endptr
, 0);
1566 if (endptr
== *inp
|| num
> INT_MAX
)
1575 static int parse_addr_size(char **inp
, u64
*num
, const char **str
, int *idx
)
1577 int err
= parse_num_or_str(inp
, num
, str
, " ");
1580 err
= parse_sym_idx(inp
, idx
);
1585 static int parse_one_filter(struct addr_filter
*filt
, const char **filter_inp
)
1590 filt
->str
= fstr
= strdup(*filter_inp
);
1594 err
= parse_num_or_str(&fstr
, NULL
, &filt
->action
, " ");
1598 err
= parse_action(filt
);
1602 err
= parse_addr_size(&fstr
, &filt
->addr
, &filt
->sym_from
,
1603 &filt
->sym_from_idx
);
1607 fstr
+= strspn(fstr
, " ");
1611 err
= parse_addr_size(&fstr
, &filt
->size
, &filt
->sym_to
,
1618 fstr
+= strspn(fstr
, " ");
1622 err
= parse_num_or_str(&fstr
, NULL
, &filt
->filename
, " ,");
1627 fstr
+= strspn(fstr
, " ,");
1629 *filter_inp
+= fstr
- filt
->str
;
1634 addr_filter__free_str(filt
);
1639 int addr_filters__parse_bare_filter(struct addr_filters
*filts
,
1642 struct addr_filter
*filt
;
1643 const char *fstr
= filter
;
1647 filt
= addr_filter__new();
1648 err
= parse_one_filter(filt
, &fstr
);
1650 addr_filter__free(filt
);
1651 addr_filters__exit(filts
);
1654 addr_filters__add(filts
, filt
);
1673 static bool kern_sym_match(struct sym_args
*args
, const char *name
, char type
)
1675 /* A function with the same name, and global or the n'th found or any */
1676 return symbol_type__is_a(type
, MAP__FUNCTION
) &&
1677 !strcmp(name
, args
->name
) &&
1678 ((args
->global
&& isupper(type
)) ||
1679 (args
->selected
&& ++(args
->cnt
) == args
->idx
) ||
1680 (!args
->global
&& !args
->selected
));
1683 static int find_kern_sym_cb(void *arg
, const char *name
, char type
, u64 start
)
1685 struct sym_args
*args
= arg
;
1687 if (args
->started
) {
1689 args
->size
= start
- args
->start
;
1690 if (args
->selected
) {
1693 } else if (kern_sym_match(args
, name
, type
)) {
1694 args
->duplicate
= true;
1697 } else if (kern_sym_match(args
, name
, type
)) {
1698 args
->started
= true;
1699 args
->start
= start
;
1705 static int print_kern_sym_cb(void *arg
, const char *name
, char type
, u64 start
)
1707 struct sym_args
*args
= arg
;
1709 if (kern_sym_match(args
, name
, type
)) {
1710 pr_err("#%d\t0x%"PRIx64
"\t%c\t%s\n",
1711 ++args
->cnt
, start
, type
, name
);
1713 } else if (args
->near
) {
1715 pr_err("\t\twhich is near\t\t%s\n", name
);
1721 static int sym_not_found_error(const char *sym_name
, int idx
)
1724 pr_err("N'th occurrence (N=%d) of symbol '%s' not found.\n",
1727 pr_err("Global symbol '%s' not found.\n", sym_name
);
1729 pr_err("Symbol '%s' not found.\n", sym_name
);
1731 pr_err("Note that symbols must be functions.\n");
1736 static int find_kern_sym(const char *sym_name
, u64
*start
, u64
*size
, int idx
)
1738 struct sym_args args
= {
1742 .selected
= idx
> 0,
1749 err
= kallsyms__parse("/proc/kallsyms", &args
, find_kern_sym_cb
);
1751 pr_err("Failed to parse /proc/kallsyms\n");
1755 if (args
.duplicate
) {
1756 pr_err("Multiple kernel symbols with name '%s'\n", sym_name
);
1758 kallsyms__parse("/proc/kallsyms", &args
, print_kern_sym_cb
);
1759 pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
1761 pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
1765 if (!args
.started
) {
1766 pr_err("Kernel symbol lookup: ");
1767 return sym_not_found_error(sym_name
, idx
);
1770 *start
= args
.start
;
1776 static int find_entire_kern_cb(void *arg
, const char *name __maybe_unused
,
1777 char type
, u64 start
)
1779 struct sym_args
*args
= arg
;
1781 if (!symbol_type__is_a(type
, MAP__FUNCTION
))
1784 if (!args
->started
) {
1785 args
->started
= true;
1786 args
->start
= start
;
1788 /* Don't know exactly where the kernel ends, so we add a page */
1789 args
->size
= round_up(start
, page_size
) + page_size
- args
->start
;
1794 static int addr_filter__entire_kernel(struct addr_filter
*filt
)
1796 struct sym_args args
= { .started
= false };
1799 err
= kallsyms__parse("/proc/kallsyms", &args
, find_entire_kern_cb
);
1800 if (err
< 0 || !args
.started
) {
1801 pr_err("Failed to parse /proc/kallsyms\n");
1805 filt
->addr
= args
.start
;
1806 filt
->size
= args
.size
;
1811 static int check_end_after_start(struct addr_filter
*filt
, u64 start
, u64 size
)
1813 if (start
+ size
>= filt
->addr
)
1816 if (filt
->sym_from
) {
1817 pr_err("Symbol '%s' (0x%"PRIx64
") comes before '%s' (0x%"PRIx64
")\n",
1818 filt
->sym_to
, start
, filt
->sym_from
, filt
->addr
);
1820 pr_err("Symbol '%s' (0x%"PRIx64
") comes before address 0x%"PRIx64
")\n",
1821 filt
->sym_to
, start
, filt
->addr
);
1827 static int addr_filter__resolve_kernel_syms(struct addr_filter
*filt
)
1829 bool no_size
= false;
1833 if (symbol_conf
.kptr_restrict
) {
1834 pr_err("Kernel addresses are restricted. Unable to resolve kernel symbols.\n");
1838 if (filt
->sym_from
&& !strcmp(filt
->sym_from
, "*"))
1839 return addr_filter__entire_kernel(filt
);
1841 if (filt
->sym_from
) {
1842 err
= find_kern_sym(filt
->sym_from
, &start
, &size
,
1843 filt
->sym_from_idx
);
1847 if (filt
->range
&& !filt
->size
&& !filt
->sym_to
) {
1854 err
= find_kern_sym(filt
->sym_to
, &start
, &size
,
1859 err
= check_end_after_start(filt
, start
, size
);
1862 filt
->size
= start
+ size
- filt
->addr
;
1866 /* The very last symbol in kallsyms does not imply a particular size */
1868 pr_err("Cannot determine size of symbol '%s'\n",
1869 filt
->sym_to
? filt
->sym_to
: filt
->sym_from
);
1876 static struct dso
*load_dso(const char *name
)
1881 map
= dso__new_map(name
);
1887 dso
= dso__get(map
->dso
);
1894 static bool dso_sym_match(struct symbol
*sym
, const char *name
, int *cnt
,
1897 /* Same name, and global or the n'th found or any */
1898 return !arch__compare_symbol_names(name
, sym
->name
) &&
1899 ((!idx
&& sym
->binding
== STB_GLOBAL
) ||
1900 (idx
> 0 && ++*cnt
== idx
) ||
1904 static void print_duplicate_syms(struct dso
*dso
, const char *sym_name
)
1910 pr_err("Multiple symbols with name '%s'\n", sym_name
);
1912 sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
1914 if (dso_sym_match(sym
, sym_name
, &cnt
, -1)) {
1915 pr_err("#%d\t0x%"PRIx64
"\t%c\t%s\n",
1917 sym
->binding
== STB_GLOBAL
? 'g' :
1918 sym
->binding
== STB_LOCAL
? 'l' : 'w',
1923 pr_err("\t\twhich is near\t\t%s\n", sym
->name
);
1925 sym
= dso__next_symbol(sym
);
1928 pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
1930 pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
1933 static int find_dso_sym(struct dso
*dso
, const char *sym_name
, u64
*start
,
1942 sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
1946 *size
= sym
->start
- *start
;
1950 } else if (dso_sym_match(sym
, sym_name
, &cnt
, idx
)) {
1951 print_duplicate_syms(dso
, sym_name
);
1954 } else if (dso_sym_match(sym
, sym_name
, &cnt
, idx
)) {
1955 *start
= sym
->start
;
1956 *size
= sym
->end
- sym
->start
;
1958 sym
= dso__next_symbol(sym
);
1962 return sym_not_found_error(sym_name
, idx
);
1967 static int addr_filter__entire_dso(struct addr_filter
*filt
, struct dso
*dso
)
1969 struct symbol
*first_sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
1970 struct symbol
*last_sym
= dso__last_symbol(dso
, MAP__FUNCTION
);
1972 if (!first_sym
|| !last_sym
) {
1973 pr_err("Failed to determine filter for %s\nNo symbols found.\n",
1978 filt
->addr
= first_sym
->start
;
1979 filt
->size
= last_sym
->end
- first_sym
->start
;
1984 static int addr_filter__resolve_syms(struct addr_filter
*filt
)
1990 if (!filt
->sym_from
&& !filt
->sym_to
)
1993 if (!filt
->filename
)
1994 return addr_filter__resolve_kernel_syms(filt
);
1996 dso
= load_dso(filt
->filename
);
1998 pr_err("Failed to load symbols from: %s\n", filt
->filename
);
2002 if (filt
->sym_from
&& !strcmp(filt
->sym_from
, "*")) {
2003 err
= addr_filter__entire_dso(filt
, dso
);
2007 if (filt
->sym_from
) {
2008 err
= find_dso_sym(dso
, filt
->sym_from
, &start
, &size
,
2009 filt
->sym_from_idx
);
2013 if (filt
->range
&& !filt
->size
&& !filt
->sym_to
)
2018 err
= find_dso_sym(dso
, filt
->sym_to
, &start
, &size
,
2023 err
= check_end_after_start(filt
, start
, size
);
2027 filt
->size
= start
+ size
- filt
->addr
;
2036 static char *addr_filter__to_str(struct addr_filter
*filt
)
2038 char filename_buf
[PATH_MAX
];
2039 const char *at
= "";
2040 const char *fn
= "";
2044 if (filt
->filename
) {
2046 fn
= realpath(filt
->filename
, filename_buf
);
2052 err
= asprintf(&filter
, "%s 0x%"PRIx64
"/0x%"PRIx64
"%s%s",
2053 filt
->action
, filt
->addr
, filt
->size
, at
, fn
);
2055 err
= asprintf(&filter
, "%s 0x%"PRIx64
"%s%s",
2056 filt
->action
, filt
->addr
, at
, fn
);
2059 return err
< 0 ? NULL
: filter
;
2062 static int parse_addr_filter(struct perf_evsel
*evsel
, const char *filter
,
2065 struct addr_filters filts
;
2066 struct addr_filter
*filt
;
2069 addr_filters__init(&filts
);
2071 err
= addr_filters__parse_bare_filter(&filts
, filter
);
2075 if (filts
.cnt
> max_nr
) {
2076 pr_err("Error: number of address filters (%d) exceeds maximum (%d)\n",
2082 list_for_each_entry(filt
, &filts
.head
, list
) {
2085 err
= addr_filter__resolve_syms(filt
);
2089 new_filter
= addr_filter__to_str(filt
);
2095 if (perf_evsel__append_addr_filter(evsel
, new_filter
)) {
2102 addr_filters__exit(&filts
);
2105 pr_err("Failed to parse address filter: '%s'\n", filter
);
2106 pr_err("Filter format is: filter|start|stop|tracestop <start symbol or address> [/ <end symbol or size>] [@<file name>]\n");
2107 pr_err("Where multiple filters are separated by space or comma.\n");
2113 static struct perf_pmu
*perf_evsel__find_pmu(struct perf_evsel
*evsel
)
2115 struct perf_pmu
*pmu
= NULL
;
2117 while ((pmu
= perf_pmu__scan(pmu
)) != NULL
) {
2118 if (pmu
->type
== evsel
->attr
.type
)
2125 static int perf_evsel__nr_addr_filter(struct perf_evsel
*evsel
)
2127 struct perf_pmu
*pmu
= perf_evsel__find_pmu(evsel
);
2128 int nr_addr_filters
= 0;
2133 perf_pmu__scan_file(pmu
, "nr_addr_filters", "%d", &nr_addr_filters
);
2135 return nr_addr_filters
;
2138 int auxtrace_parse_filters(struct perf_evlist
*evlist
)
2140 struct perf_evsel
*evsel
;
2144 evlist__for_each_entry(evlist
, evsel
) {
2145 filter
= evsel
->filter
;
2146 max_nr
= perf_evsel__nr_addr_filter(evsel
);
2147 if (!filter
|| !max_nr
)
2149 evsel
->filter
= NULL
;
2150 err
= parse_addr_filter(evsel
, filter
, max_nr
);
2154 pr_debug("Address filter: %s\n", evsel
->filter
);