?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
SHM_UNLOCK: fix Unevictable pages stranded after swap
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / tools / perf / builtin-record.c
blob6ab58cc99d53effeced21668df5605e634913e6b
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 #define _FILE_OFFSET_BITS 64
9
10 #include "builtin.h"
11
12 #include "perf.h"
13
14 #include "util/build-id.h"
15 #include "util/util.h"
16 #include "util/parse-options.h"
17 #include "util/parse-events.h"
18
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/symbol.h"
26 #include "util/cpumap.h"
27 #include "util/thread_map.h"
28
29 #include <unistd.h>
30 #include <sched.h>
31 #include <sys/mman.h>
32
33 enum write_mode_t {
34 WRITE_FORCE,
35 WRITE_APPEND
36 };
37
38 static u64 user_interval = ULLONG_MAX;
39 static u64 default_interval = 0;
40
41 static unsigned int page_size;
42 static unsigned int mmap_pages = UINT_MAX;
43 static unsigned int user_freq = UINT_MAX;
44 static int freq = 1000;
45 static int output;
46 static int pipe_output = 0;
47 static const char *output_name = NULL;
48 static bool group = false;
49 static int realtime_prio = 0;
50 static bool nodelay = false;
51 static bool raw_samples = false;
52 static bool sample_id_all_avail = true;
53 static bool system_wide = false;
54 static pid_t target_pid = -1;
55 static pid_t target_tid = -1;
56 static pid_t child_pid = -1;
57 static bool no_inherit = false;
58 static enum write_mode_t write_mode = WRITE_FORCE;
59 static bool call_graph = false;
60 static bool inherit_stat = false;
61 static bool no_samples = false;
62 static bool sample_address = false;
63 static bool sample_time = false;
64 static bool no_buildid = false;
65 static bool no_buildid_cache = false;
66 static struct perf_evlist *evsel_list;
67
68 static long samples = 0;
69 static u64 bytes_written = 0;
70
71 static int file_new = 1;
72 static off_t post_processing_offset;
73
74 static struct perf_session *session;
75 static const char *cpu_list;
76 static const char *progname;
77
78 static void advance_output(size_t size)
79 {
80 bytes_written += size;
81 }
82
83 static void write_output(void *buf, size_t size)
84 {
85 while (size) {
86 int ret = write(output, buf, size);
87
88 if (ret < 0)
89 die("failed to write");
90
91 size -= ret;
92 buf += ret;
93
94 bytes_written += ret;
95 }
96 }
97
98 static int process_synthesized_event(union perf_event *event,
99 struct perf_sample *sample __used,
100 struct perf_session *self __used)
101 {
102 write_output(event, event->header.size);
103 return 0;
104 }
105
106 static void mmap_read(struct perf_mmap *md)
107 {
108 unsigned int head = perf_mmap__read_head(md);
109 unsigned int old = md->prev;
110 unsigned char *data = md->base + page_size;
111 unsigned long size;
112 void *buf;
113
114 if (old == head)
115 return;
116
117 samples++;
118
119 size = head - old;
120
121 if ((old & md->mask) + size != (head & md->mask)) {
122 buf = &data[old & md->mask];
123 size = md->mask + 1 - (old & md->mask);
124 old += size;
125
126 write_output(buf, size);
127 }
128
129 buf = &data[old & md->mask];
130 size = head - old;
131 old += size;
132
133 write_output(buf, size);
134
135 md->prev = old;
136 perf_mmap__write_tail(md, old);
137 }
138
139 static volatile int done = 0;
140 static volatile int signr = -1;
141 static volatile int child_finished = 0;
142
143 static void sig_handler(int sig)
144 {
145 if (sig == SIGCHLD)
146 child_finished = 1;
147
148 done = 1;
149 signr = sig;
150 }
151
152 static void sig_atexit(void)
153 {
154 int status;
155
156 if (child_pid > 0) {
157 if (!child_finished)
158 kill(child_pid, SIGTERM);
159
160 wait(&status);
161 if (WIFSIGNALED(status))
162 psignal(WTERMSIG(status), progname);
163 }
164
165 if (signr == -1 || signr == SIGUSR1)
166 return;
167
168 signal(signr, SIG_DFL);
169 kill(getpid(), signr);
170 }
171
172 static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist)
173 {
174 struct perf_event_attr *attr = &evsel->attr;
175 int track = !evsel->idx; /* only the first counter needs these */
176
177 attr->disabled = 1;
178 attr->inherit = !no_inherit;
179 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
180 PERF_FORMAT_TOTAL_TIME_RUNNING |
181 PERF_FORMAT_ID;
182
183 attr->sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
184
185 if (evlist->nr_entries > 1)
186 attr->sample_type |= PERF_SAMPLE_ID;
187
188 /*
189 * We default some events to a 1 default interval. But keep
190 * it a weak assumption overridable by the user.
191 */
192 if (!attr->sample_period || (user_freq != UINT_MAX &&
193 user_interval != ULLONG_MAX)) {
194 if (freq) {
195 attr->sample_type |= PERF_SAMPLE_PERIOD;
196 attr->freq = 1;
197 attr->sample_freq = freq;
198 } else {
199 attr->sample_period = default_interval;
200 }
201 }
202
203 if (no_samples)
204 attr->sample_freq = 0;
205
206 if (inherit_stat)
207 attr->inherit_stat = 1;
208
209 if (sample_address) {
210 attr->sample_type |= PERF_SAMPLE_ADDR;
211 attr->mmap_data = track;
212 }
213
214 if (call_graph)
215 attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
216
217 if (system_wide)
218 attr->sample_type |= PERF_SAMPLE_CPU;
219
220 if (sample_id_all_avail &&
221 (sample_time || system_wide || !no_inherit || cpu_list))
222 attr->sample_type |= PERF_SAMPLE_TIME;
223
224 if (raw_samples) {
225 attr->sample_type |= PERF_SAMPLE_TIME;
226 attr->sample_type |= PERF_SAMPLE_RAW;
227 attr->sample_type |= PERF_SAMPLE_CPU;
228 }
229
230 if (nodelay) {
231 attr->watermark = 0;
232 attr->wakeup_events = 1;
233 }
234
235 attr->mmap = track;
236 attr->comm = track;
237
238 if (target_pid == -1 && target_tid == -1 && !system_wide) {
239 attr->disabled = 1;
240 attr->enable_on_exec = 1;
241 }
242 }
243
244 static bool perf_evlist__equal(struct perf_evlist *evlist,
245 struct perf_evlist *other)
246 {
247 struct perf_evsel *pos, *pair;
248
249 if (evlist->nr_entries != other->nr_entries)
250 return false;
251
252 pair = list_entry(other->entries.next, struct perf_evsel, node);
253
254 list_for_each_entry(pos, &evlist->entries, node) {
255 if (memcmp(&pos->attr, &pair->attr, sizeof(pos->attr) != 0))
256 return false;
257 pair = list_entry(pair->node.next, struct perf_evsel, node);
258 }
259
260 return true;
261 }
262
263 static void open_counters(struct perf_evlist *evlist)
264 {
265 struct perf_evsel *pos, *first;
266
267 if (evlist->cpus->map[0] < 0)
268 no_inherit = true;
269
270 first = list_entry(evlist->entries.next, struct perf_evsel, node);
271
272 list_for_each_entry(pos, &evlist->entries, node) {
273 struct perf_event_attr *attr = &pos->attr;
274 struct xyarray *group_fd = NULL;
275 /*
276 * Check if parse_single_tracepoint_event has already asked for
277 * PERF_SAMPLE_TIME.
278 *
279 * XXX this is kludgy but short term fix for problems introduced by
280 * eac23d1c that broke 'perf script' by having different sample_types
281 * when using multiple tracepoint events when we use a perf binary
282 * that tries to use sample_id_all on an older kernel.
283 *
284 * We need to move counter creation to perf_session, support
285 * different sample_types, etc.
286 */
287 bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
288
289 if (group && pos != first)
290 group_fd = first->fd;
291
292 config_attr(pos, evlist);
293 retry_sample_id:
294 attr->sample_id_all = sample_id_all_avail ? 1 : 0;
295 try_again:
296 if (perf_evsel__open(pos, evlist->cpus, evlist->threads, group,
297 group_fd) < 0) {
298 int err = errno;
299
300 if (err == EPERM || err == EACCES) {
301 ui__error_paranoid();
302 exit(EXIT_FAILURE);
303 } else if (err == ENODEV && cpu_list) {
304 die("No such device - did you specify"
305 " an out-of-range profile CPU?\n");
306 } else if (err == EINVAL && sample_id_all_avail) {
307 /*
308 * Old kernel, no attr->sample_id_type_all field
309 */
310 sample_id_all_avail = false;
311 if (!sample_time && !raw_samples && !time_needed)
312 attr->sample_type &= ~PERF_SAMPLE_TIME;
313
314 goto retry_sample_id;
315 }
316
317 /*
318 * If it's cycles then fall back to hrtimer
319 * based cpu-clock-tick sw counter, which
320 * is always available even if no PMU support:
321 */
322 if (attr->type == PERF_TYPE_HARDWARE
323 && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
324
325 if (verbose)
326 ui__warning("The cycles event is not supported, "
327 "trying to fall back to cpu-clock-ticks\n");
328 attr->type = PERF_TYPE_SOFTWARE;
329 attr->config = PERF_COUNT_SW_CPU_CLOCK;
330 goto try_again;
331 }
332
333 if (err == ENOENT) {
334 ui__warning("The %s event is not supported.\n",
335 event_name(pos));
336 exit(EXIT_FAILURE);
337 }
338
339 printf("\n");
340 error("sys_perf_event_open() syscall returned with %d (%s). /bin/dmesg may provide additional information.\n",
341 err, strerror(err));
342
343 #if defined(__i386__) || defined(__x86_64__)
344 if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
345 die("No hardware sampling interrupt available."
346 " No APIC? If so then you can boot the kernel"
347 " with the \"lapic\" boot parameter to"
348 " force-enable it.\n");
349 #endif
350
351 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
352 }
353 }
354
355 if (perf_evlist__set_filters(evlist)) {
356 error("failed to set filter with %d (%s)\n", errno,
357 strerror(errno));
358 exit(-1);
359 }
360
361 if (perf_evlist__mmap(evlist, mmap_pages, false) < 0)
362 die("failed to mmap with %d (%s)\n", errno, strerror(errno));
363
364 if (file_new)
365 session->evlist = evlist;
366 else {
367 if (!perf_evlist__equal(session->evlist, evlist)) {
368 fprintf(stderr, "incompatible append\n");
369 exit(-1);
370 }
371 }
372
373 perf_session__update_sample_type(session);
374 }
375
376 static int process_buildids(void)
377 {
378 u64 size = lseek(output, 0, SEEK_CUR);
379
380 if (size == 0)
381 return 0;
382
383 session->fd = output;
384 return __perf_session__process_events(session, post_processing_offset,
385 size - post_processing_offset,
386 size, &build_id__mark_dso_hit_ops);
387 }
388
389 static void atexit_header(void)
390 {
391 if (!pipe_output) {
392 session->header.data_size += bytes_written;
393
394 if (!no_buildid)
395 process_buildids();
396 perf_session__write_header(session, evsel_list, output, true);
397 perf_session__delete(session);
398 perf_evlist__delete(evsel_list);
399 symbol__exit();
400 }
401 }
402
403 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
404 {
405 int err;
406 struct perf_session *psession = data;
407
408 if (machine__is_host(machine))
409 return;
410
411 /*
412 *As for guest kernel when processing subcommand record&report,
413 *we arrange module mmap prior to guest kernel mmap and trigger
414 *a preload dso because default guest module symbols are loaded
415 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
416 *method is used to avoid symbol missing when the first addr is
417 *in module instead of in guest kernel.
418 */
419 err = perf_event__synthesize_modules(process_synthesized_event,
420 psession, machine);
421 if (err < 0)
422 pr_err("Couldn't record guest kernel [%d]'s reference"
423 " relocation symbol.\n", machine->pid);
424
425 /*
426 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
427 * have no _text sometimes.
428 */
429 err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
430 psession, machine, "_text");
431 if (err < 0)
432 err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
433 psession, machine,
434 "_stext");
435 if (err < 0)
436 pr_err("Couldn't record guest kernel [%d]'s reference"
437 " relocation symbol.\n", machine->pid);
438 }
439
440 static struct perf_event_header finished_round_event = {
441 .size = sizeof(struct perf_event_header),
442 .type = PERF_RECORD_FINISHED_ROUND,
443 };
444
445 static void mmap_read_all(void)
446 {
447 int i;
448
449 for (i = 0; i < evsel_list->nr_mmaps; i++) {
450 if (evsel_list->mmap[i].base)
451 mmap_read(&evsel_list->mmap[i]);
452 }
453
454 if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
455 write_output(&finished_round_event, sizeof(finished_round_event));
456 }
457
458 static int __cmd_record(int argc, const char **argv)
459 {
460 struct stat st;
461 int flags;
462 int err;
463 unsigned long waking = 0;
464 int child_ready_pipe[2], go_pipe[2];
465 const bool forks = argc > 0;
466 char buf;
467 struct machine *machine;
468
469 progname = argv[0];
470
471 page_size = sysconf(_SC_PAGE_SIZE);
472
473 atexit(sig_atexit);
474 signal(SIGCHLD, sig_handler);
475 signal(SIGINT, sig_handler);
476 signal(SIGUSR1, sig_handler);
477
478 if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
479 perror("failed to create pipes");
480 exit(-1);
481 }
482
483 if (!output_name) {
484 if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
485 pipe_output = 1;
486 else
487 output_name = "perf.data";
488 }
489 if (output_name) {
490 if (!strcmp(output_name, "-"))
491 pipe_output = 1;
492 else if (!stat(output_name, &st) && st.st_size) {
493 if (write_mode == WRITE_FORCE) {
494 char oldname[PATH_MAX];
495 snprintf(oldname, sizeof(oldname), "%s.old",
496 output_name);
497 unlink(oldname);
498 rename(output_name, oldname);
499 }
500 } else if (write_mode == WRITE_APPEND) {
501 write_mode = WRITE_FORCE;
502 }
503 }
504
505 flags = O_CREAT|O_RDWR;
506 if (write_mode == WRITE_APPEND)
507 file_new = 0;
508 else
509 flags |= O_TRUNC;
510
511 if (pipe_output)
512 output = STDOUT_FILENO;
513 else
514 output = open(output_name, flags, S_IRUSR | S_IWUSR);
515 if (output < 0) {
516 perror("failed to create output file");
517 exit(-1);
518 }
519
520 session = perf_session__new(output_name, O_WRONLY,
521 write_mode == WRITE_FORCE, false, NULL);
522 if (session == NULL) {
523 pr_err("Not enough memory for reading perf file header\n");
524 return -1;
525 }
526
527 if (!no_buildid)
528 perf_header__set_feat(&session->header, HEADER_BUILD_ID);
529
530 if (!file_new) {
531 err = perf_session__read_header(session, output);
532 if (err < 0)
533 goto out_delete_session;
534 }
535
536 if (have_tracepoints(&evsel_list->entries))
537 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
538
539 perf_header__set_feat(&session->header, HEADER_HOSTNAME);
540 perf_header__set_feat(&session->header, HEADER_OSRELEASE);
541 perf_header__set_feat(&session->header, HEADER_ARCH);
542 perf_header__set_feat(&session->header, HEADER_CPUDESC);
543 perf_header__set_feat(&session->header, HEADER_NRCPUS);
544 perf_header__set_feat(&session->header, HEADER_EVENT_DESC);
545 perf_header__set_feat(&session->header, HEADER_CMDLINE);
546 perf_header__set_feat(&session->header, HEADER_VERSION);
547 perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);
548 perf_header__set_feat(&session->header, HEADER_TOTAL_MEM);
549 perf_header__set_feat(&session->header, HEADER_NUMA_TOPOLOGY);
550 perf_header__set_feat(&session->header, HEADER_CPUID);
551
552 /* 512 kiB: default amount of unprivileged mlocked memory */
553 if (mmap_pages == UINT_MAX)
554 mmap_pages = (512 * 1024) / page_size;
555
556 if (forks) {
557 child_pid = fork();
558 if (child_pid < 0) {
559 perror("failed to fork");
560 exit(-1);
561 }
562
563 if (!child_pid) {
564 if (pipe_output)
565 dup2(2, 1);
566 close(child_ready_pipe[0]);
567 close(go_pipe[1]);
568 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
569
570 /*
571 * Do a dummy execvp to get the PLT entry resolved,
572 * so we avoid the resolver overhead on the real
573 * execvp call.
574 */
575 execvp("", (char **)argv);
576
577 /*
578 * Tell the parent we're ready to go
579 */
580 close(child_ready_pipe[1]);
581
582 /*
583 * Wait until the parent tells us to go.
584 */
585 if (read(go_pipe[0], &buf, 1) == -1)
586 perror("unable to read pipe");
587
588 execvp(argv[0], (char **)argv);
589
590 perror(argv[0]);
591 kill(getppid(), SIGUSR1);
592 exit(-1);
593 }
594
595 if (!system_wide && target_tid == -1 && target_pid == -1)
596 evsel_list->threads->map[0] = child_pid;
597
598 close(child_ready_pipe[1]);
599 close(go_pipe[0]);
600 /*
601 * wait for child to settle
602 */
603 if (read(child_ready_pipe[0], &buf, 1) == -1) {
604 perror("unable to read pipe");
605 exit(-1);
606 }
607 close(child_ready_pipe[0]);
608 }
609
610 open_counters(evsel_list);
611
612 /*
613 * perf_session__delete(session) will be called at atexit_header()
614 */
615 atexit(atexit_header);
616
617 if (pipe_output) {
618 err = perf_header__write_pipe(output);
619 if (err < 0)
620 return err;
621 } else if (file_new) {
622 err = perf_session__write_header(session, evsel_list,
623 output, false);
624 if (err < 0)
625 return err;
626 }
627
628 post_processing_offset = lseek(output, 0, SEEK_CUR);
629
630 if (pipe_output) {
631 err = perf_session__synthesize_attrs(session,
632 process_synthesized_event);
633 if (err < 0) {
634 pr_err("Couldn't synthesize attrs.\n");
635 return err;
636 }
637
638 err = perf_event__synthesize_event_types(process_synthesized_event,
639 session);
640 if (err < 0) {
641 pr_err("Couldn't synthesize event_types.\n");
642 return err;
643 }
644
645 if (have_tracepoints(&evsel_list->entries)) {
646 /*
647 * FIXME err <= 0 here actually means that
648 * there were no tracepoints so its not really
649 * an error, just that we don't need to
650 * synthesize anything. We really have to
651 * return this more properly and also
652 * propagate errors that now are calling die()
653 */
654 err = perf_event__synthesize_tracing_data(output, evsel_list,
655 process_synthesized_event,
656 session);
657 if (err <= 0) {
658 pr_err("Couldn't record tracing data.\n");
659 return err;
660 }
661 advance_output(err);
662 }
663 }
664
665 machine = perf_session__find_host_machine(session);
666 if (!machine) {
667 pr_err("Couldn't find native kernel information.\n");
668 return -1;
669 }
670
671 err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
672 session, machine, "_text");
673 if (err < 0)
674 err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
675 session, machine, "_stext");
676 if (err < 0)
677 pr_err("Couldn't record kernel reference relocation symbol\n"
678 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
679 "Check /proc/kallsyms permission or run as root.\n");
680
681 err = perf_event__synthesize_modules(process_synthesized_event,
682 session, machine);
683 if (err < 0)
684 pr_err("Couldn't record kernel module information.\n"
685 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
686 "Check /proc/modules permission or run as root.\n");
687
688 if (perf_guest)
689 perf_session__process_machines(session,
690 perf_event__synthesize_guest_os);
691
692 if (!system_wide)
693 perf_event__synthesize_thread_map(evsel_list->threads,
694 process_synthesized_event,
695 session);
696 else
697 perf_event__synthesize_threads(process_synthesized_event,
698 session);
699
700 if (realtime_prio) {
701 struct sched_param param;
702
703 param.sched_priority = realtime_prio;
704 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
705 pr_err("Could not set realtime priority.\n");
706 exit(-1);
707 }
708 }
709
710 perf_evlist__enable(evsel_list);
711
712 /*
713 * Let the child rip
714 */
715 if (forks)
716 close(go_pipe[1]);
717
718 for (;;) {
719 int hits = samples;
720
721 mmap_read_all();
722
723 if (hits == samples) {
724 if (done)
725 break;
726 err = poll(evsel_list->pollfd, evsel_list->nr_fds, -1);
727 waking++;
728 }
729
730 if (done)
731 perf_evlist__disable(evsel_list);
732 }
733
734 if (quiet || signr == SIGUSR1)
735 return 0;
736
737 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
738
739 /*
740 * Approximate RIP event size: 24 bytes.
741 */
742 fprintf(stderr,
743 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
744 (double)bytes_written / 1024.0 / 1024.0,
745 output_name,
746 bytes_written / 24);
747
748 return 0;
749
750 out_delete_session:
751 perf_session__delete(session);
752 return err;
753 }
754
755 static const char * const record_usage[] = {
756 "perf record [<options>] [<command>]",
757 "perf record [<options>] -- <command> [<options>]",
758 NULL
759 };
760
761 static bool force, append_file;
762
763 const struct option record_options[] = {
764 OPT_CALLBACK('e', "event", &evsel_list, "event",
765 "event selector. use 'perf list' to list available events",
766 parse_events_option),
767 OPT_CALLBACK(0, "filter", &evsel_list, "filter",
768 "event filter", parse_filter),
769 OPT_INTEGER('p', "pid", &target_pid,
770 "record events on existing process id"),
771 OPT_INTEGER('t', "tid", &target_tid,
772 "record events on existing thread id"),
773 OPT_INTEGER('r', "realtime", &realtime_prio,
774 "collect data with this RT SCHED_FIFO priority"),
775 OPT_BOOLEAN('D', "no-delay", &nodelay,
776 "collect data without buffering"),
777 OPT_BOOLEAN('R', "raw-samples", &raw_samples,
778 "collect raw sample records from all opened counters"),
779 OPT_BOOLEAN('a', "all-cpus", &system_wide,
780 "system-wide collection from all CPUs"),
781 OPT_BOOLEAN('A', "append", &append_file,
782 "append to the output file to do incremental profiling"),
783 OPT_STRING('C', "cpu", &cpu_list, "cpu",
784 "list of cpus to monitor"),
785 OPT_BOOLEAN('f', "force", &force,
786 "overwrite existing data file (deprecated)"),
787 OPT_U64('c', "count", &user_interval, "event period to sample"),
788 OPT_STRING('o', "output", &output_name, "file",
789 "output file name"),
790 OPT_BOOLEAN('i', "no-inherit", &no_inherit,
791 "child tasks do not inherit counters"),
792 OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
793 OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
794 OPT_BOOLEAN(0, "group", &group,
795 "put the counters into a counter group"),
796 OPT_BOOLEAN('g', "call-graph", &call_graph,
797 "do call-graph (stack chain/backtrace) recording"),
798 OPT_INCR('v', "verbose", &verbose,
799 "be more verbose (show counter open errors, etc)"),
800 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
801 OPT_BOOLEAN('s', "stat", &inherit_stat,
802 "per thread counts"),
803 OPT_BOOLEAN('d', "data", &sample_address,
804 "Sample addresses"),
805 OPT_BOOLEAN('T', "timestamp", &sample_time, "Sample timestamps"),
806 OPT_BOOLEAN('n', "no-samples", &no_samples,
807 "don't sample"),
808 OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
809 "do not update the buildid cache"),
810 OPT_BOOLEAN('B', "no-buildid", &no_buildid,
811 "do not collect buildids in perf.data"),
812 OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
813 "monitor event in cgroup name only",
814 parse_cgroups),
815 OPT_END()
816 };
817
818 int cmd_record(int argc, const char **argv, const char *prefix __used)
819 {
820 int err = -ENOMEM;
821 struct perf_evsel *pos;
822
823 perf_header__set_cmdline(argc, argv);
824
825 evsel_list = perf_evlist__new(NULL, NULL);
826 if (evsel_list == NULL)
827 return -ENOMEM;
828
829 argc = parse_options(argc, argv, record_options, record_usage,
830 PARSE_OPT_STOP_AT_NON_OPTION);
831 if (!argc && target_pid == -1 && target_tid == -1 &&
832 !system_wide && !cpu_list)
833 usage_with_options(record_usage, record_options);
834
835 if (force && append_file) {
836 fprintf(stderr, "Can't overwrite and append at the same time."
837 " You need to choose between -f and -A");
838 usage_with_options(record_usage, record_options);
839 } else if (append_file) {
840 write_mode = WRITE_APPEND;
841 } else {
842 write_mode = WRITE_FORCE;
843 }
844
845 if (nr_cgroups && !system_wide) {
846 fprintf(stderr, "cgroup monitoring only available in"
847 " system-wide mode\n");
848 usage_with_options(record_usage, record_options);
849 }
850
851 symbol__init();
852
853 if (symbol_conf.kptr_restrict)
854 pr_warning(
855 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
856 "check /proc/sys/kernel/kptr_restrict.\n\n"
857 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
858 "file is not found in the buildid cache or in the vmlinux path.\n\n"
859 "Samples in kernel modules won't be resolved at all.\n\n"
860 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
861 "even with a suitable vmlinux or kallsyms file.\n\n");
862
863 if (no_buildid_cache || no_buildid)
864 disable_buildid_cache();
865
866 if (evsel_list->nr_entries == 0 &&
867 perf_evlist__add_default(evsel_list) < 0) {
868 pr_err("Not enough memory for event selector list\n");
869 goto out_symbol_exit;
870 }
871
872 if (target_pid != -1)
873 target_tid = target_pid;
874
875 if (perf_evlist__create_maps(evsel_list, target_pid,
876 target_tid, cpu_list) < 0)
877 usage_with_options(record_usage, record_options);
878
879 list_for_each_entry(pos, &evsel_list->entries, node) {
880 if (perf_evsel__alloc_fd(pos, evsel_list->cpus->nr,
881 evsel_list->threads->nr) < 0)
882 goto out_free_fd;
883 if (perf_header__push_event(pos->attr.config, event_name(pos)))
884 goto out_free_fd;
885 }
886
887 if (perf_evlist__alloc_pollfd(evsel_list) < 0)
888 goto out_free_fd;
889
890 if (user_interval != ULLONG_MAX)
891 default_interval = user_interval;
892 if (user_freq != UINT_MAX)
893 freq = user_freq;
894
895 /*
896 * User specified count overrides default frequency.
897 */
898 if (default_interval)
899 freq = 0;
900 else if (freq) {
901 default_interval = freq;
902 } else {
903 fprintf(stderr, "frequency and count are zero, aborting\n");
904 err = -EINVAL;
905 goto out_free_fd;
906 }
907
908 err = __cmd_record(argc, argv);
909 out_free_fd:
910 perf_evlist__delete_maps(evsel_list);
911 out_symbol_exit:
912 symbol__exit();
913 return err;
914 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree