blob: 39c7486f0607b21ceb0e4ee1d4ab262a03d90ff8 [file] [log] [blame]
Ingo Molnarabaff322009-06-02 22:59:57 +02001/*
Ingo Molnarbf9e1872009-06-02 23:37:05 +02002 * 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.
Ingo Molnarabaff322009-06-02 22:59:57 +02007 */
Ingo Molnar16f762a2009-05-27 09:10:38 +02008#include "builtin.h"
Ingo Molnarbf9e1872009-06-02 23:37:05 +02009
10#include "perf.h"
11
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -020012#include "util/build-id.h"
Thomas Gleixner6eda5832009-05-01 18:29:57 +020013#include "util/util.h"
Josh Poimboeuf4b6ab942015-12-15 09:39:39 -060014#include <subcmd/parse-options.h>
Ingo Molnar8ad8db32009-05-26 11:10:09 +020015#include "util/parse-events.h"
Taeung Song41840d22016-06-23 17:55:17 +090016#include "util/config.h"
Thomas Gleixner6eda5832009-05-01 18:29:57 +020017
Arnaldo Carvalho de Melo8f651ea2014-10-09 16:12:24 -030018#include "util/callchain.h"
Arnaldo Carvalho de Melof14d5702014-10-17 12:17:40 -030019#include "util/cgroup.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020020#include "util/header.h"
Frederic Weisbecker66e274f2009-08-12 11:07:25 +020021#include "util/event.h"
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020022#include "util/evlist.h"
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -020023#include "util/evsel.h"
Frederic Weisbecker8f288272009-08-16 22:05:48 +020024#include "util/debug.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020025#include "util/session.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020026#include "util/tool.h"
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020027#include "util/symbol.h"
Paul Mackerrasa12b51c2010-03-10 20:36:09 +110028#include "util/cpumap.h"
Arnaldo Carvalho de Melofd782602011-01-18 15:15:24 -020029#include "util/thread_map.h"
Jiri Olsaf5fc14122013-10-15 16:27:32 +020030#include "util/data.h"
Stephane Eranianbcc84ec2015-08-31 18:41:12 +020031#include "util/perf_regs.h"
Adrian Hunteref149c22015-04-09 18:53:45 +030032#include "util/auxtrace.h"
Adrian Hunter46bc29b2016-03-08 10:38:44 +020033#include "util/tsc.h"
Andi Kleenf00898f2015-05-27 10:51:51 -070034#include "util/parse-branch-options.h"
Stephane Eranianbcc84ec2015-08-31 18:41:12 +020035#include "util/parse-regs-options.h"
Wang Nan71dc23262015-10-14 12:41:19 +000036#include "util/llvm-utils.h"
Wang Nan8690a2a2016-02-22 09:10:32 +000037#include "util/bpf-loader.h"
Wang Nan5f9cf592016-04-20 18:59:49 +000038#include "util/trigger.h"
Wang Nand8871ea2016-02-26 09:32:06 +000039#include "asm/bug.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020040
Peter Zijlstra97124d5e2009-06-02 15:52:24 +020041#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020042#include <sched.h>
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -030043#include <sys/mman.h>
Wang Nan2d11c652016-05-23 07:13:39 +000044#include <asm/bug.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020045
Bernhard Rosenkraenzer78da39f2012-10-08 09:43:26 +030046
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030047struct record {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020048 struct perf_tool tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -030049 struct record_opts opts;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020050 u64 bytes_written;
Jiri Olsaf5fc14122013-10-15 16:27:32 +020051 struct perf_data_file file;
Adrian Hunteref149c22015-04-09 18:53:45 +030052 struct auxtrace_record *itr;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020053 struct perf_evlist *evlist;
54 struct perf_session *session;
55 const char *progname;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020056 int realtime_prio;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020057 bool no_buildid;
Wang Nand2db9a92016-01-25 09:56:19 +000058 bool no_buildid_set;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020059 bool no_buildid_cache;
Wang Nand2db9a92016-01-25 09:56:19 +000060 bool no_buildid_cache_set;
Namhyung Kim61566812016-01-11 22:37:09 +090061 bool buildid_all;
Wang Nanecfd7a92016-04-13 08:21:07 +000062 bool timestamp_filename;
Wang Nan3c1cb7e2016-04-20 18:59:50 +000063 bool switch_output;
Yang Shi9f065192015-09-29 14:49:43 -070064 unsigned long long samples;
Arnaldo Carvalho de Melo0f82ebc2011-11-08 14:41:57 -020065};
Ingo Molnara21ca2c2009-06-06 09:58:57 +020066
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030067static int record__write(struct record *rec, void *bf, size_t size)
Peter Zijlstraf5970552009-06-18 23:22:55 +020068{
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -030069 if (perf_data_file__write(rec->session->file, bf, size) < 0) {
Jiri Olsa50a9b862013-11-22 13:11:24 +010070 pr_err("failed to write perf data, error: %m\n");
71 return -1;
Peter Zijlstraf5970552009-06-18 23:22:55 +020072 }
David Ahern8d3eca22012-08-26 12:24:47 -060073
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -030074 rec->bytes_written += size;
David Ahern8d3eca22012-08-26 12:24:47 -060075 return 0;
Peter Zijlstraf5970552009-06-18 23:22:55 +020076}
77
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020078static int process_synthesized_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020079 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +030080 struct perf_sample *sample __maybe_unused,
81 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -020082{
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030083 struct record *rec = container_of(tool, struct record, tool);
84 return record__write(rec, event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -020085}
86
Wang Nan3a62a7b2016-05-23 07:13:41 +000087static int
88backward_rb_find_range(void *buf, int mask, u64 head, u64 *start, u64 *end)
89{
90 struct perf_event_header *pheader;
91 u64 evt_head = head;
92 int size = mask + 1;
93
94 pr_debug2("backward_rb_find_range: buf=%p, head=%"PRIx64"\n", buf, head);
95 pheader = (struct perf_event_header *)(buf + (head & mask));
96 *start = head;
97 while (true) {
98 if (evt_head - head >= (unsigned int)size) {
99 pr_debug("Finshed reading backward ring buffer: rewind\n");
100 if (evt_head - head > (unsigned int)size)
101 evt_head -= pheader->size;
102 *end = evt_head;
103 return 0;
104 }
105
106 pheader = (struct perf_event_header *)(buf + (evt_head & mask));
107
108 if (pheader->size == 0) {
109 pr_debug("Finshed reading backward ring buffer: get start\n");
110 *end = evt_head;
111 return 0;
112 }
113
114 evt_head += pheader->size;
115 pr_debug3("move evt_head: %"PRIx64"\n", evt_head);
116 }
117 WARN_ONCE(1, "Shouldn't get here\n");
118 return -1;
119}
120
121static int
Wang Nana4ea0ec2016-07-14 08:34:36 +0000122rb_find_range(void *data, int mask, u64 head, u64 old,
123 u64 *start, u64 *end, bool backward)
Wang Nan3a62a7b2016-05-23 07:13:41 +0000124{
Wang Nana4ea0ec2016-07-14 08:34:36 +0000125 if (!backward) {
Wang Nan3a62a7b2016-05-23 07:13:41 +0000126 *start = old;
127 *end = head;
128 return 0;
129 }
130
131 return backward_rb_find_range(data, mask, head, start, end);
132}
133
Wang Nana4ea0ec2016-07-14 08:34:36 +0000134static int
135record__mmap_read(struct record *rec, struct perf_mmap *md,
136 bool overwrite, bool backward)
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200137{
David Ahern7b8283b52015-04-07 09:20:37 -0600138 u64 head = perf_mmap__read_head(md);
139 u64 old = md->prev;
Wang Nan09fa4f42016-05-23 07:13:40 +0000140 u64 end = head, start = old;
Jiri Olsa918512b2013-09-12 18:39:35 +0200141 unsigned char *data = md->base + page_size;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200142 unsigned long size;
143 void *buf;
David Ahern8d3eca22012-08-26 12:24:47 -0600144 int rc = 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200145
Wang Nana4ea0ec2016-07-14 08:34:36 +0000146 if (rb_find_range(data, md->mask, head,
147 old, &start, &end, backward))
Wang Nan3a62a7b2016-05-23 07:13:41 +0000148 return -1;
149
Wang Nan09fa4f42016-05-23 07:13:40 +0000150 if (start == end)
David Ahern8d3eca22012-08-26 12:24:47 -0600151 return 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200152
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200153 rec->samples++;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200154
Wang Nan09fa4f42016-05-23 07:13:40 +0000155 size = end - start;
Wang Nan2d11c652016-05-23 07:13:39 +0000156 if (size > (unsigned long)(md->mask) + 1) {
157 WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n");
158
159 md->prev = head;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000160 perf_mmap__consume(md, overwrite || backward);
Wang Nan2d11c652016-05-23 07:13:39 +0000161 return 0;
162 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200163
Wang Nan09fa4f42016-05-23 07:13:40 +0000164 if ((start & md->mask) + size != (end & md->mask)) {
165 buf = &data[start & md->mask];
166 size = md->mask + 1 - (start & md->mask);
167 start += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200168
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300169 if (record__write(rec, buf, size) < 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600170 rc = -1;
171 goto out;
172 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200173 }
174
Wang Nan09fa4f42016-05-23 07:13:40 +0000175 buf = &data[start & md->mask];
176 size = end - start;
177 start += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200178
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300179 if (record__write(rec, buf, size) < 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600180 rc = -1;
181 goto out;
182 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200183
Wang Nan09fa4f42016-05-23 07:13:40 +0000184 md->prev = head;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000185 perf_mmap__consume(md, overwrite || backward);
David Ahern8d3eca22012-08-26 12:24:47 -0600186out:
187 return rc;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200188}
189
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300190static volatile int done;
191static volatile int signr = -1;
192static volatile int child_finished;
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000193
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300194static volatile int auxtrace_record__snapshot_started;
Wang Nan5f9cf592016-04-20 18:59:49 +0000195static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000196static DEFINE_TRIGGER(switch_output_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300197
198static void sig_handler(int sig)
199{
200 if (sig == SIGCHLD)
201 child_finished = 1;
202 else
203 signr = sig;
204
205 done = 1;
206}
207
208static void record__sig_exit(void)
209{
210 if (signr == -1)
211 return;
212
213 signal(signr, SIG_DFL);
214 raise(signr);
215}
216
Adrian Huntere31f0d02015-04-30 17:37:27 +0300217#ifdef HAVE_AUXTRACE_SUPPORT
218
Adrian Hunteref149c22015-04-09 18:53:45 +0300219static int record__process_auxtrace(struct perf_tool *tool,
220 union perf_event *event, void *data1,
221 size_t len1, void *data2, size_t len2)
222{
223 struct record *rec = container_of(tool, struct record, tool);
Adrian Hunter99fa2982015-04-30 17:37:25 +0300224 struct perf_data_file *file = &rec->file;
Adrian Hunteref149c22015-04-09 18:53:45 +0300225 size_t padding;
226 u8 pad[8] = {0};
227
Adrian Hunter99fa2982015-04-30 17:37:25 +0300228 if (!perf_data_file__is_pipe(file)) {
229 off_t file_offset;
230 int fd = perf_data_file__fd(file);
231 int err;
232
233 file_offset = lseek(fd, 0, SEEK_CUR);
234 if (file_offset == -1)
235 return -1;
236 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
237 event, file_offset);
238 if (err)
239 return err;
240 }
241
Adrian Hunteref149c22015-04-09 18:53:45 +0300242 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
243 padding = (len1 + len2) & 7;
244 if (padding)
245 padding = 8 - padding;
246
247 record__write(rec, event, event->header.size);
248 record__write(rec, data1, len1);
249 if (len2)
250 record__write(rec, data2, len2);
251 record__write(rec, &pad, padding);
252
253 return 0;
254}
255
256static int record__auxtrace_mmap_read(struct record *rec,
257 struct auxtrace_mmap *mm)
258{
259 int ret;
260
261 ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
262 record__process_auxtrace);
263 if (ret < 0)
264 return ret;
265
266 if (ret)
267 rec->samples++;
268
269 return 0;
270}
271
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300272static int record__auxtrace_mmap_read_snapshot(struct record *rec,
273 struct auxtrace_mmap *mm)
274{
275 int ret;
276
277 ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
278 record__process_auxtrace,
279 rec->opts.auxtrace_snapshot_size);
280 if (ret < 0)
281 return ret;
282
283 if (ret)
284 rec->samples++;
285
286 return 0;
287}
288
289static int record__auxtrace_read_snapshot_all(struct record *rec)
290{
291 int i;
292 int rc = 0;
293
294 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
295 struct auxtrace_mmap *mm =
296 &rec->evlist->mmap[i].auxtrace_mmap;
297
298 if (!mm->base)
299 continue;
300
301 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
302 rc = -1;
303 goto out;
304 }
305 }
306out:
307 return rc;
308}
309
310static void record__read_auxtrace_snapshot(struct record *rec)
311{
312 pr_debug("Recording AUX area tracing snapshot\n");
313 if (record__auxtrace_read_snapshot_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +0000314 trigger_error(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300315 } else {
Wang Nan5f9cf592016-04-20 18:59:49 +0000316 if (auxtrace_record__snapshot_finish(rec->itr))
317 trigger_error(&auxtrace_snapshot_trigger);
318 else
319 trigger_ready(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300320 }
321}
322
Adrian Huntere31f0d02015-04-30 17:37:27 +0300323#else
324
325static inline
326int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
327 struct auxtrace_mmap *mm __maybe_unused)
328{
329 return 0;
330}
331
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300332static inline
333void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
334{
335}
336
337static inline
338int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
339{
340 return 0;
341}
342
Adrian Huntere31f0d02015-04-30 17:37:27 +0300343#endif
344
Wang Nancda57a82016-06-27 10:24:03 +0000345static int record__mmap_evlist(struct record *rec,
346 struct perf_evlist *evlist)
347{
348 struct record_opts *opts = &rec->opts;
349 char msg[512];
350
351 if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
352 opts->auxtrace_mmap_pages,
353 opts->auxtrace_snapshot_mode) < 0) {
354 if (errno == EPERM) {
355 pr_err("Permission error mapping pages.\n"
356 "Consider increasing "
357 "/proc/sys/kernel/perf_event_mlock_kb,\n"
358 "or try again with a smaller value of -m/--mmap_pages.\n"
359 "(current value: %u,%u)\n",
360 opts->mmap_pages, opts->auxtrace_mmap_pages);
361 return -errno;
362 } else {
363 pr_err("failed to mmap with %d (%s)\n", errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300364 str_error_r(errno, msg, sizeof(msg)));
Wang Nancda57a82016-06-27 10:24:03 +0000365 if (errno)
366 return -errno;
367 else
368 return -EINVAL;
369 }
370 }
371 return 0;
372}
373
374static int record__mmap(struct record *rec)
375{
376 return record__mmap_evlist(rec, rec->evlist);
377}
378
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300379static int record__open(struct record *rec)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200380{
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300381 char msg[512];
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200382 struct perf_evsel *pos;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200383 struct perf_evlist *evlist = rec->evlist;
384 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300385 struct record_opts *opts = &rec->opts;
David Ahern8d3eca22012-08-26 12:24:47 -0600386 int rc = 0;
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200387
Arnaldo Carvalho de Meloe68ae9c2016-04-11 18:15:29 -0300388 perf_evlist__config(evlist, opts, &callchain_param);
Jiri Olsacac21422012-11-12 18:34:00 +0100389
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300390 evlist__for_each_entry(evlist, pos) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200391try_again:
Kan Liangd988d5e2015-08-21 02:23:14 -0400392 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300393 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300394 if (verbose)
Arnaldo Carvalho de Meloc0a54342012-12-13 14:16:30 -0300395 ui__warning("%s\n", msg);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300396 goto try_again;
397 }
David Ahernca6a4252011-03-25 13:11:11 -0600398
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300399 rc = -errno;
400 perf_evsel__open_strerror(pos, &opts->target,
401 errno, msg, sizeof(msg));
402 ui__error("%s\n", msg);
David Ahern8d3eca22012-08-26 12:24:47 -0600403 goto out;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300404 }
Li Zefanc171b552009-10-15 11:22:07 +0800405 }
Arnaldo Carvalho de Meloa43d3f02010-12-25 12:12:25 -0200406
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300407 if (perf_evlist__apply_filters(evlist, &pos)) {
408 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
409 pos->filter, perf_evsel__name(pos), errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300410 str_error_r(errno, msg, sizeof(msg)));
David Ahern8d3eca22012-08-26 12:24:47 -0600411 rc = -1;
412 goto out;
Frederic Weisbecker0a102472011-02-26 04:51:54 +0100413 }
414
Wang Nancda57a82016-06-27 10:24:03 +0000415 rc = record__mmap(rec);
416 if (rc)
David Ahern8d3eca22012-08-26 12:24:47 -0600417 goto out;
Arnaldo Carvalho de Melo0a27d7f2011-01-14 15:50:51 -0200418
Jiri Olsa563aecb2013-06-05 13:35:06 +0200419 session->evlist = evlist;
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300420 perf_session__set_id_hdr_size(session);
David Ahern8d3eca22012-08-26 12:24:47 -0600421out:
422 return rc;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200423}
424
Namhyung Kime3d59112015-01-29 17:06:44 +0900425static int process_sample_event(struct perf_tool *tool,
426 union perf_event *event,
427 struct perf_sample *sample,
428 struct perf_evsel *evsel,
429 struct machine *machine)
430{
431 struct record *rec = container_of(tool, struct record, tool);
432
433 rec->samples++;
434
435 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
436}
437
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300438static int process_buildids(struct record *rec)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200439{
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200440 struct perf_data_file *file = &rec->file;
441 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200442
He Kuang457ae942015-05-28 13:17:30 +0000443 if (file->size == 0)
Arnaldo Carvalho de Melo9f591fd2010-03-11 15:53:11 -0300444 return 0;
445
Namhyung Kim00dc8652014-11-04 10:14:32 +0900446 /*
447 * During this process, it'll load kernel map and replace the
448 * dso->long_name to a real pathname it found. In this case
449 * we prefer the vmlinux path like
450 * /lib/modules/3.16.4/build/vmlinux
451 *
452 * rather than build-id path (in debug directory).
453 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
454 */
455 symbol_conf.ignore_vmlinux_buildid = true;
456
Namhyung Kim61566812016-01-11 22:37:09 +0900457 /*
458 * If --buildid-all is given, it marks all DSO regardless of hits,
459 * so no need to process samples.
460 */
461 if (rec->buildid_all)
462 rec->tool.sample = NULL;
463
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300464 return perf_session__process_events(session);
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200465}
466
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200467static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800468{
469 int err;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200470 struct perf_tool *tool = data;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800471 /*
472 *As for guest kernel when processing subcommand record&report,
473 *we arrange module mmap prior to guest kernel mmap and trigger
474 *a preload dso because default guest module symbols are loaded
475 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
476 *method is used to avoid symbol missing when the first addr is
477 *in module instead of in guest kernel.
478 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200479 err = perf_event__synthesize_modules(tool, process_synthesized_event,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200480 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800481 if (err < 0)
482 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300483 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800484
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800485 /*
486 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
487 * have no _text sometimes.
488 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200489 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
Adrian Hunter0ae617b2014-01-29 16:14:40 +0200490 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800491 if (err < 0)
492 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300493 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800494}
495
Frederic Weisbecker98402802010-05-02 22:05:29 +0200496static struct perf_event_header finished_round_event = {
497 .size = sizeof(struct perf_event_header),
498 .type = PERF_RECORD_FINISHED_ROUND,
499};
500
Wang Nana4ea0ec2016-07-14 08:34:36 +0000501static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist,
502 bool backward)
Frederic Weisbecker98402802010-05-02 22:05:29 +0200503{
Jiri Olsadcabb502014-07-25 16:56:16 +0200504 u64 bytes_written = rec->bytes_written;
Peter Zijlstra0e2e63d2010-05-20 14:45:26 +0200505 int i;
David Ahern8d3eca22012-08-26 12:24:47 -0600506 int rc = 0;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000507 struct perf_mmap *maps;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200508
Wang Nancb216862016-06-27 10:24:04 +0000509 if (!evlist)
510 return 0;
Adrian Hunteref149c22015-04-09 18:53:45 +0300511
Wang Nanb2cb6152016-07-14 08:34:39 +0000512 maps = backward ? evlist->backward_mmap : evlist->mmap;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000513 if (!maps)
514 return 0;
Wang Nancb216862016-06-27 10:24:04 +0000515
Wang Nan54cc54d2016-07-14 08:34:42 +0000516 if (backward && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
517 return 0;
518
Wang Nana4ea0ec2016-07-14 08:34:36 +0000519 for (i = 0; i < evlist->nr_mmaps; i++) {
520 struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
521
522 if (maps[i].base) {
523 if (record__mmap_read(rec, &maps[i],
524 evlist->overwrite, backward) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600525 rc = -1;
526 goto out;
527 }
528 }
Adrian Hunteref149c22015-04-09 18:53:45 +0300529
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300530 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
Adrian Hunteref149c22015-04-09 18:53:45 +0300531 record__auxtrace_mmap_read(rec, mm) != 0) {
532 rc = -1;
533 goto out;
534 }
Frederic Weisbecker98402802010-05-02 22:05:29 +0200535 }
536
Jiri Olsadcabb502014-07-25 16:56:16 +0200537 /*
538 * Mark the round finished in case we wrote
539 * at least one event.
540 */
541 if (bytes_written != rec->bytes_written)
542 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
David Ahern8d3eca22012-08-26 12:24:47 -0600543
Wang Nan54cc54d2016-07-14 08:34:42 +0000544 if (backward)
545 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
David Ahern8d3eca22012-08-26 12:24:47 -0600546out:
547 return rc;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200548}
549
Wang Nancb216862016-06-27 10:24:04 +0000550static int record__mmap_read_all(struct record *rec)
551{
552 int err;
553
Wang Nana4ea0ec2016-07-14 08:34:36 +0000554 err = record__mmap_read_evlist(rec, rec->evlist, false);
Wang Nancb216862016-06-27 10:24:04 +0000555 if (err)
556 return err;
557
Wang Nan057374642016-07-14 08:34:43 +0000558 return record__mmap_read_evlist(rec, rec->evlist, true);
Wang Nancb216862016-06-27 10:24:04 +0000559}
560
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300561static void record__init_features(struct record *rec)
David Ahern57706ab2013-11-06 11:41:34 -0700562{
David Ahern57706ab2013-11-06 11:41:34 -0700563 struct perf_session *session = rec->session;
564 int feat;
565
566 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
567 perf_header__set_feat(&session->header, feat);
568
569 if (rec->no_buildid)
570 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
571
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300572 if (!have_tracepoints(&rec->evlist->entries))
David Ahern57706ab2013-11-06 11:41:34 -0700573 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
574
575 if (!rec->opts.branch_stack)
576 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
Adrian Hunteref149c22015-04-09 18:53:45 +0300577
578 if (!rec->opts.full_auxtrace)
579 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
Jiri Olsaffa517a2015-10-25 15:51:43 +0100580
581 perf_header__clear_feat(&session->header, HEADER_STAT);
David Ahern57706ab2013-11-06 11:41:34 -0700582}
583
Wang Nane1ab48b2016-02-26 09:32:10 +0000584static void
585record__finish_output(struct record *rec)
586{
587 struct perf_data_file *file = &rec->file;
588 int fd = perf_data_file__fd(file);
589
590 if (file->is_pipe)
591 return;
592
593 rec->session->header.data_size += rec->bytes_written;
594 file->size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
595
596 if (!rec->no_buildid) {
597 process_buildids(rec);
598
599 if (rec->buildid_all)
600 dsos__hit_all(rec->session);
601 }
602 perf_session__write_header(rec->session, rec->evlist, fd, true);
603
604 return;
605}
606
Wang Nanbe7b0c92016-04-20 18:59:54 +0000607static int record__synthesize_workload(struct record *rec)
608{
609 struct {
610 struct thread_map map;
611 struct thread_map_data map_data;
612 } thread_map;
613
614 thread_map.map.nr = 1;
615 thread_map.map.map[0].pid = rec->evlist->workload.pid;
616 thread_map.map.map[0].comm = NULL;
617 return perf_event__synthesize_thread_map(&rec->tool, &thread_map.map,
618 process_synthesized_event,
619 &rec->session->machines.host,
620 rec->opts.sample_address,
621 rec->opts.proc_map_timeout);
622}
623
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000624static int record__synthesize(struct record *rec);
625
Wang Nanecfd7a92016-04-13 08:21:07 +0000626static int
627record__switch_output(struct record *rec, bool at_exit)
628{
629 struct perf_data_file *file = &rec->file;
630 int fd, err;
631
632 /* Same Size: "2015122520103046"*/
633 char timestamp[] = "InvalidTimestamp";
634
635 rec->samples = 0;
636 record__finish_output(rec);
637 err = fetch_current_timestamp(timestamp, sizeof(timestamp));
638 if (err) {
639 pr_err("Failed to get current timestamp\n");
640 return -EINVAL;
641 }
642
643 fd = perf_data_file__switch(file, timestamp,
644 rec->session->header.data_offset,
645 at_exit);
646 if (fd >= 0 && !at_exit) {
647 rec->bytes_written = 0;
648 rec->session->header.data_size = 0;
649 }
650
651 if (!quiet)
652 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
653 file->path, timestamp);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000654
655 /* Output tracking events */
Wang Nanbe7b0c92016-04-20 18:59:54 +0000656 if (!at_exit) {
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000657 record__synthesize(rec);
658
Wang Nanbe7b0c92016-04-20 18:59:54 +0000659 /*
660 * In 'perf record --switch-output' without -a,
661 * record__synthesize() in record__switch_output() won't
662 * generate tracking events because there's no thread_map
663 * in evlist. Which causes newly created perf.data doesn't
664 * contain map and comm information.
665 * Create a fake thread_map and directly call
666 * perf_event__synthesize_thread_map() for those events.
667 */
668 if (target__none(&rec->opts.target))
669 record__synthesize_workload(rec);
670 }
Wang Nanecfd7a92016-04-13 08:21:07 +0000671 return fd;
672}
673
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300674static volatile int workload_exec_errno;
675
676/*
677 * perf_evlist__prepare_workload will send a SIGUSR1
678 * if the fork fails, since we asked by setting its
679 * want_signal to true.
680 */
Namhyung Kim45604712014-05-12 09:47:24 +0900681static void workload_exec_failed_signal(int signo __maybe_unused,
682 siginfo_t *info,
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300683 void *ucontext __maybe_unused)
684{
685 workload_exec_errno = info->si_value.sival_int;
686 done = 1;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300687 child_finished = 1;
688}
689
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300690static void snapshot_sig_handler(int sig);
691
Adrian Hunter46bc29b2016-03-08 10:38:44 +0200692int __weak
693perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused,
694 struct perf_tool *tool __maybe_unused,
695 perf_event__handler_t process __maybe_unused,
696 struct machine *machine __maybe_unused)
697{
698 return 0;
699}
700
Wang Nanee667f92016-06-27 10:24:05 +0000701static const struct perf_event_mmap_page *
702perf_evlist__pick_pc(struct perf_evlist *evlist)
703{
Wang Nanb2cb6152016-07-14 08:34:39 +0000704 if (evlist) {
705 if (evlist->mmap && evlist->mmap[0].base)
706 return evlist->mmap[0].base;
707 if (evlist->backward_mmap && evlist->backward_mmap[0].base)
708 return evlist->backward_mmap[0].base;
709 }
Wang Nanee667f92016-06-27 10:24:05 +0000710 return NULL;
711}
712
Wang Nanc45628b2016-05-24 02:28:59 +0000713static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
714{
Wang Nanee667f92016-06-27 10:24:05 +0000715 const struct perf_event_mmap_page *pc;
716
717 pc = perf_evlist__pick_pc(rec->evlist);
718 if (pc)
719 return pc;
Wang Nanc45628b2016-05-24 02:28:59 +0000720 return NULL;
721}
722
Wang Nanc45c86e2016-02-26 09:32:07 +0000723static int record__synthesize(struct record *rec)
724{
725 struct perf_session *session = rec->session;
726 struct machine *machine = &session->machines.host;
727 struct perf_data_file *file = &rec->file;
728 struct record_opts *opts = &rec->opts;
729 struct perf_tool *tool = &rec->tool;
730 int fd = perf_data_file__fd(file);
731 int err = 0;
732
733 if (file->is_pipe) {
734 err = perf_event__synthesize_attrs(tool, session,
735 process_synthesized_event);
736 if (err < 0) {
737 pr_err("Couldn't synthesize attrs.\n");
738 goto out;
739 }
740
741 if (have_tracepoints(&rec->evlist->entries)) {
742 /*
743 * FIXME err <= 0 here actually means that
744 * there were no tracepoints so its not really
745 * an error, just that we don't need to
746 * synthesize anything. We really have to
747 * return this more properly and also
748 * propagate errors that now are calling die()
749 */
750 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
751 process_synthesized_event);
752 if (err <= 0) {
753 pr_err("Couldn't record tracing data.\n");
754 goto out;
755 }
756 rec->bytes_written += err;
757 }
758 }
759
Wang Nanc45628b2016-05-24 02:28:59 +0000760 err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
Adrian Hunter46bc29b2016-03-08 10:38:44 +0200761 process_synthesized_event, machine);
762 if (err)
763 goto out;
764
Wang Nanc45c86e2016-02-26 09:32:07 +0000765 if (rec->opts.full_auxtrace) {
766 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
767 session, process_synthesized_event);
768 if (err)
769 goto out;
770 }
771
772 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
773 machine);
774 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
775 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
776 "Check /proc/kallsyms permission or run as root.\n");
777
778 err = perf_event__synthesize_modules(tool, process_synthesized_event,
779 machine);
780 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
781 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
782 "Check /proc/modules permission or run as root.\n");
783
784 if (perf_guest) {
785 machines__process_guests(&session->machines,
786 perf_event__synthesize_guest_os, tool);
787 }
788
789 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
790 process_synthesized_event, opts->sample_address,
791 opts->proc_map_timeout);
792out:
793 return err;
794}
795
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300796static int __cmd_record(struct record *rec, int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200797{
David Ahern57706ab2013-11-06 11:41:34 -0700798 int err;
Namhyung Kim45604712014-05-12 09:47:24 +0900799 int status = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +0200800 unsigned long waking = 0;
Zhang, Yanmin46be6042010-03-18 11:36:04 -0300801 const bool forks = argc > 0;
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300802 struct machine *machine;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200803 struct perf_tool *tool = &rec->tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300804 struct record_opts *opts = &rec->opts;
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200805 struct perf_data_file *file = &rec->file;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200806 struct perf_session *session;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -0300807 bool disabled = false, draining = false;
Namhyung Kim42aa2762015-01-29 17:06:48 +0900808 int fd;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200809
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200810 rec->progname = argv[0];
Andi Kleen33e49ea2011-09-15 14:31:40 -0700811
Namhyung Kim45604712014-05-12 09:47:24 +0900812 atexit(record__sig_exit);
Peter Zijlstraf5970552009-06-18 23:22:55 +0200813 signal(SIGCHLD, sig_handler);
814 signal(SIGINT, sig_handler);
David Ahern804f7ac2013-05-06 12:24:23 -0600815 signal(SIGTERM, sig_handler);
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000816
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000817 if (rec->opts.auxtrace_snapshot_mode || rec->switch_output) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300818 signal(SIGUSR2, snapshot_sig_handler);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000819 if (rec->opts.auxtrace_snapshot_mode)
820 trigger_on(&auxtrace_snapshot_trigger);
821 if (rec->switch_output)
822 trigger_on(&switch_output_trigger);
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000823 } else {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300824 signal(SIGUSR2, SIG_IGN);
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000825 }
Peter Zijlstraf5970552009-06-18 23:22:55 +0200826
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300827 session = perf_session__new(file, false, tool);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200828 if (session == NULL) {
Adrien BAKffa91882014-04-18 11:00:43 +0900829 pr_err("Perf session creation failed.\n");
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -0200830 return -1;
831 }
832
Namhyung Kim42aa2762015-01-29 17:06:48 +0900833 fd = perf_data_file__fd(file);
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200834 rec->session = session;
835
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300836 record__init_features(rec);
Stephane Eranian330aa672012-03-08 23:47:46 +0100837
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200838 if (forks) {
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300839 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200840 argv, file->is_pipe,
Arnaldo Carvalho de Melo735f7e02014-01-03 14:56:49 -0300841 workload_exec_failed_signal);
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -0200842 if (err < 0) {
843 pr_err("Couldn't run the workload!\n");
Namhyung Kim45604712014-05-12 09:47:24 +0900844 status = err;
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -0200845 goto out_delete_session;
Jens Axboe0a5ac842009-08-12 11:18:01 +0200846 }
Peter Zijlstra856e9662009-12-16 17:55:55 +0100847 }
848
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300849 if (record__open(rec) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600850 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900851 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -0600852 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200853
Wang Nan8690a2a2016-02-22 09:10:32 +0000854 err = bpf__apply_obj_config();
855 if (err) {
856 char errbuf[BUFSIZ];
857
858 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
859 pr_err("ERROR: Apply config to BPF failed: %s\n",
860 errbuf);
861 goto out_child;
862 }
863
Adrian Huntercca84822015-08-19 17:29:21 +0300864 /*
865 * Normally perf_session__new would do this, but it doesn't have the
866 * evlist.
867 */
868 if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
869 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
870 rec->tool.ordered_events = false;
871 }
872
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300873 if (!rec->evlist->nr_groups)
Namhyung Kima8bb5592013-01-22 18:09:31 +0900874 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
875
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200876 if (file->is_pipe) {
Namhyung Kim42aa2762015-01-29 17:06:48 +0900877 err = perf_header__write_pipe(fd);
Tom Zanussi529870e2010-04-01 23:59:16 -0500878 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +0900879 goto out_child;
Jiri Olsa563aecb2013-06-05 13:35:06 +0200880 } else {
Namhyung Kim42aa2762015-01-29 17:06:48 +0900881 err = perf_session__write_header(session, rec->evlist, fd, false);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200882 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +0900883 goto out_child;
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200884 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200885
David Ahernd3665492012-02-06 15:27:52 -0700886 if (!rec->no_buildid
Robert Richtere20960c2011-12-07 10:02:55 +0100887 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
David Ahernd3665492012-02-06 15:27:52 -0700888 pr_err("Couldn't generate buildids. "
Robert Richtere20960c2011-12-07 10:02:55 +0100889 "Use --no-buildid to profile anyway.\n");
David Ahern8d3eca22012-08-26 12:24:47 -0600890 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900891 goto out_child;
Robert Richtere20960c2011-12-07 10:02:55 +0100892 }
893
Arnaldo Carvalho de Melo34ba5122012-12-19 09:04:24 -0300894 machine = &session->machines.host;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200895
Wang Nanc45c86e2016-02-26 09:32:07 +0000896 err = record__synthesize(rec);
897 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +0900898 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -0600899
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200900 if (rec->realtime_prio) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200901 struct sched_param param;
902
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200903 param.sched_priority = rec->realtime_prio;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200904 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -0200905 pr_err("Could not set realtime priority.\n");
David Ahern8d3eca22012-08-26 12:24:47 -0600906 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900907 goto out_child;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200908 }
909 }
910
Jiri Olsa774cb492012-11-12 18:34:01 +0100911 /*
912 * When perf is starting the traced process, all the events
913 * (apart from group members) have enable_on_exec=1 set,
914 * so don't spoil it by prematurely enabling them.
915 */
Andi Kleen6619a532014-01-11 13:38:27 -0800916 if (!target__none(&opts->target) && !opts->initial_delay)
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300917 perf_evlist__enable(rec->evlist);
David Ahern764e16a32011-08-25 10:17:55 -0600918
Peter Zijlstra856e9662009-12-16 17:55:55 +0100919 /*
920 * Let the child rip
921 */
Namhyung Kime803cf92015-09-22 09:24:55 +0900922 if (forks) {
Namhyung Kime5bed562015-09-30 10:45:24 +0900923 union perf_event *event;
924
925 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
926 if (event == NULL) {
927 err = -ENOMEM;
928 goto out_child;
929 }
930
Namhyung Kime803cf92015-09-22 09:24:55 +0900931 /*
932 * Some H/W events are generated before COMM event
933 * which is emitted during exec(), so perf script
934 * cannot see a correct process name for those events.
935 * Synthesize COMM event to prevent it.
936 */
Namhyung Kime5bed562015-09-30 10:45:24 +0900937 perf_event__synthesize_comm(tool, event,
Namhyung Kime803cf92015-09-22 09:24:55 +0900938 rec->evlist->workload.pid,
939 process_synthesized_event,
940 machine);
Namhyung Kime5bed562015-09-30 10:45:24 +0900941 free(event);
Namhyung Kime803cf92015-09-22 09:24:55 +0900942
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300943 perf_evlist__start_workload(rec->evlist);
Namhyung Kime803cf92015-09-22 09:24:55 +0900944 }
Peter Zijlstra856e9662009-12-16 17:55:55 +0100945
Andi Kleen6619a532014-01-11 13:38:27 -0800946 if (opts->initial_delay) {
947 usleep(opts->initial_delay * 1000);
948 perf_evlist__enable(rec->evlist);
949 }
950
Wang Nan5f9cf592016-04-20 18:59:49 +0000951 trigger_ready(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000952 trigger_ready(&switch_output_trigger);
Peter Zijlstra649c48a2009-06-24 21:12:48 +0200953 for (;;) {
Yang Shi9f065192015-09-29 14:49:43 -0700954 unsigned long long hits = rec->samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200955
Wang Nan057374642016-07-14 08:34:43 +0000956 /*
957 * rec->evlist->bkw_mmap_state is possible to be
958 * BKW_MMAP_EMPTY here: when done == true and
959 * hits != rec->samples in previous round.
960 *
961 * perf_evlist__toggle_bkw_mmap ensure we never
962 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
963 */
964 if (trigger_is_hit(&switch_output_trigger) || done || draining)
965 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
966
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300967 if (record__mmap_read_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +0000968 trigger_error(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000969 trigger_error(&switch_output_trigger);
David Ahern8d3eca22012-08-26 12:24:47 -0600970 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900971 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -0600972 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200973
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300974 if (auxtrace_record__snapshot_started) {
975 auxtrace_record__snapshot_started = 0;
Wang Nan5f9cf592016-04-20 18:59:49 +0000976 if (!trigger_is_error(&auxtrace_snapshot_trigger))
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300977 record__read_auxtrace_snapshot(rec);
Wang Nan5f9cf592016-04-20 18:59:49 +0000978 if (trigger_is_error(&auxtrace_snapshot_trigger)) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300979 pr_err("AUX area tracing snapshot failed\n");
980 err = -1;
981 goto out_child;
982 }
983 }
984
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000985 if (trigger_is_hit(&switch_output_trigger)) {
Wang Nan057374642016-07-14 08:34:43 +0000986 /*
987 * If switch_output_trigger is hit, the data in
988 * overwritable ring buffer should have been collected,
989 * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
990 *
991 * If SIGUSR2 raise after or during record__mmap_read_all(),
992 * record__mmap_read_all() didn't collect data from
993 * overwritable ring buffer. Read again.
994 */
995 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
996 continue;
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000997 trigger_ready(&switch_output_trigger);
998
Wang Nan057374642016-07-14 08:34:43 +0000999 /*
1000 * Reenable events in overwrite ring buffer after
1001 * record__mmap_read_all(): we should have collected
1002 * data from it.
1003 */
1004 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1005
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001006 if (!quiet)
1007 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1008 waking);
1009 waking = 0;
1010 fd = record__switch_output(rec, false);
1011 if (fd < 0) {
1012 pr_err("Failed to switch to new file\n");
1013 trigger_error(&switch_output_trigger);
1014 err = fd;
1015 goto out_child;
1016 }
1017 }
1018
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001019 if (hits == rec->samples) {
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001020 if (done || draining)
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001021 break;
Arnaldo Carvalho de Melof66a8892014-08-18 17:25:59 -03001022 err = perf_evlist__poll(rec->evlist, -1);
Jiri Olsaa5151142014-06-02 13:44:23 -04001023 /*
1024 * Propagate error, only if there's any. Ignore positive
1025 * number of returned events and interrupt error.
1026 */
1027 if (err > 0 || (err < 0 && errno == EINTR))
Namhyung Kim45604712014-05-12 09:47:24 +09001028 err = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001029 waking++;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001030
1031 if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
1032 draining = true;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001033 }
1034
Jiri Olsa774cb492012-11-12 18:34:01 +01001035 /*
1036 * When perf is starting the traced process, at the end events
1037 * die with the process and we wait for that. Thus no need to
1038 * disable events in this case.
1039 */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001040 if (done && !disabled && !target__none(&opts->target)) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001041 trigger_off(&auxtrace_snapshot_trigger);
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001042 perf_evlist__disable(rec->evlist);
Jiri Olsa27119262012-11-12 18:34:02 +01001043 disabled = true;
1044 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001045 }
Wang Nan5f9cf592016-04-20 18:59:49 +00001046 trigger_off(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001047 trigger_off(&switch_output_trigger);
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001048
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001049 if (forks && workload_exec_errno) {
Masami Hiramatsu35550da2014-08-14 02:22:43 +00001050 char msg[STRERR_BUFSIZE];
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -03001051 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001052 pr_err("Workload failed: %s\n", emsg);
1053 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001054 goto out_child;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001055 }
1056
Namhyung Kime3d59112015-01-29 17:06:44 +09001057 if (!quiet)
Namhyung Kim45604712014-05-12 09:47:24 +09001058 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001059
Namhyung Kim45604712014-05-12 09:47:24 +09001060out_child:
1061 if (forks) {
1062 int exit_status;
Ingo Molnaraddc2782009-06-02 23:43:11 +02001063
Namhyung Kim45604712014-05-12 09:47:24 +09001064 if (!child_finished)
1065 kill(rec->evlist->workload.pid, SIGTERM);
1066
1067 wait(&exit_status);
1068
1069 if (err < 0)
1070 status = err;
1071 else if (WIFEXITED(exit_status))
1072 status = WEXITSTATUS(exit_status);
1073 else if (WIFSIGNALED(exit_status))
1074 signr = WTERMSIG(exit_status);
1075 } else
1076 status = err;
1077
Namhyung Kime3d59112015-01-29 17:06:44 +09001078 /* this will be recalculated during process_buildids() */
1079 rec->samples = 0;
1080
Wang Nanecfd7a92016-04-13 08:21:07 +00001081 if (!err) {
1082 if (!rec->timestamp_filename) {
1083 record__finish_output(rec);
1084 } else {
1085 fd = record__switch_output(rec, true);
1086 if (fd < 0) {
1087 status = fd;
1088 goto out_delete_session;
1089 }
1090 }
1091 }
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001092
Namhyung Kime3d59112015-01-29 17:06:44 +09001093 if (!err && !quiet) {
1094 char samples[128];
Wang Nanecfd7a92016-04-13 08:21:07 +00001095 const char *postfix = rec->timestamp_filename ?
1096 ".<timestamp>" : "";
Namhyung Kime3d59112015-01-29 17:06:44 +09001097
Adrian Hunteref149c22015-04-09 18:53:45 +03001098 if (rec->samples && !rec->opts.full_auxtrace)
Namhyung Kime3d59112015-01-29 17:06:44 +09001099 scnprintf(samples, sizeof(samples),
1100 " (%" PRIu64 " samples)", rec->samples);
1101 else
1102 samples[0] = '\0';
1103
Wang Nanecfd7a92016-04-13 08:21:07 +00001104 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s ]\n",
Namhyung Kime3d59112015-01-29 17:06:44 +09001105 perf_data_file__size(file) / 1024.0 / 1024.0,
Wang Nanecfd7a92016-04-13 08:21:07 +00001106 file->path, postfix, samples);
Namhyung Kime3d59112015-01-29 17:06:44 +09001107 }
1108
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001109out_delete_session:
1110 perf_session__delete(session);
Namhyung Kim45604712014-05-12 09:47:24 +09001111 return status;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001112}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001113
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001114static void callchain_debug(struct callchain_param *callchain)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001115{
Kan Liangaad2b212015-01-05 13:23:04 -05001116 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
Jiri Olsaa601fdf2014-02-03 12:44:43 +01001117
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001118 pr_debug("callchain: type %s\n", str[callchain->record_mode]);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001119
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001120 if (callchain->record_mode == CALLCHAIN_DWARF)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001121 pr_debug("callchain: stack dump size %d\n",
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001122 callchain->dump_size);
1123}
1124
1125int record_opts__parse_callchain(struct record_opts *record,
1126 struct callchain_param *callchain,
1127 const char *arg, bool unset)
1128{
1129 int ret;
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001130 callchain->enabled = !unset;
1131
1132 /* --no-call-graph */
1133 if (unset) {
1134 callchain->record_mode = CALLCHAIN_NONE;
1135 pr_debug("callchain: disabled\n");
1136 return 0;
1137 }
1138
1139 ret = parse_callchain_record_opt(arg, callchain);
1140 if (!ret) {
1141 /* Enable data address sampling for DWARF unwind. */
1142 if (callchain->record_mode == CALLCHAIN_DWARF)
1143 record->sample_address = true;
1144 callchain_debug(callchain);
1145 }
1146
1147 return ret;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001148}
1149
Kan Liangc421e802015-07-29 05:42:12 -04001150int record_parse_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001151 const char *arg,
1152 int unset)
1153{
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001154 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
Jiri Olsa26d33022012-08-07 15:20:47 +02001155}
1156
Kan Liangc421e802015-07-29 05:42:12 -04001157int record_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001158 const char *arg __maybe_unused,
1159 int unset __maybe_unused)
1160{
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001161 struct callchain_param *callchain = opt->value;
Kan Liangc421e802015-07-29 05:42:12 -04001162
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001163 callchain->enabled = true;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001164
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001165 if (callchain->record_mode == CALLCHAIN_NONE)
1166 callchain->record_mode = CALLCHAIN_FP;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001167
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001168 callchain_debug(callchain);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001169 return 0;
1170}
1171
Jiri Olsaeb853e82014-02-03 12:44:42 +01001172static int perf_record_config(const char *var, const char *value, void *cb)
1173{
Namhyung Kim7a29c082015-12-15 10:49:56 +09001174 struct record *rec = cb;
1175
1176 if (!strcmp(var, "record.build-id")) {
1177 if (!strcmp(value, "cache"))
1178 rec->no_buildid_cache = false;
1179 else if (!strcmp(value, "no-cache"))
1180 rec->no_buildid_cache = true;
1181 else if (!strcmp(value, "skip"))
1182 rec->no_buildid = true;
1183 else
1184 return -1;
1185 return 0;
1186 }
Jiri Olsaeb853e82014-02-03 12:44:42 +01001187 if (!strcmp(var, "record.call-graph"))
Namhyung Kim5a2e5e82014-09-23 10:01:44 +09001188 var = "call-graph.record-mode"; /* fall-through */
Jiri Olsaeb853e82014-02-03 12:44:42 +01001189
1190 return perf_default_config(var, value, cb);
1191}
1192
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001193struct clockid_map {
1194 const char *name;
1195 int clockid;
1196};
1197
1198#define CLOCKID_MAP(n, c) \
1199 { .name = n, .clockid = (c), }
1200
1201#define CLOCKID_END { .name = NULL, }
1202
1203
1204/*
1205 * Add the missing ones, we need to build on many distros...
1206 */
1207#ifndef CLOCK_MONOTONIC_RAW
1208#define CLOCK_MONOTONIC_RAW 4
1209#endif
1210#ifndef CLOCK_BOOTTIME
1211#define CLOCK_BOOTTIME 7
1212#endif
1213#ifndef CLOCK_TAI
1214#define CLOCK_TAI 11
1215#endif
1216
1217static const struct clockid_map clockids[] = {
1218 /* available for all events, NMI safe */
1219 CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
1220 CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
1221
1222 /* available for some events */
1223 CLOCKID_MAP("realtime", CLOCK_REALTIME),
1224 CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
1225 CLOCKID_MAP("tai", CLOCK_TAI),
1226
1227 /* available for the lazy */
1228 CLOCKID_MAP("mono", CLOCK_MONOTONIC),
1229 CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
1230 CLOCKID_MAP("real", CLOCK_REALTIME),
1231 CLOCKID_MAP("boot", CLOCK_BOOTTIME),
1232
1233 CLOCKID_END,
1234};
1235
1236static int parse_clockid(const struct option *opt, const char *str, int unset)
1237{
1238 struct record_opts *opts = (struct record_opts *)opt->value;
1239 const struct clockid_map *cm;
1240 const char *ostr = str;
1241
1242 if (unset) {
1243 opts->use_clockid = 0;
1244 return 0;
1245 }
1246
1247 /* no arg passed */
1248 if (!str)
1249 return 0;
1250
1251 /* no setting it twice */
1252 if (opts->use_clockid)
1253 return -1;
1254
1255 opts->use_clockid = true;
1256
1257 /* if its a number, we're done */
1258 if (sscanf(str, "%d", &opts->clockid) == 1)
1259 return 0;
1260
1261 /* allow a "CLOCK_" prefix to the name */
1262 if (!strncasecmp(str, "CLOCK_", 6))
1263 str += 6;
1264
1265 for (cm = clockids; cm->name; cm++) {
1266 if (!strcasecmp(str, cm->name)) {
1267 opts->clockid = cm->clockid;
1268 return 0;
1269 }
1270 }
1271
1272 opts->use_clockid = false;
1273 ui__warning("unknown clockid %s, check man page\n", ostr);
1274 return -1;
1275}
1276
Adrian Huntere9db1312015-04-09 18:53:46 +03001277static int record__parse_mmap_pages(const struct option *opt,
1278 const char *str,
1279 int unset __maybe_unused)
1280{
1281 struct record_opts *opts = opt->value;
1282 char *s, *p;
1283 unsigned int mmap_pages;
1284 int ret;
1285
1286 if (!str)
1287 return -EINVAL;
1288
1289 s = strdup(str);
1290 if (!s)
1291 return -ENOMEM;
1292
1293 p = strchr(s, ',');
1294 if (p)
1295 *p = '\0';
1296
1297 if (*s) {
1298 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
1299 if (ret)
1300 goto out_free;
1301 opts->mmap_pages = mmap_pages;
1302 }
1303
1304 if (!p) {
1305 ret = 0;
1306 goto out_free;
1307 }
1308
1309 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
1310 if (ret)
1311 goto out_free;
1312
1313 opts->auxtrace_mmap_pages = mmap_pages;
1314
1315out_free:
1316 free(s);
1317 return ret;
1318}
1319
Namhyung Kime5b2c202014-10-23 00:15:46 +09001320static const char * const __record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +02001321 "perf record [<options>] [<command>]",
1322 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001323 NULL
1324};
Namhyung Kime5b2c202014-10-23 00:15:46 +09001325const char * const *record_usage = __record_usage;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001326
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001327/*
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001328 * XXX Ideally would be local to cmd_record() and passed to a record__new
1329 * because we need to have access to it in record__exit, that is called
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001330 * after cmd_record() exits, but since record_options need to be accessible to
1331 * builtin-script, leave it here.
1332 *
1333 * At least we don't ouch it in all the other functions here directly.
1334 *
1335 * Just say no to tons of global variables, sigh.
1336 */
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001337static struct record record = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001338 .opts = {
Andi Kleen8affc2b2014-07-31 14:45:04 +08001339 .sample_time = true,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001340 .mmap_pages = UINT_MAX,
1341 .user_freq = UINT_MAX,
1342 .user_interval = ULLONG_MAX,
Arnaldo Carvalho de Melo447a6012012-05-22 13:14:18 -03001343 .freq = 4000,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09001344 .target = {
1345 .uses_mmap = true,
Adrian Hunter3aa59392013-11-15 15:52:29 +02001346 .default_per_cpu = true,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09001347 },
Kan Liang9d9cad72015-06-17 09:51:11 -04001348 .proc_map_timeout = 500,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001349 },
Namhyung Kime3d59112015-01-29 17:06:44 +09001350 .tool = {
1351 .sample = process_sample_event,
1352 .fork = perf_event__process_fork,
Adrian Huntercca84822015-08-19 17:29:21 +03001353 .exit = perf_event__process_exit,
Namhyung Kime3d59112015-01-29 17:06:44 +09001354 .comm = perf_event__process_comm,
1355 .mmap = perf_event__process_mmap,
1356 .mmap2 = perf_event__process_mmap2,
Adrian Huntercca84822015-08-19 17:29:21 +03001357 .ordered_events = true,
Namhyung Kime3d59112015-01-29 17:06:44 +09001358 },
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001359};
Frederic Weisbecker7865e812010-04-14 19:42:07 +02001360
Namhyung Kim76a26542015-10-22 23:28:32 +09001361const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
1362 "\n\t\t\t\tDefault: fp";
Arnaldo Carvalho de Melo61eaa3b2012-10-01 15:20:58 -03001363
Wang Nan0aab2132016-06-16 08:02:41 +00001364static bool dry_run;
1365
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001366/*
1367 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
1368 * with it and switch to use the library functions in perf_evlist that came
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001369 * from builtin-record.c, i.e. use record_opts,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001370 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
1371 * using pipes, etc.
1372 */
Namhyung Kime5b2c202014-10-23 00:15:46 +09001373struct option __record_options[] = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001374 OPT_CALLBACK('e', "event", &record.evlist, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +02001375 "event selector. use 'perf list' to list available events",
Jiri Olsaf120f9d2011-07-14 11:25:32 +02001376 parse_events_option),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001377 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
Li Zefanc171b552009-10-15 11:22:07 +08001378 "event filter", parse_filter),
Wang Nan4ba1faa2015-07-10 07:36:10 +00001379 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
1380 NULL, "don't record events from perf itself",
1381 exclude_perf),
Namhyung Kimbea03402012-04-26 14:15:15 +09001382 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001383 "record events on existing process id"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001384 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001385 "record events on existing thread id"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001386 OPT_INTEGER('r', "realtime", &record.realtime_prio,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001387 "collect data with this RT SCHED_FIFO priority"),
Arnaldo Carvalho de Melo509051e2014-01-14 17:52:14 -03001388 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
Kirill Smelkovacac03f2011-01-12 17:59:36 +03001389 "collect data without buffering"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001390 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +02001391 "collect raw sample records from all opened counters"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001392 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001393 "system-wide collection from all CPUs"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001394 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02001395 "list of cpus to monitor"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001396 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
Jiri Olsaf5fc14122013-10-15 16:27:32 +02001397 OPT_STRING('o', "output", &record.file.path, "file",
Ingo Molnarabaff322009-06-02 22:59:57 +02001398 "output file name"),
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02001399 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1400 &record.opts.no_inherit_set,
1401 "child tasks do not inherit counters"),
Wang Nan626a6b72016-07-14 08:34:45 +00001402 OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001403 OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
Adrian Huntere9db1312015-04-09 18:53:46 +03001404 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1405 "number of mmap data pages and AUX area tracing mmap pages",
1406 record__parse_mmap_pages),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001407 OPT_BOOLEAN(0, "group", &record.opts.group,
Lin Ming43bece72011-08-17 18:42:07 +08001408 "put the counters into a counter group"),
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001409 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001410 NULL, "enables call-graph recording" ,
1411 &record_callchain_opt),
1412 OPT_CALLBACK(0, "call-graph", &record.opts,
Namhyung Kim76a26542015-10-22 23:28:32 +09001413 "record_mode[,record_size]", record_callchain_help,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001414 &record_parse_callchain_opt),
Ian Munsiec0555642010-04-13 18:37:33 +10001415 OPT_INCR('v', "verbose", &verbose,
Ingo Molnar3da297a2009-06-07 17:39:02 +02001416 "be more verbose (show counter open errors, etc)"),
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001417 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001418 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001419 "per thread counts"),
Peter Zijlstra56100322015-06-10 16:48:50 +02001420 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
Adrian Hunter3abebc52015-07-06 14:51:01 +03001421 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
1422 &record.opts.sample_time_set,
1423 "Record the sample timestamps"),
Peter Zijlstra56100322015-06-10 16:48:50 +02001424 OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001425 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001426 "don't sample"),
Wang Nand2db9a92016-01-25 09:56:19 +00001427 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
1428 &record.no_buildid_cache_set,
1429 "do not update the buildid cache"),
1430 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
1431 &record.no_buildid_set,
1432 "do not collect buildids in perf.data"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001433 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
Stephane Eranian023695d2011-02-14 11:20:01 +02001434 "monitor event in cgroup name only",
1435 parse_cgroups),
Arnaldo Carvalho de Meloa6205a32014-01-14 17:58:12 -03001436 OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
Andi Kleen6619a532014-01-11 13:38:27 -08001437 "ms to wait before starting measurement after program start"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001438 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1439 "user to profile"),
Stephane Eraniana5aabda2012-03-08 23:47:45 +01001440
1441 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1442 "branch any", "sample any taken branches",
1443 parse_branch_stack),
1444
1445 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1446 "branch filter mask", "branch stack filter modes",
Roberto Agostino Vitillobdfebd82012-02-09 23:21:02 +01001447 parse_branch_stack),
Andi Kleen05484292013-01-24 16:10:29 +01001448 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1449 "sample by weight (on special events only)"),
Andi Kleen475eeab2013-09-20 07:40:43 -07001450 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1451 "sample transaction flags (special events only)"),
Adrian Hunter3aa59392013-11-15 15:52:29 +02001452 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1453 "use per-thread mmaps"),
Stephane Eranianbcc84ec2015-08-31 18:41:12 +02001454 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
1455 "sample selected machine registers on interrupt,"
1456 " use -I ? to list register names", parse_regs),
Andi Kleen85c273d2015-02-24 15:13:40 -08001457 OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1458 "Record running/enabled time of read (:S) events"),
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001459 OPT_CALLBACK('k', "clockid", &record.opts,
1460 "clockid", "clockid to use for events, see clock_gettime()",
1461 parse_clockid),
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001462 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1463 "opts", "AUX area tracing Snapshot Mode", ""),
Kan Liang9d9cad72015-06-17 09:51:11 -04001464 OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
1465 "per thread proc mmap processing timeout in ms"),
Adrian Hunterb757bb02015-07-21 12:44:04 +03001466 OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
1467 "Record context switch events"),
Jiri Olsa85723882016-02-15 09:34:31 +01001468 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
1469 "Configure all used events to run in kernel space.",
1470 PARSE_OPT_EXCLUSIVE),
1471 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
1472 "Configure all used events to run in user space.",
1473 PARSE_OPT_EXCLUSIVE),
Wang Nan71dc23262015-10-14 12:41:19 +00001474 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
1475 "clang binary to use for compiling BPF scriptlets"),
1476 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
1477 "options passed to clang when compiling BPF scriptlets"),
He Kuang7efe0e02015-12-14 10:39:23 +00001478 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
1479 "file", "vmlinux pathname"),
Namhyung Kim61566812016-01-11 22:37:09 +09001480 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
1481 "Record build-id of all DSOs regardless of hits"),
Wang Nanecfd7a92016-04-13 08:21:07 +00001482 OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
1483 "append timestamp to output filename"),
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001484 OPT_BOOLEAN(0, "switch-output", &record.switch_output,
1485 "Switch output when receive SIGUSR2"),
Wang Nan0aab2132016-06-16 08:02:41 +00001486 OPT_BOOLEAN(0, "dry-run", &dry_run,
1487 "Parse options then exit"),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001488 OPT_END()
1489};
1490
Namhyung Kime5b2c202014-10-23 00:15:46 +09001491struct option *record_options = __record_options;
1492
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001493int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001494{
Adrian Hunteref149c22015-04-09 18:53:45 +03001495 int err;
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001496 struct record *rec = &record;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001497 char errbuf[BUFSIZ];
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001498
Wang Nan48e1cab2015-12-14 10:39:22 +00001499#ifndef HAVE_LIBBPF_SUPPORT
1500# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
1501 set_nobuild('\0', "clang-path", true);
1502 set_nobuild('\0', "clang-opt", true);
1503# undef set_nobuild
1504#endif
1505
He Kuang7efe0e02015-12-14 10:39:23 +00001506#ifndef HAVE_BPF_PROLOGUE
1507# if !defined (HAVE_DWARF_SUPPORT)
1508# define REASON "NO_DWARF=1"
1509# elif !defined (HAVE_LIBBPF_SUPPORT)
1510# define REASON "NO_LIBBPF=1"
1511# else
1512# define REASON "this architecture doesn't support BPF prologue"
1513# endif
1514# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
1515 set_nobuild('\0', "vmlinux", true);
1516# undef set_nobuild
1517# undef REASON
1518#endif
1519
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001520 rec->evlist = perf_evlist__new();
1521 if (rec->evlist == NULL)
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02001522 return -ENOMEM;
1523
Jiri Olsaeb853e82014-02-03 12:44:42 +01001524 perf_config(perf_record_config, rec);
1525
Tom Zanussibca647a2010-11-10 08:11:30 -06001526 argc = parse_options(argc, argv, record_options, record_usage,
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001527 PARSE_OPT_STOP_AT_NON_OPTION);
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001528 if (!argc && target__none(&rec->opts.target))
Tom Zanussibca647a2010-11-10 08:11:30 -06001529 usage_with_options(record_usage, record_options);
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001530
Namhyung Kimbea03402012-04-26 14:15:15 +09001531 if (nr_cgroups && !rec->opts.target.system_wide) {
Namhyung Kimc7118362015-10-25 00:49:27 +09001532 usage_with_options_msg(record_usage, record_options,
1533 "cgroup monitoring only available in system-wide mode");
1534
Stephane Eranian023695d2011-02-14 11:20:01 +02001535 }
Adrian Hunterb757bb02015-07-21 12:44:04 +03001536 if (rec->opts.record_switch_events &&
1537 !perf_can_record_switch_events()) {
Namhyung Kimc7118362015-10-25 00:49:27 +09001538 ui__error("kernel does not support recording context switch events\n");
1539 parse_options_usage(record_usage, record_options, "switch-events", 0);
1540 return -EINVAL;
Adrian Hunterb757bb02015-07-21 12:44:04 +03001541 }
Stephane Eranian023695d2011-02-14 11:20:01 +02001542
Wang Naneca857a2016-04-20 18:59:51 +00001543 if (rec->switch_output)
1544 rec->timestamp_filename = true;
1545
Adrian Hunteref149c22015-04-09 18:53:45 +03001546 if (!rec->itr) {
1547 rec->itr = auxtrace_record__init(rec->evlist, &err);
1548 if (err)
1549 return err;
1550 }
1551
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001552 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1553 rec->opts.auxtrace_snapshot_opts);
1554 if (err)
1555 return err;
1556
Wang Nan0aab2132016-06-16 08:02:41 +00001557 if (dry_run)
1558 return 0;
1559
Wang Nand7888572016-04-08 15:07:24 +00001560 err = bpf__setup_stdout(rec->evlist);
1561 if (err) {
1562 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
1563 pr_err("ERROR: Setup BPF stdout failed: %s\n",
1564 errbuf);
1565 return err;
1566 }
1567
Adrian Hunteref149c22015-04-09 18:53:45 +03001568 err = -ENOMEM;
1569
Namhyung Kim0a7e6d12014-08-12 15:40:45 +09001570 symbol__init(NULL);
Arnaldo Carvalho de Melobaa2f6c2010-11-26 19:39:15 -02001571
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -03001572 if (symbol_conf.kptr_restrict)
Arnaldo Carvalho de Melo646aaea2011-05-27 11:00:41 -03001573 pr_warning(
1574"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
1575"check /proc/sys/kernel/kptr_restrict.\n\n"
1576"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
1577"file is not found in the buildid cache or in the vmlinux path.\n\n"
1578"Samples in kernel modules won't be resolved at all.\n\n"
1579"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
1580"even with a suitable vmlinux or kallsyms file.\n\n");
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -03001581
Wang Nan0c1d46a2016-04-20 18:59:52 +00001582 if (rec->no_buildid_cache || rec->no_buildid) {
Stephane Eraniana1ac1d32010-06-17 11:39:01 +02001583 disable_buildid_cache();
Wang Nan0c1d46a2016-04-20 18:59:52 +00001584 } else if (rec->switch_output) {
1585 /*
1586 * In 'perf record --switch-output', disable buildid
1587 * generation by default to reduce data file switching
1588 * overhead. Still generate buildid if they are required
1589 * explicitly using
1590 *
1591 * perf record --signal-trigger --no-no-buildid \
1592 * --no-no-buildid-cache
1593 *
1594 * Following code equals to:
1595 *
1596 * if ((rec->no_buildid || !rec->no_buildid_set) &&
1597 * (rec->no_buildid_cache || !rec->no_buildid_cache_set))
1598 * disable_buildid_cache();
1599 */
1600 bool disable = true;
1601
1602 if (rec->no_buildid_set && !rec->no_buildid)
1603 disable = false;
1604 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
1605 disable = false;
1606 if (disable) {
1607 rec->no_buildid = true;
1608 rec->no_buildid_cache = true;
1609 disable_buildid_cache();
1610 }
1611 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001612
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001613 if (rec->evlist->nr_entries == 0 &&
1614 perf_evlist__add_default(rec->evlist) < 0) {
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02001615 pr_err("Not enough memory for event selector list\n");
1616 goto out_symbol_exit;
Peter Zijlstrabbd36e52009-06-11 23:11:50 +02001617 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001618
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02001619 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1620 rec->opts.no_inherit = true;
1621
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001622 err = target__validate(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001623 if (err) {
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001624 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001625 ui__warning("%s", errbuf);
1626 }
Namhyung Kim4bd0f2d2012-04-26 14:15:18 +09001627
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001628 err = target__parse_uid(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001629 if (err) {
1630 int saved_errno = errno;
1631
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001632 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim3780f482012-05-29 13:22:57 +09001633 ui__error("%s", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001634
1635 err = -saved_errno;
Namhyung Kim8fa60e12013-03-15 14:48:51 +09001636 goto out_symbol_exit;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001637 }
Arnaldo Carvalho de Melo0d37aa32012-01-19 14:08:15 -02001638
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001639 err = -ENOMEM;
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001640 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -02001641 usage_with_options(record_usage, record_options);
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02001642
Adrian Hunteref149c22015-04-09 18:53:45 +03001643 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
1644 if (err)
1645 goto out_symbol_exit;
1646
Namhyung Kim61566812016-01-11 22:37:09 +09001647 /*
1648 * We take all buildids when the file contains
1649 * AUX area tracing data because we do not decode the
1650 * trace because it would take too long.
1651 */
1652 if (rec->opts.full_auxtrace)
1653 rec->buildid_all = true;
1654
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001655 if (record_opts__config(&rec->opts)) {
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001656 err = -EINVAL;
Arnaldo Carvalho de Melo03ad9742014-01-03 15:56:06 -03001657 goto out_symbol_exit;
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +02001658 }
1659
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001660 err = __cmd_record(&record, argc, argv);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -03001661out_symbol_exit:
Namhyung Kim45604712014-05-12 09:47:24 +09001662 perf_evlist__delete(rec->evlist);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -03001663 symbol__exit();
Adrian Hunteref149c22015-04-09 18:53:45 +03001664 auxtrace_record__free(rec->itr);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001665 return err;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001666}
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001667
1668static void snapshot_sig_handler(int sig __maybe_unused)
1669{
Wang Nan5f9cf592016-04-20 18:59:49 +00001670 if (trigger_is_ready(&auxtrace_snapshot_trigger)) {
1671 trigger_hit(&auxtrace_snapshot_trigger);
1672 auxtrace_record__snapshot_started = 1;
1673 if (auxtrace_record__snapshot_start(record.itr))
1674 trigger_error(&auxtrace_snapshot_trigger);
1675 }
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001676
1677 if (trigger_is_ready(&switch_output_trigger))
1678 trigger_hit(&switch_output_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001679}