Loading...
1/*
2 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
3 *
4 * Parts came from builtin-{top,stat,record}.c, see those files for further
5 * copyright notes.
6 *
7 * Released under the GPL v2. (and only v2, not any later version)
8 */
9#include "util.h"
10#include "debugfs.h"
11#include <poll.h>
12#include "cpumap.h"
13#include "thread_map.h"
14#include "target.h"
15#include "evlist.h"
16#include "evsel.h"
17#include <unistd.h>
18
19#include "parse-events.h"
20
21#include <sys/mman.h>
22
23#include <linux/bitops.h>
24#include <linux/hash.h>
25
26#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
27#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
28
29void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
30 struct thread_map *threads)
31{
32 int i;
33
34 for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
35 INIT_HLIST_HEAD(&evlist->heads[i]);
36 INIT_LIST_HEAD(&evlist->entries);
37 perf_evlist__set_maps(evlist, cpus, threads);
38 evlist->workload.pid = -1;
39}
40
41struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
42 struct thread_map *threads)
43{
44 struct perf_evlist *evlist = zalloc(sizeof(*evlist));
45
46 if (evlist != NULL)
47 perf_evlist__init(evlist, cpus, threads);
48
49 return evlist;
50}
51
52void perf_evlist__config_attrs(struct perf_evlist *evlist,
53 struct perf_record_opts *opts)
54{
55 struct perf_evsel *evsel, *first;
56
57 if (evlist->cpus->map[0] < 0)
58 opts->no_inherit = true;
59
60 first = list_entry(evlist->entries.next, struct perf_evsel, node);
61
62 list_for_each_entry(evsel, &evlist->entries, node) {
63 perf_evsel__config(evsel, opts, first);
64
65 if (evlist->nr_entries > 1)
66 evsel->attr.sample_type |= PERF_SAMPLE_ID;
67 }
68}
69
70static void perf_evlist__purge(struct perf_evlist *evlist)
71{
72 struct perf_evsel *pos, *n;
73
74 list_for_each_entry_safe(pos, n, &evlist->entries, node) {
75 list_del_init(&pos->node);
76 perf_evsel__delete(pos);
77 }
78
79 evlist->nr_entries = 0;
80}
81
82void perf_evlist__exit(struct perf_evlist *evlist)
83{
84 free(evlist->mmap);
85 free(evlist->pollfd);
86 evlist->mmap = NULL;
87 evlist->pollfd = NULL;
88}
89
90void perf_evlist__delete(struct perf_evlist *evlist)
91{
92 perf_evlist__purge(evlist);
93 perf_evlist__exit(evlist);
94 free(evlist);
95}
96
97void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
98{
99 list_add_tail(&entry->node, &evlist->entries);
100 ++evlist->nr_entries;
101}
102
103void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
104 struct list_head *list,
105 int nr_entries)
106{
107 list_splice_tail(list, &evlist->entries);
108 evlist->nr_entries += nr_entries;
109}
110
111int perf_evlist__add_default(struct perf_evlist *evlist)
112{
113 struct perf_event_attr attr = {
114 .type = PERF_TYPE_HARDWARE,
115 .config = PERF_COUNT_HW_CPU_CYCLES,
116 };
117 struct perf_evsel *evsel;
118
119 event_attr_init(&attr);
120
121 evsel = perf_evsel__new(&attr, 0);
122 if (evsel == NULL)
123 goto error;
124
125 /* use strdup() because free(evsel) assumes name is allocated */
126 evsel->name = strdup("cycles");
127 if (!evsel->name)
128 goto error_free;
129
130 perf_evlist__add(evlist, evsel);
131 return 0;
132error_free:
133 perf_evsel__delete(evsel);
134error:
135 return -ENOMEM;
136}
137
138int perf_evlist__add_attrs(struct perf_evlist *evlist,
139 struct perf_event_attr *attrs, size_t nr_attrs)
140{
141 struct perf_evsel *evsel, *n;
142 LIST_HEAD(head);
143 size_t i;
144
145 for (i = 0; i < nr_attrs; i++) {
146 evsel = perf_evsel__new(attrs + i, evlist->nr_entries + i);
147 if (evsel == NULL)
148 goto out_delete_partial_list;
149 list_add_tail(&evsel->node, &head);
150 }
151
152 perf_evlist__splice_list_tail(evlist, &head, nr_attrs);
153
154 return 0;
155
156out_delete_partial_list:
157 list_for_each_entry_safe(evsel, n, &head, node)
158 perf_evsel__delete(evsel);
159 return -1;
160}
161
162int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,
163 struct perf_event_attr *attrs, size_t nr_attrs)
164{
165 size_t i;
166
167 for (i = 0; i < nr_attrs; i++)
168 event_attr_init(attrs + i);
169
170 return perf_evlist__add_attrs(evlist, attrs, nr_attrs);
171}
172
173static int trace_event__id(const char *evname)
174{
175 char *filename, *colon;
176 int err = -1, fd;
177
178 if (asprintf(&filename, "%s/%s/id", tracing_events_path, evname) < 0)
179 return -1;
180
181 colon = strrchr(filename, ':');
182 if (colon != NULL)
183 *colon = '/';
184
185 fd = open(filename, O_RDONLY);
186 if (fd >= 0) {
187 char id[16];
188 if (read(fd, id, sizeof(id)) > 0)
189 err = atoi(id);
190 close(fd);
191 }
192
193 free(filename);
194 return err;
195}
196
197int perf_evlist__add_tracepoints(struct perf_evlist *evlist,
198 const char *tracepoints[],
199 size_t nr_tracepoints)
200{
201 int err;
202 size_t i;
203 struct perf_event_attr *attrs = zalloc(nr_tracepoints * sizeof(*attrs));
204
205 if (attrs == NULL)
206 return -1;
207
208 for (i = 0; i < nr_tracepoints; i++) {
209 err = trace_event__id(tracepoints[i]);
210
211 if (err < 0)
212 goto out_free_attrs;
213
214 attrs[i].type = PERF_TYPE_TRACEPOINT;
215 attrs[i].config = err;
216 attrs[i].sample_type = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
217 PERF_SAMPLE_CPU);
218 attrs[i].sample_period = 1;
219 }
220
221 err = perf_evlist__add_attrs(evlist, attrs, nr_tracepoints);
222out_free_attrs:
223 free(attrs);
224 return err;
225}
226
227static struct perf_evsel *
228 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
229{
230 struct perf_evsel *evsel;
231
232 list_for_each_entry(evsel, &evlist->entries, node) {
233 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
234 (int)evsel->attr.config == id)
235 return evsel;
236 }
237
238 return NULL;
239}
240
241int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
242 const struct perf_evsel_str_handler *assocs,
243 size_t nr_assocs)
244{
245 struct perf_evsel *evsel;
246 int err;
247 size_t i;
248
249 for (i = 0; i < nr_assocs; i++) {
250 err = trace_event__id(assocs[i].name);
251 if (err < 0)
252 goto out;
253
254 evsel = perf_evlist__find_tracepoint_by_id(evlist, err);
255 if (evsel == NULL)
256 continue;
257
258 err = -EEXIST;
259 if (evsel->handler.func != NULL)
260 goto out;
261 evsel->handler.func = assocs[i].handler;
262 }
263
264 err = 0;
265out:
266 return err;
267}
268
269void perf_evlist__disable(struct perf_evlist *evlist)
270{
271 int cpu, thread;
272 struct perf_evsel *pos;
273
274 for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
275 list_for_each_entry(pos, &evlist->entries, node) {
276 for (thread = 0; thread < evlist->threads->nr; thread++)
277 ioctl(FD(pos, cpu, thread),
278 PERF_EVENT_IOC_DISABLE, 0);
279 }
280 }
281}
282
283void perf_evlist__enable(struct perf_evlist *evlist)
284{
285 int cpu, thread;
286 struct perf_evsel *pos;
287
288 for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
289 list_for_each_entry(pos, &evlist->entries, node) {
290 for (thread = 0; thread < evlist->threads->nr; thread++)
291 ioctl(FD(pos, cpu, thread),
292 PERF_EVENT_IOC_ENABLE, 0);
293 }
294 }
295}
296
297static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
298{
299 int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
300 evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
301 return evlist->pollfd != NULL ? 0 : -ENOMEM;
302}
303
304void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
305{
306 fcntl(fd, F_SETFL, O_NONBLOCK);
307 evlist->pollfd[evlist->nr_fds].fd = fd;
308 evlist->pollfd[evlist->nr_fds].events = POLLIN;
309 evlist->nr_fds++;
310}
311
312static void perf_evlist__id_hash(struct perf_evlist *evlist,
313 struct perf_evsel *evsel,
314 int cpu, int thread, u64 id)
315{
316 int hash;
317 struct perf_sample_id *sid = SID(evsel, cpu, thread);
318
319 sid->id = id;
320 sid->evsel = evsel;
321 hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
322 hlist_add_head(&sid->node, &evlist->heads[hash]);
323}
324
325void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
326 int cpu, int thread, u64 id)
327{
328 perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
329 evsel->id[evsel->ids++] = id;
330}
331
332static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
333 struct perf_evsel *evsel,
334 int cpu, int thread, int fd)
335{
336 u64 read_data[4] = { 0, };
337 int id_idx = 1; /* The first entry is the counter value */
338
339 if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
340 read(fd, &read_data, sizeof(read_data)) == -1)
341 return -1;
342
343 if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
344 ++id_idx;
345 if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
346 ++id_idx;
347
348 perf_evlist__id_add(evlist, evsel, cpu, thread, read_data[id_idx]);
349 return 0;
350}
351
352struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
353{
354 struct hlist_head *head;
355 struct hlist_node *pos;
356 struct perf_sample_id *sid;
357 int hash;
358
359 if (evlist->nr_entries == 1)
360 return list_entry(evlist->entries.next, struct perf_evsel, node);
361
362 hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
363 head = &evlist->heads[hash];
364
365 hlist_for_each_entry(sid, pos, head, node)
366 if (sid->id == id)
367 return sid->evsel;
368
369 if (!perf_evlist__sample_id_all(evlist))
370 return list_entry(evlist->entries.next, struct perf_evsel, node);
371
372 return NULL;
373}
374
375union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
376{
377 /* XXX Move this to perf.c, making it generally available */
378 unsigned int page_size = sysconf(_SC_PAGE_SIZE);
379 struct perf_mmap *md = &evlist->mmap[idx];
380 unsigned int head = perf_mmap__read_head(md);
381 unsigned int old = md->prev;
382 unsigned char *data = md->base + page_size;
383 union perf_event *event = NULL;
384
385 if (evlist->overwrite) {
386 /*
387 * If we're further behind than half the buffer, there's a chance
388 * the writer will bite our tail and mess up the samples under us.
389 *
390 * If we somehow ended up ahead of the head, we got messed up.
391 *
392 * In either case, truncate and restart at head.
393 */
394 int diff = head - old;
395 if (diff > md->mask / 2 || diff < 0) {
396 fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
397
398 /*
399 * head points to a known good entry, start there.
400 */
401 old = head;
402 }
403 }
404
405 if (old != head) {
406 size_t size;
407
408 event = (union perf_event *)&data[old & md->mask];
409 size = event->header.size;
410
411 /*
412 * Event straddles the mmap boundary -- header should always
413 * be inside due to u64 alignment of output.
414 */
415 if ((old & md->mask) + size != ((old + size) & md->mask)) {
416 unsigned int offset = old;
417 unsigned int len = min(sizeof(*event), size), cpy;
418 void *dst = &evlist->event_copy;
419
420 do {
421 cpy = min(md->mask + 1 - (offset & md->mask), len);
422 memcpy(dst, &data[offset & md->mask], cpy);
423 offset += cpy;
424 dst += cpy;
425 len -= cpy;
426 } while (len);
427
428 event = &evlist->event_copy;
429 }
430
431 old += size;
432 }
433
434 md->prev = old;
435
436 if (!evlist->overwrite)
437 perf_mmap__write_tail(md, old);
438
439 return event;
440}
441
442void perf_evlist__munmap(struct perf_evlist *evlist)
443{
444 int i;
445
446 for (i = 0; i < evlist->nr_mmaps; i++) {
447 if (evlist->mmap[i].base != NULL) {
448 munmap(evlist->mmap[i].base, evlist->mmap_len);
449 evlist->mmap[i].base = NULL;
450 }
451 }
452
453 free(evlist->mmap);
454 evlist->mmap = NULL;
455}
456
457static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
458{
459 evlist->nr_mmaps = evlist->cpus->nr;
460 if (evlist->cpus->map[0] == -1)
461 evlist->nr_mmaps = evlist->threads->nr;
462 evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
463 return evlist->mmap != NULL ? 0 : -ENOMEM;
464}
465
466static int __perf_evlist__mmap(struct perf_evlist *evlist,
467 int idx, int prot, int mask, int fd)
468{
469 evlist->mmap[idx].prev = 0;
470 evlist->mmap[idx].mask = mask;
471 evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
472 MAP_SHARED, fd, 0);
473 if (evlist->mmap[idx].base == MAP_FAILED) {
474 evlist->mmap[idx].base = NULL;
475 return -1;
476 }
477
478 perf_evlist__add_pollfd(evlist, fd);
479 return 0;
480}
481
482static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int mask)
483{
484 struct perf_evsel *evsel;
485 int cpu, thread;
486
487 for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
488 int output = -1;
489
490 for (thread = 0; thread < evlist->threads->nr; thread++) {
491 list_for_each_entry(evsel, &evlist->entries, node) {
492 int fd = FD(evsel, cpu, thread);
493
494 if (output == -1) {
495 output = fd;
496 if (__perf_evlist__mmap(evlist, cpu,
497 prot, mask, output) < 0)
498 goto out_unmap;
499 } else {
500 if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
501 goto out_unmap;
502 }
503
504 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
505 perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
506 goto out_unmap;
507 }
508 }
509 }
510
511 return 0;
512
513out_unmap:
514 for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
515 if (evlist->mmap[cpu].base != NULL) {
516 munmap(evlist->mmap[cpu].base, evlist->mmap_len);
517 evlist->mmap[cpu].base = NULL;
518 }
519 }
520 return -1;
521}
522
523static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, int mask)
524{
525 struct perf_evsel *evsel;
526 int thread;
527
528 for (thread = 0; thread < evlist->threads->nr; thread++) {
529 int output = -1;
530
531 list_for_each_entry(evsel, &evlist->entries, node) {
532 int fd = FD(evsel, 0, thread);
533
534 if (output == -1) {
535 output = fd;
536 if (__perf_evlist__mmap(evlist, thread,
537 prot, mask, output) < 0)
538 goto out_unmap;
539 } else {
540 if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
541 goto out_unmap;
542 }
543
544 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
545 perf_evlist__id_add_fd(evlist, evsel, 0, thread, fd) < 0)
546 goto out_unmap;
547 }
548 }
549
550 return 0;
551
552out_unmap:
553 for (thread = 0; thread < evlist->threads->nr; thread++) {
554 if (evlist->mmap[thread].base != NULL) {
555 munmap(evlist->mmap[thread].base, evlist->mmap_len);
556 evlist->mmap[thread].base = NULL;
557 }
558 }
559 return -1;
560}
561
562/** perf_evlist__mmap - Create per cpu maps to receive events
563 *
564 * @evlist - list of events
565 * @pages - map length in pages
566 * @overwrite - overwrite older events?
567 *
568 * If overwrite is false the user needs to signal event consuption using:
569 *
570 * struct perf_mmap *m = &evlist->mmap[cpu];
571 * unsigned int head = perf_mmap__read_head(m);
572 *
573 * perf_mmap__write_tail(m, head)
574 *
575 * Using perf_evlist__read_on_cpu does this automatically.
576 */
577int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
578 bool overwrite)
579{
580 unsigned int page_size = sysconf(_SC_PAGE_SIZE);
581 struct perf_evsel *evsel;
582 const struct cpu_map *cpus = evlist->cpus;
583 const struct thread_map *threads = evlist->threads;
584 int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), mask;
585
586 /* 512 kiB: default amount of unprivileged mlocked memory */
587 if (pages == UINT_MAX)
588 pages = (512 * 1024) / page_size;
589 else if (!is_power_of_2(pages))
590 return -EINVAL;
591
592 mask = pages * page_size - 1;
593
594 if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
595 return -ENOMEM;
596
597 if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
598 return -ENOMEM;
599
600 evlist->overwrite = overwrite;
601 evlist->mmap_len = (pages + 1) * page_size;
602
603 list_for_each_entry(evsel, &evlist->entries, node) {
604 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
605 evsel->sample_id == NULL &&
606 perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0)
607 return -ENOMEM;
608 }
609
610 if (evlist->cpus->map[0] == -1)
611 return perf_evlist__mmap_per_thread(evlist, prot, mask);
612
613 return perf_evlist__mmap_per_cpu(evlist, prot, mask);
614}
615
616int perf_evlist__create_maps(struct perf_evlist *evlist,
617 struct perf_target *target)
618{
619 evlist->threads = thread_map__new_str(target->pid, target->tid,
620 target->uid);
621
622 if (evlist->threads == NULL)
623 return -1;
624
625 if (perf_target__has_task(target))
626 evlist->cpus = cpu_map__dummy_new();
627 else if (!perf_target__has_cpu(target) && !target->uses_mmap)
628 evlist->cpus = cpu_map__dummy_new();
629 else
630 evlist->cpus = cpu_map__new(target->cpu_list);
631
632 if (evlist->cpus == NULL)
633 goto out_delete_threads;
634
635 return 0;
636
637out_delete_threads:
638 thread_map__delete(evlist->threads);
639 return -1;
640}
641
642void perf_evlist__delete_maps(struct perf_evlist *evlist)
643{
644 cpu_map__delete(evlist->cpus);
645 thread_map__delete(evlist->threads);
646 evlist->cpus = NULL;
647 evlist->threads = NULL;
648}
649
650int perf_evlist__set_filters(struct perf_evlist *evlist)
651{
652 const struct thread_map *threads = evlist->threads;
653 const struct cpu_map *cpus = evlist->cpus;
654 struct perf_evsel *evsel;
655 char *filter;
656 int thread;
657 int cpu;
658 int err;
659 int fd;
660
661 list_for_each_entry(evsel, &evlist->entries, node) {
662 filter = evsel->filter;
663 if (!filter)
664 continue;
665 for (cpu = 0; cpu < cpus->nr; cpu++) {
666 for (thread = 0; thread < threads->nr; thread++) {
667 fd = FD(evsel, cpu, thread);
668 err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
669 if (err)
670 return err;
671 }
672 }
673 }
674
675 return 0;
676}
677
678bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist)
679{
680 struct perf_evsel *pos, *first;
681
682 pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
683
684 list_for_each_entry_continue(pos, &evlist->entries, node) {
685 if (first->attr.sample_type != pos->attr.sample_type)
686 return false;
687 }
688
689 return true;
690}
691
692u64 perf_evlist__sample_type(const struct perf_evlist *evlist)
693{
694 struct perf_evsel *first;
695
696 first = list_entry(evlist->entries.next, struct perf_evsel, node);
697 return first->attr.sample_type;
698}
699
700u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist)
701{
702 struct perf_evsel *first;
703 struct perf_sample *data;
704 u64 sample_type;
705 u16 size = 0;
706
707 first = list_entry(evlist->entries.next, struct perf_evsel, node);
708
709 if (!first->attr.sample_id_all)
710 goto out;
711
712 sample_type = first->attr.sample_type;
713
714 if (sample_type & PERF_SAMPLE_TID)
715 size += sizeof(data->tid) * 2;
716
717 if (sample_type & PERF_SAMPLE_TIME)
718 size += sizeof(data->time);
719
720 if (sample_type & PERF_SAMPLE_ID)
721 size += sizeof(data->id);
722
723 if (sample_type & PERF_SAMPLE_STREAM_ID)
724 size += sizeof(data->stream_id);
725
726 if (sample_type & PERF_SAMPLE_CPU)
727 size += sizeof(data->cpu) * 2;
728out:
729 return size;
730}
731
732bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
733{
734 struct perf_evsel *pos, *first;
735
736 pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
737
738 list_for_each_entry_continue(pos, &evlist->entries, node) {
739 if (first->attr.sample_id_all != pos->attr.sample_id_all)
740 return false;
741 }
742
743 return true;
744}
745
746bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
747{
748 struct perf_evsel *first;
749
750 first = list_entry(evlist->entries.next, struct perf_evsel, node);
751 return first->attr.sample_id_all;
752}
753
754void perf_evlist__set_selected(struct perf_evlist *evlist,
755 struct perf_evsel *evsel)
756{
757 evlist->selected = evsel;
758}
759
760int perf_evlist__open(struct perf_evlist *evlist, bool group)
761{
762 struct perf_evsel *evsel, *first;
763 int err, ncpus, nthreads;
764
765 first = list_entry(evlist->entries.next, struct perf_evsel, node);
766
767 list_for_each_entry(evsel, &evlist->entries, node) {
768 struct xyarray *group_fd = NULL;
769
770 if (group && evsel != first)
771 group_fd = first->fd;
772
773 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads,
774 group, group_fd);
775 if (err < 0)
776 goto out_err;
777 }
778
779 return 0;
780out_err:
781 ncpus = evlist->cpus ? evlist->cpus->nr : 1;
782 nthreads = evlist->threads ? evlist->threads->nr : 1;
783
784 list_for_each_entry_reverse(evsel, &evlist->entries, node)
785 perf_evsel__close(evsel, ncpus, nthreads);
786
787 errno = -err;
788 return err;
789}
790
791int perf_evlist__prepare_workload(struct perf_evlist *evlist,
792 struct perf_record_opts *opts,
793 const char *argv[])
794{
795 int child_ready_pipe[2], go_pipe[2];
796 char bf;
797
798 if (pipe(child_ready_pipe) < 0) {
799 perror("failed to create 'ready' pipe");
800 return -1;
801 }
802
803 if (pipe(go_pipe) < 0) {
804 perror("failed to create 'go' pipe");
805 goto out_close_ready_pipe;
806 }
807
808 evlist->workload.pid = fork();
809 if (evlist->workload.pid < 0) {
810 perror("failed to fork");
811 goto out_close_pipes;
812 }
813
814 if (!evlist->workload.pid) {
815 if (opts->pipe_output)
816 dup2(2, 1);
817
818 close(child_ready_pipe[0]);
819 close(go_pipe[1]);
820 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
821
822 /*
823 * Do a dummy execvp to get the PLT entry resolved,
824 * so we avoid the resolver overhead on the real
825 * execvp call.
826 */
827 execvp("", (char **)argv);
828
829 /*
830 * Tell the parent we're ready to go
831 */
832 close(child_ready_pipe[1]);
833
834 /*
835 * Wait until the parent tells us to go.
836 */
837 if (read(go_pipe[0], &bf, 1) == -1)
838 perror("unable to read pipe");
839
840 execvp(argv[0], (char **)argv);
841
842 perror(argv[0]);
843 kill(getppid(), SIGUSR1);
844 exit(-1);
845 }
846
847 if (perf_target__none(&opts->target))
848 evlist->threads->map[0] = evlist->workload.pid;
849
850 close(child_ready_pipe[1]);
851 close(go_pipe[0]);
852 /*
853 * wait for child to settle
854 */
855 if (read(child_ready_pipe[0], &bf, 1) == -1) {
856 perror("unable to read pipe");
857 goto out_close_pipes;
858 }
859
860 evlist->workload.cork_fd = go_pipe[1];
861 close(child_ready_pipe[0]);
862 return 0;
863
864out_close_pipes:
865 close(go_pipe[0]);
866 close(go_pipe[1]);
867out_close_ready_pipe:
868 close(child_ready_pipe[0]);
869 close(child_ready_pipe[1]);
870 return -1;
871}
872
873int perf_evlist__start_workload(struct perf_evlist *evlist)
874{
875 if (evlist->workload.cork_fd > 0) {
876 /*
877 * Remove the cork, let it rip!
878 */
879 return close(evlist->workload.cork_fd);
880 }
881
882 return 0;
883}
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
4 *
5 * Parts came from builtin-{top,stat,record}.c, see those files for further
6 * copyright notes.
7 */
8#include <api/fs/fs.h>
9#include <errno.h>
10#include <inttypes.h>
11#include <poll.h>
12#include "cpumap.h"
13#include "util/mmap.h"
14#include "thread_map.h"
15#include "target.h"
16#include "evlist.h"
17#include "evsel.h"
18#include "debug.h"
19#include "units.h"
20#include <internal/lib.h> // page_size
21#include "affinity.h"
22#include "../perf.h"
23#include "asm/bug.h"
24#include "bpf-event.h"
25#include "util/string2.h"
26#include "util/perf_api_probe.h"
27#include <signal.h>
28#include <unistd.h>
29#include <sched.h>
30#include <stdlib.h>
31
32#include "parse-events.h"
33#include <subcmd/parse-options.h>
34
35#include <fcntl.h>
36#include <sys/ioctl.h>
37#include <sys/mman.h>
38
39#include <linux/bitops.h>
40#include <linux/hash.h>
41#include <linux/log2.h>
42#include <linux/err.h>
43#include <linux/string.h>
44#include <linux/zalloc.h>
45#include <perf/evlist.h>
46#include <perf/evsel.h>
47#include <perf/cpumap.h>
48#include <perf/mmap.h>
49
50#include <internal/xyarray.h>
51
52#ifdef LACKS_SIGQUEUE_PROTOTYPE
53int sigqueue(pid_t pid, int sig, const union sigval value);
54#endif
55
56#define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y))
57#define SID(e, x, y) xyarray__entry(e->core.sample_id, x, y)
58
59void evlist__init(struct evlist *evlist, struct perf_cpu_map *cpus,
60 struct perf_thread_map *threads)
61{
62 perf_evlist__init(&evlist->core);
63 perf_evlist__set_maps(&evlist->core, cpus, threads);
64 evlist->workload.pid = -1;
65 evlist->bkw_mmap_state = BKW_MMAP_NOTREADY;
66 evlist->ctl_fd.fd = -1;
67 evlist->ctl_fd.ack = -1;
68 evlist->ctl_fd.pos = -1;
69}
70
71struct evlist *evlist__new(void)
72{
73 struct evlist *evlist = zalloc(sizeof(*evlist));
74
75 if (evlist != NULL)
76 evlist__init(evlist, NULL, NULL);
77
78 return evlist;
79}
80
81struct evlist *perf_evlist__new_default(void)
82{
83 struct evlist *evlist = evlist__new();
84
85 if (evlist && evlist__add_default(evlist)) {
86 evlist__delete(evlist);
87 evlist = NULL;
88 }
89
90 return evlist;
91}
92
93struct evlist *perf_evlist__new_dummy(void)
94{
95 struct evlist *evlist = evlist__new();
96
97 if (evlist && evlist__add_dummy(evlist)) {
98 evlist__delete(evlist);
99 evlist = NULL;
100 }
101
102 return evlist;
103}
104
105/**
106 * perf_evlist__set_id_pos - set the positions of event ids.
107 * @evlist: selected event list
108 *
109 * Events with compatible sample types all have the same id_pos
110 * and is_pos. For convenience, put a copy on evlist.
111 */
112void perf_evlist__set_id_pos(struct evlist *evlist)
113{
114 struct evsel *first = evlist__first(evlist);
115
116 evlist->id_pos = first->id_pos;
117 evlist->is_pos = first->is_pos;
118}
119
120static void perf_evlist__update_id_pos(struct evlist *evlist)
121{
122 struct evsel *evsel;
123
124 evlist__for_each_entry(evlist, evsel)
125 evsel__calc_id_pos(evsel);
126
127 perf_evlist__set_id_pos(evlist);
128}
129
130static void evlist__purge(struct evlist *evlist)
131{
132 struct evsel *pos, *n;
133
134 evlist__for_each_entry_safe(evlist, n, pos) {
135 list_del_init(&pos->core.node);
136 pos->evlist = NULL;
137 evsel__delete(pos);
138 }
139
140 evlist->core.nr_entries = 0;
141}
142
143void evlist__exit(struct evlist *evlist)
144{
145 zfree(&evlist->mmap);
146 zfree(&evlist->overwrite_mmap);
147 perf_evlist__exit(&evlist->core);
148}
149
150void evlist__delete(struct evlist *evlist)
151{
152 if (evlist == NULL)
153 return;
154
155 evlist__munmap(evlist);
156 evlist__close(evlist);
157 evlist__purge(evlist);
158 evlist__exit(evlist);
159 free(evlist);
160}
161
162void evlist__add(struct evlist *evlist, struct evsel *entry)
163{
164 entry->evlist = evlist;
165 entry->idx = evlist->core.nr_entries;
166 entry->tracking = !entry->idx;
167
168 perf_evlist__add(&evlist->core, &entry->core);
169
170 if (evlist->core.nr_entries == 1)
171 perf_evlist__set_id_pos(evlist);
172}
173
174void evlist__remove(struct evlist *evlist, struct evsel *evsel)
175{
176 evsel->evlist = NULL;
177 perf_evlist__remove(&evlist->core, &evsel->core);
178}
179
180void perf_evlist__splice_list_tail(struct evlist *evlist,
181 struct list_head *list)
182{
183 struct evsel *evsel, *temp;
184
185 __evlist__for_each_entry_safe(list, temp, evsel) {
186 list_del_init(&evsel->core.node);
187 evlist__add(evlist, evsel);
188 }
189}
190
191int __evlist__set_tracepoints_handlers(struct evlist *evlist,
192 const struct evsel_str_handler *assocs, size_t nr_assocs)
193{
194 struct evsel *evsel;
195 size_t i;
196 int err;
197
198 for (i = 0; i < nr_assocs; i++) {
199 // Adding a handler for an event not in this evlist, just ignore it.
200 evsel = perf_evlist__find_tracepoint_by_name(evlist, assocs[i].name);
201 if (evsel == NULL)
202 continue;
203
204 err = -EEXIST;
205 if (evsel->handler != NULL)
206 goto out;
207 evsel->handler = assocs[i].handler;
208 }
209
210 err = 0;
211out:
212 return err;
213}
214
215void __perf_evlist__set_leader(struct list_head *list)
216{
217 struct evsel *evsel, *leader;
218
219 leader = list_entry(list->next, struct evsel, core.node);
220 evsel = list_entry(list->prev, struct evsel, core.node);
221
222 leader->core.nr_members = evsel->idx - leader->idx + 1;
223
224 __evlist__for_each_entry(list, evsel) {
225 evsel->leader = leader;
226 }
227}
228
229void perf_evlist__set_leader(struct evlist *evlist)
230{
231 if (evlist->core.nr_entries) {
232 evlist->nr_groups = evlist->core.nr_entries > 1 ? 1 : 0;
233 __perf_evlist__set_leader(&evlist->core.entries);
234 }
235}
236
237int __evlist__add_default(struct evlist *evlist, bool precise)
238{
239 struct evsel *evsel = evsel__new_cycles(precise);
240
241 if (evsel == NULL)
242 return -ENOMEM;
243
244 evlist__add(evlist, evsel);
245 return 0;
246}
247
248int evlist__add_dummy(struct evlist *evlist)
249{
250 struct perf_event_attr attr = {
251 .type = PERF_TYPE_SOFTWARE,
252 .config = PERF_COUNT_SW_DUMMY,
253 .size = sizeof(attr), /* to capture ABI version */
254 };
255 struct evsel *evsel = evsel__new_idx(&attr, evlist->core.nr_entries);
256
257 if (evsel == NULL)
258 return -ENOMEM;
259
260 evlist__add(evlist, evsel);
261 return 0;
262}
263
264static int evlist__add_attrs(struct evlist *evlist, struct perf_event_attr *attrs, size_t nr_attrs)
265{
266 struct evsel *evsel, *n;
267 LIST_HEAD(head);
268 size_t i;
269
270 for (i = 0; i < nr_attrs; i++) {
271 evsel = evsel__new_idx(attrs + i, evlist->core.nr_entries + i);
272 if (evsel == NULL)
273 goto out_delete_partial_list;
274 list_add_tail(&evsel->core.node, &head);
275 }
276
277 perf_evlist__splice_list_tail(evlist, &head);
278
279 return 0;
280
281out_delete_partial_list:
282 __evlist__for_each_entry_safe(&head, n, evsel)
283 evsel__delete(evsel);
284 return -1;
285}
286
287int __evlist__add_default_attrs(struct evlist *evlist, struct perf_event_attr *attrs, size_t nr_attrs)
288{
289 size_t i;
290
291 for (i = 0; i < nr_attrs; i++)
292 event_attr_init(attrs + i);
293
294 return evlist__add_attrs(evlist, attrs, nr_attrs);
295}
296
297struct evsel *
298perf_evlist__find_tracepoint_by_id(struct evlist *evlist, int id)
299{
300 struct evsel *evsel;
301
302 evlist__for_each_entry(evlist, evsel) {
303 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT &&
304 (int)evsel->core.attr.config == id)
305 return evsel;
306 }
307
308 return NULL;
309}
310
311struct evsel *
312perf_evlist__find_tracepoint_by_name(struct evlist *evlist,
313 const char *name)
314{
315 struct evsel *evsel;
316
317 evlist__for_each_entry(evlist, evsel) {
318 if ((evsel->core.attr.type == PERF_TYPE_TRACEPOINT) &&
319 (strcmp(evsel->name, name) == 0))
320 return evsel;
321 }
322
323 return NULL;
324}
325
326int evlist__add_newtp(struct evlist *evlist, const char *sys, const char *name, void *handler)
327{
328 struct evsel *evsel = evsel__newtp(sys, name);
329
330 if (IS_ERR(evsel))
331 return -1;
332
333 evsel->handler = handler;
334 evlist__add(evlist, evsel);
335 return 0;
336}
337
338static int perf_evlist__nr_threads(struct evlist *evlist,
339 struct evsel *evsel)
340{
341 if (evsel->core.system_wide)
342 return 1;
343 else
344 return perf_thread_map__nr(evlist->core.threads);
345}
346
347void evlist__cpu_iter_start(struct evlist *evlist)
348{
349 struct evsel *pos;
350
351 /*
352 * Reset the per evsel cpu_iter. This is needed because
353 * each evsel's cpumap may have a different index space,
354 * and some operations need the index to modify
355 * the FD xyarray (e.g. open, close)
356 */
357 evlist__for_each_entry(evlist, pos)
358 pos->cpu_iter = 0;
359}
360
361bool evsel__cpu_iter_skip_no_inc(struct evsel *ev, int cpu)
362{
363 if (ev->cpu_iter >= ev->core.cpus->nr)
364 return true;
365 if (cpu >= 0 && ev->core.cpus->map[ev->cpu_iter] != cpu)
366 return true;
367 return false;
368}
369
370bool evsel__cpu_iter_skip(struct evsel *ev, int cpu)
371{
372 if (!evsel__cpu_iter_skip_no_inc(ev, cpu)) {
373 ev->cpu_iter++;
374 return false;
375 }
376 return true;
377}
378
379void evlist__disable(struct evlist *evlist)
380{
381 struct evsel *pos;
382 struct affinity affinity;
383 int cpu, i, imm = 0;
384 bool has_imm = false;
385
386 if (affinity__setup(&affinity) < 0)
387 return;
388
389 /* Disable 'immediate' events last */
390 for (imm = 0; imm <= 1; imm++) {
391 evlist__for_each_cpu(evlist, i, cpu) {
392 affinity__set(&affinity, cpu);
393
394 evlist__for_each_entry(evlist, pos) {
395 if (evsel__cpu_iter_skip(pos, cpu))
396 continue;
397 if (pos->disabled || !evsel__is_group_leader(pos) || !pos->core.fd)
398 continue;
399 if (pos->immediate)
400 has_imm = true;
401 if (pos->immediate != imm)
402 continue;
403 evsel__disable_cpu(pos, pos->cpu_iter - 1);
404 }
405 }
406 if (!has_imm)
407 break;
408 }
409
410 affinity__cleanup(&affinity);
411 evlist__for_each_entry(evlist, pos) {
412 if (!evsel__is_group_leader(pos) || !pos->core.fd)
413 continue;
414 pos->disabled = true;
415 }
416
417 evlist->enabled = false;
418}
419
420void evlist__enable(struct evlist *evlist)
421{
422 struct evsel *pos;
423 struct affinity affinity;
424 int cpu, i;
425
426 if (affinity__setup(&affinity) < 0)
427 return;
428
429 evlist__for_each_cpu(evlist, i, cpu) {
430 affinity__set(&affinity, cpu);
431
432 evlist__for_each_entry(evlist, pos) {
433 if (evsel__cpu_iter_skip(pos, cpu))
434 continue;
435 if (!evsel__is_group_leader(pos) || !pos->core.fd)
436 continue;
437 evsel__enable_cpu(pos, pos->cpu_iter - 1);
438 }
439 }
440 affinity__cleanup(&affinity);
441 evlist__for_each_entry(evlist, pos) {
442 if (!evsel__is_group_leader(pos) || !pos->core.fd)
443 continue;
444 pos->disabled = false;
445 }
446
447 evlist->enabled = true;
448}
449
450void perf_evlist__toggle_enable(struct evlist *evlist)
451{
452 (evlist->enabled ? evlist__disable : evlist__enable)(evlist);
453}
454
455static int perf_evlist__enable_event_cpu(struct evlist *evlist,
456 struct evsel *evsel, int cpu)
457{
458 int thread;
459 int nr_threads = perf_evlist__nr_threads(evlist, evsel);
460
461 if (!evsel->core.fd)
462 return -EINVAL;
463
464 for (thread = 0; thread < nr_threads; thread++) {
465 int err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
466 if (err)
467 return err;
468 }
469 return 0;
470}
471
472static int perf_evlist__enable_event_thread(struct evlist *evlist,
473 struct evsel *evsel,
474 int thread)
475{
476 int cpu;
477 int nr_cpus = perf_cpu_map__nr(evlist->core.cpus);
478
479 if (!evsel->core.fd)
480 return -EINVAL;
481
482 for (cpu = 0; cpu < nr_cpus; cpu++) {
483 int err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
484 if (err)
485 return err;
486 }
487 return 0;
488}
489
490int perf_evlist__enable_event_idx(struct evlist *evlist,
491 struct evsel *evsel, int idx)
492{
493 bool per_cpu_mmaps = !perf_cpu_map__empty(evlist->core.cpus);
494
495 if (per_cpu_mmaps)
496 return perf_evlist__enable_event_cpu(evlist, evsel, idx);
497 else
498 return perf_evlist__enable_event_thread(evlist, evsel, idx);
499}
500
501int evlist__add_pollfd(struct evlist *evlist, int fd)
502{
503 return perf_evlist__add_pollfd(&evlist->core, fd, NULL, POLLIN, fdarray_flag__default);
504}
505
506int evlist__filter_pollfd(struct evlist *evlist, short revents_and_mask)
507{
508 return perf_evlist__filter_pollfd(&evlist->core, revents_and_mask);
509}
510
511int evlist__poll(struct evlist *evlist, int timeout)
512{
513 return perf_evlist__poll(&evlist->core, timeout);
514}
515
516struct perf_sample_id *perf_evlist__id2sid(struct evlist *evlist, u64 id)
517{
518 struct hlist_head *head;
519 struct perf_sample_id *sid;
520 int hash;
521
522 hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
523 head = &evlist->core.heads[hash];
524
525 hlist_for_each_entry(sid, head, node)
526 if (sid->id == id)
527 return sid;
528
529 return NULL;
530}
531
532struct evsel *perf_evlist__id2evsel(struct evlist *evlist, u64 id)
533{
534 struct perf_sample_id *sid;
535
536 if (evlist->core.nr_entries == 1 || !id)
537 return evlist__first(evlist);
538
539 sid = perf_evlist__id2sid(evlist, id);
540 if (sid)
541 return container_of(sid->evsel, struct evsel, core);
542
543 if (!evlist__sample_id_all(evlist))
544 return evlist__first(evlist);
545
546 return NULL;
547}
548
549struct evsel *perf_evlist__id2evsel_strict(struct evlist *evlist,
550 u64 id)
551{
552 struct perf_sample_id *sid;
553
554 if (!id)
555 return NULL;
556
557 sid = perf_evlist__id2sid(evlist, id);
558 if (sid)
559 return container_of(sid->evsel, struct evsel, core);
560
561 return NULL;
562}
563
564static int perf_evlist__event2id(struct evlist *evlist,
565 union perf_event *event, u64 *id)
566{
567 const __u64 *array = event->sample.array;
568 ssize_t n;
569
570 n = (event->header.size - sizeof(event->header)) >> 3;
571
572 if (event->header.type == PERF_RECORD_SAMPLE) {
573 if (evlist->id_pos >= n)
574 return -1;
575 *id = array[evlist->id_pos];
576 } else {
577 if (evlist->is_pos > n)
578 return -1;
579 n -= evlist->is_pos;
580 *id = array[n];
581 }
582 return 0;
583}
584
585struct evsel *perf_evlist__event2evsel(struct evlist *evlist,
586 union perf_event *event)
587{
588 struct evsel *first = evlist__first(evlist);
589 struct hlist_head *head;
590 struct perf_sample_id *sid;
591 int hash;
592 u64 id;
593
594 if (evlist->core.nr_entries == 1)
595 return first;
596
597 if (!first->core.attr.sample_id_all &&
598 event->header.type != PERF_RECORD_SAMPLE)
599 return first;
600
601 if (perf_evlist__event2id(evlist, event, &id))
602 return NULL;
603
604 /* Synthesized events have an id of zero */
605 if (!id)
606 return first;
607
608 hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
609 head = &evlist->core.heads[hash];
610
611 hlist_for_each_entry(sid, head, node) {
612 if (sid->id == id)
613 return container_of(sid->evsel, struct evsel, core);
614 }
615 return NULL;
616}
617
618static int perf_evlist__set_paused(struct evlist *evlist, bool value)
619{
620 int i;
621
622 if (!evlist->overwrite_mmap)
623 return 0;
624
625 for (i = 0; i < evlist->core.nr_mmaps; i++) {
626 int fd = evlist->overwrite_mmap[i].core.fd;
627 int err;
628
629 if (fd < 0)
630 continue;
631 err = ioctl(fd, PERF_EVENT_IOC_PAUSE_OUTPUT, value ? 1 : 0);
632 if (err)
633 return err;
634 }
635 return 0;
636}
637
638static int perf_evlist__pause(struct evlist *evlist)
639{
640 return perf_evlist__set_paused(evlist, true);
641}
642
643static int perf_evlist__resume(struct evlist *evlist)
644{
645 return perf_evlist__set_paused(evlist, false);
646}
647
648static void evlist__munmap_nofree(struct evlist *evlist)
649{
650 int i;
651
652 if (evlist->mmap)
653 for (i = 0; i < evlist->core.nr_mmaps; i++)
654 perf_mmap__munmap(&evlist->mmap[i].core);
655
656 if (evlist->overwrite_mmap)
657 for (i = 0; i < evlist->core.nr_mmaps; i++)
658 perf_mmap__munmap(&evlist->overwrite_mmap[i].core);
659}
660
661void evlist__munmap(struct evlist *evlist)
662{
663 evlist__munmap_nofree(evlist);
664 zfree(&evlist->mmap);
665 zfree(&evlist->overwrite_mmap);
666}
667
668static void perf_mmap__unmap_cb(struct perf_mmap *map)
669{
670 struct mmap *m = container_of(map, struct mmap, core);
671
672 mmap__munmap(m);
673}
674
675static struct mmap *evlist__alloc_mmap(struct evlist *evlist,
676 bool overwrite)
677{
678 int i;
679 struct mmap *map;
680
681 map = zalloc(evlist->core.nr_mmaps * sizeof(struct mmap));
682 if (!map)
683 return NULL;
684
685 for (i = 0; i < evlist->core.nr_mmaps; i++) {
686 struct perf_mmap *prev = i ? &map[i - 1].core : NULL;
687
688 /*
689 * When the perf_mmap() call is made we grab one refcount, plus
690 * one extra to let perf_mmap__consume() get the last
691 * events after all real references (perf_mmap__get()) are
692 * dropped.
693 *
694 * Each PERF_EVENT_IOC_SET_OUTPUT points to this mmap and
695 * thus does perf_mmap__get() on it.
696 */
697 perf_mmap__init(&map[i].core, prev, overwrite, perf_mmap__unmap_cb);
698 }
699
700 return map;
701}
702
703static void
704perf_evlist__mmap_cb_idx(struct perf_evlist *_evlist,
705 struct perf_mmap_param *_mp,
706 int idx, bool per_cpu)
707{
708 struct evlist *evlist = container_of(_evlist, struct evlist, core);
709 struct mmap_params *mp = container_of(_mp, struct mmap_params, core);
710
711 auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, idx, per_cpu);
712}
713
714static struct perf_mmap*
715perf_evlist__mmap_cb_get(struct perf_evlist *_evlist, bool overwrite, int idx)
716{
717 struct evlist *evlist = container_of(_evlist, struct evlist, core);
718 struct mmap *maps;
719
720 maps = overwrite ? evlist->overwrite_mmap : evlist->mmap;
721
722 if (!maps) {
723 maps = evlist__alloc_mmap(evlist, overwrite);
724 if (!maps)
725 return NULL;
726
727 if (overwrite) {
728 evlist->overwrite_mmap = maps;
729 if (evlist->bkw_mmap_state == BKW_MMAP_NOTREADY)
730 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_RUNNING);
731 } else {
732 evlist->mmap = maps;
733 }
734 }
735
736 return &maps[idx].core;
737}
738
739static int
740perf_evlist__mmap_cb_mmap(struct perf_mmap *_map, struct perf_mmap_param *_mp,
741 int output, int cpu)
742{
743 struct mmap *map = container_of(_map, struct mmap, core);
744 struct mmap_params *mp = container_of(_mp, struct mmap_params, core);
745
746 return mmap__mmap(map, mp, output, cpu);
747}
748
749unsigned long perf_event_mlock_kb_in_pages(void)
750{
751 unsigned long pages;
752 int max;
753
754 if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) {
755 /*
756 * Pick a once upon a time good value, i.e. things look
757 * strange since we can't read a sysctl value, but lets not
758 * die yet...
759 */
760 max = 512;
761 } else {
762 max -= (page_size / 1024);
763 }
764
765 pages = (max * 1024) / page_size;
766 if (!is_power_of_2(pages))
767 pages = rounddown_pow_of_two(pages);
768
769 return pages;
770}
771
772size_t evlist__mmap_size(unsigned long pages)
773{
774 if (pages == UINT_MAX)
775 pages = perf_event_mlock_kb_in_pages();
776 else if (!is_power_of_2(pages))
777 return 0;
778
779 return (pages + 1) * page_size;
780}
781
782static long parse_pages_arg(const char *str, unsigned long min,
783 unsigned long max)
784{
785 unsigned long pages, val;
786 static struct parse_tag tags[] = {
787 { .tag = 'B', .mult = 1 },
788 { .tag = 'K', .mult = 1 << 10 },
789 { .tag = 'M', .mult = 1 << 20 },
790 { .tag = 'G', .mult = 1 << 30 },
791 { .tag = 0 },
792 };
793
794 if (str == NULL)
795 return -EINVAL;
796
797 val = parse_tag_value(str, tags);
798 if (val != (unsigned long) -1) {
799 /* we got file size value */
800 pages = PERF_ALIGN(val, page_size) / page_size;
801 } else {
802 /* we got pages count value */
803 char *eptr;
804 pages = strtoul(str, &eptr, 10);
805 if (*eptr != '\0')
806 return -EINVAL;
807 }
808
809 if (pages == 0 && min == 0) {
810 /* leave number of pages at 0 */
811 } else if (!is_power_of_2(pages)) {
812 char buf[100];
813
814 /* round pages up to next power of 2 */
815 pages = roundup_pow_of_two(pages);
816 if (!pages)
817 return -EINVAL;
818
819 unit_number__scnprintf(buf, sizeof(buf), pages * page_size);
820 pr_info("rounding mmap pages size to %s (%lu pages)\n",
821 buf, pages);
822 }
823
824 if (pages > max)
825 return -EINVAL;
826
827 return pages;
828}
829
830int __perf_evlist__parse_mmap_pages(unsigned int *mmap_pages, const char *str)
831{
832 unsigned long max = UINT_MAX;
833 long pages;
834
835 if (max > SIZE_MAX / page_size)
836 max = SIZE_MAX / page_size;
837
838 pages = parse_pages_arg(str, 1, max);
839 if (pages < 0) {
840 pr_err("Invalid argument for --mmap_pages/-m\n");
841 return -1;
842 }
843
844 *mmap_pages = pages;
845 return 0;
846}
847
848int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str,
849 int unset __maybe_unused)
850{
851 return __perf_evlist__parse_mmap_pages(opt->value, str);
852}
853
854/**
855 * evlist__mmap_ex - Create mmaps to receive events.
856 * @evlist: list of events
857 * @pages: map length in pages
858 * @overwrite: overwrite older events?
859 * @auxtrace_pages - auxtrace map length in pages
860 * @auxtrace_overwrite - overwrite older auxtrace data?
861 *
862 * If @overwrite is %false the user needs to signal event consumption using
863 * perf_mmap__write_tail(). Using evlist__mmap_read() does this
864 * automatically.
865 *
866 * Similarly, if @auxtrace_overwrite is %false the user needs to signal data
867 * consumption using auxtrace_mmap__write_tail().
868 *
869 * Return: %0 on success, negative error code otherwise.
870 */
871int evlist__mmap_ex(struct evlist *evlist, unsigned int pages,
872 unsigned int auxtrace_pages,
873 bool auxtrace_overwrite, int nr_cblocks, int affinity, int flush,
874 int comp_level)
875{
876 /*
877 * Delay setting mp.prot: set it before calling perf_mmap__mmap.
878 * Its value is decided by evsel's write_backward.
879 * So &mp should not be passed through const pointer.
880 */
881 struct mmap_params mp = {
882 .nr_cblocks = nr_cblocks,
883 .affinity = affinity,
884 .flush = flush,
885 .comp_level = comp_level
886 };
887 struct perf_evlist_mmap_ops ops = {
888 .idx = perf_evlist__mmap_cb_idx,
889 .get = perf_evlist__mmap_cb_get,
890 .mmap = perf_evlist__mmap_cb_mmap,
891 };
892
893 evlist->core.mmap_len = evlist__mmap_size(pages);
894 pr_debug("mmap size %zuB\n", evlist->core.mmap_len);
895
896 auxtrace_mmap_params__init(&mp.auxtrace_mp, evlist->core.mmap_len,
897 auxtrace_pages, auxtrace_overwrite);
898
899 return perf_evlist__mmap_ops(&evlist->core, &ops, &mp.core);
900}
901
902int evlist__mmap(struct evlist *evlist, unsigned int pages)
903{
904 return evlist__mmap_ex(evlist, pages, 0, false, 0, PERF_AFFINITY_SYS, 1, 0);
905}
906
907int perf_evlist__create_maps(struct evlist *evlist, struct target *target)
908{
909 bool all_threads = (target->per_thread && target->system_wide);
910 struct perf_cpu_map *cpus;
911 struct perf_thread_map *threads;
912
913 /*
914 * If specify '-a' and '--per-thread' to perf record, perf record
915 * will override '--per-thread'. target->per_thread = false and
916 * target->system_wide = true.
917 *
918 * If specify '--per-thread' only to perf record,
919 * target->per_thread = true and target->system_wide = false.
920 *
921 * So target->per_thread && target->system_wide is false.
922 * For perf record, thread_map__new_str doesn't call
923 * thread_map__new_all_cpus. That will keep perf record's
924 * current behavior.
925 *
926 * For perf stat, it allows the case that target->per_thread and
927 * target->system_wide are all true. It means to collect system-wide
928 * per-thread data. thread_map__new_str will call
929 * thread_map__new_all_cpus to enumerate all threads.
930 */
931 threads = thread_map__new_str(target->pid, target->tid, target->uid,
932 all_threads);
933
934 if (!threads)
935 return -1;
936
937 if (target__uses_dummy_map(target))
938 cpus = perf_cpu_map__dummy_new();
939 else
940 cpus = perf_cpu_map__new(target->cpu_list);
941
942 if (!cpus)
943 goto out_delete_threads;
944
945 evlist->core.has_user_cpus = !!target->cpu_list;
946
947 perf_evlist__set_maps(&evlist->core, cpus, threads);
948
949 /* as evlist now has references, put count here */
950 perf_cpu_map__put(cpus);
951 perf_thread_map__put(threads);
952
953 return 0;
954
955out_delete_threads:
956 perf_thread_map__put(threads);
957 return -1;
958}
959
960void __perf_evlist__set_sample_bit(struct evlist *evlist,
961 enum perf_event_sample_format bit)
962{
963 struct evsel *evsel;
964
965 evlist__for_each_entry(evlist, evsel)
966 __evsel__set_sample_bit(evsel, bit);
967}
968
969void __perf_evlist__reset_sample_bit(struct evlist *evlist,
970 enum perf_event_sample_format bit)
971{
972 struct evsel *evsel;
973
974 evlist__for_each_entry(evlist, evsel)
975 __evsel__reset_sample_bit(evsel, bit);
976}
977
978int perf_evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel)
979{
980 struct evsel *evsel;
981 int err = 0;
982
983 evlist__for_each_entry(evlist, evsel) {
984 if (evsel->filter == NULL)
985 continue;
986
987 /*
988 * filters only work for tracepoint event, which doesn't have cpu limit.
989 * So evlist and evsel should always be same.
990 */
991 err = perf_evsel__apply_filter(&evsel->core, evsel->filter);
992 if (err) {
993 *err_evsel = evsel;
994 break;
995 }
996 }
997
998 return err;
999}
1000
1001int perf_evlist__set_tp_filter(struct evlist *evlist, const char *filter)
1002{
1003 struct evsel *evsel;
1004 int err = 0;
1005
1006 if (filter == NULL)
1007 return -1;
1008
1009 evlist__for_each_entry(evlist, evsel) {
1010 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
1011 continue;
1012
1013 err = evsel__set_filter(evsel, filter);
1014 if (err)
1015 break;
1016 }
1017
1018 return err;
1019}
1020
1021int perf_evlist__append_tp_filter(struct evlist *evlist, const char *filter)
1022{
1023 struct evsel *evsel;
1024 int err = 0;
1025
1026 if (filter == NULL)
1027 return -1;
1028
1029 evlist__for_each_entry(evlist, evsel) {
1030 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
1031 continue;
1032
1033 err = evsel__append_tp_filter(evsel, filter);
1034 if (err)
1035 break;
1036 }
1037
1038 return err;
1039}
1040
1041char *asprintf__tp_filter_pids(size_t npids, pid_t *pids)
1042{
1043 char *filter;
1044 size_t i;
1045
1046 for (i = 0; i < npids; ++i) {
1047 if (i == 0) {
1048 if (asprintf(&filter, "common_pid != %d", pids[i]) < 0)
1049 return NULL;
1050 } else {
1051 char *tmp;
1052
1053 if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0)
1054 goto out_free;
1055
1056 free(filter);
1057 filter = tmp;
1058 }
1059 }
1060
1061 return filter;
1062out_free:
1063 free(filter);
1064 return NULL;
1065}
1066
1067int perf_evlist__set_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids)
1068{
1069 char *filter = asprintf__tp_filter_pids(npids, pids);
1070 int ret = perf_evlist__set_tp_filter(evlist, filter);
1071
1072 free(filter);
1073 return ret;
1074}
1075
1076int perf_evlist__set_tp_filter_pid(struct evlist *evlist, pid_t pid)
1077{
1078 return perf_evlist__set_tp_filter_pids(evlist, 1, &pid);
1079}
1080
1081int perf_evlist__append_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids)
1082{
1083 char *filter = asprintf__tp_filter_pids(npids, pids);
1084 int ret = perf_evlist__append_tp_filter(evlist, filter);
1085
1086 free(filter);
1087 return ret;
1088}
1089
1090int perf_evlist__append_tp_filter_pid(struct evlist *evlist, pid_t pid)
1091{
1092 return perf_evlist__append_tp_filter_pids(evlist, 1, &pid);
1093}
1094
1095bool evlist__valid_sample_type(struct evlist *evlist)
1096{
1097 struct evsel *pos;
1098
1099 if (evlist->core.nr_entries == 1)
1100 return true;
1101
1102 if (evlist->id_pos < 0 || evlist->is_pos < 0)
1103 return false;
1104
1105 evlist__for_each_entry(evlist, pos) {
1106 if (pos->id_pos != evlist->id_pos ||
1107 pos->is_pos != evlist->is_pos)
1108 return false;
1109 }
1110
1111 return true;
1112}
1113
1114u64 __evlist__combined_sample_type(struct evlist *evlist)
1115{
1116 struct evsel *evsel;
1117
1118 if (evlist->combined_sample_type)
1119 return evlist->combined_sample_type;
1120
1121 evlist__for_each_entry(evlist, evsel)
1122 evlist->combined_sample_type |= evsel->core.attr.sample_type;
1123
1124 return evlist->combined_sample_type;
1125}
1126
1127u64 evlist__combined_sample_type(struct evlist *evlist)
1128{
1129 evlist->combined_sample_type = 0;
1130 return __evlist__combined_sample_type(evlist);
1131}
1132
1133u64 evlist__combined_branch_type(struct evlist *evlist)
1134{
1135 struct evsel *evsel;
1136 u64 branch_type = 0;
1137
1138 evlist__for_each_entry(evlist, evsel)
1139 branch_type |= evsel->core.attr.branch_sample_type;
1140 return branch_type;
1141}
1142
1143bool perf_evlist__valid_read_format(struct evlist *evlist)
1144{
1145 struct evsel *first = evlist__first(evlist), *pos = first;
1146 u64 read_format = first->core.attr.read_format;
1147 u64 sample_type = first->core.attr.sample_type;
1148
1149 evlist__for_each_entry(evlist, pos) {
1150 if (read_format != pos->core.attr.read_format) {
1151 pr_debug("Read format differs %#" PRIx64 " vs %#" PRIx64 "\n",
1152 read_format, (u64)pos->core.attr.read_format);
1153 }
1154 }
1155
1156 /* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
1157 if ((sample_type & PERF_SAMPLE_READ) &&
1158 !(read_format & PERF_FORMAT_ID)) {
1159 return false;
1160 }
1161
1162 return true;
1163}
1164
1165u16 perf_evlist__id_hdr_size(struct evlist *evlist)
1166{
1167 struct evsel *first = evlist__first(evlist);
1168 struct perf_sample *data;
1169 u64 sample_type;
1170 u16 size = 0;
1171
1172 if (!first->core.attr.sample_id_all)
1173 goto out;
1174
1175 sample_type = first->core.attr.sample_type;
1176
1177 if (sample_type & PERF_SAMPLE_TID)
1178 size += sizeof(data->tid) * 2;
1179
1180 if (sample_type & PERF_SAMPLE_TIME)
1181 size += sizeof(data->time);
1182
1183 if (sample_type & PERF_SAMPLE_ID)
1184 size += sizeof(data->id);
1185
1186 if (sample_type & PERF_SAMPLE_STREAM_ID)
1187 size += sizeof(data->stream_id);
1188
1189 if (sample_type & PERF_SAMPLE_CPU)
1190 size += sizeof(data->cpu) * 2;
1191
1192 if (sample_type & PERF_SAMPLE_IDENTIFIER)
1193 size += sizeof(data->id);
1194out:
1195 return size;
1196}
1197
1198bool evlist__valid_sample_id_all(struct evlist *evlist)
1199{
1200 struct evsel *first = evlist__first(evlist), *pos = first;
1201
1202 evlist__for_each_entry_continue(evlist, pos) {
1203 if (first->core.attr.sample_id_all != pos->core.attr.sample_id_all)
1204 return false;
1205 }
1206
1207 return true;
1208}
1209
1210bool evlist__sample_id_all(struct evlist *evlist)
1211{
1212 struct evsel *first = evlist__first(evlist);
1213 return first->core.attr.sample_id_all;
1214}
1215
1216void perf_evlist__set_selected(struct evlist *evlist,
1217 struct evsel *evsel)
1218{
1219 evlist->selected = evsel;
1220}
1221
1222void evlist__close(struct evlist *evlist)
1223{
1224 struct evsel *evsel;
1225 struct affinity affinity;
1226 int cpu, i;
1227
1228 /*
1229 * With perf record core.cpus is usually NULL.
1230 * Use the old method to handle this for now.
1231 */
1232 if (!evlist->core.cpus) {
1233 evlist__for_each_entry_reverse(evlist, evsel)
1234 evsel__close(evsel);
1235 return;
1236 }
1237
1238 if (affinity__setup(&affinity) < 0)
1239 return;
1240 evlist__for_each_cpu(evlist, i, cpu) {
1241 affinity__set(&affinity, cpu);
1242
1243 evlist__for_each_entry_reverse(evlist, evsel) {
1244 if (evsel__cpu_iter_skip(evsel, cpu))
1245 continue;
1246 perf_evsel__close_cpu(&evsel->core, evsel->cpu_iter - 1);
1247 }
1248 }
1249 affinity__cleanup(&affinity);
1250 evlist__for_each_entry_reverse(evlist, evsel) {
1251 perf_evsel__free_fd(&evsel->core);
1252 perf_evsel__free_id(&evsel->core);
1253 }
1254}
1255
1256static int perf_evlist__create_syswide_maps(struct evlist *evlist)
1257{
1258 struct perf_cpu_map *cpus;
1259 struct perf_thread_map *threads;
1260 int err = -ENOMEM;
1261
1262 /*
1263 * Try reading /sys/devices/system/cpu/online to get
1264 * an all cpus map.
1265 *
1266 * FIXME: -ENOMEM is the best we can do here, the cpu_map
1267 * code needs an overhaul to properly forward the
1268 * error, and we may not want to do that fallback to a
1269 * default cpu identity map :-\
1270 */
1271 cpus = perf_cpu_map__new(NULL);
1272 if (!cpus)
1273 goto out;
1274
1275 threads = perf_thread_map__new_dummy();
1276 if (!threads)
1277 goto out_put;
1278
1279 perf_evlist__set_maps(&evlist->core, cpus, threads);
1280
1281 perf_thread_map__put(threads);
1282out_put:
1283 perf_cpu_map__put(cpus);
1284out:
1285 return err;
1286}
1287
1288int evlist__open(struct evlist *evlist)
1289{
1290 struct evsel *evsel;
1291 int err;
1292
1293 /*
1294 * Default: one fd per CPU, all threads, aka systemwide
1295 * as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL
1296 */
1297 if (evlist->core.threads == NULL && evlist->core.cpus == NULL) {
1298 err = perf_evlist__create_syswide_maps(evlist);
1299 if (err < 0)
1300 goto out_err;
1301 }
1302
1303 perf_evlist__update_id_pos(evlist);
1304
1305 evlist__for_each_entry(evlist, evsel) {
1306 err = evsel__open(evsel, evsel->core.cpus, evsel->core.threads);
1307 if (err < 0)
1308 goto out_err;
1309 }
1310
1311 return 0;
1312out_err:
1313 evlist__close(evlist);
1314 errno = -err;
1315 return err;
1316}
1317
1318int perf_evlist__prepare_workload(struct evlist *evlist, struct target *target,
1319 const char *argv[], bool pipe_output,
1320 void (*exec_error)(int signo, siginfo_t *info, void *ucontext))
1321{
1322 int child_ready_pipe[2], go_pipe[2];
1323 char bf;
1324
1325 if (pipe(child_ready_pipe) < 0) {
1326 perror("failed to create 'ready' pipe");
1327 return -1;
1328 }
1329
1330 if (pipe(go_pipe) < 0) {
1331 perror("failed to create 'go' pipe");
1332 goto out_close_ready_pipe;
1333 }
1334
1335 evlist->workload.pid = fork();
1336 if (evlist->workload.pid < 0) {
1337 perror("failed to fork");
1338 goto out_close_pipes;
1339 }
1340
1341 if (!evlist->workload.pid) {
1342 int ret;
1343
1344 if (pipe_output)
1345 dup2(2, 1);
1346
1347 signal(SIGTERM, SIG_DFL);
1348
1349 close(child_ready_pipe[0]);
1350 close(go_pipe[1]);
1351 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
1352
1353 /*
1354 * Tell the parent we're ready to go
1355 */
1356 close(child_ready_pipe[1]);
1357
1358 /*
1359 * Wait until the parent tells us to go.
1360 */
1361 ret = read(go_pipe[0], &bf, 1);
1362 /*
1363 * The parent will ask for the execvp() to be performed by
1364 * writing exactly one byte, in workload.cork_fd, usually via
1365 * perf_evlist__start_workload().
1366 *
1367 * For cancelling the workload without actually running it,
1368 * the parent will just close workload.cork_fd, without writing
1369 * anything, i.e. read will return zero and we just exit()
1370 * here.
1371 */
1372 if (ret != 1) {
1373 if (ret == -1)
1374 perror("unable to read pipe");
1375 exit(ret);
1376 }
1377
1378 execvp(argv[0], (char **)argv);
1379
1380 if (exec_error) {
1381 union sigval val;
1382
1383 val.sival_int = errno;
1384 if (sigqueue(getppid(), SIGUSR1, val))
1385 perror(argv[0]);
1386 } else
1387 perror(argv[0]);
1388 exit(-1);
1389 }
1390
1391 if (exec_error) {
1392 struct sigaction act = {
1393 .sa_flags = SA_SIGINFO,
1394 .sa_sigaction = exec_error,
1395 };
1396 sigaction(SIGUSR1, &act, NULL);
1397 }
1398
1399 if (target__none(target)) {
1400 if (evlist->core.threads == NULL) {
1401 fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n",
1402 __func__, __LINE__);
1403 goto out_close_pipes;
1404 }
1405 perf_thread_map__set_pid(evlist->core.threads, 0, evlist->workload.pid);
1406 }
1407
1408 close(child_ready_pipe[1]);
1409 close(go_pipe[0]);
1410 /*
1411 * wait for child to settle
1412 */
1413 if (read(child_ready_pipe[0], &bf, 1) == -1) {
1414 perror("unable to read pipe");
1415 goto out_close_pipes;
1416 }
1417
1418 fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
1419 evlist->workload.cork_fd = go_pipe[1];
1420 close(child_ready_pipe[0]);
1421 return 0;
1422
1423out_close_pipes:
1424 close(go_pipe[0]);
1425 close(go_pipe[1]);
1426out_close_ready_pipe:
1427 close(child_ready_pipe[0]);
1428 close(child_ready_pipe[1]);
1429 return -1;
1430}
1431
1432int perf_evlist__start_workload(struct evlist *evlist)
1433{
1434 if (evlist->workload.cork_fd > 0) {
1435 char bf = 0;
1436 int ret;
1437 /*
1438 * Remove the cork, let it rip!
1439 */
1440 ret = write(evlist->workload.cork_fd, &bf, 1);
1441 if (ret < 0)
1442 perror("unable to write to pipe");
1443
1444 close(evlist->workload.cork_fd);
1445 return ret;
1446 }
1447
1448 return 0;
1449}
1450
1451int perf_evlist__parse_sample(struct evlist *evlist, union perf_event *event,
1452 struct perf_sample *sample)
1453{
1454 struct evsel *evsel = perf_evlist__event2evsel(evlist, event);
1455
1456 if (!evsel)
1457 return -EFAULT;
1458 return evsel__parse_sample(evsel, event, sample);
1459}
1460
1461int perf_evlist__parse_sample_timestamp(struct evlist *evlist,
1462 union perf_event *event,
1463 u64 *timestamp)
1464{
1465 struct evsel *evsel = perf_evlist__event2evsel(evlist, event);
1466
1467 if (!evsel)
1468 return -EFAULT;
1469 return evsel__parse_sample_timestamp(evsel, event, timestamp);
1470}
1471
1472int evlist__strerror_open(struct evlist *evlist, int err, char *buf, size_t size)
1473{
1474 int printed, value;
1475 char sbuf[STRERR_BUFSIZE], *emsg = str_error_r(err, sbuf, sizeof(sbuf));
1476
1477 switch (err) {
1478 case EACCES:
1479 case EPERM:
1480 printed = scnprintf(buf, size,
1481 "Error:\t%s.\n"
1482 "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);
1483
1484 value = perf_event_paranoid();
1485
1486 printed += scnprintf(buf + printed, size - printed, "\nHint:\t");
1487
1488 if (value >= 2) {
1489 printed += scnprintf(buf + printed, size - printed,
1490 "For your workloads it needs to be <= 1\nHint:\t");
1491 }
1492 printed += scnprintf(buf + printed, size - printed,
1493 "For system wide tracing it needs to be set to -1.\n");
1494
1495 printed += scnprintf(buf + printed, size - printed,
1496 "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
1497 "Hint:\tThe current value is %d.", value);
1498 break;
1499 case EINVAL: {
1500 struct evsel *first = evlist__first(evlist);
1501 int max_freq;
1502
1503 if (sysctl__read_int("kernel/perf_event_max_sample_rate", &max_freq) < 0)
1504 goto out_default;
1505
1506 if (first->core.attr.sample_freq < (u64)max_freq)
1507 goto out_default;
1508
1509 printed = scnprintf(buf, size,
1510 "Error:\t%s.\n"
1511 "Hint:\tCheck /proc/sys/kernel/perf_event_max_sample_rate.\n"
1512 "Hint:\tThe current value is %d and %" PRIu64 " is being requested.",
1513 emsg, max_freq, first->core.attr.sample_freq);
1514 break;
1515 }
1516 default:
1517out_default:
1518 scnprintf(buf, size, "%s", emsg);
1519 break;
1520 }
1521
1522 return 0;
1523}
1524
1525int evlist__strerror_mmap(struct evlist *evlist, int err, char *buf, size_t size)
1526{
1527 char sbuf[STRERR_BUFSIZE], *emsg = str_error_r(err, sbuf, sizeof(sbuf));
1528 int pages_attempted = evlist->core.mmap_len / 1024, pages_max_per_user, printed = 0;
1529
1530 switch (err) {
1531 case EPERM:
1532 sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user);
1533 printed += scnprintf(buf + printed, size - printed,
1534 "Error:\t%s.\n"
1535 "Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n"
1536 "Hint:\tTried using %zd kB.\n",
1537 emsg, pages_max_per_user, pages_attempted);
1538
1539 if (pages_attempted >= pages_max_per_user) {
1540 printed += scnprintf(buf + printed, size - printed,
1541 "Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n",
1542 pages_max_per_user + pages_attempted);
1543 }
1544
1545 printed += scnprintf(buf + printed, size - printed,
1546 "Hint:\tTry using a smaller -m/--mmap-pages value.");
1547 break;
1548 default:
1549 scnprintf(buf, size, "%s", emsg);
1550 break;
1551 }
1552
1553 return 0;
1554}
1555
1556void perf_evlist__to_front(struct evlist *evlist,
1557 struct evsel *move_evsel)
1558{
1559 struct evsel *evsel, *n;
1560 LIST_HEAD(move);
1561
1562 if (move_evsel == evlist__first(evlist))
1563 return;
1564
1565 evlist__for_each_entry_safe(evlist, n, evsel) {
1566 if (evsel->leader == move_evsel->leader)
1567 list_move_tail(&evsel->core.node, &move);
1568 }
1569
1570 list_splice(&move, &evlist->core.entries);
1571}
1572
1573struct evsel *perf_evlist__get_tracking_event(struct evlist *evlist)
1574{
1575 struct evsel *evsel;
1576
1577 evlist__for_each_entry(evlist, evsel) {
1578 if (evsel->tracking)
1579 return evsel;
1580 }
1581
1582 return evlist__first(evlist);
1583}
1584
1585void perf_evlist__set_tracking_event(struct evlist *evlist,
1586 struct evsel *tracking_evsel)
1587{
1588 struct evsel *evsel;
1589
1590 if (tracking_evsel->tracking)
1591 return;
1592
1593 evlist__for_each_entry(evlist, evsel) {
1594 if (evsel != tracking_evsel)
1595 evsel->tracking = false;
1596 }
1597
1598 tracking_evsel->tracking = true;
1599}
1600
1601struct evsel *
1602perf_evlist__find_evsel_by_str(struct evlist *evlist,
1603 const char *str)
1604{
1605 struct evsel *evsel;
1606
1607 evlist__for_each_entry(evlist, evsel) {
1608 if (!evsel->name)
1609 continue;
1610 if (strcmp(str, evsel->name) == 0)
1611 return evsel;
1612 }
1613
1614 return NULL;
1615}
1616
1617void perf_evlist__toggle_bkw_mmap(struct evlist *evlist,
1618 enum bkw_mmap_state state)
1619{
1620 enum bkw_mmap_state old_state = evlist->bkw_mmap_state;
1621 enum action {
1622 NONE,
1623 PAUSE,
1624 RESUME,
1625 } action = NONE;
1626
1627 if (!evlist->overwrite_mmap)
1628 return;
1629
1630 switch (old_state) {
1631 case BKW_MMAP_NOTREADY: {
1632 if (state != BKW_MMAP_RUNNING)
1633 goto state_err;
1634 break;
1635 }
1636 case BKW_MMAP_RUNNING: {
1637 if (state != BKW_MMAP_DATA_PENDING)
1638 goto state_err;
1639 action = PAUSE;
1640 break;
1641 }
1642 case BKW_MMAP_DATA_PENDING: {
1643 if (state != BKW_MMAP_EMPTY)
1644 goto state_err;
1645 break;
1646 }
1647 case BKW_MMAP_EMPTY: {
1648 if (state != BKW_MMAP_RUNNING)
1649 goto state_err;
1650 action = RESUME;
1651 break;
1652 }
1653 default:
1654 WARN_ONCE(1, "Shouldn't get there\n");
1655 }
1656
1657 evlist->bkw_mmap_state = state;
1658
1659 switch (action) {
1660 case PAUSE:
1661 perf_evlist__pause(evlist);
1662 break;
1663 case RESUME:
1664 perf_evlist__resume(evlist);
1665 break;
1666 case NONE:
1667 default:
1668 break;
1669 }
1670
1671state_err:
1672 return;
1673}
1674
1675bool perf_evlist__exclude_kernel(struct evlist *evlist)
1676{
1677 struct evsel *evsel;
1678
1679 evlist__for_each_entry(evlist, evsel) {
1680 if (!evsel->core.attr.exclude_kernel)
1681 return false;
1682 }
1683
1684 return true;
1685}
1686
1687/*
1688 * Events in data file are not collect in groups, but we still want
1689 * the group display. Set the artificial group and set the leader's
1690 * forced_leader flag to notify the display code.
1691 */
1692void perf_evlist__force_leader(struct evlist *evlist)
1693{
1694 if (!evlist->nr_groups) {
1695 struct evsel *leader = evlist__first(evlist);
1696
1697 perf_evlist__set_leader(evlist);
1698 leader->forced_leader = true;
1699 }
1700}
1701
1702struct evsel *perf_evlist__reset_weak_group(struct evlist *evsel_list,
1703 struct evsel *evsel,
1704 bool close)
1705{
1706 struct evsel *c2, *leader;
1707 bool is_open = true;
1708
1709 leader = evsel->leader;
1710 pr_debug("Weak group for %s/%d failed\n",
1711 leader->name, leader->core.nr_members);
1712
1713 /*
1714 * for_each_group_member doesn't work here because it doesn't
1715 * include the first entry.
1716 */
1717 evlist__for_each_entry(evsel_list, c2) {
1718 if (c2 == evsel)
1719 is_open = false;
1720 if (c2->leader == leader) {
1721 if (is_open && close)
1722 perf_evsel__close(&c2->core);
1723 c2->leader = c2;
1724 c2->core.nr_members = 0;
1725 /*
1726 * Set this for all former members of the group
1727 * to indicate they get reopened.
1728 */
1729 c2->reset_group = true;
1730 }
1731 }
1732 return leader;
1733}
1734
1735int evlist__initialize_ctlfd(struct evlist *evlist, int fd, int ack)
1736{
1737 if (fd == -1) {
1738 pr_debug("Control descriptor is not initialized\n");
1739 return 0;
1740 }
1741
1742 evlist->ctl_fd.pos = perf_evlist__add_pollfd(&evlist->core, fd, NULL, POLLIN,
1743 fdarray_flag__nonfilterable);
1744 if (evlist->ctl_fd.pos < 0) {
1745 evlist->ctl_fd.pos = -1;
1746 pr_err("Failed to add ctl fd entry: %m\n");
1747 return -1;
1748 }
1749
1750 evlist->ctl_fd.fd = fd;
1751 evlist->ctl_fd.ack = ack;
1752
1753 return 0;
1754}
1755
1756bool evlist__ctlfd_initialized(struct evlist *evlist)
1757{
1758 return evlist->ctl_fd.pos >= 0;
1759}
1760
1761int evlist__finalize_ctlfd(struct evlist *evlist)
1762{
1763 struct pollfd *entries = evlist->core.pollfd.entries;
1764
1765 if (!evlist__ctlfd_initialized(evlist))
1766 return 0;
1767
1768 entries[evlist->ctl_fd.pos].fd = -1;
1769 entries[evlist->ctl_fd.pos].events = 0;
1770 entries[evlist->ctl_fd.pos].revents = 0;
1771
1772 evlist->ctl_fd.pos = -1;
1773 evlist->ctl_fd.ack = -1;
1774 evlist->ctl_fd.fd = -1;
1775
1776 return 0;
1777}
1778
1779static int evlist__ctlfd_recv(struct evlist *evlist, enum evlist_ctl_cmd *cmd,
1780 char *cmd_data, size_t data_size)
1781{
1782 int err;
1783 char c;
1784 size_t bytes_read = 0;
1785
1786 memset(cmd_data, 0, data_size);
1787 data_size--;
1788
1789 do {
1790 err = read(evlist->ctl_fd.fd, &c, 1);
1791 if (err > 0) {
1792 if (c == '\n' || c == '\0')
1793 break;
1794 cmd_data[bytes_read++] = c;
1795 if (bytes_read == data_size)
1796 break;
1797 } else {
1798 if (err == -1)
1799 pr_err("Failed to read from ctlfd %d: %m\n", evlist->ctl_fd.fd);
1800 break;
1801 }
1802 } while (1);
1803
1804 pr_debug("Message from ctl_fd: \"%s%s\"\n", cmd_data,
1805 bytes_read == data_size ? "" : c == '\n' ? "\\n" : "\\0");
1806
1807 if (err > 0) {
1808 if (!strncmp(cmd_data, EVLIST_CTL_CMD_ENABLE_TAG,
1809 (sizeof(EVLIST_CTL_CMD_ENABLE_TAG)-1))) {
1810 *cmd = EVLIST_CTL_CMD_ENABLE;
1811 } else if (!strncmp(cmd_data, EVLIST_CTL_CMD_DISABLE_TAG,
1812 (sizeof(EVLIST_CTL_CMD_DISABLE_TAG)-1))) {
1813 *cmd = EVLIST_CTL_CMD_DISABLE;
1814 }
1815 }
1816
1817 return err;
1818}
1819
1820static int evlist__ctlfd_ack(struct evlist *evlist)
1821{
1822 int err;
1823
1824 if (evlist->ctl_fd.ack == -1)
1825 return 0;
1826
1827 err = write(evlist->ctl_fd.ack, EVLIST_CTL_CMD_ACK_TAG,
1828 sizeof(EVLIST_CTL_CMD_ACK_TAG));
1829 if (err == -1)
1830 pr_err("failed to write to ctl_ack_fd %d: %m\n", evlist->ctl_fd.ack);
1831
1832 return err;
1833}
1834
1835int evlist__ctlfd_process(struct evlist *evlist, enum evlist_ctl_cmd *cmd)
1836{
1837 int err = 0;
1838 char cmd_data[EVLIST_CTL_CMD_MAX_LEN];
1839 int ctlfd_pos = evlist->ctl_fd.pos;
1840 struct pollfd *entries = evlist->core.pollfd.entries;
1841
1842 if (!evlist__ctlfd_initialized(evlist) || !entries[ctlfd_pos].revents)
1843 return 0;
1844
1845 if (entries[ctlfd_pos].revents & POLLIN) {
1846 err = evlist__ctlfd_recv(evlist, cmd, cmd_data,
1847 EVLIST_CTL_CMD_MAX_LEN);
1848 if (err > 0) {
1849 switch (*cmd) {
1850 case EVLIST_CTL_CMD_ENABLE:
1851 evlist__enable(evlist);
1852 break;
1853 case EVLIST_CTL_CMD_DISABLE:
1854 evlist__disable(evlist);
1855 break;
1856 case EVLIST_CTL_CMD_ACK:
1857 case EVLIST_CTL_CMD_UNSUPPORTED:
1858 default:
1859 pr_debug("ctlfd: unsupported %d\n", *cmd);
1860 break;
1861 }
1862 if (!(*cmd == EVLIST_CTL_CMD_ACK || *cmd == EVLIST_CTL_CMD_UNSUPPORTED))
1863 evlist__ctlfd_ack(evlist);
1864 }
1865 }
1866
1867 if (entries[ctlfd_pos].revents & (POLLHUP | POLLERR))
1868 evlist__finalize_ctlfd(evlist);
1869 else
1870 entries[ctlfd_pos].revents = 0;
1871
1872 return err;
1873}