Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net
[~shefty/rdma-dev.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 #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;
266
267         if (evlist->cpus->map[0] < 0)
268                 no_inherit = true;
269
270         list_for_each_entry(pos, &evlist->entries, node) {
271                 struct perf_event_attr *attr = &pos->attr;
272                 /*
273                  * Check if parse_single_tracepoint_event has already asked for
274                  * PERF_SAMPLE_TIME.
275                  *
276                  * XXX this is kludgy but short term fix for problems introduced by
277                  * eac23d1c that broke 'perf script' by having different sample_types
278                  * when using multiple tracepoint events when we use a perf binary
279                  * that tries to use sample_id_all on an older kernel.
280                  *
281                  * We need to move counter creation to perf_session, support
282                  * different sample_types, etc.
283                  */
284                 bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
285
286                 config_attr(pos, evlist);
287 retry_sample_id:
288                 attr->sample_id_all = sample_id_all_avail ? 1 : 0;
289 try_again:
290                 if (perf_evsel__open(pos, evlist->cpus, evlist->threads, group) < 0) {
291                         int err = errno;
292
293                         if (err == EPERM || err == EACCES) {
294                                 ui__warning_paranoid();
295                                 exit(EXIT_FAILURE);
296                         } else if (err ==  ENODEV && cpu_list) {
297                                 die("No such device - did you specify"
298                                         " an out-of-range profile CPU?\n");
299                         } else if (err == EINVAL && sample_id_all_avail) {
300                                 /*
301                                  * Old kernel, no attr->sample_id_type_all field
302                                  */
303                                 sample_id_all_avail = false;
304                                 if (!sample_time && !raw_samples && !time_needed)
305                                         attr->sample_type &= ~PERF_SAMPLE_TIME;
306
307                                 goto retry_sample_id;
308                         }
309
310                         /*
311                          * If it's cycles then fall back to hrtimer
312                          * based cpu-clock-tick sw counter, which
313                          * is always available even if no PMU support:
314                          */
315                         if (attr->type == PERF_TYPE_HARDWARE
316                                         && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
317
318                                 if (verbose)
319                                         ui__warning("The cycles event is not supported, "
320                                                     "trying to fall back to cpu-clock-ticks\n");
321                                 attr->type = PERF_TYPE_SOFTWARE;
322                                 attr->config = PERF_COUNT_SW_CPU_CLOCK;
323                                 goto try_again;
324                         }
325
326                         if (err == ENOENT) {
327                                 ui__warning("The %s event is not supported.\n",
328                                             event_name(pos));
329                                 exit(EXIT_FAILURE);
330                         }
331
332                         printf("\n");
333                         error("sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information.\n",
334                               err, strerror(err));
335
336 #if defined(__i386__) || defined(__x86_64__)
337                         if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
338                                 die("No hardware sampling interrupt available."
339                                     " No APIC? If so then you can boot the kernel"
340                                     " with the \"lapic\" boot parameter to"
341                                     " force-enable it.\n");
342 #endif
343
344                         die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
345                 }
346         }
347
348         if (perf_evlist__set_filters(evlist)) {
349                 error("failed to set filter with %d (%s)\n", errno,
350                         strerror(errno));
351                 exit(-1);
352         }
353
354         if (perf_evlist__mmap(evlist, mmap_pages, false) < 0)
355                 die("failed to mmap with %d (%s)\n", errno, strerror(errno));
356
357         if (file_new)
358                 session->evlist = evlist;
359         else {
360                 if (!perf_evlist__equal(session->evlist, evlist)) {
361                         fprintf(stderr, "incompatible append\n");
362                         exit(-1);
363                 }
364         }
365
366         perf_session__update_sample_type(session);
367 }
368
369 static int process_buildids(void)
370 {
371         u64 size = lseek(output, 0, SEEK_CUR);
372
373         if (size == 0)
374                 return 0;
375
376         session->fd = output;
377         return __perf_session__process_events(session, post_processing_offset,
378                                               size - post_processing_offset,
379                                               size, &build_id__mark_dso_hit_ops);
380 }
381
382 static void atexit_header(void)
383 {
384         if (!pipe_output) {
385                 session->header.data_size += bytes_written;
386
387                 if (!no_buildid)
388                         process_buildids();
389                 perf_session__write_header(session, evsel_list, output, true);
390                 perf_session__delete(session);
391                 perf_evlist__delete(evsel_list);
392                 symbol__exit();
393         }
394 }
395
396 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
397 {
398         int err;
399         struct perf_session *psession = data;
400
401         if (machine__is_host(machine))
402                 return;
403
404         /*
405          *As for guest kernel when processing subcommand record&report,
406          *we arrange module mmap prior to guest kernel mmap and trigger
407          *a preload dso because default guest module symbols are loaded
408          *from guest kallsyms instead of /lib/modules/XXX/XXX. This
409          *method is used to avoid symbol missing when the first addr is
410          *in module instead of in guest kernel.
411          */
412         err = perf_event__synthesize_modules(process_synthesized_event,
413                                              psession, machine);
414         if (err < 0)
415                 pr_err("Couldn't record guest kernel [%d]'s reference"
416                        " relocation symbol.\n", machine->pid);
417
418         /*
419          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
420          * have no _text sometimes.
421          */
422         err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
423                                                  psession, machine, "_text");
424         if (err < 0)
425                 err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
426                                                          psession, machine,
427                                                          "_stext");
428         if (err < 0)
429                 pr_err("Couldn't record guest kernel [%d]'s reference"
430                        " relocation symbol.\n", machine->pid);
431 }
432
433 static struct perf_event_header finished_round_event = {
434         .size = sizeof(struct perf_event_header),
435         .type = PERF_RECORD_FINISHED_ROUND,
436 };
437
438 static void mmap_read_all(void)
439 {
440         int i;
441
442         for (i = 0; i < evsel_list->nr_mmaps; i++) {
443                 if (evsel_list->mmap[i].base)
444                         mmap_read(&evsel_list->mmap[i]);
445         }
446
447         if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
448                 write_output(&finished_round_event, sizeof(finished_round_event));
449 }
450
451 static int __cmd_record(int argc, const char **argv)
452 {
453         struct stat st;
454         int flags;
455         int err;
456         unsigned long waking = 0;
457         int child_ready_pipe[2], go_pipe[2];
458         const bool forks = argc > 0;
459         char buf;
460         struct machine *machine;
461
462         progname = argv[0];
463
464         page_size = sysconf(_SC_PAGE_SIZE);
465
466         atexit(sig_atexit);
467         signal(SIGCHLD, sig_handler);
468         signal(SIGINT, sig_handler);
469         signal(SIGUSR1, sig_handler);
470
471         if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
472                 perror("failed to create pipes");
473                 exit(-1);
474         }
475
476         if (!output_name) {
477                 if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
478                         pipe_output = 1;
479                 else
480                         output_name = "perf.data";
481         }
482         if (output_name) {
483                 if (!strcmp(output_name, "-"))
484                         pipe_output = 1;
485                 else if (!stat(output_name, &st) && st.st_size) {
486                         if (write_mode == WRITE_FORCE) {
487                                 char oldname[PATH_MAX];
488                                 snprintf(oldname, sizeof(oldname), "%s.old",
489                                          output_name);
490                                 unlink(oldname);
491                                 rename(output_name, oldname);
492                         }
493                 } else if (write_mode == WRITE_APPEND) {
494                         write_mode = WRITE_FORCE;
495                 }
496         }
497
498         flags = O_CREAT|O_RDWR;
499         if (write_mode == WRITE_APPEND)
500                 file_new = 0;
501         else
502                 flags |= O_TRUNC;
503
504         if (pipe_output)
505                 output = STDOUT_FILENO;
506         else
507                 output = open(output_name, flags, S_IRUSR | S_IWUSR);
508         if (output < 0) {
509                 perror("failed to create output file");
510                 exit(-1);
511         }
512
513         session = perf_session__new(output_name, O_WRONLY,
514                                     write_mode == WRITE_FORCE, false, NULL);
515         if (session == NULL) {
516                 pr_err("Not enough memory for reading perf file header\n");
517                 return -1;
518         }
519
520         if (!no_buildid)
521                 perf_header__set_feat(&session->header, HEADER_BUILD_ID);
522
523         if (!file_new) {
524                 err = perf_session__read_header(session, output);
525                 if (err < 0)
526                         goto out_delete_session;
527         }
528
529         if (have_tracepoints(&evsel_list->entries))
530                 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
531
532         perf_header__set_feat(&session->header, HEADER_HOSTNAME);
533         perf_header__set_feat(&session->header, HEADER_OSRELEASE);
534         perf_header__set_feat(&session->header, HEADER_ARCH);
535         perf_header__set_feat(&session->header, HEADER_CPUDESC);
536         perf_header__set_feat(&session->header, HEADER_NRCPUS);
537         perf_header__set_feat(&session->header, HEADER_EVENT_DESC);
538         perf_header__set_feat(&session->header, HEADER_CMDLINE);
539         perf_header__set_feat(&session->header, HEADER_VERSION);
540         perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);
541         perf_header__set_feat(&session->header, HEADER_TOTAL_MEM);
542         perf_header__set_feat(&session->header, HEADER_NUMA_TOPOLOGY);
543         perf_header__set_feat(&session->header, HEADER_CPUID);
544
545         /* 512 kiB: default amount of unprivileged mlocked memory */
546         if (mmap_pages == UINT_MAX)
547                 mmap_pages = (512 * 1024) / page_size;
548
549         if (forks) {
550                 child_pid = fork();
551                 if (child_pid < 0) {
552                         perror("failed to fork");
553                         exit(-1);
554                 }
555
556                 if (!child_pid) {
557                         if (pipe_output)
558                                 dup2(2, 1);
559                         close(child_ready_pipe[0]);
560                         close(go_pipe[1]);
561                         fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
562
563                         /*
564                          * Do a dummy execvp to get the PLT entry resolved,
565                          * so we avoid the resolver overhead on the real
566                          * execvp call.
567                          */
568                         execvp("", (char **)argv);
569
570                         /*
571                          * Tell the parent we're ready to go
572                          */
573                         close(child_ready_pipe[1]);
574
575                         /*
576                          * Wait until the parent tells us to go.
577                          */
578                         if (read(go_pipe[0], &buf, 1) == -1)
579                                 perror("unable to read pipe");
580
581                         execvp(argv[0], (char **)argv);
582
583                         perror(argv[0]);
584                         kill(getppid(), SIGUSR1);
585                         exit(-1);
586                 }
587
588                 if (!system_wide && target_tid == -1 && target_pid == -1)
589                         evsel_list->threads->map[0] = child_pid;
590
591                 close(child_ready_pipe[1]);
592                 close(go_pipe[0]);
593                 /*
594                  * wait for child to settle
595                  */
596                 if (read(child_ready_pipe[0], &buf, 1) == -1) {
597                         perror("unable to read pipe");
598                         exit(-1);
599                 }
600                 close(child_ready_pipe[0]);
601         }
602
603         open_counters(evsel_list);
604
605         /*
606          * perf_session__delete(session) will be called at atexit_header()
607          */
608         atexit(atexit_header);
609
610         if (pipe_output) {
611                 err = perf_header__write_pipe(output);
612                 if (err < 0)
613                         return err;
614         } else if (file_new) {
615                 err = perf_session__write_header(session, evsel_list,
616                                                  output, false);
617                 if (err < 0)
618                         return err;
619         }
620
621         post_processing_offset = lseek(output, 0, SEEK_CUR);
622
623         if (pipe_output) {
624                 err = perf_session__synthesize_attrs(session,
625                                                      process_synthesized_event);
626                 if (err < 0) {
627                         pr_err("Couldn't synthesize attrs.\n");
628                         return err;
629                 }
630
631                 err = perf_event__synthesize_event_types(process_synthesized_event,
632                                                          session);
633                 if (err < 0) {
634                         pr_err("Couldn't synthesize event_types.\n");
635                         return err;
636                 }
637
638                 if (have_tracepoints(&evsel_list->entries)) {
639                         /*
640                          * FIXME err <= 0 here actually means that
641                          * there were no tracepoints so its not really
642                          * an error, just that we don't need to
643                          * synthesize anything.  We really have to
644                          * return this more properly and also
645                          * propagate errors that now are calling die()
646                          */
647                         err = perf_event__synthesize_tracing_data(output, evsel_list,
648                                                                   process_synthesized_event,
649                                                                   session);
650                         if (err <= 0) {
651                                 pr_err("Couldn't record tracing data.\n");
652                                 return err;
653                         }
654                         advance_output(err);
655                 }
656         }
657
658         machine = perf_session__find_host_machine(session);
659         if (!machine) {
660                 pr_err("Couldn't find native kernel information.\n");
661                 return -1;
662         }
663
664         err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
665                                                  session, machine, "_text");
666         if (err < 0)
667                 err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
668                                                          session, machine, "_stext");
669         if (err < 0)
670                 pr_err("Couldn't record kernel reference relocation symbol\n"
671                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
672                        "Check /proc/kallsyms permission or run as root.\n");
673
674         err = perf_event__synthesize_modules(process_synthesized_event,
675                                              session, machine);
676         if (err < 0)
677                 pr_err("Couldn't record kernel module information.\n"
678                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
679                        "Check /proc/modules permission or run as root.\n");
680
681         if (perf_guest)
682                 perf_session__process_machines(session,
683                                                perf_event__synthesize_guest_os);
684
685         if (!system_wide)
686                 perf_event__synthesize_thread_map(evsel_list->threads,
687                                                   process_synthesized_event,
688                                                   session);
689         else
690                 perf_event__synthesize_threads(process_synthesized_event,
691                                                session);
692
693         if (realtime_prio) {
694                 struct sched_param param;
695
696                 param.sched_priority = realtime_prio;
697                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
698                         pr_err("Could not set realtime priority.\n");
699                         exit(-1);
700                 }
701         }
702
703         perf_evlist__enable(evsel_list);
704
705         /*
706          * Let the child rip
707          */
708         if (forks)
709                 close(go_pipe[1]);
710
711         for (;;) {
712                 int hits = samples;
713
714                 mmap_read_all();
715
716                 if (hits == samples) {
717                         if (done)
718                                 break;
719                         err = poll(evsel_list->pollfd, evsel_list->nr_fds, -1);
720                         waking++;
721                 }
722
723                 if (done)
724                         perf_evlist__disable(evsel_list);
725         }
726
727         if (quiet || signr == SIGUSR1)
728                 return 0;
729
730         fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
731
732         /*
733          * Approximate RIP event size: 24 bytes.
734          */
735         fprintf(stderr,
736                 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
737                 (double)bytes_written / 1024.0 / 1024.0,
738                 output_name,
739                 bytes_written / 24);
740
741         return 0;
742
743 out_delete_session:
744         perf_session__delete(session);
745         return err;
746 }
747
748 static const char * const record_usage[] = {
749         "perf record [<options>] [<command>]",
750         "perf record [<options>] -- <command> [<options>]",
751         NULL
752 };
753
754 static bool force, append_file;
755
756 const struct option record_options[] = {
757         OPT_CALLBACK('e', "event", &evsel_list, "event",
758                      "event selector. use 'perf list' to list available events",
759                      parse_events_option),
760         OPT_CALLBACK(0, "filter", &evsel_list, "filter",
761                      "event filter", parse_filter),
762         OPT_INTEGER('p', "pid", &target_pid,
763                     "record events on existing process id"),
764         OPT_INTEGER('t', "tid", &target_tid,
765                     "record events on existing thread id"),
766         OPT_INTEGER('r', "realtime", &realtime_prio,
767                     "collect data with this RT SCHED_FIFO priority"),
768         OPT_BOOLEAN('D', "no-delay", &nodelay,
769                     "collect data without buffering"),
770         OPT_BOOLEAN('R', "raw-samples", &raw_samples,
771                     "collect raw sample records from all opened counters"),
772         OPT_BOOLEAN('a', "all-cpus", &system_wide,
773                             "system-wide collection from all CPUs"),
774         OPT_BOOLEAN('A', "append", &append_file,
775                             "append to the output file to do incremental profiling"),
776         OPT_STRING('C', "cpu", &cpu_list, "cpu",
777                     "list of cpus to monitor"),
778         OPT_BOOLEAN('f', "force", &force,
779                         "overwrite existing data file (deprecated)"),
780         OPT_U64('c', "count", &user_interval, "event period to sample"),
781         OPT_STRING('o', "output", &output_name, "file",
782                     "output file name"),
783         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
784                     "child tasks do not inherit counters"),
785         OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
786         OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
787         OPT_BOOLEAN(0, "group", &group,
788                     "put the counters into a counter group"),
789         OPT_BOOLEAN('g', "call-graph", &call_graph,
790                     "do call-graph (stack chain/backtrace) recording"),
791         OPT_INCR('v', "verbose", &verbose,
792                     "be more verbose (show counter open errors, etc)"),
793         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
794         OPT_BOOLEAN('s', "stat", &inherit_stat,
795                     "per thread counts"),
796         OPT_BOOLEAN('d', "data", &sample_address,
797                     "Sample addresses"),
798         OPT_BOOLEAN('T', "timestamp", &sample_time, "Sample timestamps"),
799         OPT_BOOLEAN('n', "no-samples", &no_samples,
800                     "don't sample"),
801         OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
802                     "do not update the buildid cache"),
803         OPT_BOOLEAN('B', "no-buildid", &no_buildid,
804                     "do not collect buildids in perf.data"),
805         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
806                      "monitor event in cgroup name only",
807                      parse_cgroups),
808         OPT_END()
809 };
810
811 int cmd_record(int argc, const char **argv, const char *prefix __used)
812 {
813         int err = -ENOMEM;
814         struct perf_evsel *pos;
815
816         perf_header__set_cmdline(argc, argv);
817
818         evsel_list = perf_evlist__new(NULL, NULL);
819         if (evsel_list == NULL)
820                 return -ENOMEM;
821
822         argc = parse_options(argc, argv, record_options, record_usage,
823                             PARSE_OPT_STOP_AT_NON_OPTION);
824         if (!argc && target_pid == -1 && target_tid == -1 &&
825                 !system_wide && !cpu_list)
826                 usage_with_options(record_usage, record_options);
827
828         if (force && append_file) {
829                 fprintf(stderr, "Can't overwrite and append at the same time."
830                                 " You need to choose between -f and -A");
831                 usage_with_options(record_usage, record_options);
832         } else if (append_file) {
833                 write_mode = WRITE_APPEND;
834         } else {
835                 write_mode = WRITE_FORCE;
836         }
837
838         if (nr_cgroups && !system_wide) {
839                 fprintf(stderr, "cgroup monitoring only available in"
840                         " system-wide mode\n");
841                 usage_with_options(record_usage, record_options);
842         }
843
844         symbol__init();
845
846         if (symbol_conf.kptr_restrict)
847                 pr_warning(
848 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
849 "check /proc/sys/kernel/kptr_restrict.\n\n"
850 "Samples in kernel functions may not be resolved if a suitable vmlinux\n"
851 "file is not found in the buildid cache or in the vmlinux path.\n\n"
852 "Samples in kernel modules won't be resolved at all.\n\n"
853 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
854 "even with a suitable vmlinux or kallsyms file.\n\n");
855
856         if (no_buildid_cache || no_buildid)
857                 disable_buildid_cache();
858
859         if (evsel_list->nr_entries == 0 &&
860             perf_evlist__add_default(evsel_list) < 0) {
861                 pr_err("Not enough memory for event selector list\n");
862                 goto out_symbol_exit;
863         }
864
865         if (target_pid != -1)
866                 target_tid = target_pid;
867
868         if (perf_evlist__create_maps(evsel_list, target_pid,
869                                      target_tid, cpu_list) < 0)
870                 usage_with_options(record_usage, record_options);
871
872         list_for_each_entry(pos, &evsel_list->entries, node) {
873                 if (perf_evsel__alloc_fd(pos, evsel_list->cpus->nr,
874                                          evsel_list->threads->nr) < 0)
875                         goto out_free_fd;
876                 if (perf_header__push_event(pos->attr.config, event_name(pos)))
877                         goto out_free_fd;
878         }
879
880         if (perf_evlist__alloc_pollfd(evsel_list) < 0)
881                 goto out_free_fd;
882
883         if (user_interval != ULLONG_MAX)
884                 default_interval = user_interval;
885         if (user_freq != UINT_MAX)
886                 freq = user_freq;
887
888         /*
889          * User specified count overrides default frequency.
890          */
891         if (default_interval)
892                 freq = 0;
893         else if (freq) {
894                 default_interval = freq;
895         } else {
896                 fprintf(stderr, "frequency and count are zero, aborting\n");
897                 err = -EINVAL;
898                 goto out_free_fd;
899         }
900
901         err = __cmd_record(argc, argv);
902 out_free_fd:
903         perf_evlist__delete_maps(evsel_list);
904 out_symbol_exit:
905         symbol__exit();
906         return err;
907 }