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