blob: 99156b4363a5005acf846a8f62a388074524e0e7 [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"
Mathieu Poirier5d8bb1e2016-09-16 09:50:03 -060025#include "util/drv_configs.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020026#include "util/session.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020027#include "util/tool.h"
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020028#include "util/symbol.h"
Paul Mackerrasa12b51c2010-03-10 20:36:09 +110029#include "util/cpumap.h"
Arnaldo Carvalho de Melofd782602011-01-18 15:15:24 -020030#include "util/thread_map.h"
Jiri Olsaf5fc1412013-10-15 16:27:32 +020031#include "util/data.h"
Stephane Eranianbcc84ec2015-08-31 18:41:12 +020032#include "util/perf_regs.h"
Adrian Hunteref149c22015-04-09 18:53:45 +030033#include "util/auxtrace.h"
Adrian Hunter46bc29b2016-03-08 10:38:44 +020034#include "util/tsc.h"
Andi Kleenf00898f2015-05-27 10:51:51 -070035#include "util/parse-branch-options.h"
Stephane Eranianbcc84ec2015-08-31 18:41:12 +020036#include "util/parse-regs-options.h"
Wang Nan71dc23262015-10-14 12:41:19 +000037#include "util/llvm-utils.h"
Wang Nan8690a2a2016-02-22 09:10:32 +000038#include "util/bpf-loader.h"
Wang Nan5f9cf592016-04-20 18:59:49 +000039#include "util/trigger.h"
Wang Nana0748652016-11-26 07:03:28 +000040#include "util/perf-hooks.h"
Arnaldo Carvalho de Melo58db1d62017-04-19 16:05:56 -030041#include "util/units.h"
Wang Nand8871ea2016-02-26 09:32:06 +000042#include "asm/bug.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020043
Arnaldo Carvalho de Meloa43783a2017-04-18 10:46:11 -030044#include <errno.h>
Arnaldo Carvalho de Melofd20e812017-04-17 15:23:08 -030045#include <inttypes.h>
Peter Zijlstra97124d52009-06-02 15:52:24 +020046#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020047#include <sched.h>
Arnaldo Carvalho de Melo9607ad32017-04-19 15:49:18 -030048#include <signal.h>
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -030049#include <sys/mman.h>
Wang Nan2d11c652016-05-23 07:13:39 +000050#include <asm/bug.h>
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -030051#include <linux/time64.h>
Bernhard Rosenkraenzer78da39f2012-10-08 09:43:26 +030052
Jiri Olsa1b43b702017-01-09 10:51:56 +010053struct switch_output {
Jiri Olsadc0c6122017-01-09 10:51:58 +010054 bool enabled;
Jiri Olsa1b43b702017-01-09 10:51:56 +010055 bool signal;
Jiri Olsadc0c6122017-01-09 10:51:58 +010056 unsigned long size;
Jiri Olsabfacbe32017-01-09 10:52:00 +010057 unsigned long time;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +010058 const char *str;
59 bool set;
Jiri Olsa1b43b702017-01-09 10:51:56 +010060};
61
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030062struct record {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020063 struct perf_tool tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -030064 struct record_opts opts;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020065 u64 bytes_written;
Jiri Olsaf5fc1412013-10-15 16:27:32 +020066 struct perf_data_file file;
Adrian Hunteref149c22015-04-09 18:53:45 +030067 struct auxtrace_record *itr;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020068 struct perf_evlist *evlist;
69 struct perf_session *session;
70 const char *progname;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020071 int realtime_prio;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020072 bool no_buildid;
Wang Nand2db9a92016-01-25 09:56:19 +000073 bool no_buildid_set;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020074 bool no_buildid_cache;
Wang Nand2db9a92016-01-25 09:56:19 +000075 bool no_buildid_cache_set;
Namhyung Kim61566812016-01-11 22:37:09 +090076 bool buildid_all;
Wang Nanecfd7a92016-04-13 08:21:07 +000077 bool timestamp_filename;
Jiri Olsa1b43b702017-01-09 10:51:56 +010078 struct switch_output switch_output;
Yang Shi9f065192015-09-29 14:49:43 -070079 unsigned long long samples;
Arnaldo Carvalho de Melo0f82ebc2011-11-08 14:41:57 -020080};
Ingo Molnara21ca2c2009-06-06 09:58:57 +020081
Jiri Olsadc0c6122017-01-09 10:51:58 +010082static volatile int auxtrace_record__snapshot_started;
83static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
84static DEFINE_TRIGGER(switch_output_trigger);
85
86static bool switch_output_signal(struct record *rec)
87{
88 return rec->switch_output.signal &&
89 trigger_is_ready(&switch_output_trigger);
90}
91
92static bool switch_output_size(struct record *rec)
93{
94 return rec->switch_output.size &&
95 trigger_is_ready(&switch_output_trigger) &&
96 (rec->bytes_written >= rec->switch_output.size);
97}
98
Jiri Olsabfacbe32017-01-09 10:52:00 +010099static bool switch_output_time(struct record *rec)
100{
101 return rec->switch_output.time &&
102 trigger_is_ready(&switch_output_trigger);
103}
104
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300105static int record__write(struct record *rec, void *bf, size_t size)
Peter Zijlstraf5970552009-06-18 23:22:55 +0200106{
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -0300107 if (perf_data_file__write(rec->session->file, bf, size) < 0) {
Jiri Olsa50a9b862013-11-22 13:11:24 +0100108 pr_err("failed to write perf data, error: %m\n");
109 return -1;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200110 }
David Ahern8d3eca22012-08-26 12:24:47 -0600111
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -0300112 rec->bytes_written += size;
Jiri Olsadc0c6122017-01-09 10:51:58 +0100113
114 if (switch_output_size(rec))
115 trigger_hit(&switch_output_trigger);
116
David Ahern8d3eca22012-08-26 12:24:47 -0600117 return 0;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200118}
119
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200120static int process_synthesized_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200121 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300122 struct perf_sample *sample __maybe_unused,
123 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200124{
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300125 struct record *rec = container_of(tool, struct record, tool);
126 return record__write(rec, event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200127}
128
Wang Nan3a62a7b2016-05-23 07:13:41 +0000129static int
130backward_rb_find_range(void *buf, int mask, u64 head, u64 *start, u64 *end)
131{
132 struct perf_event_header *pheader;
133 u64 evt_head = head;
134 int size = mask + 1;
135
136 pr_debug2("backward_rb_find_range: buf=%p, head=%"PRIx64"\n", buf, head);
137 pheader = (struct perf_event_header *)(buf + (head & mask));
138 *start = head;
139 while (true) {
140 if (evt_head - head >= (unsigned int)size) {
Colin Ian King5e30d552016-08-22 19:30:08 +0100141 pr_debug("Finished reading backward ring buffer: rewind\n");
Wang Nan3a62a7b2016-05-23 07:13:41 +0000142 if (evt_head - head > (unsigned int)size)
143 evt_head -= pheader->size;
144 *end = evt_head;
145 return 0;
146 }
147
148 pheader = (struct perf_event_header *)(buf + (evt_head & mask));
149
150 if (pheader->size == 0) {
Colin Ian King5e30d552016-08-22 19:30:08 +0100151 pr_debug("Finished reading backward ring buffer: get start\n");
Wang Nan3a62a7b2016-05-23 07:13:41 +0000152 *end = evt_head;
153 return 0;
154 }
155
156 evt_head += pheader->size;
157 pr_debug3("move evt_head: %"PRIx64"\n", evt_head);
158 }
159 WARN_ONCE(1, "Shouldn't get here\n");
160 return -1;
161}
162
163static int
Wang Nana4ea0ec2016-07-14 08:34:36 +0000164rb_find_range(void *data, int mask, u64 head, u64 old,
165 u64 *start, u64 *end, bool backward)
Wang Nan3a62a7b2016-05-23 07:13:41 +0000166{
Wang Nana4ea0ec2016-07-14 08:34:36 +0000167 if (!backward) {
Wang Nan3a62a7b2016-05-23 07:13:41 +0000168 *start = old;
169 *end = head;
170 return 0;
171 }
172
173 return backward_rb_find_range(data, mask, head, start, end);
174}
175
Wang Nana4ea0ec2016-07-14 08:34:36 +0000176static int
177record__mmap_read(struct record *rec, struct perf_mmap *md,
178 bool overwrite, bool backward)
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200179{
David Ahern7b8283b52015-04-07 09:20:37 -0600180 u64 head = perf_mmap__read_head(md);
181 u64 old = md->prev;
Wang Nan09fa4f42016-05-23 07:13:40 +0000182 u64 end = head, start = old;
Jiri Olsa918512b2013-09-12 18:39:35 +0200183 unsigned char *data = md->base + page_size;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200184 unsigned long size;
185 void *buf;
David Ahern8d3eca22012-08-26 12:24:47 -0600186 int rc = 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200187
Wang Nana4ea0ec2016-07-14 08:34:36 +0000188 if (rb_find_range(data, md->mask, head,
189 old, &start, &end, backward))
Wang Nan3a62a7b2016-05-23 07:13:41 +0000190 return -1;
191
Wang Nan09fa4f42016-05-23 07:13:40 +0000192 if (start == end)
David Ahern8d3eca22012-08-26 12:24:47 -0600193 return 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200194
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200195 rec->samples++;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200196
Wang Nan09fa4f42016-05-23 07:13:40 +0000197 size = end - start;
Wang Nan2d11c652016-05-23 07:13:39 +0000198 if (size > (unsigned long)(md->mask) + 1) {
199 WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n");
200
201 md->prev = head;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000202 perf_mmap__consume(md, overwrite || backward);
Wang Nan2d11c652016-05-23 07:13:39 +0000203 return 0;
204 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200205
Wang Nan09fa4f42016-05-23 07:13:40 +0000206 if ((start & md->mask) + size != (end & md->mask)) {
207 buf = &data[start & md->mask];
208 size = md->mask + 1 - (start & md->mask);
209 start += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200210
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300211 if (record__write(rec, buf, size) < 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600212 rc = -1;
213 goto out;
214 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200215 }
216
Wang Nan09fa4f42016-05-23 07:13:40 +0000217 buf = &data[start & md->mask];
218 size = end - start;
219 start += size;
Ingo Molnar021e9f42009-06-03 19:27:19 +0200220
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300221 if (record__write(rec, buf, size) < 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600222 rc = -1;
223 goto out;
224 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200225
Wang Nan09fa4f42016-05-23 07:13:40 +0000226 md->prev = head;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000227 perf_mmap__consume(md, overwrite || backward);
David Ahern8d3eca22012-08-26 12:24:47 -0600228out:
229 return rc;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200230}
231
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300232static volatile int done;
233static volatile int signr = -1;
234static volatile int child_finished;
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000235
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300236static void sig_handler(int sig)
237{
238 if (sig == SIGCHLD)
239 child_finished = 1;
240 else
241 signr = sig;
242
243 done = 1;
244}
245
Wang Nana0748652016-11-26 07:03:28 +0000246static void sigsegv_handler(int sig)
247{
248 perf_hooks__recover();
249 sighandler_dump_stack(sig);
250}
251
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300252static void record__sig_exit(void)
253{
254 if (signr == -1)
255 return;
256
257 signal(signr, SIG_DFL);
258 raise(signr);
259}
260
Adrian Huntere31f0d02015-04-30 17:37:27 +0300261#ifdef HAVE_AUXTRACE_SUPPORT
262
Adrian Hunteref149c22015-04-09 18:53:45 +0300263static int record__process_auxtrace(struct perf_tool *tool,
264 union perf_event *event, void *data1,
265 size_t len1, void *data2, size_t len2)
266{
267 struct record *rec = container_of(tool, struct record, tool);
Adrian Hunter99fa2982015-04-30 17:37:25 +0300268 struct perf_data_file *file = &rec->file;
Adrian Hunteref149c22015-04-09 18:53:45 +0300269 size_t padding;
270 u8 pad[8] = {0};
271
Adrian Hunter99fa2982015-04-30 17:37:25 +0300272 if (!perf_data_file__is_pipe(file)) {
273 off_t file_offset;
274 int fd = perf_data_file__fd(file);
275 int err;
276
277 file_offset = lseek(fd, 0, SEEK_CUR);
278 if (file_offset == -1)
279 return -1;
280 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
281 event, file_offset);
282 if (err)
283 return err;
284 }
285
Adrian Hunteref149c22015-04-09 18:53:45 +0300286 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
287 padding = (len1 + len2) & 7;
288 if (padding)
289 padding = 8 - padding;
290
291 record__write(rec, event, event->header.size);
292 record__write(rec, data1, len1);
293 if (len2)
294 record__write(rec, data2, len2);
295 record__write(rec, &pad, padding);
296
297 return 0;
298}
299
300static int record__auxtrace_mmap_read(struct record *rec,
301 struct auxtrace_mmap *mm)
302{
303 int ret;
304
305 ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
306 record__process_auxtrace);
307 if (ret < 0)
308 return ret;
309
310 if (ret)
311 rec->samples++;
312
313 return 0;
314}
315
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300316static int record__auxtrace_mmap_read_snapshot(struct record *rec,
317 struct auxtrace_mmap *mm)
318{
319 int ret;
320
321 ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
322 record__process_auxtrace,
323 rec->opts.auxtrace_snapshot_size);
324 if (ret < 0)
325 return ret;
326
327 if (ret)
328 rec->samples++;
329
330 return 0;
331}
332
333static int record__auxtrace_read_snapshot_all(struct record *rec)
334{
335 int i;
336 int rc = 0;
337
338 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
339 struct auxtrace_mmap *mm =
340 &rec->evlist->mmap[i].auxtrace_mmap;
341
342 if (!mm->base)
343 continue;
344
345 if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
346 rc = -1;
347 goto out;
348 }
349 }
350out:
351 return rc;
352}
353
354static void record__read_auxtrace_snapshot(struct record *rec)
355{
356 pr_debug("Recording AUX area tracing snapshot\n");
357 if (record__auxtrace_read_snapshot_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +0000358 trigger_error(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300359 } else {
Wang Nan5f9cf592016-04-20 18:59:49 +0000360 if (auxtrace_record__snapshot_finish(rec->itr))
361 trigger_error(&auxtrace_snapshot_trigger);
362 else
363 trigger_ready(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300364 }
365}
366
Adrian Huntere31f0d02015-04-30 17:37:27 +0300367#else
368
369static inline
370int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
371 struct auxtrace_mmap *mm __maybe_unused)
372{
373 return 0;
374}
375
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300376static inline
377void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
378{
379}
380
381static inline
382int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
383{
384 return 0;
385}
386
Adrian Huntere31f0d02015-04-30 17:37:27 +0300387#endif
388
Wang Nancda57a82016-06-27 10:24:03 +0000389static int record__mmap_evlist(struct record *rec,
390 struct perf_evlist *evlist)
391{
392 struct record_opts *opts = &rec->opts;
393 char msg[512];
394
395 if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
396 opts->auxtrace_mmap_pages,
397 opts->auxtrace_snapshot_mode) < 0) {
398 if (errno == EPERM) {
399 pr_err("Permission error mapping pages.\n"
400 "Consider increasing "
401 "/proc/sys/kernel/perf_event_mlock_kb,\n"
402 "or try again with a smaller value of -m/--mmap_pages.\n"
403 "(current value: %u,%u)\n",
404 opts->mmap_pages, opts->auxtrace_mmap_pages);
405 return -errno;
406 } else {
407 pr_err("failed to mmap with %d (%s)\n", errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300408 str_error_r(errno, msg, sizeof(msg)));
Wang Nancda57a82016-06-27 10:24:03 +0000409 if (errno)
410 return -errno;
411 else
412 return -EINVAL;
413 }
414 }
415 return 0;
416}
417
418static int record__mmap(struct record *rec)
419{
420 return record__mmap_evlist(rec, rec->evlist);
421}
422
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300423static int record__open(struct record *rec)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200424{
Arnaldo Carvalho de Melod6195a62017-02-13 16:45:24 -0300425 char msg[BUFSIZ];
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200426 struct perf_evsel *pos;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200427 struct perf_evlist *evlist = rec->evlist;
428 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300429 struct record_opts *opts = &rec->opts;
Mathieu Poirier5d8bb1e2016-09-16 09:50:03 -0600430 struct perf_evsel_config_term *err_term;
David Ahern8d3eca22012-08-26 12:24:47 -0600431 int rc = 0;
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200432
Arnaldo Carvalho de Meloe68ae9c2016-04-11 18:15:29 -0300433 perf_evlist__config(evlist, opts, &callchain_param);
Jiri Olsacac21422012-11-12 18:34:00 +0100434
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300435 evlist__for_each_entry(evlist, pos) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200436try_again:
Kan Liangd988d5e2015-08-21 02:23:14 -0400437 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300438 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
Namhyung Kimbb963e12017-02-17 17:17:38 +0900439 if (verbose > 0)
Arnaldo Carvalho de Meloc0a54342012-12-13 14:16:30 -0300440 ui__warning("%s\n", msg);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300441 goto try_again;
442 }
David Ahernca6a4252011-03-25 13:11:11 -0600443
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300444 rc = -errno;
445 perf_evsel__open_strerror(pos, &opts->target,
446 errno, msg, sizeof(msg));
447 ui__error("%s\n", msg);
David Ahern8d3eca22012-08-26 12:24:47 -0600448 goto out;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300449 }
Li Zefanc171b552009-10-15 11:22:07 +0800450 }
Arnaldo Carvalho de Meloa43d3f02010-12-25 12:12:25 -0200451
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300452 if (perf_evlist__apply_filters(evlist, &pos)) {
453 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
454 pos->filter, perf_evsel__name(pos), errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300455 str_error_r(errno, msg, sizeof(msg)));
David Ahern8d3eca22012-08-26 12:24:47 -0600456 rc = -1;
457 goto out;
Frederic Weisbecker0a102472011-02-26 04:51:54 +0100458 }
459
Mathieu Poirier5d8bb1e2016-09-16 09:50:03 -0600460 if (perf_evlist__apply_drv_configs(evlist, &pos, &err_term)) {
461 error("failed to set config \"%s\" on event %s with %d (%s)\n",
462 err_term->val.drv_cfg, perf_evsel__name(pos), errno,
463 str_error_r(errno, msg, sizeof(msg)));
464 rc = -1;
465 goto out;
466 }
467
Wang Nancda57a82016-06-27 10:24:03 +0000468 rc = record__mmap(rec);
469 if (rc)
David Ahern8d3eca22012-08-26 12:24:47 -0600470 goto out;
Arnaldo Carvalho de Melo0a27d7f2011-01-14 15:50:51 -0200471
Jiri Olsa563aecb2013-06-05 13:35:06 +0200472 session->evlist = evlist;
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300473 perf_session__set_id_hdr_size(session);
David Ahern8d3eca22012-08-26 12:24:47 -0600474out:
475 return rc;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200476}
477
Namhyung Kime3d59112015-01-29 17:06:44 +0900478static int process_sample_event(struct perf_tool *tool,
479 union perf_event *event,
480 struct perf_sample *sample,
481 struct perf_evsel *evsel,
482 struct machine *machine)
483{
484 struct record *rec = container_of(tool, struct record, tool);
485
486 rec->samples++;
487
488 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
489}
490
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300491static int process_buildids(struct record *rec)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200492{
Jiri Olsaf5fc1412013-10-15 16:27:32 +0200493 struct perf_data_file *file = &rec->file;
494 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200495
He Kuang457ae942015-05-28 13:17:30 +0000496 if (file->size == 0)
Arnaldo Carvalho de Melo9f591fd2010-03-11 15:53:11 -0300497 return 0;
498
Namhyung Kim00dc8652014-11-04 10:14:32 +0900499 /*
500 * During this process, it'll load kernel map and replace the
501 * dso->long_name to a real pathname it found. In this case
502 * we prefer the vmlinux path like
503 * /lib/modules/3.16.4/build/vmlinux
504 *
505 * rather than build-id path (in debug directory).
506 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
507 */
508 symbol_conf.ignore_vmlinux_buildid = true;
509
Namhyung Kim61566812016-01-11 22:37:09 +0900510 /*
511 * If --buildid-all is given, it marks all DSO regardless of hits,
512 * so no need to process samples.
513 */
514 if (rec->buildid_all)
515 rec->tool.sample = NULL;
516
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300517 return perf_session__process_events(session);
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200518}
519
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200520static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800521{
522 int err;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200523 struct perf_tool *tool = data;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800524 /*
525 *As for guest kernel when processing subcommand record&report,
526 *we arrange module mmap prior to guest kernel mmap and trigger
527 *a preload dso because default guest module symbols are loaded
528 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
529 *method is used to avoid symbol missing when the first addr is
530 *in module instead of in guest kernel.
531 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200532 err = perf_event__synthesize_modules(tool, process_synthesized_event,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200533 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800534 if (err < 0)
535 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300536 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800537
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800538 /*
539 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
540 * have no _text sometimes.
541 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200542 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
Adrian Hunter0ae617b2014-01-29 16:14:40 +0200543 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800544 if (err < 0)
545 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300546 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800547}
548
Frederic Weisbecker98402802010-05-02 22:05:29 +0200549static struct perf_event_header finished_round_event = {
550 .size = sizeof(struct perf_event_header),
551 .type = PERF_RECORD_FINISHED_ROUND,
552};
553
Wang Nana4ea0ec2016-07-14 08:34:36 +0000554static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist,
555 bool backward)
Frederic Weisbecker98402802010-05-02 22:05:29 +0200556{
Jiri Olsadcabb502014-07-25 16:56:16 +0200557 u64 bytes_written = rec->bytes_written;
Peter Zijlstra0e2e63d2010-05-20 14:45:26 +0200558 int i;
David Ahern8d3eca22012-08-26 12:24:47 -0600559 int rc = 0;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000560 struct perf_mmap *maps;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200561
Wang Nancb216862016-06-27 10:24:04 +0000562 if (!evlist)
563 return 0;
Adrian Hunteref149c22015-04-09 18:53:45 +0300564
Wang Nanb2cb6152016-07-14 08:34:39 +0000565 maps = backward ? evlist->backward_mmap : evlist->mmap;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000566 if (!maps)
567 return 0;
Wang Nancb216862016-06-27 10:24:04 +0000568
Wang Nan54cc54d2016-07-14 08:34:42 +0000569 if (backward && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
570 return 0;
571
Wang Nana4ea0ec2016-07-14 08:34:36 +0000572 for (i = 0; i < evlist->nr_mmaps; i++) {
573 struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
574
575 if (maps[i].base) {
576 if (record__mmap_read(rec, &maps[i],
577 evlist->overwrite, backward) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600578 rc = -1;
579 goto out;
580 }
581 }
Adrian Hunteref149c22015-04-09 18:53:45 +0300582
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300583 if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
Adrian Hunteref149c22015-04-09 18:53:45 +0300584 record__auxtrace_mmap_read(rec, mm) != 0) {
585 rc = -1;
586 goto out;
587 }
Frederic Weisbecker98402802010-05-02 22:05:29 +0200588 }
589
Jiri Olsadcabb502014-07-25 16:56:16 +0200590 /*
591 * Mark the round finished in case we wrote
592 * at least one event.
593 */
594 if (bytes_written != rec->bytes_written)
595 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
David Ahern8d3eca22012-08-26 12:24:47 -0600596
Wang Nan54cc54d2016-07-14 08:34:42 +0000597 if (backward)
598 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
David Ahern8d3eca22012-08-26 12:24:47 -0600599out:
600 return rc;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200601}
602
Wang Nancb216862016-06-27 10:24:04 +0000603static int record__mmap_read_all(struct record *rec)
604{
605 int err;
606
Wang Nana4ea0ec2016-07-14 08:34:36 +0000607 err = record__mmap_read_evlist(rec, rec->evlist, false);
Wang Nancb216862016-06-27 10:24:04 +0000608 if (err)
609 return err;
610
Wang Nan057374642016-07-14 08:34:43 +0000611 return record__mmap_read_evlist(rec, rec->evlist, true);
Wang Nancb216862016-06-27 10:24:04 +0000612}
613
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300614static void record__init_features(struct record *rec)
David Ahern57706ab2013-11-06 11:41:34 -0700615{
David Ahern57706ab2013-11-06 11:41:34 -0700616 struct perf_session *session = rec->session;
617 int feat;
618
619 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
620 perf_header__set_feat(&session->header, feat);
621
622 if (rec->no_buildid)
623 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
624
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300625 if (!have_tracepoints(&rec->evlist->entries))
David Ahern57706ab2013-11-06 11:41:34 -0700626 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
627
628 if (!rec->opts.branch_stack)
629 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
Adrian Hunteref149c22015-04-09 18:53:45 +0300630
631 if (!rec->opts.full_auxtrace)
632 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
Jiri Olsaffa517a2015-10-25 15:51:43 +0100633
634 perf_header__clear_feat(&session->header, HEADER_STAT);
David Ahern57706ab2013-11-06 11:41:34 -0700635}
636
Wang Nane1ab48b2016-02-26 09:32:10 +0000637static void
638record__finish_output(struct record *rec)
639{
640 struct perf_data_file *file = &rec->file;
641 int fd = perf_data_file__fd(file);
642
643 if (file->is_pipe)
644 return;
645
646 rec->session->header.data_size += rec->bytes_written;
647 file->size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
648
649 if (!rec->no_buildid) {
650 process_buildids(rec);
651
652 if (rec->buildid_all)
653 dsos__hit_all(rec->session);
654 }
655 perf_session__write_header(rec->session, rec->evlist, fd, true);
656
657 return;
658}
659
Wang Nan4ea648a2016-07-14 08:34:47 +0000660static int record__synthesize_workload(struct record *rec, bool tail)
Wang Nanbe7b0c92016-04-20 18:59:54 +0000661{
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -0300662 int err;
663 struct thread_map *thread_map;
Wang Nanbe7b0c92016-04-20 18:59:54 +0000664
Wang Nan4ea648a2016-07-14 08:34:47 +0000665 if (rec->opts.tail_synthesize != tail)
666 return 0;
667
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -0300668 thread_map = thread_map__new_by_tid(rec->evlist->workload.pid);
669 if (thread_map == NULL)
670 return -1;
671
672 err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
Wang Nanbe7b0c92016-04-20 18:59:54 +0000673 process_synthesized_event,
674 &rec->session->machines.host,
675 rec->opts.sample_address,
676 rec->opts.proc_map_timeout);
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -0300677 thread_map__put(thread_map);
678 return err;
Wang Nanbe7b0c92016-04-20 18:59:54 +0000679}
680
Wang Nan4ea648a2016-07-14 08:34:47 +0000681static int record__synthesize(struct record *rec, bool tail);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000682
Wang Nanecfd7a92016-04-13 08:21:07 +0000683static int
684record__switch_output(struct record *rec, bool at_exit)
685{
686 struct perf_data_file *file = &rec->file;
687 int fd, err;
688
689 /* Same Size: "2015122520103046"*/
690 char timestamp[] = "InvalidTimestamp";
691
Wang Nan4ea648a2016-07-14 08:34:47 +0000692 record__synthesize(rec, true);
693 if (target__none(&rec->opts.target))
694 record__synthesize_workload(rec, true);
695
Wang Nanecfd7a92016-04-13 08:21:07 +0000696 rec->samples = 0;
697 record__finish_output(rec);
698 err = fetch_current_timestamp(timestamp, sizeof(timestamp));
699 if (err) {
700 pr_err("Failed to get current timestamp\n");
701 return -EINVAL;
702 }
703
704 fd = perf_data_file__switch(file, timestamp,
705 rec->session->header.data_offset,
706 at_exit);
707 if (fd >= 0 && !at_exit) {
708 rec->bytes_written = 0;
709 rec->session->header.data_size = 0;
710 }
711
712 if (!quiet)
713 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
714 file->path, timestamp);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000715
716 /* Output tracking events */
Wang Nanbe7b0c92016-04-20 18:59:54 +0000717 if (!at_exit) {
Wang Nan4ea648a2016-07-14 08:34:47 +0000718 record__synthesize(rec, false);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000719
Wang Nanbe7b0c92016-04-20 18:59:54 +0000720 /*
721 * In 'perf record --switch-output' without -a,
722 * record__synthesize() in record__switch_output() won't
723 * generate tracking events because there's no thread_map
724 * in evlist. Which causes newly created perf.data doesn't
725 * contain map and comm information.
726 * Create a fake thread_map and directly call
727 * perf_event__synthesize_thread_map() for those events.
728 */
729 if (target__none(&rec->opts.target))
Wang Nan4ea648a2016-07-14 08:34:47 +0000730 record__synthesize_workload(rec, false);
Wang Nanbe7b0c92016-04-20 18:59:54 +0000731 }
Wang Nanecfd7a92016-04-13 08:21:07 +0000732 return fd;
733}
734
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300735static volatile int workload_exec_errno;
736
737/*
738 * perf_evlist__prepare_workload will send a SIGUSR1
739 * if the fork fails, since we asked by setting its
740 * want_signal to true.
741 */
Namhyung Kim45604712014-05-12 09:47:24 +0900742static void workload_exec_failed_signal(int signo __maybe_unused,
743 siginfo_t *info,
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300744 void *ucontext __maybe_unused)
745{
746 workload_exec_errno = info->si_value.sival_int;
747 done = 1;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300748 child_finished = 1;
749}
750
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300751static void snapshot_sig_handler(int sig);
Jiri Olsabfacbe32017-01-09 10:52:00 +0100752static void alarm_sig_handler(int sig);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300753
Adrian Hunter46bc29b2016-03-08 10:38:44 +0200754int __weak
755perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused,
756 struct perf_tool *tool __maybe_unused,
757 perf_event__handler_t process __maybe_unused,
758 struct machine *machine __maybe_unused)
759{
760 return 0;
761}
762
Wang Nanee667f92016-06-27 10:24:05 +0000763static const struct perf_event_mmap_page *
764perf_evlist__pick_pc(struct perf_evlist *evlist)
765{
Wang Nanb2cb6152016-07-14 08:34:39 +0000766 if (evlist) {
767 if (evlist->mmap && evlist->mmap[0].base)
768 return evlist->mmap[0].base;
769 if (evlist->backward_mmap && evlist->backward_mmap[0].base)
770 return evlist->backward_mmap[0].base;
771 }
Wang Nanee667f92016-06-27 10:24:05 +0000772 return NULL;
773}
774
Wang Nanc45628b2016-05-24 02:28:59 +0000775static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
776{
Wang Nanee667f92016-06-27 10:24:05 +0000777 const struct perf_event_mmap_page *pc;
778
779 pc = perf_evlist__pick_pc(rec->evlist);
780 if (pc)
781 return pc;
Wang Nanc45628b2016-05-24 02:28:59 +0000782 return NULL;
783}
784
Wang Nan4ea648a2016-07-14 08:34:47 +0000785static int record__synthesize(struct record *rec, bool tail)
Wang Nanc45c86e2016-02-26 09:32:07 +0000786{
787 struct perf_session *session = rec->session;
788 struct machine *machine = &session->machines.host;
789 struct perf_data_file *file = &rec->file;
790 struct record_opts *opts = &rec->opts;
791 struct perf_tool *tool = &rec->tool;
792 int fd = perf_data_file__fd(file);
793 int err = 0;
794
Wang Nan4ea648a2016-07-14 08:34:47 +0000795 if (rec->opts.tail_synthesize != tail)
796 return 0;
797
Wang Nanc45c86e2016-02-26 09:32:07 +0000798 if (file->is_pipe) {
799 err = perf_event__synthesize_attrs(tool, session,
800 process_synthesized_event);
801 if (err < 0) {
802 pr_err("Couldn't synthesize attrs.\n");
803 goto out;
804 }
805
806 if (have_tracepoints(&rec->evlist->entries)) {
807 /*
808 * FIXME err <= 0 here actually means that
809 * there were no tracepoints so its not really
810 * an error, just that we don't need to
811 * synthesize anything. We really have to
812 * return this more properly and also
813 * propagate errors that now are calling die()
814 */
815 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
816 process_synthesized_event);
817 if (err <= 0) {
818 pr_err("Couldn't record tracing data.\n");
819 goto out;
820 }
821 rec->bytes_written += err;
822 }
823 }
824
Wang Nanc45628b2016-05-24 02:28:59 +0000825 err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
Adrian Hunter46bc29b2016-03-08 10:38:44 +0200826 process_synthesized_event, machine);
827 if (err)
828 goto out;
829
Wang Nanc45c86e2016-02-26 09:32:07 +0000830 if (rec->opts.full_auxtrace) {
831 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
832 session, process_synthesized_event);
833 if (err)
834 goto out;
835 }
836
837 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
838 machine);
839 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
840 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
841 "Check /proc/kallsyms permission or run as root.\n");
842
843 err = perf_event__synthesize_modules(tool, process_synthesized_event,
844 machine);
845 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
846 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
847 "Check /proc/modules permission or run as root.\n");
848
849 if (perf_guest) {
850 machines__process_guests(&session->machines,
851 perf_event__synthesize_guest_os, tool);
852 }
853
854 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
855 process_synthesized_event, opts->sample_address,
856 opts->proc_map_timeout);
857out:
858 return err;
859}
860
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300861static int __cmd_record(struct record *rec, int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200862{
David Ahern57706ab2013-11-06 11:41:34 -0700863 int err;
Namhyung Kim45604712014-05-12 09:47:24 +0900864 int status = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +0200865 unsigned long waking = 0;
Zhang, Yanmin46be6042010-03-18 11:36:04 -0300866 const bool forks = argc > 0;
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300867 struct machine *machine;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200868 struct perf_tool *tool = &rec->tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300869 struct record_opts *opts = &rec->opts;
Jiri Olsaf5fc1412013-10-15 16:27:32 +0200870 struct perf_data_file *file = &rec->file;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200871 struct perf_session *session;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -0300872 bool disabled = false, draining = false;
Namhyung Kim42aa2762015-01-29 17:06:48 +0900873 int fd;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200874
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200875 rec->progname = argv[0];
Andi Kleen33e49ea2011-09-15 14:31:40 -0700876
Namhyung Kim45604712014-05-12 09:47:24 +0900877 atexit(record__sig_exit);
Peter Zijlstraf5970552009-06-18 23:22:55 +0200878 signal(SIGCHLD, sig_handler);
879 signal(SIGINT, sig_handler);
David Ahern804f7ac2013-05-06 12:24:23 -0600880 signal(SIGTERM, sig_handler);
Wang Nana0748652016-11-26 07:03:28 +0000881 signal(SIGSEGV, sigsegv_handler);
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000882
Hari Bathinif3b36142017-03-08 02:11:43 +0530883 if (rec->opts.record_namespaces)
884 tool->namespace_events = true;
885
Jiri Olsadc0c6122017-01-09 10:51:58 +0100886 if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300887 signal(SIGUSR2, snapshot_sig_handler);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000888 if (rec->opts.auxtrace_snapshot_mode)
889 trigger_on(&auxtrace_snapshot_trigger);
Jiri Olsadc0c6122017-01-09 10:51:58 +0100890 if (rec->switch_output.enabled)
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000891 trigger_on(&switch_output_trigger);
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000892 } else {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300893 signal(SIGUSR2, SIG_IGN);
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000894 }
Peter Zijlstraf5970552009-06-18 23:22:55 +0200895
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300896 session = perf_session__new(file, false, tool);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -0200897 if (session == NULL) {
Adrien BAKffa91882014-04-18 11:00:43 +0900898 pr_err("Perf session creation failed.\n");
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -0200899 return -1;
900 }
901
Namhyung Kim42aa2762015-01-29 17:06:48 +0900902 fd = perf_data_file__fd(file);
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200903 rec->session = session;
904
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300905 record__init_features(rec);
Stephane Eranian330aa672012-03-08 23:47:46 +0100906
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -0200907 if (forks) {
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300908 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
Jiri Olsaf5fc1412013-10-15 16:27:32 +0200909 argv, file->is_pipe,
Arnaldo Carvalho de Melo735f7e02014-01-03 14:56:49 -0300910 workload_exec_failed_signal);
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -0200911 if (err < 0) {
912 pr_err("Couldn't run the workload!\n");
Namhyung Kim45604712014-05-12 09:47:24 +0900913 status = err;
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -0200914 goto out_delete_session;
Jens Axboe0a5ac842009-08-12 11:18:01 +0200915 }
Peter Zijlstra856e9662009-12-16 17:55:55 +0100916 }
917
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300918 if (record__open(rec) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -0600919 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900920 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -0600921 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200922
Wang Nan8690a2a2016-02-22 09:10:32 +0000923 err = bpf__apply_obj_config();
924 if (err) {
925 char errbuf[BUFSIZ];
926
927 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
928 pr_err("ERROR: Apply config to BPF failed: %s\n",
929 errbuf);
930 goto out_child;
931 }
932
Adrian Huntercca84822015-08-19 17:29:21 +0300933 /*
934 * Normally perf_session__new would do this, but it doesn't have the
935 * evlist.
936 */
937 if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
938 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
939 rec->tool.ordered_events = false;
940 }
941
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300942 if (!rec->evlist->nr_groups)
Namhyung Kima8bb5592013-01-22 18:09:31 +0900943 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
944
Jiri Olsaf5fc1412013-10-15 16:27:32 +0200945 if (file->is_pipe) {
Namhyung Kim42aa2762015-01-29 17:06:48 +0900946 err = perf_header__write_pipe(fd);
Tom Zanussi529870e2010-04-01 23:59:16 -0500947 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +0900948 goto out_child;
Jiri Olsa563aecb2013-06-05 13:35:06 +0200949 } else {
Namhyung Kim42aa2762015-01-29 17:06:48 +0900950 err = perf_session__write_header(session, rec->evlist, fd, false);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200951 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +0900952 goto out_child;
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -0200953 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +0200954
David Ahernd3665492012-02-06 15:27:52 -0700955 if (!rec->no_buildid
Robert Richtere20960c2011-12-07 10:02:55 +0100956 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
David Ahernd3665492012-02-06 15:27:52 -0700957 pr_err("Couldn't generate buildids. "
Robert Richtere20960c2011-12-07 10:02:55 +0100958 "Use --no-buildid to profile anyway.\n");
David Ahern8d3eca22012-08-26 12:24:47 -0600959 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900960 goto out_child;
Robert Richtere20960c2011-12-07 10:02:55 +0100961 }
962
Arnaldo Carvalho de Melo34ba5122012-12-19 09:04:24 -0300963 machine = &session->machines.host;
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200964
Wang Nan4ea648a2016-07-14 08:34:47 +0000965 err = record__synthesize(rec, false);
Wang Nanc45c86e2016-02-26 09:32:07 +0000966 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +0900967 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -0600968
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200969 if (rec->realtime_prio) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200970 struct sched_param param;
971
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200972 param.sched_priority = rec->realtime_prio;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200973 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -0200974 pr_err("Could not set realtime priority.\n");
David Ahern8d3eca22012-08-26 12:24:47 -0600975 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +0900976 goto out_child;
Peter Zijlstrade9ac072009-04-08 15:01:31 +0200977 }
978 }
979
Jiri Olsa774cb492012-11-12 18:34:01 +0100980 /*
981 * When perf is starting the traced process, all the events
982 * (apart from group members) have enable_on_exec=1 set,
983 * so don't spoil it by prematurely enabling them.
984 */
Andi Kleen6619a532014-01-11 13:38:27 -0800985 if (!target__none(&opts->target) && !opts->initial_delay)
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300986 perf_evlist__enable(rec->evlist);
David Ahern764e16a32011-08-25 10:17:55 -0600987
Peter Zijlstra856e9662009-12-16 17:55:55 +0100988 /*
989 * Let the child rip
990 */
Namhyung Kime803cf92015-09-22 09:24:55 +0900991 if (forks) {
Namhyung Kime5bed562015-09-30 10:45:24 +0900992 union perf_event *event;
Hari Bathinie907caf2017-03-08 02:11:51 +0530993 pid_t tgid;
Namhyung Kime5bed562015-09-30 10:45:24 +0900994
995 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
996 if (event == NULL) {
997 err = -ENOMEM;
998 goto out_child;
999 }
1000
Namhyung Kime803cf92015-09-22 09:24:55 +09001001 /*
1002 * Some H/W events are generated before COMM event
1003 * which is emitted during exec(), so perf script
1004 * cannot see a correct process name for those events.
1005 * Synthesize COMM event to prevent it.
1006 */
Hari Bathinie907caf2017-03-08 02:11:51 +05301007 tgid = perf_event__synthesize_comm(tool, event,
1008 rec->evlist->workload.pid,
1009 process_synthesized_event,
1010 machine);
1011 free(event);
1012
1013 if (tgid == -1)
1014 goto out_child;
1015
1016 event = malloc(sizeof(event->namespaces) +
1017 (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
1018 machine->id_hdr_size);
1019 if (event == NULL) {
1020 err = -ENOMEM;
1021 goto out_child;
1022 }
1023
1024 /*
1025 * Synthesize NAMESPACES event for the command specified.
1026 */
1027 perf_event__synthesize_namespaces(tool, event,
1028 rec->evlist->workload.pid,
1029 tgid, process_synthesized_event,
1030 machine);
Namhyung Kime5bed562015-09-30 10:45:24 +09001031 free(event);
Namhyung Kime803cf92015-09-22 09:24:55 +09001032
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001033 perf_evlist__start_workload(rec->evlist);
Namhyung Kime803cf92015-09-22 09:24:55 +09001034 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001035
Andi Kleen6619a532014-01-11 13:38:27 -08001036 if (opts->initial_delay) {
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -03001037 usleep(opts->initial_delay * USEC_PER_MSEC);
Andi Kleen6619a532014-01-11 13:38:27 -08001038 perf_evlist__enable(rec->evlist);
1039 }
1040
Wang Nan5f9cf592016-04-20 18:59:49 +00001041 trigger_ready(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001042 trigger_ready(&switch_output_trigger);
Wang Nana0748652016-11-26 07:03:28 +00001043 perf_hooks__invoke_record_start();
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001044 for (;;) {
Yang Shi9f065192015-09-29 14:49:43 -07001045 unsigned long long hits = rec->samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001046
Wang Nan057374642016-07-14 08:34:43 +00001047 /*
1048 * rec->evlist->bkw_mmap_state is possible to be
1049 * BKW_MMAP_EMPTY here: when done == true and
1050 * hits != rec->samples in previous round.
1051 *
1052 * perf_evlist__toggle_bkw_mmap ensure we never
1053 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
1054 */
1055 if (trigger_is_hit(&switch_output_trigger) || done || draining)
1056 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
1057
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001058 if (record__mmap_read_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001059 trigger_error(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001060 trigger_error(&switch_output_trigger);
David Ahern8d3eca22012-08-26 12:24:47 -06001061 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001062 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001063 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001064
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001065 if (auxtrace_record__snapshot_started) {
1066 auxtrace_record__snapshot_started = 0;
Wang Nan5f9cf592016-04-20 18:59:49 +00001067 if (!trigger_is_error(&auxtrace_snapshot_trigger))
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001068 record__read_auxtrace_snapshot(rec);
Wang Nan5f9cf592016-04-20 18:59:49 +00001069 if (trigger_is_error(&auxtrace_snapshot_trigger)) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001070 pr_err("AUX area tracing snapshot failed\n");
1071 err = -1;
1072 goto out_child;
1073 }
1074 }
1075
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001076 if (trigger_is_hit(&switch_output_trigger)) {
Wang Nan057374642016-07-14 08:34:43 +00001077 /*
1078 * If switch_output_trigger is hit, the data in
1079 * overwritable ring buffer should have been collected,
1080 * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
1081 *
1082 * If SIGUSR2 raise after or during record__mmap_read_all(),
1083 * record__mmap_read_all() didn't collect data from
1084 * overwritable ring buffer. Read again.
1085 */
1086 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
1087 continue;
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001088 trigger_ready(&switch_output_trigger);
1089
Wang Nan057374642016-07-14 08:34:43 +00001090 /*
1091 * Reenable events in overwrite ring buffer after
1092 * record__mmap_read_all(): we should have collected
1093 * data from it.
1094 */
1095 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1096
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001097 if (!quiet)
1098 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1099 waking);
1100 waking = 0;
1101 fd = record__switch_output(rec, false);
1102 if (fd < 0) {
1103 pr_err("Failed to switch to new file\n");
1104 trigger_error(&switch_output_trigger);
1105 err = fd;
1106 goto out_child;
1107 }
Jiri Olsabfacbe32017-01-09 10:52:00 +01001108
1109 /* re-arm the alarm */
1110 if (rec->switch_output.time)
1111 alarm(rec->switch_output.time);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001112 }
1113
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001114 if (hits == rec->samples) {
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001115 if (done || draining)
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001116 break;
Arnaldo Carvalho de Melof66a8892014-08-18 17:25:59 -03001117 err = perf_evlist__poll(rec->evlist, -1);
Jiri Olsaa5151142014-06-02 13:44:23 -04001118 /*
1119 * Propagate error, only if there's any. Ignore positive
1120 * number of returned events and interrupt error.
1121 */
1122 if (err > 0 || (err < 0 && errno == EINTR))
Namhyung Kim45604712014-05-12 09:47:24 +09001123 err = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001124 waking++;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001125
1126 if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
1127 draining = true;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001128 }
1129
Jiri Olsa774cb492012-11-12 18:34:01 +01001130 /*
1131 * When perf is starting the traced process, at the end events
1132 * die with the process and we wait for that. Thus no need to
1133 * disable events in this case.
1134 */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001135 if (done && !disabled && !target__none(&opts->target)) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001136 trigger_off(&auxtrace_snapshot_trigger);
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001137 perf_evlist__disable(rec->evlist);
Jiri Olsa27119262012-11-12 18:34:02 +01001138 disabled = true;
1139 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001140 }
Wang Nan5f9cf592016-04-20 18:59:49 +00001141 trigger_off(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001142 trigger_off(&switch_output_trigger);
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001143
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001144 if (forks && workload_exec_errno) {
Masami Hiramatsu35550da2014-08-14 02:22:43 +00001145 char msg[STRERR_BUFSIZE];
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -03001146 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001147 pr_err("Workload failed: %s\n", emsg);
1148 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001149 goto out_child;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001150 }
1151
Namhyung Kime3d59112015-01-29 17:06:44 +09001152 if (!quiet)
Namhyung Kim45604712014-05-12 09:47:24 +09001153 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001154
Wang Nan4ea648a2016-07-14 08:34:47 +00001155 if (target__none(&rec->opts.target))
1156 record__synthesize_workload(rec, true);
1157
Namhyung Kim45604712014-05-12 09:47:24 +09001158out_child:
1159 if (forks) {
1160 int exit_status;
Ingo Molnaraddc2782009-06-02 23:43:11 +02001161
Namhyung Kim45604712014-05-12 09:47:24 +09001162 if (!child_finished)
1163 kill(rec->evlist->workload.pid, SIGTERM);
1164
1165 wait(&exit_status);
1166
1167 if (err < 0)
1168 status = err;
1169 else if (WIFEXITED(exit_status))
1170 status = WEXITSTATUS(exit_status);
1171 else if (WIFSIGNALED(exit_status))
1172 signr = WTERMSIG(exit_status);
1173 } else
1174 status = err;
1175
Wang Nan4ea648a2016-07-14 08:34:47 +00001176 record__synthesize(rec, true);
Namhyung Kime3d59112015-01-29 17:06:44 +09001177 /* this will be recalculated during process_buildids() */
1178 rec->samples = 0;
1179
Wang Nanecfd7a92016-04-13 08:21:07 +00001180 if (!err) {
1181 if (!rec->timestamp_filename) {
1182 record__finish_output(rec);
1183 } else {
1184 fd = record__switch_output(rec, true);
1185 if (fd < 0) {
1186 status = fd;
1187 goto out_delete_session;
1188 }
1189 }
1190 }
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001191
Wang Nana0748652016-11-26 07:03:28 +00001192 perf_hooks__invoke_record_end();
1193
Namhyung Kime3d59112015-01-29 17:06:44 +09001194 if (!err && !quiet) {
1195 char samples[128];
Wang Nanecfd7a92016-04-13 08:21:07 +00001196 const char *postfix = rec->timestamp_filename ?
1197 ".<timestamp>" : "";
Namhyung Kime3d59112015-01-29 17:06:44 +09001198
Adrian Hunteref149c22015-04-09 18:53:45 +03001199 if (rec->samples && !rec->opts.full_auxtrace)
Namhyung Kime3d59112015-01-29 17:06:44 +09001200 scnprintf(samples, sizeof(samples),
1201 " (%" PRIu64 " samples)", rec->samples);
1202 else
1203 samples[0] = '\0';
1204
Wang Nanecfd7a92016-04-13 08:21:07 +00001205 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s ]\n",
Namhyung Kime3d59112015-01-29 17:06:44 +09001206 perf_data_file__size(file) / 1024.0 / 1024.0,
Wang Nanecfd7a92016-04-13 08:21:07 +00001207 file->path, postfix, samples);
Namhyung Kime3d59112015-01-29 17:06:44 +09001208 }
1209
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001210out_delete_session:
1211 perf_session__delete(session);
Namhyung Kim45604712014-05-12 09:47:24 +09001212 return status;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001213}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001214
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001215static void callchain_debug(struct callchain_param *callchain)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001216{
Kan Liangaad2b212015-01-05 13:23:04 -05001217 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
Jiri Olsaa601fdf2014-02-03 12:44:43 +01001218
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001219 pr_debug("callchain: type %s\n", str[callchain->record_mode]);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001220
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001221 if (callchain->record_mode == CALLCHAIN_DWARF)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001222 pr_debug("callchain: stack dump size %d\n",
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001223 callchain->dump_size);
1224}
1225
1226int record_opts__parse_callchain(struct record_opts *record,
1227 struct callchain_param *callchain,
1228 const char *arg, bool unset)
1229{
1230 int ret;
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001231 callchain->enabled = !unset;
1232
1233 /* --no-call-graph */
1234 if (unset) {
1235 callchain->record_mode = CALLCHAIN_NONE;
1236 pr_debug("callchain: disabled\n");
1237 return 0;
1238 }
1239
1240 ret = parse_callchain_record_opt(arg, callchain);
1241 if (!ret) {
1242 /* Enable data address sampling for DWARF unwind. */
1243 if (callchain->record_mode == CALLCHAIN_DWARF)
1244 record->sample_address = true;
1245 callchain_debug(callchain);
1246 }
1247
1248 return ret;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001249}
1250
Kan Liangc421e802015-07-29 05:42:12 -04001251int record_parse_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001252 const char *arg,
1253 int unset)
1254{
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001255 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
Jiri Olsa26d33022012-08-07 15:20:47 +02001256}
1257
Kan Liangc421e802015-07-29 05:42:12 -04001258int record_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001259 const char *arg __maybe_unused,
1260 int unset __maybe_unused)
1261{
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001262 struct callchain_param *callchain = opt->value;
Kan Liangc421e802015-07-29 05:42:12 -04001263
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001264 callchain->enabled = true;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001265
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001266 if (callchain->record_mode == CALLCHAIN_NONE)
1267 callchain->record_mode = CALLCHAIN_FP;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001268
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001269 callchain_debug(callchain);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001270 return 0;
1271}
1272
Jiri Olsaeb853e82014-02-03 12:44:42 +01001273static int perf_record_config(const char *var, const char *value, void *cb)
1274{
Namhyung Kim7a29c082015-12-15 10:49:56 +09001275 struct record *rec = cb;
1276
1277 if (!strcmp(var, "record.build-id")) {
1278 if (!strcmp(value, "cache"))
1279 rec->no_buildid_cache = false;
1280 else if (!strcmp(value, "no-cache"))
1281 rec->no_buildid_cache = true;
1282 else if (!strcmp(value, "skip"))
1283 rec->no_buildid = true;
1284 else
1285 return -1;
1286 return 0;
1287 }
Jiri Olsaeb853e82014-02-03 12:44:42 +01001288 if (!strcmp(var, "record.call-graph"))
Namhyung Kim5a2e5e82014-09-23 10:01:44 +09001289 var = "call-graph.record-mode"; /* fall-through */
Jiri Olsaeb853e82014-02-03 12:44:42 +01001290
1291 return perf_default_config(var, value, cb);
1292}
1293
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001294struct clockid_map {
1295 const char *name;
1296 int clockid;
1297};
1298
1299#define CLOCKID_MAP(n, c) \
1300 { .name = n, .clockid = (c), }
1301
1302#define CLOCKID_END { .name = NULL, }
1303
1304
1305/*
1306 * Add the missing ones, we need to build on many distros...
1307 */
1308#ifndef CLOCK_MONOTONIC_RAW
1309#define CLOCK_MONOTONIC_RAW 4
1310#endif
1311#ifndef CLOCK_BOOTTIME
1312#define CLOCK_BOOTTIME 7
1313#endif
1314#ifndef CLOCK_TAI
1315#define CLOCK_TAI 11
1316#endif
1317
1318static const struct clockid_map clockids[] = {
1319 /* available for all events, NMI safe */
1320 CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
1321 CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
1322
1323 /* available for some events */
1324 CLOCKID_MAP("realtime", CLOCK_REALTIME),
1325 CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
1326 CLOCKID_MAP("tai", CLOCK_TAI),
1327
1328 /* available for the lazy */
1329 CLOCKID_MAP("mono", CLOCK_MONOTONIC),
1330 CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
1331 CLOCKID_MAP("real", CLOCK_REALTIME),
1332 CLOCKID_MAP("boot", CLOCK_BOOTTIME),
1333
1334 CLOCKID_END,
1335};
1336
1337static int parse_clockid(const struct option *opt, const char *str, int unset)
1338{
1339 struct record_opts *opts = (struct record_opts *)opt->value;
1340 const struct clockid_map *cm;
1341 const char *ostr = str;
1342
1343 if (unset) {
1344 opts->use_clockid = 0;
1345 return 0;
1346 }
1347
1348 /* no arg passed */
1349 if (!str)
1350 return 0;
1351
1352 /* no setting it twice */
1353 if (opts->use_clockid)
1354 return -1;
1355
1356 opts->use_clockid = true;
1357
1358 /* if its a number, we're done */
1359 if (sscanf(str, "%d", &opts->clockid) == 1)
1360 return 0;
1361
1362 /* allow a "CLOCK_" prefix to the name */
1363 if (!strncasecmp(str, "CLOCK_", 6))
1364 str += 6;
1365
1366 for (cm = clockids; cm->name; cm++) {
1367 if (!strcasecmp(str, cm->name)) {
1368 opts->clockid = cm->clockid;
1369 return 0;
1370 }
1371 }
1372
1373 opts->use_clockid = false;
1374 ui__warning("unknown clockid %s, check man page\n", ostr);
1375 return -1;
1376}
1377
Adrian Huntere9db1312015-04-09 18:53:46 +03001378static int record__parse_mmap_pages(const struct option *opt,
1379 const char *str,
1380 int unset __maybe_unused)
1381{
1382 struct record_opts *opts = opt->value;
1383 char *s, *p;
1384 unsigned int mmap_pages;
1385 int ret;
1386
1387 if (!str)
1388 return -EINVAL;
1389
1390 s = strdup(str);
1391 if (!s)
1392 return -ENOMEM;
1393
1394 p = strchr(s, ',');
1395 if (p)
1396 *p = '\0';
1397
1398 if (*s) {
1399 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
1400 if (ret)
1401 goto out_free;
1402 opts->mmap_pages = mmap_pages;
1403 }
1404
1405 if (!p) {
1406 ret = 0;
1407 goto out_free;
1408 }
1409
1410 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
1411 if (ret)
1412 goto out_free;
1413
1414 opts->auxtrace_mmap_pages = mmap_pages;
1415
1416out_free:
1417 free(s);
1418 return ret;
1419}
1420
Jiri Olsa0c582442017-01-09 10:51:59 +01001421static void switch_output_size_warn(struct record *rec)
1422{
1423 u64 wakeup_size = perf_evlist__mmap_size(rec->opts.mmap_pages);
1424 struct switch_output *s = &rec->switch_output;
1425
1426 wakeup_size /= 2;
1427
1428 if (s->size < wakeup_size) {
1429 char buf[100];
1430
1431 unit_number__scnprintf(buf, sizeof(buf), wakeup_size);
1432 pr_warning("WARNING: switch-output data size lower than "
1433 "wakeup kernel buffer size (%s) "
1434 "expect bigger perf.data sizes\n", buf);
1435 }
1436}
1437
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001438static int switch_output_setup(struct record *rec)
1439{
1440 struct switch_output *s = &rec->switch_output;
Jiri Olsadc0c6122017-01-09 10:51:58 +01001441 static struct parse_tag tags_size[] = {
1442 { .tag = 'B', .mult = 1 },
1443 { .tag = 'K', .mult = 1 << 10 },
1444 { .tag = 'M', .mult = 1 << 20 },
1445 { .tag = 'G', .mult = 1 << 30 },
1446 { .tag = 0 },
1447 };
Jiri Olsabfacbe32017-01-09 10:52:00 +01001448 static struct parse_tag tags_time[] = {
1449 { .tag = 's', .mult = 1 },
1450 { .tag = 'm', .mult = 60 },
1451 { .tag = 'h', .mult = 60*60 },
1452 { .tag = 'd', .mult = 60*60*24 },
1453 { .tag = 0 },
1454 };
Jiri Olsadc0c6122017-01-09 10:51:58 +01001455 unsigned long val;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001456
1457 if (!s->set)
1458 return 0;
1459
1460 if (!strcmp(s->str, "signal")) {
1461 s->signal = true;
1462 pr_debug("switch-output with SIGUSR2 signal\n");
Jiri Olsadc0c6122017-01-09 10:51:58 +01001463 goto enabled;
1464 }
1465
1466 val = parse_tag_value(s->str, tags_size);
1467 if (val != (unsigned long) -1) {
1468 s->size = val;
1469 pr_debug("switch-output with %s size threshold\n", s->str);
1470 goto enabled;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001471 }
1472
Jiri Olsabfacbe32017-01-09 10:52:00 +01001473 val = parse_tag_value(s->str, tags_time);
1474 if (val != (unsigned long) -1) {
1475 s->time = val;
1476 pr_debug("switch-output with %s time threshold (%lu seconds)\n",
1477 s->str, s->time);
1478 goto enabled;
1479 }
1480
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001481 return -1;
Jiri Olsadc0c6122017-01-09 10:51:58 +01001482
1483enabled:
1484 rec->timestamp_filename = true;
1485 s->enabled = true;
Jiri Olsa0c582442017-01-09 10:51:59 +01001486
1487 if (s->size && !rec->opts.no_buffering)
1488 switch_output_size_warn(rec);
1489
Jiri Olsadc0c6122017-01-09 10:51:58 +01001490 return 0;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001491}
1492
Namhyung Kime5b2c202014-10-23 00:15:46 +09001493static const char * const __record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +02001494 "perf record [<options>] [<command>]",
1495 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001496 NULL
1497};
Namhyung Kime5b2c202014-10-23 00:15:46 +09001498const char * const *record_usage = __record_usage;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001499
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001500/*
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001501 * XXX Ideally would be local to cmd_record() and passed to a record__new
1502 * because we need to have access to it in record__exit, that is called
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001503 * after cmd_record() exits, but since record_options need to be accessible to
1504 * builtin-script, leave it here.
1505 *
1506 * At least we don't ouch it in all the other functions here directly.
1507 *
1508 * Just say no to tons of global variables, sigh.
1509 */
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001510static struct record record = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001511 .opts = {
Andi Kleen8affc2b2014-07-31 14:45:04 +08001512 .sample_time = true,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001513 .mmap_pages = UINT_MAX,
1514 .user_freq = UINT_MAX,
1515 .user_interval = ULLONG_MAX,
Arnaldo Carvalho de Melo447a6012012-05-22 13:14:18 -03001516 .freq = 4000,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09001517 .target = {
1518 .uses_mmap = true,
Adrian Hunter3aa59392013-11-15 15:52:29 +02001519 .default_per_cpu = true,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09001520 },
Kan Liang9d9cad72015-06-17 09:51:11 -04001521 .proc_map_timeout = 500,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001522 },
Namhyung Kime3d59112015-01-29 17:06:44 +09001523 .tool = {
1524 .sample = process_sample_event,
1525 .fork = perf_event__process_fork,
Adrian Huntercca84822015-08-19 17:29:21 +03001526 .exit = perf_event__process_exit,
Namhyung Kime3d59112015-01-29 17:06:44 +09001527 .comm = perf_event__process_comm,
Hari Bathinif3b36142017-03-08 02:11:43 +05301528 .namespaces = perf_event__process_namespaces,
Namhyung Kime3d59112015-01-29 17:06:44 +09001529 .mmap = perf_event__process_mmap,
1530 .mmap2 = perf_event__process_mmap2,
Adrian Huntercca84822015-08-19 17:29:21 +03001531 .ordered_events = true,
Namhyung Kime3d59112015-01-29 17:06:44 +09001532 },
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001533};
Frederic Weisbecker7865e812010-04-14 19:42:07 +02001534
Namhyung Kim76a26542015-10-22 23:28:32 +09001535const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
1536 "\n\t\t\t\tDefault: fp";
Arnaldo Carvalho de Melo61eaa3b2012-10-01 15:20:58 -03001537
Wang Nan0aab2132016-06-16 08:02:41 +00001538static bool dry_run;
1539
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001540/*
1541 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
1542 * with it and switch to use the library functions in perf_evlist that came
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001543 * from builtin-record.c, i.e. use record_opts,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001544 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
1545 * using pipes, etc.
1546 */
Jiri Olsaefd21302017-01-03 09:19:55 +01001547static struct option __record_options[] = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001548 OPT_CALLBACK('e', "event", &record.evlist, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +02001549 "event selector. use 'perf list' to list available events",
Jiri Olsaf120f9d2011-07-14 11:25:32 +02001550 parse_events_option),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001551 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
Li Zefanc171b552009-10-15 11:22:07 +08001552 "event filter", parse_filter),
Wang Nan4ba1faa2015-07-10 07:36:10 +00001553 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
1554 NULL, "don't record events from perf itself",
1555 exclude_perf),
Namhyung Kimbea03402012-04-26 14:15:15 +09001556 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001557 "record events on existing process id"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001558 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001559 "record events on existing thread id"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001560 OPT_INTEGER('r', "realtime", &record.realtime_prio,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001561 "collect data with this RT SCHED_FIFO priority"),
Arnaldo Carvalho de Melo509051e2014-01-14 17:52:14 -03001562 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
Kirill Smelkovacac03f2011-01-12 17:59:36 +03001563 "collect data without buffering"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001564 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +02001565 "collect raw sample records from all opened counters"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001566 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001567 "system-wide collection from all CPUs"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001568 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02001569 "list of cpus to monitor"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001570 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
Jiri Olsaf5fc1412013-10-15 16:27:32 +02001571 OPT_STRING('o', "output", &record.file.path, "file",
Ingo Molnarabaff322009-06-02 22:59:57 +02001572 "output file name"),
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02001573 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1574 &record.opts.no_inherit_set,
1575 "child tasks do not inherit counters"),
Wang Nan4ea648a2016-07-14 08:34:47 +00001576 OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize,
1577 "synthesize non-sample events at the end of output"),
Wang Nan626a6b72016-07-14 08:34:45 +00001578 OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001579 OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
Adrian Huntere9db1312015-04-09 18:53:46 +03001580 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1581 "number of mmap data pages and AUX area tracing mmap pages",
1582 record__parse_mmap_pages),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001583 OPT_BOOLEAN(0, "group", &record.opts.group,
Lin Ming43bece72011-08-17 18:42:07 +08001584 "put the counters into a counter group"),
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001585 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001586 NULL, "enables call-graph recording" ,
1587 &record_callchain_opt),
1588 OPT_CALLBACK(0, "call-graph", &record.opts,
Namhyung Kim76a26542015-10-22 23:28:32 +09001589 "record_mode[,record_size]", record_callchain_help,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001590 &record_parse_callchain_opt),
Ian Munsiec0555642010-04-13 18:37:33 +10001591 OPT_INCR('v', "verbose", &verbose,
Ingo Molnar3da297a2009-06-07 17:39:02 +02001592 "be more verbose (show counter open errors, etc)"),
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001593 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001594 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001595 "per thread counts"),
Peter Zijlstra56100322015-06-10 16:48:50 +02001596 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
Jiri Olsab6f35ed2016-08-01 20:02:35 +02001597 OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"),
Adrian Hunter3abebc52015-07-06 14:51:01 +03001598 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
1599 &record.opts.sample_time_set,
1600 "Record the sample timestamps"),
Peter Zijlstra56100322015-06-10 16:48:50 +02001601 OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001602 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001603 "don't sample"),
Wang Nand2db9a92016-01-25 09:56:19 +00001604 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
1605 &record.no_buildid_cache_set,
1606 "do not update the buildid cache"),
1607 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
1608 &record.no_buildid_set,
1609 "do not collect buildids in perf.data"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001610 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
Stephane Eranian023695d2011-02-14 11:20:01 +02001611 "monitor event in cgroup name only",
1612 parse_cgroups),
Arnaldo Carvalho de Meloa6205a32014-01-14 17:58:12 -03001613 OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
Andi Kleen6619a532014-01-11 13:38:27 -08001614 "ms to wait before starting measurement after program start"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001615 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1616 "user to profile"),
Stephane Eraniana5aabda2012-03-08 23:47:45 +01001617
1618 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1619 "branch any", "sample any taken branches",
1620 parse_branch_stack),
1621
1622 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1623 "branch filter mask", "branch stack filter modes",
Roberto Agostino Vitillobdfebd82012-02-09 23:21:02 +01001624 parse_branch_stack),
Andi Kleen05484292013-01-24 16:10:29 +01001625 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1626 "sample by weight (on special events only)"),
Andi Kleen475eeab2013-09-20 07:40:43 -07001627 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1628 "sample transaction flags (special events only)"),
Adrian Hunter3aa59392013-11-15 15:52:29 +02001629 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1630 "use per-thread mmaps"),
Stephane Eranianbcc84ec2015-08-31 18:41:12 +02001631 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
1632 "sample selected machine registers on interrupt,"
1633 " use -I ? to list register names", parse_regs),
Andi Kleen85c273d2015-02-24 15:13:40 -08001634 OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1635 "Record running/enabled time of read (:S) events"),
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001636 OPT_CALLBACK('k', "clockid", &record.opts,
1637 "clockid", "clockid to use for events, see clock_gettime()",
1638 parse_clockid),
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001639 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1640 "opts", "AUX area tracing Snapshot Mode", ""),
Kan Liang9d9cad72015-06-17 09:51:11 -04001641 OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
1642 "per thread proc mmap processing timeout in ms"),
Hari Bathinif3b36142017-03-08 02:11:43 +05301643 OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
1644 "Record namespaces events"),
Adrian Hunterb757bb02015-07-21 12:44:04 +03001645 OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
1646 "Record context switch events"),
Jiri Olsa85723882016-02-15 09:34:31 +01001647 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
1648 "Configure all used events to run in kernel space.",
1649 PARSE_OPT_EXCLUSIVE),
1650 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
1651 "Configure all used events to run in user space.",
1652 PARSE_OPT_EXCLUSIVE),
Wang Nan71dc23262015-10-14 12:41:19 +00001653 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
1654 "clang binary to use for compiling BPF scriptlets"),
1655 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
1656 "options passed to clang when compiling BPF scriptlets"),
He Kuang7efe0e02015-12-14 10:39:23 +00001657 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
1658 "file", "vmlinux pathname"),
Namhyung Kim61566812016-01-11 22:37:09 +09001659 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
1660 "Record build-id of all DSOs regardless of hits"),
Wang Nanecfd7a92016-04-13 08:21:07 +00001661 OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
1662 "append timestamp to output filename"),
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001663 OPT_STRING_OPTARG_SET(0, "switch-output", &record.switch_output.str,
Jiri Olsabfacbe32017-01-09 10:52:00 +01001664 &record.switch_output.set, "signal,size,time",
1665 "Switch output when receive SIGUSR2 or cross size,time threshold",
Jiri Olsadc0c6122017-01-09 10:51:58 +01001666 "signal"),
Wang Nan0aab2132016-06-16 08:02:41 +00001667 OPT_BOOLEAN(0, "dry-run", &dry_run,
1668 "Parse options then exit"),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001669 OPT_END()
1670};
1671
Namhyung Kime5b2c202014-10-23 00:15:46 +09001672struct option *record_options = __record_options;
1673
Arnaldo Carvalho de Melob0ad8ea2017-03-27 11:47:20 -03001674int cmd_record(int argc, const char **argv)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001675{
Adrian Hunteref149c22015-04-09 18:53:45 +03001676 int err;
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001677 struct record *rec = &record;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001678 char errbuf[BUFSIZ];
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001679
Wang Nan48e1cab2015-12-14 10:39:22 +00001680#ifndef HAVE_LIBBPF_SUPPORT
1681# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
1682 set_nobuild('\0', "clang-path", true);
1683 set_nobuild('\0', "clang-opt", true);
1684# undef set_nobuild
1685#endif
1686
He Kuang7efe0e02015-12-14 10:39:23 +00001687#ifndef HAVE_BPF_PROLOGUE
1688# if !defined (HAVE_DWARF_SUPPORT)
1689# define REASON "NO_DWARF=1"
1690# elif !defined (HAVE_LIBBPF_SUPPORT)
1691# define REASON "NO_LIBBPF=1"
1692# else
1693# define REASON "this architecture doesn't support BPF prologue"
1694# endif
1695# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
1696 set_nobuild('\0', "vmlinux", true);
1697# undef set_nobuild
1698# undef REASON
1699#endif
1700
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001701 rec->evlist = perf_evlist__new();
1702 if (rec->evlist == NULL)
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02001703 return -ENOMEM;
1704
Arnaldo Carvalho de Meloecc4c562017-01-24 13:44:10 -03001705 err = perf_config(perf_record_config, rec);
1706 if (err)
1707 return err;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001708
Tom Zanussibca647a2010-11-10 08:11:30 -06001709 argc = parse_options(argc, argv, record_options, record_usage,
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001710 PARSE_OPT_STOP_AT_NON_OPTION);
Namhyung Kim68ba3232017-02-17 17:17:42 +09001711 if (quiet)
1712 perf_quiet_option();
Jiri Olsa483635a2017-02-17 18:00:18 +01001713
1714 /* Make system wide (-a) the default target. */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001715 if (!argc && target__none(&rec->opts.target))
Jiri Olsa483635a2017-02-17 18:00:18 +01001716 rec->opts.target.system_wide = true;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001717
Namhyung Kimbea03402012-04-26 14:15:15 +09001718 if (nr_cgroups && !rec->opts.target.system_wide) {
Namhyung Kimc7118362015-10-25 00:49:27 +09001719 usage_with_options_msg(record_usage, record_options,
1720 "cgroup monitoring only available in system-wide mode");
1721
Stephane Eranian023695d2011-02-14 11:20:01 +02001722 }
Adrian Hunterb757bb02015-07-21 12:44:04 +03001723 if (rec->opts.record_switch_events &&
1724 !perf_can_record_switch_events()) {
Namhyung Kimc7118362015-10-25 00:49:27 +09001725 ui__error("kernel does not support recording context switch events\n");
1726 parse_options_usage(record_usage, record_options, "switch-events", 0);
1727 return -EINVAL;
Adrian Hunterb757bb02015-07-21 12:44:04 +03001728 }
Stephane Eranian023695d2011-02-14 11:20:01 +02001729
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001730 if (switch_output_setup(rec)) {
1731 parse_options_usage(record_usage, record_options, "switch-output", 0);
1732 return -EINVAL;
1733 }
1734
Jiri Olsabfacbe32017-01-09 10:52:00 +01001735 if (rec->switch_output.time) {
1736 signal(SIGALRM, alarm_sig_handler);
1737 alarm(rec->switch_output.time);
1738 }
1739
Adrian Hunteref149c22015-04-09 18:53:45 +03001740 if (!rec->itr) {
1741 rec->itr = auxtrace_record__init(rec->evlist, &err);
1742 if (err)
Adrian Hunter5c01ad62016-09-23 17:38:37 +03001743 goto out;
Adrian Hunteref149c22015-04-09 18:53:45 +03001744 }
1745
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001746 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
1747 rec->opts.auxtrace_snapshot_opts);
1748 if (err)
Adrian Hunter5c01ad62016-09-23 17:38:37 +03001749 goto out;
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001750
Adrian Hunter1b36c032016-09-23 17:38:39 +03001751 /*
1752 * Allow aliases to facilitate the lookup of symbols for address
1753 * filters. Refer to auxtrace_parse_filters().
1754 */
1755 symbol_conf.allow_aliases = true;
1756
1757 symbol__init(NULL);
1758
1759 err = auxtrace_parse_filters(rec->evlist);
1760 if (err)
1761 goto out;
1762
Wang Nan0aab2132016-06-16 08:02:41 +00001763 if (dry_run)
Adrian Hunter5c01ad62016-09-23 17:38:37 +03001764 goto out;
Wang Nan0aab2132016-06-16 08:02:41 +00001765
Wang Nand7888572016-04-08 15:07:24 +00001766 err = bpf__setup_stdout(rec->evlist);
1767 if (err) {
1768 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
1769 pr_err("ERROR: Setup BPF stdout failed: %s\n",
1770 errbuf);
Adrian Hunter5c01ad62016-09-23 17:38:37 +03001771 goto out;
Wang Nand7888572016-04-08 15:07:24 +00001772 }
1773
Adrian Hunteref149c22015-04-09 18:53:45 +03001774 err = -ENOMEM;
1775
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -03001776 if (symbol_conf.kptr_restrict)
Arnaldo Carvalho de Melo646aaea62011-05-27 11:00:41 -03001777 pr_warning(
1778"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
1779"check /proc/sys/kernel/kptr_restrict.\n\n"
1780"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
1781"file is not found in the buildid cache or in the vmlinux path.\n\n"
1782"Samples in kernel modules won't be resolved at all.\n\n"
1783"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
1784"even with a suitable vmlinux or kallsyms file.\n\n");
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -03001785
Wang Nan0c1d46a2016-04-20 18:59:52 +00001786 if (rec->no_buildid_cache || rec->no_buildid) {
Stephane Eraniana1ac1d32010-06-17 11:39:01 +02001787 disable_buildid_cache();
Jiri Olsadc0c6122017-01-09 10:51:58 +01001788 } else if (rec->switch_output.enabled) {
Wang Nan0c1d46a2016-04-20 18:59:52 +00001789 /*
1790 * In 'perf record --switch-output', disable buildid
1791 * generation by default to reduce data file switching
1792 * overhead. Still generate buildid if they are required
1793 * explicitly using
1794 *
Jiri Olsa60437ac2017-01-03 09:19:56 +01001795 * perf record --switch-output --no-no-buildid \
Wang Nan0c1d46a2016-04-20 18:59:52 +00001796 * --no-no-buildid-cache
1797 *
1798 * Following code equals to:
1799 *
1800 * if ((rec->no_buildid || !rec->no_buildid_set) &&
1801 * (rec->no_buildid_cache || !rec->no_buildid_cache_set))
1802 * disable_buildid_cache();
1803 */
1804 bool disable = true;
1805
1806 if (rec->no_buildid_set && !rec->no_buildid)
1807 disable = false;
1808 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
1809 disable = false;
1810 if (disable) {
1811 rec->no_buildid = true;
1812 rec->no_buildid_cache = true;
1813 disable_buildid_cache();
1814 }
1815 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001816
Wang Nan4ea648a2016-07-14 08:34:47 +00001817 if (record.opts.overwrite)
1818 record.opts.tail_synthesize = true;
1819
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001820 if (rec->evlist->nr_entries == 0 &&
1821 perf_evlist__add_default(rec->evlist) < 0) {
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02001822 pr_err("Not enough memory for event selector list\n");
Adrian Hunter394c01e2016-09-23 17:38:36 +03001823 goto out;
Peter Zijlstrabbd36e52009-06-11 23:11:50 +02001824 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001825
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02001826 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
1827 rec->opts.no_inherit = true;
1828
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001829 err = target__validate(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001830 if (err) {
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001831 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001832 ui__warning("%s", errbuf);
1833 }
Namhyung Kim4bd0f2d2012-04-26 14:15:18 +09001834
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001835 err = target__parse_uid(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001836 if (err) {
1837 int saved_errno = errno;
1838
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001839 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim3780f482012-05-29 13:22:57 +09001840 ui__error("%s", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001841
1842 err = -saved_errno;
Adrian Hunter394c01e2016-09-23 17:38:36 +03001843 goto out;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001844 }
Arnaldo Carvalho de Melo0d37aa32012-01-19 14:08:15 -02001845
Jiri Olsa23dc4f12016-12-12 11:35:43 +01001846 /* Enable ignoring missing threads when -u option is defined. */
1847 rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX;
1848
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09001849 err = -ENOMEM;
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001850 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -02001851 usage_with_options(record_usage, record_options);
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02001852
Adrian Hunteref149c22015-04-09 18:53:45 +03001853 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
1854 if (err)
Adrian Hunter394c01e2016-09-23 17:38:36 +03001855 goto out;
Adrian Hunteref149c22015-04-09 18:53:45 +03001856
Namhyung Kim61566812016-01-11 22:37:09 +09001857 /*
1858 * We take all buildids when the file contains
1859 * AUX area tracing data because we do not decode the
1860 * trace because it would take too long.
1861 */
1862 if (rec->opts.full_auxtrace)
1863 rec->buildid_all = true;
1864
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001865 if (record_opts__config(&rec->opts)) {
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001866 err = -EINVAL;
Adrian Hunter394c01e2016-09-23 17:38:36 +03001867 goto out;
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +02001868 }
1869
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001870 err = __cmd_record(&record, argc, argv);
Adrian Hunter394c01e2016-09-23 17:38:36 +03001871out:
Namhyung Kim45604712014-05-12 09:47:24 +09001872 perf_evlist__delete(rec->evlist);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -03001873 symbol__exit();
Adrian Hunteref149c22015-04-09 18:53:45 +03001874 auxtrace_record__free(rec->itr);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001875 return err;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001876}
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001877
1878static void snapshot_sig_handler(int sig __maybe_unused)
1879{
Jiri Olsadc0c6122017-01-09 10:51:58 +01001880 struct record *rec = &record;
1881
Wang Nan5f9cf592016-04-20 18:59:49 +00001882 if (trigger_is_ready(&auxtrace_snapshot_trigger)) {
1883 trigger_hit(&auxtrace_snapshot_trigger);
1884 auxtrace_record__snapshot_started = 1;
1885 if (auxtrace_record__snapshot_start(record.itr))
1886 trigger_error(&auxtrace_snapshot_trigger);
1887 }
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001888
Jiri Olsadc0c6122017-01-09 10:51:58 +01001889 if (switch_output_signal(rec))
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001890 trigger_hit(&switch_output_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001891}
Jiri Olsabfacbe32017-01-09 10:52:00 +01001892
1893static void alarm_sig_handler(int sig __maybe_unused)
1894{
1895 struct record *rec = &record;
1896
1897 if (switch_output_time(rec))
1898 trigger_hit(&switch_output_trigger);
1899}