4 * Builtin record command: Record the profile of a workload
5 * (or a CPU, or a PID) into the perf.data output file - for
6 * later analysis via perf report.
12 #include "util/build-id.h"
13 #include "util/util.h"
14 #include <subcmd/parse-options.h>
15 #include "util/parse-events.h"
17 #include "util/callchain.h"
18 #include "util/cgroup.h"
19 #include "util/header.h"
20 #include "util/event.h"
21 #include "util/evlist.h"
22 #include "util/evsel.h"
23 #include "util/debug.h"
24 #include "util/session.h"
25 #include "util/tool.h"
26 #include "util/symbol.h"
27 #include "util/cpumap.h"
28 #include "util/thread_map.h"
29 #include "util/data.h"
30 #include "util/perf_regs.h"
31 #include "util/auxtrace.h"
33 #include "util/parse-branch-options.h"
34 #include "util/parse-regs-options.h"
35 #include "util/llvm-utils.h"
36 #include "util/bpf-loader.h"
45 struct perf_tool tool;
46 struct record_opts opts;
48 struct perf_data_file file;
49 struct auxtrace_record *itr;
50 struct perf_evlist *evlist;
51 struct perf_session *session;
56 bool no_buildid_cache;
57 bool no_buildid_cache_set;
59 unsigned long long samples;
62 static int record__write(struct record *rec, void *bf, size_t size)
64 if (perf_data_file__write(rec->session->file, bf, size) < 0) {
65 pr_err("failed to write perf data, error: %m\n");
69 rec->bytes_written += size;
73 static int process_synthesized_event(struct perf_tool *tool,
74 union perf_event *event,
75 struct perf_sample *sample __maybe_unused,
76 struct machine *machine __maybe_unused)
78 struct record *rec = container_of(tool, struct record, tool);
79 return record__write(rec, event, event->header.size);
82 static int record__mmap_read(struct record *rec, int idx)
84 struct perf_mmap *md = &rec->evlist->mmap[idx];
85 u64 head = perf_mmap__read_head(md);
87 unsigned char *data = md->base + page_size;
99 if ((old & md->mask) + size != (head & md->mask)) {
100 buf = &data[old & md->mask];
101 size = md->mask + 1 - (old & md->mask);
104 if (record__write(rec, buf, size) < 0) {
110 buf = &data[old & md->mask];
114 if (record__write(rec, buf, size) < 0) {
120 perf_evlist__mmap_consume(rec->evlist, idx);
125 static volatile int done;
126 static volatile int signr = -1;
127 static volatile int child_finished;
128 static volatile int auxtrace_snapshot_enabled;
129 static volatile int auxtrace_snapshot_err;
130 static volatile int auxtrace_record__snapshot_started;
132 static void sig_handler(int sig)
142 static void record__sig_exit(void)
147 signal(signr, SIG_DFL);
151 #ifdef HAVE_AUXTRACE_SUPPORT
153 static int record__process_auxtrace(struct perf_tool *tool,
154 union perf_event *event, void *data1,
155 size_t len1, void *data2, size_t len2)
157 struct record *rec = container_of(tool, struct record, tool);
158 struct perf_data_file *file = &rec->file;
162 if (!perf_data_file__is_pipe(file)) {
164 int fd = perf_data_file__fd(file);
167 file_offset = lseek(fd, 0, SEEK_CUR);
168 if (file_offset == -1)
170 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
176 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
177 padding = (len1 + len2) & 7;
179 padding = 8 - padding;
181 record__write(rec, event, event->header.size);
182 record__write(rec, data1, len1);
184 record__write(rec, data2, len2);
185 record__write(rec, &pad, padding);
190 static int record__auxtrace_mmap_read(struct record *rec,
191 struct auxtrace_mmap *mm)
195 ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
196 record__process_auxtrace);
206 static int record__auxtrace_mmap_read_snapshot(struct record *rec,
207 struct auxtrace_mmap *mm)
211 ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
212 record__process_auxtrace,
213 rec->opts.auxtrace_snapshot_size);
223 static int record__auxtrace_read_snapshot_all(struct record *rec)
228 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
229 struct auxtrace_mmap *mm =
230 &rec->evlist->mmap[i].auxtrace_mmap;
235 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
244 static void record__read_auxtrace_snapshot(struct record *rec)
246 pr_debug("Recording AUX area tracing snapshot\n");
247 if (record__auxtrace_read_snapshot_all(rec) < 0) {
248 auxtrace_snapshot_err = -1;
250 auxtrace_snapshot_err = auxtrace_record__snapshot_finish(rec->itr);
251 if (!auxtrace_snapshot_err)
252 auxtrace_snapshot_enabled = 1;
259 int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
260 struct auxtrace_mmap *mm __maybe_unused)
266 void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
271 int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
278 static int record__open(struct record *rec)
281 struct perf_evsel *pos;
282 struct perf_evlist *evlist = rec->evlist;
283 struct perf_session *session = rec->session;
284 struct record_opts *opts = &rec->opts;
287 perf_evlist__config(evlist, opts);
289 evlist__for_each(evlist, pos) {
291 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
292 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
294 ui__warning("%s\n", msg);
299 perf_evsel__open_strerror(pos, &opts->target,
300 errno, msg, sizeof(msg));
301 ui__error("%s\n", msg);
306 if (perf_evlist__apply_filters(evlist, &pos)) {
307 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
308 pos->filter, perf_evsel__name(pos), errno,
309 strerror_r(errno, msg, sizeof(msg)));
314 if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
315 opts->auxtrace_mmap_pages,
316 opts->auxtrace_snapshot_mode) < 0) {
317 if (errno == EPERM) {
318 pr_err("Permission error mapping pages.\n"
319 "Consider increasing "
320 "/proc/sys/kernel/perf_event_mlock_kb,\n"
321 "or try again with a smaller value of -m/--mmap_pages.\n"
322 "(current value: %u,%u)\n",
323 opts->mmap_pages, opts->auxtrace_mmap_pages);
326 pr_err("failed to mmap with %d (%s)\n", errno,
327 strerror_r(errno, msg, sizeof(msg)));
336 session->evlist = evlist;
337 perf_session__set_id_hdr_size(session);
342 static int process_sample_event(struct perf_tool *tool,
343 union perf_event *event,
344 struct perf_sample *sample,
345 struct perf_evsel *evsel,
346 struct machine *machine)
348 struct record *rec = container_of(tool, struct record, tool);
352 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
355 static int process_buildids(struct record *rec)
357 struct perf_data_file *file = &rec->file;
358 struct perf_session *session = rec->session;
364 * During this process, it'll load kernel map and replace the
365 * dso->long_name to a real pathname it found. In this case
366 * we prefer the vmlinux path like
367 * /lib/modules/3.16.4/build/vmlinux
369 * rather than build-id path (in debug directory).
370 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
372 symbol_conf.ignore_vmlinux_buildid = true;
375 * If --buildid-all is given, it marks all DSO regardless of hits,
376 * so no need to process samples.
378 if (rec->buildid_all)
379 rec->tool.sample = NULL;
381 return perf_session__process_events(session);
384 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
387 struct perf_tool *tool = data;
389 *As for guest kernel when processing subcommand record&report,
390 *we arrange module mmap prior to guest kernel mmap and trigger
391 *a preload dso because default guest module symbols are loaded
392 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
393 *method is used to avoid symbol missing when the first addr is
394 *in module instead of in guest kernel.
396 err = perf_event__synthesize_modules(tool, process_synthesized_event,
399 pr_err("Couldn't record guest kernel [%d]'s reference"
400 " relocation symbol.\n", machine->pid);
403 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
404 * have no _text sometimes.
406 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
409 pr_err("Couldn't record guest kernel [%d]'s reference"
410 " relocation symbol.\n", machine->pid);
413 static struct perf_event_header finished_round_event = {
414 .size = sizeof(struct perf_event_header),
415 .type = PERF_RECORD_FINISHED_ROUND,
418 static int record__mmap_read_all(struct record *rec)
420 u64 bytes_written = rec->bytes_written;
424 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
425 struct auxtrace_mmap *mm = &rec->evlist->mmap[i].auxtrace_mmap;
427 if (rec->evlist->mmap[i].base) {
428 if (record__mmap_read(rec, i) != 0) {
434 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
435 record__auxtrace_mmap_read(rec, mm) != 0) {
442 * Mark the round finished in case we wrote
443 * at least one event.
445 if (bytes_written != rec->bytes_written)
446 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
452 static void record__init_features(struct record *rec)
454 struct perf_session *session = rec->session;
457 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
458 perf_header__set_feat(&session->header, feat);
461 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
463 if (!have_tracepoints(&rec->evlist->entries))
464 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
466 if (!rec->opts.branch_stack)
467 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
469 if (!rec->opts.full_auxtrace)
470 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
472 perf_header__clear_feat(&session->header, HEADER_STAT);
476 record__finish_output(struct record *rec)
478 struct perf_data_file *file = &rec->file;
479 int fd = perf_data_file__fd(file);
484 rec->session->header.data_size += rec->bytes_written;
485 file->size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
487 if (!rec->no_buildid) {
488 process_buildids(rec);
490 if (rec->buildid_all)
491 dsos__hit_all(rec->session);
493 perf_session__write_header(rec->session, rec->evlist, fd, true);
498 static volatile int workload_exec_errno;
501 * perf_evlist__prepare_workload will send a SIGUSR1
502 * if the fork fails, since we asked by setting its
503 * want_signal to true.
505 static void workload_exec_failed_signal(int signo __maybe_unused,
507 void *ucontext __maybe_unused)
509 workload_exec_errno = info->si_value.sival_int;
514 static void snapshot_sig_handler(int sig);
517 perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused,
518 struct perf_tool *tool __maybe_unused,
519 perf_event__handler_t process __maybe_unused,
520 struct machine *machine __maybe_unused)
525 static int record__synthesize(struct record *rec)
527 struct perf_session *session = rec->session;
528 struct machine *machine = &session->machines.host;
529 struct perf_data_file *file = &rec->file;
530 struct record_opts *opts = &rec->opts;
531 struct perf_tool *tool = &rec->tool;
532 int fd = perf_data_file__fd(file);
536 err = perf_event__synthesize_attrs(tool, session,
537 process_synthesized_event);
539 pr_err("Couldn't synthesize attrs.\n");
543 if (have_tracepoints(&rec->evlist->entries)) {
545 * FIXME err <= 0 here actually means that
546 * there were no tracepoints so its not really
547 * an error, just that we don't need to
548 * synthesize anything. We really have to
549 * return this more properly and also
550 * propagate errors that now are calling die()
552 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
553 process_synthesized_event);
555 pr_err("Couldn't record tracing data.\n");
558 rec->bytes_written += err;
562 err = perf_event__synth_time_conv(rec->evlist->mmap[0].base, tool,
563 process_synthesized_event, machine);
567 if (rec->opts.full_auxtrace) {
568 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
569 session, process_synthesized_event);
574 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
576 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
577 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
578 "Check /proc/kallsyms permission or run as root.\n");
580 err = perf_event__synthesize_modules(tool, process_synthesized_event,
582 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
583 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
584 "Check /proc/modules permission or run as root.\n");
587 machines__process_guests(&session->machines,
588 perf_event__synthesize_guest_os, tool);
591 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
592 process_synthesized_event, opts->sample_address,
593 opts->proc_map_timeout);
598 static int __cmd_record(struct record *rec, int argc, const char **argv)
602 unsigned long waking = 0;
603 const bool forks = argc > 0;
604 struct machine *machine;
605 struct perf_tool *tool = &rec->tool;
606 struct record_opts *opts = &rec->opts;
607 struct perf_data_file *file = &rec->file;
608 struct perf_session *session;
609 bool disabled = false, draining = false;
612 rec->progname = argv[0];
614 atexit(record__sig_exit);
615 signal(SIGCHLD, sig_handler);
616 signal(SIGINT, sig_handler);
617 signal(SIGTERM, sig_handler);
618 if (rec->opts.auxtrace_snapshot_mode)
619 signal(SIGUSR2, snapshot_sig_handler);
621 signal(SIGUSR2, SIG_IGN);
623 session = perf_session__new(file, false, tool);
624 if (session == NULL) {
625 pr_err("Perf session creation failed.\n");
629 fd = perf_data_file__fd(file);
630 rec->session = session;
632 record__init_features(rec);
635 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
637 workload_exec_failed_signal);
639 pr_err("Couldn't run the workload!\n");
641 goto out_delete_session;
645 if (record__open(rec) != 0) {
650 err = bpf__apply_obj_config();
654 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
655 pr_err("ERROR: Apply config to BPF failed: %s\n",
661 * Normally perf_session__new would do this, but it doesn't have the
664 if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
665 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
666 rec->tool.ordered_events = false;
669 if (!rec->evlist->nr_groups)
670 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
673 err = perf_header__write_pipe(fd);
677 err = perf_session__write_header(session, rec->evlist, fd, false);
683 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
684 pr_err("Couldn't generate buildids. "
685 "Use --no-buildid to profile anyway.\n");
690 machine = &session->machines.host;
692 err = record__synthesize(rec);
696 if (rec->realtime_prio) {
697 struct sched_param param;
699 param.sched_priority = rec->realtime_prio;
700 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) {
701 pr_err("Could not set realtime priority.\n");
708 * When perf is starting the traced process, all the events
709 * (apart from group members) have enable_on_exec=1 set,
710 * so don't spoil it by prematurely enabling them.
712 if (!target__none(&opts->target) && !opts->initial_delay)
713 perf_evlist__enable(rec->evlist);
719 union perf_event *event;
721 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
728 * Some H/W events are generated before COMM event
729 * which is emitted during exec(), so perf script
730 * cannot see a correct process name for those events.
731 * Synthesize COMM event to prevent it.
733 perf_event__synthesize_comm(tool, event,
734 rec->evlist->workload.pid,
735 process_synthesized_event,
739 perf_evlist__start_workload(rec->evlist);
742 if (opts->initial_delay) {
743 usleep(opts->initial_delay * 1000);
744 perf_evlist__enable(rec->evlist);
747 auxtrace_snapshot_enabled = 1;
749 unsigned long long hits = rec->samples;
751 if (record__mmap_read_all(rec) < 0) {
752 auxtrace_snapshot_enabled = 0;
757 if (auxtrace_record__snapshot_started) {
758 auxtrace_record__snapshot_started = 0;
759 if (!auxtrace_snapshot_err)
760 record__read_auxtrace_snapshot(rec);
761 if (auxtrace_snapshot_err) {
762 pr_err("AUX area tracing snapshot failed\n");
768 if (hits == rec->samples) {
769 if (done || draining)
771 err = perf_evlist__poll(rec->evlist, -1);
773 * Propagate error, only if there's any. Ignore positive
774 * number of returned events and interrupt error.
776 if (err > 0 || (err < 0 && errno == EINTR))
780 if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
785 * When perf is starting the traced process, at the end events
786 * die with the process and we wait for that. Thus no need to
787 * disable events in this case.
789 if (done && !disabled && !target__none(&opts->target)) {
790 auxtrace_snapshot_enabled = 0;
791 perf_evlist__disable(rec->evlist);
795 auxtrace_snapshot_enabled = 0;
797 if (forks && workload_exec_errno) {
798 char msg[STRERR_BUFSIZE];
799 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
800 pr_err("Workload failed: %s\n", emsg);
806 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
813 kill(rec->evlist->workload.pid, SIGTERM);
819 else if (WIFEXITED(exit_status))
820 status = WEXITSTATUS(exit_status);
821 else if (WIFSIGNALED(exit_status))
822 signr = WTERMSIG(exit_status);
826 /* this will be recalculated during process_buildids() */
830 record__finish_output(rec);
832 if (!err && !quiet) {
835 if (rec->samples && !rec->opts.full_auxtrace)
836 scnprintf(samples, sizeof(samples),
837 " (%" PRIu64 " samples)", rec->samples);
841 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s ]\n",
842 perf_data_file__size(file) / 1024.0 / 1024.0,
843 file->path, samples);
847 perf_session__delete(session);
851 static void callchain_debug(void)
853 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
855 pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
857 if (callchain_param.record_mode == CALLCHAIN_DWARF)
858 pr_debug("callchain: stack dump size %d\n",
859 callchain_param.dump_size);
862 int record_parse_callchain_opt(const struct option *opt,
867 struct record_opts *record = (struct record_opts *)opt->value;
869 record->callgraph_set = true;
870 callchain_param.enabled = !unset;
872 /* --no-call-graph */
874 callchain_param.record_mode = CALLCHAIN_NONE;
875 pr_debug("callchain: disabled\n");
879 ret = parse_callchain_record_opt(arg, &callchain_param);
881 /* Enable data address sampling for DWARF unwind. */
882 if (callchain_param.record_mode == CALLCHAIN_DWARF)
883 record->sample_address = true;
890 int record_callchain_opt(const struct option *opt,
891 const char *arg __maybe_unused,
892 int unset __maybe_unused)
894 struct record_opts *record = (struct record_opts *)opt->value;
896 record->callgraph_set = true;
897 callchain_param.enabled = true;
899 if (callchain_param.record_mode == CALLCHAIN_NONE)
900 callchain_param.record_mode = CALLCHAIN_FP;
906 static int perf_record_config(const char *var, const char *value, void *cb)
908 struct record *rec = cb;
910 if (!strcmp(var, "record.build-id")) {
911 if (!strcmp(value, "cache"))
912 rec->no_buildid_cache = false;
913 else if (!strcmp(value, "no-cache"))
914 rec->no_buildid_cache = true;
915 else if (!strcmp(value, "skip"))
916 rec->no_buildid = true;
921 if (!strcmp(var, "record.call-graph"))
922 var = "call-graph.record-mode"; /* fall-through */
924 return perf_default_config(var, value, cb);
932 #define CLOCKID_MAP(n, c) \
933 { .name = n, .clockid = (c), }
935 #define CLOCKID_END { .name = NULL, }
939 * Add the missing ones, we need to build on many distros...
941 #ifndef CLOCK_MONOTONIC_RAW
942 #define CLOCK_MONOTONIC_RAW 4
944 #ifndef CLOCK_BOOTTIME
945 #define CLOCK_BOOTTIME 7
951 static const struct clockid_map clockids[] = {
952 /* available for all events, NMI safe */
953 CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
954 CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
956 /* available for some events */
957 CLOCKID_MAP("realtime", CLOCK_REALTIME),
958 CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
959 CLOCKID_MAP("tai", CLOCK_TAI),
961 /* available for the lazy */
962 CLOCKID_MAP("mono", CLOCK_MONOTONIC),
963 CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
964 CLOCKID_MAP("real", CLOCK_REALTIME),
965 CLOCKID_MAP("boot", CLOCK_BOOTTIME),
970 static int parse_clockid(const struct option *opt, const char *str, int unset)
972 struct record_opts *opts = (struct record_opts *)opt->value;
973 const struct clockid_map *cm;
974 const char *ostr = str;
977 opts->use_clockid = 0;
985 /* no setting it twice */
986 if (opts->use_clockid)
989 opts->use_clockid = true;
991 /* if its a number, we're done */
992 if (sscanf(str, "%d", &opts->clockid) == 1)
995 /* allow a "CLOCK_" prefix to the name */
996 if (!strncasecmp(str, "CLOCK_", 6))
999 for (cm = clockids; cm->name; cm++) {
1000 if (!strcasecmp(str, cm->name)) {
1001 opts->clockid = cm->clockid;
1006 opts->use_clockid = false;
1007 ui__warning("unknown clockid %s, check man page\n", ostr);
1011 static int record__parse_mmap_pages(const struct option *opt,
1013 int unset __maybe_unused)
1015 struct record_opts *opts = opt->value;
1017 unsigned int mmap_pages;
1032 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
1035 opts->mmap_pages = mmap_pages;
1043 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
1047 opts->auxtrace_mmap_pages = mmap_pages;
1054 static const char * const __record_usage[] = {
1055 "perf record [<options>] [<command>]",
1056 "perf record [<options>] -- <command> [<options>]",
1059 const char * const *record_usage = __record_usage;
1062 * XXX Ideally would be local to cmd_record() and passed to a record__new
1063 * because we need to have access to it in record__exit, that is called
1064 * after cmd_record() exits, but since record_options need to be accessible to
1065 * builtin-script, leave it here.
1067 * At least we don't ouch it in all the other functions here directly.
1069 * Just say no to tons of global variables, sigh.
1071 static struct record record = {
1073 .sample_time = true,
1074 .mmap_pages = UINT_MAX,
1075 .user_freq = UINT_MAX,
1076 .user_interval = ULLONG_MAX,
1080 .default_per_cpu = true,
1082 .proc_map_timeout = 500,
1085 .sample = process_sample_event,
1086 .fork = perf_event__process_fork,
1087 .exit = perf_event__process_exit,
1088 .comm = perf_event__process_comm,
1089 .mmap = perf_event__process_mmap,
1090 .mmap2 = perf_event__process_mmap2,
1091 .ordered_events = true,
1095 const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
1096 "\n\t\t\t\tDefault: fp";
1099 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
1100 * with it and switch to use the library functions in perf_evlist that came
1101 * from builtin-record.c, i.e. use record_opts,
1102 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
1105 struct option __record_options[] = {
1106 OPT_CALLBACK('e', "event", &record.evlist, "event",
1107 "event selector. use 'perf list' to list available events",
1108 parse_events_option),
1109 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
1110 "event filter", parse_filter),
1111 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
1112 NULL, "don't record events from perf itself",
1114 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
1115 "record events on existing process id"),
1116 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
1117 "record events on existing thread id"),
1118 OPT_INTEGER('r', "realtime", &record.realtime_prio,
1119 "collect data with this RT SCHED_FIFO priority"),
1120 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
1121 "collect data without buffering"),
1122 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
1123 "collect raw sample records from all opened counters"),
1124 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
1125 "system-wide collection from all CPUs"),
1126 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
1127 "list of cpus to monitor"),
1128 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
1129 OPT_STRING('o', "output", &record.file.path, "file",
1130 "output file name"),
1131 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1132 &record.opts.no_inherit_set,
1133 "child tasks do not inherit counters"),
1134 OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
1135 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1136 "number of mmap data pages and AUX area tracing mmap pages",
1137 record__parse_mmap_pages),
1138 OPT_BOOLEAN(0, "group", &record.opts.group,
1139 "put the counters into a counter group"),
1140 OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
1141 NULL, "enables call-graph recording" ,
1142 &record_callchain_opt),
1143 OPT_CALLBACK(0, "call-graph", &record.opts,
1144 "record_mode[,record_size]", record_callchain_help,
1145 &record_parse_callchain_opt),
1146 OPT_INCR('v', "verbose", &verbose,
1147 "be more verbose (show counter open errors, etc)"),
1148 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
1149 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
1150 "per thread counts"),
1151 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
1152 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
1153 &record.opts.sample_time_set,
1154 "Record the sample timestamps"),
1155 OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
1156 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
1158 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
1159 &record.no_buildid_cache_set,
1160 "do not update the buildid cache"),
1161 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
1162 &record.no_buildid_set,
1163 "do not collect buildids in perf.data"),
1164 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
1165 "monitor event in cgroup name only",
1167 OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
1168 "ms to wait before starting measurement after program start"),
1169 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1172 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1173 "branch any", "sample any taken branches",
1174 parse_branch_stack),
1176 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1177 "branch filter mask", "branch stack filter modes",
1178 parse_branch_stack),
1179 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1180 "sample by weight (on special events only)"),
1181 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1182 "sample transaction flags (special events only)"),
1183 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1184 "use per-thread mmaps"),
1185 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
1186 "sample selected machine registers on interrupt,"
1187 " use -I ? to list register names", parse_regs),
1188 OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1189 "Record running/enabled time of read (:S) events"),
1190 OPT_CALLBACK('k', "clockid", &record.opts,
1191 "clockid", "clockid to use for events, see clock_gettime()",
1193 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1194 "opts", "AUX area tracing Snapshot Mode", ""),
1195 OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
1196 "per thread proc mmap processing timeout in ms"),
1197 OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
1198 "Record context switch events"),
1199 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
1200 "Configure all used events to run in kernel space.",
1201 PARSE_OPT_EXCLUSIVE),
1202 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
1203 "Configure all used events to run in user space.",
1204 PARSE_OPT_EXCLUSIVE),
1205 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
1206 "clang binary to use for compiling BPF scriptlets"),
1207 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
1208 "options passed to clang when compiling BPF scriptlets"),
1209 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
1210 "file", "vmlinux pathname"),
1211 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
1212 "Record build-id of all DSOs regardless of hits"),
1216 struct option *record_options = __record_options;
1218 int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
1221 struct record *rec = &record;
1222 char errbuf[BUFSIZ];
1224 #ifndef HAVE_LIBBPF_SUPPORT
1225 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
1226 set_nobuild('\0', "clang-path", true);
1227 set_nobuild('\0', "clang-opt", true);
1231 #ifndef HAVE_BPF_PROLOGUE
1232 # if !defined (HAVE_DWARF_SUPPORT)
1233 # define REASON "NO_DWARF=1"
1234 # elif !defined (HAVE_LIBBPF_SUPPORT)
1235 # define REASON "NO_LIBBPF=1"
1237 # define REASON "this architecture doesn't support BPF prologue"
1239 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
1240 set_nobuild('\0', "vmlinux", true);
1245 rec->evlist = perf_evlist__new();
1246 if (rec->evlist == NULL)
1249 perf_config(perf_record_config, rec);
1251 argc = parse_options(argc, argv, record_options, record_usage,
1252 PARSE_OPT_STOP_AT_NON_OPTION);
1253 if (!argc && target__none(&rec->opts.target))
1254 usage_with_options(record_usage, record_options);
1256 if (nr_cgroups && !rec->opts.target.system_wide) {
1257 usage_with_options_msg(record_usage, record_options,
1258 "cgroup monitoring only available in system-wide mode");
1261 if (rec->opts.record_switch_events &&
1262 !perf_can_record_switch_events()) {
1263 ui__error("kernel does not support recording context switch events\n");
1264 parse_options_usage(record_usage, record_options, "switch-events", 0);
1269 rec->itr = auxtrace_record__init(rec->evlist, &err);
1274 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1275 rec->opts.auxtrace_snapshot_opts);
1283 if (symbol_conf.kptr_restrict)
1285 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
1286 "check /proc/sys/kernel/kptr_restrict.\n\n"
1287 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
1288 "file is not found in the buildid cache or in the vmlinux path.\n\n"
1289 "Samples in kernel modules won't be resolved at all.\n\n"
1290 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
1291 "even with a suitable vmlinux or kallsyms file.\n\n");
1293 if (rec->no_buildid_cache || rec->no_buildid)
1294 disable_buildid_cache();
1296 if (rec->evlist->nr_entries == 0 &&
1297 perf_evlist__add_default(rec->evlist) < 0) {
1298 pr_err("Not enough memory for event selector list\n");
1299 goto out_symbol_exit;
1302 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1303 rec->opts.no_inherit = true;
1305 err = target__validate(&rec->opts.target);
1307 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1308 ui__warning("%s", errbuf);
1311 err = target__parse_uid(&rec->opts.target);
1313 int saved_errno = errno;
1315 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1316 ui__error("%s", errbuf);
1319 goto out_symbol_exit;
1323 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1324 usage_with_options(record_usage, record_options);
1326 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
1328 goto out_symbol_exit;
1331 * We take all buildids when the file contains
1332 * AUX area tracing data because we do not decode the
1333 * trace because it would take too long.
1335 if (rec->opts.full_auxtrace)
1336 rec->buildid_all = true;
1338 if (record_opts__config(&rec->opts)) {
1340 goto out_symbol_exit;
1343 err = __cmd_record(&record, argc, argv);
1345 perf_evlist__delete(rec->evlist);
1347 auxtrace_record__free(rec->itr);
1351 static void snapshot_sig_handler(int sig __maybe_unused)
1353 if (!auxtrace_snapshot_enabled)
1355 auxtrace_snapshot_enabled = 0;
1356 auxtrace_snapshot_err = auxtrace_record__snapshot_start(record.itr);
1357 auxtrace_record__snapshot_started = 1;