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 "dwarf-regs.h" 17 #include "evlist.h" 18 #include "evsel.h" 19 #include "record.h" 20 #include "debug.h" 21 #include "units.h" 22 #include "bpf_counter.h" 23 #include <internal/lib.h> // page_size 24 #include "affinity.h" 25 #include "../perf.h" 26 #include "asm/bug.h" 27 #include "bpf-event.h" 28 #include "util/event.h" 29 #include "util/string2.h" 30 #include "util/perf_api_probe.h" 31 #include "util/evsel_fprintf.h" 32 #include "util/pmu.h" 33 #include "util/sample.h" 34 #include "util/bpf-filter.h" 35 #include "util/stat.h" 36 #include "util/util.h" 37 #include "util/env.h" 38 #include "util/intel-tpebs.h" 39 #include "util/metricgroup.h" 40 #include "util/strbuf.h" 41 #include <signal.h> 42 #include <unistd.h> 43 #include <sched.h> 44 #include <stdlib.h> 45 46 #include "parse-events.h" 47 #include <subcmd/parse-options.h> 48 49 #include <fcntl.h> 50 #include <sys/ioctl.h> 51 #include <sys/mman.h> 52 #include <sys/prctl.h> 53 #include <sys/timerfd.h> 54 #include <sys/wait.h> 55 56 #include <linux/bitops.h> 57 #include <linux/hash.h> 58 #include <linux/log2.h> 59 #include <linux/err.h> 60 #include <linux/string.h> 61 #include <linux/time64.h> 62 #include <linux/zalloc.h> 63 #include <perf/evlist.h> 64 #include <perf/evsel.h> 65 #include <perf/cpumap.h> 66 #include <perf/mmap.h> 67 68 #include <internal/xyarray.h> 69 70 #ifdef LACKS_SIGQUEUE_PROTOTYPE 71 int sigqueue(pid_t pid, int sig, const union sigval value); 72 #endif 73 74 #define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y)) 75 #define SID(e, x, y) xyarray__entry(e->core.sample_id, x, y) 76 77 void evlist__init(struct evlist *evlist, struct perf_cpu_map *cpus, 78 struct perf_thread_map *threads) 79 { 80 perf_evlist__init(&evlist->core); 81 perf_evlist__set_maps(&evlist->core, cpus, threads); 82 evlist->workload.pid = -1; 83 evlist->bkw_mmap_state = BKW_MMAP_NOTREADY; 84 evlist->ctl_fd.fd = -1; 85 evlist->ctl_fd.ack = -1; 86 evlist->ctl_fd.pos = -1; 87 evlist->nr_br_cntr = -1; 88 metricgroup__rblist_init(&evlist->metric_events); 89 INIT_LIST_HEAD(&evlist->deferred_samples); 90 } 91 92 struct evlist *evlist__new(void) 93 { 94 struct evlist *evlist = zalloc(sizeof(*evlist)); 95 96 if (evlist != NULL) 97 evlist__init(evlist, NULL, NULL); 98 99 return evlist; 100 } 101 102 struct evlist *evlist__new_default(const struct target *target, bool sample_callchains) 103 { 104 struct evlist *evlist = evlist__new(); 105 bool can_profile_kernel; 106 struct perf_pmu *pmu = NULL; 107 struct evsel *evsel; 108 char buf[256]; 109 int err; 110 111 if (!evlist) 112 return NULL; 113 114 can_profile_kernel = perf_event_paranoid_check(1); 115 116 if (EM_HOST == EM_S390 && sample_callchains) { 117 snprintf(buf, sizeof(buf), "software/%s/%s", 118 target__has_cpu(target) ? "cpu-clock" : "task-clock", 119 can_profile_kernel ? "P" : "Pu"); 120 err = parse_event(evlist, buf); 121 if (err) 122 goto out_err; 123 } else { 124 while ((pmu = perf_pmus__scan_core(pmu)) != NULL) { 125 snprintf(buf, sizeof(buf), "%s/cycles/%s", pmu->name, 126 can_profile_kernel ? "P" : "Pu"); 127 err = parse_event(evlist, buf); 128 if (err) 129 goto out_err; 130 } 131 } 132 133 /* If there is only 1 event a sample identifier isn't necessary. */ 134 if (evlist->core.nr_entries > 1) { 135 evlist__for_each_entry(evlist, evsel) 136 evsel__set_sample_id(evsel, /*can_sample_identifier=*/false); 137 } 138 139 return evlist; 140 out_err: 141 evlist__delete(evlist); 142 return NULL; 143 } 144 145 struct evlist *evlist__new_dummy(void) 146 { 147 struct evlist *evlist = evlist__new(); 148 149 if (evlist && evlist__add_dummy(evlist)) { 150 evlist__delete(evlist); 151 evlist = NULL; 152 } 153 154 return evlist; 155 } 156 157 /** 158 * evlist__set_id_pos - set the positions of event ids. 159 * @evlist: selected event list 160 * 161 * Events with compatible sample types all have the same id_pos 162 * and is_pos. For convenience, put a copy on evlist. 163 */ 164 void evlist__set_id_pos(struct evlist *evlist) 165 { 166 struct evsel *first = evlist__first(evlist); 167 168 evlist->id_pos = first->id_pos; 169 evlist->is_pos = first->is_pos; 170 } 171 172 static void evlist__update_id_pos(struct evlist *evlist) 173 { 174 struct evsel *evsel; 175 176 evlist__for_each_entry(evlist, evsel) 177 evsel__calc_id_pos(evsel); 178 179 evlist__set_id_pos(evlist); 180 } 181 182 static void evlist__purge(struct evlist *evlist) 183 { 184 struct evsel *pos, *n; 185 186 evlist__for_each_entry_safe(evlist, n, pos) { 187 list_del_init(&pos->core.node); 188 pos->evlist = NULL; 189 evsel__delete(pos); 190 } 191 192 evlist->core.nr_entries = 0; 193 } 194 195 void evlist__exit(struct evlist *evlist) 196 { 197 metricgroup__rblist_exit(&evlist->metric_events); 198 event_enable_timer__exit(&evlist->eet); 199 zfree(&evlist->mmap); 200 zfree(&evlist->overwrite_mmap); 201 perf_evlist__exit(&evlist->core); 202 } 203 204 void evlist__delete(struct evlist *evlist) 205 { 206 if (evlist == NULL) 207 return; 208 209 evlist__free_stats(evlist); 210 evlist__munmap(evlist); 211 evlist__close(evlist); 212 evlist__purge(evlist); 213 evlist__exit(evlist); 214 free(evlist); 215 } 216 217 void evlist__add(struct evlist *evlist, struct evsel *entry) 218 { 219 perf_evlist__add(&evlist->core, &entry->core); 220 entry->evlist = evlist; 221 entry->tracking = !entry->core.idx; 222 223 if (evlist->core.nr_entries == 1) 224 evlist__set_id_pos(evlist); 225 } 226 227 void evlist__remove(struct evlist *evlist, struct evsel *evsel) 228 { 229 evsel->evlist = NULL; 230 perf_evlist__remove(&evlist->core, &evsel->core); 231 } 232 233 void evlist__splice_list_tail(struct evlist *evlist, struct list_head *list) 234 { 235 while (!list_empty(list)) { 236 struct evsel *evsel, *temp, *leader = NULL; 237 238 __evlist__for_each_entry_safe(list, temp, evsel) { 239 list_del_init(&evsel->core.node); 240 evlist__add(evlist, evsel); 241 leader = evsel; 242 break; 243 } 244 245 __evlist__for_each_entry_safe(list, temp, evsel) { 246 if (evsel__has_leader(evsel, leader)) { 247 list_del_init(&evsel->core.node); 248 evlist__add(evlist, evsel); 249 } 250 } 251 } 252 } 253 254 int __evlist__set_tracepoints_handlers(struct evlist *evlist, 255 const struct evsel_str_handler *assocs, size_t nr_assocs) 256 { 257 size_t i; 258 int err; 259 260 for (i = 0; i < nr_assocs; i++) { 261 // Adding a handler for an event not in this evlist, just ignore it. 262 struct evsel *evsel = evlist__find_tracepoint_by_name(evlist, assocs[i].name); 263 if (evsel == NULL) 264 continue; 265 266 err = -EEXIST; 267 if (evsel->handler != NULL) 268 goto out; 269 evsel->handler = assocs[i].handler; 270 } 271 272 err = 0; 273 out: 274 return err; 275 } 276 277 static void evlist__set_leader(struct evlist *evlist) 278 { 279 perf_evlist__set_leader(&evlist->core); 280 } 281 282 static struct evsel *evlist__dummy_event(struct evlist *evlist) 283 { 284 struct perf_event_attr attr = { 285 .type = PERF_TYPE_SOFTWARE, 286 .config = PERF_COUNT_SW_DUMMY, 287 .size = sizeof(attr), /* to capture ABI version */ 288 /* Avoid frequency mode for dummy events to avoid associated timers. */ 289 .freq = 0, 290 .sample_period = 1, 291 }; 292 293 return evsel__new_idx(&attr, evlist->core.nr_entries); 294 } 295 296 int evlist__add_dummy(struct evlist *evlist) 297 { 298 struct evsel *evsel = evlist__dummy_event(evlist); 299 300 if (evsel == NULL) 301 return -ENOMEM; 302 303 evlist__add(evlist, evsel); 304 return 0; 305 } 306 307 struct evsel *evlist__add_aux_dummy(struct evlist *evlist, bool system_wide) 308 { 309 struct evsel *evsel = evlist__dummy_event(evlist); 310 311 if (!evsel) 312 return NULL; 313 314 evsel->core.attr.exclude_kernel = 1; 315 evsel->core.attr.exclude_guest = 1; 316 evsel->core.attr.exclude_hv = 1; 317 evsel->core.system_wide = system_wide; 318 evsel->no_aux_samples = true; 319 evsel->name = strdup("dummy:u"); 320 321 evlist__add(evlist, evsel); 322 return evsel; 323 } 324 325 #ifdef HAVE_LIBTRACEEVENT 326 struct evsel *evlist__add_sched_switch(struct evlist *evlist, bool system_wide) 327 { 328 struct evsel *evsel = evsel__newtp_idx("sched", "sched_switch", 0, 329 /*format=*/true); 330 331 if (IS_ERR(evsel)) 332 return evsel; 333 334 evsel__set_sample_bit(evsel, CPU); 335 evsel__set_sample_bit(evsel, TIME); 336 337 evsel->core.system_wide = system_wide; 338 evsel->no_aux_samples = true; 339 340 evlist__add(evlist, evsel); 341 return evsel; 342 } 343 #endif 344 345 struct evsel *evlist__find_tracepoint_by_name(struct evlist *evlist, const char *name) 346 { 347 struct evsel *evsel; 348 349 evlist__for_each_entry(evlist, evsel) { 350 if ((evsel->core.attr.type == PERF_TYPE_TRACEPOINT) && 351 (strcmp(evsel->name, name) == 0)) 352 return evsel; 353 } 354 355 return NULL; 356 } 357 358 #ifdef HAVE_LIBTRACEEVENT 359 int evlist__add_newtp(struct evlist *evlist, const char *sys, const char *name, void *handler) 360 { 361 struct evsel *evsel = evsel__newtp(sys, name); 362 363 if (IS_ERR(evsel)) 364 return -1; 365 366 evsel->handler = handler; 367 evlist__add(evlist, evsel); 368 return 0; 369 } 370 #endif 371 372 /* 373 * Should sched_setaffinity be used with evlist__for_each_cpu? Determine if 374 * migrating the thread will avoid possibly numerous IPIs. 375 */ 376 static bool evlist__use_affinity(struct evlist *evlist) 377 { 378 struct evsel *pos; 379 struct perf_cpu_map *used_cpus = NULL; 380 bool ret = false; 381 382 if (evlist->no_affinity || !evlist->core.user_requested_cpus || 383 cpu_map__is_dummy(evlist->core.user_requested_cpus)) 384 return false; 385 386 evlist__for_each_entry(evlist, pos) { 387 struct perf_cpu_map *intersect; 388 389 if (!perf_pmu__benefits_from_affinity(pos->pmu)) 390 continue; 391 392 if (evsel__is_dummy_event(pos)) { 393 /* 394 * The dummy event is opened on all CPUs so assume >1 395 * event with shared CPUs. 396 */ 397 ret = true; 398 break; 399 } 400 if (evsel__is_retire_lat(pos)) { 401 /* 402 * Retirement latency events are similar to tool ones in 403 * their implementation, and so don't require affinity. 404 */ 405 continue; 406 } 407 if (perf_cpu_map__is_empty(used_cpus)) { 408 /* First benefitting event, we want >1 on a common CPU. */ 409 used_cpus = perf_cpu_map__get(pos->core.cpus); 410 continue; 411 } 412 if ((pos->core.attr.read_format & PERF_FORMAT_GROUP) && 413 evsel__leader(pos) != pos) { 414 /* Skip members of the same sample group. */ 415 continue; 416 } 417 intersect = perf_cpu_map__intersect(used_cpus, pos->core.cpus); 418 if (!perf_cpu_map__is_empty(intersect)) { 419 /* >1 event with shared CPUs. */ 420 perf_cpu_map__put(intersect); 421 ret = true; 422 break; 423 } 424 perf_cpu_map__put(intersect); 425 perf_cpu_map__merge(&used_cpus, pos->core.cpus); 426 } 427 perf_cpu_map__put(used_cpus); 428 return ret; 429 } 430 431 void evlist_cpu_iterator__init(struct evlist_cpu_iterator *itr, struct evlist *evlist) 432 { 433 *itr = (struct evlist_cpu_iterator){ 434 .container = evlist, 435 .evsel = NULL, 436 .cpu_map_idx = 0, 437 .evlist_cpu_map_idx = 0, 438 .evlist_cpu_map_nr = perf_cpu_map__nr(evlist->core.all_cpus), 439 .cpu = (struct perf_cpu){ .cpu = -1}, 440 .affinity = NULL, 441 }; 442 443 if (evlist__empty(evlist)) { 444 /* Ensure the empty list doesn't iterate. */ 445 itr->evlist_cpu_map_idx = itr->evlist_cpu_map_nr; 446 return; 447 } 448 449 if (evlist__use_affinity(evlist)) { 450 if (affinity__setup(&itr->saved_affinity) == 0) 451 itr->affinity = &itr->saved_affinity; 452 } 453 itr->evsel = evlist__first(evlist); 454 itr->cpu = perf_cpu_map__cpu(evlist->core.all_cpus, 0); 455 if (itr->affinity) 456 affinity__set(itr->affinity, itr->cpu.cpu); 457 itr->cpu_map_idx = perf_cpu_map__idx(itr->evsel->core.cpus, itr->cpu); 458 /* 459 * If this CPU isn't in the evsel's cpu map then advance 460 * through the list. 461 */ 462 if (itr->cpu_map_idx == -1) 463 evlist_cpu_iterator__next(itr); 464 } 465 466 void evlist_cpu_iterator__exit(struct evlist_cpu_iterator *itr) 467 { 468 if (!itr->affinity) 469 return; 470 471 affinity__cleanup(itr->affinity); 472 itr->affinity = NULL; 473 } 474 475 void evlist_cpu_iterator__next(struct evlist_cpu_iterator *evlist_cpu_itr) 476 { 477 while (evlist_cpu_itr->evsel != evlist__last(evlist_cpu_itr->container)) { 478 evlist_cpu_itr->evsel = evsel__next(evlist_cpu_itr->evsel); 479 evlist_cpu_itr->cpu_map_idx = 480 perf_cpu_map__idx(evlist_cpu_itr->evsel->core.cpus, 481 evlist_cpu_itr->cpu); 482 if (evlist_cpu_itr->cpu_map_idx != -1) 483 return; 484 } 485 evlist_cpu_itr->evlist_cpu_map_idx++; 486 if (evlist_cpu_itr->evlist_cpu_map_idx < evlist_cpu_itr->evlist_cpu_map_nr) { 487 evlist_cpu_itr->evsel = evlist__first(evlist_cpu_itr->container); 488 evlist_cpu_itr->cpu = 489 perf_cpu_map__cpu(evlist_cpu_itr->container->core.all_cpus, 490 evlist_cpu_itr->evlist_cpu_map_idx); 491 if (evlist_cpu_itr->affinity) 492 affinity__set(evlist_cpu_itr->affinity, evlist_cpu_itr->cpu.cpu); 493 evlist_cpu_itr->cpu_map_idx = 494 perf_cpu_map__idx(evlist_cpu_itr->evsel->core.cpus, 495 evlist_cpu_itr->cpu); 496 /* 497 * If this CPU isn't in the evsel's cpu map then advance through 498 * the list. 499 */ 500 if (evlist_cpu_itr->cpu_map_idx == -1) 501 evlist_cpu_iterator__next(evlist_cpu_itr); 502 } else { 503 evlist_cpu_iterator__exit(evlist_cpu_itr); 504 } 505 } 506 507 static int evsel__strcmp(struct evsel *pos, char *evsel_name) 508 { 509 if (!evsel_name) 510 return 0; 511 if (evsel__is_dummy_event(pos)) 512 return 1; 513 return !evsel__name_is(pos, evsel_name); 514 } 515 516 static int evlist__is_enabled(struct evlist *evlist) 517 { 518 struct evsel *pos; 519 520 evlist__for_each_entry(evlist, pos) { 521 if (!evsel__is_group_leader(pos) || !pos->core.fd) 522 continue; 523 /* If at least one event is enabled, evlist is enabled. */ 524 if (!pos->disabled) 525 return true; 526 } 527 return false; 528 } 529 530 static void __evlist__disable(struct evlist *evlist, char *evsel_name, bool excl_dummy) 531 { 532 struct evsel *pos; 533 struct evlist_cpu_iterator evlist_cpu_itr; 534 bool has_imm = false; 535 536 /* Disable 'immediate' events last */ 537 for (int imm = 0; imm <= 1; imm++) { 538 evlist__for_each_cpu(evlist_cpu_itr, evlist) { 539 pos = evlist_cpu_itr.evsel; 540 if (evsel__strcmp(pos, evsel_name)) 541 continue; 542 if (pos->disabled || !evsel__is_group_leader(pos) || !pos->core.fd) 543 continue; 544 if (excl_dummy && evsel__is_dummy_event(pos)) 545 continue; 546 if (pos->immediate) 547 has_imm = true; 548 if (pos->immediate != imm) 549 continue; 550 evsel__disable_cpu(pos, evlist_cpu_itr.cpu_map_idx); 551 } 552 if (!has_imm) 553 break; 554 } 555 556 evlist__for_each_entry(evlist, pos) { 557 if (evsel__strcmp(pos, evsel_name)) 558 continue; 559 if (!evsel__is_group_leader(pos) || !pos->core.fd) 560 continue; 561 if (excl_dummy && evsel__is_dummy_event(pos)) 562 continue; 563 pos->disabled = true; 564 } 565 566 /* 567 * If we disabled only single event, we need to check 568 * the enabled state of the evlist manually. 569 */ 570 if (evsel_name) 571 evlist->enabled = evlist__is_enabled(evlist); 572 else 573 evlist->enabled = false; 574 } 575 576 void evlist__disable(struct evlist *evlist) 577 { 578 __evlist__disable(evlist, NULL, false); 579 } 580 581 void evlist__disable_non_dummy(struct evlist *evlist) 582 { 583 __evlist__disable(evlist, NULL, true); 584 } 585 586 void evlist__disable_evsel(struct evlist *evlist, char *evsel_name) 587 { 588 __evlist__disable(evlist, evsel_name, false); 589 } 590 591 static void __evlist__enable(struct evlist *evlist, char *evsel_name, bool excl_dummy) 592 { 593 struct evsel *pos; 594 struct evlist_cpu_iterator evlist_cpu_itr; 595 596 evlist__for_each_cpu(evlist_cpu_itr, evlist) { 597 pos = evlist_cpu_itr.evsel; 598 if (evsel__strcmp(pos, evsel_name)) 599 continue; 600 if (!evsel__is_group_leader(pos) || !pos->core.fd) 601 continue; 602 if (excl_dummy && evsel__is_dummy_event(pos)) 603 continue; 604 evsel__enable_cpu(pos, evlist_cpu_itr.cpu_map_idx); 605 } 606 evlist__for_each_entry(evlist, pos) { 607 if (evsel__strcmp(pos, evsel_name)) 608 continue; 609 if (!evsel__is_group_leader(pos) || !pos->core.fd) 610 continue; 611 if (excl_dummy && evsel__is_dummy_event(pos)) 612 continue; 613 pos->disabled = false; 614 } 615 616 /* 617 * Even single event sets the 'enabled' for evlist, 618 * so the toggle can work properly and toggle to 619 * 'disabled' state. 620 */ 621 evlist->enabled = true; 622 } 623 624 void evlist__enable(struct evlist *evlist) 625 { 626 __evlist__enable(evlist, NULL, false); 627 } 628 629 void evlist__enable_non_dummy(struct evlist *evlist) 630 { 631 __evlist__enable(evlist, NULL, true); 632 } 633 634 void evlist__enable_evsel(struct evlist *evlist, char *evsel_name) 635 { 636 __evlist__enable(evlist, evsel_name, false); 637 } 638 639 void evlist__toggle_enable(struct evlist *evlist) 640 { 641 (evlist->enabled ? evlist__disable : evlist__enable)(evlist); 642 } 643 644 int evlist__add_pollfd(struct evlist *evlist, int fd) 645 { 646 return perf_evlist__add_pollfd(&evlist->core, fd, NULL, POLLIN, fdarray_flag__default); 647 } 648 649 int evlist__filter_pollfd(struct evlist *evlist, short revents_and_mask) 650 { 651 return perf_evlist__filter_pollfd(&evlist->core, revents_and_mask); 652 } 653 654 #ifdef HAVE_EVENTFD_SUPPORT 655 int evlist__add_wakeup_eventfd(struct evlist *evlist, int fd) 656 { 657 return perf_evlist__add_pollfd(&evlist->core, fd, NULL, POLLIN, 658 fdarray_flag__nonfilterable | 659 fdarray_flag__non_perf_event); 660 } 661 #endif 662 663 int evlist__poll(struct evlist *evlist, int timeout) 664 { 665 return perf_evlist__poll(&evlist->core, timeout); 666 } 667 668 struct perf_sample_id *evlist__id2sid(struct evlist *evlist, u64 id) 669 { 670 struct hlist_head *head; 671 struct perf_sample_id *sid; 672 int hash; 673 674 hash = hash_64(id, PERF_EVLIST__HLIST_BITS); 675 head = &evlist->core.heads[hash]; 676 677 hlist_for_each_entry(sid, head, node) 678 if (sid->id == id) 679 return sid; 680 681 return NULL; 682 } 683 684 struct evsel *evlist__id2evsel(struct evlist *evlist, u64 id) 685 { 686 struct perf_sample_id *sid; 687 688 if (evlist->core.nr_entries == 1 || !id) 689 return evlist__first(evlist); 690 691 sid = evlist__id2sid(evlist, id); 692 if (sid) 693 return container_of(sid->evsel, struct evsel, core); 694 695 if (!evlist__sample_id_all(evlist)) 696 return evlist__first(evlist); 697 698 return NULL; 699 } 700 701 struct evsel *evlist__id2evsel_strict(struct evlist *evlist, u64 id) 702 { 703 struct perf_sample_id *sid; 704 705 if (!id) 706 return NULL; 707 708 sid = evlist__id2sid(evlist, id); 709 if (sid) 710 return container_of(sid->evsel, struct evsel, core); 711 712 return NULL; 713 } 714 715 static int evlist__event2id(struct evlist *evlist, union perf_event *event, u64 *id) 716 { 717 const __u64 *array = event->sample.array; 718 ssize_t n; 719 720 n = (event->header.size - sizeof(event->header)) >> 3; 721 722 if (event->header.type == PERF_RECORD_SAMPLE) { 723 if (evlist->id_pos >= n) 724 return -1; 725 *id = array[evlist->id_pos]; 726 } else { 727 if (evlist->is_pos > n) 728 return -1; 729 n -= evlist->is_pos; 730 *id = array[n]; 731 } 732 return 0; 733 } 734 735 struct evsel *evlist__event2evsel(struct evlist *evlist, union perf_event *event) 736 { 737 struct evsel *first = evlist__first(evlist); 738 struct hlist_head *head; 739 struct perf_sample_id *sid; 740 int hash; 741 u64 id; 742 743 if (evlist->core.nr_entries == 1) 744 return first; 745 746 if (!first->core.attr.sample_id_all && 747 event->header.type != PERF_RECORD_SAMPLE) 748 return first; 749 750 if (evlist__event2id(evlist, event, &id)) 751 return NULL; 752 753 /* Synthesized events have an id of zero */ 754 if (!id) 755 return first; 756 757 hash = hash_64(id, PERF_EVLIST__HLIST_BITS); 758 head = &evlist->core.heads[hash]; 759 760 hlist_for_each_entry(sid, head, node) { 761 if (sid->id == id) 762 return container_of(sid->evsel, struct evsel, core); 763 } 764 return NULL; 765 } 766 767 static int evlist__set_paused(struct evlist *evlist, bool value) 768 { 769 int i; 770 771 if (!evlist->overwrite_mmap) 772 return 0; 773 774 for (i = 0; i < evlist->core.nr_mmaps; i++) { 775 int fd = evlist->overwrite_mmap[i].core.fd; 776 int err; 777 778 if (fd < 0) 779 continue; 780 err = ioctl(fd, PERF_EVENT_IOC_PAUSE_OUTPUT, value ? 1 : 0); 781 if (err) 782 return err; 783 } 784 return 0; 785 } 786 787 static int evlist__pause(struct evlist *evlist) 788 { 789 return evlist__set_paused(evlist, true); 790 } 791 792 static int evlist__resume(struct evlist *evlist) 793 { 794 return evlist__set_paused(evlist, false); 795 } 796 797 static void evlist__munmap_nofree(struct evlist *evlist) 798 { 799 int i; 800 801 if (evlist->mmap) 802 for (i = 0; i < evlist->core.nr_mmaps; i++) 803 perf_mmap__munmap(&evlist->mmap[i].core); 804 805 if (evlist->overwrite_mmap) 806 for (i = 0; i < evlist->core.nr_mmaps; i++) 807 perf_mmap__munmap(&evlist->overwrite_mmap[i].core); 808 } 809 810 void evlist__munmap(struct evlist *evlist) 811 { 812 evlist__munmap_nofree(evlist); 813 zfree(&evlist->mmap); 814 zfree(&evlist->overwrite_mmap); 815 } 816 817 static void perf_mmap__unmap_cb(struct perf_mmap *map) 818 { 819 struct mmap *m = container_of(map, struct mmap, core); 820 821 mmap__munmap(m); 822 } 823 824 static struct mmap *evlist__alloc_mmap(struct evlist *evlist, 825 bool overwrite) 826 { 827 int i; 828 struct mmap *map; 829 830 map = zalloc(evlist->core.nr_mmaps * sizeof(struct mmap)); 831 if (!map) 832 return NULL; 833 834 for (i = 0; i < evlist->core.nr_mmaps; i++) { 835 struct perf_mmap *prev = i ? &map[i - 1].core : NULL; 836 837 /* 838 * When the perf_mmap() call is made we grab one refcount, plus 839 * one extra to let perf_mmap__consume() get the last 840 * events after all real references (perf_mmap__get()) are 841 * dropped. 842 * 843 * Each PERF_EVENT_IOC_SET_OUTPUT points to this mmap and 844 * thus does perf_mmap__get() on it. 845 */ 846 perf_mmap__init(&map[i].core, prev, overwrite, perf_mmap__unmap_cb); 847 } 848 849 return map; 850 } 851 852 static void 853 perf_evlist__mmap_cb_idx(struct perf_evlist *_evlist, 854 struct perf_evsel *_evsel, 855 struct perf_mmap_param *_mp, 856 int idx) 857 { 858 struct evlist *evlist = container_of(_evlist, struct evlist, core); 859 struct mmap_params *mp = container_of(_mp, struct mmap_params, core); 860 struct evsel *evsel = container_of(_evsel, struct evsel, core); 861 862 auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, evsel, idx); 863 } 864 865 static struct perf_mmap* 866 perf_evlist__mmap_cb_get(struct perf_evlist *_evlist, bool overwrite, int idx) 867 { 868 struct evlist *evlist = container_of(_evlist, struct evlist, core); 869 struct mmap *maps; 870 871 maps = overwrite ? evlist->overwrite_mmap : evlist->mmap; 872 873 if (!maps) { 874 maps = evlist__alloc_mmap(evlist, overwrite); 875 if (!maps) 876 return NULL; 877 878 if (overwrite) { 879 evlist->overwrite_mmap = maps; 880 if (evlist->bkw_mmap_state == BKW_MMAP_NOTREADY) 881 evlist__toggle_bkw_mmap(evlist, BKW_MMAP_RUNNING); 882 } else { 883 evlist->mmap = maps; 884 } 885 } 886 887 return &maps[idx].core; 888 } 889 890 static int 891 perf_evlist__mmap_cb_mmap(struct perf_mmap *_map, struct perf_mmap_param *_mp, 892 int output, struct perf_cpu cpu) 893 { 894 struct mmap *map = container_of(_map, struct mmap, core); 895 struct mmap_params *mp = container_of(_mp, struct mmap_params, core); 896 897 return mmap__mmap(map, mp, output, cpu); 898 } 899 900 unsigned long perf_event_mlock_kb_in_pages(void) 901 { 902 unsigned long pages; 903 int max; 904 905 if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) { 906 /* 907 * Pick a once upon a time good value, i.e. things look 908 * strange since we can't read a sysctl value, but lets not 909 * die yet... 910 */ 911 max = 512; 912 } else { 913 max -= (page_size / 1024); 914 } 915 916 pages = (max * 1024) / page_size; 917 if (!is_power_of_2(pages)) 918 pages = rounddown_pow_of_two(pages); 919 920 return pages; 921 } 922 923 size_t evlist__mmap_size(unsigned long pages) 924 { 925 if (pages == UINT_MAX) 926 pages = perf_event_mlock_kb_in_pages(); 927 else if (!is_power_of_2(pages)) 928 return 0; 929 930 return (pages + 1) * page_size; 931 } 932 933 static long parse_pages_arg(const char *str, unsigned long min, 934 unsigned long max) 935 { 936 unsigned long pages, val; 937 static struct parse_tag tags[] = { 938 { .tag = 'B', .mult = 1 }, 939 { .tag = 'K', .mult = 1 << 10 }, 940 { .tag = 'M', .mult = 1 << 20 }, 941 { .tag = 'G', .mult = 1 << 30 }, 942 { .tag = 0 }, 943 }; 944 945 if (str == NULL) 946 return -EINVAL; 947 948 val = parse_tag_value(str, tags); 949 if (val != (unsigned long) -1) { 950 /* we got file size value */ 951 pages = PERF_ALIGN(val, page_size) / page_size; 952 } else { 953 /* we got pages count value */ 954 char *eptr; 955 pages = strtoul(str, &eptr, 10); 956 if (*eptr != '\0') 957 return -EINVAL; 958 } 959 960 if (pages == 0 && min == 0) { 961 /* leave number of pages at 0 */ 962 } else if (!is_power_of_2(pages)) { 963 char buf[100]; 964 965 /* round pages up to next power of 2 */ 966 pages = roundup_pow_of_two(pages); 967 if (!pages) 968 return -EINVAL; 969 970 unit_number__scnprintf(buf, sizeof(buf), pages * page_size); 971 pr_info("rounding mmap pages size to %s (%lu pages)\n", 972 buf, pages); 973 } 974 975 if (pages > max) 976 return -EINVAL; 977 978 return pages; 979 } 980 981 int __evlist__parse_mmap_pages(unsigned int *mmap_pages, const char *str) 982 { 983 unsigned long max = UINT_MAX; 984 long pages; 985 986 if (max > SIZE_MAX / page_size) 987 max = SIZE_MAX / page_size; 988 989 pages = parse_pages_arg(str, 1, max); 990 if (pages < 0) { 991 pr_err("Invalid argument for --mmap_pages/-m\n"); 992 return -1; 993 } 994 995 *mmap_pages = pages; 996 return 0; 997 } 998 999 int evlist__parse_mmap_pages(const struct option *opt, const char *str, int unset __maybe_unused) 1000 { 1001 return __evlist__parse_mmap_pages(opt->value, str); 1002 } 1003 1004 /** 1005 * evlist__mmap_ex - Create mmaps to receive events. 1006 * @evlist: list of events 1007 * @pages: map length in pages 1008 * @overwrite: overwrite older events? 1009 * @auxtrace_pages - auxtrace map length in pages 1010 * @auxtrace_overwrite - overwrite older auxtrace data? 1011 * 1012 * If @overwrite is %false the user needs to signal event consumption using 1013 * perf_mmap__write_tail(). Using evlist__mmap_read() does this 1014 * automatically. 1015 * 1016 * Similarly, if @auxtrace_overwrite is %false the user needs to signal data 1017 * consumption using auxtrace_mmap__write_tail(). 1018 * 1019 * Return: %0 on success, negative error code otherwise. 1020 */ 1021 int evlist__mmap_ex(struct evlist *evlist, unsigned int pages, 1022 unsigned int auxtrace_pages, 1023 bool auxtrace_overwrite, int nr_cblocks, int affinity, int flush, 1024 int comp_level) 1025 { 1026 /* 1027 * Delay setting mp.prot: set it before calling perf_mmap__mmap. 1028 * Its value is decided by evsel's write_backward. 1029 * So &mp should not be passed through const pointer. 1030 */ 1031 struct mmap_params mp = { 1032 .nr_cblocks = nr_cblocks, 1033 .affinity = affinity, 1034 .flush = flush, 1035 .comp_level = comp_level 1036 }; 1037 struct perf_evlist_mmap_ops ops = { 1038 .idx = perf_evlist__mmap_cb_idx, 1039 .get = perf_evlist__mmap_cb_get, 1040 .mmap = perf_evlist__mmap_cb_mmap, 1041 }; 1042 1043 evlist->core.mmap_len = evlist__mmap_size(pages); 1044 pr_debug("mmap size %zuB\n", evlist->core.mmap_len); 1045 1046 auxtrace_mmap_params__init(&mp.auxtrace_mp, evlist->core.mmap_len, 1047 auxtrace_pages, auxtrace_overwrite); 1048 1049 return perf_evlist__mmap_ops(&evlist->core, &ops, &mp.core); 1050 } 1051 1052 int evlist__mmap(struct evlist *evlist, unsigned int pages) 1053 { 1054 return evlist__mmap_ex(evlist, pages, 0, false, 0, PERF_AFFINITY_SYS, 1, 0); 1055 } 1056 1057 int evlist__create_maps(struct evlist *evlist, struct target *target) 1058 { 1059 bool all_threads = (target->per_thread && target->system_wide); 1060 struct perf_cpu_map *cpus; 1061 struct perf_thread_map *threads; 1062 1063 /* 1064 * If specify '-a' and '--per-thread' to perf record, perf record 1065 * will override '--per-thread'. target->per_thread = false and 1066 * target->system_wide = true. 1067 * 1068 * If specify '--per-thread' only to perf record, 1069 * target->per_thread = true and target->system_wide = false. 1070 * 1071 * So target->per_thread && target->system_wide is false. 1072 * For perf record, thread_map__new_str doesn't call 1073 * thread_map__new_all_cpus. That will keep perf record's 1074 * current behavior. 1075 * 1076 * For perf stat, it allows the case that target->per_thread and 1077 * target->system_wide are all true. It means to collect system-wide 1078 * per-thread data. thread_map__new_str will call 1079 * thread_map__new_all_cpus to enumerate all threads. 1080 */ 1081 threads = thread_map__new_str(target->pid, target->tid, all_threads); 1082 1083 if (!threads) 1084 return -1; 1085 1086 if (target__uses_dummy_map(target) && !evlist__has_bpf_output(evlist)) 1087 cpus = perf_cpu_map__new_any_cpu(); 1088 else 1089 cpus = perf_cpu_map__new(target->cpu_list); 1090 1091 if (!cpus) 1092 goto out_delete_threads; 1093 1094 evlist->core.has_user_cpus = !!target->cpu_list; 1095 1096 perf_evlist__set_maps(&evlist->core, cpus, threads); 1097 1098 /* as evlist now has references, put count here */ 1099 perf_cpu_map__put(cpus); 1100 perf_thread_map__put(threads); 1101 1102 return 0; 1103 1104 out_delete_threads: 1105 perf_thread_map__put(threads); 1106 return -1; 1107 } 1108 1109 int evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel, 1110 struct target *target) 1111 { 1112 struct evsel *evsel; 1113 int err = 0; 1114 1115 evlist__for_each_entry(evlist, evsel) { 1116 /* 1117 * filters only work for tracepoint event, which doesn't have cpu limit. 1118 * So evlist and evsel should always be same. 1119 */ 1120 if (evsel->filter) { 1121 err = perf_evsel__apply_filter(&evsel->core, evsel->filter); 1122 if (err) { 1123 *err_evsel = evsel; 1124 break; 1125 } 1126 } 1127 1128 /* 1129 * non-tracepoint events can have BPF filters. 1130 */ 1131 if (!list_empty(&evsel->bpf_filters)) { 1132 err = perf_bpf_filter__prepare(evsel, target); 1133 if (err) { 1134 *err_evsel = evsel; 1135 break; 1136 } 1137 } 1138 } 1139 1140 return err; 1141 } 1142 1143 int evlist__set_tp_filter(struct evlist *evlist, const char *filter) 1144 { 1145 struct evsel *evsel; 1146 int err = 0; 1147 1148 if (filter == NULL) 1149 return -1; 1150 1151 evlist__for_each_entry(evlist, evsel) { 1152 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) 1153 continue; 1154 1155 err = evsel__set_filter(evsel, filter); 1156 if (err) 1157 break; 1158 } 1159 1160 return err; 1161 } 1162 1163 int evlist__append_tp_filter(struct evlist *evlist, const char *filter) 1164 { 1165 struct evsel *evsel; 1166 int err = 0; 1167 1168 if (filter == NULL) 1169 return -1; 1170 1171 evlist__for_each_entry(evlist, evsel) { 1172 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) 1173 continue; 1174 1175 err = evsel__append_tp_filter(evsel, filter); 1176 if (err) 1177 break; 1178 } 1179 1180 return err; 1181 } 1182 1183 char *asprintf__tp_filter_pids(size_t npids, pid_t *pids) 1184 { 1185 char *filter; 1186 size_t i; 1187 1188 for (i = 0; i < npids; ++i) { 1189 if (i == 0) { 1190 if (asprintf(&filter, "common_pid != %d", pids[i]) < 0) 1191 return NULL; 1192 } else { 1193 char *tmp; 1194 1195 if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0) 1196 goto out_free; 1197 1198 free(filter); 1199 filter = tmp; 1200 } 1201 } 1202 1203 return filter; 1204 out_free: 1205 free(filter); 1206 return NULL; 1207 } 1208 1209 int evlist__set_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids) 1210 { 1211 char *filter = asprintf__tp_filter_pids(npids, pids); 1212 int ret = evlist__set_tp_filter(evlist, filter); 1213 1214 free(filter); 1215 return ret; 1216 } 1217 1218 int evlist__append_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids) 1219 { 1220 char *filter = asprintf__tp_filter_pids(npids, pids); 1221 int ret = evlist__append_tp_filter(evlist, filter); 1222 1223 free(filter); 1224 return ret; 1225 } 1226 1227 int evlist__append_tp_filter_pid(struct evlist *evlist, pid_t pid) 1228 { 1229 return evlist__append_tp_filter_pids(evlist, 1, &pid); 1230 } 1231 1232 bool evlist__valid_sample_type(struct evlist *evlist) 1233 { 1234 struct evsel *pos; 1235 1236 if (evlist->core.nr_entries == 1) 1237 return true; 1238 1239 if (evlist->id_pos < 0 || evlist->is_pos < 0) 1240 return false; 1241 1242 evlist__for_each_entry(evlist, pos) { 1243 if (pos->id_pos != evlist->id_pos || 1244 pos->is_pos != evlist->is_pos) 1245 return false; 1246 } 1247 1248 return true; 1249 } 1250 1251 u64 __evlist__combined_sample_type(struct evlist *evlist) 1252 { 1253 struct evsel *evsel; 1254 1255 if (evlist->combined_sample_type) 1256 return evlist->combined_sample_type; 1257 1258 evlist__for_each_entry(evlist, evsel) 1259 evlist->combined_sample_type |= evsel->core.attr.sample_type; 1260 1261 return evlist->combined_sample_type; 1262 } 1263 1264 u64 evlist__combined_sample_type(struct evlist *evlist) 1265 { 1266 evlist->combined_sample_type = 0; 1267 return __evlist__combined_sample_type(evlist); 1268 } 1269 1270 u64 evlist__combined_branch_type(struct evlist *evlist) 1271 { 1272 struct evsel *evsel; 1273 u64 branch_type = 0; 1274 1275 evlist__for_each_entry(evlist, evsel) 1276 branch_type |= evsel->core.attr.branch_sample_type; 1277 return branch_type; 1278 } 1279 1280 static struct evsel * 1281 evlist__find_dup_event_from_prev(struct evlist *evlist, struct evsel *event) 1282 { 1283 struct evsel *pos; 1284 1285 evlist__for_each_entry(evlist, pos) { 1286 if (event == pos) 1287 break; 1288 if ((pos->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS) && 1289 !strcmp(pos->name, event->name)) 1290 return pos; 1291 } 1292 return NULL; 1293 } 1294 1295 #define MAX_NR_ABBR_NAME (26 * 11) 1296 1297 /* 1298 * The abbr name is from A to Z9. If the number of event 1299 * which requires the branch counter > MAX_NR_ABBR_NAME, 1300 * return NA. 1301 */ 1302 static void evlist__new_abbr_name(char *name) 1303 { 1304 static int idx; 1305 int i = idx / 26; 1306 1307 if (idx >= MAX_NR_ABBR_NAME) { 1308 name[0] = 'N'; 1309 name[1] = 'A'; 1310 name[2] = '\0'; 1311 return; 1312 } 1313 1314 name[0] = 'A' + (idx % 26); 1315 1316 if (!i) 1317 name[1] = '\0'; 1318 else { 1319 name[1] = '0' + i - 1; 1320 name[2] = '\0'; 1321 } 1322 1323 idx++; 1324 } 1325 1326 void evlist__update_br_cntr(struct evlist *evlist) 1327 { 1328 struct evsel *evsel, *dup; 1329 int i = 0; 1330 1331 evlist__for_each_entry(evlist, evsel) { 1332 if (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS) { 1333 evsel->br_cntr_idx = i++; 1334 evsel__leader(evsel)->br_cntr_nr++; 1335 1336 dup = evlist__find_dup_event_from_prev(evlist, evsel); 1337 if (dup) 1338 memcpy(evsel->abbr_name, dup->abbr_name, 3 * sizeof(char)); 1339 else 1340 evlist__new_abbr_name(evsel->abbr_name); 1341 } 1342 } 1343 evlist->nr_br_cntr = i; 1344 } 1345 1346 bool evlist__valid_read_format(struct evlist *evlist) 1347 { 1348 struct evsel *first = evlist__first(evlist), *pos = first; 1349 u64 read_format = first->core.attr.read_format; 1350 u64 sample_type = first->core.attr.sample_type; 1351 1352 evlist__for_each_entry(evlist, pos) { 1353 if (read_format != pos->core.attr.read_format) { 1354 pr_debug("Read format differs %#" PRIx64 " vs %#" PRIx64 "\n", 1355 read_format, (u64)pos->core.attr.read_format); 1356 } 1357 } 1358 1359 /* PERF_SAMPLE_READ implies PERF_FORMAT_ID. */ 1360 if ((sample_type & PERF_SAMPLE_READ) && 1361 !(read_format & PERF_FORMAT_ID)) { 1362 return false; 1363 } 1364 1365 return true; 1366 } 1367 1368 u16 evlist__id_hdr_size(struct evlist *evlist) 1369 { 1370 struct evsel *first = evlist__first(evlist); 1371 1372 return first->core.attr.sample_id_all ? evsel__id_hdr_size(first) : 0; 1373 } 1374 1375 bool evlist__valid_sample_id_all(struct evlist *evlist) 1376 { 1377 struct evsel *first = evlist__first(evlist), *pos = first; 1378 1379 evlist__for_each_entry_continue(evlist, pos) { 1380 if (first->core.attr.sample_id_all != pos->core.attr.sample_id_all) 1381 return false; 1382 } 1383 1384 return true; 1385 } 1386 1387 bool evlist__sample_id_all(struct evlist *evlist) 1388 { 1389 struct evsel *first = evlist__first(evlist); 1390 return first->core.attr.sample_id_all; 1391 } 1392 1393 void evlist__set_selected(struct evlist *evlist, struct evsel *evsel) 1394 { 1395 evlist->selected = evsel; 1396 } 1397 1398 void evlist__close(struct evlist *evlist) 1399 { 1400 struct evsel *evsel; 1401 struct evlist_cpu_iterator evlist_cpu_itr; 1402 1403 evlist__for_each_cpu(evlist_cpu_itr, evlist) { 1404 if (evlist_cpu_itr.cpu_map_idx == 0 && evsel__is_retire_lat(evlist_cpu_itr.evsel)) 1405 evsel__tpebs_close(evlist_cpu_itr.evsel); 1406 perf_evsel__close_cpu(&evlist_cpu_itr.evsel->core, 1407 evlist_cpu_itr.cpu_map_idx); 1408 } 1409 1410 evlist__for_each_entry_reverse(evlist, evsel) { 1411 perf_evsel__free_fd(&evsel->core); 1412 perf_evsel__free_id(&evsel->core); 1413 } 1414 perf_evlist__reset_id_hash(&evlist->core); 1415 } 1416 1417 static int evlist__create_syswide_maps(struct evlist *evlist) 1418 { 1419 struct perf_cpu_map *cpus; 1420 struct perf_thread_map *threads; 1421 1422 /* 1423 * Try reading /sys/devices/system/cpu/online to get 1424 * an all cpus map. 1425 * 1426 * FIXME: -ENOMEM is the best we can do here, the cpu_map 1427 * code needs an overhaul to properly forward the 1428 * error, and we may not want to do that fallback to a 1429 * default cpu identity map :-\ 1430 */ 1431 cpus = perf_cpu_map__new_online_cpus(); 1432 if (!cpus) 1433 return -ENOMEM; 1434 1435 threads = perf_thread_map__new_dummy(); 1436 if (!threads) { 1437 perf_cpu_map__put(cpus); 1438 return -ENOMEM; 1439 } 1440 1441 perf_evlist__set_maps(&evlist->core, cpus, threads); 1442 perf_thread_map__put(threads); 1443 perf_cpu_map__put(cpus); 1444 return 0; 1445 } 1446 1447 int evlist__open(struct evlist *evlist) 1448 { 1449 struct evsel *evsel; 1450 int err; 1451 1452 /* 1453 * Default: one fd per CPU, all threads, aka systemwide 1454 * as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL 1455 */ 1456 if (evlist->core.threads == NULL && evlist->core.user_requested_cpus == NULL) { 1457 err = evlist__create_syswide_maps(evlist); 1458 if (err < 0) 1459 goto out_err; 1460 } 1461 1462 evlist__update_id_pos(evlist); 1463 1464 evlist__for_each_entry(evlist, evsel) { 1465 err = evsel__open(evsel, evsel->core.cpus, evsel->core.threads); 1466 if (err < 0) 1467 goto out_err; 1468 } 1469 1470 return 0; 1471 out_err: 1472 evlist__close(evlist); 1473 errno = -err; 1474 return err; 1475 } 1476 1477 int evlist__prepare_workload(struct evlist *evlist, struct target *target, const char *argv[], 1478 bool pipe_output, void (*exec_error)(int signo, siginfo_t *info, void *ucontext)) 1479 { 1480 int child_ready_pipe[2], go_pipe[2]; 1481 char bf; 1482 1483 evlist->workload.cork_fd = -1; 1484 1485 if (pipe(child_ready_pipe) < 0) { 1486 perror("failed to create 'ready' pipe"); 1487 return -1; 1488 } 1489 1490 if (pipe(go_pipe) < 0) { 1491 perror("failed to create 'go' pipe"); 1492 goto out_close_ready_pipe; 1493 } 1494 1495 evlist->workload.pid = fork(); 1496 if (evlist->workload.pid < 0) { 1497 perror("failed to fork"); 1498 goto out_close_pipes; 1499 } 1500 1501 if (!evlist->workload.pid) { 1502 int ret; 1503 1504 if (pipe_output) 1505 dup2(2, 1); 1506 1507 signal(SIGTERM, SIG_DFL); 1508 1509 close(child_ready_pipe[0]); 1510 close(go_pipe[1]); 1511 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC); 1512 1513 /* 1514 * Change the name of this process not to confuse --exclude-perf users 1515 * that sees 'perf' in the window up to the execvp() and thinks that 1516 * perf samples are not being excluded. 1517 */ 1518 prctl(PR_SET_NAME, "perf-exec"); 1519 1520 /* 1521 * Tell the parent we're ready to go 1522 */ 1523 close(child_ready_pipe[1]); 1524 1525 /* 1526 * Wait until the parent tells us to go. 1527 */ 1528 ret = read(go_pipe[0], &bf, 1); 1529 /* 1530 * The parent will ask for the execvp() to be performed by 1531 * writing exactly one byte, in workload.cork_fd, usually via 1532 * evlist__start_workload(). 1533 * 1534 * For cancelling the workload without actually running it, 1535 * the parent will just close workload.cork_fd, without writing 1536 * anything, i.e. read will return zero and we just exit() 1537 * here (See evlist__cancel_workload()). 1538 */ 1539 if (ret != 1) { 1540 if (ret == -1) 1541 perror("unable to read pipe"); 1542 exit(ret); 1543 } 1544 1545 execvp(argv[0], (char **)argv); 1546 1547 if (exec_error) { 1548 union sigval val; 1549 1550 val.sival_int = errno; 1551 if (sigqueue(getppid(), SIGUSR1, val)) 1552 perror(argv[0]); 1553 } else 1554 perror(argv[0]); 1555 exit(-1); 1556 } 1557 1558 if (exec_error) { 1559 struct sigaction act = { 1560 .sa_flags = SA_SIGINFO, 1561 .sa_sigaction = exec_error, 1562 }; 1563 sigaction(SIGUSR1, &act, NULL); 1564 } 1565 1566 if (target__none(target)) { 1567 if (evlist->core.threads == NULL) { 1568 fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n", 1569 __func__, __LINE__); 1570 goto out_close_pipes; 1571 } 1572 perf_thread_map__set_pid(evlist->core.threads, 0, evlist->workload.pid); 1573 } 1574 1575 close(child_ready_pipe[1]); 1576 close(go_pipe[0]); 1577 /* 1578 * wait for child to settle 1579 */ 1580 if (read(child_ready_pipe[0], &bf, 1) == -1) { 1581 perror("unable to read pipe"); 1582 goto out_close_pipes; 1583 } 1584 1585 fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC); 1586 evlist->workload.cork_fd = go_pipe[1]; 1587 close(child_ready_pipe[0]); 1588 return 0; 1589 1590 out_close_pipes: 1591 close(go_pipe[0]); 1592 close(go_pipe[1]); 1593 out_close_ready_pipe: 1594 close(child_ready_pipe[0]); 1595 close(child_ready_pipe[1]); 1596 return -1; 1597 } 1598 1599 int evlist__start_workload(struct evlist *evlist) 1600 { 1601 if (evlist->workload.cork_fd >= 0) { 1602 char bf = 0; 1603 int ret; 1604 /* 1605 * Remove the cork, let it rip! 1606 */ 1607 ret = write(evlist->workload.cork_fd, &bf, 1); 1608 if (ret < 0) 1609 perror("unable to write to pipe"); 1610 1611 close(evlist->workload.cork_fd); 1612 evlist->workload.cork_fd = -1; 1613 return ret; 1614 } 1615 1616 return 0; 1617 } 1618 1619 void evlist__cancel_workload(struct evlist *evlist) 1620 { 1621 int status; 1622 1623 if (evlist->workload.cork_fd >= 0) { 1624 close(evlist->workload.cork_fd); 1625 evlist->workload.cork_fd = -1; 1626 waitpid(evlist->workload.pid, &status, WNOHANG); 1627 } 1628 } 1629 1630 int evlist__parse_sample(struct evlist *evlist, union perf_event *event, struct perf_sample *sample) 1631 { 1632 struct evsel *evsel = evlist__event2evsel(evlist, event); 1633 int ret; 1634 1635 if (!evsel) { 1636 /* Ensure the sample is okay for perf_sample__exit. */ 1637 perf_sample__init(sample, /*all=*/false); 1638 return -EFAULT; 1639 } 1640 ret = evsel__parse_sample(evsel, event, sample); 1641 if (ret) 1642 return ret; 1643 if (perf_guest && sample->id) { 1644 struct perf_sample_id *sid = evlist__id2sid(evlist, sample->id); 1645 1646 if (sid) { 1647 sample->machine_pid = sid->machine_pid; 1648 sample->vcpu = sid->vcpu.cpu; 1649 } 1650 } 1651 return 0; 1652 } 1653 1654 int evlist__parse_sample_timestamp(struct evlist *evlist, union perf_event *event, u64 *timestamp) 1655 { 1656 struct evsel *evsel = evlist__event2evsel(evlist, event); 1657 1658 if (!evsel) 1659 return -EFAULT; 1660 return evsel__parse_sample_timestamp(evsel, event, timestamp); 1661 } 1662 1663 int evlist__strerror_open(struct evlist *evlist, int err, char *buf, size_t size) 1664 { 1665 int printed, value; 1666 1667 switch (err) { 1668 case EACCES: 1669 case EPERM: 1670 errno = err; 1671 printed = scnprintf(buf, size, 1672 "Error:\t%m.\n" 1673 "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting."); 1674 1675 value = perf_event_paranoid(); 1676 1677 printed += scnprintf(buf + printed, size - printed, "\nHint:\t"); 1678 1679 if (value >= 2) { 1680 printed += scnprintf(buf + printed, size - printed, 1681 "For your workloads it needs to be <= 1\nHint:\t"); 1682 } 1683 printed += scnprintf(buf + printed, size - printed, 1684 "For system wide tracing it needs to be set to -1.\n"); 1685 1686 printed += scnprintf(buf + printed, size - printed, 1687 "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n" 1688 "Hint:\tThe current value is %d.", value); 1689 break; 1690 case EINVAL: { 1691 struct evsel *first = evlist__first(evlist); 1692 int max_freq; 1693 1694 if (sysctl__read_int("kernel/perf_event_max_sample_rate", &max_freq) < 0) 1695 goto out_default; 1696 1697 if (first->core.attr.sample_freq < (u64)max_freq) 1698 goto out_default; 1699 1700 errno = err; 1701 printed = scnprintf(buf, size, 1702 "Error:\t%m.\n" 1703 "Hint:\tCheck /proc/sys/kernel/perf_event_max_sample_rate.\n" 1704 "Hint:\tThe current value is %d and %" PRIu64 " is being requested.", 1705 max_freq, first->core.attr.sample_freq); 1706 break; 1707 } 1708 default: 1709 out_default: 1710 errno = err; 1711 scnprintf(buf, size, "%m"); 1712 break; 1713 } 1714 1715 return 0; 1716 } 1717 1718 int evlist__strerror_mmap(struct evlist *evlist, int err, char *buf, size_t size) 1719 { 1720 int pages_attempted = evlist->core.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 errno = err; 1726 printed += scnprintf(buf + printed, size - printed, 1727 "Error:\t%m.\n" 1728 "Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n" 1729 "Hint:\tTried using %zd kB.\n", 1730 pages_max_per_user, pages_attempted); 1731 1732 if (pages_attempted >= pages_max_per_user) { 1733 printed += scnprintf(buf + printed, size - printed, 1734 "Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n", 1735 pages_max_per_user + pages_attempted); 1736 } 1737 1738 printed += scnprintf(buf + printed, size - printed, 1739 "Hint:\tTry using a smaller -m/--mmap-pages value."); 1740 break; 1741 default: 1742 errno = err; 1743 scnprintf(buf, size, "%m"); 1744 break; 1745 } 1746 1747 return 0; 1748 } 1749 1750 void evlist__to_front(struct evlist *evlist, struct evsel *move_evsel) 1751 { 1752 struct evsel *evsel, *n; 1753 LIST_HEAD(move); 1754 1755 if (move_evsel == evlist__first(evlist)) 1756 return; 1757 1758 evlist__for_each_entry_safe(evlist, n, evsel) { 1759 if (evsel__leader(evsel) == evsel__leader(move_evsel)) 1760 list_move_tail(&evsel->core.node, &move); 1761 } 1762 1763 list_splice(&move, &evlist->core.entries); 1764 } 1765 1766 struct evsel *evlist__get_tracking_event(struct evlist *evlist) 1767 { 1768 struct evsel *evsel; 1769 1770 evlist__for_each_entry(evlist, evsel) { 1771 if (evsel->tracking) 1772 return evsel; 1773 } 1774 1775 return evlist__first(evlist); 1776 } 1777 1778 void evlist__set_tracking_event(struct evlist *evlist, struct evsel *tracking_evsel) 1779 { 1780 struct evsel *evsel; 1781 1782 if (tracking_evsel->tracking) 1783 return; 1784 1785 evlist__for_each_entry(evlist, evsel) { 1786 if (evsel != tracking_evsel) 1787 evsel->tracking = false; 1788 } 1789 1790 tracking_evsel->tracking = true; 1791 } 1792 1793 struct evsel *evlist__findnew_tracking_event(struct evlist *evlist, bool system_wide) 1794 { 1795 struct evsel *evsel; 1796 1797 evsel = evlist__get_tracking_event(evlist); 1798 if (!evsel__is_dummy_event(evsel)) { 1799 evsel = evlist__add_aux_dummy(evlist, system_wide); 1800 if (!evsel) 1801 return NULL; 1802 1803 evlist__set_tracking_event(evlist, evsel); 1804 } else if (system_wide) { 1805 perf_evlist__go_system_wide(&evlist->core, &evsel->core); 1806 } 1807 1808 return evsel; 1809 } 1810 1811 struct evsel *evlist__find_evsel_by_str(struct evlist *evlist, const char *str) 1812 { 1813 struct evsel *evsel; 1814 1815 evlist__for_each_entry(evlist, evsel) { 1816 if (!evsel->name) 1817 continue; 1818 if (evsel__name_is(evsel, str)) 1819 return evsel; 1820 } 1821 1822 return NULL; 1823 } 1824 1825 void evlist__toggle_bkw_mmap(struct evlist *evlist, enum bkw_mmap_state state) 1826 { 1827 enum bkw_mmap_state old_state = evlist->bkw_mmap_state; 1828 enum action { 1829 NONE, 1830 PAUSE, 1831 RESUME, 1832 } action = NONE; 1833 1834 if (!evlist->overwrite_mmap) 1835 return; 1836 1837 switch (old_state) { 1838 case BKW_MMAP_NOTREADY: { 1839 if (state != BKW_MMAP_RUNNING) 1840 goto state_err; 1841 break; 1842 } 1843 case BKW_MMAP_RUNNING: { 1844 if (state != BKW_MMAP_DATA_PENDING) 1845 goto state_err; 1846 action = PAUSE; 1847 break; 1848 } 1849 case BKW_MMAP_DATA_PENDING: { 1850 if (state != BKW_MMAP_EMPTY) 1851 goto state_err; 1852 break; 1853 } 1854 case BKW_MMAP_EMPTY: { 1855 if (state != BKW_MMAP_RUNNING) 1856 goto state_err; 1857 action = RESUME; 1858 break; 1859 } 1860 default: 1861 WARN_ONCE(1, "Shouldn't get there\n"); 1862 } 1863 1864 evlist->bkw_mmap_state = state; 1865 1866 switch (action) { 1867 case PAUSE: 1868 evlist__pause(evlist); 1869 break; 1870 case RESUME: 1871 evlist__resume(evlist); 1872 break; 1873 case NONE: 1874 default: 1875 break; 1876 } 1877 1878 state_err: 1879 return; 1880 } 1881 1882 bool evlist__exclude_kernel(struct evlist *evlist) 1883 { 1884 struct evsel *evsel; 1885 1886 evlist__for_each_entry(evlist, evsel) { 1887 if (!evsel->core.attr.exclude_kernel) 1888 return false; 1889 } 1890 1891 return true; 1892 } 1893 1894 /* 1895 * Events in data file are not collect in groups, but we still want 1896 * the group display. Set the artificial group and set the leader's 1897 * forced_leader flag to notify the display code. 1898 */ 1899 void evlist__force_leader(struct evlist *evlist) 1900 { 1901 if (evlist__nr_groups(evlist) == 0) { 1902 struct evsel *leader = evlist__first(evlist); 1903 1904 evlist__set_leader(evlist); 1905 leader->forced_leader = true; 1906 } 1907 } 1908 1909 struct evsel *evlist__reset_weak_group(struct evlist *evsel_list, struct evsel *evsel, bool close) 1910 { 1911 struct evsel *c2, *leader; 1912 bool is_open = true; 1913 1914 leader = evsel__leader(evsel); 1915 1916 pr_debug("Weak group for %s/%d failed\n", 1917 leader->name, leader->core.nr_members); 1918 1919 /* 1920 * for_each_group_member doesn't work here because it doesn't 1921 * include the first entry. 1922 */ 1923 evlist__for_each_entry(evsel_list, c2) { 1924 if (c2 == evsel) 1925 is_open = false; 1926 if (evsel__has_leader(c2, leader)) { 1927 if (is_open && close) 1928 perf_evsel__close(&c2->core); 1929 /* 1930 * We want to close all members of the group and reopen 1931 * them. Some events, like Intel topdown, require being 1932 * in a group and so keep these in the group. 1933 */ 1934 evsel__remove_from_group(c2, leader); 1935 1936 /* 1937 * Set this for all former members of the group 1938 * to indicate they get reopened. 1939 */ 1940 c2->reset_group = true; 1941 } 1942 } 1943 /* Reset the leader count if all entries were removed. */ 1944 if (leader->core.nr_members == 1) 1945 leader->core.nr_members = 0; 1946 return leader; 1947 } 1948 1949 static int evlist__parse_control_fifo(const char *str, int *ctl_fd, int *ctl_fd_ack, bool *ctl_fd_close) 1950 { 1951 char *s, *p; 1952 int ret = 0, fd; 1953 1954 if (strncmp(str, "fifo:", 5)) 1955 return -EINVAL; 1956 1957 str += 5; 1958 if (!*str || *str == ',') 1959 return -EINVAL; 1960 1961 s = strdup(str); 1962 if (!s) 1963 return -ENOMEM; 1964 1965 p = strchr(s, ','); 1966 if (p) 1967 *p = '\0'; 1968 1969 /* 1970 * O_RDWR avoids POLLHUPs which is necessary to allow the other 1971 * end of a FIFO to be repeatedly opened and closed. 1972 */ 1973 fd = open(s, O_RDWR | O_NONBLOCK | O_CLOEXEC); 1974 if (fd < 0) { 1975 ret = -errno; 1976 pr_err("Failed to open '%s': %m\n", s); 1977 goto out_free; 1978 } 1979 *ctl_fd = fd; 1980 *ctl_fd_close = true; 1981 1982 if (p && *++p) { 1983 /* O_RDWR | O_NONBLOCK means the other end need not be open */ 1984 fd = open(p, O_RDWR | O_NONBLOCK | O_CLOEXEC); 1985 if (fd < 0) { 1986 pr_err("Failed to open '%s': %m\n", p); 1987 ret = -errno; 1988 goto out_free; 1989 } 1990 *ctl_fd_ack = fd; 1991 } 1992 1993 out_free: 1994 free(s); 1995 return ret; 1996 } 1997 1998 int evlist__parse_control(const char *str, int *ctl_fd, int *ctl_fd_ack, bool *ctl_fd_close) 1999 { 2000 const char *comma = NULL; 2001 char *endptr = NULL; 2002 2003 *ctl_fd_close = false; 2004 2005 if (strncmp(str, "fd:", 3)) 2006 return evlist__parse_control_fifo(str, ctl_fd, ctl_fd_ack, ctl_fd_close); 2007 2008 *ctl_fd = strtoul(&str[3], &endptr, 0); 2009 if (endptr == &str[3]) 2010 return -EINVAL; 2011 2012 comma = strchr(str, ','); 2013 if (comma) { 2014 if (endptr != comma) 2015 return -EINVAL; 2016 2017 *ctl_fd_ack = strtoul(comma + 1, &endptr, 0); 2018 if (endptr == comma + 1 || *endptr != '\0') 2019 return -EINVAL; 2020 } 2021 2022 return 0; 2023 } 2024 2025 void evlist__close_control(int ctl_fd, int ctl_fd_ack, bool *ctl_fd_close) 2026 { 2027 if (*ctl_fd_close) { 2028 *ctl_fd_close = false; 2029 close(ctl_fd); 2030 if (ctl_fd_ack >= 0) 2031 close(ctl_fd_ack); 2032 } 2033 } 2034 2035 int evlist__initialize_ctlfd(struct evlist *evlist, int fd, int ack) 2036 { 2037 if (fd == -1) { 2038 pr_debug("Control descriptor is not initialized\n"); 2039 return 0; 2040 } 2041 2042 evlist->ctl_fd.pos = perf_evlist__add_pollfd(&evlist->core, fd, NULL, POLLIN, 2043 fdarray_flag__nonfilterable | 2044 fdarray_flag__non_perf_event); 2045 if (evlist->ctl_fd.pos < 0) { 2046 evlist->ctl_fd.pos = -1; 2047 pr_err("Failed to add ctl fd entry: %m\n"); 2048 return -1; 2049 } 2050 2051 evlist->ctl_fd.fd = fd; 2052 evlist->ctl_fd.ack = ack; 2053 2054 return 0; 2055 } 2056 2057 bool evlist__ctlfd_initialized(struct evlist *evlist) 2058 { 2059 return evlist->ctl_fd.pos >= 0; 2060 } 2061 2062 int evlist__finalize_ctlfd(struct evlist *evlist) 2063 { 2064 struct pollfd *entries = evlist->core.pollfd.entries; 2065 2066 if (!evlist__ctlfd_initialized(evlist)) 2067 return 0; 2068 2069 entries[evlist->ctl_fd.pos].fd = -1; 2070 entries[evlist->ctl_fd.pos].events = 0; 2071 entries[evlist->ctl_fd.pos].revents = 0; 2072 2073 evlist->ctl_fd.pos = -1; 2074 evlist->ctl_fd.ack = -1; 2075 evlist->ctl_fd.fd = -1; 2076 2077 return 0; 2078 } 2079 2080 static int evlist__ctlfd_recv(struct evlist *evlist, enum evlist_ctl_cmd *cmd, 2081 char *cmd_data, size_t data_size) 2082 { 2083 int err; 2084 char c; 2085 size_t bytes_read = 0; 2086 2087 *cmd = EVLIST_CTL_CMD_UNSUPPORTED; 2088 memset(cmd_data, 0, data_size); 2089 data_size--; 2090 2091 do { 2092 err = read(evlist->ctl_fd.fd, &c, 1); 2093 if (err > 0) { 2094 if (c == '\n' || c == '\0') 2095 break; 2096 cmd_data[bytes_read++] = c; 2097 if (bytes_read == data_size) 2098 break; 2099 continue; 2100 } else if (err == -1) { 2101 if (errno == EINTR) 2102 continue; 2103 if (errno == EAGAIN || errno == EWOULDBLOCK) 2104 err = 0; 2105 else 2106 pr_err("Failed to read from ctlfd %d: %m\n", evlist->ctl_fd.fd); 2107 } 2108 break; 2109 } while (1); 2110 2111 pr_debug("Message from ctl_fd: \"%s%s\"\n", cmd_data, 2112 bytes_read == data_size ? "" : c == '\n' ? "\\n" : "\\0"); 2113 2114 if (bytes_read > 0) { 2115 if (!strncmp(cmd_data, EVLIST_CTL_CMD_ENABLE_TAG, 2116 (sizeof(EVLIST_CTL_CMD_ENABLE_TAG)-1))) { 2117 *cmd = EVLIST_CTL_CMD_ENABLE; 2118 } else if (!strncmp(cmd_data, EVLIST_CTL_CMD_DISABLE_TAG, 2119 (sizeof(EVLIST_CTL_CMD_DISABLE_TAG)-1))) { 2120 *cmd = EVLIST_CTL_CMD_DISABLE; 2121 } else if (!strncmp(cmd_data, EVLIST_CTL_CMD_SNAPSHOT_TAG, 2122 (sizeof(EVLIST_CTL_CMD_SNAPSHOT_TAG)-1))) { 2123 *cmd = EVLIST_CTL_CMD_SNAPSHOT; 2124 pr_debug("is snapshot\n"); 2125 } else if (!strncmp(cmd_data, EVLIST_CTL_CMD_EVLIST_TAG, 2126 (sizeof(EVLIST_CTL_CMD_EVLIST_TAG)-1))) { 2127 *cmd = EVLIST_CTL_CMD_EVLIST; 2128 } else if (!strncmp(cmd_data, EVLIST_CTL_CMD_STOP_TAG, 2129 (sizeof(EVLIST_CTL_CMD_STOP_TAG)-1))) { 2130 *cmd = EVLIST_CTL_CMD_STOP; 2131 } else if (!strncmp(cmd_data, EVLIST_CTL_CMD_PING_TAG, 2132 (sizeof(EVLIST_CTL_CMD_PING_TAG)-1))) { 2133 *cmd = EVLIST_CTL_CMD_PING; 2134 } 2135 } 2136 2137 return bytes_read ? (int)bytes_read : err; 2138 } 2139 2140 int evlist__ctlfd_ack(struct evlist *evlist) 2141 { 2142 int err; 2143 2144 if (evlist->ctl_fd.ack == -1) 2145 return 0; 2146 2147 err = write(evlist->ctl_fd.ack, EVLIST_CTL_CMD_ACK_TAG, 2148 sizeof(EVLIST_CTL_CMD_ACK_TAG)); 2149 if (err == -1) 2150 pr_err("failed to write to ctl_ack_fd %d: %m\n", evlist->ctl_fd.ack); 2151 2152 return err; 2153 } 2154 2155 static int get_cmd_arg(char *cmd_data, size_t cmd_size, char **arg) 2156 { 2157 char *data = cmd_data + cmd_size; 2158 2159 /* no argument */ 2160 if (!*data) 2161 return 0; 2162 2163 /* there's argument */ 2164 if (*data == ' ') { 2165 *arg = data + 1; 2166 return 1; 2167 } 2168 2169 /* malformed */ 2170 return -1; 2171 } 2172 2173 static int evlist__ctlfd_enable(struct evlist *evlist, char *cmd_data, bool enable) 2174 { 2175 struct evsel *evsel; 2176 char *name; 2177 int err; 2178 2179 err = get_cmd_arg(cmd_data, 2180 enable ? sizeof(EVLIST_CTL_CMD_ENABLE_TAG) - 1 : 2181 sizeof(EVLIST_CTL_CMD_DISABLE_TAG) - 1, 2182 &name); 2183 if (err < 0) { 2184 pr_info("failed: wrong command\n"); 2185 return -1; 2186 } 2187 2188 if (err) { 2189 evsel = evlist__find_evsel_by_str(evlist, name); 2190 if (evsel) { 2191 if (enable) 2192 evlist__enable_evsel(evlist, name); 2193 else 2194 evlist__disable_evsel(evlist, name); 2195 pr_info("Event %s %s\n", evsel->name, 2196 enable ? "enabled" : "disabled"); 2197 } else { 2198 pr_info("failed: can't find '%s' event\n", name); 2199 } 2200 } else { 2201 if (enable) { 2202 evlist__enable(evlist); 2203 pr_info(EVLIST_ENABLED_MSG); 2204 } else { 2205 evlist__disable(evlist); 2206 pr_info(EVLIST_DISABLED_MSG); 2207 } 2208 } 2209 2210 return 0; 2211 } 2212 2213 static int evlist__ctlfd_list(struct evlist *evlist, char *cmd_data) 2214 { 2215 struct perf_attr_details details = { .verbose = false, }; 2216 struct evsel *evsel; 2217 char *arg; 2218 int err; 2219 2220 err = get_cmd_arg(cmd_data, 2221 sizeof(EVLIST_CTL_CMD_EVLIST_TAG) - 1, 2222 &arg); 2223 if (err < 0) { 2224 pr_info("failed: wrong command\n"); 2225 return -1; 2226 } 2227 2228 if (err) { 2229 if (!strcmp(arg, "-v")) { 2230 details.verbose = true; 2231 } else if (!strcmp(arg, "-g")) { 2232 details.event_group = true; 2233 } else if (!strcmp(arg, "-F")) { 2234 details.freq = true; 2235 } else { 2236 pr_info("failed: wrong command\n"); 2237 return -1; 2238 } 2239 } 2240 2241 evlist__for_each_entry(evlist, evsel) 2242 evsel__fprintf(evsel, &details, stderr); 2243 2244 return 0; 2245 } 2246 2247 int evlist__ctlfd_process(struct evlist *evlist, enum evlist_ctl_cmd *cmd) 2248 { 2249 int err = 0; 2250 char cmd_data[EVLIST_CTL_CMD_MAX_LEN]; 2251 int ctlfd_pos = evlist->ctl_fd.pos; 2252 struct pollfd *entries = evlist->core.pollfd.entries; 2253 2254 if (!evlist__ctlfd_initialized(evlist) || !entries[ctlfd_pos].revents) 2255 return 0; 2256 2257 if (entries[ctlfd_pos].revents & POLLIN) { 2258 err = evlist__ctlfd_recv(evlist, cmd, cmd_data, 2259 EVLIST_CTL_CMD_MAX_LEN); 2260 if (err > 0) { 2261 switch (*cmd) { 2262 case EVLIST_CTL_CMD_ENABLE: 2263 case EVLIST_CTL_CMD_DISABLE: 2264 err = evlist__ctlfd_enable(evlist, cmd_data, 2265 *cmd == EVLIST_CTL_CMD_ENABLE); 2266 break; 2267 case EVLIST_CTL_CMD_EVLIST: 2268 err = evlist__ctlfd_list(evlist, cmd_data); 2269 break; 2270 case EVLIST_CTL_CMD_SNAPSHOT: 2271 case EVLIST_CTL_CMD_STOP: 2272 case EVLIST_CTL_CMD_PING: 2273 break; 2274 case EVLIST_CTL_CMD_ACK: 2275 case EVLIST_CTL_CMD_UNSUPPORTED: 2276 default: 2277 pr_debug("ctlfd: unsupported %d\n", *cmd); 2278 break; 2279 } 2280 if (!(*cmd == EVLIST_CTL_CMD_ACK || *cmd == EVLIST_CTL_CMD_UNSUPPORTED || 2281 *cmd == EVLIST_CTL_CMD_SNAPSHOT)) 2282 evlist__ctlfd_ack(evlist); 2283 } 2284 } 2285 2286 if (entries[ctlfd_pos].revents & (POLLHUP | POLLERR)) 2287 evlist__finalize_ctlfd(evlist); 2288 else 2289 entries[ctlfd_pos].revents = 0; 2290 2291 return err; 2292 } 2293 2294 /** 2295 * struct event_enable_time - perf record -D/--delay single time range. 2296 * @start: start of time range to enable events in milliseconds 2297 * @end: end of time range to enable events in milliseconds 2298 * 2299 * N.B. this structure is also accessed as an array of int. 2300 */ 2301 struct event_enable_time { 2302 int start; 2303 int end; 2304 }; 2305 2306 static int parse_event_enable_time(const char *str, struct event_enable_time *range, bool first) 2307 { 2308 const char *fmt = first ? "%u - %u %n" : " , %u - %u %n"; 2309 int ret, start, end, n; 2310 2311 ret = sscanf(str, fmt, &start, &end, &n); 2312 if (ret != 2 || end <= start) 2313 return -EINVAL; 2314 if (range) { 2315 range->start = start; 2316 range->end = end; 2317 } 2318 return n; 2319 } 2320 2321 static ssize_t parse_event_enable_times(const char *str, struct event_enable_time *range) 2322 { 2323 int incr = !!range; 2324 bool first = true; 2325 ssize_t ret, cnt; 2326 2327 for (cnt = 0; *str; cnt++) { 2328 ret = parse_event_enable_time(str, range, first); 2329 if (ret < 0) 2330 return ret; 2331 /* Check no overlap */ 2332 if (!first && range && range->start <= range[-1].end) 2333 return -EINVAL; 2334 str += ret; 2335 range += incr; 2336 first = false; 2337 } 2338 return cnt; 2339 } 2340 2341 /** 2342 * struct event_enable_timer - control structure for perf record -D/--delay. 2343 * @evlist: event list 2344 * @times: time ranges that events are enabled (N.B. this is also accessed as an 2345 * array of int) 2346 * @times_cnt: number of time ranges 2347 * @timerfd: timer file descriptor 2348 * @pollfd_pos: position in @evlist array of file descriptors to poll (fdarray) 2349 * @times_step: current position in (int *)@times)[], 2350 * refer event_enable_timer__process() 2351 * 2352 * Note, this structure is only used when there are time ranges, not when there 2353 * is only an initial delay. 2354 */ 2355 struct event_enable_timer { 2356 struct evlist *evlist; 2357 struct event_enable_time *times; 2358 size_t times_cnt; 2359 int timerfd; 2360 int pollfd_pos; 2361 size_t times_step; 2362 }; 2363 2364 static int str_to_delay(const char *str) 2365 { 2366 char *endptr; 2367 long d; 2368 2369 d = strtol(str, &endptr, 10); 2370 if (*endptr || d > INT_MAX || d < -1) 2371 return 0; 2372 return d; 2373 } 2374 2375 int evlist__parse_event_enable_time(struct evlist *evlist, struct record_opts *opts, 2376 const char *str, int unset) 2377 { 2378 enum fdarray_flags flags = fdarray_flag__nonfilterable | fdarray_flag__non_perf_event; 2379 struct event_enable_timer *eet; 2380 ssize_t times_cnt; 2381 ssize_t ret; 2382 int err; 2383 2384 if (unset) 2385 return 0; 2386 2387 opts->target.initial_delay = str_to_delay(str); 2388 if (opts->target.initial_delay) 2389 return 0; 2390 2391 ret = parse_event_enable_times(str, NULL); 2392 if (ret < 0) 2393 return ret; 2394 2395 times_cnt = ret; 2396 if (times_cnt == 0) 2397 return -EINVAL; 2398 2399 eet = zalloc(sizeof(*eet)); 2400 if (!eet) 2401 return -ENOMEM; 2402 2403 eet->times = calloc(times_cnt, sizeof(*eet->times)); 2404 if (!eet->times) { 2405 err = -ENOMEM; 2406 goto free_eet; 2407 } 2408 2409 if (parse_event_enable_times(str, eet->times) != times_cnt) { 2410 err = -EINVAL; 2411 goto free_eet_times; 2412 } 2413 2414 eet->times_cnt = times_cnt; 2415 2416 eet->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC); 2417 if (eet->timerfd == -1) { 2418 err = -errno; 2419 pr_err("timerfd_create failed: %m\n"); 2420 goto free_eet_times; 2421 } 2422 2423 eet->pollfd_pos = perf_evlist__add_pollfd(&evlist->core, eet->timerfd, NULL, POLLIN, flags); 2424 if (eet->pollfd_pos < 0) { 2425 err = eet->pollfd_pos; 2426 goto close_timerfd; 2427 } 2428 2429 eet->evlist = evlist; 2430 evlist->eet = eet; 2431 opts->target.initial_delay = eet->times[0].start; 2432 2433 return 0; 2434 2435 close_timerfd: 2436 close(eet->timerfd); 2437 free_eet_times: 2438 zfree(&eet->times); 2439 free_eet: 2440 free(eet); 2441 return err; 2442 } 2443 2444 static int event_enable_timer__set_timer(struct event_enable_timer *eet, int ms) 2445 { 2446 struct itimerspec its = { 2447 .it_value.tv_sec = ms / MSEC_PER_SEC, 2448 .it_value.tv_nsec = (ms % MSEC_PER_SEC) * NSEC_PER_MSEC, 2449 }; 2450 int err = 0; 2451 2452 if (timerfd_settime(eet->timerfd, 0, &its, NULL) < 0) { 2453 err = -errno; 2454 pr_err("timerfd_settime failed: %m\n"); 2455 } 2456 return err; 2457 } 2458 2459 int event_enable_timer__start(struct event_enable_timer *eet) 2460 { 2461 int ms; 2462 2463 if (!eet) 2464 return 0; 2465 2466 ms = eet->times[0].end - eet->times[0].start; 2467 eet->times_step = 1; 2468 2469 return event_enable_timer__set_timer(eet, ms); 2470 } 2471 2472 int event_enable_timer__process(struct event_enable_timer *eet) 2473 { 2474 struct pollfd *entries; 2475 short revents; 2476 2477 if (!eet) 2478 return 0; 2479 2480 entries = eet->evlist->core.pollfd.entries; 2481 revents = entries[eet->pollfd_pos].revents; 2482 entries[eet->pollfd_pos].revents = 0; 2483 2484 if (revents & POLLIN) { 2485 size_t step = eet->times_step; 2486 size_t pos = step / 2; 2487 2488 if (step & 1) { 2489 evlist__disable_non_dummy(eet->evlist); 2490 pr_info(EVLIST_DISABLED_MSG); 2491 if (pos >= eet->times_cnt - 1) { 2492 /* Disarm timer */ 2493 event_enable_timer__set_timer(eet, 0); 2494 return 1; /* Stop */ 2495 } 2496 } else { 2497 evlist__enable_non_dummy(eet->evlist); 2498 pr_info(EVLIST_ENABLED_MSG); 2499 } 2500 2501 step += 1; 2502 pos = step / 2; 2503 2504 if (pos < eet->times_cnt) { 2505 int *times = (int *)eet->times; /* Accessing 'times' as array of int */ 2506 int ms = times[step] - times[step - 1]; 2507 2508 eet->times_step = step; 2509 return event_enable_timer__set_timer(eet, ms); 2510 } 2511 } 2512 2513 return 0; 2514 } 2515 2516 void event_enable_timer__exit(struct event_enable_timer **ep) 2517 { 2518 if (!ep || !*ep) 2519 return; 2520 zfree(&(*ep)->times); 2521 zfree(ep); 2522 } 2523 2524 struct evsel *evlist__find_evsel(struct evlist *evlist, int idx) 2525 { 2526 struct evsel *evsel; 2527 2528 evlist__for_each_entry(evlist, evsel) { 2529 if (evsel->core.idx == idx) 2530 return evsel; 2531 } 2532 return NULL; 2533 } 2534 2535 void evlist__format_evsels(struct evlist *evlist, struct strbuf *sb, size_t max_length) 2536 { 2537 struct evsel *evsel, *leader = NULL; 2538 bool first = true; 2539 2540 evlist__for_each_entry(evlist, evsel) { 2541 struct evsel *new_leader = evsel__leader(evsel); 2542 2543 if (evsel__is_dummy_event(evsel)) 2544 continue; 2545 2546 if (leader != new_leader && leader && leader->core.nr_members > 1) 2547 strbuf_addch(sb, '}'); 2548 2549 if (!first) 2550 strbuf_addch(sb, ','); 2551 2552 if (sb->len > max_length) { 2553 strbuf_addstr(sb, "..."); 2554 return; 2555 } 2556 if (leader != new_leader && new_leader->core.nr_members > 1) 2557 strbuf_addch(sb, '{'); 2558 2559 strbuf_addstr(sb, evsel__name(evsel)); 2560 first = false; 2561 leader = new_leader; 2562 } 2563 if (leader && leader->core.nr_members > 1) 2564 strbuf_addch(sb, '}'); 2565 } 2566 2567 void evlist__check_mem_load_aux(struct evlist *evlist) 2568 { 2569 struct evsel *leader, *evsel, *pos; 2570 2571 /* 2572 * For some platforms, the 'mem-loads' event is required to use 2573 * together with 'mem-loads-aux' within a group and 'mem-loads-aux' 2574 * must be the group leader. Now we disable this group before reporting 2575 * because 'mem-loads-aux' is just an auxiliary event. It doesn't carry 2576 * any valid memory load information. 2577 */ 2578 evlist__for_each_entry(evlist, evsel) { 2579 leader = evsel__leader(evsel); 2580 if (leader == evsel) 2581 continue; 2582 2583 if (leader->name && strstr(leader->name, "mem-loads-aux")) { 2584 for_each_group_evsel(pos, leader) { 2585 evsel__set_leader(pos, pos); 2586 pos->core.nr_members = 0; 2587 } 2588 } 2589 } 2590 } 2591 2592 /** 2593 * evlist__warn_user_requested_cpus() - Check each evsel against requested CPUs 2594 * and warn if the user CPU list is inapplicable for the event's PMU's 2595 * CPUs. Not core PMUs list a CPU in sysfs, but this may be overwritten by a 2596 * user requested CPU and so any online CPU is applicable. Core PMUs handle 2597 * events on the CPUs in their list and otherwise the event isn't supported. 2598 * @evlist: The list of events being checked. 2599 * @cpu_list: The user provided list of CPUs. 2600 */ 2601 void evlist__warn_user_requested_cpus(struct evlist *evlist, const char *cpu_list) 2602 { 2603 struct perf_cpu_map *user_requested_cpus; 2604 struct evsel *pos; 2605 2606 if (!cpu_list) 2607 return; 2608 2609 user_requested_cpus = perf_cpu_map__new(cpu_list); 2610 if (!user_requested_cpus) 2611 return; 2612 2613 evlist__for_each_entry(evlist, pos) { 2614 evsel__warn_user_requested_cpus(pos, user_requested_cpus); 2615 } 2616 perf_cpu_map__put(user_requested_cpus); 2617 } 2618 2619 /* Should uniquify be disabled for the evlist? */ 2620 static bool evlist__disable_uniquify(const struct evlist *evlist) 2621 { 2622 struct evsel *counter; 2623 struct perf_pmu *last_pmu = NULL; 2624 bool first = true; 2625 2626 evlist__for_each_entry(evlist, counter) { 2627 /* If PMUs vary then uniquify can be useful. */ 2628 if (!first && counter->pmu != last_pmu) 2629 return false; 2630 first = false; 2631 if (counter->pmu) { 2632 /* Allow uniquify for uncore PMUs. */ 2633 if (!counter->pmu->is_core) 2634 return false; 2635 /* Keep hybrid event names uniquified for clarity. */ 2636 if (perf_pmus__num_core_pmus() > 1) 2637 return false; 2638 } 2639 last_pmu = counter->pmu; 2640 } 2641 return true; 2642 } 2643 2644 static bool evlist__set_needs_uniquify(struct evlist *evlist, const struct perf_stat_config *config) 2645 { 2646 struct evsel *counter; 2647 bool needs_uniquify = false; 2648 2649 if (evlist__disable_uniquify(evlist)) { 2650 evlist__for_each_entry(evlist, counter) 2651 counter->uniquified_name = true; 2652 return false; 2653 } 2654 2655 evlist__for_each_entry(evlist, counter) { 2656 if (evsel__set_needs_uniquify(counter, config)) 2657 needs_uniquify = true; 2658 } 2659 return needs_uniquify; 2660 } 2661 2662 void evlist__uniquify_evsel_names(struct evlist *evlist, const struct perf_stat_config *config) 2663 { 2664 if (evlist__set_needs_uniquify(evlist, config)) { 2665 struct evsel *pos; 2666 2667 evlist__for_each_entry(evlist, pos) 2668 evsel__uniquify_counter(pos); 2669 } 2670 } 2671 2672 bool evlist__has_bpf_output(struct evlist *evlist) 2673 { 2674 struct evsel *evsel; 2675 2676 evlist__for_each_entry(evlist, evsel) { 2677 if (evsel__is_bpf_output(evsel)) 2678 return true; 2679 } 2680 2681 return false; 2682 } 2683 2684 bool evlist__needs_bpf_sb_event(struct evlist *evlist) 2685 { 2686 struct evsel *evsel; 2687 2688 evlist__for_each_entry(evlist, evsel) { 2689 if (evsel__is_dummy_event(evsel)) 2690 continue; 2691 if (!evsel->core.attr.exclude_kernel) 2692 return true; 2693 } 2694 2695 return false; 2696 } 2697