1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
5 * Parts came from builtin-{top,stat,record}.c, see those files for further
13 #include "util/mmap.h"
14 #include "thread_map.h"
20 #include <internal/lib.h> // page_size
23 #include "bpf-event.h"
24 #include "util/string2.h"
30 #include "parse-events.h"
31 #include <subcmd/parse-options.h>
34 #include <sys/ioctl.h>
37 #include <linux/bitops.h>
38 #include <linux/hash.h>
39 #include <linux/log2.h>
40 #include <linux/err.h>
41 #include <linux/string.h>
42 #include <linux/zalloc.h>
43 #include <perf/evlist.h>
44 #include <perf/evsel.h>
45 #include <perf/cpumap.h>
46 #include <perf/mmap.h>
48 #include <internal/xyarray.h>
50 #ifdef LACKS_SIGQUEUE_PROTOTYPE
51 int sigqueue(pid_t pid
, int sig
, const union sigval value
);
54 #define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
55 #define SID(e, x, y) xyarray__entry(e->core.sample_id, x, y)
57 void evlist__init(struct evlist
*evlist
, struct perf_cpu_map
*cpus
,
58 struct perf_thread_map
*threads
)
60 perf_evlist__init(&evlist
->core
);
61 perf_evlist__set_maps(&evlist
->core
, cpus
, threads
);
62 evlist
->workload
.pid
= -1;
63 evlist
->bkw_mmap_state
= BKW_MMAP_NOTREADY
;
66 struct evlist
*evlist__new(void)
68 struct evlist
*evlist
= zalloc(sizeof(*evlist
));
71 evlist__init(evlist
, NULL
, NULL
);
76 struct evlist
*perf_evlist__new_default(void)
78 struct evlist
*evlist
= evlist__new();
80 if (evlist
&& perf_evlist__add_default(evlist
)) {
81 evlist__delete(evlist
);
88 struct evlist
*perf_evlist__new_dummy(void)
90 struct evlist
*evlist
= evlist__new();
92 if (evlist
&& perf_evlist__add_dummy(evlist
)) {
93 evlist__delete(evlist
);
101 * perf_evlist__set_id_pos - set the positions of event ids.
102 * @evlist: selected event list
104 * Events with compatible sample types all have the same id_pos
105 * and is_pos. For convenience, put a copy on evlist.
107 void perf_evlist__set_id_pos(struct evlist
*evlist
)
109 struct evsel
*first
= evlist__first(evlist
);
111 evlist
->id_pos
= first
->id_pos
;
112 evlist
->is_pos
= first
->is_pos
;
115 static void perf_evlist__update_id_pos(struct evlist
*evlist
)
119 evlist__for_each_entry(evlist
, evsel
)
120 perf_evsel__calc_id_pos(evsel
);
122 perf_evlist__set_id_pos(evlist
);
125 static void evlist__purge(struct evlist
*evlist
)
127 struct evsel
*pos
, *n
;
129 evlist__for_each_entry_safe(evlist
, n
, pos
) {
130 list_del_init(&pos
->core
.node
);
135 evlist
->core
.nr_entries
= 0;
138 void evlist__exit(struct evlist
*evlist
)
140 zfree(&evlist
->mmap
);
141 zfree(&evlist
->overwrite_mmap
);
142 perf_evlist__exit(&evlist
->core
);
145 void evlist__delete(struct evlist
*evlist
)
150 evlist__munmap(evlist
);
151 evlist__close(evlist
);
152 evlist__purge(evlist
);
153 evlist__exit(evlist
);
157 void evlist__add(struct evlist
*evlist
, struct evsel
*entry
)
159 entry
->evlist
= evlist
;
160 entry
->idx
= evlist
->core
.nr_entries
;
161 entry
->tracking
= !entry
->idx
;
163 perf_evlist__add(&evlist
->core
, &entry
->core
);
165 if (evlist
->core
.nr_entries
== 1)
166 perf_evlist__set_id_pos(evlist
);
169 void evlist__remove(struct evlist
*evlist
, struct evsel
*evsel
)
171 evsel
->evlist
= NULL
;
172 perf_evlist__remove(&evlist
->core
, &evsel
->core
);
175 void perf_evlist__splice_list_tail(struct evlist
*evlist
,
176 struct list_head
*list
)
178 struct evsel
*evsel
, *temp
;
180 __evlist__for_each_entry_safe(list
, temp
, evsel
) {
181 list_del_init(&evsel
->core
.node
);
182 evlist__add(evlist
, evsel
);
186 int __evlist__set_tracepoints_handlers(struct evlist
*evlist
,
187 const struct evsel_str_handler
*assocs
, size_t nr_assocs
)
193 for (i
= 0; i
< nr_assocs
; i
++) {
194 // Adding a handler for an event not in this evlist, just ignore it.
195 evsel
= perf_evlist__find_tracepoint_by_name(evlist
, assocs
[i
].name
);
200 if (evsel
->handler
!= NULL
)
202 evsel
->handler
= assocs
[i
].handler
;
210 void __perf_evlist__set_leader(struct list_head
*list
)
212 struct evsel
*evsel
, *leader
;
214 leader
= list_entry(list
->next
, struct evsel
, core
.node
);
215 evsel
= list_entry(list
->prev
, struct evsel
, core
.node
);
217 leader
->core
.nr_members
= evsel
->idx
- leader
->idx
+ 1;
219 __evlist__for_each_entry(list
, evsel
) {
220 evsel
->leader
= leader
;
224 void perf_evlist__set_leader(struct evlist
*evlist
)
226 if (evlist
->core
.nr_entries
) {
227 evlist
->nr_groups
= evlist
->core
.nr_entries
> 1 ? 1 : 0;
228 __perf_evlist__set_leader(&evlist
->core
.entries
);
232 int __perf_evlist__add_default(struct evlist
*evlist
, bool precise
)
234 struct evsel
*evsel
= perf_evsel__new_cycles(precise
);
239 evlist__add(evlist
, evsel
);
243 int perf_evlist__add_dummy(struct evlist
*evlist
)
245 struct perf_event_attr attr
= {
246 .type
= PERF_TYPE_SOFTWARE
,
247 .config
= PERF_COUNT_SW_DUMMY
,
248 .size
= sizeof(attr
), /* to capture ABI version */
250 struct evsel
*evsel
= perf_evsel__new_idx(&attr
, evlist
->core
.nr_entries
);
255 evlist__add(evlist
, evsel
);
259 static int evlist__add_attrs(struct evlist
*evlist
,
260 struct perf_event_attr
*attrs
, size_t nr_attrs
)
262 struct evsel
*evsel
, *n
;
266 for (i
= 0; i
< nr_attrs
; i
++) {
267 evsel
= perf_evsel__new_idx(attrs
+ i
, evlist
->core
.nr_entries
+ i
);
269 goto out_delete_partial_list
;
270 list_add_tail(&evsel
->core
.node
, &head
);
273 perf_evlist__splice_list_tail(evlist
, &head
);
277 out_delete_partial_list
:
278 __evlist__for_each_entry_safe(&head
, n
, evsel
)
279 evsel__delete(evsel
);
283 int __perf_evlist__add_default_attrs(struct evlist
*evlist
,
284 struct perf_event_attr
*attrs
, size_t nr_attrs
)
288 for (i
= 0; i
< nr_attrs
; i
++)
289 event_attr_init(attrs
+ i
);
291 return evlist__add_attrs(evlist
, attrs
, nr_attrs
);
295 perf_evlist__find_tracepoint_by_id(struct evlist
*evlist
, int id
)
299 evlist__for_each_entry(evlist
, evsel
) {
300 if (evsel
->core
.attr
.type
== PERF_TYPE_TRACEPOINT
&&
301 (int)evsel
->core
.attr
.config
== id
)
309 perf_evlist__find_tracepoint_by_name(struct evlist
*evlist
,
314 evlist__for_each_entry(evlist
, evsel
) {
315 if ((evsel
->core
.attr
.type
== PERF_TYPE_TRACEPOINT
) &&
316 (strcmp(evsel
->name
, name
) == 0))
323 int perf_evlist__add_newtp(struct evlist
*evlist
,
324 const char *sys
, const char *name
, void *handler
)
326 struct evsel
*evsel
= perf_evsel__newtp(sys
, name
);
331 evsel
->handler
= handler
;
332 evlist__add(evlist
, evsel
);
336 static int perf_evlist__nr_threads(struct evlist
*evlist
,
339 if (evsel
->core
.system_wide
)
342 return perf_thread_map__nr(evlist
->core
.threads
);
345 void evlist__disable(struct evlist
*evlist
)
349 evlist__for_each_entry(evlist
, pos
) {
350 if (pos
->disabled
|| !perf_evsel__is_group_leader(pos
) || !pos
->core
.fd
)
355 evlist
->enabled
= false;
358 void evlist__enable(struct evlist
*evlist
)
362 evlist__for_each_entry(evlist
, pos
) {
363 if (!perf_evsel__is_group_leader(pos
) || !pos
->core
.fd
)
368 evlist
->enabled
= true;
371 void perf_evlist__toggle_enable(struct evlist
*evlist
)
373 (evlist
->enabled
? evlist__disable
: evlist__enable
)(evlist
);
376 static int perf_evlist__enable_event_cpu(struct evlist
*evlist
,
377 struct evsel
*evsel
, int cpu
)
380 int nr_threads
= perf_evlist__nr_threads(evlist
, evsel
);
385 for (thread
= 0; thread
< nr_threads
; thread
++) {
386 int err
= ioctl(FD(evsel
, cpu
, thread
), PERF_EVENT_IOC_ENABLE
, 0);
393 static int perf_evlist__enable_event_thread(struct evlist
*evlist
,
398 int nr_cpus
= perf_cpu_map__nr(evlist
->core
.cpus
);
403 for (cpu
= 0; cpu
< nr_cpus
; cpu
++) {
404 int err
= ioctl(FD(evsel
, cpu
, thread
), PERF_EVENT_IOC_ENABLE
, 0);
411 int perf_evlist__enable_event_idx(struct evlist
*evlist
,
412 struct evsel
*evsel
, int idx
)
414 bool per_cpu_mmaps
= !perf_cpu_map__empty(evlist
->core
.cpus
);
417 return perf_evlist__enable_event_cpu(evlist
, evsel
, idx
);
419 return perf_evlist__enable_event_thread(evlist
, evsel
, idx
);
422 int evlist__add_pollfd(struct evlist
*evlist
, int fd
)
424 return perf_evlist__add_pollfd(&evlist
->core
, fd
, NULL
, POLLIN
);
427 int evlist__filter_pollfd(struct evlist
*evlist
, short revents_and_mask
)
429 return perf_evlist__filter_pollfd(&evlist
->core
, revents_and_mask
);
432 int evlist__poll(struct evlist
*evlist
, int timeout
)
434 return perf_evlist__poll(&evlist
->core
, timeout
);
437 struct perf_sample_id
*perf_evlist__id2sid(struct evlist
*evlist
, u64 id
)
439 struct hlist_head
*head
;
440 struct perf_sample_id
*sid
;
443 hash
= hash_64(id
, PERF_EVLIST__HLIST_BITS
);
444 head
= &evlist
->core
.heads
[hash
];
446 hlist_for_each_entry(sid
, head
, node
)
453 struct evsel
*perf_evlist__id2evsel(struct evlist
*evlist
, u64 id
)
455 struct perf_sample_id
*sid
;
457 if (evlist
->core
.nr_entries
== 1 || !id
)
458 return evlist__first(evlist
);
460 sid
= perf_evlist__id2sid(evlist
, id
);
462 return container_of(sid
->evsel
, struct evsel
, core
);
464 if (!perf_evlist__sample_id_all(evlist
))
465 return evlist__first(evlist
);
470 struct evsel
*perf_evlist__id2evsel_strict(struct evlist
*evlist
,
473 struct perf_sample_id
*sid
;
478 sid
= perf_evlist__id2sid(evlist
, id
);
480 return container_of(sid
->evsel
, struct evsel
, core
);
485 static int perf_evlist__event2id(struct evlist
*evlist
,
486 union perf_event
*event
, u64
*id
)
488 const __u64
*array
= event
->sample
.array
;
491 n
= (event
->header
.size
- sizeof(event
->header
)) >> 3;
493 if (event
->header
.type
== PERF_RECORD_SAMPLE
) {
494 if (evlist
->id_pos
>= n
)
496 *id
= array
[evlist
->id_pos
];
498 if (evlist
->is_pos
> n
)
506 struct evsel
*perf_evlist__event2evsel(struct evlist
*evlist
,
507 union perf_event
*event
)
509 struct evsel
*first
= evlist__first(evlist
);
510 struct hlist_head
*head
;
511 struct perf_sample_id
*sid
;
515 if (evlist
->core
.nr_entries
== 1)
518 if (!first
->core
.attr
.sample_id_all
&&
519 event
->header
.type
!= PERF_RECORD_SAMPLE
)
522 if (perf_evlist__event2id(evlist
, event
, &id
))
525 /* Synthesized events have an id of zero */
529 hash
= hash_64(id
, PERF_EVLIST__HLIST_BITS
);
530 head
= &evlist
->core
.heads
[hash
];
532 hlist_for_each_entry(sid
, head
, node
) {
534 return container_of(sid
->evsel
, struct evsel
, core
);
539 static int perf_evlist__set_paused(struct evlist
*evlist
, bool value
)
543 if (!evlist
->overwrite_mmap
)
546 for (i
= 0; i
< evlist
->core
.nr_mmaps
; i
++) {
547 int fd
= evlist
->overwrite_mmap
[i
].core
.fd
;
552 err
= ioctl(fd
, PERF_EVENT_IOC_PAUSE_OUTPUT
, value
? 1 : 0);
559 static int perf_evlist__pause(struct evlist
*evlist
)
561 return perf_evlist__set_paused(evlist
, true);
564 static int perf_evlist__resume(struct evlist
*evlist
)
566 return perf_evlist__set_paused(evlist
, false);
569 static void evlist__munmap_nofree(struct evlist
*evlist
)
574 for (i
= 0; i
< evlist
->core
.nr_mmaps
; i
++)
575 perf_mmap__munmap(&evlist
->mmap
[i
].core
);
577 if (evlist
->overwrite_mmap
)
578 for (i
= 0; i
< evlist
->core
.nr_mmaps
; i
++)
579 perf_mmap__munmap(&evlist
->overwrite_mmap
[i
].core
);
582 void evlist__munmap(struct evlist
*evlist
)
584 evlist__munmap_nofree(evlist
);
585 zfree(&evlist
->mmap
);
586 zfree(&evlist
->overwrite_mmap
);
589 static void perf_mmap__unmap_cb(struct perf_mmap
*map
)
591 struct mmap
*m
= container_of(map
, struct mmap
, core
);
596 static struct mmap
*evlist__alloc_mmap(struct evlist
*evlist
,
602 map
= zalloc(evlist
->core
.nr_mmaps
* sizeof(struct mmap
));
606 for (i
= 0; i
< evlist
->core
.nr_mmaps
; i
++) {
607 struct perf_mmap
*prev
= i
? &map
[i
- 1].core
: NULL
;
610 * When the perf_mmap() call is made we grab one refcount, plus
611 * one extra to let perf_mmap__consume() get the last
612 * events after all real references (perf_mmap__get()) are
615 * Each PERF_EVENT_IOC_SET_OUTPUT points to this mmap and
616 * thus does perf_mmap__get() on it.
618 perf_mmap__init(&map
[i
].core
, prev
, overwrite
, perf_mmap__unmap_cb
);
625 perf_evlist__mmap_cb_idx(struct perf_evlist
*_evlist
,
626 struct perf_mmap_param
*_mp
,
627 int idx
, bool per_cpu
)
629 struct evlist
*evlist
= container_of(_evlist
, struct evlist
, core
);
630 struct mmap_params
*mp
= container_of(_mp
, struct mmap_params
, core
);
632 auxtrace_mmap_params__set_idx(&mp
->auxtrace_mp
, evlist
, idx
, per_cpu
);
635 static struct perf_mmap
*
636 perf_evlist__mmap_cb_get(struct perf_evlist
*_evlist
, bool overwrite
, int idx
)
638 struct evlist
*evlist
= container_of(_evlist
, struct evlist
, core
);
641 maps
= overwrite
? evlist
->overwrite_mmap
: evlist
->mmap
;
644 maps
= evlist__alloc_mmap(evlist
, overwrite
);
649 evlist
->overwrite_mmap
= maps
;
650 if (evlist
->bkw_mmap_state
== BKW_MMAP_NOTREADY
)
651 perf_evlist__toggle_bkw_mmap(evlist
, BKW_MMAP_RUNNING
);
657 return &maps
[idx
].core
;
661 perf_evlist__mmap_cb_mmap(struct perf_mmap
*_map
, struct perf_mmap_param
*_mp
,
664 struct mmap
*map
= container_of(_map
, struct mmap
, core
);
665 struct mmap_params
*mp
= container_of(_mp
, struct mmap_params
, core
);
667 return mmap__mmap(map
, mp
, output
, cpu
);
670 unsigned long perf_event_mlock_kb_in_pages(void)
675 if (sysctl__read_int("kernel/perf_event_mlock_kb", &max
) < 0) {
677 * Pick a once upon a time good value, i.e. things look
678 * strange since we can't read a sysctl value, but lets not
683 max
-= (page_size
/ 1024);
686 pages
= (max
* 1024) / page_size
;
687 if (!is_power_of_2(pages
))
688 pages
= rounddown_pow_of_two(pages
);
693 size_t evlist__mmap_size(unsigned long pages
)
695 if (pages
== UINT_MAX
)
696 pages
= perf_event_mlock_kb_in_pages();
697 else if (!is_power_of_2(pages
))
700 return (pages
+ 1) * page_size
;
703 static long parse_pages_arg(const char *str
, unsigned long min
,
706 unsigned long pages
, val
;
707 static struct parse_tag tags
[] = {
708 { .tag
= 'B', .mult
= 1 },
709 { .tag
= 'K', .mult
= 1 << 10 },
710 { .tag
= 'M', .mult
= 1 << 20 },
711 { .tag
= 'G', .mult
= 1 << 30 },
718 val
= parse_tag_value(str
, tags
);
719 if (val
!= (unsigned long) -1) {
720 /* we got file size value */
721 pages
= PERF_ALIGN(val
, page_size
) / page_size
;
723 /* we got pages count value */
725 pages
= strtoul(str
, &eptr
, 10);
730 if (pages
== 0 && min
== 0) {
731 /* leave number of pages at 0 */
732 } else if (!is_power_of_2(pages
)) {
735 /* round pages up to next power of 2 */
736 pages
= roundup_pow_of_two(pages
);
740 unit_number__scnprintf(buf
, sizeof(buf
), pages
* page_size
);
741 pr_info("rounding mmap pages size to %s (%lu pages)\n",
751 int __perf_evlist__parse_mmap_pages(unsigned int *mmap_pages
, const char *str
)
753 unsigned long max
= UINT_MAX
;
756 if (max
> SIZE_MAX
/ page_size
)
757 max
= SIZE_MAX
/ page_size
;
759 pages
= parse_pages_arg(str
, 1, max
);
761 pr_err("Invalid argument for --mmap_pages/-m\n");
769 int perf_evlist__parse_mmap_pages(const struct option
*opt
, const char *str
,
770 int unset __maybe_unused
)
772 return __perf_evlist__parse_mmap_pages(opt
->value
, str
);
776 * evlist__mmap_ex - Create mmaps to receive events.
777 * @evlist: list of events
778 * @pages: map length in pages
779 * @overwrite: overwrite older events?
780 * @auxtrace_pages - auxtrace map length in pages
781 * @auxtrace_overwrite - overwrite older auxtrace data?
783 * If @overwrite is %false the user needs to signal event consumption using
784 * perf_mmap__write_tail(). Using evlist__mmap_read() does this
787 * Similarly, if @auxtrace_overwrite is %false the user needs to signal data
788 * consumption using auxtrace_mmap__write_tail().
790 * Return: %0 on success, negative error code otherwise.
792 int evlist__mmap_ex(struct evlist
*evlist
, unsigned int pages
,
793 unsigned int auxtrace_pages
,
794 bool auxtrace_overwrite
, int nr_cblocks
, int affinity
, int flush
,
798 * Delay setting mp.prot: set it before calling perf_mmap__mmap.
799 * Its value is decided by evsel's write_backward.
800 * So &mp should not be passed through const pointer.
802 struct mmap_params mp
= {
803 .nr_cblocks
= nr_cblocks
,
804 .affinity
= affinity
,
806 .comp_level
= comp_level
808 struct perf_evlist_mmap_ops ops
= {
809 .idx
= perf_evlist__mmap_cb_idx
,
810 .get
= perf_evlist__mmap_cb_get
,
811 .mmap
= perf_evlist__mmap_cb_mmap
,
814 evlist
->core
.mmap_len
= evlist__mmap_size(pages
);
815 pr_debug("mmap size %zuB\n", evlist
->core
.mmap_len
);
817 auxtrace_mmap_params__init(&mp
.auxtrace_mp
, evlist
->core
.mmap_len
,
818 auxtrace_pages
, auxtrace_overwrite
);
820 return perf_evlist__mmap_ops(&evlist
->core
, &ops
, &mp
.core
);
823 int evlist__mmap(struct evlist
*evlist
, unsigned int pages
)
825 return evlist__mmap_ex(evlist
, pages
, 0, false, 0, PERF_AFFINITY_SYS
, 1, 0);
828 int perf_evlist__create_maps(struct evlist
*evlist
, struct target
*target
)
830 bool all_threads
= (target
->per_thread
&& target
->system_wide
);
831 struct perf_cpu_map
*cpus
;
832 struct perf_thread_map
*threads
;
835 * If specify '-a' and '--per-thread' to perf record, perf record
836 * will override '--per-thread'. target->per_thread = false and
837 * target->system_wide = true.
839 * If specify '--per-thread' only to perf record,
840 * target->per_thread = true and target->system_wide = false.
842 * So target->per_thread && target->system_wide is false.
843 * For perf record, thread_map__new_str doesn't call
844 * thread_map__new_all_cpus. That will keep perf record's
847 * For perf stat, it allows the case that target->per_thread and
848 * target->system_wide are all true. It means to collect system-wide
849 * per-thread data. thread_map__new_str will call
850 * thread_map__new_all_cpus to enumerate all threads.
852 threads
= thread_map__new_str(target
->pid
, target
->tid
, target
->uid
,
858 if (target__uses_dummy_map(target
))
859 cpus
= perf_cpu_map__dummy_new();
861 cpus
= perf_cpu_map__new(target
->cpu_list
);
864 goto out_delete_threads
;
866 evlist
->core
.has_user_cpus
= !!target
->cpu_list
;
868 perf_evlist__set_maps(&evlist
->core
, cpus
, threads
);
873 perf_thread_map__put(threads
);
877 void __perf_evlist__set_sample_bit(struct evlist
*evlist
,
878 enum perf_event_sample_format bit
)
882 evlist__for_each_entry(evlist
, evsel
)
883 __perf_evsel__set_sample_bit(evsel
, bit
);
886 void __perf_evlist__reset_sample_bit(struct evlist
*evlist
,
887 enum perf_event_sample_format bit
)
891 evlist__for_each_entry(evlist
, evsel
)
892 __perf_evsel__reset_sample_bit(evsel
, bit
);
895 int perf_evlist__apply_filters(struct evlist
*evlist
, struct evsel
**err_evsel
)
900 evlist__for_each_entry(evlist
, evsel
) {
901 if (evsel
->filter
== NULL
)
905 * filters only work for tracepoint event, which doesn't have cpu limit.
906 * So evlist and evsel should always be same.
908 err
= perf_evsel__apply_filter(&evsel
->core
, evsel
->filter
);
918 int perf_evlist__set_tp_filter(struct evlist
*evlist
, const char *filter
)
926 evlist__for_each_entry(evlist
, evsel
) {
927 if (evsel
->core
.attr
.type
!= PERF_TYPE_TRACEPOINT
)
930 err
= perf_evsel__set_filter(evsel
, filter
);
938 int perf_evlist__append_tp_filter(struct evlist
*evlist
, const char *filter
)
946 evlist__for_each_entry(evlist
, evsel
) {
947 if (evsel
->core
.attr
.type
!= PERF_TYPE_TRACEPOINT
)
950 err
= perf_evsel__append_tp_filter(evsel
, filter
);
958 char *asprintf__tp_filter_pids(size_t npids
, pid_t
*pids
)
963 for (i
= 0; i
< npids
; ++i
) {
965 if (asprintf(&filter
, "common_pid != %d", pids
[i
]) < 0)
970 if (asprintf(&tmp
, "%s && common_pid != %d", filter
, pids
[i
]) < 0)
984 int perf_evlist__set_tp_filter_pids(struct evlist
*evlist
, size_t npids
, pid_t
*pids
)
986 char *filter
= asprintf__tp_filter_pids(npids
, pids
);
987 int ret
= perf_evlist__set_tp_filter(evlist
, filter
);
993 int perf_evlist__set_tp_filter_pid(struct evlist
*evlist
, pid_t pid
)
995 return perf_evlist__set_tp_filter_pids(evlist
, 1, &pid
);
998 int perf_evlist__append_tp_filter_pids(struct evlist
*evlist
, size_t npids
, pid_t
*pids
)
1000 char *filter
= asprintf__tp_filter_pids(npids
, pids
);
1001 int ret
= perf_evlist__append_tp_filter(evlist
, filter
);
1007 int perf_evlist__append_tp_filter_pid(struct evlist
*evlist
, pid_t pid
)
1009 return perf_evlist__append_tp_filter_pids(evlist
, 1, &pid
);
1012 bool perf_evlist__valid_sample_type(struct evlist
*evlist
)
1016 if (evlist
->core
.nr_entries
== 1)
1019 if (evlist
->id_pos
< 0 || evlist
->is_pos
< 0)
1022 evlist__for_each_entry(evlist
, pos
) {
1023 if (pos
->id_pos
!= evlist
->id_pos
||
1024 pos
->is_pos
!= evlist
->is_pos
)
1031 u64
__perf_evlist__combined_sample_type(struct evlist
*evlist
)
1033 struct evsel
*evsel
;
1035 if (evlist
->combined_sample_type
)
1036 return evlist
->combined_sample_type
;
1038 evlist__for_each_entry(evlist
, evsel
)
1039 evlist
->combined_sample_type
|= evsel
->core
.attr
.sample_type
;
1041 return evlist
->combined_sample_type
;
1044 u64
perf_evlist__combined_sample_type(struct evlist
*evlist
)
1046 evlist
->combined_sample_type
= 0;
1047 return __perf_evlist__combined_sample_type(evlist
);
1050 u64
perf_evlist__combined_branch_type(struct evlist
*evlist
)
1052 struct evsel
*evsel
;
1053 u64 branch_type
= 0;
1055 evlist__for_each_entry(evlist
, evsel
)
1056 branch_type
|= evsel
->core
.attr
.branch_sample_type
;
1060 bool perf_evlist__valid_read_format(struct evlist
*evlist
)
1062 struct evsel
*first
= evlist__first(evlist
), *pos
= first
;
1063 u64 read_format
= first
->core
.attr
.read_format
;
1064 u64 sample_type
= first
->core
.attr
.sample_type
;
1066 evlist__for_each_entry(evlist
, pos
) {
1067 if (read_format
!= pos
->core
.attr
.read_format
)
1071 /* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
1072 if ((sample_type
& PERF_SAMPLE_READ
) &&
1073 !(read_format
& PERF_FORMAT_ID
)) {
1080 u16
perf_evlist__id_hdr_size(struct evlist
*evlist
)
1082 struct evsel
*first
= evlist__first(evlist
);
1083 struct perf_sample
*data
;
1087 if (!first
->core
.attr
.sample_id_all
)
1090 sample_type
= first
->core
.attr
.sample_type
;
1092 if (sample_type
& PERF_SAMPLE_TID
)
1093 size
+= sizeof(data
->tid
) * 2;
1095 if (sample_type
& PERF_SAMPLE_TIME
)
1096 size
+= sizeof(data
->time
);
1098 if (sample_type
& PERF_SAMPLE_ID
)
1099 size
+= sizeof(data
->id
);
1101 if (sample_type
& PERF_SAMPLE_STREAM_ID
)
1102 size
+= sizeof(data
->stream_id
);
1104 if (sample_type
& PERF_SAMPLE_CPU
)
1105 size
+= sizeof(data
->cpu
) * 2;
1107 if (sample_type
& PERF_SAMPLE_IDENTIFIER
)
1108 size
+= sizeof(data
->id
);
1113 bool perf_evlist__valid_sample_id_all(struct evlist
*evlist
)
1115 struct evsel
*first
= evlist__first(evlist
), *pos
= first
;
1117 evlist__for_each_entry_continue(evlist
, pos
) {
1118 if (first
->core
.attr
.sample_id_all
!= pos
->core
.attr
.sample_id_all
)
1125 bool perf_evlist__sample_id_all(struct evlist
*evlist
)
1127 struct evsel
*first
= evlist__first(evlist
);
1128 return first
->core
.attr
.sample_id_all
;
1131 void perf_evlist__set_selected(struct evlist
*evlist
,
1132 struct evsel
*evsel
)
1134 evlist
->selected
= evsel
;
1137 void evlist__close(struct evlist
*evlist
)
1139 struct evsel
*evsel
;
1141 evlist__for_each_entry_reverse(evlist
, evsel
)
1142 evsel__close(evsel
);
1145 static int perf_evlist__create_syswide_maps(struct evlist
*evlist
)
1147 struct perf_cpu_map
*cpus
;
1148 struct perf_thread_map
*threads
;
1152 * Try reading /sys/devices/system/cpu/online to get
1155 * FIXME: -ENOMEM is the best we can do here, the cpu_map
1156 * code needs an overhaul to properly forward the
1157 * error, and we may not want to do that fallback to a
1158 * default cpu identity map :-\
1160 cpus
= perf_cpu_map__new(NULL
);
1164 threads
= perf_thread_map__new_dummy();
1168 perf_evlist__set_maps(&evlist
->core
, cpus
, threads
);
1172 perf_cpu_map__put(cpus
);
1176 int evlist__open(struct evlist
*evlist
)
1178 struct evsel
*evsel
;
1182 * Default: one fd per CPU, all threads, aka systemwide
1183 * as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL
1185 if (evlist
->core
.threads
== NULL
&& evlist
->core
.cpus
== NULL
) {
1186 err
= perf_evlist__create_syswide_maps(evlist
);
1191 perf_evlist__update_id_pos(evlist
);
1193 evlist__for_each_entry(evlist
, evsel
) {
1194 err
= evsel__open(evsel
, evsel
->core
.cpus
, evsel
->core
.threads
);
1201 evlist__close(evlist
);
1206 int perf_evlist__prepare_workload(struct evlist
*evlist
, struct target
*target
,
1207 const char *argv
[], bool pipe_output
,
1208 void (*exec_error
)(int signo
, siginfo_t
*info
, void *ucontext
))
1210 int child_ready_pipe
[2], go_pipe
[2];
1213 if (pipe(child_ready_pipe
) < 0) {
1214 perror("failed to create 'ready' pipe");
1218 if (pipe(go_pipe
) < 0) {
1219 perror("failed to create 'go' pipe");
1220 goto out_close_ready_pipe
;
1223 evlist
->workload
.pid
= fork();
1224 if (evlist
->workload
.pid
< 0) {
1225 perror("failed to fork");
1226 goto out_close_pipes
;
1229 if (!evlist
->workload
.pid
) {
1235 signal(SIGTERM
, SIG_DFL
);
1237 close(child_ready_pipe
[0]);
1239 fcntl(go_pipe
[0], F_SETFD
, FD_CLOEXEC
);
1242 * Tell the parent we're ready to go
1244 close(child_ready_pipe
[1]);
1247 * Wait until the parent tells us to go.
1249 ret
= read(go_pipe
[0], &bf
, 1);
1251 * The parent will ask for the execvp() to be performed by
1252 * writing exactly one byte, in workload.cork_fd, usually via
1253 * perf_evlist__start_workload().
1255 * For cancelling the workload without actually running it,
1256 * the parent will just close workload.cork_fd, without writing
1257 * anything, i.e. read will return zero and we just exit()
1262 perror("unable to read pipe");
1266 execvp(argv
[0], (char **)argv
);
1271 val
.sival_int
= errno
;
1272 if (sigqueue(getppid(), SIGUSR1
, val
))
1280 struct sigaction act
= {
1281 .sa_flags
= SA_SIGINFO
,
1282 .sa_sigaction
= exec_error
,
1284 sigaction(SIGUSR1
, &act
, NULL
);
1287 if (target__none(target
)) {
1288 if (evlist
->core
.threads
== NULL
) {
1289 fprintf(stderr
, "FATAL: evlist->threads need to be set at this point (%s:%d).\n",
1290 __func__
, __LINE__
);
1291 goto out_close_pipes
;
1293 perf_thread_map__set_pid(evlist
->core
.threads
, 0, evlist
->workload
.pid
);
1296 close(child_ready_pipe
[1]);
1299 * wait for child to settle
1301 if (read(child_ready_pipe
[0], &bf
, 1) == -1) {
1302 perror("unable to read pipe");
1303 goto out_close_pipes
;
1306 fcntl(go_pipe
[1], F_SETFD
, FD_CLOEXEC
);
1307 evlist
->workload
.cork_fd
= go_pipe
[1];
1308 close(child_ready_pipe
[0]);
1314 out_close_ready_pipe
:
1315 close(child_ready_pipe
[0]);
1316 close(child_ready_pipe
[1]);
1320 int perf_evlist__start_workload(struct evlist
*evlist
)
1322 if (evlist
->workload
.cork_fd
> 0) {
1326 * Remove the cork, let it rip!
1328 ret
= write(evlist
->workload
.cork_fd
, &bf
, 1);
1330 perror("unable to write to pipe");
1332 close(evlist
->workload
.cork_fd
);
1339 int perf_evlist__parse_sample(struct evlist
*evlist
, union perf_event
*event
,
1340 struct perf_sample
*sample
)
1342 struct evsel
*evsel
= perf_evlist__event2evsel(evlist
, event
);
1346 return perf_evsel__parse_sample(evsel
, event
, sample
);
1349 int perf_evlist__parse_sample_timestamp(struct evlist
*evlist
,
1350 union perf_event
*event
,
1353 struct evsel
*evsel
= perf_evlist__event2evsel(evlist
, event
);
1357 return perf_evsel__parse_sample_timestamp(evsel
, event
, timestamp
);
1360 int perf_evlist__strerror_open(struct evlist
*evlist
,
1361 int err
, char *buf
, size_t size
)
1364 char sbuf
[STRERR_BUFSIZE
], *emsg
= str_error_r(err
, sbuf
, sizeof(sbuf
));
1369 printed
= scnprintf(buf
, size
,
1371 "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg
);
1373 value
= perf_event_paranoid();
1375 printed
+= scnprintf(buf
+ printed
, size
- printed
, "\nHint:\t");
1378 printed
+= scnprintf(buf
+ printed
, size
- printed
,
1379 "For your workloads it needs to be <= 1\nHint:\t");
1381 printed
+= scnprintf(buf
+ printed
, size
- printed
,
1382 "For system wide tracing it needs to be set to -1.\n");
1384 printed
+= scnprintf(buf
+ printed
, size
- printed
,
1385 "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
1386 "Hint:\tThe current value is %d.", value
);
1389 struct evsel
*first
= evlist__first(evlist
);
1392 if (sysctl__read_int("kernel/perf_event_max_sample_rate", &max_freq
) < 0)
1395 if (first
->core
.attr
.sample_freq
< (u64
)max_freq
)
1398 printed
= scnprintf(buf
, size
,
1400 "Hint:\tCheck /proc/sys/kernel/perf_event_max_sample_rate.\n"
1401 "Hint:\tThe current value is %d and %" PRIu64
" is being requested.",
1402 emsg
, max_freq
, first
->core
.attr
.sample_freq
);
1407 scnprintf(buf
, size
, "%s", emsg
);
1414 int perf_evlist__strerror_mmap(struct evlist
*evlist
, int err
, char *buf
, size_t size
)
1416 char sbuf
[STRERR_BUFSIZE
], *emsg
= str_error_r(err
, sbuf
, sizeof(sbuf
));
1417 int pages_attempted
= evlist
->core
.mmap_len
/ 1024, pages_max_per_user
, printed
= 0;
1421 sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user
);
1422 printed
+= scnprintf(buf
+ printed
, size
- printed
,
1424 "Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n"
1425 "Hint:\tTried using %zd kB.\n",
1426 emsg
, pages_max_per_user
, pages_attempted
);
1428 if (pages_attempted
>= pages_max_per_user
) {
1429 printed
+= scnprintf(buf
+ printed
, size
- printed
,
1430 "Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n",
1431 pages_max_per_user
+ pages_attempted
);
1434 printed
+= scnprintf(buf
+ printed
, size
- printed
,
1435 "Hint:\tTry using a smaller -m/--mmap-pages value.");
1438 scnprintf(buf
, size
, "%s", emsg
);
1445 void perf_evlist__to_front(struct evlist
*evlist
,
1446 struct evsel
*move_evsel
)
1448 struct evsel
*evsel
, *n
;
1451 if (move_evsel
== evlist__first(evlist
))
1454 evlist__for_each_entry_safe(evlist
, n
, evsel
) {
1455 if (evsel
->leader
== move_evsel
->leader
)
1456 list_move_tail(&evsel
->core
.node
, &move
);
1459 list_splice(&move
, &evlist
->core
.entries
);
1462 void perf_evlist__set_tracking_event(struct evlist
*evlist
,
1463 struct evsel
*tracking_evsel
)
1465 struct evsel
*evsel
;
1467 if (tracking_evsel
->tracking
)
1470 evlist__for_each_entry(evlist
, evsel
) {
1471 if (evsel
!= tracking_evsel
)
1472 evsel
->tracking
= false;
1475 tracking_evsel
->tracking
= true;
1479 perf_evlist__find_evsel_by_str(struct evlist
*evlist
,
1482 struct evsel
*evsel
;
1484 evlist__for_each_entry(evlist
, evsel
) {
1487 if (strcmp(str
, evsel
->name
) == 0)
1494 void perf_evlist__toggle_bkw_mmap(struct evlist
*evlist
,
1495 enum bkw_mmap_state state
)
1497 enum bkw_mmap_state old_state
= evlist
->bkw_mmap_state
;
1504 if (!evlist
->overwrite_mmap
)
1507 switch (old_state
) {
1508 case BKW_MMAP_NOTREADY
: {
1509 if (state
!= BKW_MMAP_RUNNING
)
1513 case BKW_MMAP_RUNNING
: {
1514 if (state
!= BKW_MMAP_DATA_PENDING
)
1519 case BKW_MMAP_DATA_PENDING
: {
1520 if (state
!= BKW_MMAP_EMPTY
)
1524 case BKW_MMAP_EMPTY
: {
1525 if (state
!= BKW_MMAP_RUNNING
)
1531 WARN_ONCE(1, "Shouldn't get there\n");
1534 evlist
->bkw_mmap_state
= state
;
1538 perf_evlist__pause(evlist
);
1541 perf_evlist__resume(evlist
);
1552 bool perf_evlist__exclude_kernel(struct evlist
*evlist
)
1554 struct evsel
*evsel
;
1556 evlist__for_each_entry(evlist
, evsel
) {
1557 if (!evsel
->core
.attr
.exclude_kernel
)
1565 * Events in data file are not collect in groups, but we still want
1566 * the group display. Set the artificial group and set the leader's
1567 * forced_leader flag to notify the display code.
1569 void perf_evlist__force_leader(struct evlist
*evlist
)
1571 if (!evlist
->nr_groups
) {
1572 struct evsel
*leader
= evlist__first(evlist
);
1574 perf_evlist__set_leader(evlist
);
1575 leader
->forced_leader
= true;
1579 struct evsel
*perf_evlist__reset_weak_group(struct evlist
*evsel_list
,
1580 struct evsel
*evsel
)
1582 struct evsel
*c2
, *leader
;
1583 bool is_open
= true;
1585 leader
= evsel
->leader
;
1586 pr_debug("Weak group for %s/%d failed\n",
1587 leader
->name
, leader
->core
.nr_members
);
1590 * for_each_group_member doesn't work here because it doesn't
1591 * include the first entry.
1593 evlist__for_each_entry(evsel_list
, c2
) {
1596 if (c2
->leader
== leader
) {
1598 perf_evsel__close(&c2
->core
);
1600 c2
->core
.nr_members
= 0;
1606 int perf_evlist__add_sb_event(struct evlist
**evlist
,
1607 struct perf_event_attr
*attr
,
1608 perf_evsel__sb_cb_t cb
,
1611 struct evsel
*evsel
;
1612 bool new_evlist
= (*evlist
) == NULL
;
1614 if (*evlist
== NULL
)
1615 *evlist
= evlist__new();
1616 if (*evlist
== NULL
)
1619 if (!attr
->sample_id_all
) {
1620 pr_warning("enabling sample_id_all for all side band events\n");
1621 attr
->sample_id_all
= 1;
1624 evsel
= perf_evsel__new_idx(attr
, (*evlist
)->core
.nr_entries
);
1628 evsel
->side_band
.cb
= cb
;
1629 evsel
->side_band
.data
= data
;
1630 evlist__add(*evlist
, evsel
);
1635 evlist__delete(*evlist
);
1641 static void *perf_evlist__poll_thread(void *arg
)
1643 struct evlist
*evlist
= arg
;
1644 bool draining
= false;
1647 * In order to read symbols from other namespaces perf to needs to call
1648 * setns(2). This isn't permitted if the struct_fs has multiple users.
1649 * unshare(2) the fs so that we may continue to setns into namespaces
1650 * that we're observing when, for instance, reading the build-ids at
1651 * the end of a 'perf record' session.
1656 bool got_data
= false;
1658 if (evlist
->thread
.done
)
1662 evlist__poll(evlist
, 1000);
1664 for (i
= 0; i
< evlist
->core
.nr_mmaps
; i
++) {
1665 struct mmap
*map
= &evlist
->mmap
[i
];
1666 union perf_event
*event
;
1668 if (perf_mmap__read_init(&map
->core
))
1670 while ((event
= perf_mmap__read_event(&map
->core
)) != NULL
) {
1671 struct evsel
*evsel
= perf_evlist__event2evsel(evlist
, event
);
1673 if (evsel
&& evsel
->side_band
.cb
)
1674 evsel
->side_band
.cb(event
, evsel
->side_band
.data
);
1676 pr_warning("cannot locate proper evsel for the side band event\n");
1678 perf_mmap__consume(&map
->core
);
1681 perf_mmap__read_done(&map
->core
);
1684 if (draining
&& !got_data
)
1690 int perf_evlist__start_sb_thread(struct evlist
*evlist
,
1691 struct target
*target
)
1693 struct evsel
*counter
;
1698 if (perf_evlist__create_maps(evlist
, target
))
1699 goto out_delete_evlist
;
1701 evlist__for_each_entry(evlist
, counter
) {
1702 if (evsel__open(counter
, evlist
->core
.cpus
,
1703 evlist
->core
.threads
) < 0)
1704 goto out_delete_evlist
;
1707 if (evlist__mmap(evlist
, UINT_MAX
))
1708 goto out_delete_evlist
;
1710 evlist__for_each_entry(evlist
, counter
) {
1711 if (evsel__enable(counter
))
1712 goto out_delete_evlist
;
1715 evlist
->thread
.done
= 0;
1716 if (pthread_create(&evlist
->thread
.th
, NULL
, perf_evlist__poll_thread
, evlist
))
1717 goto out_delete_evlist
;
1722 evlist__delete(evlist
);
1727 void perf_evlist__stop_sb_thread(struct evlist
*evlist
)
1731 evlist
->thread
.done
= 1;
1732 pthread_join(evlist
->thread
.th
, NULL
);
1733 evlist__delete(evlist
);