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 "debugfs.h"
  11 #include <poll.h>
  12 #include "cpumap.h"
  13 #include "thread_map.h"
  14 #include "evlist.h"
  15 #include "evsel.h"
  16 #include <unistd.h>
  17
  18 #include "parse-events.h"
  19
  20 #include <sys/mman.h>
  21
  22 #include <linux/bitops.h>
  23 #include <linux/hash.h>
  24
  25 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
  26 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
  27
  28 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
  29                        struct thread_map *threads)
  30 {
  31         int i;
  32
  33         for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
  34                 INIT_HLIST_HEAD(&evlist->heads[i]);
  35         INIT_LIST_HEAD(&evlist->entries);
  36         perf_evlist__set_maps(evlist, cpus, threads);
  37         evlist->workload.pid = -1;
  38 }
  39
  40 struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
  41                                      struct thread_map *threads)
  42 {
  43         struct perf_evlist *evlist = zalloc(sizeof(*evlist));
  44
  45         if (evlist != NULL)
  46                 perf_evlist__init(evlist, cpus, threads);
  47
  48         return evlist;
  49 }
  50
  51 void perf_evlist__config_attrs(struct perf_evlist *evlist,
  52                                struct perf_record_opts *opts)
  53 {
  54         struct perf_evsel *evsel;
  55
  56         if (evlist->cpus->map[0] < 0)
  57                 opts->no_inherit = true;
  58
  59         list_for_each_entry(evsel, &evlist->entries, node) {
  60                 perf_evsel__config(evsel, opts);
  61
  62                 if (evlist->nr_entries > 1)
  63                         evsel->attr.sample_type |= PERF_SAMPLE_ID;
  64         }
  65 }
  66
  67 static void perf_evlist__purge(struct perf_evlist *evlist)
  68 {
  69         struct perf_evsel *pos, *n;
  70
  71         list_for_each_entry_safe(pos, n, &evlist->entries, node) {
  72                 list_del_init(&pos->node);
  73                 perf_evsel__delete(pos);
  74         }
  75
  76         evlist->nr_entries = 0;
  77 }
  78
  79 void perf_evlist__exit(struct perf_evlist *evlist)
  80 {
  81         free(evlist->mmap);
  82         free(evlist->pollfd);
  83         evlist->mmap = NULL;
  84         evlist->pollfd = NULL;
  85 }
  86
  87 void perf_evlist__delete(struct perf_evlist *evlist)
  88 {
  89         perf_evlist__purge(evlist);
  90         perf_evlist__exit(evlist);
  91         free(evlist);
  92 }
  93
  94 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
  95 {
  96         list_add_tail(&entry->node, &evlist->entries);
  97         ++evlist->nr_entries;
  98 }
  99
 100 static void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
 101                                           struct list_head *list,
 102                                           int nr_entries)
 103 {
 104         list_splice_tail(list, &evlist->entries);
 105         evlist->nr_entries += nr_entries;
 106 }
 107
 108 int perf_evlist__add_default(struct perf_evlist *evlist)
 109 {
 110         struct perf_event_attr attr = {
 111                 .type = PERF_TYPE_HARDWARE,
 112                 .config = PERF_COUNT_HW_CPU_CYCLES,
 113         };
 114         struct perf_evsel *evsel = perf_evsel__new(&attr, 0);
 115
 116         if (evsel == NULL)
 117                 goto error;
 118
 119         /* use strdup() because free(evsel) assumes name is allocated */
 120         evsel->name = strdup("cycles");
 121         if (!evsel->name)
 122                 goto error_free;
 123
 124         perf_evlist__add(evlist, evsel);
 125         return 0;
 126 error_free:
 127         perf_evsel__delete(evsel);
 128 error:
 129         return -ENOMEM;
 130 }
 131
 132 int perf_evlist__add_attrs(struct perf_evlist *evlist,
 133                            struct perf_event_attr *attrs, size_t nr_attrs)
 134 {
 135         struct perf_evsel *evsel, *n;
 136         LIST_HEAD(head);
 137         size_t i;
 138
 139         for (i = 0; i < nr_attrs; i++) {
 140                 evsel = perf_evsel__new(attrs + i, evlist->nr_entries + i);
 141                 if (evsel == NULL)
 142                         goto out_delete_partial_list;
 143                 list_add_tail(&evsel->node, &head);
 144         }
 145
 146         perf_evlist__splice_list_tail(evlist, &head, nr_attrs);
 147
 148         return 0;
 149
 150 out_delete_partial_list:
 151         list_for_each_entry_safe(evsel, n, &head, node)
 152                 perf_evsel__delete(evsel);
 153         return -1;
 154 }
 155
 156 static int trace_event__id(const char *evname)
 157 {
 158         char *filename, *colon;
 159         int err = -1, fd;
 160
 161         if (asprintf(&filename, "%s/%s/id", tracing_events_path, evname) < 0)
 162                 return -1;
 163
 164         colon = strrchr(filename, ':');
 165         if (colon != NULL)
 166                 *colon = '/';
 167
 168         fd = open(filename, O_RDONLY);
 169         if (fd >= 0) {
 170                 char id[16];
 171                 if (read(fd, id, sizeof(id)) > 0)
 172                         err = atoi(id);
 173                 close(fd);
 174         }
 175
 176         free(filename);
 177         return err;
 178 }
 179
 180 int perf_evlist__add_tracepoints(struct perf_evlist *evlist,
 181                                  const char *tracepoints[],
 182                                  size_t nr_tracepoints)
 183 {
 184         int err;
 185         size_t i;
 186         struct perf_event_attr *attrs = zalloc(nr_tracepoints * sizeof(*attrs));
 187
 188         if (attrs == NULL)
 189                 return -1;
 190
 191         for (i = 0; i < nr_tracepoints; i++) {
 192                 err = trace_event__id(tracepoints[i]);
 193
 194                 if (err < 0)
 195                         goto out_free_attrs;
 196
 197                 attrs[i].type          = PERF_TYPE_TRACEPOINT;
 198                 attrs[i].config        = err;
 199                 attrs[i].sample_type   = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
 200                                           PERF_SAMPLE_CPU);
 201                 attrs[i].sample_period = 1;
 202         }
 203
 204         err = perf_evlist__add_attrs(evlist, attrs, nr_tracepoints);
 205 out_free_attrs:
 206         free(attrs);
 207         return err;
 208 }
 209
 210 static struct perf_evsel *
 211         perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
 212 {
 213         struct perf_evsel *evsel;
 214
 215         list_for_each_entry(evsel, &evlist->entries, node) {
 216                 if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
 217                     (int)evsel->attr.config == id)
 218                         return evsel;
 219         }
 220
 221         return NULL;
 222 }
 223
 224 int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
 225                                           const struct perf_evsel_str_handler *assocs,
 226                                           size_t nr_assocs)
 227 {
 228         struct perf_evsel *evsel;
 229         int err;
 230         size_t i;
 231
 232         for (i = 0; i < nr_assocs; i++) {
 233                 err = trace_event__id(assocs[i].name);
 234                 if (err < 0)
 235                         goto out;
 236
 237                 evsel = perf_evlist__find_tracepoint_by_id(evlist, err);
 238                 if (evsel == NULL)
 239                         continue;
 240
 241                 err = -EEXIST;
 242                 if (evsel->handler.func != NULL)
 243                         goto out;
 244                 evsel->handler.func = assocs[i].handler;
 245         }
 246
 247         err = 0;
 248 out:
 249         return err;
 250 }
 251
 252 void perf_evlist__disable(struct perf_evlist *evlist)
 253 {
 254         int cpu, thread;
 255         struct perf_evsel *pos;
 256
 257         for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 258                 list_for_each_entry(pos, &evlist->entries, node) {
 259                         for (thread = 0; thread < evlist->threads->nr; thread++)
 260                                 ioctl(FD(pos, cpu, thread), PERF_EVENT_IOC_DISABLE);
 261                 }
 262         }
 263 }
 264
 265 void perf_evlist__enable(struct perf_evlist *evlist)
 266 {
 267         int cpu, thread;
 268         struct perf_evsel *pos;
 269
 270         for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 271                 list_for_each_entry(pos, &evlist->entries, node) {
 272                         for (thread = 0; thread < evlist->threads->nr; thread++)
 273                                 ioctl(FD(pos, cpu, thread), PERF_EVENT_IOC_ENABLE);
 274                 }
 275         }
 276 }
 277
 278 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 279 {
 280         int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
 281         evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
 282         return evlist->pollfd != NULL ? 0 : -ENOMEM;
 283 }
 284
 285 void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
 286 {
 287         fcntl(fd, F_SETFL, O_NONBLOCK);
 288         evlist->pollfd[evlist->nr_fds].fd = fd;
 289         evlist->pollfd[evlist->nr_fds].events = POLLIN;
 290         evlist->nr_fds++;
 291 }
 292
 293 static void perf_evlist__id_hash(struct perf_evlist *evlist,
 294                                  struct perf_evsel *evsel,
 295                                  int cpu, int thread, u64 id)
 296 {
 297         int hash;
 298         struct perf_sample_id *sid = SID(evsel, cpu, thread);
 299
 300         sid->id = id;
 301         sid->evsel = evsel;
 302         hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
 303         hlist_add_head(&sid->node, &evlist->heads[hash]);
 304 }
 305
 306 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
 307                          int cpu, int thread, u64 id)
 308 {
 309         perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
 310         evsel->id[evsel->ids++] = id;
 311 }
 312
 313 static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
 314                                   struct perf_evsel *evsel,
 315                                   int cpu, int thread, int fd)
 316 {
 317         u64 read_data[4] = { 0, };
 318         int id_idx = 1; /* The first entry is the counter value */
 319
 320         if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
 321             read(fd, &read_data, sizeof(read_data)) == -1)
 322                 return -1;
 323
 324         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 325                 ++id_idx;
 326         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 327                 ++id_idx;
 328
 329         perf_evlist__id_add(evlist, evsel, cpu, thread, read_data[id_idx]);
 330         return 0;
 331 }
 332
 333 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
 334 {
 335         struct hlist_head *head;
 336         struct hlist_node *pos;
 337         struct perf_sample_id *sid;
 338         int hash;
 339
 340         if (evlist->nr_entries == 1)
 341                 return list_entry(evlist->entries.next, struct perf_evsel, node);
 342
 343         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
 344         head = &evlist->heads[hash];
 345
 346         hlist_for_each_entry(sid, pos, head, node)
 347                 if (sid->id == id)
 348                         return sid->evsel;
 349         return NULL;
 350 }
 351
 352 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 353 {
 354         /* XXX Move this to perf.c, making it generally available */
 355         unsigned int page_size = sysconf(_SC_PAGE_SIZE);
 356         struct perf_mmap *md = &evlist->mmap[idx];
 357         unsigned int head = perf_mmap__read_head(md);
 358         unsigned int old = md->prev;
 359         unsigned char *data = md->base + page_size;
 360         union perf_event *event = NULL;
 361
 362         if (evlist->overwrite) {
 363                 /*
 364                  * If we're further behind than half the buffer, there's a chance
 365                  * the writer will bite our tail and mess up the samples under us.
 366                  *
 367                  * If we somehow ended up ahead of the head, we got messed up.
 368                  *
 369                  * In either case, truncate and restart at head.
 370                  */
 371                 int diff = head - old;
 372                 if (diff > md->mask / 2 || diff < 0) {
 373                         fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
 374
 375                         /*
 376                          * head points to a known good entry, start there.
 377                          */
 378                         old = head;
 379                 }
 380         }
 381
 382         if (old != head) {
 383                 size_t size;
 384
 385                 event = (union perf_event *)&data[old & md->mask];
 386                 size = event->header.size;
 387
 388                 /*
 389                  * Event straddles the mmap boundary -- header should always
 390                  * be inside due to u64 alignment of output.
 391                  */
 392                 if ((old & md->mask) + size != ((old + size) & md->mask)) {
 393                         unsigned int offset = old;
 394                         unsigned int len = min(sizeof(*event), size), cpy;
 395                         void *dst = &evlist->event_copy;
 396
 397                         do {
 398                                 cpy = min(md->mask + 1 - (offset & md->mask), len);
 399                                 memcpy(dst, &data[offset & md->mask], cpy);
 400                                 offset += cpy;
 401                                 dst += cpy;
 402                                 len -= cpy;
 403                         } while (len);
 404
 405                         event = &evlist->event_copy;
 406                 }
 407
 408                 old += size;
 409         }
 410
 411         md->prev = old;
 412
 413         if (!evlist->overwrite)
 414                 perf_mmap__write_tail(md, old);
 415
 416         return event;
 417 }
 418
 419 void perf_evlist__munmap(struct perf_evlist *evlist)
 420 {
 421         int i;
 422
 423         for (i = 0; i < evlist->nr_mmaps; i++) {
 424                 if (evlist->mmap[i].base != NULL) {
 425                         munmap(evlist->mmap[i].base, evlist->mmap_len);
 426                         evlist->mmap[i].base = NULL;
 427                 }
 428         }
 429
 430         free(evlist->mmap);
 431         evlist->mmap = NULL;
 432 }
 433
 434 static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 435 {
 436         evlist->nr_mmaps = evlist->cpus->nr;
 437         if (evlist->cpus->map[0] == -1)
 438                 evlist->nr_mmaps = evlist->threads->nr;
 439         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
 440         return evlist->mmap != NULL ? 0 : -ENOMEM;
 441 }
 442
 443 static int __perf_evlist__mmap(struct perf_evlist *evlist,
 444                                int idx, int prot, int mask, int fd)
 445 {
 446         evlist->mmap[idx].prev = 0;
 447         evlist->mmap[idx].mask = mask;
 448         evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
 449                                       MAP_SHARED, fd, 0);
 450         if (evlist->mmap[idx].base == MAP_FAILED)
 451                 return -1;
 452
 453         perf_evlist__add_pollfd(evlist, fd);
 454         return 0;
 455 }
 456
 457 static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int mask)
 458 {
 459         struct perf_evsel *evsel;
 460         int cpu, thread;
 461
 462         for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 463                 int output = -1;
 464
 465                 for (thread = 0; thread < evlist->threads->nr; thread++) {
 466                         list_for_each_entry(evsel, &evlist->entries, node) {
 467                                 int fd = FD(evsel, cpu, thread);
 468
 469                                 if (output == -1) {
 470                                         output = fd;
 471                                         if (__perf_evlist__mmap(evlist, cpu,
 472                                                                 prot, mask, output) < 0)
 473                                                 goto out_unmap;
 474                                 } else {
 475                                         if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
 476                                                 goto out_unmap;
 477                                 }
 478
 479                                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 480                                     perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
 481                                         goto out_unmap;
 482                         }
 483                 }
 484         }
 485
 486         return 0;
 487
 488 out_unmap:
 489         for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 490                 if (evlist->mmap[cpu].base != NULL) {
 491                         munmap(evlist->mmap[cpu].base, evlist->mmap_len);
 492                         evlist->mmap[cpu].base = NULL;
 493                 }
 494         }
 495         return -1;
 496 }
 497
 498 static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, int mask)
 499 {
 500         struct perf_evsel *evsel;
 501         int thread;
 502
 503         for (thread = 0; thread < evlist->threads->nr; thread++) {
 504                 int output = -1;
 505
 506                 list_for_each_entry(evsel, &evlist->entries, node) {
 507                         int fd = FD(evsel, 0, thread);
 508
 509                         if (output == -1) {
 510                                 output = fd;
 511                                 if (__perf_evlist__mmap(evlist, thread,
 512                                                         prot, mask, output) < 0)
 513                                         goto out_unmap;
 514                         } else {
 515                                 if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
 516                                         goto out_unmap;
 517                         }
 518
 519                         if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 520                             perf_evlist__id_add_fd(evlist, evsel, 0, thread, fd) < 0)
 521                                 goto out_unmap;
 522                 }
 523         }
 524
 525         return 0;
 526
 527 out_unmap:
 528         for (thread = 0; thread < evlist->threads->nr; thread++) {
 529                 if (evlist->mmap[thread].base != NULL) {
 530                         munmap(evlist->mmap[thread].base, evlist->mmap_len);
 531                         evlist->mmap[thread].base = NULL;
 532                 }
 533         }
 534         return -1;
 535 }
 536
 537 /** perf_evlist__mmap - Create per cpu maps to receive events
 538  *
 539  * @evlist - list of events
 540  * @pages - map length in pages
 541  * @overwrite - overwrite older events?
 542  *
 543  * If overwrite is false the user needs to signal event consuption using:
 544  *
 545  *      struct perf_mmap *m = &evlist->mmap[cpu];
 546  *      unsigned int head = perf_mmap__read_head(m);
 547  *
 548  *      perf_mmap__write_tail(m, head)
 549  *
 550  * Using perf_evlist__read_on_cpu does this automatically.
 551  */
 552 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
 553                       bool overwrite)
 554 {
 555         unsigned int page_size = sysconf(_SC_PAGE_SIZE);
 556         struct perf_evsel *evsel;
 557         const struct cpu_map *cpus = evlist->cpus;
 558         const struct thread_map *threads = evlist->threads;
 559         int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), mask;
 560
 561         /* 512 kiB: default amount of unprivileged mlocked memory */
 562         if (pages == UINT_MAX)
 563                 pages = (512 * 1024) / page_size;
 564
 565         mask = pages * page_size - 1;
 566
 567         if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
 568                 return -ENOMEM;
 569
 570         if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
 571                 return -ENOMEM;
 572
 573         evlist->overwrite = overwrite;
 574         evlist->mmap_len = (pages + 1) * page_size;
 575
 576         list_for_each_entry(evsel, &evlist->entries, node) {
 577                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 578                     evsel->sample_id == NULL &&
 579                     perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0)
 580                         return -ENOMEM;
 581         }
 582
 583         if (evlist->cpus->map[0] == -1)
 584                 return perf_evlist__mmap_per_thread(evlist, prot, mask);
 585
 586         return perf_evlist__mmap_per_cpu(evlist, prot, mask);
 587 }
 588
 589 int perf_evlist__create_maps(struct perf_evlist *evlist, pid_t target_pid,
 590                              pid_t target_tid, const char *cpu_list)
 591 {
 592         evlist->threads = thread_map__new(target_pid, target_tid);
 593
 594         if (evlist->threads == NULL)
 595                 return -1;
 596
 597         if (cpu_list == NULL && target_tid != -1)
 598                 evlist->cpus = cpu_map__dummy_new();
 599         else
 600                 evlist->cpus = cpu_map__new(cpu_list);
 601
 602         if (evlist->cpus == NULL)
 603                 goto out_delete_threads;
 604
 605         return 0;
 606
 607 out_delete_threads:
 608         thread_map__delete(evlist->threads);
 609         return -1;
 610 }
 611
 612 void perf_evlist__delete_maps(struct perf_evlist *evlist)
 613 {
 614         cpu_map__delete(evlist->cpus);
 615         thread_map__delete(evlist->threads);
 616         evlist->cpus    = NULL;
 617         evlist->threads = NULL;
 618 }
 619
 620 int perf_evlist__set_filters(struct perf_evlist *evlist)
 621 {
 622         const struct thread_map *threads = evlist->threads;
 623         const struct cpu_map *cpus = evlist->cpus;
 624         struct perf_evsel *evsel;
 625         char *filter;
 626         int thread;
 627         int cpu;
 628         int err;
 629         int fd;
 630
 631         list_for_each_entry(evsel, &evlist->entries, node) {
 632                 filter = evsel->filter;
 633                 if (!filter)
 634                         continue;
 635                 for (cpu = 0; cpu < cpus->nr; cpu++) {
 636                         for (thread = 0; thread < threads->nr; thread++) {
 637                                 fd = FD(evsel, cpu, thread);
 638                                 err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
 639                                 if (err)
 640                                         return err;
 641                         }
 642                 }
 643         }
 644
 645         return 0;
 646 }
 647
 648 bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist)
 649 {
 650         struct perf_evsel *pos, *first;
 651
 652         pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
 653
 654         list_for_each_entry_continue(pos, &evlist->entries, node) {
 655                 if (first->attr.sample_type != pos->attr.sample_type)
 656                         return false;
 657         }
 658
 659         return true;
 660 }
 661
 662 u64 perf_evlist__sample_type(const struct perf_evlist *evlist)
 663 {
 664         struct perf_evsel *first;
 665
 666         first = list_entry(evlist->entries.next, struct perf_evsel, node);
 667         return first->attr.sample_type;
 668 }
 669
 670 u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist)
 671 {
 672         struct perf_evsel *first;
 673         struct perf_sample *data;
 674         u64 sample_type;
 675         u16 size = 0;
 676
 677         first = list_entry(evlist->entries.next, struct perf_evsel, node);
 678
 679         if (!first->attr.sample_id_all)
 680                 goto out;
 681
 682         sample_type = first->attr.sample_type;
 683
 684         if (sample_type & PERF_SAMPLE_TID)
 685                 size += sizeof(data->tid) * 2;
 686
 687        if (sample_type & PERF_SAMPLE_TIME)
 688                 size += sizeof(data->time);
 689
 690         if (sample_type & PERF_SAMPLE_ID)
 691                 size += sizeof(data->id);
 692
 693         if (sample_type & PERF_SAMPLE_STREAM_ID)
 694                 size += sizeof(data->stream_id);
 695
 696         if (sample_type & PERF_SAMPLE_CPU)
 697                 size += sizeof(data->cpu) * 2;
 698 out:
 699         return size;
 700 }
 701
 702 bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
 703 {
 704         struct perf_evsel *pos, *first;
 705
 706         pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
 707
 708         list_for_each_entry_continue(pos, &evlist->entries, node) {
 709                 if (first->attr.sample_id_all != pos->attr.sample_id_all)
 710                         return false;
 711         }
 712
 713         return true;
 714 }
 715
 716 bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
 717 {
 718         struct perf_evsel *first;
 719
 720         first = list_entry(evlist->entries.next, struct perf_evsel, node);
 721         return first->attr.sample_id_all;
 722 }
 723
 724 void perf_evlist__set_selected(struct perf_evlist *evlist,
 725                                struct perf_evsel *evsel)
 726 {
 727         evlist->selected = evsel;
 728 }
 729
 730 int perf_evlist__open(struct perf_evlist *evlist, bool group)
 731 {
 732         struct perf_evsel *evsel, *first;
 733         int err, ncpus, nthreads;
 734
 735         first = list_entry(evlist->entries.next, struct perf_evsel, node);
 736
 737         list_for_each_entry(evsel, &evlist->entries, node) {
 738                 struct xyarray *group_fd = NULL;
 739
 740                 if (group && evsel != first)
 741                         group_fd = first->fd;
 742
 743                 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads,
 744                                        group, group_fd);
 745                 if (err < 0)
 746                         goto out_err;
 747         }
 748
 749         return 0;
 750 out_err:
 751         ncpus = evlist->cpus ? evlist->cpus->nr : 1;
 752         nthreads = evlist->threads ? evlist->threads->nr : 1;
 753
 754         list_for_each_entry_reverse(evsel, &evlist->entries, node)
 755                 perf_evsel__close(evsel, ncpus, nthreads);
 756
 757         return err;
 758 }
 759
 760 int perf_evlist__prepare_workload(struct perf_evlist *evlist,
 761                                   struct perf_record_opts *opts,
 762                                   const char *argv[])
 763 {
 764         int child_ready_pipe[2], go_pipe[2];
 765         char bf;
 766
 767         if (pipe(child_ready_pipe) < 0) {
 768                 perror("failed to create 'ready' pipe");
 769                 return -1;
 770         }
 771
 772         if (pipe(go_pipe) < 0) {
 773                 perror("failed to create 'go' pipe");
 774                 goto out_close_ready_pipe;
 775         }
 776
 777         evlist->workload.pid = fork();
 778         if (evlist->workload.pid < 0) {
 779                 perror("failed to fork");
 780                 goto out_close_pipes;
 781         }
 782
 783         if (!evlist->workload.pid) {
 784                 if (opts->pipe_output)
 785                         dup2(2, 1);
 786
 787                 close(child_ready_pipe[0]);
 788                 close(go_pipe[1]);
 789                 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 790
 791                 /*
 792                  * Do a dummy execvp to get the PLT entry resolved,
 793                  * so we avoid the resolver overhead on the real
 794                  * execvp call.
 795                  */
 796                 execvp("", (char **)argv);
 797
 798                 /*
 799                  * Tell the parent we're ready to go
 800                  */
 801                 close(child_ready_pipe[1]);
 802
 803                 /*
 804                  * Wait until the parent tells us to go.
 805                  */
 806                 if (read(go_pipe[0], &bf, 1) == -1)
 807                         perror("unable to read pipe");
 808
 809                 execvp(argv[0], (char **)argv);
 810
 811                 perror(argv[0]);
 812                 kill(getppid(), SIGUSR1);
 813                 exit(-1);
 814         }
 815
 816         if (!opts->system_wide && opts->target_tid == -1 && opts->target_pid == -1)
 817                 evlist->threads->map[0] = evlist->workload.pid;
 818
 819         close(child_ready_pipe[1]);
 820         close(go_pipe[0]);
 821         /*
 822          * wait for child to settle
 823          */
 824         if (read(child_ready_pipe[0], &bf, 1) == -1) {
 825                 perror("unable to read pipe");
 826                 goto out_close_pipes;
 827         }
 828
 829         evlist->workload.cork_fd = go_pipe[1];
 830         close(child_ready_pipe[0]);
 831         return 0;
 832
 833 out_close_pipes:
 834         close(go_pipe[0]);
 835         close(go_pipe[1]);
 836 out_close_ready_pipe:
 837         close(child_ready_pipe[0]);
 838         close(child_ready_pipe[1]);
 839         return -1;
 840 }
 841
 842 int perf_evlist__start_workload(struct perf_evlist *evlist)
 843 {
 844         if (evlist->workload.cork_fd > 0) {
 845                 /*
 846                  * Remove the cork, let it rip!
 847                  */
 848                 return close(evlist->workload.cork_fd);
 849         }
 850
 851         return 0;
 852 }