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 "util/parse-options.h"
15 #include "util/parse-events.h"
17 #include "util/header.h"
18 #include "util/event.h"
19 #include "util/evlist.h"
20 #include "util/evsel.h"
21 #include "util/debug.h"
22 #include "util/session.h"
23 #include "util/tool.h"
24 #include "util/symbol.h"
25 #include "util/cpumap.h"
26 #include "util/thread_map.h"
27 #include "util/data.h"
35 struct perf_tool tool;
36 struct record_opts opts;
38 struct perf_data_file file;
39 struct perf_evlist *evlist;
40 struct perf_session *session;
44 bool no_buildid_cache;
48 static int record__write(struct record *rec, void *bf, size_t size)
50 if (perf_data_file__write(rec->session->file, bf, size) < 0) {
51 pr_err("failed to write perf data, error: %m\n");
55 rec->bytes_written += size;
59 static int process_synthesized_event(struct perf_tool *tool,
60 union perf_event *event,
61 struct perf_sample *sample __maybe_unused,
62 struct machine *machine __maybe_unused)
64 struct record *rec = container_of(tool, struct record, tool);
65 return record__write(rec, event, event->header.size);
68 static int record__mmap_read(struct record *rec, struct perf_mmap *md)
70 unsigned int head = perf_mmap__read_head(md);
71 unsigned int old = md->prev;
72 unsigned char *data = md->base + page_size;
84 if ((old & md->mask) + size != (head & md->mask)) {
85 buf = &data[old & md->mask];
86 size = md->mask + 1 - (old & md->mask);
89 if (record__write(rec, buf, size) < 0) {
95 buf = &data[old & md->mask];
99 if (record__write(rec, buf, size) < 0) {
105 perf_mmap__write_tail(md, old);
111 static volatile int done = 0;
112 static volatile int signr = -1;
113 static volatile int child_finished = 0;
115 static void sig_handler(int sig)
125 static void record__sig_exit(void)
130 signal(signr, SIG_DFL);
134 static int record__open(struct record *rec)
137 struct perf_evsel *pos;
138 struct perf_evlist *evlist = rec->evlist;
139 struct perf_session *session = rec->session;
140 struct record_opts *opts = &rec->opts;
143 perf_evlist__config(evlist, opts);
145 evlist__for_each(evlist, pos) {
147 if (perf_evsel__open(pos, evlist->cpus, evlist->threads) < 0) {
148 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
150 ui__warning("%s\n", msg);
155 perf_evsel__open_strerror(pos, &opts->target,
156 errno, msg, sizeof(msg));
157 ui__error("%s\n", msg);
162 if (perf_evlist__apply_filters(evlist)) {
163 error("failed to set filter with %d (%s)\n", errno,
169 if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
170 if (errno == EPERM) {
171 pr_err("Permission error mapping pages.\n"
172 "Consider increasing "
173 "/proc/sys/kernel/perf_event_mlock_kb,\n"
174 "or try again with a smaller value of -m/--mmap_pages.\n"
175 "(current value: %u)\n", opts->mmap_pages);
178 pr_err("failed to mmap with %d (%s)\n", errno, strerror(errno));
184 session->evlist = evlist;
185 perf_session__set_id_hdr_size(session);
190 static int process_buildids(struct record *rec)
192 struct perf_data_file *file = &rec->file;
193 struct perf_session *session = rec->session;
194 u64 start = session->header.data_offset;
196 u64 size = lseek(file->fd, 0, SEEK_CUR);
200 return __perf_session__process_events(session, start,
202 size, &build_id__mark_dso_hit_ops);
205 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
208 struct perf_tool *tool = data;
210 *As for guest kernel when processing subcommand record&report,
211 *we arrange module mmap prior to guest kernel mmap and trigger
212 *a preload dso because default guest module symbols are loaded
213 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
214 *method is used to avoid symbol missing when the first addr is
215 *in module instead of in guest kernel.
217 err = perf_event__synthesize_modules(tool, process_synthesized_event,
220 pr_err("Couldn't record guest kernel [%d]'s reference"
221 " relocation symbol.\n", machine->pid);
224 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
225 * have no _text sometimes.
227 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
230 pr_err("Couldn't record guest kernel [%d]'s reference"
231 " relocation symbol.\n", machine->pid);
234 static struct perf_event_header finished_round_event = {
235 .size = sizeof(struct perf_event_header),
236 .type = PERF_RECORD_FINISHED_ROUND,
239 static int record__mmap_read_all(struct record *rec)
241 u64 bytes_written = rec->bytes_written;
245 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
246 if (rec->evlist->mmap[i].base) {
247 if (record__mmap_read(rec, &rec->evlist->mmap[i]) != 0) {
255 * Mark the round finished in case we wrote
256 * at least one event.
258 if (bytes_written != rec->bytes_written)
259 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
265 static void record__init_features(struct record *rec)
267 struct perf_session *session = rec->session;
270 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
271 perf_header__set_feat(&session->header, feat);
274 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
276 if (!have_tracepoints(&rec->evlist->entries))
277 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
279 if (!rec->opts.branch_stack)
280 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
283 static volatile int workload_exec_errno;
286 * perf_evlist__prepare_workload will send a SIGUSR1
287 * if the fork fails, since we asked by setting its
288 * want_signal to true.
290 static void workload_exec_failed_signal(int signo __maybe_unused,
292 void *ucontext __maybe_unused)
294 workload_exec_errno = info->si_value.sival_int;
299 static int __cmd_record(struct record *rec, int argc, const char **argv)
303 unsigned long waking = 0;
304 const bool forks = argc > 0;
305 struct machine *machine;
306 struct perf_tool *tool = &rec->tool;
307 struct record_opts *opts = &rec->opts;
308 struct perf_data_file *file = &rec->file;
309 struct perf_session *session;
310 bool disabled = false;
312 rec->progname = argv[0];
314 atexit(record__sig_exit);
315 signal(SIGCHLD, sig_handler);
316 signal(SIGINT, sig_handler);
317 signal(SIGTERM, sig_handler);
319 session = perf_session__new(file, false, NULL);
320 if (session == NULL) {
321 pr_err("Perf session creation failed.\n");
325 rec->session = session;
327 record__init_features(rec);
330 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
332 workload_exec_failed_signal);
334 pr_err("Couldn't run the workload!\n");
336 goto out_delete_session;
340 if (record__open(rec) != 0) {
345 if (!rec->evlist->nr_groups)
346 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
349 err = perf_header__write_pipe(file->fd);
353 err = perf_session__write_header(session, rec->evlist,
360 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
361 pr_err("Couldn't generate buildids. "
362 "Use --no-buildid to profile anyway.\n");
367 machine = &session->machines.host;
370 err = perf_event__synthesize_attrs(tool, session,
371 process_synthesized_event);
373 pr_err("Couldn't synthesize attrs.\n");
377 if (have_tracepoints(&rec->evlist->entries)) {
379 * FIXME err <= 0 here actually means that
380 * there were no tracepoints so its not really
381 * an error, just that we don't need to
382 * synthesize anything. We really have to
383 * return this more properly and also
384 * propagate errors that now are calling die()
386 err = perf_event__synthesize_tracing_data(tool, file->fd, rec->evlist,
387 process_synthesized_event);
389 pr_err("Couldn't record tracing data.\n");
392 rec->bytes_written += err;
396 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
399 pr_err("Couldn't record kernel reference relocation symbol\n"
400 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
401 "Check /proc/kallsyms permission or run as root.\n");
403 err = perf_event__synthesize_modules(tool, process_synthesized_event,
406 pr_err("Couldn't record kernel module information.\n"
407 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
408 "Check /proc/modules permission or run as root.\n");
411 machines__process_guests(&session->machines,
412 perf_event__synthesize_guest_os, tool);
415 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
416 process_synthesized_event, opts->sample_address);
420 if (rec->realtime_prio) {
421 struct sched_param param;
423 param.sched_priority = rec->realtime_prio;
424 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) {
425 pr_err("Could not set realtime priority.\n");
432 * When perf is starting the traced process, all the events
433 * (apart from group members) have enable_on_exec=1 set,
434 * so don't spoil it by prematurely enabling them.
436 if (!target__none(&opts->target) && !opts->initial_delay)
437 perf_evlist__enable(rec->evlist);
443 perf_evlist__start_workload(rec->evlist);
445 if (opts->initial_delay) {
446 usleep(opts->initial_delay * 1000);
447 perf_evlist__enable(rec->evlist);
451 int hits = rec->samples;
453 if (record__mmap_read_all(rec) < 0) {
458 if (hits == rec->samples) {
461 err = poll(rec->evlist->pollfd, rec->evlist->nr_fds, -1);
463 * Propagate error, only if there's any. Ignore positive
464 * number of returned events and interrupt error.
466 if (err > 0 || (err < 0 && errno == EINTR))
472 * When perf is starting the traced process, at the end events
473 * die with the process and we wait for that. Thus no need to
474 * disable events in this case.
476 if (done && !disabled && !target__none(&opts->target)) {
477 perf_evlist__disable(rec->evlist);
482 if (forks && workload_exec_errno) {
484 const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
485 pr_err("Workload failed: %s\n", emsg);
491 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
494 * Approximate RIP event size: 24 bytes.
497 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
498 (double)rec->bytes_written / 1024.0 / 1024.0,
500 rec->bytes_written / 24);
508 kill(rec->evlist->workload.pid, SIGTERM);
514 else if (WIFEXITED(exit_status))
515 status = WEXITSTATUS(exit_status);
516 else if (WIFSIGNALED(exit_status))
517 signr = WTERMSIG(exit_status);
521 if (!err && !file->is_pipe) {
522 rec->session->header.data_size += rec->bytes_written;
524 if (!rec->no_buildid)
525 process_buildids(rec);
526 perf_session__write_header(rec->session, rec->evlist,
531 perf_session__delete(session);
535 #define BRANCH_OPT(n, m) \
536 { .name = n, .mode = (m) }
538 #define BRANCH_END { .name = NULL }
545 static const struct branch_mode branch_modes[] = {
546 BRANCH_OPT("u", PERF_SAMPLE_BRANCH_USER),
547 BRANCH_OPT("k", PERF_SAMPLE_BRANCH_KERNEL),
548 BRANCH_OPT("hv", PERF_SAMPLE_BRANCH_HV),
549 BRANCH_OPT("any", PERF_SAMPLE_BRANCH_ANY),
550 BRANCH_OPT("any_call", PERF_SAMPLE_BRANCH_ANY_CALL),
551 BRANCH_OPT("any_ret", PERF_SAMPLE_BRANCH_ANY_RETURN),
552 BRANCH_OPT("ind_call", PERF_SAMPLE_BRANCH_IND_CALL),
553 BRANCH_OPT("abort_tx", PERF_SAMPLE_BRANCH_ABORT_TX),
554 BRANCH_OPT("in_tx", PERF_SAMPLE_BRANCH_IN_TX),
555 BRANCH_OPT("no_tx", PERF_SAMPLE_BRANCH_NO_TX),
556 BRANCH_OPT("cond", PERF_SAMPLE_BRANCH_COND),
561 parse_branch_stack(const struct option *opt, const char *str, int unset)
564 (PERF_SAMPLE_BRANCH_USER |\
565 PERF_SAMPLE_BRANCH_KERNEL |\
566 PERF_SAMPLE_BRANCH_HV)
568 uint64_t *mode = (uint64_t *)opt->value;
569 const struct branch_mode *br;
570 char *s, *os = NULL, *p;
577 * cannot set it twice, -b + --branch-filter for instance
582 /* str may be NULL in case no arg is passed to -b */
584 /* because str is read-only */
585 s = os = strdup(str);
594 for (br = branch_modes; br->name; br++) {
595 if (!strcasecmp(s, br->name))
599 ui__warning("unknown branch filter %s,"
600 " check man page\n", s);
614 /* default to any branch */
615 if ((*mode & ~ONLY_PLM) == 0) {
616 *mode = PERF_SAMPLE_BRANCH_ANY;
623 #ifdef HAVE_DWARF_UNWIND_SUPPORT
624 static int get_stack_size(char *str, unsigned long *_size)
628 unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
630 size = strtoul(str, &endptr, 0);
636 size = round_up(size, sizeof(u64));
637 if (!size || size > max_size)
645 pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
649 #endif /* HAVE_DWARF_UNWIND_SUPPORT */
651 int record_parse_callchain(const char *arg, struct record_opts *opts)
653 char *tok, *name, *saveptr = NULL;
657 /* We need buffer that we know we can write to. */
658 buf = malloc(strlen(arg) + 1);
664 tok = strtok_r((char *)buf, ",", &saveptr);
665 name = tok ? : (char *)buf;
668 /* Framepointer style */
669 if (!strncmp(name, "fp", sizeof("fp"))) {
670 if (!strtok_r(NULL, ",", &saveptr)) {
671 opts->call_graph = CALLCHAIN_FP;
674 pr_err("callchain: No more arguments "
675 "needed for -g fp\n");
678 #ifdef HAVE_DWARF_UNWIND_SUPPORT
680 } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
681 const unsigned long default_stack_dump_size = 8192;
684 opts->call_graph = CALLCHAIN_DWARF;
685 opts->stack_dump_size = default_stack_dump_size;
687 tok = strtok_r(NULL, ",", &saveptr);
689 unsigned long size = 0;
691 ret = get_stack_size(tok, &size);
692 opts->stack_dump_size = size;
694 #endif /* HAVE_DWARF_UNWIND_SUPPORT */
696 pr_err("callchain: Unknown --call-graph option "
707 static void callchain_debug(struct record_opts *opts)
709 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF" };
711 pr_debug("callchain: type %s\n", str[opts->call_graph]);
713 if (opts->call_graph == CALLCHAIN_DWARF)
714 pr_debug("callchain: stack dump size %d\n",
715 opts->stack_dump_size);
718 int record_parse_callchain_opt(const struct option *opt,
722 struct record_opts *opts = opt->value;
725 opts->call_graph_enabled = !unset;
727 /* --no-call-graph */
729 opts->call_graph = CALLCHAIN_NONE;
730 pr_debug("callchain: disabled\n");
734 ret = record_parse_callchain(arg, opts);
736 callchain_debug(opts);
741 int record_callchain_opt(const struct option *opt,
742 const char *arg __maybe_unused,
743 int unset __maybe_unused)
745 struct record_opts *opts = opt->value;
747 opts->call_graph_enabled = !unset;
749 if (opts->call_graph == CALLCHAIN_NONE)
750 opts->call_graph = CALLCHAIN_FP;
752 callchain_debug(opts);
756 static int perf_record_config(const char *var, const char *value, void *cb)
758 struct record *rec = cb;
760 if (!strcmp(var, "record.call-graph"))
761 return record_parse_callchain(value, &rec->opts);
763 return perf_default_config(var, value, cb);
766 static const char * const record_usage[] = {
767 "perf record [<options>] [<command>]",
768 "perf record [<options>] -- <command> [<options>]",
773 * XXX Ideally would be local to cmd_record() and passed to a record__new
774 * because we need to have access to it in record__exit, that is called
775 * after cmd_record() exits, but since record_options need to be accessible to
776 * builtin-script, leave it here.
778 * At least we don't ouch it in all the other functions here directly.
780 * Just say no to tons of global variables, sigh.
782 static struct record record = {
784 .mmap_pages = UINT_MAX,
785 .user_freq = UINT_MAX,
786 .user_interval = ULLONG_MAX,
790 .default_per_cpu = true,
795 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
797 #ifdef HAVE_DWARF_UNWIND_SUPPORT
798 const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf";
800 const char record_callchain_help[] = CALLCHAIN_HELP "fp";
804 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
805 * with it and switch to use the library functions in perf_evlist that came
806 * from builtin-record.c, i.e. use record_opts,
807 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
810 const struct option record_options[] = {
811 OPT_CALLBACK('e', "event", &record.evlist, "event",
812 "event selector. use 'perf list' to list available events",
813 parse_events_option),
814 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
815 "event filter", parse_filter),
816 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
817 "record events on existing process id"),
818 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
819 "record events on existing thread id"),
820 OPT_INTEGER('r', "realtime", &record.realtime_prio,
821 "collect data with this RT SCHED_FIFO priority"),
822 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
823 "collect data without buffering"),
824 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
825 "collect raw sample records from all opened counters"),
826 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
827 "system-wide collection from all CPUs"),
828 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
829 "list of cpus to monitor"),
830 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
831 OPT_STRING('o', "output", &record.file.path, "file",
833 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
834 &record.opts.no_inherit_set,
835 "child tasks do not inherit counters"),
836 OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
837 OPT_CALLBACK('m', "mmap-pages", &record.opts.mmap_pages, "pages",
838 "number of mmap data pages",
839 perf_evlist__parse_mmap_pages),
840 OPT_BOOLEAN(0, "group", &record.opts.group,
841 "put the counters into a counter group"),
842 OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
843 NULL, "enables call-graph recording" ,
844 &record_callchain_opt),
845 OPT_CALLBACK(0, "call-graph", &record.opts,
846 "mode[,dump_size]", record_callchain_help,
847 &record_parse_callchain_opt),
848 OPT_INCR('v', "verbose", &verbose,
849 "be more verbose (show counter open errors, etc)"),
850 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
851 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
852 "per thread counts"),
853 OPT_BOOLEAN('d', "data", &record.opts.sample_address,
855 OPT_BOOLEAN('T', "timestamp", &record.opts.sample_time, "Sample timestamps"),
856 OPT_BOOLEAN('P', "period", &record.opts.period, "Sample period"),
857 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
859 OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
860 "do not update the buildid cache"),
861 OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
862 "do not collect buildids in perf.data"),
863 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
864 "monitor event in cgroup name only",
866 OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
867 "ms to wait before starting measurement after program start"),
868 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
871 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
872 "branch any", "sample any taken branches",
875 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
876 "branch filter mask", "branch stack filter modes",
878 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
879 "sample by weight (on special events only)"),
880 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
881 "sample transaction flags (special events only)"),
882 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
883 "use per-thread mmaps"),
887 int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
890 struct record *rec = &record;
893 rec->evlist = perf_evlist__new();
894 if (rec->evlist == NULL)
897 perf_config(perf_record_config, rec);
899 argc = parse_options(argc, argv, record_options, record_usage,
900 PARSE_OPT_STOP_AT_NON_OPTION);
901 if (!argc && target__none(&rec->opts.target))
902 usage_with_options(record_usage, record_options);
904 if (nr_cgroups && !rec->opts.target.system_wide) {
905 ui__error("cgroup monitoring only available in"
906 " system-wide mode\n");
907 usage_with_options(record_usage, record_options);
912 if (symbol_conf.kptr_restrict)
914 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
915 "check /proc/sys/kernel/kptr_restrict.\n\n"
916 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
917 "file is not found in the buildid cache or in the vmlinux path.\n\n"
918 "Samples in kernel modules won't be resolved at all.\n\n"
919 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
920 "even with a suitable vmlinux or kallsyms file.\n\n");
922 if (rec->no_buildid_cache || rec->no_buildid)
923 disable_buildid_cache();
925 if (rec->evlist->nr_entries == 0 &&
926 perf_evlist__add_default(rec->evlist) < 0) {
927 pr_err("Not enough memory for event selector list\n");
928 goto out_symbol_exit;
931 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
932 rec->opts.no_inherit = true;
934 err = target__validate(&rec->opts.target);
936 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
937 ui__warning("%s", errbuf);
940 err = target__parse_uid(&rec->opts.target);
942 int saved_errno = errno;
944 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
945 ui__error("%s", errbuf);
948 goto out_symbol_exit;
952 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
953 usage_with_options(record_usage, record_options);
955 if (record_opts__config(&rec->opts)) {
957 goto out_symbol_exit;
960 err = __cmd_record(&record, argc, argv);
962 perf_evlist__delete(rec->evlist);