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