blob: e7144a1c1c8226d4bb49f06d0ebb3d90cae51cff [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Ingo Molnarabaff322009-06-02 22:59:57 +02002/*
Ingo Molnarbf9e1872009-06-02 23:37:05 +02003 * builtin-record.c
4 *
5 * Builtin record command: Record the profile of a workload
6 * (or a CPU, or a PID) into the perf.data output file - for
7 * later analysis via perf report.
Ingo Molnarabaff322009-06-02 22:59:57 +02008 */
Ingo Molnar16f762a2009-05-27 09:10:38 +02009#include "builtin.h"
Ingo Molnarbf9e1872009-06-02 23:37:05 +020010
11#include "perf.h"
12
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -020013#include "util/build-id.h"
Thomas Gleixner6eda5832009-05-01 18:29:57 +020014#include "util/util.h"
Josh Poimboeuf4b6ab942015-12-15 09:39:39 -060015#include <subcmd/parse-options.h>
Ingo Molnar8ad8db32009-05-26 11:10:09 +020016#include "util/parse-events.h"
Taeung Song41840d22016-06-23 17:55:17 +090017#include "util/config.h"
Thomas Gleixner6eda5832009-05-01 18:29:57 +020018
Arnaldo Carvalho de Melo8f651ea2014-10-09 16:12:24 -030019#include "util/callchain.h"
Arnaldo Carvalho de Melof14d5702014-10-17 12:17:40 -030020#include "util/cgroup.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020021#include "util/header.h"
Frederic Weisbecker66e274f2009-08-12 11:07:25 +020022#include "util/event.h"
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020023#include "util/evlist.h"
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -020024#include "util/evsel.h"
Frederic Weisbecker8f288272009-08-16 22:05:48 +020025#include "util/debug.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 Olsaf5fc14122013-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"
Alexey Budankovf13de662019-01-22 20:50:57 +030041#include "util/cpu-set-sched.h"
Arnaldo Carvalho de Meloc5e40272017-04-19 16:12:39 -030042#include "util/time-utils.h"
Arnaldo Carvalho de Melo58db1d62017-04-19 16:05:56 -030043#include "util/units.h"
Song Liu7b612e22019-01-17 08:15:19 -080044#include "util/bpf-event.h"
Wang Nand8871ea2016-02-26 09:32:06 +000045#include "asm/bug.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020046
Arnaldo Carvalho de Meloa43783a2017-04-18 10:46:11 -030047#include <errno.h>
Arnaldo Carvalho de Melofd20e812017-04-17 15:23:08 -030048#include <inttypes.h>
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -030049#include <locale.h>
Arnaldo Carvalho de Melo42087352017-04-19 19:06:30 -030050#include <poll.h>
Peter Zijlstra97124d5e2009-06-02 15:52:24 +020051#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020052#include <sched.h>
Arnaldo Carvalho de Melo9607ad32017-04-19 15:49:18 -030053#include <signal.h>
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -030054#include <sys/mman.h>
Arnaldo Carvalho de Melo42087352017-04-19 19:06:30 -030055#include <sys/wait.h>
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -030056#include <linux/time64.h>
Bernhard Rosenkraenzer78da39f2012-10-08 09:43:26 +030057
Jiri Olsa1b43b702017-01-09 10:51:56 +010058struct switch_output {
Jiri Olsadc0c6122017-01-09 10:51:58 +010059 bool enabled;
Jiri Olsa1b43b702017-01-09 10:51:56 +010060 bool signal;
Jiri Olsadc0c6122017-01-09 10:51:58 +010061 unsigned long size;
Jiri Olsabfacbe32017-01-09 10:52:00 +010062 unsigned long time;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +010063 const char *str;
64 bool set;
Andi Kleen03724b22019-03-14 15:49:55 -070065 char **filenames;
66 int num_files;
67 int cur_file;
Jiri Olsa1b43b702017-01-09 10:51:56 +010068};
69
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030070struct record {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020071 struct perf_tool tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -030072 struct record_opts opts;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020073 u64 bytes_written;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +010074 struct perf_data data;
Adrian Hunteref149c22015-04-09 18:53:45 +030075 struct auxtrace_record *itr;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020076 struct perf_evlist *evlist;
77 struct perf_session *session;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020078 int realtime_prio;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020079 bool no_buildid;
Wang Nand2db9a92016-01-25 09:56:19 +000080 bool no_buildid_set;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020081 bool no_buildid_cache;
Wang Nand2db9a92016-01-25 09:56:19 +000082 bool no_buildid_cache_set;
Namhyung Kim61566812016-01-11 22:37:09 +090083 bool buildid_all;
Wang Nanecfd7a92016-04-13 08:21:07 +000084 bool timestamp_filename;
Jin Yao68588ba2017-12-08 21:13:42 +080085 bool timestamp_boundary;
Jiri Olsa1b43b702017-01-09 10:51:56 +010086 struct switch_output switch_output;
Yang Shi9f065192015-09-29 14:49:43 -070087 unsigned long long samples;
Alexey Budankov9d2ed642019-01-22 20:47:43 +030088 cpu_set_t affinity_mask;
Arnaldo Carvalho de Melo0f82ebc2011-11-08 14:41:57 -020089};
Ingo Molnara21ca2c2009-06-06 09:58:57 +020090
Jiri Olsadc0c6122017-01-09 10:51:58 +010091static volatile int auxtrace_record__snapshot_started;
92static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
93static DEFINE_TRIGGER(switch_output_trigger);
94
Alexey Budankov9d2ed642019-01-22 20:47:43 +030095static const char *affinity_tags[PERF_AFFINITY_MAX] = {
96 "SYS", "NODE", "CPU"
97};
98
Jiri Olsadc0c6122017-01-09 10:51:58 +010099static bool switch_output_signal(struct record *rec)
100{
101 return rec->switch_output.signal &&
102 trigger_is_ready(&switch_output_trigger);
103}
104
105static bool switch_output_size(struct record *rec)
106{
107 return rec->switch_output.size &&
108 trigger_is_ready(&switch_output_trigger) &&
109 (rec->bytes_written >= rec->switch_output.size);
110}
111
Jiri Olsabfacbe32017-01-09 10:52:00 +0100112static bool switch_output_time(struct record *rec)
113{
114 return rec->switch_output.time &&
115 trigger_is_ready(&switch_output_trigger);
116}
117
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200118static int record__write(struct record *rec, struct perf_mmap *map __maybe_unused,
119 void *bf, size_t size)
Peter Zijlstraf5970552009-06-18 23:22:55 +0200120{
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200121 struct perf_data_file *file = &rec->session->data->file;
122
123 if (perf_data_file__write(file, bf, size) < 0) {
Jiri Olsa50a9b862013-11-22 13:11:24 +0100124 pr_err("failed to write perf data, error: %m\n");
125 return -1;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200126 }
David Ahern8d3eca22012-08-26 12:24:47 -0600127
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -0300128 rec->bytes_written += size;
Jiri Olsadc0c6122017-01-09 10:51:58 +0100129
130 if (switch_output_size(rec))
131 trigger_hit(&switch_output_trigger);
132
David Ahern8d3eca22012-08-26 12:24:47 -0600133 return 0;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200134}
135
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300136#ifdef HAVE_AIO_SUPPORT
137static int record__aio_write(struct aiocb *cblock, int trace_fd,
138 void *buf, size_t size, off_t off)
139{
140 int rc;
141
142 cblock->aio_fildes = trace_fd;
143 cblock->aio_buf = buf;
144 cblock->aio_nbytes = size;
145 cblock->aio_offset = off;
146 cblock->aio_sigevent.sigev_notify = SIGEV_NONE;
147
148 do {
149 rc = aio_write(cblock);
150 if (rc == 0) {
151 break;
152 } else if (errno != EAGAIN) {
153 cblock->aio_fildes = -1;
154 pr_err("failed to queue perf data, error: %m\n");
155 break;
156 }
157 } while (1);
158
159 return rc;
160}
161
162static int record__aio_complete(struct perf_mmap *md, struct aiocb *cblock)
163{
164 void *rem_buf;
165 off_t rem_off;
166 size_t rem_size;
167 int rc, aio_errno;
168 ssize_t aio_ret, written;
169
170 aio_errno = aio_error(cblock);
171 if (aio_errno == EINPROGRESS)
172 return 0;
173
174 written = aio_ret = aio_return(cblock);
175 if (aio_ret < 0) {
176 if (aio_errno != EINTR)
177 pr_err("failed to write perf data, error: %m\n");
178 written = 0;
179 }
180
181 rem_size = cblock->aio_nbytes - written;
182
183 if (rem_size == 0) {
184 cblock->aio_fildes = -1;
185 /*
186 * md->refcount is incremented in perf_mmap__push() for
187 * every enqueued aio write request so decrement it because
188 * the request is now complete.
189 */
190 perf_mmap__put(md);
191 rc = 1;
192 } else {
193 /*
194 * aio write request may require restart with the
195 * reminder if the kernel didn't write whole
196 * chunk at once.
197 */
198 rem_off = cblock->aio_offset + written;
199 rem_buf = (void *)(cblock->aio_buf + written);
200 record__aio_write(cblock, cblock->aio_fildes,
201 rem_buf, rem_size, rem_off);
202 rc = 0;
203 }
204
205 return rc;
206}
207
Alexey Budankov93f20c02018-11-06 12:07:19 +0300208static int record__aio_sync(struct perf_mmap *md, bool sync_all)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300209{
Alexey Budankov93f20c02018-11-06 12:07:19 +0300210 struct aiocb **aiocb = md->aio.aiocb;
211 struct aiocb *cblocks = md->aio.cblocks;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300212 struct timespec timeout = { 0, 1000 * 1000 * 1 }; /* 1ms */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300213 int i, do_suspend;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300214
215 do {
Alexey Budankov93f20c02018-11-06 12:07:19 +0300216 do_suspend = 0;
217 for (i = 0; i < md->aio.nr_cblocks; ++i) {
218 if (cblocks[i].aio_fildes == -1 || record__aio_complete(md, &cblocks[i])) {
219 if (sync_all)
220 aiocb[i] = NULL;
221 else
222 return i;
223 } else {
224 /*
225 * Started aio write is not complete yet
226 * so it has to be waited before the
227 * next allocation.
228 */
229 aiocb[i] = &cblocks[i];
230 do_suspend = 1;
231 }
232 }
233 if (!do_suspend)
234 return -1;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300235
Alexey Budankov93f20c02018-11-06 12:07:19 +0300236 while (aio_suspend((const struct aiocb **)aiocb, md->aio.nr_cblocks, &timeout)) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300237 if (!(errno == EAGAIN || errno == EINTR))
238 pr_err("failed to sync perf data, error: %m\n");
239 }
240 } while (1);
241}
242
243static int record__aio_pushfn(void *to, struct aiocb *cblock, void *bf, size_t size, off_t off)
244{
245 struct record *rec = to;
246 int ret, trace_fd = rec->session->data->file.fd;
247
248 rec->samples++;
249
250 ret = record__aio_write(cblock, trace_fd, bf, size, off);
251 if (!ret) {
252 rec->bytes_written += size;
253 if (switch_output_size(rec))
254 trigger_hit(&switch_output_trigger);
255 }
256
257 return ret;
258}
259
260static off_t record__aio_get_pos(int trace_fd)
261{
262 return lseek(trace_fd, 0, SEEK_CUR);
263}
264
265static void record__aio_set_pos(int trace_fd, off_t pos)
266{
267 lseek(trace_fd, pos, SEEK_SET);
268}
269
270static void record__aio_mmap_read_sync(struct record *rec)
271{
272 int i;
273 struct perf_evlist *evlist = rec->evlist;
274 struct perf_mmap *maps = evlist->mmap;
275
276 if (!rec->opts.nr_cblocks)
277 return;
278
279 for (i = 0; i < evlist->nr_mmaps; i++) {
280 struct perf_mmap *map = &maps[i];
281
282 if (map->base)
Alexey Budankov93f20c02018-11-06 12:07:19 +0300283 record__aio_sync(map, true);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300284 }
285}
286
287static int nr_cblocks_default = 1;
Alexey Budankov93f20c02018-11-06 12:07:19 +0300288static int nr_cblocks_max = 4;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300289
290static int record__aio_parse(const struct option *opt,
Alexey Budankov93f20c02018-11-06 12:07:19 +0300291 const char *str,
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300292 int unset)
293{
294 struct record_opts *opts = (struct record_opts *)opt->value;
295
Alexey Budankov93f20c02018-11-06 12:07:19 +0300296 if (unset) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300297 opts->nr_cblocks = 0;
Alexey Budankov93f20c02018-11-06 12:07:19 +0300298 } else {
299 if (str)
300 opts->nr_cblocks = strtol(str, NULL, 0);
301 if (!opts->nr_cblocks)
302 opts->nr_cblocks = nr_cblocks_default;
303 }
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300304
305 return 0;
306}
307#else /* HAVE_AIO_SUPPORT */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300308static int nr_cblocks_max = 0;
309
310static int record__aio_sync(struct perf_mmap *md __maybe_unused, bool sync_all __maybe_unused)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300311{
Alexey Budankov93f20c02018-11-06 12:07:19 +0300312 return -1;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300313}
314
315static int record__aio_pushfn(void *to __maybe_unused, struct aiocb *cblock __maybe_unused,
316 void *bf __maybe_unused, size_t size __maybe_unused, off_t off __maybe_unused)
317{
318 return -1;
319}
320
321static off_t record__aio_get_pos(int trace_fd __maybe_unused)
322{
323 return -1;
324}
325
326static void record__aio_set_pos(int trace_fd __maybe_unused, off_t pos __maybe_unused)
327{
328}
329
330static void record__aio_mmap_read_sync(struct record *rec __maybe_unused)
331{
332}
333#endif
334
335static int record__aio_enabled(struct record *rec)
336{
337 return rec->opts.nr_cblocks > 0;
338}
339
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200340static int process_synthesized_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200341 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300342 struct perf_sample *sample __maybe_unused,
343 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200344{
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300345 struct record *rec = container_of(tool, struct record, tool);
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200346 return record__write(rec, NULL, event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200347}
348
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200349static int record__pushfn(struct perf_mmap *map, void *to, void *bf, size_t size)
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300350{
351 struct record *rec = to;
352
353 rec->samples++;
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200354 return record__write(rec, map, bf, size);
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300355}
356
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300357static volatile int done;
358static volatile int signr = -1;
359static volatile int child_finished;
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000360
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300361static void sig_handler(int sig)
362{
363 if (sig == SIGCHLD)
364 child_finished = 1;
365 else
366 signr = sig;
367
368 done = 1;
369}
370
Wang Nana0748652016-11-26 07:03:28 +0000371static void sigsegv_handler(int sig)
372{
373 perf_hooks__recover();
374 sighandler_dump_stack(sig);
375}
376
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300377static void record__sig_exit(void)
378{
379 if (signr == -1)
380 return;
381
382 signal(signr, SIG_DFL);
383 raise(signr);
384}
385
Adrian Huntere31f0d02015-04-30 17:37:27 +0300386#ifdef HAVE_AUXTRACE_SUPPORT
387
Adrian Hunteref149c22015-04-09 18:53:45 +0300388static int record__process_auxtrace(struct perf_tool *tool,
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200389 struct perf_mmap *map,
Adrian Hunteref149c22015-04-09 18:53:45 +0300390 union perf_event *event, void *data1,
391 size_t len1, void *data2, size_t len2)
392{
393 struct record *rec = container_of(tool, struct record, tool);
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100394 struct perf_data *data = &rec->data;
Adrian Hunteref149c22015-04-09 18:53:45 +0300395 size_t padding;
396 u8 pad[8] = {0};
397
Jiri Olsacd3dd8d2019-03-08 14:47:36 +0100398 if (!perf_data__is_pipe(data) && !perf_data__is_dir(data)) {
Adrian Hunter99fa2982015-04-30 17:37:25 +0300399 off_t file_offset;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100400 int fd = perf_data__fd(data);
Adrian Hunter99fa2982015-04-30 17:37:25 +0300401 int err;
402
403 file_offset = lseek(fd, 0, SEEK_CUR);
404 if (file_offset == -1)
405 return -1;
406 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
407 event, file_offset);
408 if (err)
409 return err;
410 }
411
Adrian Hunteref149c22015-04-09 18:53:45 +0300412 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
413 padding = (len1 + len2) & 7;
414 if (padding)
415 padding = 8 - padding;
416
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200417 record__write(rec, map, event, event->header.size);
418 record__write(rec, map, data1, len1);
Adrian Hunteref149c22015-04-09 18:53:45 +0300419 if (len2)
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200420 record__write(rec, map, data2, len2);
421 record__write(rec, map, &pad, padding);
Adrian Hunteref149c22015-04-09 18:53:45 +0300422
423 return 0;
424}
425
426static int record__auxtrace_mmap_read(struct record *rec,
Jiri Olsae035f4c2018-09-13 14:54:05 +0200427 struct perf_mmap *map)
Adrian Hunteref149c22015-04-09 18:53:45 +0300428{
429 int ret;
430
Jiri Olsae035f4c2018-09-13 14:54:05 +0200431 ret = auxtrace_mmap__read(map, rec->itr, &rec->tool,
Adrian Hunteref149c22015-04-09 18:53:45 +0300432 record__process_auxtrace);
433 if (ret < 0)
434 return ret;
435
436 if (ret)
437 rec->samples++;
438
439 return 0;
440}
441
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300442static int record__auxtrace_mmap_read_snapshot(struct record *rec,
Jiri Olsae035f4c2018-09-13 14:54:05 +0200443 struct perf_mmap *map)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300444{
445 int ret;
446
Jiri Olsae035f4c2018-09-13 14:54:05 +0200447 ret = auxtrace_mmap__read_snapshot(map, rec->itr, &rec->tool,
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300448 record__process_auxtrace,
449 rec->opts.auxtrace_snapshot_size);
450 if (ret < 0)
451 return ret;
452
453 if (ret)
454 rec->samples++;
455
456 return 0;
457}
458
459static int record__auxtrace_read_snapshot_all(struct record *rec)
460{
461 int i;
462 int rc = 0;
463
464 for (i = 0; i < rec->evlist->nr_mmaps; i++) {
Jiri Olsae035f4c2018-09-13 14:54:05 +0200465 struct perf_mmap *map = &rec->evlist->mmap[i];
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300466
Jiri Olsae035f4c2018-09-13 14:54:05 +0200467 if (!map->auxtrace_mmap.base)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300468 continue;
469
Jiri Olsae035f4c2018-09-13 14:54:05 +0200470 if (record__auxtrace_mmap_read_snapshot(rec, map) != 0) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300471 rc = -1;
472 goto out;
473 }
474 }
475out:
476 return rc;
477}
478
479static void record__read_auxtrace_snapshot(struct record *rec)
480{
481 pr_debug("Recording AUX area tracing snapshot\n");
482 if (record__auxtrace_read_snapshot_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +0000483 trigger_error(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300484 } else {
Wang Nan5f9cf592016-04-20 18:59:49 +0000485 if (auxtrace_record__snapshot_finish(rec->itr))
486 trigger_error(&auxtrace_snapshot_trigger);
487 else
488 trigger_ready(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300489 }
490}
491
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200492static int record__auxtrace_init(struct record *rec)
493{
494 int err;
495
496 if (!rec->itr) {
497 rec->itr = auxtrace_record__init(rec->evlist, &err);
498 if (err)
499 return err;
500 }
501
502 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
503 rec->opts.auxtrace_snapshot_opts);
504 if (err)
505 return err;
506
507 return auxtrace_parse_filters(rec->evlist);
508}
509
Adrian Huntere31f0d02015-04-30 17:37:27 +0300510#else
511
512static inline
513int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
Jiri Olsae035f4c2018-09-13 14:54:05 +0200514 struct perf_mmap *map __maybe_unused)
Adrian Huntere31f0d02015-04-30 17:37:27 +0300515{
516 return 0;
517}
518
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300519static inline
520void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
521{
522}
523
524static inline
525int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
526{
527 return 0;
528}
529
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200530static int record__auxtrace_init(struct record *rec __maybe_unused)
531{
532 return 0;
533}
534
Adrian Huntere31f0d02015-04-30 17:37:27 +0300535#endif
536
Wang Nancda57a82016-06-27 10:24:03 +0000537static int record__mmap_evlist(struct record *rec,
538 struct perf_evlist *evlist)
539{
540 struct record_opts *opts = &rec->opts;
541 char msg[512];
542
Alexey Budankovf13de662019-01-22 20:50:57 +0300543 if (opts->affinity != PERF_AFFINITY_SYS)
544 cpu__setup_cpunode_map();
545
Wang Nan7a276ff2017-12-03 02:00:38 +0000546 if (perf_evlist__mmap_ex(evlist, opts->mmap_pages,
Wang Nancda57a82016-06-27 10:24:03 +0000547 opts->auxtrace_mmap_pages,
Alexey Budankov9d2ed642019-01-22 20:47:43 +0300548 opts->auxtrace_snapshot_mode,
549 opts->nr_cblocks, opts->affinity) < 0) {
Wang Nancda57a82016-06-27 10:24:03 +0000550 if (errno == EPERM) {
551 pr_err("Permission error mapping pages.\n"
552 "Consider increasing "
553 "/proc/sys/kernel/perf_event_mlock_kb,\n"
554 "or try again with a smaller value of -m/--mmap_pages.\n"
555 "(current value: %u,%u)\n",
556 opts->mmap_pages, opts->auxtrace_mmap_pages);
557 return -errno;
558 } else {
559 pr_err("failed to mmap with %d (%s)\n", errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300560 str_error_r(errno, msg, sizeof(msg)));
Wang Nancda57a82016-06-27 10:24:03 +0000561 if (errno)
562 return -errno;
563 else
564 return -EINVAL;
565 }
566 }
567 return 0;
568}
569
570static int record__mmap(struct record *rec)
571{
572 return record__mmap_evlist(rec, rec->evlist);
573}
574
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300575static int record__open(struct record *rec)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200576{
Arnaldo Carvalho de Melod6195a62017-02-13 16:45:24 -0300577 char msg[BUFSIZ];
Jiri Olsa6a4bb042012-08-08 12:22:36 +0200578 struct perf_evsel *pos;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200579 struct perf_evlist *evlist = rec->evlist;
580 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300581 struct record_opts *opts = &rec->opts;
David Ahern8d3eca22012-08-26 12:24:47 -0600582 int rc = 0;
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200583
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300584 /*
585 * For initial_delay we need to add a dummy event so that we can track
586 * PERF_RECORD_MMAP while we wait for the initial delay to enable the
587 * real events, the ones asked by the user.
588 */
589 if (opts->initial_delay) {
590 if (perf_evlist__add_dummy(evlist))
591 return -ENOMEM;
592
593 pos = perf_evlist__first(evlist);
594 pos->tracking = 0;
595 pos = perf_evlist__last(evlist);
596 pos->tracking = 1;
597 pos->attr.enable_on_exec = 1;
598 }
599
Arnaldo Carvalho de Meloe68ae9c2016-04-11 18:15:29 -0300600 perf_evlist__config(evlist, opts, &callchain_param);
Jiri Olsacac21422012-11-12 18:34:00 +0100601
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300602 evlist__for_each_entry(evlist, pos) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200603try_again:
Kan Liangd988d5e2015-08-21 02:23:14 -0400604 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300605 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
Namhyung Kimbb963e12017-02-17 17:17:38 +0900606 if (verbose > 0)
Arnaldo Carvalho de Meloc0a54342012-12-13 14:16:30 -0300607 ui__warning("%s\n", msg);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300608 goto try_again;
609 }
Andi Kleencf99ad12018-10-01 12:59:27 -0700610 if ((errno == EINVAL || errno == EBADF) &&
611 pos->leader != pos &&
612 pos->weak_group) {
613 pos = perf_evlist__reset_weak_group(evlist, pos);
614 goto try_again;
615 }
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300616 rc = -errno;
617 perf_evsel__open_strerror(pos, &opts->target,
618 errno, msg, sizeof(msg));
619 ui__error("%s\n", msg);
David Ahern8d3eca22012-08-26 12:24:47 -0600620 goto out;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300621 }
Andi Kleenbfd8f722017-11-17 13:42:58 -0800622
623 pos->supported = true;
Li Zefanc171b552009-10-15 11:22:07 +0800624 }
Arnaldo Carvalho de Meloa43d3f02010-12-25 12:12:25 -0200625
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300626 if (perf_evlist__apply_filters(evlist, &pos)) {
Arnaldo Carvalho de Melo62d94b02017-06-27 11:22:31 -0300627 pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300628 pos->filter, perf_evsel__name(pos), errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300629 str_error_r(errno, msg, sizeof(msg)));
David Ahern8d3eca22012-08-26 12:24:47 -0600630 rc = -1;
631 goto out;
Frederic Weisbecker0a102472011-02-26 04:51:54 +0100632 }
633
Wang Nancda57a82016-06-27 10:24:03 +0000634 rc = record__mmap(rec);
635 if (rc)
David Ahern8d3eca22012-08-26 12:24:47 -0600636 goto out;
Arnaldo Carvalho de Melo0a27d7f2011-01-14 15:50:51 -0200637
Jiri Olsa563aecb2013-06-05 13:35:06 +0200638 session->evlist = evlist;
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300639 perf_session__set_id_hdr_size(session);
David Ahern8d3eca22012-08-26 12:24:47 -0600640out:
641 return rc;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200642}
643
Namhyung Kime3d59112015-01-29 17:06:44 +0900644static int process_sample_event(struct perf_tool *tool,
645 union perf_event *event,
646 struct perf_sample *sample,
647 struct perf_evsel *evsel,
648 struct machine *machine)
649{
650 struct record *rec = container_of(tool, struct record, tool);
651
Jin Yao68588ba2017-12-08 21:13:42 +0800652 if (rec->evlist->first_sample_time == 0)
653 rec->evlist->first_sample_time = sample->time;
Namhyung Kime3d59112015-01-29 17:06:44 +0900654
Jin Yao68588ba2017-12-08 21:13:42 +0800655 rec->evlist->last_sample_time = sample->time;
656
657 if (rec->buildid_all)
658 return 0;
659
660 rec->samples++;
Namhyung Kime3d59112015-01-29 17:06:44 +0900661 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
662}
663
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300664static int process_buildids(struct record *rec)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200665{
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200666 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200667
Jiri Olsa45112e82019-02-21 10:41:29 +0100668 if (perf_data__size(&rec->data) == 0)
Arnaldo Carvalho de Melo9f591fd2010-03-11 15:53:11 -0300669 return 0;
670
Namhyung Kim00dc8652014-11-04 10:14:32 +0900671 /*
672 * During this process, it'll load kernel map and replace the
673 * dso->long_name to a real pathname it found. In this case
674 * we prefer the vmlinux path like
675 * /lib/modules/3.16.4/build/vmlinux
676 *
677 * rather than build-id path (in debug directory).
678 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
679 */
680 symbol_conf.ignore_vmlinux_buildid = true;
681
Namhyung Kim61566812016-01-11 22:37:09 +0900682 /*
683 * If --buildid-all is given, it marks all DSO regardless of hits,
Jin Yao68588ba2017-12-08 21:13:42 +0800684 * so no need to process samples. But if timestamp_boundary is enabled,
685 * it still needs to walk on all samples to get the timestamps of
686 * first/last samples.
Namhyung Kim61566812016-01-11 22:37:09 +0900687 */
Jin Yao68588ba2017-12-08 21:13:42 +0800688 if (rec->buildid_all && !rec->timestamp_boundary)
Namhyung Kim61566812016-01-11 22:37:09 +0900689 rec->tool.sample = NULL;
690
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300691 return perf_session__process_events(session);
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200692}
693
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200694static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800695{
696 int err;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200697 struct perf_tool *tool = data;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800698 /*
699 *As for guest kernel when processing subcommand record&report,
700 *we arrange module mmap prior to guest kernel mmap and trigger
701 *a preload dso because default guest module symbols are loaded
702 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
703 *method is used to avoid symbol missing when the first addr is
704 *in module instead of in guest kernel.
705 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200706 err = perf_event__synthesize_modules(tool, process_synthesized_event,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200707 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800708 if (err < 0)
709 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300710 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800711
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800712 /*
713 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
714 * have no _text sometimes.
715 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200716 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
Adrian Hunter0ae617b2014-01-29 16:14:40 +0200717 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800718 if (err < 0)
719 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300720 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800721}
722
Frederic Weisbecker98402802010-05-02 22:05:29 +0200723static struct perf_event_header finished_round_event = {
724 .size = sizeof(struct perf_event_header),
725 .type = PERF_RECORD_FINISHED_ROUND,
726};
727
Alexey Budankovf13de662019-01-22 20:50:57 +0300728static void record__adjust_affinity(struct record *rec, struct perf_mmap *map)
729{
730 if (rec->opts.affinity != PERF_AFFINITY_SYS &&
731 !CPU_EQUAL(&rec->affinity_mask, &map->affinity_mask)) {
732 CPU_ZERO(&rec->affinity_mask);
733 CPU_OR(&rec->affinity_mask, &rec->affinity_mask, &map->affinity_mask);
734 sched_setaffinity(0, sizeof(rec->affinity_mask), &rec->affinity_mask);
735 }
736}
737
Wang Nana4ea0ec2016-07-14 08:34:36 +0000738static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist,
Wang Nan0b72d692017-12-04 16:51:07 +0000739 bool overwrite)
Frederic Weisbecker98402802010-05-02 22:05:29 +0200740{
Jiri Olsadcabb502014-07-25 16:56:16 +0200741 u64 bytes_written = rec->bytes_written;
Peter Zijlstra0e2e63d2010-05-20 14:45:26 +0200742 int i;
David Ahern8d3eca22012-08-26 12:24:47 -0600743 int rc = 0;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000744 struct perf_mmap *maps;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300745 int trace_fd = rec->data.file.fd;
746 off_t off;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200747
Wang Nancb216862016-06-27 10:24:04 +0000748 if (!evlist)
749 return 0;
Adrian Hunteref149c22015-04-09 18:53:45 +0300750
Wang Nan0b72d692017-12-04 16:51:07 +0000751 maps = overwrite ? evlist->overwrite_mmap : evlist->mmap;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000752 if (!maps)
753 return 0;
Wang Nancb216862016-06-27 10:24:04 +0000754
Wang Nan0b72d692017-12-04 16:51:07 +0000755 if (overwrite && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
Wang Nan54cc54d2016-07-14 08:34:42 +0000756 return 0;
757
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300758 if (record__aio_enabled(rec))
759 off = record__aio_get_pos(trace_fd);
760
Wang Nana4ea0ec2016-07-14 08:34:36 +0000761 for (i = 0; i < evlist->nr_mmaps; i++) {
Jiri Olsae035f4c2018-09-13 14:54:05 +0200762 struct perf_mmap *map = &maps[i];
Wang Nana4ea0ec2016-07-14 08:34:36 +0000763
Jiri Olsae035f4c2018-09-13 14:54:05 +0200764 if (map->base) {
Alexey Budankovf13de662019-01-22 20:50:57 +0300765 record__adjust_affinity(rec, map);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300766 if (!record__aio_enabled(rec)) {
767 if (perf_mmap__push(map, rec, record__pushfn) != 0) {
768 rc = -1;
769 goto out;
770 }
771 } else {
Alexey Budankov93f20c02018-11-06 12:07:19 +0300772 int idx;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300773 /*
774 * Call record__aio_sync() to wait till map->data buffer
775 * becomes available after previous aio write request.
776 */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300777 idx = record__aio_sync(map, false);
778 if (perf_mmap__aio_push(map, rec, idx, record__aio_pushfn, &off) != 0) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300779 record__aio_set_pos(trace_fd, off);
780 rc = -1;
781 goto out;
782 }
David Ahern8d3eca22012-08-26 12:24:47 -0600783 }
784 }
Adrian Hunteref149c22015-04-09 18:53:45 +0300785
Jiri Olsae035f4c2018-09-13 14:54:05 +0200786 if (map->auxtrace_mmap.base && !rec->opts.auxtrace_snapshot_mode &&
787 record__auxtrace_mmap_read(rec, map) != 0) {
Adrian Hunteref149c22015-04-09 18:53:45 +0300788 rc = -1;
789 goto out;
790 }
Frederic Weisbecker98402802010-05-02 22:05:29 +0200791 }
792
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300793 if (record__aio_enabled(rec))
794 record__aio_set_pos(trace_fd, off);
795
Jiri Olsadcabb502014-07-25 16:56:16 +0200796 /*
797 * Mark the round finished in case we wrote
798 * at least one event.
799 */
800 if (bytes_written != rec->bytes_written)
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200801 rc = record__write(rec, NULL, &finished_round_event, sizeof(finished_round_event));
David Ahern8d3eca22012-08-26 12:24:47 -0600802
Wang Nan0b72d692017-12-04 16:51:07 +0000803 if (overwrite)
Wang Nan54cc54d2016-07-14 08:34:42 +0000804 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
David Ahern8d3eca22012-08-26 12:24:47 -0600805out:
806 return rc;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200807}
808
Wang Nancb216862016-06-27 10:24:04 +0000809static int record__mmap_read_all(struct record *rec)
810{
811 int err;
812
Wang Nana4ea0ec2016-07-14 08:34:36 +0000813 err = record__mmap_read_evlist(rec, rec->evlist, false);
Wang Nancb216862016-06-27 10:24:04 +0000814 if (err)
815 return err;
816
Wang Nan057374642016-07-14 08:34:43 +0000817 return record__mmap_read_evlist(rec, rec->evlist, true);
Wang Nancb216862016-06-27 10:24:04 +0000818}
819
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300820static void record__init_features(struct record *rec)
David Ahern57706ab2013-11-06 11:41:34 -0700821{
David Ahern57706ab2013-11-06 11:41:34 -0700822 struct perf_session *session = rec->session;
823 int feat;
824
825 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
826 perf_header__set_feat(&session->header, feat);
827
828 if (rec->no_buildid)
829 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
830
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -0300831 if (!have_tracepoints(&rec->evlist->entries))
David Ahern57706ab2013-11-06 11:41:34 -0700832 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
833
834 if (!rec->opts.branch_stack)
835 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
Adrian Hunteref149c22015-04-09 18:53:45 +0300836
837 if (!rec->opts.full_auxtrace)
838 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
Jiri Olsaffa517a2015-10-25 15:51:43 +0100839
Alexey Budankovcf790512018-10-09 17:36:24 +0300840 if (!(rec->opts.use_clockid && rec->opts.clockid_res_ns))
841 perf_header__clear_feat(&session->header, HEADER_CLOCKID);
842
Jiri Olsa258031c2019-03-08 14:47:39 +0100843 perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT);
844
Jiri Olsaffa517a2015-10-25 15:51:43 +0100845 perf_header__clear_feat(&session->header, HEADER_STAT);
David Ahern57706ab2013-11-06 11:41:34 -0700846}
847
Wang Nane1ab48b2016-02-26 09:32:10 +0000848static void
849record__finish_output(struct record *rec)
850{
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100851 struct perf_data *data = &rec->data;
852 int fd = perf_data__fd(data);
Wang Nane1ab48b2016-02-26 09:32:10 +0000853
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100854 if (data->is_pipe)
Wang Nane1ab48b2016-02-26 09:32:10 +0000855 return;
856
857 rec->session->header.data_size += rec->bytes_written;
Jiri Olsa45112e82019-02-21 10:41:29 +0100858 data->file.size = lseek(perf_data__fd(data), 0, SEEK_CUR);
Wang Nane1ab48b2016-02-26 09:32:10 +0000859
860 if (!rec->no_buildid) {
861 process_buildids(rec);
862
863 if (rec->buildid_all)
864 dsos__hit_all(rec->session);
865 }
866 perf_session__write_header(rec->session, rec->evlist, fd, true);
867
868 return;
869}
870
Wang Nan4ea648a2016-07-14 08:34:47 +0000871static int record__synthesize_workload(struct record *rec, bool tail)
Wang Nanbe7b0c92016-04-20 18:59:54 +0000872{
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -0300873 int err;
874 struct thread_map *thread_map;
Wang Nanbe7b0c92016-04-20 18:59:54 +0000875
Wang Nan4ea648a2016-07-14 08:34:47 +0000876 if (rec->opts.tail_synthesize != tail)
877 return 0;
878
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -0300879 thread_map = thread_map__new_by_tid(rec->evlist->workload.pid);
880 if (thread_map == NULL)
881 return -1;
882
883 err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
Wang Nanbe7b0c92016-04-20 18:59:54 +0000884 process_synthesized_event,
885 &rec->session->machines.host,
Mark Drayton3fcb10e2018-12-04 12:34:20 -0800886 rec->opts.sample_address);
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -0300887 thread_map__put(thread_map);
888 return err;
Wang Nanbe7b0c92016-04-20 18:59:54 +0000889}
890
Wang Nan4ea648a2016-07-14 08:34:47 +0000891static int record__synthesize(struct record *rec, bool tail);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000892
Wang Nanecfd7a92016-04-13 08:21:07 +0000893static int
894record__switch_output(struct record *rec, bool at_exit)
895{
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100896 struct perf_data *data = &rec->data;
Wang Nanecfd7a92016-04-13 08:21:07 +0000897 int fd, err;
Andi Kleen03724b22019-03-14 15:49:55 -0700898 char *new_filename;
Wang Nanecfd7a92016-04-13 08:21:07 +0000899
900 /* Same Size: "2015122520103046"*/
901 char timestamp[] = "InvalidTimestamp";
902
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300903 record__aio_mmap_read_sync(rec);
904
Wang Nan4ea648a2016-07-14 08:34:47 +0000905 record__synthesize(rec, true);
906 if (target__none(&rec->opts.target))
907 record__synthesize_workload(rec, true);
908
Wang Nanecfd7a92016-04-13 08:21:07 +0000909 rec->samples = 0;
910 record__finish_output(rec);
911 err = fetch_current_timestamp(timestamp, sizeof(timestamp));
912 if (err) {
913 pr_err("Failed to get current timestamp\n");
914 return -EINVAL;
915 }
916
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100917 fd = perf_data__switch(data, timestamp,
Wang Nanecfd7a92016-04-13 08:21:07 +0000918 rec->session->header.data_offset,
Andi Kleen03724b22019-03-14 15:49:55 -0700919 at_exit, &new_filename);
Wang Nanecfd7a92016-04-13 08:21:07 +0000920 if (fd >= 0 && !at_exit) {
921 rec->bytes_written = 0;
922 rec->session->header.data_size = 0;
923 }
924
925 if (!quiet)
926 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
Jiri Olsa2d4f2792019-02-21 10:41:30 +0100927 data->path, timestamp);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000928
Andi Kleen03724b22019-03-14 15:49:55 -0700929 if (rec->switch_output.num_files) {
930 int n = rec->switch_output.cur_file + 1;
931
932 if (n >= rec->switch_output.num_files)
933 n = 0;
934 rec->switch_output.cur_file = n;
935 if (rec->switch_output.filenames[n]) {
936 remove(rec->switch_output.filenames[n]);
937 free(rec->switch_output.filenames[n]);
938 }
939 rec->switch_output.filenames[n] = new_filename;
940 } else {
941 free(new_filename);
942 }
943
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000944 /* Output tracking events */
Wang Nanbe7b0c92016-04-20 18:59:54 +0000945 if (!at_exit) {
Wang Nan4ea648a2016-07-14 08:34:47 +0000946 record__synthesize(rec, false);
Wang Nan3c1cb7e2016-04-20 18:59:50 +0000947
Wang Nanbe7b0c92016-04-20 18:59:54 +0000948 /*
949 * In 'perf record --switch-output' without -a,
950 * record__synthesize() in record__switch_output() won't
951 * generate tracking events because there's no thread_map
952 * in evlist. Which causes newly created perf.data doesn't
953 * contain map and comm information.
954 * Create a fake thread_map and directly call
955 * perf_event__synthesize_thread_map() for those events.
956 */
957 if (target__none(&rec->opts.target))
Wang Nan4ea648a2016-07-14 08:34:47 +0000958 record__synthesize_workload(rec, false);
Wang Nanbe7b0c92016-04-20 18:59:54 +0000959 }
Wang Nanecfd7a92016-04-13 08:21:07 +0000960 return fd;
961}
962
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300963static volatile int workload_exec_errno;
964
965/*
966 * perf_evlist__prepare_workload will send a SIGUSR1
967 * if the fork fails, since we asked by setting its
968 * want_signal to true.
969 */
Namhyung Kim45604712014-05-12 09:47:24 +0900970static void workload_exec_failed_signal(int signo __maybe_unused,
971 siginfo_t *info,
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300972 void *ucontext __maybe_unused)
973{
974 workload_exec_errno = info->si_value.sival_int;
975 done = 1;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -0300976 child_finished = 1;
977}
978
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300979static void snapshot_sig_handler(int sig);
Jiri Olsabfacbe32017-01-09 10:52:00 +0100980static void alarm_sig_handler(int sig);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300981
Adrian Hunter46bc29b2016-03-08 10:38:44 +0200982int __weak
983perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused,
984 struct perf_tool *tool __maybe_unused,
985 perf_event__handler_t process __maybe_unused,
986 struct machine *machine __maybe_unused)
987{
988 return 0;
989}
990
Wang Nanee667f92016-06-27 10:24:05 +0000991static const struct perf_event_mmap_page *
992perf_evlist__pick_pc(struct perf_evlist *evlist)
993{
Wang Nanb2cb6152016-07-14 08:34:39 +0000994 if (evlist) {
995 if (evlist->mmap && evlist->mmap[0].base)
996 return evlist->mmap[0].base;
Wang Nan0b72d692017-12-04 16:51:07 +0000997 if (evlist->overwrite_mmap && evlist->overwrite_mmap[0].base)
998 return evlist->overwrite_mmap[0].base;
Wang Nanb2cb6152016-07-14 08:34:39 +0000999 }
Wang Nanee667f92016-06-27 10:24:05 +00001000 return NULL;
1001}
1002
Wang Nanc45628b2016-05-24 02:28:59 +00001003static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
1004{
Wang Nanee667f92016-06-27 10:24:05 +00001005 const struct perf_event_mmap_page *pc;
1006
1007 pc = perf_evlist__pick_pc(rec->evlist);
1008 if (pc)
1009 return pc;
Wang Nanc45628b2016-05-24 02:28:59 +00001010 return NULL;
1011}
1012
Wang Nan4ea648a2016-07-14 08:34:47 +00001013static int record__synthesize(struct record *rec, bool tail)
Wang Nanc45c86e2016-02-26 09:32:07 +00001014{
1015 struct perf_session *session = rec->session;
1016 struct machine *machine = &session->machines.host;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001017 struct perf_data *data = &rec->data;
Wang Nanc45c86e2016-02-26 09:32:07 +00001018 struct record_opts *opts = &rec->opts;
1019 struct perf_tool *tool = &rec->tool;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001020 int fd = perf_data__fd(data);
Wang Nanc45c86e2016-02-26 09:32:07 +00001021 int err = 0;
1022
Wang Nan4ea648a2016-07-14 08:34:47 +00001023 if (rec->opts.tail_synthesize != tail)
1024 return 0;
1025
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001026 if (data->is_pipe) {
Jiri Olsaa2015512018-03-14 10:22:04 +01001027 /*
1028 * We need to synthesize events first, because some
1029 * features works on top of them (on report side).
1030 */
Jiri Olsa318ec182018-08-30 08:32:15 +02001031 err = perf_event__synthesize_attrs(tool, rec->evlist,
Wang Nanc45c86e2016-02-26 09:32:07 +00001032 process_synthesized_event);
1033 if (err < 0) {
1034 pr_err("Couldn't synthesize attrs.\n");
1035 goto out;
1036 }
1037
Jiri Olsaa2015512018-03-14 10:22:04 +01001038 err = perf_event__synthesize_features(tool, session, rec->evlist,
1039 process_synthesized_event);
1040 if (err < 0) {
1041 pr_err("Couldn't synthesize features.\n");
1042 return err;
1043 }
1044
Wang Nanc45c86e2016-02-26 09:32:07 +00001045 if (have_tracepoints(&rec->evlist->entries)) {
1046 /*
1047 * FIXME err <= 0 here actually means that
1048 * there were no tracepoints so its not really
1049 * an error, just that we don't need to
1050 * synthesize anything. We really have to
1051 * return this more properly and also
1052 * propagate errors that now are calling die()
1053 */
1054 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
1055 process_synthesized_event);
1056 if (err <= 0) {
1057 pr_err("Couldn't record tracing data.\n");
1058 goto out;
1059 }
1060 rec->bytes_written += err;
1061 }
1062 }
1063
Wang Nanc45628b2016-05-24 02:28:59 +00001064 err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
Adrian Hunter46bc29b2016-03-08 10:38:44 +02001065 process_synthesized_event, machine);
1066 if (err)
1067 goto out;
1068
Wang Nanc45c86e2016-02-26 09:32:07 +00001069 if (rec->opts.full_auxtrace) {
1070 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
1071 session, process_synthesized_event);
1072 if (err)
1073 goto out;
1074 }
1075
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03001076 if (!perf_evlist__exclude_kernel(rec->evlist)) {
1077 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
1078 machine);
1079 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
1080 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
1081 "Check /proc/kallsyms permission or run as root.\n");
Wang Nanc45c86e2016-02-26 09:32:07 +00001082
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03001083 err = perf_event__synthesize_modules(tool, process_synthesized_event,
1084 machine);
1085 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
1086 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
1087 "Check /proc/modules permission or run as root.\n");
1088 }
Wang Nanc45c86e2016-02-26 09:32:07 +00001089
1090 if (perf_guest) {
1091 machines__process_guests(&session->machines,
1092 perf_event__synthesize_guest_os, tool);
1093 }
1094
Andi Kleenbfd8f722017-11-17 13:42:58 -08001095 err = perf_event__synthesize_extra_attr(&rec->tool,
1096 rec->evlist,
1097 process_synthesized_event,
1098 data->is_pipe);
1099 if (err)
1100 goto out;
1101
Andi Kleen373565d2017-11-17 13:42:59 -08001102 err = perf_event__synthesize_thread_map2(&rec->tool, rec->evlist->threads,
1103 process_synthesized_event,
1104 NULL);
1105 if (err < 0) {
1106 pr_err("Couldn't synthesize thread map.\n");
1107 return err;
1108 }
1109
1110 err = perf_event__synthesize_cpu_map(&rec->tool, rec->evlist->cpus,
1111 process_synthesized_event, NULL);
1112 if (err < 0) {
1113 pr_err("Couldn't synthesize cpu map.\n");
1114 return err;
1115 }
1116
Song Liu7b612e22019-01-17 08:15:19 -08001117 err = perf_event__synthesize_bpf_events(tool, process_synthesized_event,
1118 machine, opts);
1119 if (err < 0)
1120 pr_warning("Couldn't synthesize bpf events.\n");
1121
Wang Nanc45c86e2016-02-26 09:32:07 +00001122 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
1123 process_synthesized_event, opts->sample_address,
Mark Drayton3fcb10e2018-12-04 12:34:20 -08001124 1);
Wang Nanc45c86e2016-02-26 09:32:07 +00001125out:
1126 return err;
1127}
1128
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001129static int __cmd_record(struct record *rec, int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +02001130{
David Ahern57706ab2013-11-06 11:41:34 -07001131 int err;
Namhyung Kim45604712014-05-12 09:47:24 +09001132 int status = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001133 unsigned long waking = 0;
Zhang, Yanmin46be6042010-03-18 11:36:04 -03001134 const bool forks = argc > 0;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001135 struct perf_tool *tool = &rec->tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001136 struct record_opts *opts = &rec->opts;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001137 struct perf_data *data = &rec->data;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001138 struct perf_session *session;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001139 bool disabled = false, draining = false;
Namhyung Kim42aa2762015-01-29 17:06:48 +09001140 int fd;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001141
Namhyung Kim45604712014-05-12 09:47:24 +09001142 atexit(record__sig_exit);
Peter Zijlstraf5970552009-06-18 23:22:55 +02001143 signal(SIGCHLD, sig_handler);
1144 signal(SIGINT, sig_handler);
David Ahern804f7ac2013-05-06 12:24:23 -06001145 signal(SIGTERM, sig_handler);
Wang Nana0748652016-11-26 07:03:28 +00001146 signal(SIGSEGV, sigsegv_handler);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001147
Hari Bathinif3b36142017-03-08 02:11:43 +05301148 if (rec->opts.record_namespaces)
1149 tool->namespace_events = true;
1150
Jiri Olsadc0c6122017-01-09 10:51:58 +01001151 if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001152 signal(SIGUSR2, snapshot_sig_handler);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001153 if (rec->opts.auxtrace_snapshot_mode)
1154 trigger_on(&auxtrace_snapshot_trigger);
Jiri Olsadc0c6122017-01-09 10:51:58 +01001155 if (rec->switch_output.enabled)
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001156 trigger_on(&switch_output_trigger);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001157 } else {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001158 signal(SIGUSR2, SIG_IGN);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001159 }
Peter Zijlstraf5970552009-06-18 23:22:55 +02001160
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001161 session = perf_session__new(data, false, tool);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02001162 if (session == NULL) {
Adrien BAKffa91882014-04-18 11:00:43 +09001163 pr_err("Perf session creation failed.\n");
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -02001164 return -1;
1165 }
1166
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001167 fd = perf_data__fd(data);
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001168 rec->session = session;
1169
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001170 record__init_features(rec);
Stephane Eranian330aa672012-03-08 23:47:46 +01001171
Alexey Budankovcf790512018-10-09 17:36:24 +03001172 if (rec->opts.use_clockid && rec->opts.clockid_res_ns)
1173 session->header.env.clockid_res_ns = rec->opts.clockid_res_ns;
1174
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -02001175 if (forks) {
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001176 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001177 argv, data->is_pipe,
Arnaldo Carvalho de Melo735f7e02014-01-03 14:56:49 -03001178 workload_exec_failed_signal);
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -02001179 if (err < 0) {
1180 pr_err("Couldn't run the workload!\n");
Namhyung Kim45604712014-05-12 09:47:24 +09001181 status = err;
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -02001182 goto out_delete_session;
Jens Axboe0a5ac842009-08-12 11:18:01 +02001183 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001184 }
1185
Jiri Olsaad46e48c2018-03-02 17:13:54 +01001186 /*
1187 * If we have just single event and are sending data
1188 * through pipe, we need to force the ids allocation,
1189 * because we synthesize event name through the pipe
1190 * and need the id for that.
1191 */
1192 if (data->is_pipe && rec->evlist->nr_entries == 1)
1193 rec->opts.sample_id = true;
1194
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001195 if (record__open(rec) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -06001196 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001197 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001198 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001199
Wang Nan8690a2a2016-02-22 09:10:32 +00001200 err = bpf__apply_obj_config();
1201 if (err) {
1202 char errbuf[BUFSIZ];
1203
1204 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
1205 pr_err("ERROR: Apply config to BPF failed: %s\n",
1206 errbuf);
1207 goto out_child;
1208 }
1209
Adrian Huntercca84822015-08-19 17:29:21 +03001210 /*
1211 * Normally perf_session__new would do this, but it doesn't have the
1212 * evlist.
1213 */
1214 if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
1215 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
1216 rec->tool.ordered_events = false;
1217 }
1218
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001219 if (!rec->evlist->nr_groups)
Namhyung Kima8bb5592013-01-22 18:09:31 +09001220 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
1221
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001222 if (data->is_pipe) {
Namhyung Kim42aa2762015-01-29 17:06:48 +09001223 err = perf_header__write_pipe(fd);
Tom Zanussi529870e2010-04-01 23:59:16 -05001224 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001225 goto out_child;
Jiri Olsa563aecb2013-06-05 13:35:06 +02001226 } else {
Namhyung Kim42aa2762015-01-29 17:06:48 +09001227 err = perf_session__write_header(session, rec->evlist, fd, false);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001228 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001229 goto out_child;
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001230 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001231
David Ahernd3665492012-02-06 15:27:52 -07001232 if (!rec->no_buildid
Robert Richtere20960c2011-12-07 10:02:55 +01001233 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
David Ahernd3665492012-02-06 15:27:52 -07001234 pr_err("Couldn't generate buildids. "
Robert Richtere20960c2011-12-07 10:02:55 +01001235 "Use --no-buildid to profile anyway.\n");
David Ahern8d3eca22012-08-26 12:24:47 -06001236 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001237 goto out_child;
Robert Richtere20960c2011-12-07 10:02:55 +01001238 }
1239
Wang Nan4ea648a2016-07-14 08:34:47 +00001240 err = record__synthesize(rec, false);
Wang Nanc45c86e2016-02-26 09:32:07 +00001241 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001242 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001243
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001244 if (rec->realtime_prio) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001245 struct sched_param param;
1246
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001247 param.sched_priority = rec->realtime_prio;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001248 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -02001249 pr_err("Could not set realtime priority.\n");
David Ahern8d3eca22012-08-26 12:24:47 -06001250 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001251 goto out_child;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001252 }
1253 }
1254
Jiri Olsa774cb492012-11-12 18:34:01 +01001255 /*
1256 * When perf is starting the traced process, all the events
1257 * (apart from group members) have enable_on_exec=1 set,
1258 * so don't spoil it by prematurely enabling them.
1259 */
Andi Kleen6619a532014-01-11 13:38:27 -08001260 if (!target__none(&opts->target) && !opts->initial_delay)
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001261 perf_evlist__enable(rec->evlist);
David Ahern764e16a32011-08-25 10:17:55 -06001262
Peter Zijlstra856e9662009-12-16 17:55:55 +01001263 /*
1264 * Let the child rip
1265 */
Namhyung Kime803cf92015-09-22 09:24:55 +09001266 if (forks) {
Jiri Olsa20a8a3c2018-03-07 16:50:04 +01001267 struct machine *machine = &session->machines.host;
Namhyung Kime5bed562015-09-30 10:45:24 +09001268 union perf_event *event;
Hari Bathinie907caf2017-03-08 02:11:51 +05301269 pid_t tgid;
Namhyung Kime5bed562015-09-30 10:45:24 +09001270
1271 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
1272 if (event == NULL) {
1273 err = -ENOMEM;
1274 goto out_child;
1275 }
1276
Namhyung Kime803cf92015-09-22 09:24:55 +09001277 /*
1278 * Some H/W events are generated before COMM event
1279 * which is emitted during exec(), so perf script
1280 * cannot see a correct process name for those events.
1281 * Synthesize COMM event to prevent it.
1282 */
Hari Bathinie907caf2017-03-08 02:11:51 +05301283 tgid = perf_event__synthesize_comm(tool, event,
1284 rec->evlist->workload.pid,
1285 process_synthesized_event,
1286 machine);
1287 free(event);
1288
1289 if (tgid == -1)
1290 goto out_child;
1291
1292 event = malloc(sizeof(event->namespaces) +
1293 (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
1294 machine->id_hdr_size);
1295 if (event == NULL) {
1296 err = -ENOMEM;
1297 goto out_child;
1298 }
1299
1300 /*
1301 * Synthesize NAMESPACES event for the command specified.
1302 */
1303 perf_event__synthesize_namespaces(tool, event,
1304 rec->evlist->workload.pid,
1305 tgid, process_synthesized_event,
1306 machine);
Namhyung Kime5bed562015-09-30 10:45:24 +09001307 free(event);
Namhyung Kime803cf92015-09-22 09:24:55 +09001308
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001309 perf_evlist__start_workload(rec->evlist);
Namhyung Kime803cf92015-09-22 09:24:55 +09001310 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001311
Andi Kleen6619a532014-01-11 13:38:27 -08001312 if (opts->initial_delay) {
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -03001313 usleep(opts->initial_delay * USEC_PER_MSEC);
Andi Kleen6619a532014-01-11 13:38:27 -08001314 perf_evlist__enable(rec->evlist);
1315 }
1316
Wang Nan5f9cf592016-04-20 18:59:49 +00001317 trigger_ready(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001318 trigger_ready(&switch_output_trigger);
Wang Nana0748652016-11-26 07:03:28 +00001319 perf_hooks__invoke_record_start();
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001320 for (;;) {
Yang Shi9f065192015-09-29 14:49:43 -07001321 unsigned long long hits = rec->samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001322
Wang Nan057374642016-07-14 08:34:43 +00001323 /*
1324 * rec->evlist->bkw_mmap_state is possible to be
1325 * BKW_MMAP_EMPTY here: when done == true and
1326 * hits != rec->samples in previous round.
1327 *
1328 * perf_evlist__toggle_bkw_mmap ensure we never
1329 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
1330 */
1331 if (trigger_is_hit(&switch_output_trigger) || done || draining)
1332 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
1333
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001334 if (record__mmap_read_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001335 trigger_error(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001336 trigger_error(&switch_output_trigger);
David Ahern8d3eca22012-08-26 12:24:47 -06001337 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001338 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001339 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001340
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001341 if (auxtrace_record__snapshot_started) {
1342 auxtrace_record__snapshot_started = 0;
Wang Nan5f9cf592016-04-20 18:59:49 +00001343 if (!trigger_is_error(&auxtrace_snapshot_trigger))
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001344 record__read_auxtrace_snapshot(rec);
Wang Nan5f9cf592016-04-20 18:59:49 +00001345 if (trigger_is_error(&auxtrace_snapshot_trigger)) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001346 pr_err("AUX area tracing snapshot failed\n");
1347 err = -1;
1348 goto out_child;
1349 }
1350 }
1351
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001352 if (trigger_is_hit(&switch_output_trigger)) {
Wang Nan057374642016-07-14 08:34:43 +00001353 /*
1354 * If switch_output_trigger is hit, the data in
1355 * overwritable ring buffer should have been collected,
1356 * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
1357 *
1358 * If SIGUSR2 raise after or during record__mmap_read_all(),
1359 * record__mmap_read_all() didn't collect data from
1360 * overwritable ring buffer. Read again.
1361 */
1362 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
1363 continue;
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001364 trigger_ready(&switch_output_trigger);
1365
Wang Nan057374642016-07-14 08:34:43 +00001366 /*
1367 * Reenable events in overwrite ring buffer after
1368 * record__mmap_read_all(): we should have collected
1369 * data from it.
1370 */
1371 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1372
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001373 if (!quiet)
1374 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1375 waking);
1376 waking = 0;
1377 fd = record__switch_output(rec, false);
1378 if (fd < 0) {
1379 pr_err("Failed to switch to new file\n");
1380 trigger_error(&switch_output_trigger);
1381 err = fd;
1382 goto out_child;
1383 }
Jiri Olsabfacbe32017-01-09 10:52:00 +01001384
1385 /* re-arm the alarm */
1386 if (rec->switch_output.time)
1387 alarm(rec->switch_output.time);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001388 }
1389
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001390 if (hits == rec->samples) {
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001391 if (done || draining)
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001392 break;
Arnaldo Carvalho de Melof66a8892014-08-18 17:25:59 -03001393 err = perf_evlist__poll(rec->evlist, -1);
Jiri Olsaa5151142014-06-02 13:44:23 -04001394 /*
1395 * Propagate error, only if there's any. Ignore positive
1396 * number of returned events and interrupt error.
1397 */
1398 if (err > 0 || (err < 0 && errno == EINTR))
Namhyung Kim45604712014-05-12 09:47:24 +09001399 err = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001400 waking++;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001401
1402 if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
1403 draining = true;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001404 }
1405
Jiri Olsa774cb492012-11-12 18:34:01 +01001406 /*
1407 * When perf is starting the traced process, at the end events
1408 * die with the process and we wait for that. Thus no need to
1409 * disable events in this case.
1410 */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001411 if (done && !disabled && !target__none(&opts->target)) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001412 trigger_off(&auxtrace_snapshot_trigger);
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001413 perf_evlist__disable(rec->evlist);
Jiri Olsa27119262012-11-12 18:34:02 +01001414 disabled = true;
1415 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001416 }
Wang Nan5f9cf592016-04-20 18:59:49 +00001417 trigger_off(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001418 trigger_off(&switch_output_trigger);
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001419
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001420 if (forks && workload_exec_errno) {
Masami Hiramatsu35550da2014-08-14 02:22:43 +00001421 char msg[STRERR_BUFSIZE];
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -03001422 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001423 pr_err("Workload failed: %s\n", emsg);
1424 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001425 goto out_child;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001426 }
1427
Namhyung Kime3d59112015-01-29 17:06:44 +09001428 if (!quiet)
Namhyung Kim45604712014-05-12 09:47:24 +09001429 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001430
Wang Nan4ea648a2016-07-14 08:34:47 +00001431 if (target__none(&rec->opts.target))
1432 record__synthesize_workload(rec, true);
1433
Namhyung Kim45604712014-05-12 09:47:24 +09001434out_child:
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001435 record__aio_mmap_read_sync(rec);
1436
Namhyung Kim45604712014-05-12 09:47:24 +09001437 if (forks) {
1438 int exit_status;
Ingo Molnaraddc2782009-06-02 23:43:11 +02001439
Namhyung Kim45604712014-05-12 09:47:24 +09001440 if (!child_finished)
1441 kill(rec->evlist->workload.pid, SIGTERM);
1442
1443 wait(&exit_status);
1444
1445 if (err < 0)
1446 status = err;
1447 else if (WIFEXITED(exit_status))
1448 status = WEXITSTATUS(exit_status);
1449 else if (WIFSIGNALED(exit_status))
1450 signr = WTERMSIG(exit_status);
1451 } else
1452 status = err;
1453
Wang Nan4ea648a2016-07-14 08:34:47 +00001454 record__synthesize(rec, true);
Namhyung Kime3d59112015-01-29 17:06:44 +09001455 /* this will be recalculated during process_buildids() */
1456 rec->samples = 0;
1457
Wang Nanecfd7a92016-04-13 08:21:07 +00001458 if (!err) {
1459 if (!rec->timestamp_filename) {
1460 record__finish_output(rec);
1461 } else {
1462 fd = record__switch_output(rec, true);
1463 if (fd < 0) {
1464 status = fd;
1465 goto out_delete_session;
1466 }
1467 }
1468 }
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001469
Wang Nana0748652016-11-26 07:03:28 +00001470 perf_hooks__invoke_record_end();
1471
Namhyung Kime3d59112015-01-29 17:06:44 +09001472 if (!err && !quiet) {
1473 char samples[128];
Wang Nanecfd7a92016-04-13 08:21:07 +00001474 const char *postfix = rec->timestamp_filename ?
1475 ".<timestamp>" : "";
Namhyung Kime3d59112015-01-29 17:06:44 +09001476
Adrian Hunteref149c22015-04-09 18:53:45 +03001477 if (rec->samples && !rec->opts.full_auxtrace)
Namhyung Kime3d59112015-01-29 17:06:44 +09001478 scnprintf(samples, sizeof(samples),
1479 " (%" PRIu64 " samples)", rec->samples);
1480 else
1481 samples[0] = '\0';
1482
Wang Nanecfd7a92016-04-13 08:21:07 +00001483 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s ]\n",
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001484 perf_data__size(data) / 1024.0 / 1024.0,
Jiri Olsa2d4f2792019-02-21 10:41:30 +01001485 data->path, postfix, samples);
Namhyung Kime3d59112015-01-29 17:06:44 +09001486 }
1487
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001488out_delete_session:
1489 perf_session__delete(session);
Namhyung Kim45604712014-05-12 09:47:24 +09001490 return status;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001491}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001492
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001493static void callchain_debug(struct callchain_param *callchain)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001494{
Kan Liangaad2b212015-01-05 13:23:04 -05001495 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
Jiri Olsaa601fdf2014-02-03 12:44:43 +01001496
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001497 pr_debug("callchain: type %s\n", str[callchain->record_mode]);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001498
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001499 if (callchain->record_mode == CALLCHAIN_DWARF)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001500 pr_debug("callchain: stack dump size %d\n",
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001501 callchain->dump_size);
1502}
1503
1504int record_opts__parse_callchain(struct record_opts *record,
1505 struct callchain_param *callchain,
1506 const char *arg, bool unset)
1507{
1508 int ret;
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001509 callchain->enabled = !unset;
1510
1511 /* --no-call-graph */
1512 if (unset) {
1513 callchain->record_mode = CALLCHAIN_NONE;
1514 pr_debug("callchain: disabled\n");
1515 return 0;
1516 }
1517
1518 ret = parse_callchain_record_opt(arg, callchain);
1519 if (!ret) {
1520 /* Enable data address sampling for DWARF unwind. */
1521 if (callchain->record_mode == CALLCHAIN_DWARF)
1522 record->sample_address = true;
1523 callchain_debug(callchain);
1524 }
1525
1526 return ret;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001527}
1528
Kan Liangc421e802015-07-29 05:42:12 -04001529int record_parse_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001530 const char *arg,
1531 int unset)
1532{
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001533 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
Jiri Olsa26d33022012-08-07 15:20:47 +02001534}
1535
Kan Liangc421e802015-07-29 05:42:12 -04001536int record_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001537 const char *arg __maybe_unused,
1538 int unset __maybe_unused)
1539{
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001540 struct callchain_param *callchain = opt->value;
Kan Liangc421e802015-07-29 05:42:12 -04001541
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001542 callchain->enabled = true;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001543
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001544 if (callchain->record_mode == CALLCHAIN_NONE)
1545 callchain->record_mode = CALLCHAIN_FP;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001546
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001547 callchain_debug(callchain);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001548 return 0;
1549}
1550
Jiri Olsaeb853e82014-02-03 12:44:42 +01001551static int perf_record_config(const char *var, const char *value, void *cb)
1552{
Namhyung Kim7a29c082015-12-15 10:49:56 +09001553 struct record *rec = cb;
1554
1555 if (!strcmp(var, "record.build-id")) {
1556 if (!strcmp(value, "cache"))
1557 rec->no_buildid_cache = false;
1558 else if (!strcmp(value, "no-cache"))
1559 rec->no_buildid_cache = true;
1560 else if (!strcmp(value, "skip"))
1561 rec->no_buildid = true;
1562 else
1563 return -1;
1564 return 0;
1565 }
Yisheng Xiecff17202018-03-12 19:25:57 +08001566 if (!strcmp(var, "record.call-graph")) {
1567 var = "call-graph.record-mode";
1568 return perf_default_config(var, value, cb);
1569 }
Alexey Budankov93f20c02018-11-06 12:07:19 +03001570#ifdef HAVE_AIO_SUPPORT
1571 if (!strcmp(var, "record.aio")) {
1572 rec->opts.nr_cblocks = strtol(value, NULL, 0);
1573 if (!rec->opts.nr_cblocks)
1574 rec->opts.nr_cblocks = nr_cblocks_default;
1575 }
1576#endif
Jiri Olsaeb853e82014-02-03 12:44:42 +01001577
Yisheng Xiecff17202018-03-12 19:25:57 +08001578 return 0;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001579}
1580
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001581struct clockid_map {
1582 const char *name;
1583 int clockid;
1584};
1585
1586#define CLOCKID_MAP(n, c) \
1587 { .name = n, .clockid = (c), }
1588
1589#define CLOCKID_END { .name = NULL, }
1590
1591
1592/*
1593 * Add the missing ones, we need to build on many distros...
1594 */
1595#ifndef CLOCK_MONOTONIC_RAW
1596#define CLOCK_MONOTONIC_RAW 4
1597#endif
1598#ifndef CLOCK_BOOTTIME
1599#define CLOCK_BOOTTIME 7
1600#endif
1601#ifndef CLOCK_TAI
1602#define CLOCK_TAI 11
1603#endif
1604
1605static const struct clockid_map clockids[] = {
1606 /* available for all events, NMI safe */
1607 CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
1608 CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
1609
1610 /* available for some events */
1611 CLOCKID_MAP("realtime", CLOCK_REALTIME),
1612 CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
1613 CLOCKID_MAP("tai", CLOCK_TAI),
1614
1615 /* available for the lazy */
1616 CLOCKID_MAP("mono", CLOCK_MONOTONIC),
1617 CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
1618 CLOCKID_MAP("real", CLOCK_REALTIME),
1619 CLOCKID_MAP("boot", CLOCK_BOOTTIME),
1620
1621 CLOCKID_END,
1622};
1623
Alexey Budankovcf790512018-10-09 17:36:24 +03001624static int get_clockid_res(clockid_t clk_id, u64 *res_ns)
1625{
1626 struct timespec res;
1627
1628 *res_ns = 0;
1629 if (!clock_getres(clk_id, &res))
1630 *res_ns = res.tv_nsec + res.tv_sec * NSEC_PER_SEC;
1631 else
1632 pr_warning("WARNING: Failed to determine specified clock resolution.\n");
1633
1634 return 0;
1635}
1636
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001637static int parse_clockid(const struct option *opt, const char *str, int unset)
1638{
1639 struct record_opts *opts = (struct record_opts *)opt->value;
1640 const struct clockid_map *cm;
1641 const char *ostr = str;
1642
1643 if (unset) {
1644 opts->use_clockid = 0;
1645 return 0;
1646 }
1647
1648 /* no arg passed */
1649 if (!str)
1650 return 0;
1651
1652 /* no setting it twice */
1653 if (opts->use_clockid)
1654 return -1;
1655
1656 opts->use_clockid = true;
1657
1658 /* if its a number, we're done */
1659 if (sscanf(str, "%d", &opts->clockid) == 1)
Alexey Budankovcf790512018-10-09 17:36:24 +03001660 return get_clockid_res(opts->clockid, &opts->clockid_res_ns);
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001661
1662 /* allow a "CLOCK_" prefix to the name */
1663 if (!strncasecmp(str, "CLOCK_", 6))
1664 str += 6;
1665
1666 for (cm = clockids; cm->name; cm++) {
1667 if (!strcasecmp(str, cm->name)) {
1668 opts->clockid = cm->clockid;
Alexey Budankovcf790512018-10-09 17:36:24 +03001669 return get_clockid_res(opts->clockid,
1670 &opts->clockid_res_ns);
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001671 }
1672 }
1673
1674 opts->use_clockid = false;
1675 ui__warning("unknown clockid %s, check man page\n", ostr);
1676 return -1;
1677}
1678
Alexey Budankovf4fe11b2019-01-22 20:52:03 +03001679static int record__parse_affinity(const struct option *opt, const char *str, int unset)
1680{
1681 struct record_opts *opts = (struct record_opts *)opt->value;
1682
1683 if (unset || !str)
1684 return 0;
1685
1686 if (!strcasecmp(str, "node"))
1687 opts->affinity = PERF_AFFINITY_NODE;
1688 else if (!strcasecmp(str, "cpu"))
1689 opts->affinity = PERF_AFFINITY_CPU;
1690
1691 return 0;
1692}
1693
Adrian Huntere9db1312015-04-09 18:53:46 +03001694static int record__parse_mmap_pages(const struct option *opt,
1695 const char *str,
1696 int unset __maybe_unused)
1697{
1698 struct record_opts *opts = opt->value;
1699 char *s, *p;
1700 unsigned int mmap_pages;
1701 int ret;
1702
1703 if (!str)
1704 return -EINVAL;
1705
1706 s = strdup(str);
1707 if (!s)
1708 return -ENOMEM;
1709
1710 p = strchr(s, ',');
1711 if (p)
1712 *p = '\0';
1713
1714 if (*s) {
1715 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
1716 if (ret)
1717 goto out_free;
1718 opts->mmap_pages = mmap_pages;
1719 }
1720
1721 if (!p) {
1722 ret = 0;
1723 goto out_free;
1724 }
1725
1726 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
1727 if (ret)
1728 goto out_free;
1729
1730 opts->auxtrace_mmap_pages = mmap_pages;
1731
1732out_free:
1733 free(s);
1734 return ret;
1735}
1736
Jiri Olsa0c582442017-01-09 10:51:59 +01001737static void switch_output_size_warn(struct record *rec)
1738{
1739 u64 wakeup_size = perf_evlist__mmap_size(rec->opts.mmap_pages);
1740 struct switch_output *s = &rec->switch_output;
1741
1742 wakeup_size /= 2;
1743
1744 if (s->size < wakeup_size) {
1745 char buf[100];
1746
1747 unit_number__scnprintf(buf, sizeof(buf), wakeup_size);
1748 pr_warning("WARNING: switch-output data size lower than "
1749 "wakeup kernel buffer size (%s) "
1750 "expect bigger perf.data sizes\n", buf);
1751 }
1752}
1753
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001754static int switch_output_setup(struct record *rec)
1755{
1756 struct switch_output *s = &rec->switch_output;
Jiri Olsadc0c6122017-01-09 10:51:58 +01001757 static struct parse_tag tags_size[] = {
1758 { .tag = 'B', .mult = 1 },
1759 { .tag = 'K', .mult = 1 << 10 },
1760 { .tag = 'M', .mult = 1 << 20 },
1761 { .tag = 'G', .mult = 1 << 30 },
1762 { .tag = 0 },
1763 };
Jiri Olsabfacbe32017-01-09 10:52:00 +01001764 static struct parse_tag tags_time[] = {
1765 { .tag = 's', .mult = 1 },
1766 { .tag = 'm', .mult = 60 },
1767 { .tag = 'h', .mult = 60*60 },
1768 { .tag = 'd', .mult = 60*60*24 },
1769 { .tag = 0 },
1770 };
Jiri Olsadc0c6122017-01-09 10:51:58 +01001771 unsigned long val;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001772
1773 if (!s->set)
1774 return 0;
1775
1776 if (!strcmp(s->str, "signal")) {
1777 s->signal = true;
1778 pr_debug("switch-output with SIGUSR2 signal\n");
Jiri Olsadc0c6122017-01-09 10:51:58 +01001779 goto enabled;
1780 }
1781
1782 val = parse_tag_value(s->str, tags_size);
1783 if (val != (unsigned long) -1) {
1784 s->size = val;
1785 pr_debug("switch-output with %s size threshold\n", s->str);
1786 goto enabled;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001787 }
1788
Jiri Olsabfacbe32017-01-09 10:52:00 +01001789 val = parse_tag_value(s->str, tags_time);
1790 if (val != (unsigned long) -1) {
1791 s->time = val;
1792 pr_debug("switch-output with %s time threshold (%lu seconds)\n",
1793 s->str, s->time);
1794 goto enabled;
1795 }
1796
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001797 return -1;
Jiri Olsadc0c6122017-01-09 10:51:58 +01001798
1799enabled:
1800 rec->timestamp_filename = true;
1801 s->enabled = true;
Jiri Olsa0c582442017-01-09 10:51:59 +01001802
1803 if (s->size && !rec->opts.no_buffering)
1804 switch_output_size_warn(rec);
1805
Jiri Olsadc0c6122017-01-09 10:51:58 +01001806 return 0;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001807}
1808
Namhyung Kime5b2c202014-10-23 00:15:46 +09001809static const char * const __record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +02001810 "perf record [<options>] [<command>]",
1811 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001812 NULL
1813};
Namhyung Kime5b2c202014-10-23 00:15:46 +09001814const char * const *record_usage = __record_usage;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001815
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001816/*
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001817 * XXX Ideally would be local to cmd_record() and passed to a record__new
1818 * because we need to have access to it in record__exit, that is called
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001819 * after cmd_record() exits, but since record_options need to be accessible to
1820 * builtin-script, leave it here.
1821 *
1822 * At least we don't ouch it in all the other functions here directly.
1823 *
1824 * Just say no to tons of global variables, sigh.
1825 */
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001826static struct record record = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001827 .opts = {
Andi Kleen8affc2b2014-07-31 14:45:04 +08001828 .sample_time = true,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001829 .mmap_pages = UINT_MAX,
1830 .user_freq = UINT_MAX,
1831 .user_interval = ULLONG_MAX,
Arnaldo Carvalho de Melo447a6012012-05-22 13:14:18 -03001832 .freq = 4000,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09001833 .target = {
1834 .uses_mmap = true,
Adrian Hunter3aa59392013-11-15 15:52:29 +02001835 .default_per_cpu = true,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09001836 },
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001837 },
Namhyung Kime3d59112015-01-29 17:06:44 +09001838 .tool = {
1839 .sample = process_sample_event,
1840 .fork = perf_event__process_fork,
Adrian Huntercca84822015-08-19 17:29:21 +03001841 .exit = perf_event__process_exit,
Namhyung Kime3d59112015-01-29 17:06:44 +09001842 .comm = perf_event__process_comm,
Hari Bathinif3b36142017-03-08 02:11:43 +05301843 .namespaces = perf_event__process_namespaces,
Namhyung Kime3d59112015-01-29 17:06:44 +09001844 .mmap = perf_event__process_mmap,
1845 .mmap2 = perf_event__process_mmap2,
Adrian Huntercca84822015-08-19 17:29:21 +03001846 .ordered_events = true,
Namhyung Kime3d59112015-01-29 17:06:44 +09001847 },
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001848};
Frederic Weisbecker7865e812010-04-14 19:42:07 +02001849
Namhyung Kim76a26542015-10-22 23:28:32 +09001850const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
1851 "\n\t\t\t\tDefault: fp";
Arnaldo Carvalho de Melo61eaa3b2012-10-01 15:20:58 -03001852
Wang Nan0aab2132016-06-16 08:02:41 +00001853static bool dry_run;
1854
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001855/*
1856 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
1857 * with it and switch to use the library functions in perf_evlist that came
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001858 * from builtin-record.c, i.e. use record_opts,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001859 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
1860 * using pipes, etc.
1861 */
Jiri Olsaefd21302017-01-03 09:19:55 +01001862static struct option __record_options[] = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001863 OPT_CALLBACK('e', "event", &record.evlist, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +02001864 "event selector. use 'perf list' to list available events",
Jiri Olsaf120f9d2011-07-14 11:25:32 +02001865 parse_events_option),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001866 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
Li Zefanc171b552009-10-15 11:22:07 +08001867 "event filter", parse_filter),
Wang Nan4ba1faa2015-07-10 07:36:10 +00001868 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
1869 NULL, "don't record events from perf itself",
1870 exclude_perf),
Namhyung Kimbea03402012-04-26 14:15:15 +09001871 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001872 "record events on existing process id"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001873 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03001874 "record events on existing thread id"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001875 OPT_INTEGER('r', "realtime", &record.realtime_prio,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001876 "collect data with this RT SCHED_FIFO priority"),
Arnaldo Carvalho de Melo509051e2014-01-14 17:52:14 -03001877 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
Kirill Smelkovacac03f2011-01-12 17:59:36 +03001878 "collect data without buffering"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001879 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +02001880 "collect raw sample records from all opened counters"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001881 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001882 "system-wide collection from all CPUs"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001883 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02001884 "list of cpus to monitor"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001885 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
Jiri Olsa2d4f2792019-02-21 10:41:30 +01001886 OPT_STRING('o', "output", &record.data.path, "file",
Ingo Molnarabaff322009-06-02 22:59:57 +02001887 "output file name"),
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02001888 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
1889 &record.opts.no_inherit_set,
1890 "child tasks do not inherit counters"),
Wang Nan4ea648a2016-07-14 08:34:47 +00001891 OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize,
1892 "synthesize non-sample events at the end of output"),
Wang Nan626a6b72016-07-14 08:34:45 +00001893 OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
Song Liu45178a92019-01-17 08:15:18 -08001894 OPT_BOOLEAN(0, "bpf-event", &record.opts.bpf_event, "record bpf events"),
Arnaldo Carvalho de Melob09c2362018-03-01 14:52:50 -03001895 OPT_BOOLEAN(0, "strict-freq", &record.opts.strict_freq,
1896 "Fail if the specified frequency can't be used"),
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -03001897 OPT_CALLBACK('F', "freq", &record.opts, "freq or 'max'",
1898 "profile at this frequency",
1899 record__parse_freq),
Adrian Huntere9db1312015-04-09 18:53:46 +03001900 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
1901 "number of mmap data pages and AUX area tracing mmap pages",
1902 record__parse_mmap_pages),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001903 OPT_BOOLEAN(0, "group", &record.opts.group,
Lin Ming43bece72011-08-17 18:42:07 +08001904 "put the counters into a counter group"),
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001905 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001906 NULL, "enables call-graph recording" ,
1907 &record_callchain_opt),
1908 OPT_CALLBACK(0, "call-graph", &record.opts,
Namhyung Kim76a26542015-10-22 23:28:32 +09001909 "record_mode[,record_size]", record_callchain_help,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001910 &record_parse_callchain_opt),
Ian Munsiec0555642010-04-13 18:37:33 +10001911 OPT_INCR('v', "verbose", &verbose,
Ingo Molnar3da297a2009-06-07 17:39:02 +02001912 "be more verbose (show counter open errors, etc)"),
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001913 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001914 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001915 "per thread counts"),
Peter Zijlstra56100322015-06-10 16:48:50 +02001916 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
Kan Liang3b0a5da2017-08-29 13:11:08 -04001917 OPT_BOOLEAN(0, "phys-data", &record.opts.sample_phys_addr,
1918 "Record the sample physical addresses"),
Jiri Olsab6f35ed2016-08-01 20:02:35 +02001919 OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"),
Adrian Hunter3abebc52015-07-06 14:51:01 +03001920 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
1921 &record.opts.sample_time_set,
1922 "Record the sample timestamps"),
Jiri Olsaf290aa12018-02-01 09:38:11 +01001923 OPT_BOOLEAN_SET('P', "period", &record.opts.period, &record.opts.period_set,
1924 "Record the sample period"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001925 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001926 "don't sample"),
Wang Nand2db9a92016-01-25 09:56:19 +00001927 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
1928 &record.no_buildid_cache_set,
1929 "do not update the buildid cache"),
1930 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
1931 &record.no_buildid_set,
1932 "do not collect buildids in perf.data"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001933 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
Stephane Eranian023695d2011-02-14 11:20:01 +02001934 "monitor event in cgroup name only",
1935 parse_cgroups),
Arnaldo Carvalho de Meloa6205a32014-01-14 17:58:12 -03001936 OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
Andi Kleen6619a532014-01-11 13:38:27 -08001937 "ms to wait before starting measurement after program start"),
Namhyung Kimbea03402012-04-26 14:15:15 +09001938 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
1939 "user to profile"),
Stephane Eraniana5aabda2012-03-08 23:47:45 +01001940
1941 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
1942 "branch any", "sample any taken branches",
1943 parse_branch_stack),
1944
1945 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
1946 "branch filter mask", "branch stack filter modes",
Roberto Agostino Vitillobdfebd82012-02-09 23:21:02 +01001947 parse_branch_stack),
Andi Kleen05484292013-01-24 16:10:29 +01001948 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
1949 "sample by weight (on special events only)"),
Andi Kleen475eeab2013-09-20 07:40:43 -07001950 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
1951 "sample transaction flags (special events only)"),
Adrian Hunter3aa59392013-11-15 15:52:29 +02001952 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
1953 "use per-thread mmaps"),
Stephane Eranianbcc84ec2015-08-31 18:41:12 +02001954 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
1955 "sample selected machine registers on interrupt,"
1956 " use -I ? to list register names", parse_regs),
Andi Kleen84c41742017-09-05 10:00:28 -07001957 OPT_CALLBACK_OPTARG(0, "user-regs", &record.opts.sample_user_regs, NULL, "any register",
1958 "sample selected machine registers on interrupt,"
1959 " use -I ? to list register names", parse_regs),
Andi Kleen85c273d2015-02-24 15:13:40 -08001960 OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
1961 "Record running/enabled time of read (:S) events"),
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001962 OPT_CALLBACK('k', "clockid", &record.opts,
1963 "clockid", "clockid to use for events, see clock_gettime()",
1964 parse_clockid),
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001965 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
1966 "opts", "AUX area tracing Snapshot Mode", ""),
Mark Drayton3fcb10e2018-12-04 12:34:20 -08001967 OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
Kan Liang9d9cad72015-06-17 09:51:11 -04001968 "per thread proc mmap processing timeout in ms"),
Hari Bathinif3b36142017-03-08 02:11:43 +05301969 OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
1970 "Record namespaces events"),
Adrian Hunterb757bb02015-07-21 12:44:04 +03001971 OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
1972 "Record context switch events"),
Jiri Olsa85723882016-02-15 09:34:31 +01001973 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
1974 "Configure all used events to run in kernel space.",
1975 PARSE_OPT_EXCLUSIVE),
1976 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
1977 "Configure all used events to run in user space.",
1978 PARSE_OPT_EXCLUSIVE),
Wang Nan71dc23262015-10-14 12:41:19 +00001979 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
1980 "clang binary to use for compiling BPF scriptlets"),
1981 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
1982 "options passed to clang when compiling BPF scriptlets"),
He Kuang7efe0e02015-12-14 10:39:23 +00001983 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
1984 "file", "vmlinux pathname"),
Namhyung Kim61566812016-01-11 22:37:09 +09001985 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
1986 "Record build-id of all DSOs regardless of hits"),
Wang Nanecfd7a92016-04-13 08:21:07 +00001987 OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
1988 "append timestamp to output filename"),
Jin Yao68588ba2017-12-08 21:13:42 +08001989 OPT_BOOLEAN(0, "timestamp-boundary", &record.timestamp_boundary,
1990 "Record timestamp boundary (time of first/last samples)"),
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01001991 OPT_STRING_OPTARG_SET(0, "switch-output", &record.switch_output.str,
Andi Kleenc38dab72019-03-14 15:49:56 -07001992 &record.switch_output.set, "signal or size[BKMG] or time[smhd]",
1993 "Switch output when receiving SIGUSR2 (signal) or cross a size or time threshold",
Jiri Olsadc0c6122017-01-09 10:51:58 +01001994 "signal"),
Andi Kleen03724b22019-03-14 15:49:55 -07001995 OPT_INTEGER(0, "switch-max-files", &record.switch_output.num_files,
1996 "Limit number of switch output generated files"),
Wang Nan0aab2132016-06-16 08:02:41 +00001997 OPT_BOOLEAN(0, "dry-run", &dry_run,
1998 "Parse options then exit"),
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001999#ifdef HAVE_AIO_SUPPORT
Alexey Budankov93f20c02018-11-06 12:07:19 +03002000 OPT_CALLBACK_OPTARG(0, "aio", &record.opts,
2001 &nr_cblocks_default, "n", "Use <n> control blocks in asynchronous trace writing mode (default: 1, max: 4)",
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002002 record__aio_parse),
2003#endif
Alexey Budankovf4fe11b2019-01-22 20:52:03 +03002004 OPT_CALLBACK(0, "affinity", &record.opts, "node|cpu",
2005 "Set affinity mask of trace reading thread to NUMA node cpu mask or cpu of processed mmap buffer",
2006 record__parse_affinity),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002007 OPT_END()
2008};
2009
Namhyung Kime5b2c202014-10-23 00:15:46 +09002010struct option *record_options = __record_options;
2011
Arnaldo Carvalho de Melob0ad8ea2017-03-27 11:47:20 -03002012int cmd_record(int argc, const char **argv)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002013{
Adrian Hunteref149c22015-04-09 18:53:45 +03002014 int err;
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002015 struct record *rec = &record;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002016 char errbuf[BUFSIZ];
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002017
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -03002018 setlocale(LC_ALL, "");
2019
Wang Nan48e1cab2015-12-14 10:39:22 +00002020#ifndef HAVE_LIBBPF_SUPPORT
2021# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
2022 set_nobuild('\0', "clang-path", true);
2023 set_nobuild('\0', "clang-opt", true);
2024# undef set_nobuild
2025#endif
2026
He Kuang7efe0e02015-12-14 10:39:23 +00002027#ifndef HAVE_BPF_PROLOGUE
2028# if !defined (HAVE_DWARF_SUPPORT)
2029# define REASON "NO_DWARF=1"
2030# elif !defined (HAVE_LIBBPF_SUPPORT)
2031# define REASON "NO_LIBBPF=1"
2032# else
2033# define REASON "this architecture doesn't support BPF prologue"
2034# endif
2035# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
2036 set_nobuild('\0', "vmlinux", true);
2037# undef set_nobuild
2038# undef REASON
2039#endif
2040
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002041 CPU_ZERO(&rec->affinity_mask);
2042 rec->opts.affinity = PERF_AFFINITY_SYS;
2043
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002044 rec->evlist = perf_evlist__new();
2045 if (rec->evlist == NULL)
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02002046 return -ENOMEM;
2047
Arnaldo Carvalho de Meloecc4c562017-01-24 13:44:10 -03002048 err = perf_config(perf_record_config, rec);
2049 if (err)
2050 return err;
Jiri Olsaeb853e82014-02-03 12:44:42 +01002051
Tom Zanussibca647a2010-11-10 08:11:30 -06002052 argc = parse_options(argc, argv, record_options, record_usage,
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02002053 PARSE_OPT_STOP_AT_NON_OPTION);
Namhyung Kim68ba3232017-02-17 17:17:42 +09002054 if (quiet)
2055 perf_quiet_option();
Jiri Olsa483635a2017-02-17 18:00:18 +01002056
2057 /* Make system wide (-a) the default target. */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002058 if (!argc && target__none(&rec->opts.target))
Jiri Olsa483635a2017-02-17 18:00:18 +01002059 rec->opts.target.system_wide = true;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002060
Namhyung Kimbea03402012-04-26 14:15:15 +09002061 if (nr_cgroups && !rec->opts.target.system_wide) {
Namhyung Kimc7118362015-10-25 00:49:27 +09002062 usage_with_options_msg(record_usage, record_options,
2063 "cgroup monitoring only available in system-wide mode");
2064
Stephane Eranian023695d2011-02-14 11:20:01 +02002065 }
Adrian Hunterb757bb02015-07-21 12:44:04 +03002066 if (rec->opts.record_switch_events &&
2067 !perf_can_record_switch_events()) {
Namhyung Kimc7118362015-10-25 00:49:27 +09002068 ui__error("kernel does not support recording context switch events\n");
2069 parse_options_usage(record_usage, record_options, "switch-events", 0);
2070 return -EINVAL;
Adrian Hunterb757bb02015-07-21 12:44:04 +03002071 }
Stephane Eranian023695d2011-02-14 11:20:01 +02002072
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002073 if (switch_output_setup(rec)) {
2074 parse_options_usage(record_usage, record_options, "switch-output", 0);
2075 return -EINVAL;
2076 }
2077
Jiri Olsabfacbe32017-01-09 10:52:00 +01002078 if (rec->switch_output.time) {
2079 signal(SIGALRM, alarm_sig_handler);
2080 alarm(rec->switch_output.time);
2081 }
2082
Andi Kleen03724b22019-03-14 15:49:55 -07002083 if (rec->switch_output.num_files) {
2084 rec->switch_output.filenames = calloc(sizeof(char *),
2085 rec->switch_output.num_files);
2086 if (!rec->switch_output.filenames)
2087 return -EINVAL;
2088 }
2089
Adrian Hunter1b36c032016-09-23 17:38:39 +03002090 /*
2091 * Allow aliases to facilitate the lookup of symbols for address
2092 * filters. Refer to auxtrace_parse_filters().
2093 */
2094 symbol_conf.allow_aliases = true;
2095
2096 symbol__init(NULL);
2097
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +02002098 err = record__auxtrace_init(rec);
Adrian Hunter1b36c032016-09-23 17:38:39 +03002099 if (err)
2100 goto out;
2101
Wang Nan0aab2132016-06-16 08:02:41 +00002102 if (dry_run)
Adrian Hunter5c01ad602016-09-23 17:38:37 +03002103 goto out;
Wang Nan0aab2132016-06-16 08:02:41 +00002104
Wang Nand7888572016-04-08 15:07:24 +00002105 err = bpf__setup_stdout(rec->evlist);
2106 if (err) {
2107 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
2108 pr_err("ERROR: Setup BPF stdout failed: %s\n",
2109 errbuf);
Adrian Hunter5c01ad602016-09-23 17:38:37 +03002110 goto out;
Wang Nand7888572016-04-08 15:07:24 +00002111 }
2112
Adrian Hunteref149c22015-04-09 18:53:45 +03002113 err = -ENOMEM;
2114
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03002115 if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(rec->evlist))
Arnaldo Carvalho de Melo646aaea2011-05-27 11:00:41 -03002116 pr_warning(
2117"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
2118"check /proc/sys/kernel/kptr_restrict.\n\n"
2119"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
2120"file is not found in the buildid cache or in the vmlinux path.\n\n"
2121"Samples in kernel modules won't be resolved at all.\n\n"
2122"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
2123"even with a suitable vmlinux or kallsyms file.\n\n");
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -03002124
Wang Nan0c1d46a2016-04-20 18:59:52 +00002125 if (rec->no_buildid_cache || rec->no_buildid) {
Stephane Eraniana1ac1d32010-06-17 11:39:01 +02002126 disable_buildid_cache();
Jiri Olsadc0c6122017-01-09 10:51:58 +01002127 } else if (rec->switch_output.enabled) {
Wang Nan0c1d46a2016-04-20 18:59:52 +00002128 /*
2129 * In 'perf record --switch-output', disable buildid
2130 * generation by default to reduce data file switching
2131 * overhead. Still generate buildid if they are required
2132 * explicitly using
2133 *
Jiri Olsa60437ac2017-01-03 09:19:56 +01002134 * perf record --switch-output --no-no-buildid \
Wang Nan0c1d46a2016-04-20 18:59:52 +00002135 * --no-no-buildid-cache
2136 *
2137 * Following code equals to:
2138 *
2139 * if ((rec->no_buildid || !rec->no_buildid_set) &&
2140 * (rec->no_buildid_cache || !rec->no_buildid_cache_set))
2141 * disable_buildid_cache();
2142 */
2143 bool disable = true;
2144
2145 if (rec->no_buildid_set && !rec->no_buildid)
2146 disable = false;
2147 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
2148 disable = false;
2149 if (disable) {
2150 rec->no_buildid = true;
2151 rec->no_buildid_cache = true;
2152 disable_buildid_cache();
2153 }
2154 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02002155
Wang Nan4ea648a2016-07-14 08:34:47 +00002156 if (record.opts.overwrite)
2157 record.opts.tail_synthesize = true;
2158
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002159 if (rec->evlist->nr_entries == 0 &&
Arnaldo Carvalho de Melo4b4cd502017-07-03 13:26:32 -03002160 __perf_evlist__add_default(rec->evlist, !record.opts.no_samples) < 0) {
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02002161 pr_err("Not enough memory for event selector list\n");
Adrian Hunter394c01e2016-09-23 17:38:36 +03002162 goto out;
Peter Zijlstrabbd36e52009-06-11 23:11:50 +02002163 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002164
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02002165 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
2166 rec->opts.no_inherit = true;
2167
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002168 err = target__validate(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002169 if (err) {
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002170 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Jiri Olsac3dec272018-02-06 19:17:58 +01002171 ui__warning("%s\n", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002172 }
Namhyung Kim4bd0f2d2012-04-26 14:15:18 +09002173
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002174 err = target__parse_uid(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002175 if (err) {
2176 int saved_errno = errno;
2177
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002178 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim3780f482012-05-29 13:22:57 +09002179 ui__error("%s", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002180
2181 err = -saved_errno;
Adrian Hunter394c01e2016-09-23 17:38:36 +03002182 goto out;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002183 }
Arnaldo Carvalho de Melo0d37aa32012-01-19 14:08:15 -02002184
Mengting Zhangca800062017-12-13 15:01:53 +08002185 /* Enable ignoring missing threads when -u/-p option is defined. */
2186 rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX || rec->opts.target.pid;
Jiri Olsa23dc4f12016-12-12 11:35:43 +01002187
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002188 err = -ENOMEM;
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002189 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -02002190 usage_with_options(record_usage, record_options);
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02002191
Adrian Hunteref149c22015-04-09 18:53:45 +03002192 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
2193 if (err)
Adrian Hunter394c01e2016-09-23 17:38:36 +03002194 goto out;
Adrian Hunteref149c22015-04-09 18:53:45 +03002195
Namhyung Kim61566812016-01-11 22:37:09 +09002196 /*
2197 * We take all buildids when the file contains
2198 * AUX area tracing data because we do not decode the
2199 * trace because it would take too long.
2200 */
2201 if (rec->opts.full_auxtrace)
2202 rec->buildid_all = true;
2203
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03002204 if (record_opts__config(&rec->opts)) {
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002205 err = -EINVAL;
Adrian Hunter394c01e2016-09-23 17:38:36 +03002206 goto out;
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +02002207 }
2208
Alexey Budankov93f20c02018-11-06 12:07:19 +03002209 if (rec->opts.nr_cblocks > nr_cblocks_max)
2210 rec->opts.nr_cblocks = nr_cblocks_max;
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002211 if (verbose > 0)
2212 pr_info("nr_cblocks: %d\n", rec->opts.nr_cblocks);
2213
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002214 pr_debug("affinity: %s\n", affinity_tags[rec->opts.affinity]);
2215
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002216 err = __cmd_record(&record, argc, argv);
Adrian Hunter394c01e2016-09-23 17:38:36 +03002217out:
Namhyung Kim45604712014-05-12 09:47:24 +09002218 perf_evlist__delete(rec->evlist);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -03002219 symbol__exit();
Adrian Hunteref149c22015-04-09 18:53:45 +03002220 auxtrace_record__free(rec->itr);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002221 return err;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002222}
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002223
2224static void snapshot_sig_handler(int sig __maybe_unused)
2225{
Jiri Olsadc0c6122017-01-09 10:51:58 +01002226 struct record *rec = &record;
2227
Wang Nan5f9cf592016-04-20 18:59:49 +00002228 if (trigger_is_ready(&auxtrace_snapshot_trigger)) {
2229 trigger_hit(&auxtrace_snapshot_trigger);
2230 auxtrace_record__snapshot_started = 1;
2231 if (auxtrace_record__snapshot_start(record.itr))
2232 trigger_error(&auxtrace_snapshot_trigger);
2233 }
Wang Nan3c1cb7e2016-04-20 18:59:50 +00002234
Jiri Olsadc0c6122017-01-09 10:51:58 +01002235 if (switch_output_signal(rec))
Wang Nan3c1cb7e2016-04-20 18:59:50 +00002236 trigger_hit(&switch_output_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002237}
Jiri Olsabfacbe32017-01-09 10:52:00 +01002238
2239static void alarm_sig_handler(int sig __maybe_unused)
2240{
2241 struct record *rec = &record;
2242
2243 if (switch_output_time(rec))
2244 trigger_hit(&switch_output_trigger);
2245}