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