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