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