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"
33 #ifndef HAVE_ON_EXIT_SUPPORT
37 static int __on_exit_count
= 0;
38 typedef void (*on_exit_func_t
) (int, void *);
39 static on_exit_func_t __on_exit_funcs
[ATEXIT_MAX
];
40 static void *__on_exit_args
[ATEXIT_MAX
];
41 static int __exitcode
= 0;
42 static void __handle_on_exit_funcs(void);
43 static int on_exit(on_exit_func_t function
, void *arg
);
44 #define exit(x) (exit)(__exitcode = (x))
46 static int on_exit(on_exit_func_t function
, void *arg
)
48 if (__on_exit_count
== ATEXIT_MAX
)
50 else if (__on_exit_count
== 0)
51 atexit(__handle_on_exit_funcs
);
52 __on_exit_funcs
[__on_exit_count
] = function
;
53 __on_exit_args
[__on_exit_count
++] = arg
;
57 static void __handle_on_exit_funcs(void)
60 for (i
= 0; i
< __on_exit_count
; i
++)
61 __on_exit_funcs
[i
] (__exitcode
, __on_exit_args
[i
]);
66 struct perf_tool tool
;
67 struct perf_record_opts opts
;
69 struct perf_data_file file
;
70 struct perf_evlist
*evlist
;
71 struct perf_session
*session
;
75 bool no_buildid_cache
;
79 static int do_write_output(struct perf_record
*rec
, void *buf
, size_t size
)
81 struct perf_data_file
*file
= &rec
->file
;
84 ssize_t ret
= write(file
->fd
, buf
, size
);
87 pr_err("failed to write perf data, error: %m\n");
94 rec
->bytes_written
+= ret
;
100 static int write_output(struct perf_record
*rec
, void *buf
, size_t size
)
102 return do_write_output(rec
, buf
, size
);
105 static int process_synthesized_event(struct perf_tool
*tool
,
106 union perf_event
*event
,
107 struct perf_sample
*sample __maybe_unused
,
108 struct machine
*machine __maybe_unused
)
110 struct perf_record
*rec
= container_of(tool
, struct perf_record
, tool
);
111 if (write_output(rec
, event
, event
->header
.size
) < 0)
117 static int perf_record__mmap_read(struct perf_record
*rec
,
118 struct perf_mmap
*md
)
120 unsigned int head
= perf_mmap__read_head(md
);
121 unsigned int old
= md
->prev
;
122 unsigned char *data
= md
->base
+ page_size
;
134 if ((old
& md
->mask
) + size
!= (head
& md
->mask
)) {
135 buf
= &data
[old
& md
->mask
];
136 size
= md
->mask
+ 1 - (old
& md
->mask
);
139 if (write_output(rec
, buf
, size
) < 0) {
145 buf
= &data
[old
& md
->mask
];
149 if (write_output(rec
, buf
, size
) < 0) {
155 perf_mmap__write_tail(md
, old
);
161 static volatile int done
= 0;
162 static volatile int signr
= -1;
163 static volatile int child_finished
= 0;
165 static void sig_handler(int sig
)
174 static void perf_record__sig_exit(int exit_status __maybe_unused
, void *arg
)
176 struct perf_record
*rec
= arg
;
179 if (rec
->evlist
->workload
.pid
> 0) {
181 kill(rec
->evlist
->workload
.pid
, SIGTERM
);
184 if (WIFSIGNALED(status
))
185 psignal(WTERMSIG(status
), rec
->progname
);
188 if (signr
== -1 || signr
== SIGUSR1
)
191 signal(signr
, SIG_DFL
);
194 static int perf_record__open(struct perf_record
*rec
)
197 struct perf_evsel
*pos
;
198 struct perf_evlist
*evlist
= rec
->evlist
;
199 struct perf_session
*session
= rec
->session
;
200 struct perf_record_opts
*opts
= &rec
->opts
;
203 perf_evlist__config(evlist
, opts
);
205 list_for_each_entry(pos
, &evlist
->entries
, node
) {
207 if (perf_evsel__open(pos
, evlist
->cpus
, evlist
->threads
) < 0) {
208 if (perf_evsel__fallback(pos
, errno
, msg
, sizeof(msg
))) {
210 ui__warning("%s\n", msg
);
215 perf_evsel__open_strerror(pos
, &opts
->target
,
216 errno
, msg
, sizeof(msg
));
217 ui__error("%s\n", msg
);
222 if (perf_evlist__apply_filters(evlist
)) {
223 error("failed to set filter with %d (%s)\n", errno
,
229 if (perf_evlist__mmap(evlist
, opts
->mmap_pages
, false) < 0) {
230 if (errno
== EPERM
) {
231 pr_err("Permission error mapping pages.\n"
232 "Consider increasing "
233 "/proc/sys/kernel/perf_event_mlock_kb,\n"
234 "or try again with a smaller value of -m/--mmap_pages.\n"
235 "(current value: %d)\n", opts
->mmap_pages
);
238 pr_err("failed to mmap with %d (%s)\n", errno
, strerror(errno
));
244 session
->evlist
= evlist
;
245 perf_session__set_id_hdr_size(session
);
250 static int process_buildids(struct perf_record
*rec
)
252 struct perf_data_file
*file
= &rec
->file
;
253 struct perf_session
*session
= rec
->session
;
254 u64 start
= session
->header
.data_offset
;
256 u64 size
= lseek(file
->fd
, 0, SEEK_CUR
);
260 return __perf_session__process_events(session
, start
,
262 size
, &build_id__mark_dso_hit_ops
);
265 static void perf_record__exit(int status
, void *arg
)
267 struct perf_record
*rec
= arg
;
268 struct perf_data_file
*file
= &rec
->file
;
273 if (!file
->is_pipe
) {
274 rec
->session
->header
.data_size
+= rec
->bytes_written
;
276 if (!rec
->no_buildid
)
277 process_buildids(rec
);
278 perf_session__write_header(rec
->session
, rec
->evlist
,
280 perf_session__delete(rec
->session
);
281 perf_evlist__delete(rec
->evlist
);
286 static void perf_event__synthesize_guest_os(struct machine
*machine
, void *data
)
289 struct perf_tool
*tool
= data
;
291 *As for guest kernel when processing subcommand record&report,
292 *we arrange module mmap prior to guest kernel mmap and trigger
293 *a preload dso because default guest module symbols are loaded
294 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
295 *method is used to avoid symbol missing when the first addr is
296 *in module instead of in guest kernel.
298 err
= perf_event__synthesize_modules(tool
, process_synthesized_event
,
301 pr_err("Couldn't record guest kernel [%d]'s reference"
302 " relocation symbol.\n", machine
->pid
);
305 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
306 * have no _text sometimes.
308 err
= perf_event__synthesize_kernel_mmap(tool
, process_synthesized_event
,
311 err
= perf_event__synthesize_kernel_mmap(tool
, process_synthesized_event
,
314 pr_err("Couldn't record guest kernel [%d]'s reference"
315 " relocation symbol.\n", machine
->pid
);
318 static struct perf_event_header finished_round_event
= {
319 .size
= sizeof(struct perf_event_header
),
320 .type
= PERF_RECORD_FINISHED_ROUND
,
323 static int perf_record__mmap_read_all(struct perf_record
*rec
)
328 for (i
= 0; i
< rec
->evlist
->nr_mmaps
; i
++) {
329 if (rec
->evlist
->mmap
[i
].base
) {
330 if (perf_record__mmap_read(rec
, &rec
->evlist
->mmap
[i
]) != 0) {
337 if (perf_header__has_feat(&rec
->session
->header
, HEADER_TRACING_DATA
))
338 rc
= write_output(rec
, &finished_round_event
,
339 sizeof(finished_round_event
));
345 static void perf_record__init_features(struct perf_record
*rec
)
347 struct perf_evlist
*evsel_list
= rec
->evlist
;
348 struct perf_session
*session
= rec
->session
;
351 for (feat
= HEADER_FIRST_FEATURE
; feat
< HEADER_LAST_FEATURE
; feat
++)
352 perf_header__set_feat(&session
->header
, feat
);
355 perf_header__clear_feat(&session
->header
, HEADER_BUILD_ID
);
357 if (!have_tracepoints(&evsel_list
->entries
))
358 perf_header__clear_feat(&session
->header
, HEADER_TRACING_DATA
);
360 if (!rec
->opts
.branch_stack
)
361 perf_header__clear_feat(&session
->header
, HEADER_BRANCH_STACK
);
364 static int __cmd_record(struct perf_record
*rec
, int argc
, const char **argv
)
367 unsigned long waking
= 0;
368 const bool forks
= argc
> 0;
369 struct machine
*machine
;
370 struct perf_tool
*tool
= &rec
->tool
;
371 struct perf_record_opts
*opts
= &rec
->opts
;
372 struct perf_evlist
*evsel_list
= rec
->evlist
;
373 struct perf_data_file
*file
= &rec
->file
;
374 struct perf_session
*session
;
375 bool disabled
= false;
377 rec
->progname
= argv
[0];
379 on_exit(perf_record__sig_exit
, rec
);
380 signal(SIGCHLD
, sig_handler
);
381 signal(SIGINT
, sig_handler
);
382 signal(SIGUSR1
, sig_handler
);
383 signal(SIGTERM
, sig_handler
);
385 session
= perf_session__new(file
, false, NULL
);
386 if (session
== NULL
) {
387 pr_err("Not enough memory for reading perf file header\n");
391 rec
->session
= session
;
393 perf_record__init_features(rec
);
396 err
= perf_evlist__prepare_workload(evsel_list
, &opts
->target
,
400 pr_err("Couldn't run the workload!\n");
401 goto out_delete_session
;
405 if (perf_record__open(rec
) != 0) {
407 goto out_delete_session
;
410 if (!evsel_list
->nr_groups
)
411 perf_header__clear_feat(&session
->header
, HEADER_GROUP_DESC
);
414 * perf_session__delete(session) will be called at perf_record__exit()
416 on_exit(perf_record__exit
, rec
);
419 err
= perf_header__write_pipe(file
->fd
);
421 goto out_delete_session
;
423 err
= perf_session__write_header(session
, evsel_list
,
426 goto out_delete_session
;
430 && !perf_header__has_feat(&session
->header
, HEADER_BUILD_ID
)) {
431 pr_err("Couldn't generate buildids. "
432 "Use --no-buildid to profile anyway.\n");
434 goto out_delete_session
;
437 machine
= &session
->machines
.host
;
440 err
= perf_event__synthesize_attrs(tool
, session
,
441 process_synthesized_event
);
443 pr_err("Couldn't synthesize attrs.\n");
444 goto out_delete_session
;
447 if (have_tracepoints(&evsel_list
->entries
)) {
449 * FIXME err <= 0 here actually means that
450 * there were no tracepoints so its not really
451 * an error, just that we don't need to
452 * synthesize anything. We really have to
453 * return this more properly and also
454 * propagate errors that now are calling die()
456 err
= perf_event__synthesize_tracing_data(tool
, file
->fd
, evsel_list
,
457 process_synthesized_event
);
459 pr_err("Couldn't record tracing data.\n");
460 goto out_delete_session
;
462 rec
->bytes_written
+= err
;
466 err
= perf_event__synthesize_kernel_mmap(tool
, process_synthesized_event
,
469 err
= perf_event__synthesize_kernel_mmap(tool
, process_synthesized_event
,
472 pr_err("Couldn't record kernel reference relocation symbol\n"
473 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
474 "Check /proc/kallsyms permission or run as root.\n");
476 err
= perf_event__synthesize_modules(tool
, process_synthesized_event
,
479 pr_err("Couldn't record kernel module information.\n"
480 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
481 "Check /proc/modules permission or run as root.\n");
484 machines__process_guests(&session
->machines
,
485 perf_event__synthesize_guest_os
, tool
);
488 err
= __machine__synthesize_threads(machine
, tool
, &opts
->target
, evsel_list
->threads
,
489 process_synthesized_event
, opts
->sample_address
);
491 goto out_delete_session
;
493 if (rec
->realtime_prio
) {
494 struct sched_param param
;
496 param
.sched_priority
= rec
->realtime_prio
;
497 if (sched_setscheduler(0, SCHED_FIFO
, ¶m
)) {
498 pr_err("Could not set realtime priority.\n");
500 goto out_delete_session
;
505 * When perf is starting the traced process, all the events
506 * (apart from group members) have enable_on_exec=1 set,
507 * so don't spoil it by prematurely enabling them.
509 if (!target__none(&opts
->target
))
510 perf_evlist__enable(evsel_list
);
516 perf_evlist__start_workload(evsel_list
);
519 int hits
= rec
->samples
;
521 if (perf_record__mmap_read_all(rec
) < 0) {
523 goto out_delete_session
;
526 if (hits
== rec
->samples
) {
529 err
= poll(evsel_list
->pollfd
, evsel_list
->nr_fds
, -1);
534 * When perf is starting the traced process, at the end events
535 * die with the process and we wait for that. Thus no need to
536 * disable events in this case.
538 if (done
&& !disabled
&& !target__none(&opts
->target
)) {
539 perf_evlist__disable(evsel_list
);
544 if (quiet
|| signr
== SIGUSR1
)
547 fprintf(stderr
, "[ perf record: Woken up %ld times to write data ]\n", waking
);
550 * Approximate RIP event size: 24 bytes.
553 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64
" samples) ]\n",
554 (double)rec
->bytes_written
/ 1024.0 / 1024.0,
556 rec
->bytes_written
/ 24);
561 perf_session__delete(session
);
565 #define BRANCH_OPT(n, m) \
566 { .name = n, .mode = (m) }
568 #define BRANCH_END { .name = NULL }
575 static const struct branch_mode branch_modes
[] = {
576 BRANCH_OPT("u", PERF_SAMPLE_BRANCH_USER
),
577 BRANCH_OPT("k", PERF_SAMPLE_BRANCH_KERNEL
),
578 BRANCH_OPT("hv", PERF_SAMPLE_BRANCH_HV
),
579 BRANCH_OPT("any", PERF_SAMPLE_BRANCH_ANY
),
580 BRANCH_OPT("any_call", PERF_SAMPLE_BRANCH_ANY_CALL
),
581 BRANCH_OPT("any_ret", PERF_SAMPLE_BRANCH_ANY_RETURN
),
582 BRANCH_OPT("ind_call", PERF_SAMPLE_BRANCH_IND_CALL
),
583 BRANCH_OPT("abort_tx", PERF_SAMPLE_BRANCH_ABORT_TX
),
584 BRANCH_OPT("in_tx", PERF_SAMPLE_BRANCH_IN_TX
),
585 BRANCH_OPT("no_tx", PERF_SAMPLE_BRANCH_NO_TX
),
590 parse_branch_stack(const struct option
*opt
, const char *str
, int unset
)
593 (PERF_SAMPLE_BRANCH_USER |\
594 PERF_SAMPLE_BRANCH_KERNEL |\
595 PERF_SAMPLE_BRANCH_HV)
597 uint64_t *mode
= (uint64_t *)opt
->value
;
598 const struct branch_mode
*br
;
599 char *s
, *os
= NULL
, *p
;
606 * cannot set it twice, -b + --branch-filter for instance
611 /* str may be NULL in case no arg is passed to -b */
613 /* because str is read-only */
614 s
= os
= strdup(str
);
623 for (br
= branch_modes
; br
->name
; br
++) {
624 if (!strcasecmp(s
, br
->name
))
628 ui__warning("unknown branch filter %s,"
629 " check man page\n", s
);
643 /* default to any branch */
644 if ((*mode
& ~ONLY_PLM
) == 0) {
645 *mode
= PERF_SAMPLE_BRANCH_ANY
;
652 #ifdef HAVE_LIBUNWIND_SUPPORT
653 static int get_stack_size(char *str
, unsigned long *_size
)
657 unsigned long max_size
= round_down(USHRT_MAX
, sizeof(u64
));
659 size
= strtoul(str
, &endptr
, 0);
665 size
= round_up(size
, sizeof(u64
));
666 if (!size
|| size
> max_size
)
674 pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
678 #endif /* HAVE_LIBUNWIND_SUPPORT */
680 int record_parse_callchain(const char *arg
, struct perf_record_opts
*opts
)
682 char *tok
, *name
, *saveptr
= NULL
;
686 /* We need buffer that we know we can write to. */
687 buf
= malloc(strlen(arg
) + 1);
693 tok
= strtok_r((char *)buf
, ",", &saveptr
);
694 name
= tok
? : (char *)buf
;
697 /* Framepointer style */
698 if (!strncmp(name
, "fp", sizeof("fp"))) {
699 if (!strtok_r(NULL
, ",", &saveptr
)) {
700 opts
->call_graph
= CALLCHAIN_FP
;
703 pr_err("callchain: No more arguments "
704 "needed for -g fp\n");
707 #ifdef HAVE_LIBUNWIND_SUPPORT
709 } else if (!strncmp(name
, "dwarf", sizeof("dwarf"))) {
710 const unsigned long default_stack_dump_size
= 8192;
713 opts
->call_graph
= CALLCHAIN_DWARF
;
714 opts
->stack_dump_size
= default_stack_dump_size
;
716 tok
= strtok_r(NULL
, ",", &saveptr
);
718 unsigned long size
= 0;
720 ret
= get_stack_size(tok
, &size
);
721 opts
->stack_dump_size
= size
;
723 #endif /* HAVE_LIBUNWIND_SUPPORT */
725 pr_err("callchain: Unknown --call-graph option "
736 static void callchain_debug(struct perf_record_opts
*opts
)
738 pr_debug("callchain: type %d\n", opts
->call_graph
);
740 if (opts
->call_graph
== CALLCHAIN_DWARF
)
741 pr_debug("callchain: stack dump size %d\n",
742 opts
->stack_dump_size
);
745 int record_parse_callchain_opt(const struct option
*opt
,
749 struct perf_record_opts
*opts
= opt
->value
;
752 /* --no-call-graph */
754 opts
->call_graph
= CALLCHAIN_NONE
;
755 pr_debug("callchain: disabled\n");
759 ret
= record_parse_callchain(arg
, opts
);
761 callchain_debug(opts
);
766 int record_callchain_opt(const struct option
*opt
,
767 const char *arg __maybe_unused
,
768 int unset __maybe_unused
)
770 struct perf_record_opts
*opts
= opt
->value
;
772 if (opts
->call_graph
== CALLCHAIN_NONE
)
773 opts
->call_graph
= CALLCHAIN_FP
;
775 callchain_debug(opts
);
779 static const char * const record_usage
[] = {
780 "perf record [<options>] [<command>]",
781 "perf record [<options>] -- <command> [<options>]",
786 * XXX Ideally would be local to cmd_record() and passed to a perf_record__new
787 * because we need to have access to it in perf_record__exit, that is called
788 * after cmd_record() exits, but since record_options need to be accessible to
789 * builtin-script, leave it here.
791 * At least we don't ouch it in all the other functions here directly.
793 * Just say no to tons of global variables, sigh.
795 static struct perf_record record
= {
797 .mmap_pages
= UINT_MAX
,
798 .user_freq
= UINT_MAX
,
799 .user_interval
= ULLONG_MAX
,
807 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
809 #ifdef HAVE_LIBUNWIND_SUPPORT
810 const char record_callchain_help
[] = CALLCHAIN_HELP
"fp dwarf";
812 const char record_callchain_help
[] = CALLCHAIN_HELP
"fp";
816 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
817 * with it and switch to use the library functions in perf_evlist that came
818 * from builtin-record.c, i.e. use perf_record_opts,
819 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
822 const struct option record_options
[] = {
823 OPT_CALLBACK('e', "event", &record
.evlist
, "event",
824 "event selector. use 'perf list' to list available events",
825 parse_events_option
),
826 OPT_CALLBACK(0, "filter", &record
.evlist
, "filter",
827 "event filter", parse_filter
),
828 OPT_STRING('p', "pid", &record
.opts
.target
.pid
, "pid",
829 "record events on existing process id"),
830 OPT_STRING('t', "tid", &record
.opts
.target
.tid
, "tid",
831 "record events on existing thread id"),
832 OPT_INTEGER('r', "realtime", &record
.realtime_prio
,
833 "collect data with this RT SCHED_FIFO priority"),
834 OPT_BOOLEAN('D', "no-delay", &record
.opts
.no_delay
,
835 "collect data without buffering"),
836 OPT_BOOLEAN('R', "raw-samples", &record
.opts
.raw_samples
,
837 "collect raw sample records from all opened counters"),
838 OPT_BOOLEAN('a', "all-cpus", &record
.opts
.target
.system_wide
,
839 "system-wide collection from all CPUs"),
840 OPT_STRING('C', "cpu", &record
.opts
.target
.cpu_list
, "cpu",
841 "list of cpus to monitor"),
842 OPT_U64('c', "count", &record
.opts
.user_interval
, "event period to sample"),
843 OPT_STRING('o', "output", &record
.file
.path
, "file",
845 OPT_BOOLEAN('i', "no-inherit", &record
.opts
.no_inherit
,
846 "child tasks do not inherit counters"),
847 OPT_UINTEGER('F', "freq", &record
.opts
.user_freq
, "profile at this frequency"),
848 OPT_CALLBACK('m', "mmap-pages", &record
.opts
.mmap_pages
, "pages",
849 "number of mmap data pages",
850 perf_evlist__parse_mmap_pages
),
851 OPT_BOOLEAN(0, "group", &record
.opts
.group
,
852 "put the counters into a counter group"),
853 OPT_CALLBACK_NOOPT('g', NULL
, &record
.opts
,
854 NULL
, "enables call-graph recording" ,
855 &record_callchain_opt
),
856 OPT_CALLBACK(0, "call-graph", &record
.opts
,
857 "mode[,dump_size]", record_callchain_help
,
858 &record_parse_callchain_opt
),
859 OPT_INCR('v', "verbose", &verbose
,
860 "be more verbose (show counter open errors, etc)"),
861 OPT_BOOLEAN('q', "quiet", &quiet
, "don't print any message"),
862 OPT_BOOLEAN('s', "stat", &record
.opts
.inherit_stat
,
863 "per thread counts"),
864 OPT_BOOLEAN('d', "data", &record
.opts
.sample_address
,
866 OPT_BOOLEAN('T', "timestamp", &record
.opts
.sample_time
, "Sample timestamps"),
867 OPT_BOOLEAN('P', "period", &record
.opts
.period
, "Sample period"),
868 OPT_BOOLEAN('n', "no-samples", &record
.opts
.no_samples
,
870 OPT_BOOLEAN('N', "no-buildid-cache", &record
.no_buildid_cache
,
871 "do not update the buildid cache"),
872 OPT_BOOLEAN('B', "no-buildid", &record
.no_buildid
,
873 "do not collect buildids in perf.data"),
874 OPT_CALLBACK('G', "cgroup", &record
.evlist
, "name",
875 "monitor event in cgroup name only",
877 OPT_STRING('u', "uid", &record
.opts
.target
.uid_str
, "user",
880 OPT_CALLBACK_NOOPT('b', "branch-any", &record
.opts
.branch_stack
,
881 "branch any", "sample any taken branches",
884 OPT_CALLBACK('j', "branch-filter", &record
.opts
.branch_stack
,
885 "branch filter mask", "branch stack filter modes",
887 OPT_BOOLEAN('W', "weight", &record
.opts
.sample_weight
,
888 "sample by weight (on special events only)"),
889 OPT_BOOLEAN(0, "transaction", &record
.opts
.sample_transaction
,
890 "sample transaction flags (special events only)"),
891 OPT_BOOLEAN(0, "force-per-cpu", &record
.opts
.target
.force_per_cpu
,
892 "force the use of per-cpu mmaps"),
896 int cmd_record(int argc
, const char **argv
, const char *prefix __maybe_unused
)
899 struct perf_evlist
*evsel_list
;
900 struct perf_record
*rec
= &record
;
903 evsel_list
= perf_evlist__new();
904 if (evsel_list
== NULL
)
907 rec
->evlist
= evsel_list
;
909 argc
= parse_options(argc
, argv
, record_options
, record_usage
,
910 PARSE_OPT_STOP_AT_NON_OPTION
);
911 if (!argc
&& target__none(&rec
->opts
.target
))
912 usage_with_options(record_usage
, record_options
);
914 if (nr_cgroups
&& !rec
->opts
.target
.system_wide
) {
915 ui__error("cgroup monitoring only available in"
916 " system-wide mode\n");
917 usage_with_options(record_usage
, record_options
);
922 if (symbol_conf
.kptr_restrict
)
924 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
925 "check /proc/sys/kernel/kptr_restrict.\n\n"
926 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
927 "file is not found in the buildid cache or in the vmlinux path.\n\n"
928 "Samples in kernel modules won't be resolved at all.\n\n"
929 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
930 "even with a suitable vmlinux or kallsyms file.\n\n");
932 if (rec
->no_buildid_cache
|| rec
->no_buildid
)
933 disable_buildid_cache();
935 if (evsel_list
->nr_entries
== 0 &&
936 perf_evlist__add_default(evsel_list
) < 0) {
937 pr_err("Not enough memory for event selector list\n");
938 goto out_symbol_exit
;
941 err
= target__validate(&rec
->opts
.target
);
943 target__strerror(&rec
->opts
.target
, err
, errbuf
, BUFSIZ
);
944 ui__warning("%s", errbuf
);
947 err
= target__parse_uid(&rec
->opts
.target
);
949 int saved_errno
= errno
;
951 target__strerror(&rec
->opts
.target
, err
, errbuf
, BUFSIZ
);
952 ui__error("%s", errbuf
);
955 goto out_symbol_exit
;
959 if (perf_evlist__create_maps(evsel_list
, &rec
->opts
.target
) < 0)
960 usage_with_options(record_usage
, record_options
);
962 if (perf_record_opts__config(&rec
->opts
)) {
967 err
= __cmd_record(&record
, argc
, argv
);
969 perf_evlist__munmap(evsel_list
);
970 perf_evlist__close(evsel_list
);
972 perf_evlist__delete_maps(evsel_list
);