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/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 "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
  28 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
  29 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
  30
  31 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
  32                        struct thread_map *threads)
  33 {
  34         int i;
  35
  36         for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
  37                 INIT_HLIST_HEAD(&evlist->heads[i]);
  38         INIT_LIST_HEAD(&evlist->entries);
  39         perf_evlist__set_maps(evlist, cpus, threads);
  40         evlist->workload.pid = -1;
  41 }
  42
  43 struct perf_evlist *perf_evlist__new(void)
  44 {
  45         struct perf_evlist *evlist = zalloc(sizeof(*evlist));
  46
  47         if (evlist != NULL)
  48                 perf_evlist__init(evlist, NULL, NULL);
  49
  50         return evlist;
  51 }
  52
  53 struct perf_evlist *perf_evlist__new_default(void)
  54 {
  55         struct perf_evlist *evlist = perf_evlist__new();
  56
  57         if (evlist && perf_evlist__add_default(evlist)) {
  58                 perf_evlist__delete(evlist);
  59                 evlist = NULL;
  60         }
  61
  62         return evlist;
  63 }
  64
  65 /**
  66  * perf_evlist__set_id_pos - set the positions of event ids.
  67  * @evlist: selected event list
  68  *
  69  * Events with compatible sample types all have the same id_pos
  70  * and is_pos.  For convenience, put a copy on evlist.
  71  */
  72 void perf_evlist__set_id_pos(struct perf_evlist *evlist)
  73 {
  74         struct perf_evsel *first = perf_evlist__first(evlist);
  75
  76         evlist->id_pos = first->id_pos;
  77         evlist->is_pos = first->is_pos;
  78 }
  79
  80 static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
  81 {
  82         struct perf_evsel *evsel;
  83
  84         evlist__for_each(evlist, evsel)
  85                 perf_evsel__calc_id_pos(evsel);
  86
  87         perf_evlist__set_id_pos(evlist);
  88 }
  89
  90 static void perf_evlist__purge(struct perf_evlist *evlist)
  91 {
  92         struct perf_evsel *pos, *n;
  93
  94         evlist__for_each_safe(evlist, n, pos) {
  95                 list_del_init(&pos->node);
  96                 perf_evsel__delete(pos);
  97         }
  98
  99         evlist->nr_entries = 0;
 100 }
 101
 102 void perf_evlist__exit(struct perf_evlist *evlist)
 103 {
 104         zfree(&evlist->mmap);
 105         zfree(&evlist->pollfd);
 106 }
 107
 108 void perf_evlist__delete(struct perf_evlist *evlist)
 109 {
 110         perf_evlist__munmap(evlist);
 111         perf_evlist__close(evlist);
 112         cpu_map__delete(evlist->cpus);
 113         thread_map__delete(evlist->threads);
 114         evlist->cpus = NULL;
 115         evlist->threads = NULL;
 116         perf_evlist__purge(evlist);
 117         perf_evlist__exit(evlist);
 118         free(evlist);
 119 }
 120
 121 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
 122 {
 123         list_add_tail(&entry->node, &evlist->entries);
 124         entry->idx = evlist->nr_entries;
 125
 126         if (!evlist->nr_entries++)
 127                 perf_evlist__set_id_pos(evlist);
 128 }
 129
 130 void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
 131                                    struct list_head *list,
 132                                    int nr_entries)
 133 {
 134         bool set_id_pos = !evlist->nr_entries;
 135
 136         list_splice_tail(list, &evlist->entries);
 137         evlist->nr_entries += nr_entries;
 138         if (set_id_pos)
 139                 perf_evlist__set_id_pos(evlist);
 140 }
 141
 142 void __perf_evlist__set_leader(struct list_head *list)
 143 {
 144         struct perf_evsel *evsel, *leader;
 145
 146         leader = list_entry(list->next, struct perf_evsel, node);
 147         evsel = list_entry(list->prev, struct perf_evsel, node);
 148
 149         leader->nr_members = evsel->idx - leader->idx + 1;
 150
 151         __evlist__for_each(list, evsel) {
 152                 evsel->leader = leader;
 153         }
 154 }
 155
 156 void perf_evlist__set_leader(struct perf_evlist *evlist)
 157 {
 158         if (evlist->nr_entries) {
 159                 evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
 160                 __perf_evlist__set_leader(&evlist->entries);
 161         }
 162 }
 163
 164 int perf_evlist__add_default(struct perf_evlist *evlist)
 165 {
 166         struct perf_event_attr attr = {
 167                 .type = PERF_TYPE_HARDWARE,
 168                 .config = PERF_COUNT_HW_CPU_CYCLES,
 169         };
 170         struct perf_evsel *evsel;
 171
 172         event_attr_init(&attr);
 173
 174         evsel = perf_evsel__new(&attr);
 175         if (evsel == NULL)
 176                 goto error;
 177
 178         /* use strdup() because free(evsel) assumes name is allocated */
 179         evsel->name = strdup("cycles");
 180         if (!evsel->name)
 181                 goto error_free;
 182
 183         perf_evlist__add(evlist, evsel);
 184         return 0;
 185 error_free:
 186         perf_evsel__delete(evsel);
 187 error:
 188         return -ENOMEM;
 189 }
 190
 191 static int perf_evlist__add_attrs(struct perf_evlist *evlist,
 192                                   struct perf_event_attr *attrs, size_t nr_attrs)
 193 {
 194         struct perf_evsel *evsel, *n;
 195         LIST_HEAD(head);
 196         size_t i;
 197
 198         for (i = 0; i < nr_attrs; i++) {
 199                 evsel = perf_evsel__new_idx(attrs + i, evlist->nr_entries + i);
 200                 if (evsel == NULL)
 201                         goto out_delete_partial_list;
 202                 list_add_tail(&evsel->node, &head);
 203         }
 204
 205         perf_evlist__splice_list_tail(evlist, &head, nr_attrs);
 206
 207         return 0;
 208
 209 out_delete_partial_list:
 210         __evlist__for_each_safe(&head, n, evsel)
 211                 perf_evsel__delete(evsel);
 212         return -1;
 213 }
 214
 215 int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,
 216                                      struct perf_event_attr *attrs, size_t nr_attrs)
 217 {
 218         size_t i;
 219
 220         for (i = 0; i < nr_attrs; i++)
 221                 event_attr_init(attrs + i);
 222
 223         return perf_evlist__add_attrs(evlist, attrs, nr_attrs);
 224 }
 225
 226 struct perf_evsel *
 227 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
 228 {
 229         struct perf_evsel *evsel;
 230
 231         evlist__for_each(evlist, evsel) {
 232                 if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
 233                     (int)evsel->attr.config == id)
 234                         return evsel;
 235         }
 236
 237         return NULL;
 238 }
 239
 240 struct perf_evsel *
 241 perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
 242                                      const char *name)
 243 {
 244         struct perf_evsel *evsel;
 245
 246         evlist__for_each(evlist, evsel) {
 247                 if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
 248                     (strcmp(evsel->name, name) == 0))
 249                         return evsel;
 250         }
 251
 252         return NULL;
 253 }
 254
 255 int perf_evlist__add_newtp(struct perf_evlist *evlist,
 256                            const char *sys, const char *name, void *handler)
 257 {
 258         struct perf_evsel *evsel = perf_evsel__newtp(sys, name);
 259
 260         if (evsel == NULL)
 261                 return -1;
 262
 263         evsel->handler = handler;
 264         perf_evlist__add(evlist, evsel);
 265         return 0;
 266 }
 267
 268 void perf_evlist__disable(struct perf_evlist *evlist)
 269 {
 270         int cpu, thread;
 271         struct perf_evsel *pos;
 272         int nr_cpus = cpu_map__nr(evlist->cpus);
 273         int nr_threads = thread_map__nr(evlist->threads);
 274
 275         for (cpu = 0; cpu < nr_cpus; cpu++) {
 276                 evlist__for_each(evlist, pos) {
 277                         if (!perf_evsel__is_group_leader(pos) || !pos->fd)
 278                                 continue;
 279                         for (thread = 0; thread < nr_threads; thread++)
 280                                 ioctl(FD(pos, cpu, thread),
 281                                       PERF_EVENT_IOC_DISABLE, 0);
 282                 }
 283         }
 284 }
 285
 286 void perf_evlist__enable(struct perf_evlist *evlist)
 287 {
 288         int cpu, thread;
 289         struct perf_evsel *pos;
 290         int nr_cpus = cpu_map__nr(evlist->cpus);
 291         int nr_threads = thread_map__nr(evlist->threads);
 292
 293         for (cpu = 0; cpu < nr_cpus; cpu++) {
 294                 evlist__for_each(evlist, pos) {
 295                         if (!perf_evsel__is_group_leader(pos) || !pos->fd)
 296                                 continue;
 297                         for (thread = 0; thread < nr_threads; thread++)
 298                                 ioctl(FD(pos, cpu, thread),
 299                                       PERF_EVENT_IOC_ENABLE, 0);
 300                 }
 301         }
 302 }
 303
 304 int perf_evlist__disable_event(struct perf_evlist *evlist,
 305                                struct perf_evsel *evsel)
 306 {
 307         int cpu, thread, err;
 308
 309         if (!evsel->fd)
 310                 return 0;
 311
 312         for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 313                 for (thread = 0; thread < evlist->threads->nr; thread++) {
 314                         err = ioctl(FD(evsel, cpu, thread),
 315                                     PERF_EVENT_IOC_DISABLE, 0);
 316                         if (err)
 317                                 return err;
 318                 }
 319         }
 320         return 0;
 321 }
 322
 323 int perf_evlist__enable_event(struct perf_evlist *evlist,
 324                               struct perf_evsel *evsel)
 325 {
 326         int cpu, thread, err;
 327
 328         if (!evsel->fd)
 329                 return -EINVAL;
 330
 331         for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 332                 for (thread = 0; thread < evlist->threads->nr; thread++) {
 333                         err = ioctl(FD(evsel, cpu, thread),
 334                                     PERF_EVENT_IOC_ENABLE, 0);
 335                         if (err)
 336                                 return err;
 337                 }
 338         }
 339         return 0;
 340 }
 341
 342 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 343 {
 344         int nr_cpus = cpu_map__nr(evlist->cpus);
 345         int nr_threads = thread_map__nr(evlist->threads);
 346         int nfds = nr_cpus * nr_threads * evlist->nr_entries;
 347         evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
 348         return evlist->pollfd != NULL ? 0 : -ENOMEM;
 349 }
 350
 351 void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
 352 {
 353         fcntl(fd, F_SETFL, O_NONBLOCK);
 354         evlist->pollfd[evlist->nr_fds].fd = fd;
 355         evlist->pollfd[evlist->nr_fds].events = POLLIN;
 356         evlist->nr_fds++;
 357 }
 358
 359 static void perf_evlist__id_hash(struct perf_evlist *evlist,
 360                                  struct perf_evsel *evsel,
 361                                  int cpu, int thread, u64 id)
 362 {
 363         int hash;
 364         struct perf_sample_id *sid = SID(evsel, cpu, thread);
 365
 366         sid->id = id;
 367         sid->evsel = evsel;
 368         hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
 369         hlist_add_head(&sid->node, &evlist->heads[hash]);
 370 }
 371
 372 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
 373                          int cpu, int thread, u64 id)
 374 {
 375         perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
 376         evsel->id[evsel->ids++] = id;
 377 }
 378
 379 static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
 380                                   struct perf_evsel *evsel,
 381                                   int cpu, int thread, int fd)
 382 {
 383         u64 read_data[4] = { 0, };
 384         int id_idx = 1; /* The first entry is the counter value */
 385         u64 id;
 386         int ret;
 387
 388         ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);
 389         if (!ret)
 390                 goto add;
 391
 392         if (errno != ENOTTY)
 393                 return -1;
 394
 395         /* Legacy way to get event id.. All hail to old kernels! */
 396
 397         /*
 398          * This way does not work with group format read, so bail
 399          * out in that case.
 400          */
 401         if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)
 402                 return -1;
 403
 404         if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
 405             read(fd, &read_data, sizeof(read_data)) == -1)
 406                 return -1;
 407
 408         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 409                 ++id_idx;
 410         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 411                 ++id_idx;
 412
 413         id = read_data[id_idx];
 414
 415  add:
 416         perf_evlist__id_add(evlist, evsel, cpu, thread, id);
 417         return 0;
 418 }
 419
 420 struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
 421 {
 422         struct hlist_head *head;
 423         struct perf_sample_id *sid;
 424         int hash;
 425
 426         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
 427         head = &evlist->heads[hash];
 428
 429         hlist_for_each_entry(sid, head, node)
 430                 if (sid->id == id)
 431                         return sid;
 432
 433         return NULL;
 434 }
 435
 436 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
 437 {
 438         struct perf_sample_id *sid;
 439
 440         if (evlist->nr_entries == 1)
 441                 return perf_evlist__first(evlist);
 442
 443         sid = perf_evlist__id2sid(evlist, id);
 444         if (sid)
 445                 return sid->evsel;
 446
 447         if (!perf_evlist__sample_id_all(evlist))
 448                 return perf_evlist__first(evlist);
 449
 450         return NULL;
 451 }
 452
 453 static int perf_evlist__event2id(struct perf_evlist *evlist,
 454                                  union perf_event *event, u64 *id)
 455 {
 456         const u64 *array = event->sample.array;
 457         ssize_t n;
 458
 459         n = (event->header.size - sizeof(event->header)) >> 3;
 460
 461         if (event->header.type == PERF_RECORD_SAMPLE) {
 462                 if (evlist->id_pos >= n)
 463                         return -1;
 464                 *id = array[evlist->id_pos];
 465         } else {
 466                 if (evlist->is_pos > n)
 467                         return -1;
 468                 n -= evlist->is_pos;
 469                 *id = array[n];
 470         }
 471         return 0;
 472 }
 473
 474 static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
 475                                                    union perf_event *event)
 476 {
 477         struct perf_evsel *first = perf_evlist__first(evlist);
 478         struct hlist_head *head;
 479         struct perf_sample_id *sid;
 480         int hash;
 481         u64 id;
 482
 483         if (evlist->nr_entries == 1)
 484                 return first;
 485
 486         if (!first->attr.sample_id_all &&
 487             event->header.type != PERF_RECORD_SAMPLE)
 488                 return first;
 489
 490         if (perf_evlist__event2id(evlist, event, &id))
 491                 return NULL;
 492
 493         /* Synthesized events have an id of zero */
 494         if (!id)
 495                 return first;
 496
 497         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
 498         head = &evlist->heads[hash];
 499
 500         hlist_for_each_entry(sid, head, node) {
 501                 if (sid->id == id)
 502                         return sid->evsel;
 503         }
 504         return NULL;
 505 }
 506
 507 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 508 {
 509         struct perf_mmap *md = &evlist->mmap[idx];
 510         unsigned int head = perf_mmap__read_head(md);
 511         unsigned int old = md->prev;
 512         unsigned char *data = md->base + page_size;
 513         union perf_event *event = NULL;
 514
 515         if (evlist->overwrite) {
 516                 /*
 517                  * If we're further behind than half the buffer, there's a chance
 518                  * the writer will bite our tail and mess up the samples under us.
 519                  *
 520                  * If we somehow ended up ahead of the head, we got messed up.
 521                  *
 522                  * In either case, truncate and restart at head.
 523                  */
 524                 int diff = head - old;
 525                 if (diff > md->mask / 2 || diff < 0) {
 526                         fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
 527
 528                         /*
 529                          * head points to a known good entry, start there.
 530                          */
 531                         old = head;
 532                 }
 533         }
 534
 535         if (old != head) {
 536                 size_t size;
 537
 538                 event = (union perf_event *)&data[old & md->mask];
 539                 size = event->header.size;
 540
 541                 /*
 542                  * Event straddles the mmap boundary -- header should always
 543                  * be inside due to u64 alignment of output.
 544                  */
 545                 if ((old & md->mask) + size != ((old + size) & md->mask)) {
 546                         unsigned int offset = old;
 547                         unsigned int len = min(sizeof(*event), size), cpy;
 548                         void *dst = md->event_copy;
 549
 550                         do {
 551                                 cpy = min(md->mask + 1 - (offset & md->mask), len);
 552                                 memcpy(dst, &data[offset & md->mask], cpy);
 553                                 offset += cpy;
 554                                 dst += cpy;
 555                                 len -= cpy;
 556                         } while (len);
 557
 558                         event = (union perf_event *) md->event_copy;
 559                 }
 560
 561                 old += size;
 562         }
 563
 564         md->prev = old;
 565
 566         return event;
 567 }
 568
 569 void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
 570 {
 571         if (!evlist->overwrite) {
 572                 struct perf_mmap *md = &evlist->mmap[idx];
 573                 unsigned int old = md->prev;
 574
 575                 perf_mmap__write_tail(md, old);
 576         }
 577 }
 578
 579 static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
 580 {
 581         if (evlist->mmap[idx].base != NULL) {
 582                 munmap(evlist->mmap[idx].base, evlist->mmap_len);
 583                 evlist->mmap[idx].base = NULL;
 584         }
 585 }
 586
 587 void perf_evlist__munmap(struct perf_evlist *evlist)
 588 {
 589         int i;
 590
 591         if (evlist->mmap == NULL)
 592                 return;
 593
 594         for (i = 0; i < evlist->nr_mmaps; i++)
 595                 __perf_evlist__munmap(evlist, i);
 596
 597         zfree(&evlist->mmap);
 598 }
 599
 600 static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 601 {
 602         evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
 603         if (cpu_map__empty(evlist->cpus))
 604                 evlist->nr_mmaps = thread_map__nr(evlist->threads);
 605         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
 606         return evlist->mmap != NULL ? 0 : -ENOMEM;
 607 }
 608
 609 struct mmap_params {
 610         int prot;
 611         int mask;
 612 };
 613
 614 static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
 615                                struct mmap_params *mp, int fd)
 616 {
 617         evlist->mmap[idx].prev = 0;
 618         evlist->mmap[idx].mask = mp->mask;
 619         evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
 620                                       MAP_SHARED, fd, 0);
 621         if (evlist->mmap[idx].base == MAP_FAILED) {
 622                 pr_debug2("failed to mmap perf event ring buffer, error %d\n",
 623                           errno);
 624                 evlist->mmap[idx].base = NULL;
 625                 return -1;
 626         }
 627
 628         perf_evlist__add_pollfd(evlist, fd);
 629         return 0;
 630 }
 631
 632 static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
 633                                        struct mmap_params *mp, int cpu,
 634                                        int thread, int *output)
 635 {
 636         struct perf_evsel *evsel;
 637
 638         evlist__for_each(evlist, evsel) {
 639                 int fd = FD(evsel, cpu, thread);
 640
 641                 if (*output == -1) {
 642                         *output = fd;
 643                         if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)
 644                                 return -1;
 645                 } else {
 646                         if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
 647                                 return -1;
 648                 }
 649
 650                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 651                     perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
 652                         return -1;
 653         }
 654
 655         return 0;
 656 }
 657
 658 static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
 659                                      struct mmap_params *mp)
 660 {
 661         int cpu, thread;
 662         int nr_cpus = cpu_map__nr(evlist->cpus);
 663         int nr_threads = thread_map__nr(evlist->threads);
 664
 665         pr_debug2("perf event ring buffer mmapped per cpu\n");
 666         for (cpu = 0; cpu < nr_cpus; cpu++) {
 667                 int output = -1;
 668
 669                 for (thread = 0; thread < nr_threads; thread++) {
 670                         if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
 671                                                         thread, &output))
 672                                 goto out_unmap;
 673                 }
 674         }
 675
 676         return 0;
 677
 678 out_unmap:
 679         for (cpu = 0; cpu < nr_cpus; cpu++)
 680                 __perf_evlist__munmap(evlist, cpu);
 681         return -1;
 682 }
 683
 684 static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
 685                                         struct mmap_params *mp)
 686 {
 687         int thread;
 688         int nr_threads = thread_map__nr(evlist->threads);
 689
 690         pr_debug2("perf event ring buffer mmapped per thread\n");
 691         for (thread = 0; thread < nr_threads; thread++) {
 692                 int output = -1;
 693
 694                 if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
 695                                                 &output))
 696                         goto out_unmap;
 697         }
 698
 699         return 0;
 700
 701 out_unmap:
 702         for (thread = 0; thread < nr_threads; thread++)
 703                 __perf_evlist__munmap(evlist, thread);
 704         return -1;
 705 }
 706
 707 static size_t perf_evlist__mmap_size(unsigned long pages)
 708 {
 709         /* 512 kiB: default amount of unprivileged mlocked memory */
 710         if (pages == UINT_MAX)
 711                 pages = (512 * 1024) / page_size;
 712         else if (!is_power_of_2(pages))
 713                 return 0;
 714
 715         return (pages + 1) * page_size;
 716 }
 717
 718 static long parse_pages_arg(const char *str, unsigned long min,
 719                             unsigned long max)
 720 {
 721         unsigned long pages, val;
 722         static struct parse_tag tags[] = {
 723                 { .tag  = 'B', .mult = 1       },
 724                 { .tag  = 'K', .mult = 1 << 10 },
 725                 { .tag  = 'M', .mult = 1 << 20 },
 726                 { .tag  = 'G', .mult = 1 << 30 },
 727                 { .tag  = 0 },
 728         };
 729
 730         if (str == NULL)
 731                 return -EINVAL;
 732
 733         val = parse_tag_value(str, tags);
 734         if (val != (unsigned long) -1) {
 735                 /* we got file size value */
 736                 pages = PERF_ALIGN(val, page_size) / page_size;
 737         } else {
 738                 /* we got pages count value */
 739                 char *eptr;
 740                 pages = strtoul(str, &eptr, 10);
 741                 if (*eptr != '\0')
 742                         return -EINVAL;
 743         }
 744
 745         if (pages == 0 && min == 0) {
 746                 /* leave number of pages at 0 */
 747         } else if (!is_power_of_2(pages)) {
 748                 /* round pages up to next power of 2 */
 749                 pages = next_pow2_l(pages);
 750                 if (!pages)
 751                         return -EINVAL;
 752                 pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n",
 753                         pages * page_size, pages);
 754         }
 755
 756         if (pages > max)
 757                 return -EINVAL;
 758
 759         return pages;
 760 }
 761
 762 int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str,
 763                                   int unset __maybe_unused)
 764 {
 765         unsigned int *mmap_pages = opt->value;
 766         unsigned long max = UINT_MAX;
 767         long pages;
 768
 769         if (max > SIZE_MAX / page_size)
 770                 max = SIZE_MAX / page_size;
 771
 772         pages = parse_pages_arg(str, 1, max);
 773         if (pages < 0) {
 774                 pr_err("Invalid argument for --mmap_pages/-m\n");
 775                 return -1;
 776         }
 777
 778         *mmap_pages = pages;
 779         return 0;
 780 }
 781
 782 /**
 783  * perf_evlist__mmap - Create mmaps to receive events.
 784  * @evlist: list of events
 785  * @pages: map length in pages
 786  * @overwrite: overwrite older events?
 787  *
 788  * If @overwrite is %false the user needs to signal event consumption using
 789  * perf_mmap__write_tail().  Using perf_evlist__mmap_read() does this
 790  * automatically.
 791  *
 792  * Return: %0 on success, negative error code otherwise.
 793  */
 794 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
 795                       bool overwrite)
 796 {
 797         struct perf_evsel *evsel;
 798         const struct cpu_map *cpus = evlist->cpus;
 799         const struct thread_map *threads = evlist->threads;
 800         struct mmap_params mp = {
 801                 .prot = PROT_READ | (overwrite ? 0 : PROT_WRITE),
 802         };
 803
 804         if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
 805                 return -ENOMEM;
 806
 807         if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
 808                 return -ENOMEM;
 809
 810         evlist->overwrite = overwrite;
 811         evlist->mmap_len = perf_evlist__mmap_size(pages);
 812         pr_debug("mmap size %zuB\n", evlist->mmap_len);
 813         mp.mask = evlist->mmap_len - page_size - 1;
 814
 815         evlist__for_each(evlist, evsel) {
 816                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 817                     evsel->sample_id == NULL &&
 818                     perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
 819                         return -ENOMEM;
 820         }
 821
 822         if (cpu_map__empty(cpus))
 823                 return perf_evlist__mmap_per_thread(evlist, &mp);
 824
 825         return perf_evlist__mmap_per_cpu(evlist, &mp);
 826 }
 827
 828 int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target)
 829 {
 830         evlist->threads = thread_map__new_str(target->pid, target->tid,
 831                                               target->uid);
 832
 833         if (evlist->threads == NULL)
 834                 return -1;
 835
 836         if (target__uses_dummy_map(target))
 837                 evlist->cpus = cpu_map__dummy_new();
 838         else
 839                 evlist->cpus = cpu_map__new(target->cpu_list);
 840
 841         if (evlist->cpus == NULL)
 842                 goto out_delete_threads;
 843
 844         return 0;
 845
 846 out_delete_threads:
 847         thread_map__delete(evlist->threads);
 848         return -1;
 849 }
 850
 851 int perf_evlist__apply_filters(struct perf_evlist *evlist)
 852 {
 853         struct perf_evsel *evsel;
 854         int err = 0;
 855         const int ncpus = cpu_map__nr(evlist->cpus),
 856                   nthreads = thread_map__nr(evlist->threads);
 857
 858         evlist__for_each(evlist, evsel) {
 859                 if (evsel->filter == NULL)
 860                         continue;
 861
 862                 err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
 863                 if (err)
 864                         break;
 865         }
 866
 867         return err;
 868 }
 869
 870 int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
 871 {
 872         struct perf_evsel *evsel;
 873         int err = 0;
 874         const int ncpus = cpu_map__nr(evlist->cpus),
 875                   nthreads = thread_map__nr(evlist->threads);
 876
 877         evlist__for_each(evlist, evsel) {
 878                 err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
 879                 if (err)
 880                         break;
 881         }
 882
 883         return err;
 884 }
 885
 886 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
 887 {
 888         struct perf_evsel *pos;
 889
 890         if (evlist->nr_entries == 1)
 891                 return true;
 892
 893         if (evlist->id_pos < 0 || evlist->is_pos < 0)
 894                 return false;
 895
 896         evlist__for_each(evlist, pos) {
 897                 if (pos->id_pos != evlist->id_pos ||
 898                     pos->is_pos != evlist->is_pos)
 899                         return false;
 900         }
 901
 902         return true;
 903 }
 904
 905 u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
 906 {
 907         struct perf_evsel *evsel;
 908
 909         if (evlist->combined_sample_type)
 910                 return evlist->combined_sample_type;
 911
 912         evlist__for_each(evlist, evsel)
 913                 evlist->combined_sample_type |= evsel->attr.sample_type;
 914
 915         return evlist->combined_sample_type;
 916 }
 917
 918 u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)
 919 {
 920         evlist->combined_sample_type = 0;
 921         return __perf_evlist__combined_sample_type(evlist);
 922 }
 923
 924 bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
 925 {
 926         struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 927         u64 read_format = first->attr.read_format;
 928         u64 sample_type = first->attr.sample_type;
 929
 930         evlist__for_each(evlist, pos) {
 931                 if (read_format != pos->attr.read_format)
 932                         return false;
 933         }
 934
 935         /* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
 936         if ((sample_type & PERF_SAMPLE_READ) &&
 937             !(read_format & PERF_FORMAT_ID)) {
 938                 return false;
 939         }
 940
 941         return true;
 942 }
 943
 944 u64 perf_evlist__read_format(struct perf_evlist *evlist)
 945 {
 946         struct perf_evsel *first = perf_evlist__first(evlist);
 947         return first->attr.read_format;
 948 }
 949
 950 u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
 951 {
 952         struct perf_evsel *first = perf_evlist__first(evlist);
 953         struct perf_sample *data;
 954         u64 sample_type;
 955         u16 size = 0;
 956
 957         if (!first->attr.sample_id_all)
 958                 goto out;
 959
 960         sample_type = first->attr.sample_type;
 961
 962         if (sample_type & PERF_SAMPLE_TID)
 963                 size += sizeof(data->tid) * 2;
 964
 965        if (sample_type & PERF_SAMPLE_TIME)
 966                 size += sizeof(data->time);
 967
 968         if (sample_type & PERF_SAMPLE_ID)
 969                 size += sizeof(data->id);
 970
 971         if (sample_type & PERF_SAMPLE_STREAM_ID)
 972                 size += sizeof(data->stream_id);
 973
 974         if (sample_type & PERF_SAMPLE_CPU)
 975                 size += sizeof(data->cpu) * 2;
 976
 977         if (sample_type & PERF_SAMPLE_IDENTIFIER)
 978                 size += sizeof(data->id);
 979 out:
 980         return size;
 981 }
 982
 983 bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
 984 {
 985         struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 986
 987         evlist__for_each_continue(evlist, pos) {
 988                 if (first->attr.sample_id_all != pos->attr.sample_id_all)
 989                         return false;
 990         }
 991
 992         return true;
 993 }
 994
 995 bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
 996 {
 997         struct perf_evsel *first = perf_evlist__first(evlist);
 998         return first->attr.sample_id_all;
 999 }
1000
1001 void perf_evlist__set_selected(struct perf_evlist *evlist,
1002                                struct perf_evsel *evsel)
1003 {
1004         evlist->selected = evsel;
1005 }
1006
1007 void perf_evlist__close(struct perf_evlist *evlist)
1008 {
1009         struct perf_evsel *evsel;
1010         int ncpus = cpu_map__nr(evlist->cpus);
1011         int nthreads = thread_map__nr(evlist->threads);
1012         int n;
1013
1014         evlist__for_each_reverse(evlist, evsel) {
1015                 n = evsel->cpus ? evsel->cpus->nr : ncpus;
1016                 perf_evsel__close(evsel, n, nthreads);
1017         }
1018 }
1019
1020 int perf_evlist__open(struct perf_evlist *evlist)
1021 {
1022         struct perf_evsel *evsel;
1023         int err;
1024
1025         perf_evlist__update_id_pos(evlist);
1026
1027         evlist__for_each(evlist, evsel) {
1028                 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
1029                 if (err < 0)
1030                         goto out_err;
1031         }
1032
1033         return 0;
1034 out_err:
1035         perf_evlist__close(evlist);
1036         errno = -err;
1037         return err;
1038 }
1039
1040 int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *target,
1041                                   const char *argv[], bool pipe_output,
1042                                   void (*exec_error)(int signo, siginfo_t *info, void *ucontext))
1043 {
1044         int child_ready_pipe[2], go_pipe[2];
1045         char bf;
1046
1047         if (pipe(child_ready_pipe) < 0) {
1048                 perror("failed to create 'ready' pipe");
1049                 return -1;
1050         }
1051
1052         if (pipe(go_pipe) < 0) {
1053                 perror("failed to create 'go' pipe");
1054                 goto out_close_ready_pipe;
1055         }
1056
1057         evlist->workload.pid = fork();
1058         if (evlist->workload.pid < 0) {
1059                 perror("failed to fork");
1060                 goto out_close_pipes;
1061         }
1062
1063         if (!evlist->workload.pid) {
1064                 if (pipe_output)
1065                         dup2(2, 1);
1066
1067                 signal(SIGTERM, SIG_DFL);
1068
1069                 close(child_ready_pipe[0]);
1070                 close(go_pipe[1]);
1071                 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
1072
1073                 /*
1074                  * Tell the parent we're ready to go
1075                  */
1076                 close(child_ready_pipe[1]);
1077
1078                 /*
1079                  * Wait until the parent tells us to go.
1080                  */
1081                 if (read(go_pipe[0], &bf, 1) == -1)
1082                         perror("unable to read pipe");
1083
1084                 execvp(argv[0], (char **)argv);
1085
1086                 if (exec_error) {
1087                         union sigval val;
1088
1089                         val.sival_int = errno;
1090                         if (sigqueue(getppid(), SIGUSR1, val))
1091                                 perror(argv[0]);
1092                 } else
1093                         perror(argv[0]);
1094                 exit(-1);
1095         }
1096
1097         if (exec_error) {
1098                 struct sigaction act = {
1099                         .sa_flags     = SA_SIGINFO,
1100                         .sa_sigaction = exec_error,
1101                 };
1102                 sigaction(SIGUSR1, &act, NULL);
1103         }
1104
1105         if (target__none(target))
1106                 evlist->threads->map[0] = evlist->workload.pid;
1107
1108         close(child_ready_pipe[1]);
1109         close(go_pipe[0]);
1110         /*
1111          * wait for child to settle
1112          */
1113         if (read(child_ready_pipe[0], &bf, 1) == -1) {
1114                 perror("unable to read pipe");
1115                 goto out_close_pipes;
1116         }
1117
1118         fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
1119         evlist->workload.cork_fd = go_pipe[1];
1120         close(child_ready_pipe[0]);
1121         return 0;
1122
1123 out_close_pipes:
1124         close(go_pipe[0]);
1125         close(go_pipe[1]);
1126 out_close_ready_pipe:
1127         close(child_ready_pipe[0]);
1128         close(child_ready_pipe[1]);
1129         return -1;
1130 }
1131
1132 int perf_evlist__start_workload(struct perf_evlist *evlist)
1133 {
1134         if (evlist->workload.cork_fd > 0) {
1135                 char bf = 0;
1136                 int ret;
1137                 /*
1138                  * Remove the cork, let it rip!
1139                  */
1140                 ret = write(evlist->workload.cork_fd, &bf, 1);
1141                 if (ret < 0)
1142                         perror("enable to write to pipe");
1143
1144                 close(evlist->workload.cork_fd);
1145                 return ret;
1146         }
1147
1148         return 0;
1149 }
1150
1151 int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
1152                               struct perf_sample *sample)
1153 {
1154         struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);
1155
1156         if (!evsel)
1157                 return -EFAULT;
1158         return perf_evsel__parse_sample(evsel, event, sample);
1159 }
1160
1161 size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
1162 {
1163         struct perf_evsel *evsel;
1164         size_t printed = 0;
1165
1166         evlist__for_each(evlist, evsel) {
1167                 printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
1168                                    perf_evsel__name(evsel));
1169         }
1170
1171         return printed + fprintf(fp, "\n");
1172 }
1173
1174 int perf_evlist__strerror_tp(struct perf_evlist *evlist __maybe_unused,
1175                              int err, char *buf, size_t size)
1176 {
1177         char sbuf[128];
1178
1179         switch (err) {
1180         case ENOENT:
1181                 scnprintf(buf, size, "%s",
1182                           "Error:\tUnable to find debugfs\n"
1183                           "Hint:\tWas your kernel was compiled with debugfs support?\n"
1184                           "Hint:\tIs the debugfs filesystem mounted?\n"
1185                           "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");
1186                 break;
1187         case EACCES:
1188                 scnprintf(buf, size,
1189                           "Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"
1190                           "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
1191                           debugfs_mountpoint, debugfs_mountpoint);
1192                 break;
1193         default:
1194                 scnprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
1195                 break;
1196         }
1197
1198         return 0;
1199 }
1200
1201 int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
1202                                int err, char *buf, size_t size)
1203 {
1204         int printed, value;
1205         char sbuf[128], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
1206
1207         switch (err) {
1208         case EACCES:
1209         case EPERM:
1210                 printed = scnprintf(buf, size,
1211                                     "Error:\t%s.\n"
1212                                     "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg);
1213
1214                 value = perf_event_paranoid();
1215
1216                 printed += scnprintf(buf + printed, size - printed, "\nHint:\t");
1217
1218                 if (value >= 2) {
1219                         printed += scnprintf(buf + printed, size - printed,
1220                                              "For your workloads it needs to be <= 1\nHint:\t");
1221                 }
1222                 printed += scnprintf(buf + printed, size - printed,
1223                                      "For system wide tracing it needs to be set to -1.\n");
1224
1225                 printed += scnprintf(buf + printed, size - printed,
1226                                     "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n"
1227                                     "Hint:\tThe current value is %d.", value);
1228                 break;
1229         default:
1230                 scnprintf(buf, size, "%s", emsg);
1231                 break;
1232         }
1233
1234         return 0;
1235 }
1236
1237 void perf_evlist__to_front(struct perf_evlist *evlist,
1238                            struct perf_evsel *move_evsel)
1239 {
1240         struct perf_evsel *evsel, *n;
1241         LIST_HEAD(move);
1242
1243         if (move_evsel == perf_evlist__first(evlist))
1244                 return;
1245
1246         evlist__for_each_safe(evlist, n, evsel) {
1247                 if (evsel->leader == move_evsel->leader)
1248                         list_move_tail(&evsel->node, &move);
1249         }
1250
1251         list_splice(&move, &evlist->entries);
1252 }