2 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
4 * Parts came from builtin-{top,stat,record}.c, see those files for further
7 * Released under the GPL v2. (and only v2, not any later version)
13 #include "thread_map.h"
18 #include "parse-events.h"
22 #include <linux/bitops.h>
23 #include <linux/hash.h>
25 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
26 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
28 void perf_evlist__init(struct perf_evlist
*evlist
, struct cpu_map
*cpus
,
29 struct thread_map
*threads
)
33 for (i
= 0; i
< PERF_EVLIST__HLIST_SIZE
; ++i
)
34 INIT_HLIST_HEAD(&evlist
->heads
[i
]);
35 INIT_LIST_HEAD(&evlist
->entries
);
36 perf_evlist__set_maps(evlist
, cpus
, threads
);
37 evlist
->workload
.pid
= -1;
40 struct perf_evlist
*perf_evlist__new(struct cpu_map
*cpus
,
41 struct thread_map
*threads
)
43 struct perf_evlist
*evlist
= zalloc(sizeof(*evlist
));
46 perf_evlist__init(evlist
, cpus
, threads
);
51 void perf_evlist__config_attrs(struct perf_evlist
*evlist
,
52 struct perf_record_opts
*opts
)
54 struct perf_evsel
*evsel
;
56 if (evlist
->cpus
->map
[0] < 0)
57 opts
->no_inherit
= true;
59 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
60 perf_evsel__config(evsel
, opts
);
62 if (evlist
->nr_entries
> 1)
63 evsel
->attr
.sample_type
|= PERF_SAMPLE_ID
;
67 static void perf_evlist__purge(struct perf_evlist
*evlist
)
69 struct perf_evsel
*pos
, *n
;
71 list_for_each_entry_safe(pos
, n
, &evlist
->entries
, node
) {
72 list_del_init(&pos
->node
);
73 perf_evsel__delete(pos
);
76 evlist
->nr_entries
= 0;
79 void perf_evlist__exit(struct perf_evlist
*evlist
)
84 evlist
->pollfd
= NULL
;
87 void perf_evlist__delete(struct perf_evlist
*evlist
)
89 perf_evlist__purge(evlist
);
90 perf_evlist__exit(evlist
);
94 void perf_evlist__add(struct perf_evlist
*evlist
, struct perf_evsel
*entry
)
96 list_add_tail(&entry
->node
, &evlist
->entries
);
100 static void perf_evlist__splice_list_tail(struct perf_evlist
*evlist
,
101 struct list_head
*list
,
104 list_splice_tail(list
, &evlist
->entries
);
105 evlist
->nr_entries
+= nr_entries
;
108 int perf_evlist__add_default(struct perf_evlist
*evlist
)
110 struct perf_event_attr attr
= {
111 .type
= PERF_TYPE_HARDWARE
,
112 .config
= PERF_COUNT_HW_CPU_CYCLES
,
114 struct perf_evsel
*evsel
;
116 event_attr_init(&attr
);
118 evsel
= perf_evsel__new(&attr
, 0);
122 /* use strdup() because free(evsel) assumes name is allocated */
123 evsel
->name
= strdup("cycles");
127 perf_evlist__add(evlist
, evsel
);
130 perf_evsel__delete(evsel
);
135 int perf_evlist__add_attrs(struct perf_evlist
*evlist
,
136 struct perf_event_attr
*attrs
, size_t nr_attrs
)
138 struct perf_evsel
*evsel
, *n
;
142 for (i
= 0; i
< nr_attrs
; i
++) {
143 evsel
= perf_evsel__new(attrs
+ i
, evlist
->nr_entries
+ i
);
145 goto out_delete_partial_list
;
146 list_add_tail(&evsel
->node
, &head
);
149 perf_evlist__splice_list_tail(evlist
, &head
, nr_attrs
);
153 out_delete_partial_list
:
154 list_for_each_entry_safe(evsel
, n
, &head
, node
)
155 perf_evsel__delete(evsel
);
159 static int trace_event__id(const char *evname
)
161 char *filename
, *colon
;
164 if (asprintf(&filename
, "%s/%s/id", tracing_events_path
, evname
) < 0)
167 colon
= strrchr(filename
, ':');
171 fd
= open(filename
, O_RDONLY
);
174 if (read(fd
, id
, sizeof(id
)) > 0)
183 int perf_evlist__add_tracepoints(struct perf_evlist
*evlist
,
184 const char *tracepoints
[],
185 size_t nr_tracepoints
)
189 struct perf_event_attr
*attrs
= zalloc(nr_tracepoints
* sizeof(*attrs
));
194 for (i
= 0; i
< nr_tracepoints
; i
++) {
195 err
= trace_event__id(tracepoints
[i
]);
200 attrs
[i
].type
= PERF_TYPE_TRACEPOINT
;
201 attrs
[i
].config
= err
;
202 attrs
[i
].sample_type
= (PERF_SAMPLE_RAW
| PERF_SAMPLE_TIME
|
204 attrs
[i
].sample_period
= 1;
207 err
= perf_evlist__add_attrs(evlist
, attrs
, nr_tracepoints
);
213 static struct perf_evsel
*
214 perf_evlist__find_tracepoint_by_id(struct perf_evlist
*evlist
, int id
)
216 struct perf_evsel
*evsel
;
218 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
219 if (evsel
->attr
.type
== PERF_TYPE_TRACEPOINT
&&
220 (int)evsel
->attr
.config
== id
)
227 int perf_evlist__set_tracepoints_handlers(struct perf_evlist
*evlist
,
228 const struct perf_evsel_str_handler
*assocs
,
231 struct perf_evsel
*evsel
;
235 for (i
= 0; i
< nr_assocs
; i
++) {
236 err
= trace_event__id(assocs
[i
].name
);
240 evsel
= perf_evlist__find_tracepoint_by_id(evlist
, err
);
245 if (evsel
->handler
.func
!= NULL
)
247 evsel
->handler
.func
= assocs
[i
].handler
;
255 void perf_evlist__disable(struct perf_evlist
*evlist
)
258 struct perf_evsel
*pos
;
260 for (cpu
= 0; cpu
< evlist
->cpus
->nr
; cpu
++) {
261 list_for_each_entry(pos
, &evlist
->entries
, node
) {
262 for (thread
= 0; thread
< evlist
->threads
->nr
; thread
++)
263 ioctl(FD(pos
, cpu
, thread
), PERF_EVENT_IOC_DISABLE
);
268 void perf_evlist__enable(struct perf_evlist
*evlist
)
271 struct perf_evsel
*pos
;
273 for (cpu
= 0; cpu
< evlist
->cpus
->nr
; cpu
++) {
274 list_for_each_entry(pos
, &evlist
->entries
, node
) {
275 for (thread
= 0; thread
< evlist
->threads
->nr
; thread
++)
276 ioctl(FD(pos
, cpu
, thread
), PERF_EVENT_IOC_ENABLE
);
281 static int perf_evlist__alloc_pollfd(struct perf_evlist
*evlist
)
283 int nfds
= evlist
->cpus
->nr
* evlist
->threads
->nr
* evlist
->nr_entries
;
284 evlist
->pollfd
= malloc(sizeof(struct pollfd
) * nfds
);
285 return evlist
->pollfd
!= NULL
? 0 : -ENOMEM
;
288 void perf_evlist__add_pollfd(struct perf_evlist
*evlist
, int fd
)
290 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
291 evlist
->pollfd
[evlist
->nr_fds
].fd
= fd
;
292 evlist
->pollfd
[evlist
->nr_fds
].events
= POLLIN
;
296 static void perf_evlist__id_hash(struct perf_evlist
*evlist
,
297 struct perf_evsel
*evsel
,
298 int cpu
, int thread
, u64 id
)
301 struct perf_sample_id
*sid
= SID(evsel
, cpu
, thread
);
305 hash
= hash_64(sid
->id
, PERF_EVLIST__HLIST_BITS
);
306 hlist_add_head(&sid
->node
, &evlist
->heads
[hash
]);
309 void perf_evlist__id_add(struct perf_evlist
*evlist
, struct perf_evsel
*evsel
,
310 int cpu
, int thread
, u64 id
)
312 perf_evlist__id_hash(evlist
, evsel
, cpu
, thread
, id
);
313 evsel
->id
[evsel
->ids
++] = id
;
316 static int perf_evlist__id_add_fd(struct perf_evlist
*evlist
,
317 struct perf_evsel
*evsel
,
318 int cpu
, int thread
, int fd
)
320 u64 read_data
[4] = { 0, };
321 int id_idx
= 1; /* The first entry is the counter value */
323 if (!(evsel
->attr
.read_format
& PERF_FORMAT_ID
) ||
324 read(fd
, &read_data
, sizeof(read_data
)) == -1)
327 if (evsel
->attr
.read_format
& PERF_FORMAT_TOTAL_TIME_ENABLED
)
329 if (evsel
->attr
.read_format
& PERF_FORMAT_TOTAL_TIME_RUNNING
)
332 perf_evlist__id_add(evlist
, evsel
, cpu
, thread
, read_data
[id_idx
]);
336 struct perf_evsel
*perf_evlist__id2evsel(struct perf_evlist
*evlist
, u64 id
)
338 struct hlist_head
*head
;
339 struct hlist_node
*pos
;
340 struct perf_sample_id
*sid
;
343 if (evlist
->nr_entries
== 1)
344 return list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
346 hash
= hash_64(id
, PERF_EVLIST__HLIST_BITS
);
347 head
= &evlist
->heads
[hash
];
349 hlist_for_each_entry(sid
, pos
, head
, node
)
355 union perf_event
*perf_evlist__mmap_read(struct perf_evlist
*evlist
, int idx
)
357 /* XXX Move this to perf.c, making it generally available */
358 unsigned int page_size
= sysconf(_SC_PAGE_SIZE
);
359 struct perf_mmap
*md
= &evlist
->mmap
[idx
];
360 unsigned int head
= perf_mmap__read_head(md
);
361 unsigned int old
= md
->prev
;
362 unsigned char *data
= md
->base
+ page_size
;
363 union perf_event
*event
= NULL
;
365 if (evlist
->overwrite
) {
367 * If we're further behind than half the buffer, there's a chance
368 * the writer will bite our tail and mess up the samples under us.
370 * If we somehow ended up ahead of the head, we got messed up.
372 * In either case, truncate and restart at head.
374 int diff
= head
- old
;
375 if (diff
> md
->mask
/ 2 || diff
< 0) {
376 fprintf(stderr
, "WARNING: failed to keep up with mmap data.\n");
379 * head points to a known good entry, start there.
388 event
= (union perf_event
*)&data
[old
& md
->mask
];
389 size
= event
->header
.size
;
392 * Event straddles the mmap boundary -- header should always
393 * be inside due to u64 alignment of output.
395 if ((old
& md
->mask
) + size
!= ((old
+ size
) & md
->mask
)) {
396 unsigned int offset
= old
;
397 unsigned int len
= min(sizeof(*event
), size
), cpy
;
398 void *dst
= &evlist
->event_copy
;
401 cpy
= min(md
->mask
+ 1 - (offset
& md
->mask
), len
);
402 memcpy(dst
, &data
[offset
& md
->mask
], cpy
);
408 event
= &evlist
->event_copy
;
416 if (!evlist
->overwrite
)
417 perf_mmap__write_tail(md
, old
);
422 void perf_evlist__munmap(struct perf_evlist
*evlist
)
426 for (i
= 0; i
< evlist
->nr_mmaps
; i
++) {
427 if (evlist
->mmap
[i
].base
!= NULL
) {
428 munmap(evlist
->mmap
[i
].base
, evlist
->mmap_len
);
429 evlist
->mmap
[i
].base
= NULL
;
437 static int perf_evlist__alloc_mmap(struct perf_evlist
*evlist
)
439 evlist
->nr_mmaps
= evlist
->cpus
->nr
;
440 if (evlist
->cpus
->map
[0] == -1)
441 evlist
->nr_mmaps
= evlist
->threads
->nr
;
442 evlist
->mmap
= zalloc(evlist
->nr_mmaps
* sizeof(struct perf_mmap
));
443 return evlist
->mmap
!= NULL
? 0 : -ENOMEM
;
446 static int __perf_evlist__mmap(struct perf_evlist
*evlist
,
447 int idx
, int prot
, int mask
, int fd
)
449 evlist
->mmap
[idx
].prev
= 0;
450 evlist
->mmap
[idx
].mask
= mask
;
451 evlist
->mmap
[idx
].base
= mmap(NULL
, evlist
->mmap_len
, prot
,
453 if (evlist
->mmap
[idx
].base
== MAP_FAILED
) {
454 evlist
->mmap
[idx
].base
= NULL
;
458 perf_evlist__add_pollfd(evlist
, fd
);
462 static int perf_evlist__mmap_per_cpu(struct perf_evlist
*evlist
, int prot
, int mask
)
464 struct perf_evsel
*evsel
;
467 for (cpu
= 0; cpu
< evlist
->cpus
->nr
; cpu
++) {
470 for (thread
= 0; thread
< evlist
->threads
->nr
; thread
++) {
471 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
472 int fd
= FD(evsel
, cpu
, thread
);
476 if (__perf_evlist__mmap(evlist
, cpu
,
477 prot
, mask
, output
) < 0)
480 if (ioctl(fd
, PERF_EVENT_IOC_SET_OUTPUT
, output
) != 0)
484 if ((evsel
->attr
.read_format
& PERF_FORMAT_ID
) &&
485 perf_evlist__id_add_fd(evlist
, evsel
, cpu
, thread
, fd
) < 0)
494 for (cpu
= 0; cpu
< evlist
->cpus
->nr
; cpu
++) {
495 if (evlist
->mmap
[cpu
].base
!= NULL
) {
496 munmap(evlist
->mmap
[cpu
].base
, evlist
->mmap_len
);
497 evlist
->mmap
[cpu
].base
= NULL
;
503 static int perf_evlist__mmap_per_thread(struct perf_evlist
*evlist
, int prot
, int mask
)
505 struct perf_evsel
*evsel
;
508 for (thread
= 0; thread
< evlist
->threads
->nr
; thread
++) {
511 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
512 int fd
= FD(evsel
, 0, thread
);
516 if (__perf_evlist__mmap(evlist
, thread
,
517 prot
, mask
, output
) < 0)
520 if (ioctl(fd
, PERF_EVENT_IOC_SET_OUTPUT
, output
) != 0)
524 if ((evsel
->attr
.read_format
& PERF_FORMAT_ID
) &&
525 perf_evlist__id_add_fd(evlist
, evsel
, 0, thread
, fd
) < 0)
533 for (thread
= 0; thread
< evlist
->threads
->nr
; thread
++) {
534 if (evlist
->mmap
[thread
].base
!= NULL
) {
535 munmap(evlist
->mmap
[thread
].base
, evlist
->mmap_len
);
536 evlist
->mmap
[thread
].base
= NULL
;
542 /** perf_evlist__mmap - Create per cpu maps to receive events
544 * @evlist - list of events
545 * @pages - map length in pages
546 * @overwrite - overwrite older events?
548 * If overwrite is false the user needs to signal event consuption using:
550 * struct perf_mmap *m = &evlist->mmap[cpu];
551 * unsigned int head = perf_mmap__read_head(m);
553 * perf_mmap__write_tail(m, head)
555 * Using perf_evlist__read_on_cpu does this automatically.
557 int perf_evlist__mmap(struct perf_evlist
*evlist
, unsigned int pages
,
560 unsigned int page_size
= sysconf(_SC_PAGE_SIZE
);
561 struct perf_evsel
*evsel
;
562 const struct cpu_map
*cpus
= evlist
->cpus
;
563 const struct thread_map
*threads
= evlist
->threads
;
564 int prot
= PROT_READ
| (overwrite
? 0 : PROT_WRITE
), mask
;
566 /* 512 kiB: default amount of unprivileged mlocked memory */
567 if (pages
== UINT_MAX
)
568 pages
= (512 * 1024) / page_size
;
569 else if (!is_power_of_2(pages
))
572 mask
= pages
* page_size
- 1;
574 if (evlist
->mmap
== NULL
&& perf_evlist__alloc_mmap(evlist
) < 0)
577 if (evlist
->pollfd
== NULL
&& perf_evlist__alloc_pollfd(evlist
) < 0)
580 evlist
->overwrite
= overwrite
;
581 evlist
->mmap_len
= (pages
+ 1) * page_size
;
583 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
584 if ((evsel
->attr
.read_format
& PERF_FORMAT_ID
) &&
585 evsel
->sample_id
== NULL
&&
586 perf_evsel__alloc_id(evsel
, cpus
->nr
, threads
->nr
) < 0)
590 if (evlist
->cpus
->map
[0] == -1)
591 return perf_evlist__mmap_per_thread(evlist
, prot
, mask
);
593 return perf_evlist__mmap_per_cpu(evlist
, prot
, mask
);
596 int perf_evlist__create_maps(struct perf_evlist
*evlist
, pid_t target_pid
,
597 pid_t target_tid
, uid_t uid
, const char *cpu_list
)
599 evlist
->threads
= thread_map__new(target_pid
, target_tid
, uid
);
601 if (evlist
->threads
== NULL
)
604 if (uid
!= UINT_MAX
|| (cpu_list
== NULL
&& target_tid
!= -1))
605 evlist
->cpus
= cpu_map__dummy_new();
607 evlist
->cpus
= cpu_map__new(cpu_list
);
609 if (evlist
->cpus
== NULL
)
610 goto out_delete_threads
;
615 thread_map__delete(evlist
->threads
);
619 void perf_evlist__delete_maps(struct perf_evlist
*evlist
)
621 cpu_map__delete(evlist
->cpus
);
622 thread_map__delete(evlist
->threads
);
624 evlist
->threads
= NULL
;
627 int perf_evlist__set_filters(struct perf_evlist
*evlist
)
629 const struct thread_map
*threads
= evlist
->threads
;
630 const struct cpu_map
*cpus
= evlist
->cpus
;
631 struct perf_evsel
*evsel
;
638 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
639 filter
= evsel
->filter
;
642 for (cpu
= 0; cpu
< cpus
->nr
; cpu
++) {
643 for (thread
= 0; thread
< threads
->nr
; thread
++) {
644 fd
= FD(evsel
, cpu
, thread
);
645 err
= ioctl(fd
, PERF_EVENT_IOC_SET_FILTER
, filter
);
655 bool perf_evlist__valid_sample_type(const struct perf_evlist
*evlist
)
657 struct perf_evsel
*pos
, *first
;
659 pos
= first
= list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
661 list_for_each_entry_continue(pos
, &evlist
->entries
, node
) {
662 if (first
->attr
.sample_type
!= pos
->attr
.sample_type
)
669 u64
perf_evlist__sample_type(const struct perf_evlist
*evlist
)
671 struct perf_evsel
*first
;
673 first
= list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
674 return first
->attr
.sample_type
;
677 u16
perf_evlist__id_hdr_size(const struct perf_evlist
*evlist
)
679 struct perf_evsel
*first
;
680 struct perf_sample
*data
;
684 first
= list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
686 if (!first
->attr
.sample_id_all
)
689 sample_type
= first
->attr
.sample_type
;
691 if (sample_type
& PERF_SAMPLE_TID
)
692 size
+= sizeof(data
->tid
) * 2;
694 if (sample_type
& PERF_SAMPLE_TIME
)
695 size
+= sizeof(data
->time
);
697 if (sample_type
& PERF_SAMPLE_ID
)
698 size
+= sizeof(data
->id
);
700 if (sample_type
& PERF_SAMPLE_STREAM_ID
)
701 size
+= sizeof(data
->stream_id
);
703 if (sample_type
& PERF_SAMPLE_CPU
)
704 size
+= sizeof(data
->cpu
) * 2;
709 bool perf_evlist__valid_sample_id_all(const struct perf_evlist
*evlist
)
711 struct perf_evsel
*pos
, *first
;
713 pos
= first
= list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
715 list_for_each_entry_continue(pos
, &evlist
->entries
, node
) {
716 if (first
->attr
.sample_id_all
!= pos
->attr
.sample_id_all
)
723 bool perf_evlist__sample_id_all(const struct perf_evlist
*evlist
)
725 struct perf_evsel
*first
;
727 first
= list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
728 return first
->attr
.sample_id_all
;
731 void perf_evlist__set_selected(struct perf_evlist
*evlist
,
732 struct perf_evsel
*evsel
)
734 evlist
->selected
= evsel
;
737 int perf_evlist__open(struct perf_evlist
*evlist
, bool group
)
739 struct perf_evsel
*evsel
, *first
;
740 int err
, ncpus
, nthreads
;
742 first
= list_entry(evlist
->entries
.next
, struct perf_evsel
, node
);
744 list_for_each_entry(evsel
, &evlist
->entries
, node
) {
745 struct xyarray
*group_fd
= NULL
;
747 if (group
&& evsel
!= first
)
748 group_fd
= first
->fd
;
750 err
= perf_evsel__open(evsel
, evlist
->cpus
, evlist
->threads
,
758 ncpus
= evlist
->cpus
? evlist
->cpus
->nr
: 1;
759 nthreads
= evlist
->threads
? evlist
->threads
->nr
: 1;
761 list_for_each_entry_reverse(evsel
, &evlist
->entries
, node
)
762 perf_evsel__close(evsel
, ncpus
, nthreads
);
767 int perf_evlist__prepare_workload(struct perf_evlist
*evlist
,
768 struct perf_record_opts
*opts
,
771 int child_ready_pipe
[2], go_pipe
[2];
774 if (pipe(child_ready_pipe
) < 0) {
775 perror("failed to create 'ready' pipe");
779 if (pipe(go_pipe
) < 0) {
780 perror("failed to create 'go' pipe");
781 goto out_close_ready_pipe
;
784 evlist
->workload
.pid
= fork();
785 if (evlist
->workload
.pid
< 0) {
786 perror("failed to fork");
787 goto out_close_pipes
;
790 if (!evlist
->workload
.pid
) {
791 if (opts
->pipe_output
)
794 close(child_ready_pipe
[0]);
796 fcntl(go_pipe
[0], F_SETFD
, FD_CLOEXEC
);
799 * Do a dummy execvp to get the PLT entry resolved,
800 * so we avoid the resolver overhead on the real
803 execvp("", (char **)argv
);
806 * Tell the parent we're ready to go
808 close(child_ready_pipe
[1]);
811 * Wait until the parent tells us to go.
813 if (read(go_pipe
[0], &bf
, 1) == -1)
814 perror("unable to read pipe");
816 execvp(argv
[0], (char **)argv
);
819 kill(getppid(), SIGUSR1
);
823 if (!opts
->system_wide
&& opts
->target_tid
== -1 && opts
->target_pid
== -1)
824 evlist
->threads
->map
[0] = evlist
->workload
.pid
;
826 close(child_ready_pipe
[1]);
829 * wait for child to settle
831 if (read(child_ready_pipe
[0], &bf
, 1) == -1) {
832 perror("unable to read pipe");
833 goto out_close_pipes
;
836 evlist
->workload
.cork_fd
= go_pipe
[1];
837 close(child_ready_pipe
[0]);
843 out_close_ready_pipe
:
844 close(child_ready_pipe
[0]);
845 close(child_ready_pipe
[1]);
849 int perf_evlist__start_workload(struct perf_evlist
*evlist
)
851 if (evlist
->workload
.cork_fd
> 0) {
853 * Remove the cork, let it rip!
855 return close(evlist
->workload
.cork_fd
);