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