blob: f6664bb08b26fc70afe8e8a6f44b70e8d688ea05 [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
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -020011#include "util/build-id.h"
Josh Poimboeuf4b6ab942015-12-15 09:39:39 -060012#include <subcmd/parse-options.h>
Ingo Molnar8ad8db32009-05-26 11:10:09 +020013#include "util/parse-events.h"
Taeung Song41840d22016-06-23 17:55:17 +090014#include "util/config.h"
Thomas Gleixner6eda5832009-05-01 18:29:57 +020015
Arnaldo Carvalho de Melo8f651ea2014-10-09 16:12:24 -030016#include "util/callchain.h"
Arnaldo Carvalho de Melof14d5702014-10-17 12:17:40 -030017#include "util/cgroup.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020018#include "util/header.h"
Frederic Weisbecker66e274f2009-08-12 11:07:25 +020019#include "util/event.h"
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020020#include "util/evlist.h"
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -020021#include "util/evsel.h"
Frederic Weisbecker8f288272009-08-16 22:05:48 +020022#include "util/debug.h"
Arnaldo Carvalho de Meloe0fcfb02019-09-23 12:20:38 -030023#include "util/mmap.h"
Arnaldo Carvalho de Meloaeb00b12019-08-22 15:40:29 -030024#include "util/target.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020025#include "util/session.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020026#include "util/tool.h"
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020027#include "util/symbol.h"
Arnaldo Carvalho de Meloaeb00b12019-08-22 15:40:29 -030028#include "util/record.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 Meloea49e012019-09-18 11:36:13 -030042#include "util/synthetic-events.h"
Arnaldo Carvalho de Meloc5e40272017-04-19 16:12:39 -030043#include "util/time-utils.h"
Arnaldo Carvalho de Melo58db1d62017-04-19 16:05:56 -030044#include "util/units.h"
Song Liu7b612e22019-01-17 08:15:19 -080045#include "util/bpf-event.h"
Wang Nand8871ea2016-02-26 09:32:06 +000046#include "asm/bug.h"
Arnaldo Carvalho de Meloc1a604d2019-08-29 15:20:59 -030047#include "perf.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020048
Arnaldo Carvalho de Meloa43783a2017-04-18 10:46:11 -030049#include <errno.h>
Arnaldo Carvalho de Melofd20e812017-04-17 15:23:08 -030050#include <inttypes.h>
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -030051#include <locale.h>
Arnaldo Carvalho de Melo42087352017-04-19 19:06:30 -030052#include <poll.h>
Peter Zijlstra97124d5e2009-06-02 15:52:24 +020053#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020054#include <sched.h>
Arnaldo Carvalho de Melo9607ad32017-04-19 15:49:18 -030055#include <signal.h>
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -030056#include <sys/mman.h>
Arnaldo Carvalho de Melo42087352017-04-19 19:06:30 -030057#include <sys/wait.h>
Adrian Huntereeb399b2019-10-04 11:31:21 +030058#include <sys/types.h>
59#include <sys/stat.h>
60#include <fcntl.h>
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +053061#include <linux/err.h>
Arnaldo Carvalho de Melo8520a982019-08-29 16:18:59 -030062#include <linux/string.h>
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -030063#include <linux/time64.h>
Arnaldo Carvalho de Melod8f9da22019-07-04 12:06:20 -030064#include <linux/zalloc.h>
Bernhard Rosenkraenzer78da39f2012-10-08 09:43:26 +030065
Jiri Olsa1b43b702017-01-09 10:51:56 +010066struct switch_output {
Jiri Olsadc0c6122017-01-09 10:51:58 +010067 bool enabled;
Jiri Olsa1b43b702017-01-09 10:51:56 +010068 bool signal;
Jiri Olsadc0c6122017-01-09 10:51:58 +010069 unsigned long size;
Jiri Olsabfacbe32017-01-09 10:52:00 +010070 unsigned long time;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +010071 const char *str;
72 bool set;
Andi Kleen03724b22019-03-14 15:49:55 -070073 char **filenames;
74 int num_files;
75 int cur_file;
Jiri Olsa1b43b702017-01-09 10:51:56 +010076};
77
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030078struct record {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020079 struct perf_tool tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -030080 struct record_opts opts;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020081 u64 bytes_written;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +010082 struct perf_data data;
Adrian Hunteref149c22015-04-09 18:53:45 +030083 struct auxtrace_record *itr;
Jiri Olsa63503db2019-07-21 13:23:52 +020084 struct evlist *evlist;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020085 struct perf_session *session;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020086 int realtime_prio;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020087 bool no_buildid;
Wang Nand2db9a92016-01-25 09:56:19 +000088 bool no_buildid_set;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020089 bool no_buildid_cache;
Wang Nand2db9a92016-01-25 09:56:19 +000090 bool no_buildid_cache_set;
Namhyung Kim61566812016-01-11 22:37:09 +090091 bool buildid_all;
Wang Nanecfd7a92016-04-13 08:21:07 +000092 bool timestamp_filename;
Jin Yao68588ba2017-12-08 21:13:42 +080093 bool timestamp_boundary;
Jiri Olsa1b43b702017-01-09 10:51:56 +010094 struct switch_output switch_output;
Yang Shi9f065192015-09-29 14:49:43 -070095 unsigned long long samples;
Alexey Budankov9d2ed642019-01-22 20:47:43 +030096 cpu_set_t affinity_mask;
Arnaldo Carvalho de Melo0f82ebc2011-11-08 14:41:57 -020097};
Ingo Molnara21ca2c2009-06-06 09:58:57 +020098
Jiri Olsadc0c6122017-01-09 10:51:58 +010099static volatile int auxtrace_record__snapshot_started;
100static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
101static DEFINE_TRIGGER(switch_output_trigger);
102
Alexey Budankov9d2ed642019-01-22 20:47:43 +0300103static const char *affinity_tags[PERF_AFFINITY_MAX] = {
104 "SYS", "NODE", "CPU"
105};
106
Jiri Olsadc0c6122017-01-09 10:51:58 +0100107static bool switch_output_signal(struct record *rec)
108{
109 return rec->switch_output.signal &&
110 trigger_is_ready(&switch_output_trigger);
111}
112
113static bool switch_output_size(struct record *rec)
114{
115 return rec->switch_output.size &&
116 trigger_is_ready(&switch_output_trigger) &&
117 (rec->bytes_written >= rec->switch_output.size);
118}
119
Jiri Olsabfacbe32017-01-09 10:52:00 +0100120static bool switch_output_time(struct record *rec)
121{
122 return rec->switch_output.time &&
123 trigger_is_ready(&switch_output_trigger);
124}
125
Jiri Olsaa5830532019-07-27 20:30:53 +0200126static int record__write(struct record *rec, struct mmap *map __maybe_unused,
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200127 void *bf, size_t size)
Peter Zijlstraf5970552009-06-18 23:22:55 +0200128{
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200129 struct perf_data_file *file = &rec->session->data->file;
130
131 if (perf_data_file__write(file, bf, size) < 0) {
Jiri Olsa50a9b862013-11-22 13:11:24 +0100132 pr_err("failed to write perf data, error: %m\n");
133 return -1;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200134 }
David Ahern8d3eca22012-08-26 12:24:47 -0600135
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -0300136 rec->bytes_written += size;
Jiri Olsadc0c6122017-01-09 10:51:58 +0100137
138 if (switch_output_size(rec))
139 trigger_hit(&switch_output_trigger);
140
David Ahern8d3eca22012-08-26 12:24:47 -0600141 return 0;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200142}
143
Alexey Budankovef781122019-03-18 20:44:12 +0300144static int record__aio_enabled(struct record *rec);
145static int record__comp_enabled(struct record *rec);
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300146static size_t zstd_compress(struct perf_session *session, void *dst, size_t dst_size,
147 void *src, size_t src_size);
148
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300149#ifdef HAVE_AIO_SUPPORT
150static int record__aio_write(struct aiocb *cblock, int trace_fd,
151 void *buf, size_t size, off_t off)
152{
153 int rc;
154
155 cblock->aio_fildes = trace_fd;
156 cblock->aio_buf = buf;
157 cblock->aio_nbytes = size;
158 cblock->aio_offset = off;
159 cblock->aio_sigevent.sigev_notify = SIGEV_NONE;
160
161 do {
162 rc = aio_write(cblock);
163 if (rc == 0) {
164 break;
165 } else if (errno != EAGAIN) {
166 cblock->aio_fildes = -1;
167 pr_err("failed to queue perf data, error: %m\n");
168 break;
169 }
170 } while (1);
171
172 return rc;
173}
174
Jiri Olsaa5830532019-07-27 20:30:53 +0200175static int record__aio_complete(struct mmap *md, struct aiocb *cblock)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300176{
177 void *rem_buf;
178 off_t rem_off;
179 size_t rem_size;
180 int rc, aio_errno;
181 ssize_t aio_ret, written;
182
183 aio_errno = aio_error(cblock);
184 if (aio_errno == EINPROGRESS)
185 return 0;
186
187 written = aio_ret = aio_return(cblock);
188 if (aio_ret < 0) {
189 if (aio_errno != EINTR)
190 pr_err("failed to write perf data, error: %m\n");
191 written = 0;
192 }
193
194 rem_size = cblock->aio_nbytes - written;
195
196 if (rem_size == 0) {
197 cblock->aio_fildes = -1;
198 /*
Alexey Budankovef781122019-03-18 20:44:12 +0300199 * md->refcount is incremented in record__aio_pushfn() for
200 * every aio write request started in record__aio_push() so
201 * decrement it because the request is now complete.
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300202 */
Jiri Olsa80e53d12019-10-07 14:53:15 +0200203 perf_mmap__put(&md->core);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300204 rc = 1;
205 } else {
206 /*
207 * aio write request may require restart with the
208 * reminder if the kernel didn't write whole
209 * chunk at once.
210 */
211 rem_off = cblock->aio_offset + written;
212 rem_buf = (void *)(cblock->aio_buf + written);
213 record__aio_write(cblock, cblock->aio_fildes,
214 rem_buf, rem_size, rem_off);
215 rc = 0;
216 }
217
218 return rc;
219}
220
Jiri Olsaa5830532019-07-27 20:30:53 +0200221static int record__aio_sync(struct mmap *md, bool sync_all)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300222{
Alexey Budankov93f20c02018-11-06 12:07:19 +0300223 struct aiocb **aiocb = md->aio.aiocb;
224 struct aiocb *cblocks = md->aio.cblocks;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300225 struct timespec timeout = { 0, 1000 * 1000 * 1 }; /* 1ms */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300226 int i, do_suspend;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300227
228 do {
Alexey Budankov93f20c02018-11-06 12:07:19 +0300229 do_suspend = 0;
230 for (i = 0; i < md->aio.nr_cblocks; ++i) {
231 if (cblocks[i].aio_fildes == -1 || record__aio_complete(md, &cblocks[i])) {
232 if (sync_all)
233 aiocb[i] = NULL;
234 else
235 return i;
236 } else {
237 /*
238 * Started aio write is not complete yet
239 * so it has to be waited before the
240 * next allocation.
241 */
242 aiocb[i] = &cblocks[i];
243 do_suspend = 1;
244 }
245 }
246 if (!do_suspend)
247 return -1;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300248
Alexey Budankov93f20c02018-11-06 12:07:19 +0300249 while (aio_suspend((const struct aiocb **)aiocb, md->aio.nr_cblocks, &timeout)) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300250 if (!(errno == EAGAIN || errno == EINTR))
251 pr_err("failed to sync perf data, error: %m\n");
252 }
253 } while (1);
254}
255
Alexey Budankovef781122019-03-18 20:44:12 +0300256struct record_aio {
257 struct record *rec;
258 void *data;
259 size_t size;
260};
261
Jiri Olsaa5830532019-07-27 20:30:53 +0200262static int record__aio_pushfn(struct mmap *map, void *to, void *buf, size_t size)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300263{
Alexey Budankovef781122019-03-18 20:44:12 +0300264 struct record_aio *aio = to;
265
266 /*
Jiri Olsa547740f2019-07-27 22:07:44 +0200267 * map->core.base data pointed by buf is copied into free map->aio.data[] buffer
Alexey Budankovef781122019-03-18 20:44:12 +0300268 * to release space in the kernel buffer as fast as possible, calling
269 * perf_mmap__consume() from perf_mmap__push() function.
270 *
271 * That lets the kernel to proceed with storing more profiling data into
272 * the kernel buffer earlier than other per-cpu kernel buffers are handled.
273 *
274 * Coping can be done in two steps in case the chunk of profiling data
275 * crosses the upper bound of the kernel buffer. In this case we first move
276 * part of data from map->start till the upper bound and then the reminder
277 * from the beginning of the kernel buffer till the end of the data chunk.
278 */
279
280 if (record__comp_enabled(aio->rec)) {
281 size = zstd_compress(aio->rec->session, aio->data + aio->size,
Jiri Olsabf59b302019-10-07 14:53:11 +0200282 mmap__mmap_len(map) - aio->size,
Alexey Budankovef781122019-03-18 20:44:12 +0300283 buf, size);
284 } else {
285 memcpy(aio->data + aio->size, buf, size);
286 }
287
288 if (!aio->size) {
289 /*
290 * Increment map->refcount to guard map->aio.data[] buffer
291 * from premature deallocation because map object can be
292 * released earlier than aio write request started on
293 * map->aio.data[] buffer is complete.
294 *
295 * perf_mmap__put() is done at record__aio_complete()
296 * after started aio request completion or at record__aio_push()
297 * if the request failed to start.
298 */
Jiri Olsae75710f2019-10-07 14:53:13 +0200299 perf_mmap__get(&map->core);
Alexey Budankovef781122019-03-18 20:44:12 +0300300 }
301
302 aio->size += size;
303
304 return size;
305}
306
Jiri Olsaa5830532019-07-27 20:30:53 +0200307static int record__aio_push(struct record *rec, struct mmap *map, off_t *off)
Alexey Budankovef781122019-03-18 20:44:12 +0300308{
309 int ret, idx;
310 int trace_fd = rec->session->data->file.fd;
311 struct record_aio aio = { .rec = rec, .size = 0 };
312
313 /*
314 * Call record__aio_sync() to wait till map->aio.data[] buffer
315 * becomes available after previous aio write operation.
316 */
317
318 idx = record__aio_sync(map, false);
319 aio.data = map->aio.data[idx];
320 ret = perf_mmap__push(map, &aio, record__aio_pushfn);
321 if (ret != 0) /* ret > 0 - no data, ret < 0 - error */
322 return ret;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300323
324 rec->samples++;
Alexey Budankovef781122019-03-18 20:44:12 +0300325 ret = record__aio_write(&(map->aio.cblocks[idx]), trace_fd, aio.data, aio.size, *off);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300326 if (!ret) {
Alexey Budankovef781122019-03-18 20:44:12 +0300327 *off += aio.size;
328 rec->bytes_written += aio.size;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300329 if (switch_output_size(rec))
330 trigger_hit(&switch_output_trigger);
Alexey Budankovef781122019-03-18 20:44:12 +0300331 } else {
332 /*
333 * Decrement map->refcount incremented in record__aio_pushfn()
334 * back if record__aio_write() operation failed to start, otherwise
335 * map->refcount is decremented in record__aio_complete() after
336 * aio write operation finishes successfully.
337 */
Jiri Olsa80e53d12019-10-07 14:53:15 +0200338 perf_mmap__put(&map->core);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300339 }
340
341 return ret;
342}
343
344static off_t record__aio_get_pos(int trace_fd)
345{
346 return lseek(trace_fd, 0, SEEK_CUR);
347}
348
349static void record__aio_set_pos(int trace_fd, off_t pos)
350{
351 lseek(trace_fd, pos, SEEK_SET);
352}
353
354static void record__aio_mmap_read_sync(struct record *rec)
355{
356 int i;
Jiri Olsa63503db2019-07-21 13:23:52 +0200357 struct evlist *evlist = rec->evlist;
Jiri Olsaa5830532019-07-27 20:30:53 +0200358 struct mmap *maps = evlist->mmap;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300359
Alexey Budankovef781122019-03-18 20:44:12 +0300360 if (!record__aio_enabled(rec))
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300361 return;
362
Jiri Olsac976ee12019-07-30 13:04:59 +0200363 for (i = 0; i < evlist->core.nr_mmaps; i++) {
Jiri Olsaa5830532019-07-27 20:30:53 +0200364 struct mmap *map = &maps[i];
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300365
Jiri Olsa547740f2019-07-27 22:07:44 +0200366 if (map->core.base)
Alexey Budankov93f20c02018-11-06 12:07:19 +0300367 record__aio_sync(map, true);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300368 }
369}
370
371static int nr_cblocks_default = 1;
Alexey Budankov93f20c02018-11-06 12:07:19 +0300372static int nr_cblocks_max = 4;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300373
374static int record__aio_parse(const struct option *opt,
Alexey Budankov93f20c02018-11-06 12:07:19 +0300375 const char *str,
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300376 int unset)
377{
378 struct record_opts *opts = (struct record_opts *)opt->value;
379
Alexey Budankov93f20c02018-11-06 12:07:19 +0300380 if (unset) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300381 opts->nr_cblocks = 0;
Alexey Budankov93f20c02018-11-06 12:07:19 +0300382 } else {
383 if (str)
384 opts->nr_cblocks = strtol(str, NULL, 0);
385 if (!opts->nr_cblocks)
386 opts->nr_cblocks = nr_cblocks_default;
387 }
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300388
389 return 0;
390}
391#else /* HAVE_AIO_SUPPORT */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300392static int nr_cblocks_max = 0;
393
Jiri Olsaa5830532019-07-27 20:30:53 +0200394static int record__aio_push(struct record *rec __maybe_unused, struct mmap *map __maybe_unused,
Alexey Budankovef781122019-03-18 20:44:12 +0300395 off_t *off __maybe_unused)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300396{
397 return -1;
398}
399
400static off_t record__aio_get_pos(int trace_fd __maybe_unused)
401{
402 return -1;
403}
404
405static void record__aio_set_pos(int trace_fd __maybe_unused, off_t pos __maybe_unused)
406{
407}
408
409static void record__aio_mmap_read_sync(struct record *rec __maybe_unused)
410{
411}
412#endif
413
414static int record__aio_enabled(struct record *rec)
415{
416 return rec->opts.nr_cblocks > 0;
417}
418
Alexey Budankov470530b2019-03-18 20:40:26 +0300419#define MMAP_FLUSH_DEFAULT 1
420static int record__mmap_flush_parse(const struct option *opt,
421 const char *str,
422 int unset)
423{
424 int flush_max;
425 struct record_opts *opts = (struct record_opts *)opt->value;
426 static struct parse_tag tags[] = {
427 { .tag = 'B', .mult = 1 },
428 { .tag = 'K', .mult = 1 << 10 },
429 { .tag = 'M', .mult = 1 << 20 },
430 { .tag = 'G', .mult = 1 << 30 },
431 { .tag = 0 },
432 };
433
434 if (unset)
435 return 0;
436
437 if (str) {
438 opts->mmap_flush = parse_tag_value(str, tags);
439 if (opts->mmap_flush == (int)-1)
440 opts->mmap_flush = strtol(str, NULL, 0);
441 }
442
443 if (!opts->mmap_flush)
444 opts->mmap_flush = MMAP_FLUSH_DEFAULT;
445
Jiri Olsa9521b5f2019-07-28 12:45:35 +0200446 flush_max = evlist__mmap_size(opts->mmap_pages);
Alexey Budankov470530b2019-03-18 20:40:26 +0300447 flush_max /= 4;
448 if (opts->mmap_flush > flush_max)
449 opts->mmap_flush = flush_max;
450
451 return 0;
452}
453
Alexey Budankov504c1ad2019-03-18 20:44:42 +0300454#ifdef HAVE_ZSTD_SUPPORT
455static unsigned int comp_level_default = 1;
456
457static int record__parse_comp_level(const struct option *opt, const char *str, int unset)
458{
459 struct record_opts *opts = opt->value;
460
461 if (unset) {
462 opts->comp_level = 0;
463 } else {
464 if (str)
465 opts->comp_level = strtol(str, NULL, 0);
466 if (!opts->comp_level)
467 opts->comp_level = comp_level_default;
468 }
469
470 return 0;
471}
472#endif
Alexey Budankov51255a82019-03-18 20:42:19 +0300473static unsigned int comp_level_max = 22;
474
Alexey Budankov42e1fd82019-03-18 20:41:33 +0300475static int record__comp_enabled(struct record *rec)
476{
477 return rec->opts.comp_level > 0;
478}
479
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200480static int process_synthesized_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200481 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300482 struct perf_sample *sample __maybe_unused,
483 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200484{
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300485 struct record *rec = container_of(tool, struct record, tool);
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200486 return record__write(rec, NULL, event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200487}
488
Jiri Olsaa5830532019-07-27 20:30:53 +0200489static int record__pushfn(struct mmap *map, void *to, void *bf, size_t size)
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300490{
491 struct record *rec = to;
492
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300493 if (record__comp_enabled(rec)) {
Jiri Olsabf59b302019-10-07 14:53:11 +0200494 size = zstd_compress(rec->session, map->data, mmap__mmap_len(map), bf, size);
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300495 bf = map->data;
496 }
497
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300498 rec->samples++;
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200499 return record__write(rec, map, bf, size);
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300500}
501
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300502static volatile int done;
503static volatile int signr = -1;
504static volatile int child_finished;
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000505
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300506static void sig_handler(int sig)
507{
508 if (sig == SIGCHLD)
509 child_finished = 1;
510 else
511 signr = sig;
512
513 done = 1;
514}
515
Wang Nana0748652016-11-26 07:03:28 +0000516static void sigsegv_handler(int sig)
517{
518 perf_hooks__recover();
519 sighandler_dump_stack(sig);
520}
521
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300522static void record__sig_exit(void)
523{
524 if (signr == -1)
525 return;
526
527 signal(signr, SIG_DFL);
528 raise(signr);
529}
530
Adrian Huntere31f0d02015-04-30 17:37:27 +0300531#ifdef HAVE_AUXTRACE_SUPPORT
532
Adrian Hunteref149c22015-04-09 18:53:45 +0300533static int record__process_auxtrace(struct perf_tool *tool,
Jiri Olsaa5830532019-07-27 20:30:53 +0200534 struct mmap *map,
Adrian Hunteref149c22015-04-09 18:53:45 +0300535 union perf_event *event, void *data1,
536 size_t len1, void *data2, size_t len2)
537{
538 struct record *rec = container_of(tool, struct record, tool);
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100539 struct perf_data *data = &rec->data;
Adrian Hunteref149c22015-04-09 18:53:45 +0300540 size_t padding;
541 u8 pad[8] = {0};
542
Adrian Hunter46e201e2019-10-04 11:31:20 +0300543 if (!perf_data__is_pipe(data) && perf_data__is_single_file(data)) {
Adrian Hunter99fa2982015-04-30 17:37:25 +0300544 off_t file_offset;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100545 int fd = perf_data__fd(data);
Adrian Hunter99fa2982015-04-30 17:37:25 +0300546 int err;
547
548 file_offset = lseek(fd, 0, SEEK_CUR);
549 if (file_offset == -1)
550 return -1;
551 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
552 event, file_offset);
553 if (err)
554 return err;
555 }
556
Adrian Hunteref149c22015-04-09 18:53:45 +0300557 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
558 padding = (len1 + len2) & 7;
559 if (padding)
560 padding = 8 - padding;
561
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200562 record__write(rec, map, event, event->header.size);
563 record__write(rec, map, data1, len1);
Adrian Hunteref149c22015-04-09 18:53:45 +0300564 if (len2)
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200565 record__write(rec, map, data2, len2);
566 record__write(rec, map, &pad, padding);
Adrian Hunteref149c22015-04-09 18:53:45 +0300567
568 return 0;
569}
570
571static int record__auxtrace_mmap_read(struct record *rec,
Jiri Olsaa5830532019-07-27 20:30:53 +0200572 struct mmap *map)
Adrian Hunteref149c22015-04-09 18:53:45 +0300573{
574 int ret;
575
Jiri Olsae035f4c2018-09-13 14:54:05 +0200576 ret = auxtrace_mmap__read(map, rec->itr, &rec->tool,
Adrian Hunteref149c22015-04-09 18:53:45 +0300577 record__process_auxtrace);
578 if (ret < 0)
579 return ret;
580
581 if (ret)
582 rec->samples++;
583
584 return 0;
585}
586
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300587static int record__auxtrace_mmap_read_snapshot(struct record *rec,
Jiri Olsaa5830532019-07-27 20:30:53 +0200588 struct mmap *map)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300589{
590 int ret;
591
Jiri Olsae035f4c2018-09-13 14:54:05 +0200592 ret = auxtrace_mmap__read_snapshot(map, rec->itr, &rec->tool,
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300593 record__process_auxtrace,
594 rec->opts.auxtrace_snapshot_size);
595 if (ret < 0)
596 return ret;
597
598 if (ret)
599 rec->samples++;
600
601 return 0;
602}
603
604static int record__auxtrace_read_snapshot_all(struct record *rec)
605{
606 int i;
607 int rc = 0;
608
Jiri Olsac976ee12019-07-30 13:04:59 +0200609 for (i = 0; i < rec->evlist->core.nr_mmaps; i++) {
Jiri Olsaa5830532019-07-27 20:30:53 +0200610 struct mmap *map = &rec->evlist->mmap[i];
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300611
Jiri Olsae035f4c2018-09-13 14:54:05 +0200612 if (!map->auxtrace_mmap.base)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300613 continue;
614
Jiri Olsae035f4c2018-09-13 14:54:05 +0200615 if (record__auxtrace_mmap_read_snapshot(rec, map) != 0) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300616 rc = -1;
617 goto out;
618 }
619 }
620out:
621 return rc;
622}
623
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300624static void record__read_auxtrace_snapshot(struct record *rec, bool on_exit)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300625{
626 pr_debug("Recording AUX area tracing snapshot\n");
627 if (record__auxtrace_read_snapshot_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +0000628 trigger_error(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300629 } else {
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300630 if (auxtrace_record__snapshot_finish(rec->itr, on_exit))
Wang Nan5f9cf592016-04-20 18:59:49 +0000631 trigger_error(&auxtrace_snapshot_trigger);
632 else
633 trigger_ready(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300634 }
635}
636
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300637static int record__auxtrace_snapshot_exit(struct record *rec)
638{
639 if (trigger_is_error(&auxtrace_snapshot_trigger))
640 return 0;
641
642 if (!auxtrace_record__snapshot_started &&
643 auxtrace_record__snapshot_start(rec->itr))
644 return -1;
645
646 record__read_auxtrace_snapshot(rec, true);
647 if (trigger_is_error(&auxtrace_snapshot_trigger))
648 return -1;
649
650 return 0;
651}
652
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200653static int record__auxtrace_init(struct record *rec)
654{
655 int err;
656
657 if (!rec->itr) {
658 rec->itr = auxtrace_record__init(rec->evlist, &err);
659 if (err)
660 return err;
661 }
662
663 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
664 rec->opts.auxtrace_snapshot_opts);
665 if (err)
666 return err;
667
668 return auxtrace_parse_filters(rec->evlist);
669}
670
Adrian Huntere31f0d02015-04-30 17:37:27 +0300671#else
672
673static inline
674int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
Jiri Olsaa5830532019-07-27 20:30:53 +0200675 struct mmap *map __maybe_unused)
Adrian Huntere31f0d02015-04-30 17:37:27 +0300676{
677 return 0;
678}
679
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300680static inline
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300681void record__read_auxtrace_snapshot(struct record *rec __maybe_unused,
682 bool on_exit __maybe_unused)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300683{
684}
685
686static inline
687int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
688{
689 return 0;
690}
691
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300692static inline
693int record__auxtrace_snapshot_exit(struct record *rec __maybe_unused)
694{
695 return 0;
696}
697
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200698static int record__auxtrace_init(struct record *rec __maybe_unused)
699{
700 return 0;
701}
702
Adrian Huntere31f0d02015-04-30 17:37:27 +0300703#endif
704
Adrian Huntereeb399b2019-10-04 11:31:21 +0300705static bool record__kcore_readable(struct machine *machine)
706{
707 char kcore[PATH_MAX];
708 int fd;
709
710 scnprintf(kcore, sizeof(kcore), "%s/proc/kcore", machine->root_dir);
711
712 fd = open(kcore, O_RDONLY);
713 if (fd < 0)
714 return false;
715
716 close(fd);
717
718 return true;
719}
720
721static int record__kcore_copy(struct machine *machine, struct perf_data *data)
722{
723 char from_dir[PATH_MAX];
724 char kcore_dir[PATH_MAX];
725 int ret;
726
727 snprintf(from_dir, sizeof(from_dir), "%s/proc", machine->root_dir);
728
729 ret = perf_data__make_kcore_dir(data, kcore_dir, sizeof(kcore_dir));
730 if (ret)
731 return ret;
732
733 return kcore_copy(from_dir, kcore_dir);
734}
735
Wang Nancda57a82016-06-27 10:24:03 +0000736static int record__mmap_evlist(struct record *rec,
Jiri Olsa63503db2019-07-21 13:23:52 +0200737 struct evlist *evlist)
Wang Nancda57a82016-06-27 10:24:03 +0000738{
739 struct record_opts *opts = &rec->opts;
740 char msg[512];
741
Alexey Budankovf13de662019-01-22 20:50:57 +0300742 if (opts->affinity != PERF_AFFINITY_SYS)
743 cpu__setup_cpunode_map();
744
Jiri Olsa9521b5f2019-07-28 12:45:35 +0200745 if (evlist__mmap_ex(evlist, opts->mmap_pages,
Wang Nancda57a82016-06-27 10:24:03 +0000746 opts->auxtrace_mmap_pages,
Alexey Budankov9d2ed642019-01-22 20:47:43 +0300747 opts->auxtrace_snapshot_mode,
Alexey Budankov470530b2019-03-18 20:40:26 +0300748 opts->nr_cblocks, opts->affinity,
Alexey Budankov51255a82019-03-18 20:42:19 +0300749 opts->mmap_flush, opts->comp_level) < 0) {
Wang Nancda57a82016-06-27 10:24:03 +0000750 if (errno == EPERM) {
751 pr_err("Permission error mapping pages.\n"
752 "Consider increasing "
753 "/proc/sys/kernel/perf_event_mlock_kb,\n"
754 "or try again with a smaller value of -m/--mmap_pages.\n"
755 "(current value: %u,%u)\n",
756 opts->mmap_pages, opts->auxtrace_mmap_pages);
757 return -errno;
758 } else {
759 pr_err("failed to mmap with %d (%s)\n", errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300760 str_error_r(errno, msg, sizeof(msg)));
Wang Nancda57a82016-06-27 10:24:03 +0000761 if (errno)
762 return -errno;
763 else
764 return -EINVAL;
765 }
766 }
767 return 0;
768}
769
770static int record__mmap(struct record *rec)
771{
772 return record__mmap_evlist(rec, rec->evlist);
773}
774
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300775static int record__open(struct record *rec)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200776{
Arnaldo Carvalho de Melod6195a62017-02-13 16:45:24 -0300777 char msg[BUFSIZ];
Jiri Olsa32dcd022019-07-21 13:23:51 +0200778 struct evsel *pos;
Jiri Olsa63503db2019-07-21 13:23:52 +0200779 struct evlist *evlist = rec->evlist;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200780 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300781 struct record_opts *opts = &rec->opts;
David Ahern8d3eca22012-08-26 12:24:47 -0600782 int rc = 0;
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200783
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300784 /*
785 * For initial_delay we need to add a dummy event so that we can track
786 * PERF_RECORD_MMAP while we wait for the initial delay to enable the
787 * real events, the ones asked by the user.
788 */
789 if (opts->initial_delay) {
790 if (perf_evlist__add_dummy(evlist))
791 return -ENOMEM;
792
Jiri Olsa515dbe42019-09-03 10:39:52 +0200793 pos = evlist__first(evlist);
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300794 pos->tracking = 0;
Jiri Olsa515dbe42019-09-03 10:39:52 +0200795 pos = evlist__last(evlist);
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300796 pos->tracking = 1;
Jiri Olsa1fc632c2019-07-21 13:24:29 +0200797 pos->core.attr.enable_on_exec = 1;
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300798 }
799
Arnaldo Carvalho de Meloe68ae9c2016-04-11 18:15:29 -0300800 perf_evlist__config(evlist, opts, &callchain_param);
Jiri Olsacac21422012-11-12 18:34:00 +0100801
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300802 evlist__for_each_entry(evlist, pos) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200803try_again:
Jiri Olsaaf663bd2019-07-21 13:24:39 +0200804 if (evsel__open(pos, pos->core.cpus, pos->core.threads) < 0) {
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300805 if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
Namhyung Kimbb963e12017-02-17 17:17:38 +0900806 if (verbose > 0)
Arnaldo Carvalho de Meloc0a54342012-12-13 14:16:30 -0300807 ui__warning("%s\n", msg);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300808 goto try_again;
809 }
Andi Kleencf99ad12018-10-01 12:59:27 -0700810 if ((errno == EINVAL || errno == EBADF) &&
811 pos->leader != pos &&
812 pos->weak_group) {
813 pos = perf_evlist__reset_weak_group(evlist, pos);
814 goto try_again;
815 }
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300816 rc = -errno;
817 perf_evsel__open_strerror(pos, &opts->target,
818 errno, msg, sizeof(msg));
819 ui__error("%s\n", msg);
David Ahern8d3eca22012-08-26 12:24:47 -0600820 goto out;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300821 }
Andi Kleenbfd8f722017-11-17 13:42:58 -0800822
823 pos->supported = true;
Li Zefanc171b552009-10-15 11:22:07 +0800824 }
Arnaldo Carvalho de Meloa43d3f02010-12-25 12:12:25 -0200825
Arnaldo Carvalho de Meloc8b567c2019-09-23 11:07:29 -0300826 if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(evlist)) {
827 pr_warning(
828"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
829"check /proc/sys/kernel/kptr_restrict and /proc/sys/kernel/perf_event_paranoid.\n\n"
830"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
831"file is not found in the buildid cache or in the vmlinux path.\n\n"
832"Samples in kernel modules won't be resolved at all.\n\n"
833"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
834"even with a suitable vmlinux or kallsyms file.\n\n");
835 }
836
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300837 if (perf_evlist__apply_filters(evlist, &pos)) {
Arnaldo Carvalho de Melo62d94b02017-06-27 11:22:31 -0300838 pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300839 pos->filter, perf_evsel__name(pos), errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300840 str_error_r(errno, msg, sizeof(msg)));
David Ahern8d3eca22012-08-26 12:24:47 -0600841 rc = -1;
842 goto out;
Frederic Weisbecker0a102472011-02-26 04:51:54 +0100843 }
844
Wang Nancda57a82016-06-27 10:24:03 +0000845 rc = record__mmap(rec);
846 if (rc)
David Ahern8d3eca22012-08-26 12:24:47 -0600847 goto out;
Arnaldo Carvalho de Melo0a27d7f2011-01-14 15:50:51 -0200848
Jiri Olsa563aecb2013-06-05 13:35:06 +0200849 session->evlist = evlist;
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300850 perf_session__set_id_hdr_size(session);
David Ahern8d3eca22012-08-26 12:24:47 -0600851out:
852 return rc;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200853}
854
Namhyung Kime3d59112015-01-29 17:06:44 +0900855static int process_sample_event(struct perf_tool *tool,
856 union perf_event *event,
857 struct perf_sample *sample,
Jiri Olsa32dcd022019-07-21 13:23:51 +0200858 struct evsel *evsel,
Namhyung Kime3d59112015-01-29 17:06:44 +0900859 struct machine *machine)
860{
861 struct record *rec = container_of(tool, struct record, tool);
862
Jin Yao68588ba2017-12-08 21:13:42 +0800863 if (rec->evlist->first_sample_time == 0)
864 rec->evlist->first_sample_time = sample->time;
Namhyung Kime3d59112015-01-29 17:06:44 +0900865
Jin Yao68588ba2017-12-08 21:13:42 +0800866 rec->evlist->last_sample_time = sample->time;
867
868 if (rec->buildid_all)
869 return 0;
870
871 rec->samples++;
Namhyung Kime3d59112015-01-29 17:06:44 +0900872 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
873}
874
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300875static int process_buildids(struct record *rec)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200876{
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200877 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200878
Jiri Olsa45112e82019-02-21 10:41:29 +0100879 if (perf_data__size(&rec->data) == 0)
Arnaldo Carvalho de Melo9f591fd2010-03-11 15:53:11 -0300880 return 0;
881
Namhyung Kim00dc8652014-11-04 10:14:32 +0900882 /*
883 * During this process, it'll load kernel map and replace the
884 * dso->long_name to a real pathname it found. In this case
885 * we prefer the vmlinux path like
886 * /lib/modules/3.16.4/build/vmlinux
887 *
888 * rather than build-id path (in debug directory).
889 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
890 */
891 symbol_conf.ignore_vmlinux_buildid = true;
892
Namhyung Kim61566812016-01-11 22:37:09 +0900893 /*
894 * If --buildid-all is given, it marks all DSO regardless of hits,
Jin Yao68588ba2017-12-08 21:13:42 +0800895 * so no need to process samples. But if timestamp_boundary is enabled,
896 * it still needs to walk on all samples to get the timestamps of
897 * first/last samples.
Namhyung Kim61566812016-01-11 22:37:09 +0900898 */
Jin Yao68588ba2017-12-08 21:13:42 +0800899 if (rec->buildid_all && !rec->timestamp_boundary)
Namhyung Kim61566812016-01-11 22:37:09 +0900900 rec->tool.sample = NULL;
901
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300902 return perf_session__process_events(session);
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200903}
904
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200905static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800906{
907 int err;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200908 struct perf_tool *tool = data;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800909 /*
910 *As for guest kernel when processing subcommand record&report,
911 *we arrange module mmap prior to guest kernel mmap and trigger
912 *a preload dso because default guest module symbols are loaded
913 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
914 *method is used to avoid symbol missing when the first addr is
915 *in module instead of in guest kernel.
916 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200917 err = perf_event__synthesize_modules(tool, process_synthesized_event,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -0200918 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800919 if (err < 0)
920 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300921 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800922
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800923 /*
924 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
925 * have no _text sometimes.
926 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200927 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
Adrian Hunter0ae617b2014-01-29 16:14:40 +0200928 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800929 if (err < 0)
930 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -0300931 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +0800932}
933
Frederic Weisbecker98402802010-05-02 22:05:29 +0200934static struct perf_event_header finished_round_event = {
935 .size = sizeof(struct perf_event_header),
936 .type = PERF_RECORD_FINISHED_ROUND,
937};
938
Jiri Olsaa5830532019-07-27 20:30:53 +0200939static void record__adjust_affinity(struct record *rec, struct mmap *map)
Alexey Budankovf13de662019-01-22 20:50:57 +0300940{
941 if (rec->opts.affinity != PERF_AFFINITY_SYS &&
942 !CPU_EQUAL(&rec->affinity_mask, &map->affinity_mask)) {
943 CPU_ZERO(&rec->affinity_mask);
944 CPU_OR(&rec->affinity_mask, &rec->affinity_mask, &map->affinity_mask);
945 sched_setaffinity(0, sizeof(rec->affinity_mask), &rec->affinity_mask);
946 }
947}
948
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300949static size_t process_comp_header(void *record, size_t increment)
950{
Jiri Olsa72932372019-08-28 15:57:16 +0200951 struct perf_record_compressed *event = record;
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300952 size_t size = sizeof(*event);
953
954 if (increment) {
955 event->header.size += increment;
956 return increment;
957 }
958
959 event->header.type = PERF_RECORD_COMPRESSED;
960 event->header.size = size;
961
962 return size;
963}
964
965static size_t zstd_compress(struct perf_session *session, void *dst, size_t dst_size,
966 void *src, size_t src_size)
967{
968 size_t compressed;
Jiri Olsa72932372019-08-28 15:57:16 +0200969 size_t max_record_size = PERF_SAMPLE_MAX_SIZE - sizeof(struct perf_record_compressed) - 1;
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300970
971 compressed = zstd_compress_stream_to_records(&session->zstd_data, dst, dst_size, src, src_size,
972 max_record_size, process_comp_header);
973
974 session->bytes_transferred += src_size;
975 session->bytes_compressed += compressed;
976
977 return compressed;
978}
979
Jiri Olsa63503db2019-07-21 13:23:52 +0200980static int record__mmap_read_evlist(struct record *rec, struct evlist *evlist,
Alexey Budankov470530b2019-03-18 20:40:26 +0300981 bool overwrite, bool synch)
Frederic Weisbecker98402802010-05-02 22:05:29 +0200982{
Jiri Olsadcabb502014-07-25 16:56:16 +0200983 u64 bytes_written = rec->bytes_written;
Peter Zijlstra0e2e63d2010-05-20 14:45:26 +0200984 int i;
David Ahern8d3eca22012-08-26 12:24:47 -0600985 int rc = 0;
Jiri Olsaa5830532019-07-27 20:30:53 +0200986 struct mmap *maps;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300987 int trace_fd = rec->data.file.fd;
Alexey Budankovef781122019-03-18 20:44:12 +0300988 off_t off = 0;
Frederic Weisbecker98402802010-05-02 22:05:29 +0200989
Wang Nancb216862016-06-27 10:24:04 +0000990 if (!evlist)
991 return 0;
Adrian Hunteref149c22015-04-09 18:53:45 +0300992
Wang Nan0b72d692017-12-04 16:51:07 +0000993 maps = overwrite ? evlist->overwrite_mmap : evlist->mmap;
Wang Nana4ea0ec2016-07-14 08:34:36 +0000994 if (!maps)
995 return 0;
Wang Nancb216862016-06-27 10:24:04 +0000996
Wang Nan0b72d692017-12-04 16:51:07 +0000997 if (overwrite && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
Wang Nan54cc54d2016-07-14 08:34:42 +0000998 return 0;
999
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001000 if (record__aio_enabled(rec))
1001 off = record__aio_get_pos(trace_fd);
1002
Jiri Olsac976ee12019-07-30 13:04:59 +02001003 for (i = 0; i < evlist->core.nr_mmaps; i++) {
Alexey Budankov470530b2019-03-18 20:40:26 +03001004 u64 flush = 0;
Jiri Olsaa5830532019-07-27 20:30:53 +02001005 struct mmap *map = &maps[i];
Wang Nana4ea0ec2016-07-14 08:34:36 +00001006
Jiri Olsa547740f2019-07-27 22:07:44 +02001007 if (map->core.base) {
Alexey Budankovf13de662019-01-22 20:50:57 +03001008 record__adjust_affinity(rec, map);
Alexey Budankov470530b2019-03-18 20:40:26 +03001009 if (synch) {
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001010 flush = map->core.flush;
1011 map->core.flush = 1;
Alexey Budankov470530b2019-03-18 20:40:26 +03001012 }
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001013 if (!record__aio_enabled(rec)) {
Alexey Budankovef781122019-03-18 20:44:12 +03001014 if (perf_mmap__push(map, rec, record__pushfn) < 0) {
Alexey Budankov470530b2019-03-18 20:40:26 +03001015 if (synch)
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001016 map->core.flush = flush;
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001017 rc = -1;
1018 goto out;
1019 }
1020 } else {
Alexey Budankovef781122019-03-18 20:44:12 +03001021 if (record__aio_push(rec, map, &off) < 0) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001022 record__aio_set_pos(trace_fd, off);
Alexey Budankov470530b2019-03-18 20:40:26 +03001023 if (synch)
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001024 map->core.flush = flush;
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001025 rc = -1;
1026 goto out;
1027 }
David Ahern8d3eca22012-08-26 12:24:47 -06001028 }
Alexey Budankov470530b2019-03-18 20:40:26 +03001029 if (synch)
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001030 map->core.flush = flush;
David Ahern8d3eca22012-08-26 12:24:47 -06001031 }
Adrian Hunteref149c22015-04-09 18:53:45 +03001032
Jiri Olsae035f4c2018-09-13 14:54:05 +02001033 if (map->auxtrace_mmap.base && !rec->opts.auxtrace_snapshot_mode &&
1034 record__auxtrace_mmap_read(rec, map) != 0) {
Adrian Hunteref149c22015-04-09 18:53:45 +03001035 rc = -1;
1036 goto out;
1037 }
Frederic Weisbecker98402802010-05-02 22:05:29 +02001038 }
1039
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001040 if (record__aio_enabled(rec))
1041 record__aio_set_pos(trace_fd, off);
1042
Jiri Olsadcabb502014-07-25 16:56:16 +02001043 /*
1044 * Mark the round finished in case we wrote
1045 * at least one event.
1046 */
1047 if (bytes_written != rec->bytes_written)
Jiri Olsaded2b8f2018-09-13 14:54:06 +02001048 rc = record__write(rec, NULL, &finished_round_event, sizeof(finished_round_event));
David Ahern8d3eca22012-08-26 12:24:47 -06001049
Wang Nan0b72d692017-12-04 16:51:07 +00001050 if (overwrite)
Wang Nan54cc54d2016-07-14 08:34:42 +00001051 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
David Ahern8d3eca22012-08-26 12:24:47 -06001052out:
1053 return rc;
Frederic Weisbecker98402802010-05-02 22:05:29 +02001054}
1055
Alexey Budankov470530b2019-03-18 20:40:26 +03001056static int record__mmap_read_all(struct record *rec, bool synch)
Wang Nancb216862016-06-27 10:24:04 +00001057{
1058 int err;
1059
Alexey Budankov470530b2019-03-18 20:40:26 +03001060 err = record__mmap_read_evlist(rec, rec->evlist, false, synch);
Wang Nancb216862016-06-27 10:24:04 +00001061 if (err)
1062 return err;
1063
Alexey Budankov470530b2019-03-18 20:40:26 +03001064 return record__mmap_read_evlist(rec, rec->evlist, true, synch);
Wang Nancb216862016-06-27 10:24:04 +00001065}
1066
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001067static void record__init_features(struct record *rec)
David Ahern57706ab2013-11-06 11:41:34 -07001068{
David Ahern57706ab2013-11-06 11:41:34 -07001069 struct perf_session *session = rec->session;
1070 int feat;
1071
1072 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
1073 perf_header__set_feat(&session->header, feat);
1074
1075 if (rec->no_buildid)
1076 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
1077
Jiri Olsace9036a2019-07-21 13:24:23 +02001078 if (!have_tracepoints(&rec->evlist->core.entries))
David Ahern57706ab2013-11-06 11:41:34 -07001079 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
1080
1081 if (!rec->opts.branch_stack)
1082 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
Adrian Hunteref149c22015-04-09 18:53:45 +03001083
1084 if (!rec->opts.full_auxtrace)
1085 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
Jiri Olsaffa517a2015-10-25 15:51:43 +01001086
Alexey Budankovcf790512018-10-09 17:36:24 +03001087 if (!(rec->opts.use_clockid && rec->opts.clockid_res_ns))
1088 perf_header__clear_feat(&session->header, HEADER_CLOCKID);
1089
Jiri Olsa258031c2019-03-08 14:47:39 +01001090 perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT);
Alexey Budankov42e1fd82019-03-18 20:41:33 +03001091 if (!record__comp_enabled(rec))
1092 perf_header__clear_feat(&session->header, HEADER_COMPRESSED);
Jiri Olsa258031c2019-03-08 14:47:39 +01001093
Jiri Olsaffa517a2015-10-25 15:51:43 +01001094 perf_header__clear_feat(&session->header, HEADER_STAT);
David Ahern57706ab2013-11-06 11:41:34 -07001095}
1096
Wang Nane1ab48b2016-02-26 09:32:10 +00001097static void
1098record__finish_output(struct record *rec)
1099{
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001100 struct perf_data *data = &rec->data;
1101 int fd = perf_data__fd(data);
Wang Nane1ab48b2016-02-26 09:32:10 +00001102
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001103 if (data->is_pipe)
Wang Nane1ab48b2016-02-26 09:32:10 +00001104 return;
1105
1106 rec->session->header.data_size += rec->bytes_written;
Jiri Olsa45112e82019-02-21 10:41:29 +01001107 data->file.size = lseek(perf_data__fd(data), 0, SEEK_CUR);
Wang Nane1ab48b2016-02-26 09:32:10 +00001108
1109 if (!rec->no_buildid) {
1110 process_buildids(rec);
1111
1112 if (rec->buildid_all)
1113 dsos__hit_all(rec->session);
1114 }
1115 perf_session__write_header(rec->session, rec->evlist, fd, true);
1116
1117 return;
1118}
1119
Wang Nan4ea648a2016-07-14 08:34:47 +00001120static int record__synthesize_workload(struct record *rec, bool tail)
Wang Nanbe7b0c92016-04-20 18:59:54 +00001121{
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -03001122 int err;
Jiri Olsa9749b902019-07-21 13:23:50 +02001123 struct perf_thread_map *thread_map;
Wang Nanbe7b0c92016-04-20 18:59:54 +00001124
Wang Nan4ea648a2016-07-14 08:34:47 +00001125 if (rec->opts.tail_synthesize != tail)
1126 return 0;
1127
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -03001128 thread_map = thread_map__new_by_tid(rec->evlist->workload.pid);
1129 if (thread_map == NULL)
1130 return -1;
1131
1132 err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
Wang Nanbe7b0c92016-04-20 18:59:54 +00001133 process_synthesized_event,
1134 &rec->session->machines.host,
Mark Drayton3fcb10e2018-12-04 12:34:20 -08001135 rec->opts.sample_address);
Jiri Olsa7836e522019-07-21 13:24:20 +02001136 perf_thread_map__put(thread_map);
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -03001137 return err;
Wang Nanbe7b0c92016-04-20 18:59:54 +00001138}
1139
Wang Nan4ea648a2016-07-14 08:34:47 +00001140static int record__synthesize(struct record *rec, bool tail);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001141
Wang Nanecfd7a92016-04-13 08:21:07 +00001142static int
1143record__switch_output(struct record *rec, bool at_exit)
1144{
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001145 struct perf_data *data = &rec->data;
Wang Nanecfd7a92016-04-13 08:21:07 +00001146 int fd, err;
Andi Kleen03724b22019-03-14 15:49:55 -07001147 char *new_filename;
Wang Nanecfd7a92016-04-13 08:21:07 +00001148
1149 /* Same Size: "2015122520103046"*/
1150 char timestamp[] = "InvalidTimestamp";
1151
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001152 record__aio_mmap_read_sync(rec);
1153
Wang Nan4ea648a2016-07-14 08:34:47 +00001154 record__synthesize(rec, true);
1155 if (target__none(&rec->opts.target))
1156 record__synthesize_workload(rec, true);
1157
Wang Nanecfd7a92016-04-13 08:21:07 +00001158 rec->samples = 0;
1159 record__finish_output(rec);
1160 err = fetch_current_timestamp(timestamp, sizeof(timestamp));
1161 if (err) {
1162 pr_err("Failed to get current timestamp\n");
1163 return -EINVAL;
1164 }
1165
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001166 fd = perf_data__switch(data, timestamp,
Wang Nanecfd7a92016-04-13 08:21:07 +00001167 rec->session->header.data_offset,
Andi Kleen03724b22019-03-14 15:49:55 -07001168 at_exit, &new_filename);
Wang Nanecfd7a92016-04-13 08:21:07 +00001169 if (fd >= 0 && !at_exit) {
1170 rec->bytes_written = 0;
1171 rec->session->header.data_size = 0;
1172 }
1173
1174 if (!quiet)
1175 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
Jiri Olsa2d4f2792019-02-21 10:41:30 +01001176 data->path, timestamp);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001177
Andi Kleen03724b22019-03-14 15:49:55 -07001178 if (rec->switch_output.num_files) {
1179 int n = rec->switch_output.cur_file + 1;
1180
1181 if (n >= rec->switch_output.num_files)
1182 n = 0;
1183 rec->switch_output.cur_file = n;
1184 if (rec->switch_output.filenames[n]) {
1185 remove(rec->switch_output.filenames[n]);
Arnaldo Carvalho de Melod8f9da22019-07-04 12:06:20 -03001186 zfree(&rec->switch_output.filenames[n]);
Andi Kleen03724b22019-03-14 15:49:55 -07001187 }
1188 rec->switch_output.filenames[n] = new_filename;
1189 } else {
1190 free(new_filename);
1191 }
1192
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001193 /* Output tracking events */
Wang Nanbe7b0c92016-04-20 18:59:54 +00001194 if (!at_exit) {
Wang Nan4ea648a2016-07-14 08:34:47 +00001195 record__synthesize(rec, false);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001196
Wang Nanbe7b0c92016-04-20 18:59:54 +00001197 /*
1198 * In 'perf record --switch-output' without -a,
1199 * record__synthesize() in record__switch_output() won't
1200 * generate tracking events because there's no thread_map
1201 * in evlist. Which causes newly created perf.data doesn't
1202 * contain map and comm information.
1203 * Create a fake thread_map and directly call
1204 * perf_event__synthesize_thread_map() for those events.
1205 */
1206 if (target__none(&rec->opts.target))
Wang Nan4ea648a2016-07-14 08:34:47 +00001207 record__synthesize_workload(rec, false);
Wang Nanbe7b0c92016-04-20 18:59:54 +00001208 }
Wang Nanecfd7a92016-04-13 08:21:07 +00001209 return fd;
1210}
1211
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001212static volatile int workload_exec_errno;
1213
1214/*
1215 * perf_evlist__prepare_workload will send a SIGUSR1
1216 * if the fork fails, since we asked by setting its
1217 * want_signal to true.
1218 */
Namhyung Kim45604712014-05-12 09:47:24 +09001219static void workload_exec_failed_signal(int signo __maybe_unused,
1220 siginfo_t *info,
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001221 void *ucontext __maybe_unused)
1222{
1223 workload_exec_errno = info->si_value.sival_int;
1224 done = 1;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001225 child_finished = 1;
1226}
1227
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001228static void snapshot_sig_handler(int sig);
Jiri Olsabfacbe32017-01-09 10:52:00 +01001229static void alarm_sig_handler(int sig);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001230
Wang Nanee667f92016-06-27 10:24:05 +00001231static const struct perf_event_mmap_page *
Jiri Olsa63503db2019-07-21 13:23:52 +02001232perf_evlist__pick_pc(struct evlist *evlist)
Wang Nanee667f92016-06-27 10:24:05 +00001233{
Wang Nanb2cb6152016-07-14 08:34:39 +00001234 if (evlist) {
Jiri Olsa547740f2019-07-27 22:07:44 +02001235 if (evlist->mmap && evlist->mmap[0].core.base)
1236 return evlist->mmap[0].core.base;
1237 if (evlist->overwrite_mmap && evlist->overwrite_mmap[0].core.base)
1238 return evlist->overwrite_mmap[0].core.base;
Wang Nanb2cb6152016-07-14 08:34:39 +00001239 }
Wang Nanee667f92016-06-27 10:24:05 +00001240 return NULL;
1241}
1242
Wang Nanc45628b2016-05-24 02:28:59 +00001243static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
1244{
Wang Nanee667f92016-06-27 10:24:05 +00001245 const struct perf_event_mmap_page *pc;
1246
1247 pc = perf_evlist__pick_pc(rec->evlist);
1248 if (pc)
1249 return pc;
Wang Nanc45628b2016-05-24 02:28:59 +00001250 return NULL;
1251}
1252
Wang Nan4ea648a2016-07-14 08:34:47 +00001253static int record__synthesize(struct record *rec, bool tail)
Wang Nanc45c86e2016-02-26 09:32:07 +00001254{
1255 struct perf_session *session = rec->session;
1256 struct machine *machine = &session->machines.host;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001257 struct perf_data *data = &rec->data;
Wang Nanc45c86e2016-02-26 09:32:07 +00001258 struct record_opts *opts = &rec->opts;
1259 struct perf_tool *tool = &rec->tool;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001260 int fd = perf_data__fd(data);
Wang Nanc45c86e2016-02-26 09:32:07 +00001261 int err = 0;
1262
Wang Nan4ea648a2016-07-14 08:34:47 +00001263 if (rec->opts.tail_synthesize != tail)
1264 return 0;
1265
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001266 if (data->is_pipe) {
Jiri Olsaa2015512018-03-14 10:22:04 +01001267 /*
1268 * We need to synthesize events first, because some
1269 * features works on top of them (on report side).
1270 */
Jiri Olsa318ec182018-08-30 08:32:15 +02001271 err = perf_event__synthesize_attrs(tool, rec->evlist,
Wang Nanc45c86e2016-02-26 09:32:07 +00001272 process_synthesized_event);
1273 if (err < 0) {
1274 pr_err("Couldn't synthesize attrs.\n");
1275 goto out;
1276 }
1277
Jiri Olsaa2015512018-03-14 10:22:04 +01001278 err = perf_event__synthesize_features(tool, session, rec->evlist,
1279 process_synthesized_event);
1280 if (err < 0) {
1281 pr_err("Couldn't synthesize features.\n");
1282 return err;
1283 }
1284
Jiri Olsace9036a2019-07-21 13:24:23 +02001285 if (have_tracepoints(&rec->evlist->core.entries)) {
Wang Nanc45c86e2016-02-26 09:32:07 +00001286 /*
1287 * FIXME err <= 0 here actually means that
1288 * there were no tracepoints so its not really
1289 * an error, just that we don't need to
1290 * synthesize anything. We really have to
1291 * return this more properly and also
1292 * propagate errors that now are calling die()
1293 */
1294 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
1295 process_synthesized_event);
1296 if (err <= 0) {
1297 pr_err("Couldn't record tracing data.\n");
1298 goto out;
1299 }
1300 rec->bytes_written += err;
1301 }
1302 }
1303
Wang Nanc45628b2016-05-24 02:28:59 +00001304 err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
Adrian Hunter46bc29b2016-03-08 10:38:44 +02001305 process_synthesized_event, machine);
1306 if (err)
1307 goto out;
1308
Wang Nanc45c86e2016-02-26 09:32:07 +00001309 if (rec->opts.full_auxtrace) {
1310 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
1311 session, process_synthesized_event);
1312 if (err)
1313 goto out;
1314 }
1315
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03001316 if (!perf_evlist__exclude_kernel(rec->evlist)) {
1317 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
1318 machine);
1319 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
1320 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
1321 "Check /proc/kallsyms permission or run as root.\n");
Wang Nanc45c86e2016-02-26 09:32:07 +00001322
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03001323 err = perf_event__synthesize_modules(tool, process_synthesized_event,
1324 machine);
1325 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
1326 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
1327 "Check /proc/modules permission or run as root.\n");
1328 }
Wang Nanc45c86e2016-02-26 09:32:07 +00001329
1330 if (perf_guest) {
1331 machines__process_guests(&session->machines,
1332 perf_event__synthesize_guest_os, tool);
1333 }
1334
Andi Kleenbfd8f722017-11-17 13:42:58 -08001335 err = perf_event__synthesize_extra_attr(&rec->tool,
1336 rec->evlist,
1337 process_synthesized_event,
1338 data->is_pipe);
1339 if (err)
1340 goto out;
1341
Jiri Olsa03617c22019-07-21 13:24:42 +02001342 err = perf_event__synthesize_thread_map2(&rec->tool, rec->evlist->core.threads,
Andi Kleen373565d2017-11-17 13:42:59 -08001343 process_synthesized_event,
1344 NULL);
1345 if (err < 0) {
1346 pr_err("Couldn't synthesize thread map.\n");
1347 return err;
1348 }
1349
Jiri Olsaf72f9012019-07-21 13:24:41 +02001350 err = perf_event__synthesize_cpu_map(&rec->tool, rec->evlist->core.cpus,
Andi Kleen373565d2017-11-17 13:42:59 -08001351 process_synthesized_event, NULL);
1352 if (err < 0) {
1353 pr_err("Couldn't synthesize cpu map.\n");
1354 return err;
1355 }
1356
Song Liue5416952019-03-11 22:30:41 -07001357 err = perf_event__synthesize_bpf_events(session, process_synthesized_event,
Song Liu7b612e22019-01-17 08:15:19 -08001358 machine, opts);
1359 if (err < 0)
1360 pr_warning("Couldn't synthesize bpf events.\n");
1361
Jiri Olsa03617c22019-07-21 13:24:42 +02001362 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->core.threads,
Wang Nanc45c86e2016-02-26 09:32:07 +00001363 process_synthesized_event, opts->sample_address,
Mark Drayton3fcb10e2018-12-04 12:34:20 -08001364 1);
Wang Nanc45c86e2016-02-26 09:32:07 +00001365out:
1366 return err;
1367}
1368
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001369static int __cmd_record(struct record *rec, int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +02001370{
David Ahern57706ab2013-11-06 11:41:34 -07001371 int err;
Namhyung Kim45604712014-05-12 09:47:24 +09001372 int status = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001373 unsigned long waking = 0;
Zhang, Yanmin46be6042010-03-18 11:36:04 -03001374 const bool forks = argc > 0;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001375 struct perf_tool *tool = &rec->tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001376 struct record_opts *opts = &rec->opts;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001377 struct perf_data *data = &rec->data;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001378 struct perf_session *session;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001379 bool disabled = false, draining = false;
Jiri Olsa63503db2019-07-21 13:23:52 +02001380 struct evlist *sb_evlist = NULL;
Namhyung Kim42aa2762015-01-29 17:06:48 +09001381 int fd;
Alexey Budankovd3c8c082019-03-18 20:41:02 +03001382 float ratio = 0;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001383
Namhyung Kim45604712014-05-12 09:47:24 +09001384 atexit(record__sig_exit);
Peter Zijlstraf5970552009-06-18 23:22:55 +02001385 signal(SIGCHLD, sig_handler);
1386 signal(SIGINT, sig_handler);
David Ahern804f7ac2013-05-06 12:24:23 -06001387 signal(SIGTERM, sig_handler);
Wang Nana0748652016-11-26 07:03:28 +00001388 signal(SIGSEGV, sigsegv_handler);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001389
Hari Bathinif3b36142017-03-08 02:11:43 +05301390 if (rec->opts.record_namespaces)
1391 tool->namespace_events = true;
1392
Jiri Olsadc0c6122017-01-09 10:51:58 +01001393 if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001394 signal(SIGUSR2, snapshot_sig_handler);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001395 if (rec->opts.auxtrace_snapshot_mode)
1396 trigger_on(&auxtrace_snapshot_trigger);
Jiri Olsadc0c6122017-01-09 10:51:58 +01001397 if (rec->switch_output.enabled)
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001398 trigger_on(&switch_output_trigger);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001399 } else {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001400 signal(SIGUSR2, SIG_IGN);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001401 }
Peter Zijlstraf5970552009-06-18 23:22:55 +02001402
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001403 session = perf_session__new(data, false, tool);
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +05301404 if (IS_ERR(session)) {
Adrien BAKffa91882014-04-18 11:00:43 +09001405 pr_err("Perf session creation failed.\n");
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +05301406 return PTR_ERR(session);
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -02001407 }
1408
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001409 fd = perf_data__fd(data);
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001410 rec->session = session;
1411
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001412 if (zstd_init(&session->zstd_data, rec->opts.comp_level) < 0) {
1413 pr_err("Compression initialization failed.\n");
1414 return -1;
1415 }
1416
1417 session->header.env.comp_type = PERF_COMP_ZSTD;
1418 session->header.env.comp_level = rec->opts.comp_level;
1419
Adrian Huntereeb399b2019-10-04 11:31:21 +03001420 if (rec->opts.kcore &&
1421 !record__kcore_readable(&session->machines.host)) {
1422 pr_err("ERROR: kcore is not readable.\n");
1423 return -1;
1424 }
1425
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001426 record__init_features(rec);
Stephane Eranian330aa672012-03-08 23:47:46 +01001427
Alexey Budankovcf790512018-10-09 17:36:24 +03001428 if (rec->opts.use_clockid && rec->opts.clockid_res_ns)
1429 session->header.env.clockid_res_ns = rec->opts.clockid_res_ns;
1430
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -02001431 if (forks) {
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001432 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001433 argv, data->is_pipe,
Arnaldo Carvalho de Melo735f7e02014-01-03 14:56:49 -03001434 workload_exec_failed_signal);
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -02001435 if (err < 0) {
1436 pr_err("Couldn't run the workload!\n");
Namhyung Kim45604712014-05-12 09:47:24 +09001437 status = err;
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -02001438 goto out_delete_session;
Jens Axboe0a5ac842009-08-12 11:18:01 +02001439 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001440 }
1441
Jiri Olsaad46e48c2018-03-02 17:13:54 +01001442 /*
1443 * If we have just single event and are sending data
1444 * through pipe, we need to force the ids allocation,
1445 * because we synthesize event name through the pipe
1446 * and need the id for that.
1447 */
Jiri Olsa6484d2f2019-07-21 13:24:28 +02001448 if (data->is_pipe && rec->evlist->core.nr_entries == 1)
Jiri Olsaad46e48c2018-03-02 17:13:54 +01001449 rec->opts.sample_id = true;
1450
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001451 if (record__open(rec) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -06001452 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001453 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001454 }
Jiri Olsaf6fa4372019-08-06 15:14:05 +02001455 session->header.env.comp_mmap_len = session->evlist->core.mmap_len;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001456
Adrian Huntereeb399b2019-10-04 11:31:21 +03001457 if (rec->opts.kcore) {
1458 err = record__kcore_copy(&session->machines.host, data);
1459 if (err) {
1460 pr_err("ERROR: Failed to copy kcore\n");
1461 goto out_child;
1462 }
1463 }
1464
Wang Nan8690a2a2016-02-22 09:10:32 +00001465 err = bpf__apply_obj_config();
1466 if (err) {
1467 char errbuf[BUFSIZ];
1468
1469 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
1470 pr_err("ERROR: Apply config to BPF failed: %s\n",
1471 errbuf);
1472 goto out_child;
1473 }
1474
Adrian Huntercca84822015-08-19 17:29:21 +03001475 /*
1476 * Normally perf_session__new would do this, but it doesn't have the
1477 * evlist.
1478 */
1479 if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
1480 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
1481 rec->tool.ordered_events = false;
1482 }
1483
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001484 if (!rec->evlist->nr_groups)
Namhyung Kima8bb5592013-01-22 18:09:31 +09001485 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
1486
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001487 if (data->is_pipe) {
Namhyung Kim42aa2762015-01-29 17:06:48 +09001488 err = perf_header__write_pipe(fd);
Tom Zanussi529870e2010-04-01 23:59:16 -05001489 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001490 goto out_child;
Jiri Olsa563aecb2013-06-05 13:35:06 +02001491 } else {
Namhyung Kim42aa2762015-01-29 17:06:48 +09001492 err = perf_session__write_header(session, rec->evlist, fd, false);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001493 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001494 goto out_child;
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001495 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001496
David Ahernd3665492012-02-06 15:27:52 -07001497 if (!rec->no_buildid
Robert Richtere20960c2011-12-07 10:02:55 +01001498 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
David Ahernd3665492012-02-06 15:27:52 -07001499 pr_err("Couldn't generate buildids. "
Robert Richtere20960c2011-12-07 10:02:55 +01001500 "Use --no-buildid to profile anyway.\n");
David Ahern8d3eca22012-08-26 12:24:47 -06001501 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001502 goto out_child;
Robert Richtere20960c2011-12-07 10:02:55 +01001503 }
1504
Song Liud56354d2019-03-11 22:30:51 -07001505 if (!opts->no_bpf_event)
1506 bpf_event__add_sb_event(&sb_evlist, &session->header.env);
1507
Song Liu657ee552019-03-11 22:30:50 -07001508 if (perf_evlist__start_sb_thread(sb_evlist, &rec->opts.target)) {
1509 pr_debug("Couldn't start the BPF side band thread:\nBPF programs starting from now on won't be annotatable\n");
1510 opts->no_bpf_event = true;
1511 }
1512
Wang Nan4ea648a2016-07-14 08:34:47 +00001513 err = record__synthesize(rec, false);
Wang Nanc45c86e2016-02-26 09:32:07 +00001514 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001515 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001516
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001517 if (rec->realtime_prio) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001518 struct sched_param param;
1519
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001520 param.sched_priority = rec->realtime_prio;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001521 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -02001522 pr_err("Could not set realtime priority.\n");
David Ahern8d3eca22012-08-26 12:24:47 -06001523 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001524 goto out_child;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001525 }
1526 }
1527
Jiri Olsa774cb492012-11-12 18:34:01 +01001528 /*
1529 * When perf is starting the traced process, all the events
1530 * (apart from group members) have enable_on_exec=1 set,
1531 * so don't spoil it by prematurely enabling them.
1532 */
Andi Kleen6619a532014-01-11 13:38:27 -08001533 if (!target__none(&opts->target) && !opts->initial_delay)
Jiri Olsa1c87f162019-07-21 13:24:08 +02001534 evlist__enable(rec->evlist);
David Ahern764e16a32011-08-25 10:17:55 -06001535
Peter Zijlstra856e9662009-12-16 17:55:55 +01001536 /*
1537 * Let the child rip
1538 */
Namhyung Kime803cf92015-09-22 09:24:55 +09001539 if (forks) {
Jiri Olsa20a8a3c2018-03-07 16:50:04 +01001540 struct machine *machine = &session->machines.host;
Namhyung Kime5bed562015-09-30 10:45:24 +09001541 union perf_event *event;
Hari Bathinie907caf2017-03-08 02:11:51 +05301542 pid_t tgid;
Namhyung Kime5bed562015-09-30 10:45:24 +09001543
1544 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
1545 if (event == NULL) {
1546 err = -ENOMEM;
1547 goto out_child;
1548 }
1549
Namhyung Kime803cf92015-09-22 09:24:55 +09001550 /*
1551 * Some H/W events are generated before COMM event
1552 * which is emitted during exec(), so perf script
1553 * cannot see a correct process name for those events.
1554 * Synthesize COMM event to prevent it.
1555 */
Hari Bathinie907caf2017-03-08 02:11:51 +05301556 tgid = perf_event__synthesize_comm(tool, event,
1557 rec->evlist->workload.pid,
1558 process_synthesized_event,
1559 machine);
1560 free(event);
1561
1562 if (tgid == -1)
1563 goto out_child;
1564
1565 event = malloc(sizeof(event->namespaces) +
1566 (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
1567 machine->id_hdr_size);
1568 if (event == NULL) {
1569 err = -ENOMEM;
1570 goto out_child;
1571 }
1572
1573 /*
1574 * Synthesize NAMESPACES event for the command specified.
1575 */
1576 perf_event__synthesize_namespaces(tool, event,
1577 rec->evlist->workload.pid,
1578 tgid, process_synthesized_event,
1579 machine);
Namhyung Kime5bed562015-09-30 10:45:24 +09001580 free(event);
Namhyung Kime803cf92015-09-22 09:24:55 +09001581
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001582 perf_evlist__start_workload(rec->evlist);
Namhyung Kime803cf92015-09-22 09:24:55 +09001583 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001584
Andi Kleen6619a532014-01-11 13:38:27 -08001585 if (opts->initial_delay) {
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -03001586 usleep(opts->initial_delay * USEC_PER_MSEC);
Jiri Olsa1c87f162019-07-21 13:24:08 +02001587 evlist__enable(rec->evlist);
Andi Kleen6619a532014-01-11 13:38:27 -08001588 }
1589
Wang Nan5f9cf592016-04-20 18:59:49 +00001590 trigger_ready(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001591 trigger_ready(&switch_output_trigger);
Wang Nana0748652016-11-26 07:03:28 +00001592 perf_hooks__invoke_record_start();
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001593 for (;;) {
Yang Shi9f065192015-09-29 14:49:43 -07001594 unsigned long long hits = rec->samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001595
Wang Nan057374642016-07-14 08:34:43 +00001596 /*
1597 * rec->evlist->bkw_mmap_state is possible to be
1598 * BKW_MMAP_EMPTY here: when done == true and
1599 * hits != rec->samples in previous round.
1600 *
1601 * perf_evlist__toggle_bkw_mmap ensure we never
1602 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
1603 */
1604 if (trigger_is_hit(&switch_output_trigger) || done || draining)
1605 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
1606
Alexey Budankov470530b2019-03-18 20:40:26 +03001607 if (record__mmap_read_all(rec, false) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001608 trigger_error(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001609 trigger_error(&switch_output_trigger);
David Ahern8d3eca22012-08-26 12:24:47 -06001610 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001611 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001612 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001613
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001614 if (auxtrace_record__snapshot_started) {
1615 auxtrace_record__snapshot_started = 0;
Wang Nan5f9cf592016-04-20 18:59:49 +00001616 if (!trigger_is_error(&auxtrace_snapshot_trigger))
Alexander Shishkince7b0e42019-08-06 17:41:01 +03001617 record__read_auxtrace_snapshot(rec, false);
Wang Nan5f9cf592016-04-20 18:59:49 +00001618 if (trigger_is_error(&auxtrace_snapshot_trigger)) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001619 pr_err("AUX area tracing snapshot failed\n");
1620 err = -1;
1621 goto out_child;
1622 }
1623 }
1624
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001625 if (trigger_is_hit(&switch_output_trigger)) {
Wang Nan057374642016-07-14 08:34:43 +00001626 /*
1627 * If switch_output_trigger is hit, the data in
1628 * overwritable ring buffer should have been collected,
1629 * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
1630 *
1631 * If SIGUSR2 raise after or during record__mmap_read_all(),
1632 * record__mmap_read_all() didn't collect data from
1633 * overwritable ring buffer. Read again.
1634 */
1635 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
1636 continue;
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001637 trigger_ready(&switch_output_trigger);
1638
Wang Nan057374642016-07-14 08:34:43 +00001639 /*
1640 * Reenable events in overwrite ring buffer after
1641 * record__mmap_read_all(): we should have collected
1642 * data from it.
1643 */
1644 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1645
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001646 if (!quiet)
1647 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1648 waking);
1649 waking = 0;
1650 fd = record__switch_output(rec, false);
1651 if (fd < 0) {
1652 pr_err("Failed to switch to new file\n");
1653 trigger_error(&switch_output_trigger);
1654 err = fd;
1655 goto out_child;
1656 }
Jiri Olsabfacbe32017-01-09 10:52:00 +01001657
1658 /* re-arm the alarm */
1659 if (rec->switch_output.time)
1660 alarm(rec->switch_output.time);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001661 }
1662
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001663 if (hits == rec->samples) {
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001664 if (done || draining)
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001665 break;
Jiri Olsa80ab2982019-08-31 22:48:33 +02001666 err = evlist__poll(rec->evlist, -1);
Jiri Olsaa5151142014-06-02 13:44:23 -04001667 /*
1668 * Propagate error, only if there's any. Ignore positive
1669 * number of returned events and interrupt error.
1670 */
1671 if (err > 0 || (err < 0 && errno == EINTR))
Namhyung Kim45604712014-05-12 09:47:24 +09001672 err = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001673 waking++;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001674
Jiri Olsaf4009e72019-08-16 16:00:45 +02001675 if (evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001676 draining = true;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001677 }
1678
Jiri Olsa774cb492012-11-12 18:34:01 +01001679 /*
1680 * When perf is starting the traced process, at the end events
1681 * die with the process and we wait for that. Thus no need to
1682 * disable events in this case.
1683 */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001684 if (done && !disabled && !target__none(&opts->target)) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001685 trigger_off(&auxtrace_snapshot_trigger);
Jiri Olsae74676d2019-07-21 13:24:09 +02001686 evlist__disable(rec->evlist);
Jiri Olsa27119262012-11-12 18:34:02 +01001687 disabled = true;
1688 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001689 }
Alexander Shishkince7b0e42019-08-06 17:41:01 +03001690
Wang Nan5f9cf592016-04-20 18:59:49 +00001691 trigger_off(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001692 trigger_off(&switch_output_trigger);
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001693
Alexander Shishkince7b0e42019-08-06 17:41:01 +03001694 if (opts->auxtrace_snapshot_on_exit)
1695 record__auxtrace_snapshot_exit(rec);
1696
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001697 if (forks && workload_exec_errno) {
Masami Hiramatsu35550da2014-08-14 02:22:43 +00001698 char msg[STRERR_BUFSIZE];
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -03001699 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001700 pr_err("Workload failed: %s\n", emsg);
1701 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001702 goto out_child;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001703 }
1704
Namhyung Kime3d59112015-01-29 17:06:44 +09001705 if (!quiet)
Namhyung Kim45604712014-05-12 09:47:24 +09001706 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001707
Wang Nan4ea648a2016-07-14 08:34:47 +00001708 if (target__none(&rec->opts.target))
1709 record__synthesize_workload(rec, true);
1710
Namhyung Kim45604712014-05-12 09:47:24 +09001711out_child:
Alexey Budankov470530b2019-03-18 20:40:26 +03001712 record__mmap_read_all(rec, true);
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001713 record__aio_mmap_read_sync(rec);
1714
Alexey Budankovd3c8c082019-03-18 20:41:02 +03001715 if (rec->session->bytes_transferred && rec->session->bytes_compressed) {
1716 ratio = (float)rec->session->bytes_transferred/(float)rec->session->bytes_compressed;
1717 session->header.env.comp_ratio = ratio + 0.5;
1718 }
1719
Namhyung Kim45604712014-05-12 09:47:24 +09001720 if (forks) {
1721 int exit_status;
Ingo Molnaraddc2782009-06-02 23:43:11 +02001722
Namhyung Kim45604712014-05-12 09:47:24 +09001723 if (!child_finished)
1724 kill(rec->evlist->workload.pid, SIGTERM);
1725
1726 wait(&exit_status);
1727
1728 if (err < 0)
1729 status = err;
1730 else if (WIFEXITED(exit_status))
1731 status = WEXITSTATUS(exit_status);
1732 else if (WIFSIGNALED(exit_status))
1733 signr = WTERMSIG(exit_status);
1734 } else
1735 status = err;
1736
Wang Nan4ea648a2016-07-14 08:34:47 +00001737 record__synthesize(rec, true);
Namhyung Kime3d59112015-01-29 17:06:44 +09001738 /* this will be recalculated during process_buildids() */
1739 rec->samples = 0;
1740
Wang Nanecfd7a92016-04-13 08:21:07 +00001741 if (!err) {
1742 if (!rec->timestamp_filename) {
1743 record__finish_output(rec);
1744 } else {
1745 fd = record__switch_output(rec, true);
1746 if (fd < 0) {
1747 status = fd;
1748 goto out_delete_session;
1749 }
1750 }
1751 }
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001752
Wang Nana0748652016-11-26 07:03:28 +00001753 perf_hooks__invoke_record_end();
1754
Namhyung Kime3d59112015-01-29 17:06:44 +09001755 if (!err && !quiet) {
1756 char samples[128];
Wang Nanecfd7a92016-04-13 08:21:07 +00001757 const char *postfix = rec->timestamp_filename ?
1758 ".<timestamp>" : "";
Namhyung Kime3d59112015-01-29 17:06:44 +09001759
Adrian Hunteref149c22015-04-09 18:53:45 +03001760 if (rec->samples && !rec->opts.full_auxtrace)
Namhyung Kime3d59112015-01-29 17:06:44 +09001761 scnprintf(samples, sizeof(samples),
1762 " (%" PRIu64 " samples)", rec->samples);
1763 else
1764 samples[0] = '\0';
1765
Alexey Budankovd3c8c082019-03-18 20:41:02 +03001766 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s",
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001767 perf_data__size(data) / 1024.0 / 1024.0,
Jiri Olsa2d4f2792019-02-21 10:41:30 +01001768 data->path, postfix, samples);
Alexey Budankovd3c8c082019-03-18 20:41:02 +03001769 if (ratio) {
1770 fprintf(stderr, ", compressed (original %.3f MB, ratio is %.3f)",
1771 rec->session->bytes_transferred / 1024.0 / 1024.0,
1772 ratio);
1773 }
1774 fprintf(stderr, " ]\n");
Namhyung Kime3d59112015-01-29 17:06:44 +09001775 }
1776
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001777out_delete_session:
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001778 zstd_fini(&session->zstd_data);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03001779 perf_session__delete(session);
Song Liu657ee552019-03-11 22:30:50 -07001780
1781 if (!opts->no_bpf_event)
1782 perf_evlist__stop_sb_thread(sb_evlist);
Namhyung Kim45604712014-05-12 09:47:24 +09001783 return status;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001784}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02001785
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001786static void callchain_debug(struct callchain_param *callchain)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001787{
Kan Liangaad2b212015-01-05 13:23:04 -05001788 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
Jiri Olsaa601fdf2014-02-03 12:44:43 +01001789
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001790 pr_debug("callchain: type %s\n", str[callchain->record_mode]);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001791
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001792 if (callchain->record_mode == CALLCHAIN_DWARF)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001793 pr_debug("callchain: stack dump size %d\n",
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001794 callchain->dump_size);
1795}
1796
1797int record_opts__parse_callchain(struct record_opts *record,
1798 struct callchain_param *callchain,
1799 const char *arg, bool unset)
1800{
1801 int ret;
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001802 callchain->enabled = !unset;
1803
1804 /* --no-call-graph */
1805 if (unset) {
1806 callchain->record_mode = CALLCHAIN_NONE;
1807 pr_debug("callchain: disabled\n");
1808 return 0;
1809 }
1810
1811 ret = parse_callchain_record_opt(arg, callchain);
1812 if (!ret) {
1813 /* Enable data address sampling for DWARF unwind. */
1814 if (callchain->record_mode == CALLCHAIN_DWARF)
1815 record->sample_address = true;
1816 callchain_debug(callchain);
1817 }
1818
1819 return ret;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001820}
1821
Kan Liangc421e802015-07-29 05:42:12 -04001822int record_parse_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001823 const char *arg,
1824 int unset)
1825{
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03001826 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
Jiri Olsa26d33022012-08-07 15:20:47 +02001827}
1828
Kan Liangc421e802015-07-29 05:42:12 -04001829int record_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001830 const char *arg __maybe_unused,
1831 int unset __maybe_unused)
1832{
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001833 struct callchain_param *callchain = opt->value;
Kan Liangc421e802015-07-29 05:42:12 -04001834
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001835 callchain->enabled = true;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001836
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001837 if (callchain->record_mode == CALLCHAIN_NONE)
1838 callchain->record_mode = CALLCHAIN_FP;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001839
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03001840 callchain_debug(callchain);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02001841 return 0;
1842}
1843
Jiri Olsaeb853e82014-02-03 12:44:42 +01001844static int perf_record_config(const char *var, const char *value, void *cb)
1845{
Namhyung Kim7a29c082015-12-15 10:49:56 +09001846 struct record *rec = cb;
1847
1848 if (!strcmp(var, "record.build-id")) {
1849 if (!strcmp(value, "cache"))
1850 rec->no_buildid_cache = false;
1851 else if (!strcmp(value, "no-cache"))
1852 rec->no_buildid_cache = true;
1853 else if (!strcmp(value, "skip"))
1854 rec->no_buildid = true;
1855 else
1856 return -1;
1857 return 0;
1858 }
Yisheng Xiecff17202018-03-12 19:25:57 +08001859 if (!strcmp(var, "record.call-graph")) {
1860 var = "call-graph.record-mode";
1861 return perf_default_config(var, value, cb);
1862 }
Alexey Budankov93f20c02018-11-06 12:07:19 +03001863#ifdef HAVE_AIO_SUPPORT
1864 if (!strcmp(var, "record.aio")) {
1865 rec->opts.nr_cblocks = strtol(value, NULL, 0);
1866 if (!rec->opts.nr_cblocks)
1867 rec->opts.nr_cblocks = nr_cblocks_default;
1868 }
1869#endif
Jiri Olsaeb853e82014-02-03 12:44:42 +01001870
Yisheng Xiecff17202018-03-12 19:25:57 +08001871 return 0;
Jiri Olsaeb853e82014-02-03 12:44:42 +01001872}
1873
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001874struct clockid_map {
1875 const char *name;
1876 int clockid;
1877};
1878
1879#define CLOCKID_MAP(n, c) \
1880 { .name = n, .clockid = (c), }
1881
1882#define CLOCKID_END { .name = NULL, }
1883
1884
1885/*
1886 * Add the missing ones, we need to build on many distros...
1887 */
1888#ifndef CLOCK_MONOTONIC_RAW
1889#define CLOCK_MONOTONIC_RAW 4
1890#endif
1891#ifndef CLOCK_BOOTTIME
1892#define CLOCK_BOOTTIME 7
1893#endif
1894#ifndef CLOCK_TAI
1895#define CLOCK_TAI 11
1896#endif
1897
1898static const struct clockid_map clockids[] = {
1899 /* available for all events, NMI safe */
1900 CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
1901 CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),
1902
1903 /* available for some events */
1904 CLOCKID_MAP("realtime", CLOCK_REALTIME),
1905 CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
1906 CLOCKID_MAP("tai", CLOCK_TAI),
1907
1908 /* available for the lazy */
1909 CLOCKID_MAP("mono", CLOCK_MONOTONIC),
1910 CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
1911 CLOCKID_MAP("real", CLOCK_REALTIME),
1912 CLOCKID_MAP("boot", CLOCK_BOOTTIME),
1913
1914 CLOCKID_END,
1915};
1916
Alexey Budankovcf790512018-10-09 17:36:24 +03001917static int get_clockid_res(clockid_t clk_id, u64 *res_ns)
1918{
1919 struct timespec res;
1920
1921 *res_ns = 0;
1922 if (!clock_getres(clk_id, &res))
1923 *res_ns = res.tv_nsec + res.tv_sec * NSEC_PER_SEC;
1924 else
1925 pr_warning("WARNING: Failed to determine specified clock resolution.\n");
1926
1927 return 0;
1928}
1929
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001930static int parse_clockid(const struct option *opt, const char *str, int unset)
1931{
1932 struct record_opts *opts = (struct record_opts *)opt->value;
1933 const struct clockid_map *cm;
1934 const char *ostr = str;
1935
1936 if (unset) {
1937 opts->use_clockid = 0;
1938 return 0;
1939 }
1940
1941 /* no arg passed */
1942 if (!str)
1943 return 0;
1944
1945 /* no setting it twice */
1946 if (opts->use_clockid)
1947 return -1;
1948
1949 opts->use_clockid = true;
1950
1951 /* if its a number, we're done */
1952 if (sscanf(str, "%d", &opts->clockid) == 1)
Alexey Budankovcf790512018-10-09 17:36:24 +03001953 return get_clockid_res(opts->clockid, &opts->clockid_res_ns);
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001954
1955 /* allow a "CLOCK_" prefix to the name */
1956 if (!strncasecmp(str, "CLOCK_", 6))
1957 str += 6;
1958
1959 for (cm = clockids; cm->name; cm++) {
1960 if (!strcasecmp(str, cm->name)) {
1961 opts->clockid = cm->clockid;
Alexey Budankovcf790512018-10-09 17:36:24 +03001962 return get_clockid_res(opts->clockid,
1963 &opts->clockid_res_ns);
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001964 }
1965 }
1966
1967 opts->use_clockid = false;
1968 ui__warning("unknown clockid %s, check man page\n", ostr);
1969 return -1;
1970}
1971
Alexey Budankovf4fe11b2019-01-22 20:52:03 +03001972static int record__parse_affinity(const struct option *opt, const char *str, int unset)
1973{
1974 struct record_opts *opts = (struct record_opts *)opt->value;
1975
1976 if (unset || !str)
1977 return 0;
1978
1979 if (!strcasecmp(str, "node"))
1980 opts->affinity = PERF_AFFINITY_NODE;
1981 else if (!strcasecmp(str, "cpu"))
1982 opts->affinity = PERF_AFFINITY_CPU;
1983
1984 return 0;
1985}
1986
Adrian Huntere9db1312015-04-09 18:53:46 +03001987static int record__parse_mmap_pages(const struct option *opt,
1988 const char *str,
1989 int unset __maybe_unused)
1990{
1991 struct record_opts *opts = opt->value;
1992 char *s, *p;
1993 unsigned int mmap_pages;
1994 int ret;
1995
1996 if (!str)
1997 return -EINVAL;
1998
1999 s = strdup(str);
2000 if (!s)
2001 return -ENOMEM;
2002
2003 p = strchr(s, ',');
2004 if (p)
2005 *p = '\0';
2006
2007 if (*s) {
2008 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
2009 if (ret)
2010 goto out_free;
2011 opts->mmap_pages = mmap_pages;
2012 }
2013
2014 if (!p) {
2015 ret = 0;
2016 goto out_free;
2017 }
2018
2019 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
2020 if (ret)
2021 goto out_free;
2022
2023 opts->auxtrace_mmap_pages = mmap_pages;
2024
2025out_free:
2026 free(s);
2027 return ret;
2028}
2029
Jiri Olsa0c582442017-01-09 10:51:59 +01002030static void switch_output_size_warn(struct record *rec)
2031{
Jiri Olsa9521b5f2019-07-28 12:45:35 +02002032 u64 wakeup_size = evlist__mmap_size(rec->opts.mmap_pages);
Jiri Olsa0c582442017-01-09 10:51:59 +01002033 struct switch_output *s = &rec->switch_output;
2034
2035 wakeup_size /= 2;
2036
2037 if (s->size < wakeup_size) {
2038 char buf[100];
2039
2040 unit_number__scnprintf(buf, sizeof(buf), wakeup_size);
2041 pr_warning("WARNING: switch-output data size lower than "
2042 "wakeup kernel buffer size (%s) "
2043 "expect bigger perf.data sizes\n", buf);
2044 }
2045}
2046
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002047static int switch_output_setup(struct record *rec)
2048{
2049 struct switch_output *s = &rec->switch_output;
Jiri Olsadc0c6122017-01-09 10:51:58 +01002050 static struct parse_tag tags_size[] = {
2051 { .tag = 'B', .mult = 1 },
2052 { .tag = 'K', .mult = 1 << 10 },
2053 { .tag = 'M', .mult = 1 << 20 },
2054 { .tag = 'G', .mult = 1 << 30 },
2055 { .tag = 0 },
2056 };
Jiri Olsabfacbe32017-01-09 10:52:00 +01002057 static struct parse_tag tags_time[] = {
2058 { .tag = 's', .mult = 1 },
2059 { .tag = 'm', .mult = 60 },
2060 { .tag = 'h', .mult = 60*60 },
2061 { .tag = 'd', .mult = 60*60*24 },
2062 { .tag = 0 },
2063 };
Jiri Olsadc0c6122017-01-09 10:51:58 +01002064 unsigned long val;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002065
2066 if (!s->set)
2067 return 0;
2068
2069 if (!strcmp(s->str, "signal")) {
2070 s->signal = true;
2071 pr_debug("switch-output with SIGUSR2 signal\n");
Jiri Olsadc0c6122017-01-09 10:51:58 +01002072 goto enabled;
2073 }
2074
2075 val = parse_tag_value(s->str, tags_size);
2076 if (val != (unsigned long) -1) {
2077 s->size = val;
2078 pr_debug("switch-output with %s size threshold\n", s->str);
2079 goto enabled;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002080 }
2081
Jiri Olsabfacbe32017-01-09 10:52:00 +01002082 val = parse_tag_value(s->str, tags_time);
2083 if (val != (unsigned long) -1) {
2084 s->time = val;
2085 pr_debug("switch-output with %s time threshold (%lu seconds)\n",
2086 s->str, s->time);
2087 goto enabled;
2088 }
2089
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002090 return -1;
Jiri Olsadc0c6122017-01-09 10:51:58 +01002091
2092enabled:
2093 rec->timestamp_filename = true;
2094 s->enabled = true;
Jiri Olsa0c582442017-01-09 10:51:59 +01002095
2096 if (s->size && !rec->opts.no_buffering)
2097 switch_output_size_warn(rec);
2098
Jiri Olsadc0c6122017-01-09 10:51:58 +01002099 return 0;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002100}
2101
Namhyung Kime5b2c202014-10-23 00:15:46 +09002102static const char * const __record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +02002103 "perf record [<options>] [<command>]",
2104 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002105 NULL
2106};
Namhyung Kime5b2c202014-10-23 00:15:46 +09002107const char * const *record_usage = __record_usage;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002108
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002109/*
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002110 * XXX Ideally would be local to cmd_record() and passed to a record__new
2111 * because we need to have access to it in record__exit, that is called
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002112 * after cmd_record() exits, but since record_options need to be accessible to
2113 * builtin-script, leave it here.
2114 *
2115 * At least we don't ouch it in all the other functions here directly.
2116 *
2117 * Just say no to tons of global variables, sigh.
2118 */
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002119static struct record record = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002120 .opts = {
Andi Kleen8affc2b2014-07-31 14:45:04 +08002121 .sample_time = true,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002122 .mmap_pages = UINT_MAX,
2123 .user_freq = UINT_MAX,
2124 .user_interval = ULLONG_MAX,
Arnaldo Carvalho de Melo447a6012012-05-22 13:14:18 -03002125 .freq = 4000,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09002126 .target = {
2127 .uses_mmap = true,
Adrian Hunter3aa59392013-11-15 15:52:29 +02002128 .default_per_cpu = true,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09002129 },
Alexey Budankov470530b2019-03-18 20:40:26 +03002130 .mmap_flush = MMAP_FLUSH_DEFAULT,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002131 },
Namhyung Kime3d59112015-01-29 17:06:44 +09002132 .tool = {
2133 .sample = process_sample_event,
2134 .fork = perf_event__process_fork,
Adrian Huntercca84822015-08-19 17:29:21 +03002135 .exit = perf_event__process_exit,
Namhyung Kime3d59112015-01-29 17:06:44 +09002136 .comm = perf_event__process_comm,
Hari Bathinif3b36142017-03-08 02:11:43 +05302137 .namespaces = perf_event__process_namespaces,
Namhyung Kime3d59112015-01-29 17:06:44 +09002138 .mmap = perf_event__process_mmap,
2139 .mmap2 = perf_event__process_mmap2,
Adrian Huntercca84822015-08-19 17:29:21 +03002140 .ordered_events = true,
Namhyung Kime3d59112015-01-29 17:06:44 +09002141 },
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002142};
Frederic Weisbecker7865e812010-04-14 19:42:07 +02002143
Namhyung Kim76a26542015-10-22 23:28:32 +09002144const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
2145 "\n\t\t\t\tDefault: fp";
Arnaldo Carvalho de Melo61eaa3b2012-10-01 15:20:58 -03002146
Wang Nan0aab2132016-06-16 08:02:41 +00002147static bool dry_run;
2148
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002149/*
2150 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
2151 * with it and switch to use the library functions in perf_evlist that came
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03002152 * from builtin-record.c, i.e. use record_opts,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002153 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
2154 * using pipes, etc.
2155 */
Jiri Olsaefd21302017-01-03 09:19:55 +01002156static struct option __record_options[] = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002157 OPT_CALLBACK('e', "event", &record.evlist, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +02002158 "event selector. use 'perf list' to list available events",
Jiri Olsaf120f9d2011-07-14 11:25:32 +02002159 parse_events_option),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002160 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
Li Zefanc171b552009-10-15 11:22:07 +08002161 "event filter", parse_filter),
Wang Nan4ba1faa2015-07-10 07:36:10 +00002162 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
2163 NULL, "don't record events from perf itself",
2164 exclude_perf),
Namhyung Kimbea03402012-04-26 14:15:15 +09002165 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03002166 "record events on existing process id"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002167 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03002168 "record events on existing thread id"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002169 OPT_INTEGER('r', "realtime", &record.realtime_prio,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002170 "collect data with this RT SCHED_FIFO priority"),
Arnaldo Carvalho de Melo509051e2014-01-14 17:52:14 -03002171 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
Kirill Smelkovacac03f2011-01-12 17:59:36 +03002172 "collect data without buffering"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002173 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +02002174 "collect raw sample records from all opened counters"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002175 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002176 "system-wide collection from all CPUs"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002177 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02002178 "list of cpus to monitor"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002179 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
Jiri Olsa2d4f2792019-02-21 10:41:30 +01002180 OPT_STRING('o', "output", &record.data.path, "file",
Ingo Molnarabaff322009-06-02 22:59:57 +02002181 "output file name"),
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02002182 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
2183 &record.opts.no_inherit_set,
2184 "child tasks do not inherit counters"),
Wang Nan4ea648a2016-07-14 08:34:47 +00002185 OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize,
2186 "synthesize non-sample events at the end of output"),
Wang Nan626a6b72016-07-14 08:34:45 +00002187 OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
Song Liu71184c62019-03-11 22:30:37 -07002188 OPT_BOOLEAN(0, "no-bpf-event", &record.opts.no_bpf_event, "record bpf events"),
Arnaldo Carvalho de Melob09c2362018-03-01 14:52:50 -03002189 OPT_BOOLEAN(0, "strict-freq", &record.opts.strict_freq,
2190 "Fail if the specified frequency can't be used"),
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -03002191 OPT_CALLBACK('F', "freq", &record.opts, "freq or 'max'",
2192 "profile at this frequency",
2193 record__parse_freq),
Adrian Huntere9db1312015-04-09 18:53:46 +03002194 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
2195 "number of mmap data pages and AUX area tracing mmap pages",
2196 record__parse_mmap_pages),
Alexey Budankov470530b2019-03-18 20:40:26 +03002197 OPT_CALLBACK(0, "mmap-flush", &record.opts, "number",
2198 "Minimal number of bytes that is extracted from mmap data pages (default: 1)",
2199 record__mmap_flush_parse),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002200 OPT_BOOLEAN(0, "group", &record.opts.group,
Lin Ming43bece72011-08-17 18:42:07 +08002201 "put the counters into a counter group"),
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03002202 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002203 NULL, "enables call-graph recording" ,
2204 &record_callchain_opt),
2205 OPT_CALLBACK(0, "call-graph", &record.opts,
Namhyung Kim76a26542015-10-22 23:28:32 +09002206 "record_mode[,record_size]", record_callchain_help,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002207 &record_parse_callchain_opt),
Ian Munsiec0555642010-04-13 18:37:33 +10002208 OPT_INCR('v', "verbose", &verbose,
Ingo Molnar3da297a2009-06-07 17:39:02 +02002209 "be more verbose (show counter open errors, etc)"),
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02002210 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002211 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02002212 "per thread counts"),
Peter Zijlstra56100322015-06-10 16:48:50 +02002213 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
Kan Liang3b0a5da2017-08-29 13:11:08 -04002214 OPT_BOOLEAN(0, "phys-data", &record.opts.sample_phys_addr,
2215 "Record the sample physical addresses"),
Jiri Olsab6f35ed2016-08-01 20:02:35 +02002216 OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"),
Adrian Hunter3abebc52015-07-06 14:51:01 +03002217 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
2218 &record.opts.sample_time_set,
2219 "Record the sample timestamps"),
Jiri Olsaf290aa12018-02-01 09:38:11 +01002220 OPT_BOOLEAN_SET('P', "period", &record.opts.period, &record.opts.period_set,
2221 "Record the sample period"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002222 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02002223 "don't sample"),
Wang Nand2db9a92016-01-25 09:56:19 +00002224 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
2225 &record.no_buildid_cache_set,
2226 "do not update the buildid cache"),
2227 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
2228 &record.no_buildid_set,
2229 "do not collect buildids in perf.data"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002230 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
Stephane Eranian023695d2011-02-14 11:20:01 +02002231 "monitor event in cgroup name only",
2232 parse_cgroups),
Arnaldo Carvalho de Meloa6205a32014-01-14 17:58:12 -03002233 OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
Andi Kleen6619a532014-01-11 13:38:27 -08002234 "ms to wait before starting measurement after program start"),
Adrian Huntereeb399b2019-10-04 11:31:21 +03002235 OPT_BOOLEAN(0, "kcore", &record.opts.kcore, "copy /proc/kcore"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002236 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
2237 "user to profile"),
Stephane Eraniana5aabda2012-03-08 23:47:45 +01002238
2239 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
2240 "branch any", "sample any taken branches",
2241 parse_branch_stack),
2242
2243 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
2244 "branch filter mask", "branch stack filter modes",
Roberto Agostino Vitillobdfebd82012-02-09 23:21:02 +01002245 parse_branch_stack),
Andi Kleen05484292013-01-24 16:10:29 +01002246 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
2247 "sample by weight (on special events only)"),
Andi Kleen475eeab2013-09-20 07:40:43 -07002248 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
2249 "sample transaction flags (special events only)"),
Adrian Hunter3aa59392013-11-15 15:52:29 +02002250 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
2251 "use per-thread mmaps"),
Stephane Eranianbcc84ec2015-08-31 18:41:12 +02002252 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
2253 "sample selected machine registers on interrupt,"
Kan Liangaeea9062019-05-14 13:19:32 -07002254 " use '-I?' to list register names", parse_intr_regs),
Andi Kleen84c41742017-09-05 10:00:28 -07002255 OPT_CALLBACK_OPTARG(0, "user-regs", &record.opts.sample_user_regs, NULL, "any register",
2256 "sample selected machine registers on interrupt,"
Kan Liangaeea9062019-05-14 13:19:32 -07002257 " use '--user-regs=?' to list register names", parse_user_regs),
Andi Kleen85c273d2015-02-24 15:13:40 -08002258 OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
2259 "Record running/enabled time of read (:S) events"),
Peter Zijlstra814c8c32015-03-31 00:19:31 +02002260 OPT_CALLBACK('k', "clockid", &record.opts,
2261 "clockid", "clockid to use for events, see clock_gettime()",
2262 parse_clockid),
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002263 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
2264 "opts", "AUX area tracing Snapshot Mode", ""),
Mark Drayton3fcb10e2018-12-04 12:34:20 -08002265 OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
Kan Liang9d9cad72015-06-17 09:51:11 -04002266 "per thread proc mmap processing timeout in ms"),
Hari Bathinif3b36142017-03-08 02:11:43 +05302267 OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
2268 "Record namespaces events"),
Adrian Hunterb757bb02015-07-21 12:44:04 +03002269 OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
2270 "Record context switch events"),
Jiri Olsa85723882016-02-15 09:34:31 +01002271 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
2272 "Configure all used events to run in kernel space.",
2273 PARSE_OPT_EXCLUSIVE),
2274 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
2275 "Configure all used events to run in user space.",
2276 PARSE_OPT_EXCLUSIVE),
yuzhoujian53651b22019-05-30 14:29:22 +01002277 OPT_BOOLEAN(0, "kernel-callchains", &record.opts.kernel_callchains,
2278 "collect kernel callchains"),
2279 OPT_BOOLEAN(0, "user-callchains", &record.opts.user_callchains,
2280 "collect user callchains"),
Wang Nan71dc23262015-10-14 12:41:19 +00002281 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
2282 "clang binary to use for compiling BPF scriptlets"),
2283 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
2284 "options passed to clang when compiling BPF scriptlets"),
He Kuang7efe0e02015-12-14 10:39:23 +00002285 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
2286 "file", "vmlinux pathname"),
Namhyung Kim61566812016-01-11 22:37:09 +09002287 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
2288 "Record build-id of all DSOs regardless of hits"),
Wang Nanecfd7a92016-04-13 08:21:07 +00002289 OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
2290 "append timestamp to output filename"),
Jin Yao68588ba2017-12-08 21:13:42 +08002291 OPT_BOOLEAN(0, "timestamp-boundary", &record.timestamp_boundary,
2292 "Record timestamp boundary (time of first/last samples)"),
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002293 OPT_STRING_OPTARG_SET(0, "switch-output", &record.switch_output.str,
Andi Kleenc38dab72019-03-14 15:49:56 -07002294 &record.switch_output.set, "signal or size[BKMG] or time[smhd]",
2295 "Switch output when receiving SIGUSR2 (signal) or cross a size or time threshold",
Jiri Olsadc0c6122017-01-09 10:51:58 +01002296 "signal"),
Andi Kleen03724b22019-03-14 15:49:55 -07002297 OPT_INTEGER(0, "switch-max-files", &record.switch_output.num_files,
2298 "Limit number of switch output generated files"),
Wang Nan0aab2132016-06-16 08:02:41 +00002299 OPT_BOOLEAN(0, "dry-run", &dry_run,
2300 "Parse options then exit"),
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002301#ifdef HAVE_AIO_SUPPORT
Alexey Budankov93f20c02018-11-06 12:07:19 +03002302 OPT_CALLBACK_OPTARG(0, "aio", &record.opts,
2303 &nr_cblocks_default, "n", "Use <n> control blocks in asynchronous trace writing mode (default: 1, max: 4)",
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002304 record__aio_parse),
2305#endif
Alexey Budankovf4fe11b2019-01-22 20:52:03 +03002306 OPT_CALLBACK(0, "affinity", &record.opts, "node|cpu",
2307 "Set affinity mask of trace reading thread to NUMA node cpu mask or cpu of processed mmap buffer",
2308 record__parse_affinity),
Alexey Budankov504c1ad2019-03-18 20:44:42 +03002309#ifdef HAVE_ZSTD_SUPPORT
2310 OPT_CALLBACK_OPTARG('z', "compression-level", &record.opts, &comp_level_default,
2311 "n", "Compressed records using specified level (default: 1 - fastest compression, 22 - greatest compression)",
2312 record__parse_comp_level),
2313#endif
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002314 OPT_END()
2315};
2316
Namhyung Kime5b2c202014-10-23 00:15:46 +09002317struct option *record_options = __record_options;
2318
Arnaldo Carvalho de Melob0ad8ea2017-03-27 11:47:20 -03002319int cmd_record(int argc, const char **argv)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002320{
Adrian Hunteref149c22015-04-09 18:53:45 +03002321 int err;
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002322 struct record *rec = &record;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002323 char errbuf[BUFSIZ];
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002324
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -03002325 setlocale(LC_ALL, "");
2326
Wang Nan48e1cab2015-12-14 10:39:22 +00002327#ifndef HAVE_LIBBPF_SUPPORT
2328# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
2329 set_nobuild('\0', "clang-path", true);
2330 set_nobuild('\0', "clang-opt", true);
2331# undef set_nobuild
2332#endif
2333
He Kuang7efe0e02015-12-14 10:39:23 +00002334#ifndef HAVE_BPF_PROLOGUE
2335# if !defined (HAVE_DWARF_SUPPORT)
2336# define REASON "NO_DWARF=1"
2337# elif !defined (HAVE_LIBBPF_SUPPORT)
2338# define REASON "NO_LIBBPF=1"
2339# else
2340# define REASON "this architecture doesn't support BPF prologue"
2341# endif
2342# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
2343 set_nobuild('\0', "vmlinux", true);
2344# undef set_nobuild
2345# undef REASON
2346#endif
2347
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002348 CPU_ZERO(&rec->affinity_mask);
2349 rec->opts.affinity = PERF_AFFINITY_SYS;
2350
Jiri Olsa0f98b112019-07-21 13:23:55 +02002351 rec->evlist = evlist__new();
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002352 if (rec->evlist == NULL)
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02002353 return -ENOMEM;
2354
Arnaldo Carvalho de Meloecc4c562017-01-24 13:44:10 -03002355 err = perf_config(perf_record_config, rec);
2356 if (err)
2357 return err;
Jiri Olsaeb853e82014-02-03 12:44:42 +01002358
Tom Zanussibca647a2010-11-10 08:11:30 -06002359 argc = parse_options(argc, argv, record_options, record_usage,
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02002360 PARSE_OPT_STOP_AT_NON_OPTION);
Namhyung Kim68ba3232017-02-17 17:17:42 +09002361 if (quiet)
2362 perf_quiet_option();
Jiri Olsa483635a2017-02-17 18:00:18 +01002363
2364 /* Make system wide (-a) the default target. */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002365 if (!argc && target__none(&rec->opts.target))
Jiri Olsa483635a2017-02-17 18:00:18 +01002366 rec->opts.target.system_wide = true;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002367
Namhyung Kimbea03402012-04-26 14:15:15 +09002368 if (nr_cgroups && !rec->opts.target.system_wide) {
Namhyung Kimc7118362015-10-25 00:49:27 +09002369 usage_with_options_msg(record_usage, record_options,
2370 "cgroup monitoring only available in system-wide mode");
2371
Stephane Eranian023695d2011-02-14 11:20:01 +02002372 }
Alexey Budankov504c1ad2019-03-18 20:44:42 +03002373
Adrian Huntereeb399b2019-10-04 11:31:21 +03002374 if (rec->opts.kcore)
2375 rec->data.is_dir = true;
2376
Alexey Budankov504c1ad2019-03-18 20:44:42 +03002377 if (rec->opts.comp_level != 0) {
2378 pr_debug("Compression enabled, disabling build id collection at the end of the session.\n");
2379 rec->no_buildid = true;
2380 }
2381
Adrian Hunterb757bb02015-07-21 12:44:04 +03002382 if (rec->opts.record_switch_events &&
2383 !perf_can_record_switch_events()) {
Namhyung Kimc7118362015-10-25 00:49:27 +09002384 ui__error("kernel does not support recording context switch events\n");
2385 parse_options_usage(record_usage, record_options, "switch-events", 0);
2386 return -EINVAL;
Adrian Hunterb757bb02015-07-21 12:44:04 +03002387 }
Stephane Eranian023695d2011-02-14 11:20:01 +02002388
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002389 if (switch_output_setup(rec)) {
2390 parse_options_usage(record_usage, record_options, "switch-output", 0);
2391 return -EINVAL;
2392 }
2393
Jiri Olsabfacbe32017-01-09 10:52:00 +01002394 if (rec->switch_output.time) {
2395 signal(SIGALRM, alarm_sig_handler);
2396 alarm(rec->switch_output.time);
2397 }
2398
Andi Kleen03724b22019-03-14 15:49:55 -07002399 if (rec->switch_output.num_files) {
2400 rec->switch_output.filenames = calloc(sizeof(char *),
2401 rec->switch_output.num_files);
2402 if (!rec->switch_output.filenames)
2403 return -EINVAL;
2404 }
2405
Adrian Hunter1b36c032016-09-23 17:38:39 +03002406 /*
2407 * Allow aliases to facilitate the lookup of symbols for address
2408 * filters. Refer to auxtrace_parse_filters().
2409 */
2410 symbol_conf.allow_aliases = true;
2411
2412 symbol__init(NULL);
2413
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +02002414 err = record__auxtrace_init(rec);
Adrian Hunter1b36c032016-09-23 17:38:39 +03002415 if (err)
2416 goto out;
2417
Wang Nan0aab2132016-06-16 08:02:41 +00002418 if (dry_run)
Adrian Hunter5c01ad602016-09-23 17:38:37 +03002419 goto out;
Wang Nan0aab2132016-06-16 08:02:41 +00002420
Wang Nand7888572016-04-08 15:07:24 +00002421 err = bpf__setup_stdout(rec->evlist);
2422 if (err) {
2423 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
2424 pr_err("ERROR: Setup BPF stdout failed: %s\n",
2425 errbuf);
Adrian Hunter5c01ad602016-09-23 17:38:37 +03002426 goto out;
Wang Nand7888572016-04-08 15:07:24 +00002427 }
2428
Adrian Hunteref149c22015-04-09 18:53:45 +03002429 err = -ENOMEM;
2430
Wang Nan0c1d46a2016-04-20 18:59:52 +00002431 if (rec->no_buildid_cache || rec->no_buildid) {
Stephane Eraniana1ac1d32010-06-17 11:39:01 +02002432 disable_buildid_cache();
Jiri Olsadc0c6122017-01-09 10:51:58 +01002433 } else if (rec->switch_output.enabled) {
Wang Nan0c1d46a2016-04-20 18:59:52 +00002434 /*
2435 * In 'perf record --switch-output', disable buildid
2436 * generation by default to reduce data file switching
2437 * overhead. Still generate buildid if they are required
2438 * explicitly using
2439 *
Jiri Olsa60437ac2017-01-03 09:19:56 +01002440 * perf record --switch-output --no-no-buildid \
Wang Nan0c1d46a2016-04-20 18:59:52 +00002441 * --no-no-buildid-cache
2442 *
2443 * Following code equals to:
2444 *
2445 * if ((rec->no_buildid || !rec->no_buildid_set) &&
2446 * (rec->no_buildid_cache || !rec->no_buildid_cache_set))
2447 * disable_buildid_cache();
2448 */
2449 bool disable = true;
2450
2451 if (rec->no_buildid_set && !rec->no_buildid)
2452 disable = false;
2453 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
2454 disable = false;
2455 if (disable) {
2456 rec->no_buildid = true;
2457 rec->no_buildid_cache = true;
2458 disable_buildid_cache();
2459 }
2460 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02002461
Wang Nan4ea648a2016-07-14 08:34:47 +00002462 if (record.opts.overwrite)
2463 record.opts.tail_synthesize = true;
2464
Jiri Olsa6484d2f2019-07-21 13:24:28 +02002465 if (rec->evlist->core.nr_entries == 0 &&
Arnaldo Carvalho de Melo4b4cd502017-07-03 13:26:32 -03002466 __perf_evlist__add_default(rec->evlist, !record.opts.no_samples) < 0) {
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02002467 pr_err("Not enough memory for event selector list\n");
Adrian Hunter394c01e2016-09-23 17:38:36 +03002468 goto out;
Peter Zijlstrabbd36e52009-06-11 23:11:50 +02002469 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002470
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02002471 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
2472 rec->opts.no_inherit = true;
2473
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002474 err = target__validate(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002475 if (err) {
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002476 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Jiri Olsac3dec272018-02-06 19:17:58 +01002477 ui__warning("%s\n", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002478 }
Namhyung Kim4bd0f2d2012-04-26 14:15:18 +09002479
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002480 err = target__parse_uid(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002481 if (err) {
2482 int saved_errno = errno;
2483
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002484 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim3780f482012-05-29 13:22:57 +09002485 ui__error("%s", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002486
2487 err = -saved_errno;
Adrian Hunter394c01e2016-09-23 17:38:36 +03002488 goto out;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002489 }
Arnaldo Carvalho de Melo0d37aa32012-01-19 14:08:15 -02002490
Mengting Zhangca800062017-12-13 15:01:53 +08002491 /* Enable ignoring missing threads when -u/-p option is defined. */
2492 rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX || rec->opts.target.pid;
Jiri Olsa23dc4f12016-12-12 11:35:43 +01002493
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002494 err = -ENOMEM;
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002495 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -02002496 usage_with_options(record_usage, record_options);
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02002497
Adrian Hunteref149c22015-04-09 18:53:45 +03002498 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
2499 if (err)
Adrian Hunter394c01e2016-09-23 17:38:36 +03002500 goto out;
Adrian Hunteref149c22015-04-09 18:53:45 +03002501
Namhyung Kim61566812016-01-11 22:37:09 +09002502 /*
2503 * We take all buildids when the file contains
2504 * AUX area tracing data because we do not decode the
2505 * trace because it would take too long.
2506 */
2507 if (rec->opts.full_auxtrace)
2508 rec->buildid_all = true;
2509
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03002510 if (record_opts__config(&rec->opts)) {
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002511 err = -EINVAL;
Adrian Hunter394c01e2016-09-23 17:38:36 +03002512 goto out;
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +02002513 }
2514
Alexey Budankov93f20c02018-11-06 12:07:19 +03002515 if (rec->opts.nr_cblocks > nr_cblocks_max)
2516 rec->opts.nr_cblocks = nr_cblocks_max;
Alexey Budankov5d7f4112019-03-18 20:43:35 +03002517 pr_debug("nr_cblocks: %d\n", rec->opts.nr_cblocks);
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002518
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002519 pr_debug("affinity: %s\n", affinity_tags[rec->opts.affinity]);
Alexey Budankov470530b2019-03-18 20:40:26 +03002520 pr_debug("mmap flush: %d\n", rec->opts.mmap_flush);
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002521
Alexey Budankov51255a82019-03-18 20:42:19 +03002522 if (rec->opts.comp_level > comp_level_max)
2523 rec->opts.comp_level = comp_level_max;
2524 pr_debug("comp level: %d\n", rec->opts.comp_level);
2525
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002526 err = __cmd_record(&record, argc, argv);
Adrian Hunter394c01e2016-09-23 17:38:36 +03002527out:
Jiri Olsac12995a2019-07-21 13:23:56 +02002528 evlist__delete(rec->evlist);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -03002529 symbol__exit();
Adrian Hunteref149c22015-04-09 18:53:45 +03002530 auxtrace_record__free(rec->itr);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002531 return err;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002532}
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002533
2534static void snapshot_sig_handler(int sig __maybe_unused)
2535{
Jiri Olsadc0c6122017-01-09 10:51:58 +01002536 struct record *rec = &record;
2537
Wang Nan5f9cf592016-04-20 18:59:49 +00002538 if (trigger_is_ready(&auxtrace_snapshot_trigger)) {
2539 trigger_hit(&auxtrace_snapshot_trigger);
2540 auxtrace_record__snapshot_started = 1;
2541 if (auxtrace_record__snapshot_start(record.itr))
2542 trigger_error(&auxtrace_snapshot_trigger);
2543 }
Wang Nan3c1cb7e2016-04-20 18:59:50 +00002544
Jiri Olsadc0c6122017-01-09 10:51:58 +01002545 if (switch_output_signal(rec))
Wang Nan3c1cb7e2016-04-20 18:59:50 +00002546 trigger_hit(&switch_output_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002547}
Jiri Olsabfacbe32017-01-09 10:52:00 +01002548
2549static void alarm_sig_handler(int sig __maybe_unused)
2550{
2551 struct record *rec = &record;
2552
2553 if (switch_output_time(rec))
2554 trigger_hit(&switch_output_trigger);
2555}