]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - tools/perf/builtin-record.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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