1 // SPDX-License-Identifier: GPL-2.0
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.
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"
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"
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"
55 #include <linux/time64.h>
57 struct switch_output {
67 struct perf_tool tool;
68 struct record_opts opts;
70 struct perf_data data;
71 struct auxtrace_record *itr;
72 struct perf_evlist *evlist;
73 struct perf_session *session;
78 bool no_buildid_cache;
79 bool no_buildid_cache_set;
81 bool timestamp_filename;
82 struct switch_output switch_output;
83 unsigned long long samples;
86 static volatile int auxtrace_record__snapshot_started;
87 static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
88 static DEFINE_TRIGGER(switch_output_trigger);
90 static bool switch_output_signal(struct record *rec)
92 return rec->switch_output.signal &&
93 trigger_is_ready(&switch_output_trigger);
96 static bool switch_output_size(struct record *rec)
98 return rec->switch_output.size &&
99 trigger_is_ready(&switch_output_trigger) &&
100 (rec->bytes_written >= rec->switch_output.size);
103 static bool switch_output_time(struct record *rec)
105 return rec->switch_output.time &&
106 trigger_is_ready(&switch_output_trigger);
109 static int record__write(struct record *rec, void *bf, size_t size)
111 if (perf_data__write(rec->session->data, bf, size) < 0) {
112 pr_err("failed to write perf data, error: %m\n");
116 rec->bytes_written += size;
118 if (switch_output_size(rec))
119 trigger_hit(&switch_output_trigger);
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)
129 struct record *rec = container_of(tool, struct record, tool);
130 return record__write(rec, event, event->header.size);
133 static int record__pushfn(void *to, void *bf, size_t size)
135 struct record *rec = to;
138 return record__write(rec, bf, size);
141 static volatile int done;
142 static volatile int signr = -1;
143 static volatile int child_finished;
145 static void sig_handler(int sig)
155 static void sigsegv_handler(int sig)
157 perf_hooks__recover();
158 sighandler_dump_stack(sig);
161 static void record__sig_exit(void)
166 signal(signr, SIG_DFL);
170 #ifdef HAVE_AUXTRACE_SUPPORT
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)
176 struct record *rec = container_of(tool, struct record, tool);
177 struct perf_data *data = &rec->data;
181 if (!perf_data__is_pipe(data)) {
183 int fd = perf_data__fd(data);
186 file_offset = lseek(fd, 0, SEEK_CUR);
187 if (file_offset == -1)
189 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
195 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
196 padding = (len1 + len2) & 7;
198 padding = 8 - padding;
200 record__write(rec, event, event->header.size);
201 record__write(rec, data1, len1);
203 record__write(rec, data2, len2);
204 record__write(rec, &pad, padding);
209 static int record__auxtrace_mmap_read(struct record *rec,
210 struct auxtrace_mmap *mm)
214 ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
215 record__process_auxtrace);
225 static int record__auxtrace_mmap_read_snapshot(struct record *rec,
226 struct auxtrace_mmap *mm)
230 ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
231 record__process_auxtrace,
232 rec->opts.auxtrace_snapshot_size);
242 static int record__auxtrace_read_snapshot_all(struct record *rec)
247 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
248 struct auxtrace_mmap *mm =
249 &rec->evlist->mmap[i].auxtrace_mmap;
254 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
263 static void record__read_auxtrace_snapshot(struct record *rec)
265 pr_debug("Recording AUX area tracing snapshot\n");
266 if (record__auxtrace_read_snapshot_all(rec) < 0) {
267 trigger_error(&auxtrace_snapshot_trigger);
269 if (auxtrace_record__snapshot_finish(rec->itr))
270 trigger_error(&auxtrace_snapshot_trigger);
272 trigger_ready(&auxtrace_snapshot_trigger);
279 int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
280 struct auxtrace_mmap *mm __maybe_unused)
286 void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
291 int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
298 static int record__mmap_evlist(struct record *rec,
299 struct perf_evlist *evlist)
301 struct record_opts *opts = &rec->opts;
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);
316 pr_err("failed to mmap with %d (%s)\n", errno,
317 str_error_r(errno, msg, sizeof(msg)));
327 static int record__mmap(struct record *rec)
329 return record__mmap_evlist(rec, rec->evlist);
332 static int record__open(struct record *rec)
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;
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.
347 if (opts->initial_delay) {
348 if (perf_evlist__add_dummy(evlist))
351 pos = perf_evlist__first(evlist);
353 pos = perf_evlist__last(evlist);
355 pos->attr.enable_on_exec = 1;
358 perf_evlist__config(evlist, opts, &callchain_param);
360 evlist__for_each_entry(evlist, pos) {
362 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
363 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
365 ui__warning("%s\n", msg);
370 perf_evsel__open_strerror(pos, &opts->target,
371 errno, msg, sizeof(msg));
372 ui__error("%s\n", msg);
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)));
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)));
393 rc = record__mmap(rec);
397 session->evlist = evlist;
398 perf_session__set_id_hdr_size(session);
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)
409 struct record *rec = container_of(tool, struct record, tool);
413 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
416 static int process_buildids(struct record *rec)
418 struct perf_data *data = &rec->data;
419 struct perf_session *session = rec->session;
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
430 * rather than build-id path (in debug directory).
431 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
433 symbol_conf.ignore_vmlinux_buildid = true;
436 * If --buildid-all is given, it marks all DSO regardless of hits,
437 * so no need to process samples.
439 if (rec->buildid_all)
440 rec->tool.sample = NULL;
442 return perf_session__process_events(session);
445 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
448 struct perf_tool *tool = data;
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.
457 err = perf_event__synthesize_modules(tool, process_synthesized_event,
460 pr_err("Couldn't record guest kernel [%d]'s reference"
461 " relocation symbol.\n", machine->pid);
464 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
465 * have no _text sometimes.
467 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
470 pr_err("Couldn't record guest kernel [%d]'s reference"
471 " relocation symbol.\n", machine->pid);
474 static struct perf_event_header finished_round_event = {
475 .size = sizeof(struct perf_event_header),
476 .type = PERF_RECORD_FINISHED_ROUND,
479 static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist,
482 u64 bytes_written = rec->bytes_written;
485 struct perf_mmap *maps;
490 maps = backward ? evlist->backward_mmap : evlist->mmap;
494 if (backward && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
497 for (i = 0; i < evlist->nr_mmaps; i++) {
498 struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
501 if (perf_mmap__push(&maps[i], evlist->overwrite, backward, rec, record__pushfn) != 0) {
507 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
508 record__auxtrace_mmap_read(rec, mm) != 0) {
515 * Mark the round finished in case we wrote
516 * at least one event.
518 if (bytes_written != rec->bytes_written)
519 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
522 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
527 static int record__mmap_read_all(struct record *rec)
531 err = record__mmap_read_evlist(rec, rec->evlist, false);
535 return record__mmap_read_evlist(rec, rec->evlist, true);
538 static void record__init_features(struct record *rec)
540 struct perf_session *session = rec->session;
543 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
544 perf_header__set_feat(&session->header, feat);
547 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
549 if (!have_tracepoints(&rec->evlist->entries))
550 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
552 if (!rec->opts.branch_stack)
553 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
555 if (!rec->opts.full_auxtrace)
556 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
558 perf_header__clear_feat(&session->header, HEADER_STAT);
562 record__finish_output(struct record *rec)
564 struct perf_data *data = &rec->data;
565 int fd = perf_data__fd(data);
570 rec->session->header.data_size += rec->bytes_written;
571 data->size = lseek(perf_data__fd(data), 0, SEEK_CUR);
573 if (!rec->no_buildid) {
574 process_buildids(rec);
576 if (rec->buildid_all)
577 dsos__hit_all(rec->session);
579 perf_session__write_header(rec->session, rec->evlist, fd, true);
584 static int record__synthesize_workload(struct record *rec, bool tail)
587 struct thread_map *thread_map;
589 if (rec->opts.tail_synthesize != tail)
592 thread_map = thread_map__new_by_tid(rec->evlist->workload.pid);
593 if (thread_map == NULL)
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);
605 static int record__synthesize(struct record *rec, bool tail);
608 record__switch_output(struct record *rec, bool at_exit)
610 struct perf_data *data = &rec->data;
613 /* Same Size: "2015122520103046"*/
614 char timestamp[] = "InvalidTimestamp";
616 record__synthesize(rec, true);
617 if (target__none(&rec->opts.target))
618 record__synthesize_workload(rec, true);
621 record__finish_output(rec);
622 err = fetch_current_timestamp(timestamp, sizeof(timestamp));
624 pr_err("Failed to get current timestamp\n");
628 fd = perf_data__switch(data, timestamp,
629 rec->session->header.data_offset,
631 if (fd >= 0 && !at_exit) {
632 rec->bytes_written = 0;
633 rec->session->header.data_size = 0;
637 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
638 data->file.path, timestamp);
640 /* Output tracking events */
642 record__synthesize(rec, false);
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.
653 if (target__none(&rec->opts.target))
654 record__synthesize_workload(rec, false);
659 static volatile int workload_exec_errno;
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.
666 static void workload_exec_failed_signal(int signo __maybe_unused,
668 void *ucontext __maybe_unused)
670 workload_exec_errno = info->si_value.sival_int;
675 static void snapshot_sig_handler(int sig);
676 static void alarm_sig_handler(int sig);
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)
687 static const struct perf_event_mmap_page *
688 perf_evlist__pick_pc(struct perf_evlist *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;
699 static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
701 const struct perf_event_mmap_page *pc;
703 pc = perf_evlist__pick_pc(rec->evlist);
709 static int record__synthesize(struct record *rec, bool tail)
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);
719 if (rec->opts.tail_synthesize != tail)
723 err = perf_event__synthesize_features(
724 tool, session, rec->evlist, process_synthesized_event);
726 pr_err("Couldn't synthesize features.\n");
730 err = perf_event__synthesize_attrs(tool, session,
731 process_synthesized_event);
733 pr_err("Couldn't synthesize attrs.\n");
737 if (have_tracepoints(&rec->evlist->entries)) {
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()
746 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
747 process_synthesized_event);
749 pr_err("Couldn't record tracing data.\n");
752 rec->bytes_written += err;
756 err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
757 process_synthesized_event, machine);
761 if (rec->opts.full_auxtrace) {
762 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
763 session, process_synthesized_event);
768 if (!perf_evlist__exclude_kernel(rec->evlist)) {
769 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
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");
775 err = perf_event__synthesize_modules(tool, process_synthesized_event,
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");
783 machines__process_guests(&session->machines,
784 perf_event__synthesize_guest_os, tool);
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);
794 static int __cmd_record(struct record *rec, int argc, const char **argv)
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;
808 rec->progname = argv[0];
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);
816 if (rec->opts.record_namespaces)
817 tool->namespace_events = true;
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);
826 signal(SIGUSR2, SIG_IGN);
829 session = perf_session__new(data, false, tool);
830 if (session == NULL) {
831 pr_err("Perf session creation failed.\n");
835 fd = perf_data__fd(data);
836 rec->session = session;
838 record__init_features(rec);
841 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
843 workload_exec_failed_signal);
845 pr_err("Couldn't run the workload!\n");
847 goto out_delete_session;
851 if (record__open(rec) != 0) {
856 err = bpf__apply_obj_config();
860 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
861 pr_err("ERROR: Apply config to BPF failed: %s\n",
867 * Normally perf_session__new would do this, but it doesn't have the
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;
875 if (!rec->evlist->nr_groups)
876 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
879 err = perf_header__write_pipe(fd);
883 err = perf_session__write_header(session, rec->evlist, fd, false);
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");
896 machine = &session->machines.host;
898 err = record__synthesize(rec, false);
902 if (rec->realtime_prio) {
903 struct sched_param param;
905 param.sched_priority = rec->realtime_prio;
906 if (sched_setscheduler(0, SCHED_FIFO, ¶m)) {
907 pr_err("Could not set realtime priority.\n");
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.
918 if (!target__none(&opts->target) && !opts->initial_delay)
919 perf_evlist__enable(rec->evlist);
925 union perf_event *event;
928 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
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.
940 tgid = perf_event__synthesize_comm(tool, event,
941 rec->evlist->workload.pid,
942 process_synthesized_event,
949 event = malloc(sizeof(event->namespaces) +
950 (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
951 machine->id_hdr_size);
958 * Synthesize NAMESPACES event for the command specified.
960 perf_event__synthesize_namespaces(tool, event,
961 rec->evlist->workload.pid,
962 tgid, process_synthesized_event,
966 perf_evlist__start_workload(rec->evlist);
969 if (opts->initial_delay) {
970 usleep(opts->initial_delay * USEC_PER_MSEC);
971 perf_evlist__enable(rec->evlist);
974 trigger_ready(&auxtrace_snapshot_trigger);
975 trigger_ready(&switch_output_trigger);
976 perf_hooks__invoke_record_start();
978 unsigned long long hits = rec->samples;
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.
985 * perf_evlist__toggle_bkw_mmap ensure we never
986 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
988 if (trigger_is_hit(&switch_output_trigger) || done || draining)
989 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
991 if (record__mmap_read_all(rec) < 0) {
992 trigger_error(&auxtrace_snapshot_trigger);
993 trigger_error(&switch_output_trigger);
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");
1009 if (trigger_is_hit(&switch_output_trigger)) {
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.
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.
1019 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
1021 trigger_ready(&switch_output_trigger);
1024 * Reenable events in overwrite ring buffer after
1025 * record__mmap_read_all(): we should have collected
1028 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1031 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1034 fd = record__switch_output(rec, false);
1036 pr_err("Failed to switch to new file\n");
1037 trigger_error(&switch_output_trigger);
1042 /* re-arm the alarm */
1043 if (rec->switch_output.time)
1044 alarm(rec->switch_output.time);
1047 if (hits == rec->samples) {
1048 if (done || draining)
1050 err = perf_evlist__poll(rec->evlist, -1);
1052 * Propagate error, only if there's any. Ignore positive
1053 * number of returned events and interrupt error.
1055 if (err > 0 || (err < 0 && errno == EINTR))
1059 if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
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.
1068 if (done && !disabled && !target__none(&opts->target)) {
1069 trigger_off(&auxtrace_snapshot_trigger);
1070 perf_evlist__disable(rec->evlist);
1074 trigger_off(&auxtrace_snapshot_trigger);
1075 trigger_off(&switch_output_trigger);
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);
1086 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
1088 if (target__none(&rec->opts.target))
1089 record__synthesize_workload(rec, true);
1095 if (!child_finished)
1096 kill(rec->evlist->workload.pid, SIGTERM);
1102 else if (WIFEXITED(exit_status))
1103 status = WEXITSTATUS(exit_status);
1104 else if (WIFSIGNALED(exit_status))
1105 signr = WTERMSIG(exit_status);
1109 record__synthesize(rec, true);
1110 /* this will be recalculated during process_buildids() */
1114 if (!rec->timestamp_filename) {
1115 record__finish_output(rec);
1117 fd = record__switch_output(rec, true);
1120 goto out_delete_session;
1125 perf_hooks__invoke_record_end();
1127 if (!err && !quiet) {
1129 const char *postfix = rec->timestamp_filename ?
1130 ".<timestamp>" : "";
1132 if (rec->samples && !rec->opts.full_auxtrace)
1133 scnprintf(samples, sizeof(samples),
1134 " (%" PRIu64 " samples)", rec->samples);
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);
1144 perf_session__delete(session);
1148 static void callchain_debug(struct callchain_param *callchain)
1150 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
1152 pr_debug("callchain: type %s\n", str[callchain->record_mode]);
1154 if (callchain->record_mode == CALLCHAIN_DWARF)
1155 pr_debug("callchain: stack dump size %d\n",
1156 callchain->dump_size);
1159 int record_opts__parse_callchain(struct record_opts *record,
1160 struct callchain_param *callchain,
1161 const char *arg, bool unset)
1164 callchain->enabled = !unset;
1166 /* --no-call-graph */
1168 callchain->record_mode = CALLCHAIN_NONE;
1169 pr_debug("callchain: disabled\n");
1173 ret = parse_callchain_record_opt(arg, callchain);
1175 /* Enable data address sampling for DWARF unwind. */
1176 if (callchain->record_mode == CALLCHAIN_DWARF)
1177 record->sample_address = true;
1178 callchain_debug(callchain);
1184 int record_parse_callchain_opt(const struct option *opt,
1188 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
1191 int record_callchain_opt(const struct option *opt,
1192 const char *arg __maybe_unused,
1193 int unset __maybe_unused)
1195 struct callchain_param *callchain = opt->value;
1197 callchain->enabled = true;
1199 if (callchain->record_mode == CALLCHAIN_NONE)
1200 callchain->record_mode = CALLCHAIN_FP;
1202 callchain_debug(callchain);
1206 static int perf_record_config(const char *var, const char *value, void *cb)
1208 struct record *rec = cb;
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;
1221 if (!strcmp(var, "record.call-graph"))
1222 var = "call-graph.record-mode"; /* fall-through */
1224 return perf_default_config(var, value, cb);
1227 struct clockid_map {
1232 #define CLOCKID_MAP(n, c) \
1233 { .name = n, .clockid = (c), }
1235 #define CLOCKID_END { .name = NULL, }
1239 * Add the missing ones, we need to build on many distros...
1241 #ifndef CLOCK_MONOTONIC_RAW
1242 #define CLOCK_MONOTONIC_RAW 4
1244 #ifndef CLOCK_BOOTTIME
1245 #define CLOCK_BOOTTIME 7
1248 #define CLOCK_TAI 11
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),
1256 /* available for some events */
1257 CLOCKID_MAP("realtime", CLOCK_REALTIME),
1258 CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
1259 CLOCKID_MAP("tai", CLOCK_TAI),
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),
1270 static int parse_clockid(const struct option *opt, const char *str, int unset)
1272 struct record_opts *opts = (struct record_opts *)opt->value;
1273 const struct clockid_map *cm;
1274 const char *ostr = str;
1277 opts->use_clockid = 0;
1285 /* no setting it twice */
1286 if (opts->use_clockid)
1289 opts->use_clockid = true;
1291 /* if its a number, we're done */
1292 if (sscanf(str, "%d", &opts->clockid) == 1)
1295 /* allow a "CLOCK_" prefix to the name */
1296 if (!strncasecmp(str, "CLOCK_", 6))
1299 for (cm = clockids; cm->name; cm++) {
1300 if (!strcasecmp(str, cm->name)) {
1301 opts->clockid = cm->clockid;
1306 opts->use_clockid = false;
1307 ui__warning("unknown clockid %s, check man page\n", ostr);
1311 static int record__parse_mmap_pages(const struct option *opt,
1313 int unset __maybe_unused)
1315 struct record_opts *opts = opt->value;
1317 unsigned int mmap_pages;
1332 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
1335 opts->mmap_pages = mmap_pages;
1343 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
1347 opts->auxtrace_mmap_pages = mmap_pages;
1354 static void switch_output_size_warn(struct record *rec)
1356 u64 wakeup_size = perf_evlist__mmap_size(rec->opts.mmap_pages);
1357 struct switch_output *s = &rec->switch_output;
1361 if (s->size < wakeup_size) {
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);
1371 static int switch_output_setup(struct record *rec)
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 },
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 },
1393 if (!strcmp(s->str, "signal")) {
1395 pr_debug("switch-output with SIGUSR2 signal\n");
1399 val = parse_tag_value(s->str, tags_size);
1400 if (val != (unsigned long) -1) {
1402 pr_debug("switch-output with %s size threshold\n", s->str);
1406 val = parse_tag_value(s->str, tags_time);
1407 if (val != (unsigned long) -1) {
1409 pr_debug("switch-output with %s time threshold (%lu seconds)\n",
1417 rec->timestamp_filename = true;
1420 if (s->size && !rec->opts.no_buffering)
1421 switch_output_size_warn(rec);
1426 static const char * const __record_usage[] = {
1427 "perf record [<options>] [<command>]",
1428 "perf record [<options>] -- <command> [<options>]",
1431 const char * const *record_usage = __record_usage;
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.
1439 * At least we don't ouch it in all the other functions here directly.
1441 * Just say no to tons of global variables, sigh.
1443 static struct record record = {
1445 .sample_time = true,
1446 .mmap_pages = UINT_MAX,
1447 .user_freq = UINT_MAX,
1448 .user_interval = ULLONG_MAX,
1452 .default_per_cpu = true,
1454 .proc_map_timeout = 500,
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,
1468 const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
1469 "\n\t\t\t\tDefault: fp";
1471 static bool dry_run;
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',
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",
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,
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",
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",
1553 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1554 "branch any", "sample any taken branches",
1555 parse_branch_stack),
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()",
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",
1605 OPT_BOOLEAN(0, "dry-run", &dry_run,
1606 "Parse options then exit"),
1610 struct option *record_options = __record_options;
1612 int cmd_record(int argc, const char **argv)
1615 struct record *rec = &record;
1616 char errbuf[BUFSIZ];
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);
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"
1631 # define REASON "this architecture doesn't support BPF prologue"
1633 # define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
1634 set_nobuild('\0', "vmlinux", true);
1639 rec->evlist = perf_evlist__new();
1640 if (rec->evlist == NULL)
1643 err = perf_config(perf_record_config, rec);
1647 argc = parse_options(argc, argv, record_options, record_usage,
1648 PARSE_OPT_STOP_AT_NON_OPTION);
1650 perf_quiet_option();
1652 /* Make system wide (-a) the default target. */
1653 if (!argc && target__none(&rec->opts.target))
1654 rec->opts.target.system_wide = true;
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");
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);
1668 if (switch_output_setup(rec)) {
1669 parse_options_usage(record_usage, record_options, "switch-output", 0);
1673 if (rec->switch_output.time) {
1674 signal(SIGALRM, alarm_sig_handler);
1675 alarm(rec->switch_output.time);
1679 rec->itr = auxtrace_record__init(rec->evlist, &err);
1684 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1685 rec->opts.auxtrace_snapshot_opts);
1690 * Allow aliases to facilitate the lookup of symbols for address
1691 * filters. Refer to auxtrace_parse_filters().
1693 symbol_conf.allow_aliases = true;
1697 err = auxtrace_parse_filters(rec->evlist);
1704 err = bpf__setup_stdout(rec->evlist);
1706 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
1707 pr_err("ERROR: Setup BPF stdout failed: %s\n",
1714 if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(rec->evlist))
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");
1724 if (rec->no_buildid_cache || rec->no_buildid) {
1725 disable_buildid_cache();
1726 } else if (rec->switch_output.enabled) {
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
1733 * perf record --switch-output --no-no-buildid \
1734 * --no-no-buildid-cache
1736 * Following code equals to:
1738 * if ((rec->no_buildid || !rec->no_buildid_set) &&
1739 * (rec->no_buildid_cache || !rec->no_buildid_cache_set))
1740 * disable_buildid_cache();
1742 bool disable = true;
1744 if (rec->no_buildid_set && !rec->no_buildid)
1746 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
1749 rec->no_buildid = true;
1750 rec->no_buildid_cache = true;
1751 disable_buildid_cache();
1755 if (record.opts.overwrite)
1756 record.opts.tail_synthesize = true;
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");
1764 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1765 rec->opts.no_inherit = true;
1767 err = target__validate(&rec->opts.target);
1769 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1770 ui__warning("%s", errbuf);
1773 err = target__parse_uid(&rec->opts.target);
1775 int saved_errno = errno;
1777 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1778 ui__error("%s", errbuf);
1784 /* Enable ignoring missing threads when -u option is defined. */
1785 rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX;
1788 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1789 usage_with_options(record_usage, record_options);
1791 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
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.
1800 if (rec->opts.full_auxtrace)
1801 rec->buildid_all = true;
1803 if (record_opts__config(&rec->opts)) {
1808 err = __cmd_record(&record, argc, argv);
1810 perf_evlist__delete(rec->evlist);
1812 auxtrace_record__free(rec->itr);
1816 static void snapshot_sig_handler(int sig __maybe_unused)
1818 struct record *rec = &record;
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);
1827 if (switch_output_signal(rec))
1828 trigger_hit(&switch_output_trigger);
1831 static void alarm_sig_handler(int sig __maybe_unused)
1833 struct record *rec = &record;
1835 if (switch_output_time(rec))
1836 trigger_hit(&switch_output_trigger);