tools/perf/util/evlist.c

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