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