tools/perf/util/evlist.c

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