1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * builtin-record.c 4 * 5 * Builtin record command: Record the profile of a workload 6 * (or a CPU, or a PID) into the perf.data output file - for 7 * later analysis via perf report. 8 */ 9 #include "builtin.h" 10 11 #include "perf.h" 12 13 #include "util/build-id.h" 14 #include "util/util.h" 15 #include <subcmd/parse-options.h> 16 #include "util/parse-events.h" 17 #include "util/config.h" 18 19 #include "util/callchain.h" 20 #include "util/cgroup.h" 21 #include "util/header.h" 22 #include "util/event.h" 23 #include "util/evlist.h" 24 #include "util/evsel.h" 25 #include "util/debug.h" 26 #include "util/drv_configs.h" 27 #include "util/session.h" 28 #include "util/tool.h" 29 #include "util/symbol.h" 30 #include "util/cpumap.h" 31 #include "util/thread_map.h" 32 #include "util/data.h" 33 #include "util/perf_regs.h" 34 #include "util/auxtrace.h" 35 #include "util/tsc.h" 36 #include "util/parse-branch-options.h" 37 #include "util/parse-regs-options.h" 38 #include "util/llvm-utils.h" 39 #include "util/bpf-loader.h" 40 #include "util/trigger.h" 41 #include "util/perf-hooks.h" 42 #include "util/time-utils.h" 43 #include "util/units.h" 44 #include "asm/bug.h" 45 46 #include <errno.h> 47 #include <inttypes.h> 48 #include <poll.h> 49 #include <unistd.h> 50 #include <sched.h> 51 #include <signal.h> 52 #include <sys/mman.h> 53 #include <sys/wait.h> 54 #include <asm/bug.h> 55 #include <linux/time64.h> 56 57 struct switch_output { 58 bool enabled; 59 bool signal; 60 unsigned long size; 61 unsigned long time; 62 const char *str; 63 bool set; 64 }; 65 66 struct record { 67 struct perf_tool tool; 68 struct record_opts opts; 69 u64 bytes_written; 70 struct perf_data data; 71 struct auxtrace_record *itr; 72 struct perf_evlist *evlist; 73 struct perf_session *session; 74 const char *progname; 75 int realtime_prio; 76 bool no_buildid; 77 bool no_buildid_set; 78 bool no_buildid_cache; 79 bool no_buildid_cache_set; 80 bool buildid_all; 81 bool timestamp_filename; 82 struct switch_output switch_output; 83 unsigned long long samples; 84 }; 85 86 static volatile int auxtrace_record__snapshot_started; 87 static DEFINE_TRIGGER(auxtrace_snapshot_trigger); 88 static DEFINE_TRIGGER(switch_output_trigger); 89 90 static bool switch_output_signal(struct record *rec) 91 { 92 return rec->switch_output.signal && 93 trigger_is_ready(&switch_output_trigger); 94 } 95 96 static bool switch_output_size(struct record *rec) 97 { 98 return rec->switch_output.size && 99 trigger_is_ready(&switch_output_trigger) && 100 (rec->bytes_written >= rec->switch_output.size); 101 } 102 103 static bool switch_output_time(struct record *rec) 104 { 105 return rec->switch_output.time && 106 trigger_is_ready(&switch_output_trigger); 107 } 108 109 static int record__write(struct record *rec, void *bf, size_t size) 110 { 111 if (perf_data__write(rec->session->data, bf, size) < 0) { 112 pr_err("failed to write perf data, error: %m\n"); 113 return -1; 114 } 115 116 rec->bytes_written += size; 117 118 if (switch_output_size(rec)) 119 trigger_hit(&switch_output_trigger); 120 121 return 0; 122 } 123 124 static int process_synthesized_event(struct perf_tool *tool, 125 union perf_event *event, 126 struct perf_sample *sample __maybe_unused, 127 struct machine *machine __maybe_unused) 128 { 129 struct record *rec = container_of(tool, struct record, tool); 130 return record__write(rec, event, event->header.size); 131 } 132 133 static int record__pushfn(void *to, void *bf, size_t size) 134 { 135 struct record *rec = to; 136 137 rec->samples++; 138 return record__write(rec, bf, size); 139 } 140 141 static volatile int done; 142 static volatile int signr = -1; 143 static volatile int child_finished; 144 145 static void sig_handler(int sig) 146 { 147 if (sig == SIGCHLD) 148 child_finished = 1; 149 else 150 signr = sig; 151 152 done = 1; 153 } 154 155 static void sigsegv_handler(int sig) 156 { 157 perf_hooks__recover(); 158 sighandler_dump_stack(sig); 159 } 160 161 static void record__sig_exit(void) 162 { 163 if (signr == -1) 164 return; 165 166 signal(signr, SIG_DFL); 167 raise(signr); 168 } 169 170 #ifdef HAVE_AUXTRACE_SUPPORT 171 172 static int record__process_auxtrace(struct perf_tool *tool, 173 union perf_event *event, void *data1, 174 size_t len1, void *data2, size_t len2) 175 { 176 struct record *rec = container_of(tool, struct record, tool); 177 struct perf_data *data = &rec->data; 178 size_t padding; 179 u8 pad[8] = {0}; 180 181 if (!perf_data__is_pipe(data)) { 182 off_t file_offset; 183 int fd = perf_data__fd(data); 184 int err; 185 186 file_offset = lseek(fd, 0, SEEK_CUR); 187 if (file_offset == -1) 188 return -1; 189 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index, 190 event, file_offset); 191 if (err) 192 return err; 193 } 194 195 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */ 196 padding = (len1 + len2) & 7; 197 if (padding) 198 padding = 8 - padding; 199 200 record__write(rec, event, event->header.size); 201 record__write(rec, data1, len1); 202 if (len2) 203 record__write(rec, data2, len2); 204 record__write(rec, &pad, padding); 205 206 return 0; 207 } 208 209 static int record__auxtrace_mmap_read(struct record *rec, 210 struct auxtrace_mmap *mm) 211 { 212 int ret; 213 214 ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool, 215 record__process_auxtrace); 216 if (ret < 0) 217 return ret; 218 219 if (ret) 220 rec->samples++; 221 222 return 0; 223 } 224 225 static int record__auxtrace_mmap_read_snapshot(struct record *rec, 226 struct auxtrace_mmap *mm) 227 { 228 int ret; 229 230 ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool, 231 record__process_auxtrace, 232 rec->opts.auxtrace_snapshot_size); 233 if (ret < 0) 234 return ret; 235 236 if (ret) 237 rec->samples++; 238 239 return 0; 240 } 241 242 static int record__auxtrace_read_snapshot_all(struct record *rec) 243 { 244 int i; 245 int rc = 0; 246 247 for (i = 0; i < rec->evlist->nr_mmaps; i++) { 248 struct auxtrace_mmap *mm = 249 &rec->evlist->mmap[i].auxtrace_mmap; 250 251 if (!mm->base) 252 continue; 253 254 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) { 255 rc = -1; 256 goto out; 257 } 258 } 259 out: 260 return rc; 261 } 262 263 static void record__read_auxtrace_snapshot(struct record *rec) 264 { 265 pr_debug("Recording AUX area tracing snapshot\n"); 266 if (record__auxtrace_read_snapshot_all(rec) < 0) { 267 trigger_error(&auxtrace_snapshot_trigger); 268 } else { 269 if (auxtrace_record__snapshot_finish(rec->itr)) 270 trigger_error(&auxtrace_snapshot_trigger); 271 else 272 trigger_ready(&auxtrace_snapshot_trigger); 273 } 274 } 275 276 #else 277 278 static inline 279 int record__auxtrace_mmap_read(struct record *rec __maybe_unused, 280 struct auxtrace_mmap *mm __maybe_unused) 281 { 282 return 0; 283 } 284 285 static inline 286 void record__read_auxtrace_snapshot(struct record *rec __maybe_unused) 287 { 288 } 289 290 static inline 291 int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused) 292 { 293 return 0; 294 } 295 296 #endif 297 298 static int record__mmap_evlist(struct record *rec, 299 struct perf_evlist *evlist) 300 { 301 struct record_opts *opts = &rec->opts; 302 char msg[512]; 303 304 if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false, 305 opts->auxtrace_mmap_pages, 306 opts->auxtrace_snapshot_mode) < 0) { 307 if (errno == EPERM) { 308 pr_err("Permission error mapping pages.\n" 309 "Consider increasing " 310 "/proc/sys/kernel/perf_event_mlock_kb,\n" 311 "or try again with a smaller value of -m/--mmap_pages.\n" 312 "(current value: %u,%u)\n", 313 opts->mmap_pages, opts->auxtrace_mmap_pages); 314 return -errno; 315 } else { 316 pr_err("failed to mmap with %d (%s)\n", errno, 317 str_error_r(errno, msg, sizeof(msg))); 318 if (errno) 319 return -errno; 320 else 321 return -EINVAL; 322 } 323 } 324 return 0; 325 } 326 327 static int record__mmap(struct record *rec) 328 { 329 return record__mmap_evlist(rec, rec->evlist); 330 } 331 332 static int record__open(struct record *rec) 333 { 334 char msg[BUFSIZ]; 335 struct perf_evsel *pos; 336 struct perf_evlist *evlist = rec->evlist; 337 struct perf_session *session = rec->session; 338 struct record_opts *opts = &rec->opts; 339 struct perf_evsel_config_term *err_term; 340 int rc = 0; 341 342 /* 343 * For initial_delay we need to add a dummy event so that we can track 344 * PERF_RECORD_MMAP while we wait for the initial delay to enable the 345 * real events, the ones asked by the user. 346 */ 347 if (opts->initial_delay) { 348 if (perf_evlist__add_dummy(evlist)) 349 return -ENOMEM; 350 351 pos = perf_evlist__first(evlist); 352 pos->tracking = 0; 353 pos = perf_evlist__last(evlist); 354 pos->tracking = 1; 355 pos->attr.enable_on_exec = 1; 356 } 357 358 perf_evlist__config(evlist, opts, &callchain_param); 359 360 evlist__for_each_entry(evlist, pos) { 361 try_again: 362 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) { 363 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) { 364 if (verbose > 0) 365 ui__warning("%s\n", msg); 366 goto try_again; 367 } 368 369 rc = -errno; 370 perf_evsel__open_strerror(pos, &opts->target, 371 errno, msg, sizeof(msg)); 372 ui__error("%s\n", msg); 373 goto out; 374 } 375 } 376 377 if (perf_evlist__apply_filters(evlist, &pos)) { 378 pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n", 379 pos->filter, perf_evsel__name(pos), errno, 380 str_error_r(errno, msg, sizeof(msg))); 381 rc = -1; 382 goto out; 383 } 384 385 if (perf_evlist__apply_drv_configs(evlist, &pos, &err_term)) { 386 pr_err("failed to set config \"%s\" on event %s with %d (%s)\n", 387 err_term->val.drv_cfg, perf_evsel__name(pos), errno, 388 str_error_r(errno, msg, sizeof(msg))); 389 rc = -1; 390 goto out; 391 } 392 393 rc = record__mmap(rec); 394 if (rc) 395 goto out; 396 397 session->evlist = evlist; 398 perf_session__set_id_hdr_size(session); 399 out: 400 return rc; 401 } 402 403 static int process_sample_event(struct perf_tool *tool, 404 union perf_event *event, 405 struct perf_sample *sample, 406 struct perf_evsel *evsel, 407 struct machine *machine) 408 { 409 struct record *rec = container_of(tool, struct record, tool); 410 411 rec->samples++; 412 413 return build_id__mark_dso_hit(tool, event, sample, evsel, machine); 414 } 415 416 static int process_buildids(struct record *rec) 417 { 418 struct perf_data *data = &rec->data; 419 struct perf_session *session = rec->session; 420 421 if (data->size == 0) 422 return 0; 423 424 /* 425 * During this process, it'll load kernel map and replace the 426 * dso->long_name to a real pathname it found. In this case 427 * we prefer the vmlinux path like 428 * /lib/modules/3.16.4/build/vmlinux 429 * 430 * rather than build-id path (in debug directory). 431 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551 432 */ 433 symbol_conf.ignore_vmlinux_buildid = true; 434 435 /* 436 * If --buildid-all is given, it marks all DSO regardless of hits, 437 * so no need to process samples. 438 */ 439 if (rec->buildid_all) 440 rec->tool.sample = NULL; 441 442 return perf_session__process_events(session); 443 } 444 445 static void perf_event__synthesize_guest_os(struct machine *machine, void *data) 446 { 447 int err; 448 struct perf_tool *tool = data; 449 /* 450 *As for guest kernel when processing subcommand record&report, 451 *we arrange module mmap prior to guest kernel mmap and trigger 452 *a preload dso because default guest module symbols are loaded 453 *from guest kallsyms instead of /lib/modules/XXX/XXX. This 454 *method is used to avoid symbol missing when the first addr is 455 *in module instead of in guest kernel. 456 */ 457 err = perf_event__synthesize_modules(tool, process_synthesized_event, 458 machine); 459 if (err < 0) 460 pr_err("Couldn't record guest kernel [%d]'s reference" 461 " relocation symbol.\n", machine->pid); 462 463 /* 464 * We use _stext for guest kernel because guest kernel's /proc/kallsyms 465 * have no _text sometimes. 466 */ 467 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event, 468 machine); 469 if (err < 0) 470 pr_err("Couldn't record guest kernel [%d]'s reference" 471 " relocation symbol.\n", machine->pid); 472 } 473 474 static struct perf_event_header finished_round_event = { 475 .size = sizeof(struct perf_event_header), 476 .type = PERF_RECORD_FINISHED_ROUND, 477 }; 478 479 static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist, 480 bool backward) 481 { 482 u64 bytes_written = rec->bytes_written; 483 int i; 484 int rc = 0; 485 struct perf_mmap *maps; 486 487 if (!evlist) 488 return 0; 489 490 maps = backward ? evlist->backward_mmap : evlist->mmap; 491 if (!maps) 492 return 0; 493 494 if (backward && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING) 495 return 0; 496 497 for (i = 0; i < evlist->nr_mmaps; i++) { 498 struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap; 499 500 if (maps[i].base) { 501 if (perf_mmap__push(&maps[i], evlist->overwrite, backward, rec, record__pushfn) != 0) { 502 rc = -1; 503 goto out; 504 } 505 } 506 507 if (mm->base && !rec->opts.auxtrace_snapshot_mode && 508 record__auxtrace_mmap_read(rec, mm) != 0) { 509 rc = -1; 510 goto out; 511 } 512 } 513 514 /* 515 * Mark the round finished in case we wrote 516 * at least one event. 517 */ 518 if (bytes_written != rec->bytes_written) 519 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event)); 520 521 if (backward) 522 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY); 523 out: 524 return rc; 525 } 526 527 static int record__mmap_read_all(struct record *rec) 528 { 529 int err; 530 531 err = record__mmap_read_evlist(rec, rec->evlist, false); 532 if (err) 533 return err; 534 535 return record__mmap_read_evlist(rec, rec->evlist, true); 536 } 537 538 static void record__init_features(struct record *rec) 539 { 540 struct perf_session *session = rec->session; 541 int feat; 542 543 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++) 544 perf_header__set_feat(&session->header, feat); 545 546 if (rec->no_buildid) 547 perf_header__clear_feat(&session->header, HEADER_BUILD_ID); 548 549 if (!have_tracepoints(&rec->evlist->entries)) 550 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA); 551 552 if (!rec->opts.branch_stack) 553 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK); 554 555 if (!rec->opts.full_auxtrace) 556 perf_header__clear_feat(&session->header, HEADER_AUXTRACE); 557 558 perf_header__clear_feat(&session->header, HEADER_STAT); 559 } 560 561 static void 562 record__finish_output(struct record *rec) 563 { 564 struct perf_data *data = &rec->data; 565 int fd = perf_data__fd(data); 566 567 if (data->is_pipe) 568 return; 569 570 rec->session->header.data_size += rec->bytes_written; 571 data->size = lseek(perf_data__fd(data), 0, SEEK_CUR); 572 573 if (!rec->no_buildid) { 574 process_buildids(rec); 575 576 if (rec->buildid_all) 577 dsos__hit_all(rec->session); 578 } 579 perf_session__write_header(rec->session, rec->evlist, fd, true); 580 581 return; 582 } 583 584 static int record__synthesize_workload(struct record *rec, bool tail) 585 { 586 int err; 587 struct thread_map *thread_map; 588 589 if (rec->opts.tail_synthesize != tail) 590 return 0; 591 592 thread_map = thread_map__new_by_tid(rec->evlist->workload.pid); 593 if (thread_map == NULL) 594 return -1; 595 596 err = perf_event__synthesize_thread_map(&rec->tool, thread_map, 597 process_synthesized_event, 598 &rec->session->machines.host, 599 rec->opts.sample_address, 600 rec->opts.proc_map_timeout); 601 thread_map__put(thread_map); 602 return err; 603 } 604 605 static int record__synthesize(struct record *rec, bool tail); 606 607 static int 608 record__switch_output(struct record *rec, bool at_exit) 609 { 610 struct perf_data *data = &rec->data; 611 int fd, err; 612 613 /* Same Size: "2015122520103046"*/ 614 char timestamp[] = "InvalidTimestamp"; 615 616 record__synthesize(rec, true); 617 if (target__none(&rec->opts.target)) 618 record__synthesize_workload(rec, true); 619 620 rec->samples = 0; 621 record__finish_output(rec); 622 err = fetch_current_timestamp(timestamp, sizeof(timestamp)); 623 if (err) { 624 pr_err("Failed to get current timestamp\n"); 625 return -EINVAL; 626 } 627 628 fd = perf_data__switch(data, timestamp, 629 rec->session->header.data_offset, 630 at_exit); 631 if (fd >= 0 && !at_exit) { 632 rec->bytes_written = 0; 633 rec->session->header.data_size = 0; 634 } 635 636 if (!quiet) 637 fprintf(stderr, "[ perf record: Dump %s.%s ]\n", 638 data->file.path, timestamp); 639 640 /* Output tracking events */ 641 if (!at_exit) { 642 record__synthesize(rec, false); 643 644 /* 645 * In 'perf record --switch-output' without -a, 646 * record__synthesize() in record__switch_output() won't 647 * generate tracking events because there's no thread_map 648 * in evlist. Which causes newly created perf.data doesn't 649 * contain map and comm information. 650 * Create a fake thread_map and directly call 651 * perf_event__synthesize_thread_map() for those events. 652 */ 653 if (target__none(&rec->opts.target)) 654 record__synthesize_workload(rec, false); 655 } 656 return fd; 657 } 658 659 static volatile int workload_exec_errno; 660 661 /* 662 * perf_evlist__prepare_workload will send a SIGUSR1 663 * if the fork fails, since we asked by setting its 664 * want_signal to true. 665 */ 666 static void workload_exec_failed_signal(int signo __maybe_unused, 667 siginfo_t *info, 668 void *ucontext __maybe_unused) 669 { 670 workload_exec_errno = info->si_value.sival_int; 671 done = 1; 672 child_finished = 1; 673 } 674 675 static void snapshot_sig_handler(int sig); 676 static void alarm_sig_handler(int sig); 677 678 int __weak 679 perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused, 680 struct perf_tool *tool __maybe_unused, 681 perf_event__handler_t process __maybe_unused, 682 struct machine *machine __maybe_unused) 683 { 684 return 0; 685 } 686 687 static const struct perf_event_mmap_page * 688 perf_evlist__pick_pc(struct perf_evlist *evlist) 689 { 690 if (evlist) { 691 if (evlist->mmap && evlist->mmap[0].base) 692 return evlist->mmap[0].base; 693 if (evlist->backward_mmap && evlist->backward_mmap[0].base) 694 return evlist->backward_mmap[0].base; 695 } 696 return NULL; 697 } 698 699 static const struct perf_event_mmap_page *record__pick_pc(struct record *rec) 700 { 701 const struct perf_event_mmap_page *pc; 702 703 pc = perf_evlist__pick_pc(rec->evlist); 704 if (pc) 705 return pc; 706 return NULL; 707 } 708 709 static int record__synthesize(struct record *rec, bool tail) 710 { 711 struct perf_session *session = rec->session; 712 struct machine *machine = &session->machines.host; 713 struct perf_data *data = &rec->data; 714 struct record_opts *opts = &rec->opts; 715 struct perf_tool *tool = &rec->tool; 716 int fd = perf_data__fd(data); 717 int err = 0; 718 719 if (rec->opts.tail_synthesize != tail) 720 return 0; 721 722 if (data->is_pipe) { 723 err = perf_event__synthesize_features( 724 tool, session, rec->evlist, process_synthesized_event); 725 if (err < 0) { 726 pr_err("Couldn't synthesize features.\n"); 727 return err; 728 } 729 730 err = perf_event__synthesize_attrs(tool, session, 731 process_synthesized_event); 732 if (err < 0) { 733 pr_err("Couldn't synthesize attrs.\n"); 734 goto out; 735 } 736 737 if (have_tracepoints(&rec->evlist->entries)) { 738 /* 739 * FIXME err <= 0 here actually means that 740 * there were no tracepoints so its not really 741 * an error, just that we don't need to 742 * synthesize anything. We really have to 743 * return this more properly and also 744 * propagate errors that now are calling die() 745 */ 746 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist, 747 process_synthesized_event); 748 if (err <= 0) { 749 pr_err("Couldn't record tracing data.\n"); 750 goto out; 751 } 752 rec->bytes_written += err; 753 } 754 } 755 756 err = perf_event__synth_time_conv(record__pick_pc(rec), tool, 757 process_synthesized_event, machine); 758 if (err) 759 goto out; 760 761 if (rec->opts.full_auxtrace) { 762 err = perf_event__synthesize_auxtrace_info(rec->itr, tool, 763 session, process_synthesized_event); 764 if (err) 765 goto out; 766 } 767 768 if (!perf_evlist__exclude_kernel(rec->evlist)) { 769 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event, 770 machine); 771 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n" 772 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n" 773 "Check /proc/kallsyms permission or run as root.\n"); 774 775 err = perf_event__synthesize_modules(tool, process_synthesized_event, 776 machine); 777 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n" 778 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n" 779 "Check /proc/modules permission or run as root.\n"); 780 } 781 782 if (perf_guest) { 783 machines__process_guests(&session->machines, 784 perf_event__synthesize_guest_os, tool); 785 } 786 787 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads, 788 process_synthesized_event, opts->sample_address, 789 opts->proc_map_timeout, 1); 790 out: 791 return err; 792 } 793 794 static int __cmd_record(struct record *rec, int argc, const char **argv) 795 { 796 int err; 797 int status = 0; 798 unsigned long waking = 0; 799 const bool forks = argc > 0; 800 struct machine *machine; 801 struct perf_tool *tool = &rec->tool; 802 struct record_opts *opts = &rec->opts; 803 struct perf_data *data = &rec->data; 804 struct perf_session *session; 805 bool disabled = false, draining = false; 806 int fd; 807 808 rec->progname = argv[0]; 809 810 atexit(record__sig_exit); 811 signal(SIGCHLD, sig_handler); 812 signal(SIGINT, sig_handler); 813 signal(SIGTERM, sig_handler); 814 signal(SIGSEGV, sigsegv_handler); 815 816 if (rec->opts.record_namespaces) 817 tool->namespace_events = true; 818 819 if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) { 820 signal(SIGUSR2, snapshot_sig_handler); 821 if (rec->opts.auxtrace_snapshot_mode) 822 trigger_on(&auxtrace_snapshot_trigger); 823 if (rec->switch_output.enabled) 824 trigger_on(&switch_output_trigger); 825 } else { 826 signal(SIGUSR2, SIG_IGN); 827 } 828 829 session = perf_session__new(data, false, tool); 830 if (session == NULL) { 831 pr_err("Perf session creation failed.\n"); 832 return -1; 833 } 834 835 fd = perf_data__fd(data); 836 rec->session = session; 837 838 record__init_features(rec); 839 840 if (forks) { 841 err = perf_evlist__prepare_workload(rec->evlist, &opts->target, 842 argv, data->is_pipe, 843 workload_exec_failed_signal); 844 if (err < 0) { 845 pr_err("Couldn't run the workload!\n"); 846 status = err; 847 goto out_delete_session; 848 } 849 } 850 851 if (record__open(rec) != 0) { 852 err = -1; 853 goto out_child; 854 } 855 856 err = bpf__apply_obj_config(); 857 if (err) { 858 char errbuf[BUFSIZ]; 859 860 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf)); 861 pr_err("ERROR: Apply config to BPF failed: %s\n", 862 errbuf); 863 goto out_child; 864 } 865 866 /* 867 * Normally perf_session__new would do this, but it doesn't have the 868 * evlist. 869 */ 870 if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) { 871 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n"); 872 rec->tool.ordered_events = false; 873 } 874 875 if (!rec->evlist->nr_groups) 876 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC); 877 878 if (data->is_pipe) { 879 err = perf_header__write_pipe(fd); 880 if (err < 0) 881 goto out_child; 882 } else { 883 err = perf_session__write_header(session, rec->evlist, fd, false); 884 if (err < 0) 885 goto out_child; 886 } 887 888 if (!rec->no_buildid 889 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) { 890 pr_err("Couldn't generate buildids. " 891 "Use --no-buildid to profile anyway.\n"); 892 err = -1; 893 goto out_child; 894 } 895 896 machine = &session->machines.host; 897 898 err = record__synthesize(rec, false); 899 if (err < 0) 900 goto out_child; 901 902 if (rec->realtime_prio) { 903 struct sched_param param; 904 905 param.sched_priority = rec->realtime_prio; 906 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) { 907 pr_err("Could not set realtime priority.\n"); 908 err = -1; 909 goto out_child; 910 } 911 } 912 913 /* 914 * When perf is starting the traced process, all the events 915 * (apart from group members) have enable_on_exec=1 set, 916 * so don't spoil it by prematurely enabling them. 917 */ 918 if (!target__none(&opts->target) && !opts->initial_delay) 919 perf_evlist__enable(rec->evlist); 920 921 /* 922 * Let the child rip 923 */ 924 if (forks) { 925 union perf_event *event; 926 pid_t tgid; 927 928 event = malloc(sizeof(event->comm) + machine->id_hdr_size); 929 if (event == NULL) { 930 err = -ENOMEM; 931 goto out_child; 932 } 933 934 /* 935 * Some H/W events are generated before COMM event 936 * which is emitted during exec(), so perf script 937 * cannot see a correct process name for those events. 938 * Synthesize COMM event to prevent it. 939 */ 940 tgid = perf_event__synthesize_comm(tool, event, 941 rec->evlist->workload.pid, 942 process_synthesized_event, 943 machine); 944 free(event); 945 946 if (tgid == -1) 947 goto out_child; 948 949 event = malloc(sizeof(event->namespaces) + 950 (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) + 951 machine->id_hdr_size); 952 if (event == NULL) { 953 err = -ENOMEM; 954 goto out_child; 955 } 956 957 /* 958 * Synthesize NAMESPACES event for the command specified. 959 */ 960 perf_event__synthesize_namespaces(tool, event, 961 rec->evlist->workload.pid, 962 tgid, process_synthesized_event, 963 machine); 964 free(event); 965 966 perf_evlist__start_workload(rec->evlist); 967 } 968 969 if (opts->initial_delay) { 970 usleep(opts->initial_delay * USEC_PER_MSEC); 971 perf_evlist__enable(rec->evlist); 972 } 973 974 trigger_ready(&auxtrace_snapshot_trigger); 975 trigger_ready(&switch_output_trigger); 976 perf_hooks__invoke_record_start(); 977 for (;;) { 978 unsigned long long hits = rec->samples; 979 980 /* 981 * rec->evlist->bkw_mmap_state is possible to be 982 * BKW_MMAP_EMPTY here: when done == true and 983 * hits != rec->samples in previous round. 984 * 985 * perf_evlist__toggle_bkw_mmap ensure we never 986 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING. 987 */ 988 if (trigger_is_hit(&switch_output_trigger) || done || draining) 989 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING); 990 991 if (record__mmap_read_all(rec) < 0) { 992 trigger_error(&auxtrace_snapshot_trigger); 993 trigger_error(&switch_output_trigger); 994 err = -1; 995 goto out_child; 996 } 997 998 if (auxtrace_record__snapshot_started) { 999 auxtrace_record__snapshot_started = 0; 1000 if (!trigger_is_error(&auxtrace_snapshot_trigger)) 1001 record__read_auxtrace_snapshot(rec); 1002 if (trigger_is_error(&auxtrace_snapshot_trigger)) { 1003 pr_err("AUX area tracing snapshot failed\n"); 1004 err = -1; 1005 goto out_child; 1006 } 1007 } 1008 1009 if (trigger_is_hit(&switch_output_trigger)) { 1010 /* 1011 * If switch_output_trigger is hit, the data in 1012 * overwritable ring buffer should have been collected, 1013 * so bkw_mmap_state should be set to BKW_MMAP_EMPTY. 1014 * 1015 * If SIGUSR2 raise after or during record__mmap_read_all(), 1016 * record__mmap_read_all() didn't collect data from 1017 * overwritable ring buffer. Read again. 1018 */ 1019 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING) 1020 continue; 1021 trigger_ready(&switch_output_trigger); 1022 1023 /* 1024 * Reenable events in overwrite ring buffer after 1025 * record__mmap_read_all(): we should have collected 1026 * data from it. 1027 */ 1028 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING); 1029 1030 if (!quiet) 1031 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n", 1032 waking); 1033 waking = 0; 1034 fd = record__switch_output(rec, false); 1035 if (fd < 0) { 1036 pr_err("Failed to switch to new file\n"); 1037 trigger_error(&switch_output_trigger); 1038 err = fd; 1039 goto out_child; 1040 } 1041 1042 /* re-arm the alarm */ 1043 if (rec->switch_output.time) 1044 alarm(rec->switch_output.time); 1045 } 1046 1047 if (hits == rec->samples) { 1048 if (done || draining) 1049 break; 1050 err = perf_evlist__poll(rec->evlist, -1); 1051 /* 1052 * Propagate error, only if there's any. Ignore positive 1053 * number of returned events and interrupt error. 1054 */ 1055 if (err > 0 || (err < 0 && errno == EINTR)) 1056 err = 0; 1057 waking++; 1058 1059 if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0) 1060 draining = true; 1061 } 1062 1063 /* 1064 * When perf is starting the traced process, at the end events 1065 * die with the process and we wait for that. Thus no need to 1066 * disable events in this case. 1067 */ 1068 if (done && !disabled && !target__none(&opts->target)) { 1069 trigger_off(&auxtrace_snapshot_trigger); 1070 perf_evlist__disable(rec->evlist); 1071 disabled = true; 1072 } 1073 } 1074 trigger_off(&auxtrace_snapshot_trigger); 1075 trigger_off(&switch_output_trigger); 1076 1077 if (forks && workload_exec_errno) { 1078 char msg[STRERR_BUFSIZE]; 1079 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg)); 1080 pr_err("Workload failed: %s\n", emsg); 1081 err = -1; 1082 goto out_child; 1083 } 1084 1085 if (!quiet) 1086 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking); 1087 1088 if (target__none(&rec->opts.target)) 1089 record__synthesize_workload(rec, true); 1090 1091 out_child: 1092 if (forks) { 1093 int exit_status; 1094 1095 if (!child_finished) 1096 kill(rec->evlist->workload.pid, SIGTERM); 1097 1098 wait(&exit_status); 1099 1100 if (err < 0) 1101 status = err; 1102 else if (WIFEXITED(exit_status)) 1103 status = WEXITSTATUS(exit_status); 1104 else if (WIFSIGNALED(exit_status)) 1105 signr = WTERMSIG(exit_status); 1106 } else 1107 status = err; 1108 1109 record__synthesize(rec, true); 1110 /* this will be recalculated during process_buildids() */ 1111 rec->samples = 0; 1112 1113 if (!err) { 1114 if (!rec->timestamp_filename) { 1115 record__finish_output(rec); 1116 } else { 1117 fd = record__switch_output(rec, true); 1118 if (fd < 0) { 1119 status = fd; 1120 goto out_delete_session; 1121 } 1122 } 1123 } 1124 1125 perf_hooks__invoke_record_end(); 1126 1127 if (!err && !quiet) { 1128 char samples[128]; 1129 const char *postfix = rec->timestamp_filename ? 1130 ".<timestamp>" : ""; 1131 1132 if (rec->samples && !rec->opts.full_auxtrace) 1133 scnprintf(samples, sizeof(samples), 1134 " (%" PRIu64 " samples)", rec->samples); 1135 else 1136 samples[0] = '\0'; 1137 1138 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s ]\n", 1139 perf_data__size(data) / 1024.0 / 1024.0, 1140 data->file.path, postfix, samples); 1141 } 1142 1143 out_delete_session: 1144 perf_session__delete(session); 1145 return status; 1146 } 1147 1148 static void callchain_debug(struct callchain_param *callchain) 1149 { 1150 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" }; 1151 1152 pr_debug("callchain: type %s\n", str[callchain->record_mode]); 1153 1154 if (callchain->record_mode == CALLCHAIN_DWARF) 1155 pr_debug("callchain: stack dump size %d\n", 1156 callchain->dump_size); 1157 } 1158 1159 int record_opts__parse_callchain(struct record_opts *record, 1160 struct callchain_param *callchain, 1161 const char *arg, bool unset) 1162 { 1163 int ret; 1164 callchain->enabled = !unset; 1165 1166 /* --no-call-graph */ 1167 if (unset) { 1168 callchain->record_mode = CALLCHAIN_NONE; 1169 pr_debug("callchain: disabled\n"); 1170 return 0; 1171 } 1172 1173 ret = parse_callchain_record_opt(arg, callchain); 1174 if (!ret) { 1175 /* Enable data address sampling for DWARF unwind. */ 1176 if (callchain->record_mode == CALLCHAIN_DWARF) 1177 record->sample_address = true; 1178 callchain_debug(callchain); 1179 } 1180 1181 return ret; 1182 } 1183 1184 int record_parse_callchain_opt(const struct option *opt, 1185 const char *arg, 1186 int unset) 1187 { 1188 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset); 1189 } 1190 1191 int record_callchain_opt(const struct option *opt, 1192 const char *arg __maybe_unused, 1193 int unset __maybe_unused) 1194 { 1195 struct callchain_param *callchain = opt->value; 1196 1197 callchain->enabled = true; 1198 1199 if (callchain->record_mode == CALLCHAIN_NONE) 1200 callchain->record_mode = CALLCHAIN_FP; 1201 1202 callchain_debug(callchain); 1203 return 0; 1204 } 1205 1206 static int perf_record_config(const char *var, const char *value, void *cb) 1207 { 1208 struct record *rec = cb; 1209 1210 if (!strcmp(var, "record.build-id")) { 1211 if (!strcmp(value, "cache")) 1212 rec->no_buildid_cache = false; 1213 else if (!strcmp(value, "no-cache")) 1214 rec->no_buildid_cache = true; 1215 else if (!strcmp(value, "skip")) 1216 rec->no_buildid = true; 1217 else 1218 return -1; 1219 return 0; 1220 } 1221 if (!strcmp(var, "record.call-graph")) 1222 var = "call-graph.record-mode"; /* fall-through */ 1223 1224 return perf_default_config(var, value, cb); 1225 } 1226 1227 struct clockid_map { 1228 const char *name; 1229 int clockid; 1230 }; 1231 1232 #define CLOCKID_MAP(n, c) \ 1233 { .name = n, .clockid = (c), } 1234 1235 #define CLOCKID_END { .name = NULL, } 1236 1237 1238 /* 1239 * Add the missing ones, we need to build on many distros... 1240 */ 1241 #ifndef CLOCK_MONOTONIC_RAW 1242 #define CLOCK_MONOTONIC_RAW 4 1243 #endif 1244 #ifndef CLOCK_BOOTTIME 1245 #define CLOCK_BOOTTIME 7 1246 #endif 1247 #ifndef CLOCK_TAI 1248 #define CLOCK_TAI 11 1249 #endif 1250 1251 static const struct clockid_map clockids[] = { 1252 /* available for all events, NMI safe */ 1253 CLOCKID_MAP("monotonic", CLOCK_MONOTONIC), 1254 CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW), 1255 1256 /* available for some events */ 1257 CLOCKID_MAP("realtime", CLOCK_REALTIME), 1258 CLOCKID_MAP("boottime", CLOCK_BOOTTIME), 1259 CLOCKID_MAP("tai", CLOCK_TAI), 1260 1261 /* available for the lazy */ 1262 CLOCKID_MAP("mono", CLOCK_MONOTONIC), 1263 CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW), 1264 CLOCKID_MAP("real", CLOCK_REALTIME), 1265 CLOCKID_MAP("boot", CLOCK_BOOTTIME), 1266 1267 CLOCKID_END, 1268 }; 1269 1270 static int parse_clockid(const struct option *opt, const char *str, int unset) 1271 { 1272 struct record_opts *opts = (struct record_opts *)opt->value; 1273 const struct clockid_map *cm; 1274 const char *ostr = str; 1275 1276 if (unset) { 1277 opts->use_clockid = 0; 1278 return 0; 1279 } 1280 1281 /* no arg passed */ 1282 if (!str) 1283 return 0; 1284 1285 /* no setting it twice */ 1286 if (opts->use_clockid) 1287 return -1; 1288 1289 opts->use_clockid = true; 1290 1291 /* if its a number, we're done */ 1292 if (sscanf(str, "%d", &opts->clockid) == 1) 1293 return 0; 1294 1295 /* allow a "CLOCK_" prefix to the name */ 1296 if (!strncasecmp(str, "CLOCK_", 6)) 1297 str += 6; 1298 1299 for (cm = clockids; cm->name; cm++) { 1300 if (!strcasecmp(str, cm->name)) { 1301 opts->clockid = cm->clockid; 1302 return 0; 1303 } 1304 } 1305 1306 opts->use_clockid = false; 1307 ui__warning("unknown clockid %s, check man page\n", ostr); 1308 return -1; 1309 } 1310 1311 static int record__parse_mmap_pages(const struct option *opt, 1312 const char *str, 1313 int unset __maybe_unused) 1314 { 1315 struct record_opts *opts = opt->value; 1316 char *s, *p; 1317 unsigned int mmap_pages; 1318 int ret; 1319 1320 if (!str) 1321 return -EINVAL; 1322 1323 s = strdup(str); 1324 if (!s) 1325 return -ENOMEM; 1326 1327 p = strchr(s, ','); 1328 if (p) 1329 *p = '\0'; 1330 1331 if (*s) { 1332 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s); 1333 if (ret) 1334 goto out_free; 1335 opts->mmap_pages = mmap_pages; 1336 } 1337 1338 if (!p) { 1339 ret = 0; 1340 goto out_free; 1341 } 1342 1343 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1); 1344 if (ret) 1345 goto out_free; 1346 1347 opts->auxtrace_mmap_pages = mmap_pages; 1348 1349 out_free: 1350 free(s); 1351 return ret; 1352 } 1353 1354 static void switch_output_size_warn(struct record *rec) 1355 { 1356 u64 wakeup_size = perf_evlist__mmap_size(rec->opts.mmap_pages); 1357 struct switch_output *s = &rec->switch_output; 1358 1359 wakeup_size /= 2; 1360 1361 if (s->size < wakeup_size) { 1362 char buf[100]; 1363 1364 unit_number__scnprintf(buf, sizeof(buf), wakeup_size); 1365 pr_warning("WARNING: switch-output data size lower than " 1366 "wakeup kernel buffer size (%s) " 1367 "expect bigger perf.data sizes\n", buf); 1368 } 1369 } 1370 1371 static int switch_output_setup(struct record *rec) 1372 { 1373 struct switch_output *s = &rec->switch_output; 1374 static struct parse_tag tags_size[] = { 1375 { .tag = 'B', .mult = 1 }, 1376 { .tag = 'K', .mult = 1 << 10 }, 1377 { .tag = 'M', .mult = 1 << 20 }, 1378 { .tag = 'G', .mult = 1 << 30 }, 1379 { .tag = 0 }, 1380 }; 1381 static struct parse_tag tags_time[] = { 1382 { .tag = 's', .mult = 1 }, 1383 { .tag = 'm', .mult = 60 }, 1384 { .tag = 'h', .mult = 60*60 }, 1385 { .tag = 'd', .mult = 60*60*24 }, 1386 { .tag = 0 }, 1387 }; 1388 unsigned long val; 1389 1390 if (!s->set) 1391 return 0; 1392 1393 if (!strcmp(s->str, "signal")) { 1394 s->signal = true; 1395 pr_debug("switch-output with SIGUSR2 signal\n"); 1396 goto enabled; 1397 } 1398 1399 val = parse_tag_value(s->str, tags_size); 1400 if (val != (unsigned long) -1) { 1401 s->size = val; 1402 pr_debug("switch-output with %s size threshold\n", s->str); 1403 goto enabled; 1404 } 1405 1406 val = parse_tag_value(s->str, tags_time); 1407 if (val != (unsigned long) -1) { 1408 s->time = val; 1409 pr_debug("switch-output with %s time threshold (%lu seconds)\n", 1410 s->str, s->time); 1411 goto enabled; 1412 } 1413 1414 return -1; 1415 1416 enabled: 1417 rec->timestamp_filename = true; 1418 s->enabled = true; 1419 1420 if (s->size && !rec->opts.no_buffering) 1421 switch_output_size_warn(rec); 1422 1423 return 0; 1424 } 1425 1426 static const char * const __record_usage[] = { 1427 "perf record [<options>] [<command>]", 1428 "perf record [<options>] -- <command> [<options>]", 1429 NULL 1430 }; 1431 const char * const *record_usage = __record_usage; 1432 1433 /* 1434 * XXX Ideally would be local to cmd_record() and passed to a record__new 1435 * because we need to have access to it in record__exit, that is called 1436 * after cmd_record() exits, but since record_options need to be accessible to 1437 * builtin-script, leave it here. 1438 * 1439 * At least we don't ouch it in all the other functions here directly. 1440 * 1441 * Just say no to tons of global variables, sigh. 1442 */ 1443 static struct record record = { 1444 .opts = { 1445 .sample_time = true, 1446 .mmap_pages = UINT_MAX, 1447 .user_freq = UINT_MAX, 1448 .user_interval = ULLONG_MAX, 1449 .freq = 4000, 1450 .target = { 1451 .uses_mmap = true, 1452 .default_per_cpu = true, 1453 }, 1454 .proc_map_timeout = 500, 1455 }, 1456 .tool = { 1457 .sample = process_sample_event, 1458 .fork = perf_event__process_fork, 1459 .exit = perf_event__process_exit, 1460 .comm = perf_event__process_comm, 1461 .namespaces = perf_event__process_namespaces, 1462 .mmap = perf_event__process_mmap, 1463 .mmap2 = perf_event__process_mmap2, 1464 .ordered_events = true, 1465 }, 1466 }; 1467 1468 const char record_callchain_help[] = CALLCHAIN_RECORD_HELP 1469 "\n\t\t\t\tDefault: fp"; 1470 1471 static bool dry_run; 1472 1473 /* 1474 * XXX Will stay a global variable till we fix builtin-script.c to stop messing 1475 * with it and switch to use the library functions in perf_evlist that came 1476 * from builtin-record.c, i.e. use record_opts, 1477 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record', 1478 * using pipes, etc. 1479 */ 1480 static struct option __record_options[] = { 1481 OPT_CALLBACK('e', "event", &record.evlist, "event", 1482 "event selector. use 'perf list' to list available events", 1483 parse_events_option), 1484 OPT_CALLBACK(0, "filter", &record.evlist, "filter", 1485 "event filter", parse_filter), 1486 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist, 1487 NULL, "don't record events from perf itself", 1488 exclude_perf), 1489 OPT_STRING('p', "pid", &record.opts.target.pid, "pid", 1490 "record events on existing process id"), 1491 OPT_STRING('t', "tid", &record.opts.target.tid, "tid", 1492 "record events on existing thread id"), 1493 OPT_INTEGER('r', "realtime", &record.realtime_prio, 1494 "collect data with this RT SCHED_FIFO priority"), 1495 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering, 1496 "collect data without buffering"), 1497 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples, 1498 "collect raw sample records from all opened counters"), 1499 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide, 1500 "system-wide collection from all CPUs"), 1501 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu", 1502 "list of cpus to monitor"), 1503 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"), 1504 OPT_STRING('o', "output", &record.data.file.path, "file", 1505 "output file name"), 1506 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit, 1507 &record.opts.no_inherit_set, 1508 "child tasks do not inherit counters"), 1509 OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize, 1510 "synthesize non-sample events at the end of output"), 1511 OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"), 1512 OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"), 1513 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]", 1514 "number of mmap data pages and AUX area tracing mmap pages", 1515 record__parse_mmap_pages), 1516 OPT_BOOLEAN(0, "group", &record.opts.group, 1517 "put the counters into a counter group"), 1518 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param, 1519 NULL, "enables call-graph recording" , 1520 &record_callchain_opt), 1521 OPT_CALLBACK(0, "call-graph", &record.opts, 1522 "record_mode[,record_size]", record_callchain_help, 1523 &record_parse_callchain_opt), 1524 OPT_INCR('v', "verbose", &verbose, 1525 "be more verbose (show counter open errors, etc)"), 1526 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"), 1527 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat, 1528 "per thread counts"), 1529 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"), 1530 OPT_BOOLEAN(0, "phys-data", &record.opts.sample_phys_addr, 1531 "Record the sample physical addresses"), 1532 OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"), 1533 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time, 1534 &record.opts.sample_time_set, 1535 "Record the sample timestamps"), 1536 OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"), 1537 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples, 1538 "don't sample"), 1539 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache, 1540 &record.no_buildid_cache_set, 1541 "do not update the buildid cache"), 1542 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid, 1543 &record.no_buildid_set, 1544 "do not collect buildids in perf.data"), 1545 OPT_CALLBACK('G', "cgroup", &record.evlist, "name", 1546 "monitor event in cgroup name only", 1547 parse_cgroups), 1548 OPT_UINTEGER('D', "delay", &record.opts.initial_delay, 1549 "ms to wait before starting measurement after program start"), 1550 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user", 1551 "user to profile"), 1552 1553 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack, 1554 "branch any", "sample any taken branches", 1555 parse_branch_stack), 1556 1557 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack, 1558 "branch filter mask", "branch stack filter modes", 1559 parse_branch_stack), 1560 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight, 1561 "sample by weight (on special events only)"), 1562 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction, 1563 "sample transaction flags (special events only)"), 1564 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread, 1565 "use per-thread mmaps"), 1566 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register", 1567 "sample selected machine registers on interrupt," 1568 " use -I ? to list register names", parse_regs), 1569 OPT_CALLBACK_OPTARG(0, "user-regs", &record.opts.sample_user_regs, NULL, "any register", 1570 "sample selected machine registers on interrupt," 1571 " use -I ? to list register names", parse_regs), 1572 OPT_BOOLEAN(0, "running-time", &record.opts.running_time, 1573 "Record running/enabled time of read (:S) events"), 1574 OPT_CALLBACK('k', "clockid", &record.opts, 1575 "clockid", "clockid to use for events, see clock_gettime()", 1576 parse_clockid), 1577 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts, 1578 "opts", "AUX area tracing Snapshot Mode", ""), 1579 OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout, 1580 "per thread proc mmap processing timeout in ms"), 1581 OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces, 1582 "Record namespaces events"), 1583 OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events, 1584 "Record context switch events"), 1585 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel, 1586 "Configure all used events to run in kernel space.", 1587 PARSE_OPT_EXCLUSIVE), 1588 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user, 1589 "Configure all used events to run in user space.", 1590 PARSE_OPT_EXCLUSIVE), 1591 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path", 1592 "clang binary to use for compiling BPF scriptlets"), 1593 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options", 1594 "options passed to clang when compiling BPF scriptlets"), 1595 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name, 1596 "file", "vmlinux pathname"), 1597 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all, 1598 "Record build-id of all DSOs regardless of hits"), 1599 OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename, 1600 "append timestamp to output filename"), 1601 OPT_STRING_OPTARG_SET(0, "switch-output", &record.switch_output.str, 1602 &record.switch_output.set, "signal,size,time", 1603 "Switch output when receive SIGUSR2 or cross size,time threshold", 1604 "signal"), 1605 OPT_BOOLEAN(0, "dry-run", &dry_run, 1606 "Parse options then exit"), 1607 OPT_END() 1608 }; 1609 1610 struct option *record_options = __record_options; 1611 1612 int cmd_record(int argc, const char **argv) 1613 { 1614 int err; 1615 struct record *rec = &record; 1616 char errbuf[BUFSIZ]; 1617 1618 #ifndef HAVE_LIBBPF_SUPPORT 1619 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c) 1620 set_nobuild('\0', "clang-path", true); 1621 set_nobuild('\0', "clang-opt", true); 1622 # undef set_nobuild 1623 #endif 1624 1625 #ifndef HAVE_BPF_PROLOGUE 1626 # if !defined (HAVE_DWARF_SUPPORT) 1627 # define REASON "NO_DWARF=1" 1628 # elif !defined (HAVE_LIBBPF_SUPPORT) 1629 # define REASON "NO_LIBBPF=1" 1630 # else 1631 # define REASON "this architecture doesn't support BPF prologue" 1632 # endif 1633 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c) 1634 set_nobuild('\0', "vmlinux", true); 1635 # undef set_nobuild 1636 # undef REASON 1637 #endif 1638 1639 rec->evlist = perf_evlist__new(); 1640 if (rec->evlist == NULL) 1641 return -ENOMEM; 1642 1643 err = perf_config(perf_record_config, rec); 1644 if (err) 1645 return err; 1646 1647 argc = parse_options(argc, argv, record_options, record_usage, 1648 PARSE_OPT_STOP_AT_NON_OPTION); 1649 if (quiet) 1650 perf_quiet_option(); 1651 1652 /* Make system wide (-a) the default target. */ 1653 if (!argc && target__none(&rec->opts.target)) 1654 rec->opts.target.system_wide = true; 1655 1656 if (nr_cgroups && !rec->opts.target.system_wide) { 1657 usage_with_options_msg(record_usage, record_options, 1658 "cgroup monitoring only available in system-wide mode"); 1659 1660 } 1661 if (rec->opts.record_switch_events && 1662 !perf_can_record_switch_events()) { 1663 ui__error("kernel does not support recording context switch events\n"); 1664 parse_options_usage(record_usage, record_options, "switch-events", 0); 1665 return -EINVAL; 1666 } 1667 1668 if (switch_output_setup(rec)) { 1669 parse_options_usage(record_usage, record_options, "switch-output", 0); 1670 return -EINVAL; 1671 } 1672 1673 if (rec->switch_output.time) { 1674 signal(SIGALRM, alarm_sig_handler); 1675 alarm(rec->switch_output.time); 1676 } 1677 1678 if (!rec->itr) { 1679 rec->itr = auxtrace_record__init(rec->evlist, &err); 1680 if (err) 1681 goto out; 1682 } 1683 1684 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts, 1685 rec->opts.auxtrace_snapshot_opts); 1686 if (err) 1687 goto out; 1688 1689 /* 1690 * Allow aliases to facilitate the lookup of symbols for address 1691 * filters. Refer to auxtrace_parse_filters(). 1692 */ 1693 symbol_conf.allow_aliases = true; 1694 1695 symbol__init(NULL); 1696 1697 err = auxtrace_parse_filters(rec->evlist); 1698 if (err) 1699 goto out; 1700 1701 if (dry_run) 1702 goto out; 1703 1704 err = bpf__setup_stdout(rec->evlist); 1705 if (err) { 1706 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf)); 1707 pr_err("ERROR: Setup BPF stdout failed: %s\n", 1708 errbuf); 1709 goto out; 1710 } 1711 1712 err = -ENOMEM; 1713 1714 if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(rec->evlist)) 1715 pr_warning( 1716 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n" 1717 "check /proc/sys/kernel/kptr_restrict.\n\n" 1718 "Samples in kernel functions may not be resolved if a suitable vmlinux\n" 1719 "file is not found in the buildid cache or in the vmlinux path.\n\n" 1720 "Samples in kernel modules won't be resolved at all.\n\n" 1721 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n" 1722 "even with a suitable vmlinux or kallsyms file.\n\n"); 1723 1724 if (rec->no_buildid_cache || rec->no_buildid) { 1725 disable_buildid_cache(); 1726 } else if (rec->switch_output.enabled) { 1727 /* 1728 * In 'perf record --switch-output', disable buildid 1729 * generation by default to reduce data file switching 1730 * overhead. Still generate buildid if they are required 1731 * explicitly using 1732 * 1733 * perf record --switch-output --no-no-buildid \ 1734 * --no-no-buildid-cache 1735 * 1736 * Following code equals to: 1737 * 1738 * if ((rec->no_buildid || !rec->no_buildid_set) && 1739 * (rec->no_buildid_cache || !rec->no_buildid_cache_set)) 1740 * disable_buildid_cache(); 1741 */ 1742 bool disable = true; 1743 1744 if (rec->no_buildid_set && !rec->no_buildid) 1745 disable = false; 1746 if (rec->no_buildid_cache_set && !rec->no_buildid_cache) 1747 disable = false; 1748 if (disable) { 1749 rec->no_buildid = true; 1750 rec->no_buildid_cache = true; 1751 disable_buildid_cache(); 1752 } 1753 } 1754 1755 if (record.opts.overwrite) 1756 record.opts.tail_synthesize = true; 1757 1758 if (rec->evlist->nr_entries == 0 && 1759 __perf_evlist__add_default(rec->evlist, !record.opts.no_samples) < 0) { 1760 pr_err("Not enough memory for event selector list\n"); 1761 goto out; 1762 } 1763 1764 if (rec->opts.target.tid && !rec->opts.no_inherit_set) 1765 rec->opts.no_inherit = true; 1766 1767 err = target__validate(&rec->opts.target); 1768 if (err) { 1769 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ); 1770 ui__warning("%s", errbuf); 1771 } 1772 1773 err = target__parse_uid(&rec->opts.target); 1774 if (err) { 1775 int saved_errno = errno; 1776 1777 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ); 1778 ui__error("%s", errbuf); 1779 1780 err = -saved_errno; 1781 goto out; 1782 } 1783 1784 /* Enable ignoring missing threads when -u option is defined. */ 1785 rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX; 1786 1787 err = -ENOMEM; 1788 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0) 1789 usage_with_options(record_usage, record_options); 1790 1791 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts); 1792 if (err) 1793 goto out; 1794 1795 /* 1796 * We take all buildids when the file contains 1797 * AUX area tracing data because we do not decode the 1798 * trace because it would take too long. 1799 */ 1800 if (rec->opts.full_auxtrace) 1801 rec->buildid_all = true; 1802 1803 if (record_opts__config(&rec->opts)) { 1804 err = -EINVAL; 1805 goto out; 1806 } 1807 1808 err = __cmd_record(&record, argc, argv); 1809 out: 1810 perf_evlist__delete(rec->evlist); 1811 symbol__exit(); 1812 auxtrace_record__free(rec->itr); 1813 return err; 1814 } 1815 1816 static void snapshot_sig_handler(int sig __maybe_unused) 1817 { 1818 struct record *rec = &record; 1819 1820 if (trigger_is_ready(&auxtrace_snapshot_trigger)) { 1821 trigger_hit(&auxtrace_snapshot_trigger); 1822 auxtrace_record__snapshot_started = 1; 1823 if (auxtrace_record__snapshot_start(record.itr)) 1824 trigger_error(&auxtrace_snapshot_trigger); 1825 } 1826 1827 if (switch_output_signal(rec)) 1828 trigger_hit(&switch_output_trigger); 1829 } 1830 1831 static void alarm_sig_handler(int sig __maybe_unused) 1832 { 1833 struct record *rec = &record; 1834 1835 if (switch_output_time(rec)) 1836 trigger_hit(&switch_output_trigger); 1837 } 1838