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