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
16 #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"
49 #include "symbol/kallsyms.h"
52 #include <linux/hash.h>
57 #include <subcmd/parse-options.h>
60 #include "intel-bts.h"
62 int auxtrace_mmap__mmap(struct auxtrace_mmap
*mm
,
63 struct auxtrace_mmap_params
*mp
,
66 struct perf_event_mmap_page
*pc
= userpg
;
68 WARN_ONCE(mm
->base
, "Uninitialized auxtrace_mmap\n");
83 #if BITS_PER_LONG != 64 && !defined(HAVE_SYNC_COMPARE_AND_SWAP_SUPPORT)
84 pr_err("Cannot use AUX area tracing mmaps\n");
88 pc
->aux_offset
= mp
->offset
;
89 pc
->aux_size
= mp
->len
;
91 mm
->base
= mmap(NULL
, mp
->len
, mp
->prot
, MAP_SHARED
, fd
, mp
->offset
);
92 if (mm
->base
== MAP_FAILED
) {
93 pr_debug2("failed to mmap AUX area\n");
101 void auxtrace_mmap__munmap(struct auxtrace_mmap
*mm
)
104 munmap(mm
->base
, mm
->len
);
109 void auxtrace_mmap_params__init(struct auxtrace_mmap_params
*mp
,
110 off_t auxtrace_offset
,
111 unsigned int auxtrace_pages
,
112 bool auxtrace_overwrite
)
114 if (auxtrace_pages
) {
115 mp
->offset
= auxtrace_offset
;
116 mp
->len
= auxtrace_pages
* (size_t)page_size
;
117 mp
->mask
= is_power_of_2(mp
->len
) ? mp
->len
- 1 : 0;
118 mp
->prot
= PROT_READ
| (auxtrace_overwrite
? 0 : PROT_WRITE
);
119 pr_debug2("AUX area mmap length %zu\n", mp
->len
);
125 void auxtrace_mmap_params__set_idx(struct auxtrace_mmap_params
*mp
,
126 struct perf_evlist
*evlist
, int idx
,
132 mp
->cpu
= evlist
->cpus
->map
[idx
];
134 mp
->tid
= thread_map__pid(evlist
->threads
, 0);
139 mp
->tid
= thread_map__pid(evlist
->threads
, idx
);
143 #define AUXTRACE_INIT_NR_QUEUES 32
145 static struct auxtrace_queue
*auxtrace_alloc_queue_array(unsigned int nr_queues
)
147 struct auxtrace_queue
*queue_array
;
148 unsigned int max_nr_queues
, i
;
150 max_nr_queues
= UINT_MAX
/ sizeof(struct auxtrace_queue
);
151 if (nr_queues
> max_nr_queues
)
154 queue_array
= calloc(nr_queues
, sizeof(struct auxtrace_queue
));
158 for (i
= 0; i
< nr_queues
; i
++) {
159 INIT_LIST_HEAD(&queue_array
[i
].head
);
160 queue_array
[i
].priv
= NULL
;
166 int auxtrace_queues__init(struct auxtrace_queues
*queues
)
168 queues
->nr_queues
= AUXTRACE_INIT_NR_QUEUES
;
169 queues
->queue_array
= auxtrace_alloc_queue_array(queues
->nr_queues
);
170 if (!queues
->queue_array
)
175 static int auxtrace_queues__grow(struct auxtrace_queues
*queues
,
176 unsigned int new_nr_queues
)
178 unsigned int nr_queues
= queues
->nr_queues
;
179 struct auxtrace_queue
*queue_array
;
183 nr_queues
= AUXTRACE_INIT_NR_QUEUES
;
185 while (nr_queues
&& nr_queues
< new_nr_queues
)
188 if (nr_queues
< queues
->nr_queues
|| nr_queues
< new_nr_queues
)
191 queue_array
= auxtrace_alloc_queue_array(nr_queues
);
195 for (i
= 0; i
< queues
->nr_queues
; i
++) {
196 list_splice_tail(&queues
->queue_array
[i
].head
,
197 &queue_array
[i
].head
);
198 queue_array
[i
].priv
= queues
->queue_array
[i
].priv
;
201 queues
->nr_queues
= nr_queues
;
202 queues
->queue_array
= queue_array
;
207 static void *auxtrace_copy_data(u64 size
, struct perf_session
*session
)
209 int fd
= perf_data_file__fd(session
->file
);
213 if (size
> SSIZE_MAX
)
220 ret
= readn(fd
, p
, size
);
221 if (ret
!= (ssize_t
)size
) {
229 static int auxtrace_queues__add_buffer(struct auxtrace_queues
*queues
,
231 struct auxtrace_buffer
*buffer
)
233 struct auxtrace_queue
*queue
;
236 if (idx
>= queues
->nr_queues
) {
237 err
= auxtrace_queues__grow(queues
, idx
+ 1);
242 queue
= &queues
->queue_array
[idx
];
246 queue
->tid
= buffer
->tid
;
247 queue
->cpu
= buffer
->cpu
;
248 } else if (buffer
->cpu
!= queue
->cpu
|| buffer
->tid
!= queue
->tid
) {
249 pr_err("auxtrace queue conflict: cpu %d, tid %d vs cpu %d, tid %d\n",
250 queue
->cpu
, queue
->tid
, buffer
->cpu
, buffer
->tid
);
254 buffer
->buffer_nr
= queues
->next_buffer_nr
++;
256 list_add_tail(&buffer
->list
, &queue
->head
);
258 queues
->new_data
= true;
259 queues
->populated
= true;
264 /* Limit buffers to 32MiB on 32-bit */
265 #define BUFFER_LIMIT_FOR_32_BIT (32 * 1024 * 1024)
267 static int auxtrace_queues__split_buffer(struct auxtrace_queues
*queues
,
269 struct auxtrace_buffer
*buffer
)
271 u64 sz
= buffer
->size
;
272 bool consecutive
= false;
273 struct auxtrace_buffer
*b
;
276 while (sz
> BUFFER_LIMIT_FOR_32_BIT
) {
277 b
= memdup(buffer
, sizeof(struct auxtrace_buffer
));
280 b
->size
= BUFFER_LIMIT_FOR_32_BIT
;
281 b
->consecutive
= consecutive
;
282 err
= auxtrace_queues__add_buffer(queues
, idx
, b
);
284 auxtrace_buffer__free(b
);
287 buffer
->data_offset
+= BUFFER_LIMIT_FOR_32_BIT
;
288 sz
-= BUFFER_LIMIT_FOR_32_BIT
;
293 buffer
->consecutive
= consecutive
;
298 static int auxtrace_queues__add_event_buffer(struct auxtrace_queues
*queues
,
299 struct perf_session
*session
,
301 struct auxtrace_buffer
*buffer
)
303 if (session
->one_mmap
) {
304 buffer
->data
= buffer
->data_offset
- session
->one_mmap_offset
+
305 session
->one_mmap_addr
;
306 } else if (perf_data_file__is_pipe(session
->file
)) {
307 buffer
->data
= auxtrace_copy_data(buffer
->size
, session
);
310 buffer
->data_needs_freeing
= true;
311 } else if (BITS_PER_LONG
== 32 &&
312 buffer
->size
> BUFFER_LIMIT_FOR_32_BIT
) {
315 err
= auxtrace_queues__split_buffer(queues
, idx
, buffer
);
320 return auxtrace_queues__add_buffer(queues
, idx
, buffer
);
323 int auxtrace_queues__add_event(struct auxtrace_queues
*queues
,
324 struct perf_session
*session
,
325 union perf_event
*event
, off_t data_offset
,
326 struct auxtrace_buffer
**buffer_ptr
)
328 struct auxtrace_buffer
*buffer
;
332 buffer
= zalloc(sizeof(struct auxtrace_buffer
));
337 buffer
->tid
= event
->auxtrace
.tid
;
338 buffer
->cpu
= event
->auxtrace
.cpu
;
339 buffer
->data_offset
= data_offset
;
340 buffer
->offset
= event
->auxtrace
.offset
;
341 buffer
->reference
= event
->auxtrace
.reference
;
342 buffer
->size
= event
->auxtrace
.size
;
343 idx
= event
->auxtrace
.idx
;
345 err
= auxtrace_queues__add_event_buffer(queues
, session
, idx
, buffer
);
350 *buffer_ptr
= buffer
;
355 auxtrace_buffer__free(buffer
);
359 static int auxtrace_queues__add_indexed_event(struct auxtrace_queues
*queues
,
360 struct perf_session
*session
,
361 off_t file_offset
, size_t sz
)
363 union perf_event
*event
;
365 char buf
[PERF_SAMPLE_MAX_SIZE
];
367 err
= perf_session__peek_event(session
, file_offset
, buf
,
368 PERF_SAMPLE_MAX_SIZE
, &event
, NULL
);
372 if (event
->header
.type
== PERF_RECORD_AUXTRACE
) {
373 if (event
->header
.size
< sizeof(struct auxtrace_event
) ||
374 event
->header
.size
!= sz
) {
378 file_offset
+= event
->header
.size
;
379 err
= auxtrace_queues__add_event(queues
, session
, event
,
386 void auxtrace_queues__free(struct auxtrace_queues
*queues
)
390 for (i
= 0; i
< queues
->nr_queues
; i
++) {
391 while (!list_empty(&queues
->queue_array
[i
].head
)) {
392 struct auxtrace_buffer
*buffer
;
394 buffer
= list_entry(queues
->queue_array
[i
].head
.next
,
395 struct auxtrace_buffer
, list
);
396 list_del(&buffer
->list
);
397 auxtrace_buffer__free(buffer
);
401 zfree(&queues
->queue_array
);
402 queues
->nr_queues
= 0;
405 static void auxtrace_heapify(struct auxtrace_heap_item
*heap_array
,
406 unsigned int pos
, unsigned int queue_nr
,
412 parent
= (pos
- 1) >> 1;
413 if (heap_array
[parent
].ordinal
<= ordinal
)
415 heap_array
[pos
] = heap_array
[parent
];
418 heap_array
[pos
].queue_nr
= queue_nr
;
419 heap_array
[pos
].ordinal
= ordinal
;
422 int auxtrace_heap__add(struct auxtrace_heap
*heap
, unsigned int queue_nr
,
425 struct auxtrace_heap_item
*heap_array
;
427 if (queue_nr
>= heap
->heap_sz
) {
428 unsigned int heap_sz
= AUXTRACE_INIT_NR_QUEUES
;
430 while (heap_sz
<= queue_nr
)
432 heap_array
= realloc(heap
->heap_array
,
433 heap_sz
* sizeof(struct auxtrace_heap_item
));
436 heap
->heap_array
= heap_array
;
437 heap
->heap_sz
= heap_sz
;
440 auxtrace_heapify(heap
->heap_array
, heap
->heap_cnt
++, queue_nr
, ordinal
);
445 void auxtrace_heap__free(struct auxtrace_heap
*heap
)
447 zfree(&heap
->heap_array
);
452 void auxtrace_heap__pop(struct auxtrace_heap
*heap
)
454 unsigned int pos
, last
, heap_cnt
= heap
->heap_cnt
;
455 struct auxtrace_heap_item
*heap_array
;
462 heap_array
= heap
->heap_array
;
466 unsigned int left
, right
;
468 left
= (pos
<< 1) + 1;
469 if (left
>= heap_cnt
)
472 if (right
>= heap_cnt
) {
473 heap_array
[pos
] = heap_array
[left
];
476 if (heap_array
[left
].ordinal
< heap_array
[right
].ordinal
) {
477 heap_array
[pos
] = heap_array
[left
];
480 heap_array
[pos
] = heap_array
[right
];
486 auxtrace_heapify(heap_array
, pos
, heap_array
[last
].queue_nr
,
487 heap_array
[last
].ordinal
);
490 size_t auxtrace_record__info_priv_size(struct auxtrace_record
*itr
,
491 struct perf_evlist
*evlist
)
494 return itr
->info_priv_size(itr
, evlist
);
498 static int auxtrace_not_supported(void)
500 pr_err("AUX area tracing is not supported on this architecture\n");
504 int auxtrace_record__info_fill(struct auxtrace_record
*itr
,
505 struct perf_session
*session
,
506 struct auxtrace_info_event
*auxtrace_info
,
510 return itr
->info_fill(itr
, session
, auxtrace_info
, priv_size
);
511 return auxtrace_not_supported();
514 void auxtrace_record__free(struct auxtrace_record
*itr
)
520 int auxtrace_record__snapshot_start(struct auxtrace_record
*itr
)
522 if (itr
&& itr
->snapshot_start
)
523 return itr
->snapshot_start(itr
);
527 int auxtrace_record__snapshot_finish(struct auxtrace_record
*itr
)
529 if (itr
&& itr
->snapshot_finish
)
530 return itr
->snapshot_finish(itr
);
534 int auxtrace_record__find_snapshot(struct auxtrace_record
*itr
, int idx
,
535 struct auxtrace_mmap
*mm
,
536 unsigned char *data
, u64
*head
, u64
*old
)
538 if (itr
&& itr
->find_snapshot
)
539 return itr
->find_snapshot(itr
, idx
, mm
, data
, head
, old
);
543 int auxtrace_record__options(struct auxtrace_record
*itr
,
544 struct perf_evlist
*evlist
,
545 struct record_opts
*opts
)
548 return itr
->recording_options(itr
, evlist
, opts
);
552 u64
auxtrace_record__reference(struct auxtrace_record
*itr
)
555 return itr
->reference(itr
);
559 int auxtrace_parse_snapshot_options(struct auxtrace_record
*itr
,
560 struct record_opts
*opts
, const char *str
)
566 return itr
->parse_snapshot_options(itr
, opts
, str
);
568 pr_err("No AUX area tracing to snapshot\n");
572 struct auxtrace_record
*__weak
573 auxtrace_record__init(struct perf_evlist
*evlist __maybe_unused
, int *err
)
579 static int auxtrace_index__alloc(struct list_head
*head
)
581 struct auxtrace_index
*auxtrace_index
;
583 auxtrace_index
= malloc(sizeof(struct auxtrace_index
));
587 auxtrace_index
->nr
= 0;
588 INIT_LIST_HEAD(&auxtrace_index
->list
);
590 list_add_tail(&auxtrace_index
->list
, head
);
595 void auxtrace_index__free(struct list_head
*head
)
597 struct auxtrace_index
*auxtrace_index
, *n
;
599 list_for_each_entry_safe(auxtrace_index
, n
, head
, list
) {
600 list_del(&auxtrace_index
->list
);
601 free(auxtrace_index
);
605 static struct auxtrace_index
*auxtrace_index__last(struct list_head
*head
)
607 struct auxtrace_index
*auxtrace_index
;
610 if (list_empty(head
)) {
611 err
= auxtrace_index__alloc(head
);
616 auxtrace_index
= list_entry(head
->prev
, struct auxtrace_index
, list
);
618 if (auxtrace_index
->nr
>= PERF_AUXTRACE_INDEX_ENTRY_COUNT
) {
619 err
= auxtrace_index__alloc(head
);
622 auxtrace_index
= list_entry(head
->prev
, struct auxtrace_index
,
626 return auxtrace_index
;
629 int auxtrace_index__auxtrace_event(struct list_head
*head
,
630 union perf_event
*event
, off_t file_offset
)
632 struct auxtrace_index
*auxtrace_index
;
635 auxtrace_index
= auxtrace_index__last(head
);
639 nr
= auxtrace_index
->nr
;
640 auxtrace_index
->entries
[nr
].file_offset
= file_offset
;
641 auxtrace_index
->entries
[nr
].sz
= event
->header
.size
;
642 auxtrace_index
->nr
+= 1;
647 static int auxtrace_index__do_write(int fd
,
648 struct auxtrace_index
*auxtrace_index
)
650 struct auxtrace_index_entry ent
;
653 for (i
= 0; i
< auxtrace_index
->nr
; i
++) {
654 ent
.file_offset
= auxtrace_index
->entries
[i
].file_offset
;
655 ent
.sz
= auxtrace_index
->entries
[i
].sz
;
656 if (writen(fd
, &ent
, sizeof(ent
)) != sizeof(ent
))
662 int auxtrace_index__write(int fd
, struct list_head
*head
)
664 struct auxtrace_index
*auxtrace_index
;
668 list_for_each_entry(auxtrace_index
, head
, list
)
669 total
+= auxtrace_index
->nr
;
671 if (writen(fd
, &total
, sizeof(total
)) != sizeof(total
))
674 list_for_each_entry(auxtrace_index
, head
, list
) {
675 err
= auxtrace_index__do_write(fd
, auxtrace_index
);
683 static int auxtrace_index__process_entry(int fd
, struct list_head
*head
,
686 struct auxtrace_index
*auxtrace_index
;
687 struct auxtrace_index_entry ent
;
690 if (readn(fd
, &ent
, sizeof(ent
)) != sizeof(ent
))
693 auxtrace_index
= auxtrace_index__last(head
);
697 nr
= auxtrace_index
->nr
;
699 auxtrace_index
->entries
[nr
].file_offset
=
700 bswap_64(ent
.file_offset
);
701 auxtrace_index
->entries
[nr
].sz
= bswap_64(ent
.sz
);
703 auxtrace_index
->entries
[nr
].file_offset
= ent
.file_offset
;
704 auxtrace_index
->entries
[nr
].sz
= ent
.sz
;
707 auxtrace_index
->nr
= nr
+ 1;
712 int auxtrace_index__process(int fd
, u64 size
, struct perf_session
*session
,
715 struct list_head
*head
= &session
->auxtrace_index
;
718 if (readn(fd
, &nr
, sizeof(u64
)) != sizeof(u64
))
724 if (sizeof(u64
) + nr
* sizeof(struct auxtrace_index_entry
) > size
)
730 err
= auxtrace_index__process_entry(fd
, head
, needs_swap
);
738 static int auxtrace_queues__process_index_entry(struct auxtrace_queues
*queues
,
739 struct perf_session
*session
,
740 struct auxtrace_index_entry
*ent
)
742 return auxtrace_queues__add_indexed_event(queues
, session
,
743 ent
->file_offset
, ent
->sz
);
746 int auxtrace_queues__process_index(struct auxtrace_queues
*queues
,
747 struct perf_session
*session
)
749 struct auxtrace_index
*auxtrace_index
;
750 struct auxtrace_index_entry
*ent
;
754 list_for_each_entry(auxtrace_index
, &session
->auxtrace_index
, list
) {
755 for (i
= 0; i
< auxtrace_index
->nr
; i
++) {
756 ent
= &auxtrace_index
->entries
[i
];
757 err
= auxtrace_queues__process_index_entry(queues
,
767 struct auxtrace_buffer
*auxtrace_buffer__next(struct auxtrace_queue
*queue
,
768 struct auxtrace_buffer
*buffer
)
771 if (list_is_last(&buffer
->list
, &queue
->head
))
773 return list_entry(buffer
->list
.next
, struct auxtrace_buffer
,
776 if (list_empty(&queue
->head
))
778 return list_entry(queue
->head
.next
, struct auxtrace_buffer
,
783 void *auxtrace_buffer__get_data(struct auxtrace_buffer
*buffer
, int fd
)
785 size_t adj
= buffer
->data_offset
& (page_size
- 1);
786 size_t size
= buffer
->size
+ adj
;
787 off_t file_offset
= buffer
->data_offset
- adj
;
793 addr
= mmap(NULL
, size
, PROT_READ
, MAP_SHARED
, fd
, file_offset
);
794 if (addr
== MAP_FAILED
)
797 buffer
->mmap_addr
= addr
;
798 buffer
->mmap_size
= size
;
800 buffer
->data
= addr
+ adj
;
805 void auxtrace_buffer__put_data(struct auxtrace_buffer
*buffer
)
807 if (!buffer
->data
|| !buffer
->mmap_addr
)
809 munmap(buffer
->mmap_addr
, buffer
->mmap_size
);
810 buffer
->mmap_addr
= NULL
;
811 buffer
->mmap_size
= 0;
813 buffer
->use_data
= NULL
;
816 void auxtrace_buffer__drop_data(struct auxtrace_buffer
*buffer
)
818 auxtrace_buffer__put_data(buffer
);
819 if (buffer
->data_needs_freeing
) {
820 buffer
->data_needs_freeing
= false;
821 zfree(&buffer
->data
);
822 buffer
->use_data
= NULL
;
827 void auxtrace_buffer__free(struct auxtrace_buffer
*buffer
)
829 auxtrace_buffer__drop_data(buffer
);
833 void auxtrace_synth_error(struct auxtrace_error_event
*auxtrace_error
, int type
,
834 int code
, int cpu
, pid_t pid
, pid_t tid
, u64 ip
,
839 memset(auxtrace_error
, 0, sizeof(struct auxtrace_error_event
));
841 auxtrace_error
->header
.type
= PERF_RECORD_AUXTRACE_ERROR
;
842 auxtrace_error
->type
= type
;
843 auxtrace_error
->code
= code
;
844 auxtrace_error
->cpu
= cpu
;
845 auxtrace_error
->pid
= pid
;
846 auxtrace_error
->tid
= tid
;
847 auxtrace_error
->ip
= ip
;
848 strlcpy(auxtrace_error
->msg
, msg
, MAX_AUXTRACE_ERROR_MSG
);
850 size
= (void *)auxtrace_error
->msg
- (void *)auxtrace_error
+
851 strlen(auxtrace_error
->msg
) + 1;
852 auxtrace_error
->header
.size
= PERF_ALIGN(size
, sizeof(u64
));
855 int perf_event__synthesize_auxtrace_info(struct auxtrace_record
*itr
,
856 struct perf_tool
*tool
,
857 struct perf_session
*session
,
858 perf_event__handler_t process
)
860 union perf_event
*ev
;
864 pr_debug2("Synthesizing auxtrace information\n");
865 priv_size
= auxtrace_record__info_priv_size(itr
, session
->evlist
);
866 ev
= zalloc(sizeof(struct auxtrace_info_event
) + priv_size
);
870 ev
->auxtrace_info
.header
.type
= PERF_RECORD_AUXTRACE_INFO
;
871 ev
->auxtrace_info
.header
.size
= sizeof(struct auxtrace_info_event
) +
873 err
= auxtrace_record__info_fill(itr
, session
, &ev
->auxtrace_info
,
878 err
= process(tool
, ev
, NULL
, NULL
);
884 static bool auxtrace__dont_decode(struct perf_session
*session
)
886 return !session
->itrace_synth_opts
||
887 session
->itrace_synth_opts
->dont_decode
;
890 int perf_event__process_auxtrace_info(struct perf_tool
*tool __maybe_unused
,
891 union perf_event
*event
,
892 struct perf_session
*session
)
894 enum auxtrace_type type
= event
->auxtrace_info
.type
;
897 fprintf(stdout
, " type: %u\n", type
);
900 case PERF_AUXTRACE_INTEL_PT
:
901 return intel_pt_process_auxtrace_info(event
, session
);
902 case PERF_AUXTRACE_INTEL_BTS
:
903 return intel_bts_process_auxtrace_info(event
, session
);
904 case PERF_AUXTRACE_CS_ETM
:
905 case PERF_AUXTRACE_UNKNOWN
:
911 s64
perf_event__process_auxtrace(struct perf_tool
*tool
,
912 union perf_event
*event
,
913 struct perf_session
*session
)
918 fprintf(stdout
, " size: %#"PRIx64
" offset: %#"PRIx64
" ref: %#"PRIx64
" idx: %u tid: %d cpu: %d\n",
919 event
->auxtrace
.size
, event
->auxtrace
.offset
,
920 event
->auxtrace
.reference
, event
->auxtrace
.idx
,
921 event
->auxtrace
.tid
, event
->auxtrace
.cpu
);
923 if (auxtrace__dont_decode(session
))
924 return event
->auxtrace
.size
;
926 if (!session
->auxtrace
|| event
->header
.type
!= PERF_RECORD_AUXTRACE
)
929 err
= session
->auxtrace
->process_auxtrace_event(session
, event
, tool
);
933 return event
->auxtrace
.size
;
936 #define PERF_ITRACE_DEFAULT_PERIOD_TYPE PERF_ITRACE_PERIOD_NANOSECS
937 #define PERF_ITRACE_DEFAULT_PERIOD 100000
938 #define PERF_ITRACE_DEFAULT_CALLCHAIN_SZ 16
939 #define PERF_ITRACE_MAX_CALLCHAIN_SZ 1024
940 #define PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ 64
941 #define PERF_ITRACE_MAX_LAST_BRANCH_SZ 1024
943 void itrace_synth_opts__set_default(struct itrace_synth_opts
*synth_opts
)
945 synth_opts
->instructions
= true;
946 synth_opts
->branches
= true;
947 synth_opts
->transactions
= true;
948 synth_opts
->errors
= true;
949 synth_opts
->period_type
= PERF_ITRACE_DEFAULT_PERIOD_TYPE
;
950 synth_opts
->period
= PERF_ITRACE_DEFAULT_PERIOD
;
951 synth_opts
->callchain_sz
= PERF_ITRACE_DEFAULT_CALLCHAIN_SZ
;
952 synth_opts
->last_branch_sz
= PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ
;
953 synth_opts
->initial_skip
= 0;
957 * Please check tools/perf/Documentation/perf-script.txt for information
958 * about the options parsed here, which is introduced after this cset,
959 * when support in 'perf script' for these options is introduced.
961 int itrace_parse_synth_opts(const struct option
*opt
, const char *str
,
964 struct itrace_synth_opts
*synth_opts
= opt
->value
;
967 bool period_type_set
= false;
968 bool period_set
= false;
970 synth_opts
->set
= true;
973 synth_opts
->dont_decode
= true;
978 itrace_synth_opts__set_default(synth_opts
);
985 synth_opts
->instructions
= true;
986 while (*p
== ' ' || *p
== ',')
989 synth_opts
->period
= strtoull(p
, &endptr
, 10);
992 while (*p
== ' ' || *p
== ',')
996 synth_opts
->period_type
=
997 PERF_ITRACE_PERIOD_INSTRUCTIONS
;
998 period_type_set
= true;
1001 synth_opts
->period_type
=
1002 PERF_ITRACE_PERIOD_TICKS
;
1003 period_type_set
= true;
1006 synth_opts
->period
*= 1000;
1009 synth_opts
->period
*= 1000;
1014 synth_opts
->period_type
=
1015 PERF_ITRACE_PERIOD_NANOSECS
;
1016 period_type_set
= true;
1026 synth_opts
->branches
= true;
1029 synth_opts
->transactions
= true;
1032 synth_opts
->errors
= true;
1035 synth_opts
->log
= true;
1038 synth_opts
->branches
= true;
1039 synth_opts
->calls
= true;
1042 synth_opts
->branches
= true;
1043 synth_opts
->returns
= true;
1046 synth_opts
->callchain
= true;
1047 synth_opts
->callchain_sz
=
1048 PERF_ITRACE_DEFAULT_CALLCHAIN_SZ
;
1049 while (*p
== ' ' || *p
== ',')
1054 val
= strtoul(p
, &endptr
, 10);
1056 if (!val
|| val
> PERF_ITRACE_MAX_CALLCHAIN_SZ
)
1058 synth_opts
->callchain_sz
= val
;
1062 synth_opts
->last_branch
= true;
1063 synth_opts
->last_branch_sz
=
1064 PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ
;
1065 while (*p
== ' ' || *p
== ',')
1070 val
= strtoul(p
, &endptr
, 10);
1073 val
> PERF_ITRACE_MAX_LAST_BRANCH_SZ
)
1075 synth_opts
->last_branch_sz
= val
;
1079 synth_opts
->initial_skip
= strtoul(p
, &endptr
, 10);
1092 if (synth_opts
->instructions
) {
1093 if (!period_type_set
)
1094 synth_opts
->period_type
=
1095 PERF_ITRACE_DEFAULT_PERIOD_TYPE
;
1097 synth_opts
->period
= PERF_ITRACE_DEFAULT_PERIOD
;
1103 pr_err("Bad Instruction Tracing options '%s'\n", str
);
1107 static const char * const auxtrace_error_type_name
[] = {
1108 [PERF_AUXTRACE_ERROR_ITRACE
] = "instruction trace",
1111 static const char *auxtrace_error_name(int type
)
1113 const char *error_type_name
= NULL
;
1115 if (type
< PERF_AUXTRACE_ERROR_MAX
)
1116 error_type_name
= auxtrace_error_type_name
[type
];
1117 if (!error_type_name
)
1118 error_type_name
= "unknown AUX";
1119 return error_type_name
;
1122 size_t perf_event__fprintf_auxtrace_error(union perf_event
*event
, FILE *fp
)
1124 struct auxtrace_error_event
*e
= &event
->auxtrace_error
;
1127 ret
= fprintf(fp
, " %s error type %u",
1128 auxtrace_error_name(e
->type
), e
->type
);
1129 ret
+= fprintf(fp
, " cpu %d pid %d tid %d ip %#"PRIx64
" code %u: %s\n",
1130 e
->cpu
, e
->pid
, e
->tid
, e
->ip
, e
->code
, e
->msg
);
1134 void perf_session__auxtrace_error_inc(struct perf_session
*session
,
1135 union perf_event
*event
)
1137 struct auxtrace_error_event
*e
= &event
->auxtrace_error
;
1139 if (e
->type
< PERF_AUXTRACE_ERROR_MAX
)
1140 session
->evlist
->stats
.nr_auxtrace_errors
[e
->type
] += 1;
1143 void events_stats__auxtrace_error_warn(const struct events_stats
*stats
)
1147 for (i
= 0; i
< PERF_AUXTRACE_ERROR_MAX
; i
++) {
1148 if (!stats
->nr_auxtrace_errors
[i
])
1150 ui__warning("%u %s errors\n",
1151 stats
->nr_auxtrace_errors
[i
],
1152 auxtrace_error_name(i
));
1156 int perf_event__process_auxtrace_error(struct perf_tool
*tool __maybe_unused
,
1157 union perf_event
*event
,
1158 struct perf_session
*session
)
1160 if (auxtrace__dont_decode(session
))
1163 perf_event__fprintf_auxtrace_error(event
, stdout
);
1167 static int __auxtrace_mmap__read(struct auxtrace_mmap
*mm
,
1168 struct auxtrace_record
*itr
,
1169 struct perf_tool
*tool
, process_auxtrace_t fn
,
1170 bool snapshot
, size_t snapshot_size
)
1172 u64 head
, old
= mm
->prev
, offset
, ref
;
1173 unsigned char *data
= mm
->base
;
1174 size_t size
, head_off
, old_off
, len1
, len2
, padding
;
1175 union perf_event ev
;
1176 void *data1
, *data2
;
1179 head
= auxtrace_mmap__read_snapshot_head(mm
);
1180 if (auxtrace_record__find_snapshot(itr
, mm
->idx
, mm
, data
,
1184 head
= auxtrace_mmap__read_head(mm
);
1190 pr_debug3("auxtrace idx %d old %#"PRIx64
" head %#"PRIx64
" diff %#"PRIx64
"\n",
1191 mm
->idx
, old
, head
, head
- old
);
1194 head_off
= head
& mm
->mask
;
1195 old_off
= old
& mm
->mask
;
1197 head_off
= head
% mm
->len
;
1198 old_off
= old
% mm
->len
;
1201 if (head_off
> old_off
)
1202 size
= head_off
- old_off
;
1204 size
= mm
->len
- (old_off
- head_off
);
1206 if (snapshot
&& size
> snapshot_size
)
1207 size
= snapshot_size
;
1209 ref
= auxtrace_record__reference(itr
);
1211 if (head
> old
|| size
<= head
|| mm
->mask
) {
1212 offset
= head
- size
;
1215 * When the buffer size is not a power of 2, 'head' wraps at the
1216 * highest multiple of the buffer size, so we have to subtract
1217 * the remainder here.
1219 u64 rem
= (0ULL - mm
->len
) % mm
->len
;
1221 offset
= head
- size
- rem
;
1224 if (size
> head_off
) {
1225 len1
= size
- head_off
;
1226 data1
= &data
[mm
->len
- len1
];
1231 data1
= &data
[head_off
- len1
];
1236 if (itr
->alignment
) {
1237 unsigned int unwanted
= len1
% itr
->alignment
;
1243 /* padding must be written by fn() e.g. record__process_auxtrace() */
1246 padding
= 8 - padding
;
1248 memset(&ev
, 0, sizeof(ev
));
1249 ev
.auxtrace
.header
.type
= PERF_RECORD_AUXTRACE
;
1250 ev
.auxtrace
.header
.size
= sizeof(ev
.auxtrace
);
1251 ev
.auxtrace
.size
= size
+ padding
;
1252 ev
.auxtrace
.offset
= offset
;
1253 ev
.auxtrace
.reference
= ref
;
1254 ev
.auxtrace
.idx
= mm
->idx
;
1255 ev
.auxtrace
.tid
= mm
->tid
;
1256 ev
.auxtrace
.cpu
= mm
->cpu
;
1258 if (fn(tool
, &ev
, data1
, len1
, data2
, len2
))
1264 auxtrace_mmap__write_tail(mm
, head
);
1265 if (itr
->read_finish
) {
1268 err
= itr
->read_finish(itr
, mm
->idx
);
1277 int auxtrace_mmap__read(struct auxtrace_mmap
*mm
, struct auxtrace_record
*itr
,
1278 struct perf_tool
*tool
, process_auxtrace_t fn
)
1280 return __auxtrace_mmap__read(mm
, itr
, tool
, fn
, false, 0);
1283 int auxtrace_mmap__read_snapshot(struct auxtrace_mmap
*mm
,
1284 struct auxtrace_record
*itr
,
1285 struct perf_tool
*tool
, process_auxtrace_t fn
,
1286 size_t snapshot_size
)
1288 return __auxtrace_mmap__read(mm
, itr
, tool
, fn
, true, snapshot_size
);
1292 * struct auxtrace_cache - hash table to implement a cache
1293 * @hashtable: the hashtable
1294 * @sz: hashtable size (number of hlists)
1295 * @entry_size: size of an entry
1296 * @limit: limit the number of entries to this maximum, when reached the cache
1297 * is dropped and caching begins again with an empty cache
1298 * @cnt: current number of entries
1299 * @bits: hashtable size (@sz = 2^@bits)
1301 struct auxtrace_cache
{
1302 struct hlist_head
*hashtable
;
1310 struct auxtrace_cache
*auxtrace_cache__new(unsigned int bits
, size_t entry_size
,
1311 unsigned int limit_percent
)
1313 struct auxtrace_cache
*c
;
1314 struct hlist_head
*ht
;
1317 c
= zalloc(sizeof(struct auxtrace_cache
));
1323 ht
= calloc(sz
, sizeof(struct hlist_head
));
1327 for (i
= 0; i
< sz
; i
++)
1328 INIT_HLIST_HEAD(&ht
[i
]);
1332 c
->entry_size
= entry_size
;
1333 c
->limit
= (c
->sz
* limit_percent
) / 100;
1343 static void auxtrace_cache__drop(struct auxtrace_cache
*c
)
1345 struct auxtrace_cache_entry
*entry
;
1346 struct hlist_node
*tmp
;
1352 for (i
= 0; i
< c
->sz
; i
++) {
1353 hlist_for_each_entry_safe(entry
, tmp
, &c
->hashtable
[i
], hash
) {
1354 hlist_del(&entry
->hash
);
1355 auxtrace_cache__free_entry(c
, entry
);
1362 void auxtrace_cache__free(struct auxtrace_cache
*c
)
1367 auxtrace_cache__drop(c
);
1372 void *auxtrace_cache__alloc_entry(struct auxtrace_cache
*c
)
1374 return malloc(c
->entry_size
);
1377 void auxtrace_cache__free_entry(struct auxtrace_cache
*c __maybe_unused
,
1383 int auxtrace_cache__add(struct auxtrace_cache
*c
, u32 key
,
1384 struct auxtrace_cache_entry
*entry
)
1386 if (c
->limit
&& ++c
->cnt
> c
->limit
)
1387 auxtrace_cache__drop(c
);
1390 hlist_add_head(&entry
->hash
, &c
->hashtable
[hash_32(key
, c
->bits
)]);
1395 void *auxtrace_cache__lookup(struct auxtrace_cache
*c
, u32 key
)
1397 struct auxtrace_cache_entry
*entry
;
1398 struct hlist_head
*hlist
;
1403 hlist
= &c
->hashtable
[hash_32(key
, c
->bits
)];
1404 hlist_for_each_entry(entry
, hlist
, hash
) {
1405 if (entry
->key
== key
)
1412 static void addr_filter__free_str(struct addr_filter
*filt
)
1415 filt
->action
= NULL
;
1416 filt
->sym_from
= NULL
;
1417 filt
->sym_to
= NULL
;
1418 filt
->filename
= NULL
;
1422 static struct addr_filter
*addr_filter__new(void)
1424 struct addr_filter
*filt
= zalloc(sizeof(*filt
));
1427 INIT_LIST_HEAD(&filt
->list
);
1432 static void addr_filter__free(struct addr_filter
*filt
)
1435 addr_filter__free_str(filt
);
1439 static void addr_filters__add(struct addr_filters
*filts
,
1440 struct addr_filter
*filt
)
1442 list_add_tail(&filt
->list
, &filts
->head
);
1446 static void addr_filters__del(struct addr_filters
*filts
,
1447 struct addr_filter
*filt
)
1449 list_del_init(&filt
->list
);
1453 void addr_filters__init(struct addr_filters
*filts
)
1455 INIT_LIST_HEAD(&filts
->head
);
1459 void addr_filters__exit(struct addr_filters
*filts
)
1461 struct addr_filter
*filt
, *n
;
1463 list_for_each_entry_safe(filt
, n
, &filts
->head
, list
) {
1464 addr_filters__del(filts
, filt
);
1465 addr_filter__free(filt
);
1469 static int parse_num_or_str(char **inp
, u64
*num
, const char **str
,
1470 const char *str_delim
)
1472 *inp
+= strspn(*inp
, " ");
1474 if (isdigit(**inp
)) {
1480 *num
= strtoull(*inp
, &endptr
, 0);
1491 *inp
+= strspn(*inp
, " ");
1493 n
= strcspn(*inp
, str_delim
);
1505 static int parse_action(struct addr_filter
*filt
)
1507 if (!strcmp(filt
->action
, "filter")) {
1510 } else if (!strcmp(filt
->action
, "start")) {
1512 } else if (!strcmp(filt
->action
, "stop")) {
1513 filt
->start
= false;
1514 } else if (!strcmp(filt
->action
, "tracestop")) {
1515 filt
->start
= false;
1517 filt
->action
+= 5; /* Change 'tracestop' to 'stop' */
1524 static int parse_sym_idx(char **inp
, int *idx
)
1528 *inp
+= strspn(*inp
, " ");
1535 if (**inp
== 'g' || **inp
== 'G') {
1543 num
= strtoul(*inp
, &endptr
, 0);
1546 if (endptr
== *inp
|| num
> INT_MAX
)
1555 static int parse_addr_size(char **inp
, u64
*num
, const char **str
, int *idx
)
1557 int err
= parse_num_or_str(inp
, num
, str
, " ");
1560 err
= parse_sym_idx(inp
, idx
);
1565 static int parse_one_filter(struct addr_filter
*filt
, const char **filter_inp
)
1570 filt
->str
= fstr
= strdup(*filter_inp
);
1574 err
= parse_num_or_str(&fstr
, NULL
, &filt
->action
, " ");
1578 err
= parse_action(filt
);
1582 err
= parse_addr_size(&fstr
, &filt
->addr
, &filt
->sym_from
,
1583 &filt
->sym_from_idx
);
1587 fstr
+= strspn(fstr
, " ");
1591 err
= parse_addr_size(&fstr
, &filt
->size
, &filt
->sym_to
,
1598 fstr
+= strspn(fstr
, " ");
1602 err
= parse_num_or_str(&fstr
, NULL
, &filt
->filename
, " ,");
1607 fstr
+= strspn(fstr
, " ,");
1609 *filter_inp
+= fstr
- filt
->str
;
1614 addr_filter__free_str(filt
);
1619 int addr_filters__parse_bare_filter(struct addr_filters
*filts
,
1622 struct addr_filter
*filt
;
1623 const char *fstr
= filter
;
1627 filt
= addr_filter__new();
1628 err
= parse_one_filter(filt
, &fstr
);
1630 addr_filter__free(filt
);
1631 addr_filters__exit(filts
);
1634 addr_filters__add(filts
, filt
);
1653 static bool kern_sym_match(struct sym_args
*args
, const char *name
, char type
)
1655 /* A function with the same name, and global or the n'th found or any */
1656 return symbol_type__is_a(type
, MAP__FUNCTION
) &&
1657 !strcmp(name
, args
->name
) &&
1658 ((args
->global
&& isupper(type
)) ||
1659 (args
->selected
&& ++(args
->cnt
) == args
->idx
) ||
1660 (!args
->global
&& !args
->selected
));
1663 static int find_kern_sym_cb(void *arg
, const char *name
, char type
, u64 start
)
1665 struct sym_args
*args
= arg
;
1667 if (args
->started
) {
1669 args
->size
= start
- args
->start
;
1670 if (args
->selected
) {
1673 } else if (kern_sym_match(args
, name
, type
)) {
1674 args
->duplicate
= true;
1677 } else if (kern_sym_match(args
, name
, type
)) {
1678 args
->started
= true;
1679 args
->start
= start
;
1685 static int print_kern_sym_cb(void *arg
, const char *name
, char type
, u64 start
)
1687 struct sym_args
*args
= arg
;
1689 if (kern_sym_match(args
, name
, type
)) {
1690 pr_err("#%d\t0x%"PRIx64
"\t%c\t%s\n",
1691 ++args
->cnt
, start
, type
, name
);
1693 } else if (args
->near
) {
1695 pr_err("\t\twhich is near\t\t%s\n", name
);
1701 static int sym_not_found_error(const char *sym_name
, int idx
)
1704 pr_err("N'th occurrence (N=%d) of symbol '%s' not found.\n",
1707 pr_err("Global symbol '%s' not found.\n", sym_name
);
1709 pr_err("Symbol '%s' not found.\n", sym_name
);
1711 pr_err("Note that symbols must be functions.\n");
1716 static int find_kern_sym(const char *sym_name
, u64
*start
, u64
*size
, int idx
)
1718 struct sym_args args
= {
1722 .selected
= idx
> 0,
1729 err
= kallsyms__parse("/proc/kallsyms", &args
, find_kern_sym_cb
);
1731 pr_err("Failed to parse /proc/kallsyms\n");
1735 if (args
.duplicate
) {
1736 pr_err("Multiple kernel symbols with name '%s'\n", sym_name
);
1738 kallsyms__parse("/proc/kallsyms", &args
, print_kern_sym_cb
);
1739 pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
1741 pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
1745 if (!args
.started
) {
1746 pr_err("Kernel symbol lookup: ");
1747 return sym_not_found_error(sym_name
, idx
);
1750 *start
= args
.start
;
1756 static int find_entire_kern_cb(void *arg
, const char *name __maybe_unused
,
1757 char type
, u64 start
)
1759 struct sym_args
*args
= arg
;
1761 if (!symbol_type__is_a(type
, MAP__FUNCTION
))
1764 if (!args
->started
) {
1765 args
->started
= true;
1766 args
->start
= start
;
1768 /* Don't know exactly where the kernel ends, so we add a page */
1769 args
->size
= round_up(start
, page_size
) + page_size
- args
->start
;
1774 static int addr_filter__entire_kernel(struct addr_filter
*filt
)
1776 struct sym_args args
= { .started
= false };
1779 err
= kallsyms__parse("/proc/kallsyms", &args
, find_entire_kern_cb
);
1780 if (err
< 0 || !args
.started
) {
1781 pr_err("Failed to parse /proc/kallsyms\n");
1785 filt
->addr
= args
.start
;
1786 filt
->size
= args
.size
;
1791 static int check_end_after_start(struct addr_filter
*filt
, u64 start
, u64 size
)
1793 if (start
+ size
>= filt
->addr
)
1796 if (filt
->sym_from
) {
1797 pr_err("Symbol '%s' (0x%"PRIx64
") comes before '%s' (0x%"PRIx64
")\n",
1798 filt
->sym_to
, start
, filt
->sym_from
, filt
->addr
);
1800 pr_err("Symbol '%s' (0x%"PRIx64
") comes before address 0x%"PRIx64
")\n",
1801 filt
->sym_to
, start
, filt
->addr
);
1807 static int addr_filter__resolve_kernel_syms(struct addr_filter
*filt
)
1809 bool no_size
= false;
1813 if (symbol_conf
.kptr_restrict
) {
1814 pr_err("Kernel addresses are restricted. Unable to resolve kernel symbols.\n");
1818 if (filt
->sym_from
&& !strcmp(filt
->sym_from
, "*"))
1819 return addr_filter__entire_kernel(filt
);
1821 if (filt
->sym_from
) {
1822 err
= find_kern_sym(filt
->sym_from
, &start
, &size
,
1823 filt
->sym_from_idx
);
1827 if (filt
->range
&& !filt
->size
&& !filt
->sym_to
) {
1834 err
= find_kern_sym(filt
->sym_to
, &start
, &size
,
1839 err
= check_end_after_start(filt
, start
, size
);
1842 filt
->size
= start
+ size
- filt
->addr
;
1846 /* The very last symbol in kallsyms does not imply a particular size */
1848 pr_err("Cannot determine size of symbol '%s'\n",
1849 filt
->sym_to
? filt
->sym_to
: filt
->sym_from
);
1856 static struct dso
*load_dso(const char *name
)
1861 map
= dso__new_map(name
);
1867 dso
= dso__get(map
->dso
);
1874 static bool dso_sym_match(struct symbol
*sym
, const char *name
, int *cnt
,
1877 /* Same name, and global or the n'th found or any */
1878 return !arch__compare_symbol_names(name
, sym
->name
) &&
1879 ((!idx
&& sym
->binding
== STB_GLOBAL
) ||
1880 (idx
> 0 && ++*cnt
== idx
) ||
1884 static void print_duplicate_syms(struct dso
*dso
, const char *sym_name
)
1890 pr_err("Multiple symbols with name '%s'\n", sym_name
);
1892 sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
1894 if (dso_sym_match(sym
, sym_name
, &cnt
, -1)) {
1895 pr_err("#%d\t0x%"PRIx64
"\t%c\t%s\n",
1897 sym
->binding
== STB_GLOBAL
? 'g' :
1898 sym
->binding
== STB_LOCAL
? 'l' : 'w',
1903 pr_err("\t\twhich is near\t\t%s\n", sym
->name
);
1905 sym
= dso__next_symbol(sym
);
1908 pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
1910 pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
1913 static int find_dso_sym(struct dso
*dso
, const char *sym_name
, u64
*start
,
1922 sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
1926 *size
= sym
->start
- *start
;
1930 } else if (dso_sym_match(sym
, sym_name
, &cnt
, idx
)) {
1931 print_duplicate_syms(dso
, sym_name
);
1934 } else if (dso_sym_match(sym
, sym_name
, &cnt
, idx
)) {
1935 *start
= sym
->start
;
1936 *size
= sym
->end
- sym
->start
;
1938 sym
= dso__next_symbol(sym
);
1942 return sym_not_found_error(sym_name
, idx
);
1947 static int addr_filter__entire_dso(struct addr_filter
*filt
, struct dso
*dso
)
1949 struct symbol
*first_sym
= dso__first_symbol(dso
, MAP__FUNCTION
);
1950 struct symbol
*last_sym
= dso__last_symbol(dso
, MAP__FUNCTION
);
1952 if (!first_sym
|| !last_sym
) {
1953 pr_err("Failed to determine filter for %s\nNo symbols found.\n",
1958 filt
->addr
= first_sym
->start
;
1959 filt
->size
= last_sym
->end
- first_sym
->start
;
1964 static int addr_filter__resolve_syms(struct addr_filter
*filt
)
1970 if (!filt
->sym_from
&& !filt
->sym_to
)
1973 if (!filt
->filename
)
1974 return addr_filter__resolve_kernel_syms(filt
);
1976 dso
= load_dso(filt
->filename
);
1978 pr_err("Failed to load symbols from: %s\n", filt
->filename
);
1982 if (filt
->sym_from
&& !strcmp(filt
->sym_from
, "*")) {
1983 err
= addr_filter__entire_dso(filt
, dso
);
1987 if (filt
->sym_from
) {
1988 err
= find_dso_sym(dso
, filt
->sym_from
, &start
, &size
,
1989 filt
->sym_from_idx
);
1993 if (filt
->range
&& !filt
->size
&& !filt
->sym_to
)
1998 err
= find_dso_sym(dso
, filt
->sym_to
, &start
, &size
,
2003 err
= check_end_after_start(filt
, start
, size
);
2007 filt
->size
= start
+ size
- filt
->addr
;
2016 static char *addr_filter__to_str(struct addr_filter
*filt
)
2018 char filename_buf
[PATH_MAX
];
2019 const char *at
= "";
2020 const char *fn
= "";
2024 if (filt
->filename
) {
2026 fn
= realpath(filt
->filename
, filename_buf
);
2032 err
= asprintf(&filter
, "%s 0x%"PRIx64
"/0x%"PRIx64
"%s%s",
2033 filt
->action
, filt
->addr
, filt
->size
, at
, fn
);
2035 err
= asprintf(&filter
, "%s 0x%"PRIx64
"%s%s",
2036 filt
->action
, filt
->addr
, at
, fn
);
2039 return err
< 0 ? NULL
: filter
;
2042 static int parse_addr_filter(struct perf_evsel
*evsel
, const char *filter
,
2045 struct addr_filters filts
;
2046 struct addr_filter
*filt
;
2049 addr_filters__init(&filts
);
2051 err
= addr_filters__parse_bare_filter(&filts
, filter
);
2055 if (filts
.cnt
> max_nr
) {
2056 pr_err("Error: number of address filters (%d) exceeds maximum (%d)\n",
2062 list_for_each_entry(filt
, &filts
.head
, list
) {
2065 err
= addr_filter__resolve_syms(filt
);
2069 new_filter
= addr_filter__to_str(filt
);
2075 if (perf_evsel__append_addr_filter(evsel
, new_filter
)) {
2082 addr_filters__exit(&filts
);
2085 pr_err("Failed to parse address filter: '%s'\n", filter
);
2086 pr_err("Filter format is: filter|start|stop|tracestop <start symbol or address> [/ <end symbol or size>] [@<file name>]\n");
2087 pr_err("Where multiple filters are separated by space or comma.\n");
2093 static struct perf_pmu
*perf_evsel__find_pmu(struct perf_evsel
*evsel
)
2095 struct perf_pmu
*pmu
= NULL
;
2097 while ((pmu
= perf_pmu__scan(pmu
)) != NULL
) {
2098 if (pmu
->type
== evsel
->attr
.type
)
2105 static int perf_evsel__nr_addr_filter(struct perf_evsel
*evsel
)
2107 struct perf_pmu
*pmu
= perf_evsel__find_pmu(evsel
);
2108 int nr_addr_filters
= 0;
2113 perf_pmu__scan_file(pmu
, "nr_addr_filters", "%d", &nr_addr_filters
);
2115 return nr_addr_filters
;
2118 int auxtrace_parse_filters(struct perf_evlist
*evlist
)
2120 struct perf_evsel
*evsel
;
2124 evlist__for_each_entry(evlist
, evsel
) {
2125 filter
= evsel
->filter
;
2126 max_nr
= perf_evsel__nr_addr_filter(evsel
);
2127 if (!filter
|| !max_nr
)
2129 evsel
->filter
= NULL
;
2130 err
= parse_addr_filter(evsel
, filter
, max_nr
);
2134 pr_debug("Address filter: %s\n", evsel
->filter
);