ARM64: DTS: Add rk3399-firefly uart4 device, node as /dev/ttyS1
[firefly-linux-kernel-4.4.55.git] / tools / perf / util / evlist.c
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 <api/fs/fs.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 "debug.h"
18 #include <unistd.h>
19
20 #include "parse-events.h"
21 #include "parse-options.h"
22
23 #include <sys/mman.h>
24
25 #include <linux/bitops.h>
26 #include <linux/hash.h>
27 #include <linux/log2.h>
28 #include <linux/err.h>
29
30 static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx);
31 static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx);
32
33 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
34 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
35
36 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
37                        struct thread_map *threads)
38 {
39         int i;
40
41         for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
42                 INIT_HLIST_HEAD(&evlist->heads[i]);
43         INIT_LIST_HEAD(&evlist->entries);
44         perf_evlist__set_maps(evlist, cpus, threads);
45         fdarray__init(&evlist->pollfd, 64);
46         evlist->workload.pid = -1;
47 }
48
49 struct perf_evlist *perf_evlist__new(void)
50 {
51         struct perf_evlist *evlist = zalloc(sizeof(*evlist));
52
53         if (evlist != NULL)
54                 perf_evlist__init(evlist, NULL, NULL);
55
56         return evlist;
57 }
58
59 struct perf_evlist *perf_evlist__new_default(void)
60 {
61         struct perf_evlist *evlist = perf_evlist__new();
62
63         if (evlist && perf_evlist__add_default(evlist)) {
64                 perf_evlist__delete(evlist);
65                 evlist = NULL;
66         }
67
68         return evlist;
69 }
70
71 /**
72  * perf_evlist__set_id_pos - set the positions of event ids.
73  * @evlist: selected event list
74  *
75  * Events with compatible sample types all have the same id_pos
76  * and is_pos.  For convenience, put a copy on evlist.
77  */
78 void perf_evlist__set_id_pos(struct perf_evlist *evlist)
79 {
80         struct perf_evsel *first = perf_evlist__first(evlist);
81
82         evlist->id_pos = first->id_pos;
83         evlist->is_pos = first->is_pos;
84 }
85
86 static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
87 {
88         struct perf_evsel *evsel;
89
90         evlist__for_each(evlist, evsel)
91                 perf_evsel__calc_id_pos(evsel);
92
93         perf_evlist__set_id_pos(evlist);
94 }
95
96 static void perf_evlist__purge(struct perf_evlist *evlist)
97 {
98         struct perf_evsel *pos, *n;
99
100         evlist__for_each_safe(evlist, n, pos) {
101                 list_del_init(&pos->node);
102                 pos->evlist = NULL;
103                 perf_evsel__delete(pos);
104         }
105
106         evlist->nr_entries = 0;
107 }
108
109 void perf_evlist__exit(struct perf_evlist *evlist)
110 {
111         zfree(&evlist->mmap);
112         fdarray__exit(&evlist->pollfd);
113 }
114
115 void perf_evlist__delete(struct perf_evlist *evlist)
116 {
117         perf_evlist__munmap(evlist);
118         perf_evlist__close(evlist);
119         cpu_map__put(evlist->cpus);
120         thread_map__put(evlist->threads);
121         evlist->cpus = NULL;
122         evlist->threads = NULL;
123         perf_evlist__purge(evlist);
124         perf_evlist__exit(evlist);
125         free(evlist);
126 }
127
128 static void __perf_evlist__propagate_maps(struct perf_evlist *evlist,
129                                           struct perf_evsel *evsel)
130 {
131         /*
132          * We already have cpus for evsel (via PMU sysfs) so
133          * keep it, if there's no target cpu list defined.
134          */
135         if (!evsel->own_cpus || evlist->has_user_cpus) {
136                 cpu_map__put(evsel->cpus);
137                 evsel->cpus = cpu_map__get(evlist->cpus);
138         } else if (evsel->cpus != evsel->own_cpus) {
139                 cpu_map__put(evsel->cpus);
140                 evsel->cpus = cpu_map__get(evsel->own_cpus);
141         }
142
143         thread_map__put(evsel->threads);
144         evsel->threads = thread_map__get(evlist->threads);
145 }
146
147 static void perf_evlist__propagate_maps(struct perf_evlist *evlist)
148 {
149         struct perf_evsel *evsel;
150
151         evlist__for_each(evlist, evsel)
152                 __perf_evlist__propagate_maps(evlist, evsel);
153 }
154
155 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
156 {
157         entry->evlist = evlist;
158         list_add_tail(&entry->node, &evlist->entries);
159         entry->idx = evlist->nr_entries;
160         entry->tracking = !entry->idx;
161
162         if (!evlist->nr_entries++)
163                 perf_evlist__set_id_pos(evlist);
164
165         __perf_evlist__propagate_maps(evlist, entry);
166 }
167
168 void perf_evlist__remove(struct perf_evlist *evlist, struct perf_evsel *evsel)
169 {
170         evsel->evlist = NULL;
171         list_del_init(&evsel->node);
172         evlist->nr_entries -= 1;
173 }
174
175 void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
176                                    struct list_head *list)
177 {
178         struct perf_evsel *evsel, *temp;
179
180         __evlist__for_each_safe(list, temp, evsel) {
181                 list_del_init(&evsel->node);
182                 perf_evlist__add(evlist, evsel);
183         }
184 }
185
186 void __perf_evlist__set_leader(struct list_head *list)
187 {
188         struct perf_evsel *evsel, *leader;
189
190         leader = list_entry(list->next, struct perf_evsel, node);
191         evsel = list_entry(list->prev, struct perf_evsel, node);
192
193         leader->nr_members = evsel->idx - leader->idx + 1;
194
195         __evlist__for_each(list, evsel) {
196                 evsel->leader = leader;
197         }
198 }
199
200 void perf_evlist__set_leader(struct perf_evlist *evlist)
201 {
202         if (evlist->nr_entries) {
203                 evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
204                 __perf_evlist__set_leader(&evlist->entries);
205         }
206 }
207
208 void perf_event_attr__set_max_precise_ip(struct perf_event_attr *attr)
209 {
210         attr->precise_ip = 3;
211
212         while (attr->precise_ip != 0) {
213                 int fd = sys_perf_event_open(attr, 0, -1, -1, 0);
214                 if (fd != -1) {
215                         close(fd);
216                         break;
217                 }
218                 --attr->precise_ip;
219         }
220 }
221
222 int perf_evlist__add_default(struct perf_evlist *evlist)
223 {
224         struct perf_event_attr attr = {
225                 .type = PERF_TYPE_HARDWARE,
226                 .config = PERF_COUNT_HW_CPU_CYCLES,
227         };
228         struct perf_evsel *evsel;
229
230         event_attr_init(&attr);
231
232         perf_event_attr__set_max_precise_ip(&attr);
233
234         evsel = perf_evsel__new(&attr);
235         if (evsel == NULL)
236                 goto error;
237
238         /* use asprintf() because free(evsel) assumes name is allocated */
239         if (asprintf(&evsel->name, "cycles%.*s",
240                      attr.precise_ip ? attr.precise_ip + 1 : 0, ":ppp") < 0)
241                 goto error_free;
242
243         perf_evlist__add(evlist, evsel);
244         return 0;
245 error_free:
246         perf_evsel__delete(evsel);
247 error:
248         return -ENOMEM;
249 }
250
251 static int perf_evlist__add_attrs(struct perf_evlist *evlist,
252                                   struct perf_event_attr *attrs, size_t nr_attrs)
253 {
254         struct perf_evsel *evsel, *n;
255         LIST_HEAD(head);
256         size_t i;
257
258         for (i = 0; i < nr_attrs; i++) {
259                 evsel = perf_evsel__new_idx(attrs + i, evlist->nr_entries + i);
260                 if (evsel == NULL)
261                         goto out_delete_partial_list;
262                 list_add_tail(&evsel->node, &head);
263         }
264
265         perf_evlist__splice_list_tail(evlist, &head);
266
267         return 0;
268
269 out_delete_partial_list:
270         __evlist__for_each_safe(&head, n, evsel)
271                 perf_evsel__delete(evsel);
272         return -1;
273 }
274
275 int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,
276                                      struct perf_event_attr *attrs, size_t nr_attrs)
277 {
278         size_t i;
279
280         for (i = 0; i < nr_attrs; i++)
281                 event_attr_init(attrs + i);
282
283         return perf_evlist__add_attrs(evlist, attrs, nr_attrs);
284 }
285
286 struct perf_evsel *
287 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
288 {
289         struct perf_evsel *evsel;
290
291         evlist__for_each(evlist, evsel) {
292                 if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
293                     (int)evsel->attr.config == id)
294                         return evsel;
295         }
296
297         return NULL;
298 }
299
300 struct perf_evsel *
301 perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
302                                      const char *name)
303 {
304         struct perf_evsel *evsel;
305
306         evlist__for_each(evlist, evsel) {
307                 if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
308                     (strcmp(evsel->name, name) == 0))
309                         return evsel;
310         }
311
312         return NULL;
313 }
314
315 int perf_evlist__add_newtp(struct perf_evlist *evlist,
316                            const char *sys, const char *name, void *handler)
317 {
318         struct perf_evsel *evsel = perf_evsel__newtp(sys, name);
319
320         if (IS_ERR(evsel))
321                 return -1;
322
323         evsel->handler = handler;
324         perf_evlist__add(evlist, evsel);
325         return 0;
326 }
327
328 static int perf_evlist__nr_threads(struct perf_evlist *evlist,
329                                    struct perf_evsel *evsel)
330 {
331         if (evsel->system_wide)
332                 return 1;
333         else
334                 return thread_map__nr(evlist->threads);
335 }
336
337 void perf_evlist__disable(struct perf_evlist *evlist)
338 {
339         int cpu, thread;
340         struct perf_evsel *pos;
341         int nr_cpus = cpu_map__nr(evlist->cpus);
342         int nr_threads;
343
344         for (cpu = 0; cpu < nr_cpus; cpu++) {
345                 evlist__for_each(evlist, pos) {
346                         if (!perf_evsel__is_group_leader(pos) || !pos->fd)
347                                 continue;
348                         nr_threads = perf_evlist__nr_threads(evlist, pos);
349                         for (thread = 0; thread < nr_threads; thread++)
350                                 ioctl(FD(pos, cpu, thread),
351                                       PERF_EVENT_IOC_DISABLE, 0);
352                 }
353         }
354
355         evlist->enabled = false;
356 }
357
358 void perf_evlist__enable(struct perf_evlist *evlist)
359 {
360         int cpu, thread;
361         struct perf_evsel *pos;
362         int nr_cpus = cpu_map__nr(evlist->cpus);
363         int nr_threads;
364
365         for (cpu = 0; cpu < nr_cpus; cpu++) {
366                 evlist__for_each(evlist, pos) {
367                         if (!perf_evsel__is_group_leader(pos) || !pos->fd)
368                                 continue;
369                         nr_threads = perf_evlist__nr_threads(evlist, pos);
370                         for (thread = 0; thread < nr_threads; thread++)
371                                 ioctl(FD(pos, cpu, thread),
372                                       PERF_EVENT_IOC_ENABLE, 0);
373                 }
374         }
375
376         evlist->enabled = true;
377 }
378
379 void perf_evlist__toggle_enable(struct perf_evlist *evlist)
380 {
381         (evlist->enabled ? perf_evlist__disable : perf_evlist__enable)(evlist);
382 }
383
384 int perf_evlist__disable_event(struct perf_evlist *evlist,
385                                struct perf_evsel *evsel)
386 {
387         int cpu, thread, err;
388         int nr_cpus = cpu_map__nr(evlist->cpus);
389         int nr_threads = perf_evlist__nr_threads(evlist, evsel);
390
391         if (!evsel->fd)
392                 return 0;
393
394         for (cpu = 0; cpu < nr_cpus; cpu++) {
395                 for (thread = 0; thread < nr_threads; thread++) {
396                         err = ioctl(FD(evsel, cpu, thread),
397                                     PERF_EVENT_IOC_DISABLE, 0);
398                         if (err)
399                                 return err;
400                 }
401         }
402         return 0;
403 }
404
405 int perf_evlist__enable_event(struct perf_evlist *evlist,
406                               struct perf_evsel *evsel)
407 {
408         int cpu, thread, err;
409         int nr_cpus = cpu_map__nr(evlist->cpus);
410         int nr_threads = perf_evlist__nr_threads(evlist, evsel);
411
412         if (!evsel->fd)
413                 return -EINVAL;
414
415         for (cpu = 0; cpu < nr_cpus; cpu++) {
416                 for (thread = 0; thread < nr_threads; thread++) {
417                         err = ioctl(FD(evsel, cpu, thread),
418                                     PERF_EVENT_IOC_ENABLE, 0);
419                         if (err)
420                                 return err;
421                 }
422         }
423         return 0;
424 }
425
426 static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,
427                                          struct perf_evsel *evsel, int cpu)
428 {
429         int thread, err;
430         int nr_threads = perf_evlist__nr_threads(evlist, evsel);
431
432         if (!evsel->fd)
433                 return -EINVAL;
434
435         for (thread = 0; thread < nr_threads; thread++) {
436                 err = ioctl(FD(evsel, cpu, thread),
437                             PERF_EVENT_IOC_ENABLE, 0);
438                 if (err)
439                         return err;
440         }
441         return 0;
442 }
443
444 static int perf_evlist__enable_event_thread(struct perf_evlist *evlist,
445                                             struct perf_evsel *evsel,
446                                             int thread)
447 {
448         int cpu, err;
449         int nr_cpus = cpu_map__nr(evlist->cpus);
450
451         if (!evsel->fd)
452                 return -EINVAL;
453
454         for (cpu = 0; cpu < nr_cpus; cpu++) {
455                 err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
456                 if (err)
457                         return err;
458         }
459         return 0;
460 }
461
462 int perf_evlist__enable_event_idx(struct perf_evlist *evlist,
463                                   struct perf_evsel *evsel, int idx)
464 {
465         bool per_cpu_mmaps = !cpu_map__empty(evlist->cpus);
466
467         if (per_cpu_mmaps)
468                 return perf_evlist__enable_event_cpu(evlist, evsel, idx);
469         else
470                 return perf_evlist__enable_event_thread(evlist, evsel, idx);
471 }
472
473 int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
474 {
475         int nr_cpus = cpu_map__nr(evlist->cpus);
476         int nr_threads = thread_map__nr(evlist->threads);
477         int nfds = 0;
478         struct perf_evsel *evsel;
479
480         evlist__for_each(evlist, evsel) {
481                 if (evsel->system_wide)
482                         nfds += nr_cpus;
483                 else
484                         nfds += nr_cpus * nr_threads;
485         }
486
487         if (fdarray__available_entries(&evlist->pollfd) < nfds &&
488             fdarray__grow(&evlist->pollfd, nfds) < 0)
489                 return -ENOMEM;
490
491         return 0;
492 }
493
494 static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx)
495 {
496         int pos = fdarray__add(&evlist->pollfd, fd, POLLIN | POLLERR | POLLHUP);
497         /*
498          * Save the idx so that when we filter out fds POLLHUP'ed we can
499          * close the associated evlist->mmap[] entry.
500          */
501         if (pos >= 0) {
502                 evlist->pollfd.priv[pos].idx = idx;
503
504                 fcntl(fd, F_SETFL, O_NONBLOCK);
505         }
506
507         return pos;
508 }
509
510 int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
511 {
512         return __perf_evlist__add_pollfd(evlist, fd, -1);
513 }
514
515 static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd)
516 {
517         struct perf_evlist *evlist = container_of(fda, struct perf_evlist, pollfd);
518
519         perf_evlist__mmap_put(evlist, fda->priv[fd].idx);
520 }
521
522 int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)
523 {
524         return fdarray__filter(&evlist->pollfd, revents_and_mask,
525                                perf_evlist__munmap_filtered);
526 }
527
528 int perf_evlist__poll(struct perf_evlist *evlist, int timeout)
529 {
530         return fdarray__poll(&evlist->pollfd, timeout);
531 }
532
533 static void perf_evlist__id_hash(struct perf_evlist *evlist,
534                                  struct perf_evsel *evsel,
535                                  int cpu, int thread, u64 id)
536 {
537         int hash;
538         struct perf_sample_id *sid = SID(evsel, cpu, thread);
539
540         sid->id = id;
541         sid->evsel = evsel;
542         hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
543         hlist_add_head(&sid->node, &evlist->heads[hash]);
544 }
545
546 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
547                          int cpu, int thread, u64 id)
548 {
549         perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
550         evsel->id[evsel->ids++] = id;
551 }
552
553 static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
554                                   struct perf_evsel *evsel,
555                                   int cpu, int thread, int fd)
556 {
557         u64 read_data[4] = { 0, };
558         int id_idx = 1; /* The first entry is the counter value */
559         u64 id;
560         int ret;
561
562         ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);
563         if (!ret)
564                 goto add;
565
566         if (errno != ENOTTY)
567                 return -1;
568
569         /* Legacy way to get event id.. All hail to old kernels! */
570
571         /*
572          * This way does not work with group format read, so bail
573          * out in that case.
574          */
575         if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)
576                 return -1;
577
578         if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
579             read(fd, &read_data, sizeof(read_data)) == -1)
580                 return -1;
581
582         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
583                 ++id_idx;
584         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
585                 ++id_idx;
586
587         id = read_data[id_idx];
588
589  add:
590         perf_evlist__id_add(evlist, evsel, cpu, thread, id);
591         return 0;
592 }
593
594 static void perf_evlist__set_sid_idx(struct perf_evlist *evlist,
595                                      struct perf_evsel *evsel, int idx, int cpu,
596                                      int thread)
597 {
598         struct perf_sample_id *sid = SID(evsel, cpu, thread);
599         sid->idx = idx;
600         if (evlist->cpus && cpu >= 0)
601                 sid->cpu = evlist->cpus->map[cpu];
602         else
603                 sid->cpu = -1;
604         if (!evsel->system_wide && evlist->threads && thread >= 0)
605                 sid->tid = thread_map__pid(evlist->threads, thread);
606         else
607                 sid->tid = -1;
608 }
609
610 struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
611 {
612         struct hlist_head *head;
613         struct perf_sample_id *sid;
614         int hash;
615
616         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
617         head = &evlist->heads[hash];
618
619         hlist_for_each_entry(sid, head, node)
620                 if (sid->id == id)
621                         return sid;
622
623         return NULL;
624 }
625
626 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
627 {
628         struct perf_sample_id *sid;
629
630         if (evlist->nr_entries == 1 || !id)
631                 return perf_evlist__first(evlist);
632
633         sid = perf_evlist__id2sid(evlist, id);
634         if (sid)
635                 return sid->evsel;
636
637         if (!perf_evlist__sample_id_all(evlist))
638                 return perf_evlist__first(evlist);
639
640         return NULL;
641 }
642
643 struct perf_evsel *perf_evlist__id2evsel_strict(struct perf_evlist *evlist,
644                                                 u64 id)
645 {
646         struct perf_sample_id *sid;
647
648         if (!id)
649                 return NULL;
650
651         sid = perf_evlist__id2sid(evlist, id);
652         if (sid)
653                 return sid->evsel;
654
655         return NULL;
656 }
657
658 static int perf_evlist__event2id(struct perf_evlist *evlist,
659                                  union perf_event *event, u64 *id)
660 {
661         const u64 *array = event->sample.array;
662         ssize_t n;
663
664         n = (event->header.size - sizeof(event->header)) >> 3;
665
666         if (event->header.type == PERF_RECORD_SAMPLE) {
667                 if (evlist->id_pos >= n)
668                         return -1;
669                 *id = array[evlist->id_pos];
670         } else {
671                 if (evlist->is_pos > n)
672                         return -1;
673                 n -= evlist->is_pos;
674                 *id = array[n];
675         }
676         return 0;
677 }
678
679 static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
680                                                    union perf_event *event)
681 {
682         struct perf_evsel *first = perf_evlist__first(evlist);
683         struct hlist_head *head;
684         struct perf_sample_id *sid;
685         int hash;
686         u64 id;
687
688         if (evlist->nr_entries == 1)
689                 return first;
690
691         if (!first->attr.sample_id_all &&
692             event->header.type != PERF_RECORD_SAMPLE)
693                 return first;
694
695         if (perf_evlist__event2id(evlist, event, &id))
696                 return NULL;
697
698         /* Synthesized events have an id of zero */
699         if (!id)
700                 return first;
701
702         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
703         head = &evlist->heads[hash];
704
705         hlist_for_each_entry(sid, head, node) {
706                 if (sid->id == id)
707                         return sid->evsel;
708         }
709         return NULL;
710 }
711
712 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
713 {
714         struct perf_mmap *md = &evlist->mmap[idx];
715         u64 head;
716         u64 old = md->prev;
717         unsigned char *data = md->base + page_size;
718         union perf_event *event = NULL;
719
720         /*
721          * Check if event was unmapped due to a POLLHUP/POLLERR.
722          */
723         if (!atomic_read(&md->refcnt))
724                 return NULL;
725
726         head = perf_mmap__read_head(md);
727         if (evlist->overwrite) {
728                 /*
729                  * If we're further behind than half the buffer, there's a chance
730                  * the writer will bite our tail and mess up the samples under us.
731                  *
732                  * If we somehow ended up ahead of the head, we got messed up.
733                  *
734                  * In either case, truncate and restart at head.
735                  */
736                 int diff = head - old;
737                 if (diff > md->mask / 2 || diff < 0) {
738                         fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
739
740                         /*
741                          * head points to a known good entry, start there.
742                          */
743                         old = head;
744                 }
745         }
746
747         if (old != head) {
748                 size_t size;
749
750                 event = (union perf_event *)&data[old & md->mask];
751                 size = event->header.size;
752
753                 /*
754                  * Event straddles the mmap boundary -- header should always
755                  * be inside due to u64 alignment of output.
756                  */
757                 if ((old & md->mask) + size != ((old + size) & md->mask)) {
758                         unsigned int offset = old;
759                         unsigned int len = min(sizeof(*event), size), cpy;
760                         void *dst = md->event_copy;
761
762                         do {
763                                 cpy = min(md->mask + 1 - (offset & md->mask), len);
764                                 memcpy(dst, &data[offset & md->mask], cpy);
765                                 offset += cpy;
766                                 dst += cpy;
767                                 len -= cpy;
768                         } while (len);
769
770                         event = (union perf_event *) md->event_copy;
771                 }
772
773                 old += size;
774         }
775
776         md->prev = old;
777
778         return event;
779 }
780
781 static bool perf_mmap__empty(struct perf_mmap *md)
782 {
783         return perf_mmap__read_head(md) == md->prev && !md->auxtrace_mmap.base;
784 }
785
786 static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx)
787 {
788         atomic_inc(&evlist->mmap[idx].refcnt);
789 }
790
791 static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx)
792 {
793         BUG_ON(atomic_read(&evlist->mmap[idx].refcnt) == 0);
794
795         if (atomic_dec_and_test(&evlist->mmap[idx].refcnt))
796                 __perf_evlist__munmap(evlist, idx);
797 }
798
799 void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
800 {
801         struct perf_mmap *md = &evlist->mmap[idx];
802
803         if (!evlist->overwrite) {
804                 u64 old = md->prev;
805
806                 perf_mmap__write_tail(md, old);
807         }
808
809         if (atomic_read(&md->refcnt) == 1 && perf_mmap__empty(md))
810                 perf_evlist__mmap_put(evlist, idx);
811 }
812
813 int __weak auxtrace_mmap__mmap(struct auxtrace_mmap *mm __maybe_unused,
814                                struct auxtrace_mmap_params *mp __maybe_unused,
815                                void *userpg __maybe_unused,
816                                int fd __maybe_unused)
817 {
818         return 0;
819 }
820
821 void __weak auxtrace_mmap__munmap(struct auxtrace_mmap *mm __maybe_unused)
822 {
823 }
824
825 void __weak auxtrace_mmap_params__init(
826                         struct auxtrace_mmap_params *mp __maybe_unused,
827                         off_t auxtrace_offset __maybe_unused,
828                         unsigned int auxtrace_pages __maybe_unused,
829                         bool auxtrace_overwrite __maybe_unused)
830 {
831 }
832
833 void __weak auxtrace_mmap_params__set_idx(
834                         struct auxtrace_mmap_params *mp __maybe_unused,
835                         struct perf_evlist *evlist __maybe_unused,
836                         int idx __maybe_unused,
837                         bool per_cpu __maybe_unused)
838 {
839 }
840
841 static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
842 {
843         if (evlist->mmap[idx].base != NULL) {
844                 munmap(evlist->mmap[idx].base, evlist->mmap_len);
845                 evlist->mmap[idx].base = NULL;
846                 atomic_set(&evlist->mmap[idx].refcnt, 0);
847         }
848         auxtrace_mmap__munmap(&evlist->mmap[idx].auxtrace_mmap);
849 }
850
851 void perf_evlist__munmap(struct perf_evlist *evlist)
852 {
853         int i;
854
855         if (evlist->mmap == NULL)
856                 return;
857
858         for (i = 0; i < evlist->nr_mmaps; i++)
859                 __perf_evlist__munmap(evlist, i);
860
861         zfree(&evlist->mmap);
862 }
863
864 static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
865 {
866         evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
867         if (cpu_map__empty(evlist->cpus))
868                 evlist->nr_mmaps = thread_map__nr(evlist->threads);
869         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
870         return evlist->mmap != NULL ? 0 : -ENOMEM;
871 }
872
873 struct mmap_params {
874         int prot;
875         int mask;
876         struct auxtrace_mmap_params auxtrace_mp;
877 };
878
879 static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
880                                struct mmap_params *mp, int fd)
881 {
882         /*
883          * The last one will be done at perf_evlist__mmap_consume(), so that we
884          * make sure we don't prevent tools from consuming every last event in
885          * the ring buffer.
886          *
887          * I.e. we can get the POLLHUP meaning that the fd doesn't exist
888          * anymore, but the last events for it are still in the ring buffer,
889          * waiting to be consumed.
890          *
891          * Tools can chose to ignore this at their own discretion, but the
892          * evlist layer can't just drop it when filtering events in
893          * perf_evlist__filter_pollfd().
894          */
895         atomic_set(&evlist->mmap[idx].refcnt, 2);
896         evlist->mmap[idx].prev = 0;
897         evlist->mmap[idx].mask = mp->mask;
898         evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
899                                       MAP_SHARED, fd, 0);
900         if (evlist->mmap[idx].base == MAP_FAILED) {
901                 pr_debug2("failed to mmap perf event ring buffer, error %d\n",
902                           errno);
903                 evlist->mmap[idx].base = NULL;
904                 return -1;
905         }
906
907         if (auxtrace_mmap__mmap(&evlist->mmap[idx].auxtrace_mmap,
908                                 &mp->auxtrace_mp, evlist->mmap[idx].base, fd))
909                 return -1;
910
911         return 0;
912 }
913
914 static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
915                                        struct mmap_params *mp, int cpu,
916                                        int thread, int *output)
917 {
918         struct perf_evsel *evsel;
919
920         evlist__for_each(evlist, evsel) {
921                 int fd;
922
923                 if (evsel->system_wide && thread)
924                         continue;
925
926                 fd = FD(evsel, cpu, thread);
927
928                 if (*output == -1) {
929                         *output = fd;
930                         if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)
931                                 return -1;
932                 } else {
933                         if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
934                                 return -1;
935
936                         perf_evlist__mmap_get(evlist, idx);
937                 }
938
939                 /*
940                  * The system_wide flag causes a selected event to be opened
941                  * always without a pid.  Consequently it will never get a
942                  * POLLHUP, but it is used for tracking in combination with
943                  * other events, so it should not need to be polled anyway.
944                  * Therefore don't add it for polling.
945                  */
946                 if (!evsel->system_wide &&
947                     __perf_evlist__add_pollfd(evlist, fd, idx) < 0) {
948                         perf_evlist__mmap_put(evlist, idx);
949                         return -1;
950                 }
951
952                 if (evsel->attr.read_format & PERF_FORMAT_ID) {
953                         if (perf_evlist__id_add_fd(evlist, evsel, cpu, thread,
954                                                    fd) < 0)
955                                 return -1;
956                         perf_evlist__set_sid_idx(evlist, evsel, idx, cpu,
957                                                  thread);
958                 }
959         }
960
961         return 0;
962 }
963
964 static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
965                                      struct mmap_params *mp)
966 {
967         int cpu, thread;
968         int nr_cpus = cpu_map__nr(evlist->cpus);
969         int nr_threads = thread_map__nr(evlist->threads);
970
971         pr_debug2("perf event ring buffer mmapped per cpu\n");
972         for (cpu = 0; cpu < nr_cpus; cpu++) {
973                 int output = -1;
974
975                 auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, cpu,
976                                               true);
977
978                 for (thread = 0; thread < nr_threads; thread++) {
979                         if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
980                                                         thread, &output))
981                                 goto out_unmap;
982                 }
983         }
984
985         return 0;
986
987 out_unmap:
988         for (cpu = 0; cpu < nr_cpus; cpu++)
989                 __perf_evlist__munmap(evlist, cpu);
990         return -1;
991 }
992
993 static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
994                                         struct mmap_params *mp)
995 {
996         int thread;
997         int nr_threads = thread_map__nr(evlist->threads);
998
999         pr_debug2("perf event ring buffer mmapped per thread\n");
1000         for (thread = 0; thread < nr_threads; thread++) {
1001                 int output = -1;
1002
1003                 auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, thread,
1004                                               false);
1005
1006                 if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
1007                                                 &output))
1008                         goto out_unmap;
1009         }
1010
1011         return 0;
1012
1013 out_unmap:
1014         for (thread = 0; thread < nr_threads; thread++)
1015                 __perf_evlist__munmap(evlist, thread);
1016         return -1;
1017 }
1018
1019 static size_t perf_evlist__mmap_size(unsigned long pages)
1020 {
1021         if (pages == UINT_MAX) {
1022                 int max;
1023
1024                 if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) {
1025                         /*
1026                          * Pick a once upon a time good value, i.e. things look
1027                          * strange since we can't read a sysctl value, but lets not
1028                          * die yet...
1029                          */
1030                         max = 512;
1031                 } else {
1032                         max -= (page_size / 1024);
1033                 }
1034
1035                 pages = (max * 1024) / page_size;
1036                 if (!is_power_of_2(pages))
1037                         pages = rounddown_pow_of_two(pages);
1038         } else if (!is_power_of_2(pages))
1039                 return 0;
1040
1041         return (pages + 1) * page_size;
1042 }
1043
1044 static long parse_pages_arg(const char *str, unsigned long min,
1045                             unsigned long max)
1046 {
1047         unsigned long pages, val;
1048         static struct parse_tag tags[] = {
1049                 { .tag  = 'B', .mult = 1       },
1050                 { .tag  = 'K', .mult = 1 << 10 },
1051                 { .tag  = 'M', .mult = 1 << 20 },
1052                 { .tag  = 'G', .mult = 1 << 30 },
1053                 { .tag  = 0 },
1054         };
1055
1056         if (str == NULL)
1057                 return -EINVAL;
1058
1059         val = parse_tag_value(str, tags);
1060         if (val != (unsigned long) -1) {
1061                 /* we got file size value */
1062                 pages = PERF_ALIGN(val, page_size) / page_size;
1063         } else {
1064                 /* we got pages count value */
1065                 char *eptr;
1066                 pages = strtoul(str, &eptr, 10);
1067                 if (*eptr != '\0')
1068                         return -EINVAL;
1069         }
1070
1071         if (pages == 0 && min == 0) {
1072                 /* leave number of pages at 0 */
1073         } else if (!is_power_of_2(pages)) {
1074                 /* round pages up to next power of 2 */
1075                 pages = roundup_pow_of_two(pages);
1076                 if (!pages)
1077                         return -EINVAL;
1078                 pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n",
1079                         pages * page_size, pages);
1080         }
1081
1082         if (pages > max)
1083                 return -EINVAL;
1084
1085         return pages;
1086 }
1087
1088 int __perf_evlist__parse_mmap_pages(unsigned int *mmap_pages, const char *str)
1089 {
1090         unsigned long max = UINT_MAX;
1091         long pages;
1092
1093         if (max > SIZE_MAX / page_size)
1094                 max = SIZE_MAX / page_size;
1095
1096         pages = parse_pages_arg(str, 1, max);
1097         if (pages < 0) {
1098                 pr_err("Invalid argument for --mmap_pages/-m\n");
1099                 return -1;
1100         }
1101
1102         *mmap_pages = pages;
1103         return 0;
1104 }
1105
1106 int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str,
1107                                   int unset __maybe_unused)
1108 {
1109         return __perf_evlist__parse_mmap_pages(opt->value, str);
1110 }
1111
1112 /**
1113  * perf_evlist__mmap_ex - Create mmaps to receive events.
1114  * @evlist: list of events
1115  * @pages: map length in pages
1116  * @overwrite: overwrite older events?
1117  * @auxtrace_pages - auxtrace map length in pages
1118  * @auxtrace_overwrite - overwrite older auxtrace data?
1119  *
1120  * If @overwrite is %false the user needs to signal event consumption using
1121  * perf_mmap__write_tail().  Using perf_evlist__mmap_read() does this
1122  * automatically.
1123  *
1124  * Similarly, if @auxtrace_overwrite is %false the user needs to signal data
1125  * consumption using auxtrace_mmap__write_tail().
1126  *
1127  * Return: %0 on success, negative error code otherwise.
1128  */
1129 int perf_evlist__mmap_ex(struct perf_evlist *evlist, unsigned int pages,
1130                          bool overwrite, unsigned int auxtrace_pages,
1131                          bool auxtrace_overwrite)
1132 {
1133         struct perf_evsel *evsel;
1134         const struct cpu_map *cpus = evlist->cpus;
1135         const struct thread_map *threads = evlist->threads;
1136         struct mmap_params mp = {
1137                 .prot = PROT_READ | (overwrite ? 0 : PROT_WRITE),
1138         };
1139
1140         if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
1141                 return -ENOMEM;
1142
1143         if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
1144                 return -ENOMEM;
1145
1146         evlist->overwrite = overwrite;
1147         evlist->mmap_len = perf_evlist__mmap_size(pages);
1148         pr_debug("mmap size %zuB\n", evlist->mmap_len);
1149         mp.mask = evlist->mmap_len - page_size - 1;
1150
1151         auxtrace_mmap_params__init(&mp.auxtrace_mp, evlist->mmap_len,
1152                                    auxtrace_pages, auxtrace_overwrite);
1153
1154         evlist__for_each(evlist, evsel) {
1155                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
1156                     evsel->sample_id == NULL &&
1157                     perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
1158                         return -ENOMEM;
1159         }
1160
1161         if (cpu_map__empty(cpus))
1162                 return perf_evlist__mmap_per_thread(evlist, &mp);
1163
1164         return perf_evlist__mmap_per_cpu(evlist, &mp);
1165 }
1166
1167 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
1168                       bool overwrite)
1169 {
1170         return perf_evlist__mmap_ex(evlist, pages, overwrite, 0, false);
1171 }
1172
1173 int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
1174 {
1175         struct cpu_map *cpus;
1176         struct thread_map *threads;
1177
1178         threads = thread_map__new_str(target->pid, target->tid, target->uid);
1179
1180         if (!threads)
1181                 return -1;
1182
1183         if (target__uses_dummy_map(target))
1184                 cpus = cpu_map__dummy_new();
1185         else
1186                 cpus = cpu_map__new(target->cpu_list);
1187
1188         if (!cpus)
1189                 goto out_delete_threads;
1190
1191         evlist->has_user_cpus = !!target->cpu_list;
1192
1193         perf_evlist__set_maps(evlist, cpus, threads);
1194
1195         return 0;
1196
1197 out_delete_threads:
1198         thread_map__put(threads);
1199         return -1;
1200 }
1201
1202 void perf_evlist__set_maps(struct perf_evlist *evlist, struct cpu_map *cpus,
1203                            struct thread_map *threads)
1204 {
1205         /*
1206          * Allow for the possibility that one or another of the maps isn't being
1207          * changed i.e. don't put it.  Note we are assuming the maps that are
1208          * being applied are brand new and evlist is taking ownership of the
1209          * original reference count of 1.  If that is not the case it is up to
1210          * the caller to increase the reference count.
1211          */
1212         if (cpus != evlist->cpus) {
1213                 cpu_map__put(evlist->cpus);
1214                 evlist->cpus = cpu_map__get(cpus);
1215         }
1216
1217         if (threads != evlist->threads) {
1218                 thread_map__put(evlist->threads);
1219                 evlist->threads = thread_map__get(threads);
1220         }
1221
1222         perf_evlist__propagate_maps(evlist);
1223 }
1224
1225 int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel)
1226 {
1227         struct perf_evsel *evsel;
1228         int err = 0;
1229         const int ncpus = cpu_map__nr(evlist->cpus),
1230                   nthreads = thread_map__nr(evlist->threads);
1231
1232         evlist__for_each(evlist, evsel) {
1233                 if (evsel->filter == NULL)
1234                         continue;
1235
1236                 /*
1237                  * filters only work for tracepoint event, which doesn't have cpu limit.
1238                  * So evlist and evsel should always be same.
1239                  */
1240                 err = perf_evsel__apply_filter(evsel, ncpus, nthreads, evsel->filter);
1241                 if (err) {
1242                         *err_evsel = evsel;
1243                         break;
1244                 }
1245         }
1246
1247         return err;
1248 }
1249
1250 int perf_evlist__apply_drv_configs(struct perf_evlist *evlist,
1251                                    struct perf_evsel **err_evsel,
1252                                    struct perf_evsel_config_term **err_term)
1253 {
1254         struct perf_evsel *evsel;
1255         int err = 0;
1256         const int ncpus = cpu_map__nr(evlist->cpus),
1257                   nthreads = thread_map__nr(evlist->threads);
1258
1259         evlist__for_each(evlist, evsel) {
1260                 if (list_empty(&evsel->drv_config_terms))
1261                         continue;
1262
1263                 err = perf_evsel__apply_drv_configs(evsel, ncpus,
1264                                                     nthreads, err_term);
1265                 if (err) {
1266                         *err_evsel = evsel;
1267                         break;
1268                 }
1269         }
1270
1271         return err;
1272 }
1273
1274 int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
1275 {
1276         struct perf_evsel *evsel;
1277         int err = 0;
1278
1279         evlist__for_each(evlist, evsel) {
1280                 err = perf_evsel__set_filter(evsel, filter);
1281                 if (err)
1282                         break;
1283         }
1284
1285         return err;
1286 }
1287
1288 int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids)
1289 {
1290         char *filter;
1291         int ret = -1;
1292         size_t i;
1293
1294         for (i = 0; i < npids; ++i) {
1295                 if (i == 0) {
1296                         if (asprintf(&filter, "common_pid != %d", pids[i]) < 0)
1297                                 return -1;
1298                 } else {
1299                         char *tmp;
1300
1301                         if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0)
1302                                 goto out_free;
1303
1304                         free(filter);
1305                         filter = tmp;
1306                 }
1307         }
1308
1309         ret = perf_evlist__set_filter(evlist, filter);
1310 out_free:
1311         free(filter);
1312         return ret;
1313 }
1314
1315 int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid)
1316 {
1317         return perf_evlist__set_filter_pids(evlist, 1, &pid);
1318 }
1319
1320 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
1321 {
1322         struct perf_evsel *pos;
1323
1324         if (evlist->nr_entries == 1)
1325                 return true;
1326
1327         if (evlist->id_pos < 0 || evlist->is_pos < 0)
1328                 return false;
1329
1330         evlist__for_each(evlist, pos) {
1331                 if (pos->id_pos != evlist->id_pos ||
1332                     pos->is_pos != evlist->is_pos)
1333                         return false;
1334         }
1335
1336         return true;
1337 }
1338
1339 u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
1340 {
1341         struct perf_evsel *evsel;
1342
1343         if (evlist->combined_sample_type)
1344                 return evlist->combined_sample_type;
1345
1346         evlist__for_each(evlist, evsel)
1347                 evlist->combined_sample_type |= evsel->attr.sample_type;
1348
1349         return evlist->combined_sample_type;
1350 }
1351
1352 u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)
1353 {
1354         evlist->combined_sample_type = 0;
1355         return __perf_evlist__combined_sample_type(evlist);
1356 }
1357
1358 u64 perf_evlist__combined_branch_type(struct perf_evlist *evlist)
1359 {
1360         struct perf_evsel *evsel;
1361         u64 branch_type = 0;
1362
1363         evlist__for_each(evlist, evsel)
1364                 branch_type |= evsel->attr.branch_sample_type;
1365         return branch_type;
1366 }
1367
1368 bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
1369 {
1370         struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
1371         u64 read_format = first->attr.read_format;
1372         u64 sample_type = first->attr.sample_type;
1373
1374         evlist__for_each(evlist, pos) {
1375                 if (read_format != pos->attr.read_format)
1376                         return false;
1377         }
1378
1379         /* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
1380         if ((sample_type & PERF_SAMPLE_READ) &&
1381             !(read_format & PERF_FORMAT_ID)) {
1382                 return false;
1383         }
1384
1385         return true;
1386 }
1387
1388 u64 perf_evlist__read_format(struct perf_evlist *evlist)
1389 {
1390         struct perf_evsel *first = perf_evlist__first(evlist);
1391         return first->attr.read_format;
1392 }
1393
1394 u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
1395 {
1396         struct perf_evsel *first = perf_evlist__first(evlist);
1397         struct perf_sample *data;
1398         u64 sample_type;
1399         u16 size = 0;
1400
1401         if (!first->attr.sample_id_all)
1402                 goto out;
1403
1404         sample_type = first->attr.sample_type;
1405
1406         if (sample_type & PERF_SAMPLE_TID)
1407                 size += sizeof(data->tid) * 2;
1408
1409        if (sample_type & PERF_SAMPLE_TIME)
1410                 size += sizeof(data->time);
1411
1412         if (sample_type & PERF_SAMPLE_ID)
1413                 size += sizeof(data->id);
1414
1415         if (sample_type & PERF_SAMPLE_STREAM_ID)
1416                 size += sizeof(data->stream_id);
1417
1418         if (sample_type & PERF_SAMPLE_CPU)
1419                 size += sizeof(data->cpu) * 2;
1420
1421         if (sample_type & PERF_SAMPLE_IDENTIFIER)
1422                 size += sizeof(data->id);
1423 out:
1424         return size;
1425 }
1426
1427 bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
1428 {
1429         struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
1430
1431         evlist__for_each_continue(evlist, pos) {
1432                 if (first->attr.sample_id_all != pos->attr.sample_id_all)
1433                         return false;
1434         }
1435
1436         return true;
1437 }
1438
1439 bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
1440 {
1441         struct perf_evsel *first = perf_evlist__first(evlist);
1442         return first->attr.sample_id_all;
1443 }
1444
1445 void perf_evlist__set_selected(struct perf_evlist *evlist,
1446                                struct perf_evsel *evsel)
1447 {
1448         evlist->selected = evsel;
1449 }
1450
1451 void perf_evlist__close(struct perf_evlist *evlist)
1452 {
1453         struct perf_evsel *evsel;
1454         int ncpus = cpu_map__nr(evlist->cpus);
1455         int nthreads = thread_map__nr(evlist->threads);
1456         int n;
1457
1458         evlist__for_each_reverse(evlist, evsel) {
1459                 n = evsel->cpus ? evsel->cpus->nr : ncpus;
1460                 perf_evsel__close(evsel, n, nthreads);
1461         }
1462 }
1463
1464 static int perf_evlist__create_syswide_maps(struct perf_evlist *evlist)
1465 {
1466         struct cpu_map    *cpus;
1467         struct thread_map *threads;
1468         int err = -ENOMEM;
1469
1470         /*
1471          * Try reading /sys/devices/system/cpu/online to get
1472          * an all cpus map.
1473          *
1474          * FIXME: -ENOMEM is the best we can do here, the cpu_map
1475          * code needs an overhaul to properly forward the
1476          * error, and we may not want to do that fallback to a
1477          * default cpu identity map :-\
1478          */
1479         cpus = cpu_map__new(NULL);
1480         if (!cpus)
1481                 goto out;
1482
1483         threads = thread_map__new_dummy();
1484         if (!threads)
1485                 goto out_put;
1486
1487         perf_evlist__set_maps(evlist, cpus, threads);
1488 out:
1489         return err;
1490 out_put:
1491         cpu_map__put(cpus);
1492         goto out;
1493 }
1494
1495 int perf_evlist__open(struct perf_evlist *evlist)
1496 {
1497         struct perf_evsel *evsel;
1498         int err;
1499
1500         /*
1501          * Default: one fd per CPU, all threads, aka systemwide
1502          * as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL
1503          */
1504         if (evlist->threads == NULL && evlist->cpus == NULL) {
1505                 err = perf_evlist__create_syswide_maps(evlist);
1506                 if (err < 0)
1507                         goto out_err;
1508         }
1509
1510         perf_evlist__update_id_pos(evlist);
1511
1512         evlist__for_each(evlist, evsel) {
1513                 err = perf_evsel__open(evsel, evsel->cpus, evsel->threads);
1514                 if (err < 0)
1515                         goto out_err;
1516         }
1517
1518         return 0;
1519 out_err:
1520         perf_evlist__close(evlist);
1521         errno = -err;
1522         return err;
1523 }
1524
1525 int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *target,
1526                                   const char *argv[], bool pipe_output,
1527                                   void (*exec_error)(int signo, siginfo_t *info, void *ucontext))
1528 {
1529         int child_ready_pipe[2], go_pipe[2];
1530         char bf;
1531
1532         if (pipe(child_ready_pipe) < 0) {
1533                 perror("failed to create 'ready' pipe");
1534                 return -1;
1535         }
1536
1537         if (pipe(go_pipe) < 0) {
1538                 perror("failed to create 'go' pipe");
1539                 goto out_close_ready_pipe;
1540         }
1541
1542         evlist->workload.pid = fork();
1543         if (evlist->workload.pid < 0) {
1544                 perror("failed to fork");
1545                 goto out_close_pipes;
1546         }
1547
1548         if (!evlist->workload.pid) {
1549                 int ret;
1550
1551                 if (pipe_output)
1552                         dup2(2, 1);
1553
1554                 signal(SIGTERM, SIG_DFL);
1555
1556                 close(child_ready_pipe[0]);
1557                 close(go_pipe[1]);
1558                 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
1559
1560                 /*
1561                  * Tell the parent we're ready to go
1562                  */
1563                 close(child_ready_pipe[1]);
1564
1565                 /*
1566                  * Wait until the parent tells us to go.
1567                  */
1568                 ret = read(go_pipe[0], &bf, 1);
1569                 /*
1570                  * The parent will ask for the execvp() to be performed by
1571                  * writing exactly one byte, in workload.cork_fd, usually via
1572                  * perf_evlist__start_workload().
1573                  *
1574                  * For cancelling the workload without actually running it,
1575                  * the parent will just close workload.cork_fd, without writing
1576                  * anything, i.e. read will return zero and we just exit()
1577                  * here.
1578                  */
1579                 if (ret != 1) {
1580                         if (ret == -1)
1581                                 perror("unable to read pipe");
1582                         exit(ret);
1583                 }
1584
1585                 execvp(argv[0], (char **)argv);
1586
1587                 if (exec_error) {
1588                         union sigval val;
1589
1590                         val.sival_int = errno;
1591                         if (sigqueue(getppid(), SIGUSR1, val))
1592                                 perror(argv[0]);
1593                 } else
1594                         perror(argv[0]);
1595                 exit(-1);
1596         }
1597
1598         if (exec_error) {
1599                 struct sigaction act = {
1600                         .sa_flags     = SA_SIGINFO,
1601                         .sa_sigaction = exec_error,
1602                 };
1603                 sigaction(SIGUSR1, &act, NULL);
1604         }
1605
1606         if (target__none(target)) {
1607                 if (evlist->threads == NULL) {
1608                         fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n",
1609                                 __func__, __LINE__);
1610                         goto out_close_pipes;
1611                 }
1612                 thread_map__set_pid(evlist->threads, 0, evlist->workload.pid);
1613         }
1614
1615         close(child_ready_pipe[1]);
1616         close(go_pipe[0]);
1617         /*
1618          * wait for child to settle
1619          */
1620         if (read(child_ready_pipe[0], &bf, 1) == -1) {
1621                 perror("unable to read pipe");
1622                 goto out_close_pipes;
1623         }
1624
1625         fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
1626         evlist->workload.cork_fd = go_pipe[1];
1627         close(child_ready_pipe[0]);
1628         return 0;
1629
1630 out_close_pipes:
1631         close(go_pipe[0]);
1632         close(go_pipe[1]);
1633 out_close_ready_pipe:
1634         close(child_ready_pipe[0]);
1635         close(child_ready_pipe[1]);
1636         return -1;
1637 }
1638
1639 int perf_evlist__start_workload(struct perf_evlist *evlist)
1640 {
1641         if (evlist->workload.cork_fd > 0) {
1642                 char bf = 0;
1643                 int ret;
1644                 /*
1645                  * Remove the cork, let it rip!
1646                  */
1647                 ret = write(evlist->workload.cork_fd, &bf, 1);
1648                 if (ret < 0)
1649                         perror("enable to write to pipe");
1650
1651                 close(evlist->workload.cork_fd);
1652                 return ret;
1653         }
1654
1655         return 0;
1656 }
1657
1658 int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
1659                               struct perf_sample *sample)
1660 {
1661         struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);
1662
1663         if (!evsel)
1664                 return -EFAULT;
1665         return perf_evsel__parse_sample(evsel, event, sample);
1666 }
1667
1668 size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
1669 {
1670         struct perf_evsel *evsel;
1671         size_t printed = 0;
1672
1673         evlist__for_each(evlist, evsel) {
1674                 printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
1675                                    perf_evsel__name(evsel));
1676         }
1677
1678         return printed + fprintf(fp, "\n");
1679 }
1680
1681 int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
1682                                int err, char *buf, size_t size)
1683 {
1684         int printed, value;
1685         char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
1686
1687         switch (err) {
1688         case EACCES:
1689         case EPERM:
1690                 printed = scnprintf(buf, size,
1691                                     "Error:\t%s.\n"
1692                                     "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);
1693
1694                 value = perf_event_paranoid();
1695
1696                 printed += scnprintf(buf + printed, size - printed, "\nHint:\t");
1697
1698                 if (value >= 2) {
1699                         printed += scnprintf(buf + printed, size - printed,
1700                                              "For your workloads it needs to be <= 1\nHint:\t");
1701                 }
1702                 printed += scnprintf(buf + printed, size - printed,
1703                                      "For system wide tracing it needs to be set to -1.\n");
1704
1705                 printed += scnprintf(buf + printed, size - printed,
1706                                     "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
1707                                     "Hint:\tThe current value is %d.", value);
1708                 break;
1709         default:
1710                 scnprintf(buf, size, "%s", emsg);
1711                 break;
1712         }
1713
1714         return 0;
1715 }
1716
1717 int perf_evlist__strerror_mmap(struct perf_evlist *evlist, int err, char *buf, size_t size)
1718 {
1719         char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
1720         int pages_attempted = evlist->mmap_len / 1024, pages_max_per_user, printed = 0;
1721
1722         switch (err) {
1723         case EPERM:
1724                 sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user);
1725                 printed += scnprintf(buf + printed, size - printed,
1726                                      "Error:\t%s.\n"
1727                                      "Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n"
1728                                      "Hint:\tTried using %zd kB.\n",
1729                                      emsg, pages_max_per_user, pages_attempted);
1730
1731                 if (pages_attempted >= pages_max_per_user) {
1732                         printed += scnprintf(buf + printed, size - printed,
1733                                              "Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n",
1734                                              pages_max_per_user + pages_attempted);
1735                 }
1736
1737                 printed += scnprintf(buf + printed, size - printed,
1738                                      "Hint:\tTry using a smaller -m/--mmap-pages value.");
1739                 break;
1740         default:
1741                 scnprintf(buf, size, "%s", emsg);
1742                 break;
1743         }
1744
1745         return 0;
1746 }
1747
1748 void perf_evlist__to_front(struct perf_evlist *evlist,
1749                            struct perf_evsel *move_evsel)
1750 {
1751         struct perf_evsel *evsel, *n;
1752         LIST_HEAD(move);
1753
1754         if (move_evsel == perf_evlist__first(evlist))
1755                 return;
1756
1757         evlist__for_each_safe(evlist, n, evsel) {
1758                 if (evsel->leader == move_evsel->leader)
1759                         list_move_tail(&evsel->node, &move);
1760         }
1761
1762         list_splice(&move, &evlist->entries);
1763 }
1764
1765 void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
1766                                      struct perf_evsel *tracking_evsel)
1767 {
1768         struct perf_evsel *evsel;
1769
1770         if (tracking_evsel->tracking)
1771                 return;
1772
1773         evlist__for_each(evlist, evsel) {
1774                 if (evsel != tracking_evsel)
1775                         evsel->tracking = false;
1776         }
1777
1778         tracking_evsel->tracking = true;
1779 }