blob: adf311d15d3d2225b01fa804ccbc3f18dd7541be [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"
Arnaldo Carvalho de Melo40c7d242020-05-05 11:49:08 -030037#include "util/perf_api_probe.h"
Wang Nan71dc23262015-10-14 12:41:19 +000038#include "util/llvm-utils.h"
Wang Nan8690a2a2016-02-22 09:10:32 +000039#include "util/bpf-loader.h"
Wang Nan5f9cf592016-04-20 18:59:49 +000040#include "util/trigger.h"
Wang Nana0748652016-11-26 07:03:28 +000041#include "util/perf-hooks.h"
Alexey Budankovf13de662019-01-22 20:50:57 +030042#include "util/cpu-set-sched.h"
Arnaldo Carvalho de Meloea49e012019-09-18 11:36:13 -030043#include "util/synthetic-events.h"
Arnaldo Carvalho de Meloc5e40272017-04-19 16:12:39 -030044#include "util/time-utils.h"
Arnaldo Carvalho de Melo58db1d62017-04-19 16:05:56 -030045#include "util/units.h"
Song Liu7b612e22019-01-17 08:15:19 -080046#include "util/bpf-event.h"
Stephane Eraniand99c22e2020-04-22 08:50:38 -070047#include "util/util.h"
Stephane Eranian70943492020-05-05 11:29:43 -070048#include "util/pfm.h"
Jiri Olsa6953beb2020-08-05 11:34:38 +020049#include "util/clockid.h"
Wang Nand8871ea2016-02-26 09:32:06 +000050#include "asm/bug.h"
Arnaldo Carvalho de Meloc1a604d2019-08-29 15:20:59 -030051#include "perf.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020052
Arnaldo Carvalho de Meloa43783a2017-04-18 10:46:11 -030053#include <errno.h>
Arnaldo Carvalho de Melofd20e812017-04-17 15:23:08 -030054#include <inttypes.h>
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -030055#include <locale.h>
Arnaldo Carvalho de Melo42087352017-04-19 19:06:30 -030056#include <poll.h>
Stephane Eraniand99c22e2020-04-22 08:50:38 -070057#include <pthread.h>
Peter Zijlstra97124d5e2009-06-02 15:52:24 +020058#include <unistd.h>
Peter Zijlstrade9ac072009-04-08 15:01:31 +020059#include <sched.h>
Arnaldo Carvalho de Melo9607ad32017-04-19 15:49:18 -030060#include <signal.h>
Anand K Mistryda231332020-05-13 12:20:23 +100061#ifdef HAVE_EVENTFD_SUPPORT
62#include <sys/eventfd.h>
63#endif
Arnaldo Carvalho de Meloa41794c2010-05-18 18:29:23 -030064#include <sys/mman.h>
Arnaldo Carvalho de Melo42087352017-04-19 19:06:30 -030065#include <sys/wait.h>
Adrian Huntereeb399b2019-10-04 11:31:21 +030066#include <sys/types.h>
67#include <sys/stat.h>
68#include <fcntl.h>
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +053069#include <linux/err.h>
Arnaldo Carvalho de Melo8520a982019-08-29 16:18:59 -030070#include <linux/string.h>
Arnaldo Carvalho de Melo0693e682016-08-08 15:05:46 -030071#include <linux/time64.h>
Arnaldo Carvalho de Melod8f9da22019-07-04 12:06:20 -030072#include <linux/zalloc.h>
Alexey Budankov8384a262019-12-03 14:45:27 +030073#include <linux/bitmap.h>
Jiri Olsad1e325c2020-08-05 11:34:40 +020074#include <sys/time.h>
Bernhard Rosenkraenzer78da39f2012-10-08 09:43:26 +030075
Jiri Olsa1b43b702017-01-09 10:51:56 +010076struct switch_output {
Jiri Olsadc0c6122017-01-09 10:51:58 +010077 bool enabled;
Jiri Olsa1b43b702017-01-09 10:51:56 +010078 bool signal;
Jiri Olsadc0c6122017-01-09 10:51:58 +010079 unsigned long size;
Jiri Olsabfacbe32017-01-09 10:52:00 +010080 unsigned long time;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +010081 const char *str;
82 bool set;
Andi Kleen03724b22019-03-14 15:49:55 -070083 char **filenames;
84 int num_files;
85 int cur_file;
Jiri Olsa1b43b702017-01-09 10:51:56 +010086};
87
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -030088struct record {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020089 struct perf_tool tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -030090 struct record_opts opts;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020091 u64 bytes_written;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +010092 struct perf_data data;
Adrian Hunteref149c22015-04-09 18:53:45 +030093 struct auxtrace_record *itr;
Jiri Olsa63503db2019-07-21 13:23:52 +020094 struct evlist *evlist;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020095 struct perf_session *session;
Arnaldo Carvalho de Melobc477d72020-04-24 10:24:04 -030096 struct evlist *sb_evlist;
Arnaldo Carvalho de Melo899e5ff2020-04-27 17:56:37 -030097 pthread_t thread_id;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020098 int realtime_prio;
Arnaldo Carvalho de Melo899e5ff2020-04-27 17:56:37 -030099 bool switch_output_event_set;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200100 bool no_buildid;
Wang Nand2db9a92016-01-25 09:56:19 +0000101 bool no_buildid_set;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200102 bool no_buildid_cache;
Wang Nand2db9a92016-01-25 09:56:19 +0000103 bool no_buildid_cache_set;
Namhyung Kim61566812016-01-11 22:37:09 +0900104 bool buildid_all;
Wang Nanecfd7a92016-04-13 08:21:07 +0000105 bool timestamp_filename;
Jin Yao68588ba2017-12-08 21:13:42 +0800106 bool timestamp_boundary;
Jiri Olsa1b43b702017-01-09 10:51:56 +0100107 struct switch_output switch_output;
Yang Shi9f065192015-09-29 14:49:43 -0700108 unsigned long long samples;
Alexey Budankov8384a262019-12-03 14:45:27 +0300109 struct mmap_cpu_mask affinity_mask;
Jiwei Sun6d575812019-10-22 16:09:01 +0800110 unsigned long output_max_size; /* = 0: unlimited */
Arnaldo Carvalho de Melo0f82ebc2011-11-08 14:41:57 -0200111};
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200112
Jiwei Sun6d575812019-10-22 16:09:01 +0800113static volatile int done;
114
Jiri Olsadc0c6122017-01-09 10:51:58 +0100115static volatile int auxtrace_record__snapshot_started;
116static DEFINE_TRIGGER(auxtrace_snapshot_trigger);
117static DEFINE_TRIGGER(switch_output_trigger);
118
Alexey Budankov9d2ed642019-01-22 20:47:43 +0300119static const char *affinity_tags[PERF_AFFINITY_MAX] = {
120 "SYS", "NODE", "CPU"
121};
122
Jiri Olsadc0c6122017-01-09 10:51:58 +0100123static bool switch_output_signal(struct record *rec)
124{
125 return rec->switch_output.signal &&
126 trigger_is_ready(&switch_output_trigger);
127}
128
129static bool switch_output_size(struct record *rec)
130{
131 return rec->switch_output.size &&
132 trigger_is_ready(&switch_output_trigger) &&
133 (rec->bytes_written >= rec->switch_output.size);
134}
135
Jiri Olsabfacbe32017-01-09 10:52:00 +0100136static bool switch_output_time(struct record *rec)
137{
138 return rec->switch_output.time &&
139 trigger_is_ready(&switch_output_trigger);
140}
141
Jiwei Sun6d575812019-10-22 16:09:01 +0800142static bool record__output_max_size_exceeded(struct record *rec)
143{
144 return rec->output_max_size &&
145 (rec->bytes_written >= rec->output_max_size);
146}
147
Jiri Olsaa5830532019-07-27 20:30:53 +0200148static int record__write(struct record *rec, struct mmap *map __maybe_unused,
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200149 void *bf, size_t size)
Peter Zijlstraf5970552009-06-18 23:22:55 +0200150{
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200151 struct perf_data_file *file = &rec->session->data->file;
152
153 if (perf_data_file__write(file, bf, size) < 0) {
Jiri Olsa50a9b862013-11-22 13:11:24 +0100154 pr_err("failed to write perf data, error: %m\n");
155 return -1;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200156 }
David Ahern8d3eca22012-08-26 12:24:47 -0600157
Arnaldo Carvalho de Melocf8b2e62013-12-19 14:26:26 -0300158 rec->bytes_written += size;
Jiri Olsadc0c6122017-01-09 10:51:58 +0100159
Jiwei Sun6d575812019-10-22 16:09:01 +0800160 if (record__output_max_size_exceeded(rec) && !done) {
161 fprintf(stderr, "[ perf record: perf size limit reached (%" PRIu64 " KB),"
162 " stopping session ]\n",
163 rec->bytes_written >> 10);
164 done = 1;
165 }
166
Jiri Olsadc0c6122017-01-09 10:51:58 +0100167 if (switch_output_size(rec))
168 trigger_hit(&switch_output_trigger);
169
David Ahern8d3eca22012-08-26 12:24:47 -0600170 return 0;
Peter Zijlstraf5970552009-06-18 23:22:55 +0200171}
172
Alexey Budankovef781122019-03-18 20:44:12 +0300173static int record__aio_enabled(struct record *rec);
174static int record__comp_enabled(struct record *rec);
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300175static size_t zstd_compress(struct perf_session *session, void *dst, size_t dst_size,
176 void *src, size_t src_size);
177
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300178#ifdef HAVE_AIO_SUPPORT
179static int record__aio_write(struct aiocb *cblock, int trace_fd,
180 void *buf, size_t size, off_t off)
181{
182 int rc;
183
184 cblock->aio_fildes = trace_fd;
185 cblock->aio_buf = buf;
186 cblock->aio_nbytes = size;
187 cblock->aio_offset = off;
188 cblock->aio_sigevent.sigev_notify = SIGEV_NONE;
189
190 do {
191 rc = aio_write(cblock);
192 if (rc == 0) {
193 break;
194 } else if (errno != EAGAIN) {
195 cblock->aio_fildes = -1;
196 pr_err("failed to queue perf data, error: %m\n");
197 break;
198 }
199 } while (1);
200
201 return rc;
202}
203
Jiri Olsaa5830532019-07-27 20:30:53 +0200204static int record__aio_complete(struct mmap *md, struct aiocb *cblock)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300205{
206 void *rem_buf;
207 off_t rem_off;
208 size_t rem_size;
209 int rc, aio_errno;
210 ssize_t aio_ret, written;
211
212 aio_errno = aio_error(cblock);
213 if (aio_errno == EINPROGRESS)
214 return 0;
215
216 written = aio_ret = aio_return(cblock);
217 if (aio_ret < 0) {
218 if (aio_errno != EINTR)
219 pr_err("failed to write perf data, error: %m\n");
220 written = 0;
221 }
222
223 rem_size = cblock->aio_nbytes - written;
224
225 if (rem_size == 0) {
226 cblock->aio_fildes = -1;
227 /*
Alexey Budankovef781122019-03-18 20:44:12 +0300228 * md->refcount is incremented in record__aio_pushfn() for
229 * every aio write request started in record__aio_push() so
230 * decrement it because the request is now complete.
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300231 */
Jiri Olsa80e53d12019-10-07 14:53:15 +0200232 perf_mmap__put(&md->core);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300233 rc = 1;
234 } else {
235 /*
236 * aio write request may require restart with the
237 * reminder if the kernel didn't write whole
238 * chunk at once.
239 */
240 rem_off = cblock->aio_offset + written;
241 rem_buf = (void *)(cblock->aio_buf + written);
242 record__aio_write(cblock, cblock->aio_fildes,
243 rem_buf, rem_size, rem_off);
244 rc = 0;
245 }
246
247 return rc;
248}
249
Jiri Olsaa5830532019-07-27 20:30:53 +0200250static int record__aio_sync(struct mmap *md, bool sync_all)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300251{
Alexey Budankov93f20c02018-11-06 12:07:19 +0300252 struct aiocb **aiocb = md->aio.aiocb;
253 struct aiocb *cblocks = md->aio.cblocks;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300254 struct timespec timeout = { 0, 1000 * 1000 * 1 }; /* 1ms */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300255 int i, do_suspend;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300256
257 do {
Alexey Budankov93f20c02018-11-06 12:07:19 +0300258 do_suspend = 0;
259 for (i = 0; i < md->aio.nr_cblocks; ++i) {
260 if (cblocks[i].aio_fildes == -1 || record__aio_complete(md, &cblocks[i])) {
261 if (sync_all)
262 aiocb[i] = NULL;
263 else
264 return i;
265 } else {
266 /*
267 * Started aio write is not complete yet
268 * so it has to be waited before the
269 * next allocation.
270 */
271 aiocb[i] = &cblocks[i];
272 do_suspend = 1;
273 }
274 }
275 if (!do_suspend)
276 return -1;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300277
Alexey Budankov93f20c02018-11-06 12:07:19 +0300278 while (aio_suspend((const struct aiocb **)aiocb, md->aio.nr_cblocks, &timeout)) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300279 if (!(errno == EAGAIN || errno == EINTR))
280 pr_err("failed to sync perf data, error: %m\n");
281 }
282 } while (1);
283}
284
Alexey Budankovef781122019-03-18 20:44:12 +0300285struct record_aio {
286 struct record *rec;
287 void *data;
288 size_t size;
289};
290
Jiri Olsaa5830532019-07-27 20:30:53 +0200291static int record__aio_pushfn(struct mmap *map, void *to, void *buf, size_t size)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300292{
Alexey Budankovef781122019-03-18 20:44:12 +0300293 struct record_aio *aio = to;
294
295 /*
Jiri Olsa547740f2019-07-27 22:07:44 +0200296 * map->core.base data pointed by buf is copied into free map->aio.data[] buffer
Alexey Budankovef781122019-03-18 20:44:12 +0300297 * to release space in the kernel buffer as fast as possible, calling
298 * perf_mmap__consume() from perf_mmap__push() function.
299 *
300 * That lets the kernel to proceed with storing more profiling data into
301 * the kernel buffer earlier than other per-cpu kernel buffers are handled.
302 *
303 * Coping can be done in two steps in case the chunk of profiling data
304 * crosses the upper bound of the kernel buffer. In this case we first move
305 * part of data from map->start till the upper bound and then the reminder
306 * from the beginning of the kernel buffer till the end of the data chunk.
307 */
308
309 if (record__comp_enabled(aio->rec)) {
310 size = zstd_compress(aio->rec->session, aio->data + aio->size,
Jiri Olsabf59b302019-10-07 14:53:11 +0200311 mmap__mmap_len(map) - aio->size,
Alexey Budankovef781122019-03-18 20:44:12 +0300312 buf, size);
313 } else {
314 memcpy(aio->data + aio->size, buf, size);
315 }
316
317 if (!aio->size) {
318 /*
319 * Increment map->refcount to guard map->aio.data[] buffer
320 * from premature deallocation because map object can be
321 * released earlier than aio write request started on
322 * map->aio.data[] buffer is complete.
323 *
324 * perf_mmap__put() is done at record__aio_complete()
325 * after started aio request completion or at record__aio_push()
326 * if the request failed to start.
327 */
Jiri Olsae75710f2019-10-07 14:53:13 +0200328 perf_mmap__get(&map->core);
Alexey Budankovef781122019-03-18 20:44:12 +0300329 }
330
331 aio->size += size;
332
333 return size;
334}
335
Jiri Olsaa5830532019-07-27 20:30:53 +0200336static int record__aio_push(struct record *rec, struct mmap *map, off_t *off)
Alexey Budankovef781122019-03-18 20:44:12 +0300337{
338 int ret, idx;
339 int trace_fd = rec->session->data->file.fd;
340 struct record_aio aio = { .rec = rec, .size = 0 };
341
342 /*
343 * Call record__aio_sync() to wait till map->aio.data[] buffer
344 * becomes available after previous aio write operation.
345 */
346
347 idx = record__aio_sync(map, false);
348 aio.data = map->aio.data[idx];
349 ret = perf_mmap__push(map, &aio, record__aio_pushfn);
350 if (ret != 0) /* ret > 0 - no data, ret < 0 - error */
351 return ret;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300352
353 rec->samples++;
Alexey Budankovef781122019-03-18 20:44:12 +0300354 ret = record__aio_write(&(map->aio.cblocks[idx]), trace_fd, aio.data, aio.size, *off);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300355 if (!ret) {
Alexey Budankovef781122019-03-18 20:44:12 +0300356 *off += aio.size;
357 rec->bytes_written += aio.size;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300358 if (switch_output_size(rec))
359 trigger_hit(&switch_output_trigger);
Alexey Budankovef781122019-03-18 20:44:12 +0300360 } else {
361 /*
362 * Decrement map->refcount incremented in record__aio_pushfn()
363 * back if record__aio_write() operation failed to start, otherwise
364 * map->refcount is decremented in record__aio_complete() after
365 * aio write operation finishes successfully.
366 */
Jiri Olsa80e53d12019-10-07 14:53:15 +0200367 perf_mmap__put(&map->core);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300368 }
369
370 return ret;
371}
372
373static off_t record__aio_get_pos(int trace_fd)
374{
375 return lseek(trace_fd, 0, SEEK_CUR);
376}
377
378static void record__aio_set_pos(int trace_fd, off_t pos)
379{
380 lseek(trace_fd, pos, SEEK_SET);
381}
382
383static void record__aio_mmap_read_sync(struct record *rec)
384{
385 int i;
Jiri Olsa63503db2019-07-21 13:23:52 +0200386 struct evlist *evlist = rec->evlist;
Jiri Olsaa5830532019-07-27 20:30:53 +0200387 struct mmap *maps = evlist->mmap;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300388
Alexey Budankovef781122019-03-18 20:44:12 +0300389 if (!record__aio_enabled(rec))
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300390 return;
391
Jiri Olsac976ee12019-07-30 13:04:59 +0200392 for (i = 0; i < evlist->core.nr_mmaps; i++) {
Jiri Olsaa5830532019-07-27 20:30:53 +0200393 struct mmap *map = &maps[i];
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300394
Jiri Olsa547740f2019-07-27 22:07:44 +0200395 if (map->core.base)
Alexey Budankov93f20c02018-11-06 12:07:19 +0300396 record__aio_sync(map, true);
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300397 }
398}
399
400static int nr_cblocks_default = 1;
Alexey Budankov93f20c02018-11-06 12:07:19 +0300401static int nr_cblocks_max = 4;
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300402
403static int record__aio_parse(const struct option *opt,
Alexey Budankov93f20c02018-11-06 12:07:19 +0300404 const char *str,
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300405 int unset)
406{
407 struct record_opts *opts = (struct record_opts *)opt->value;
408
Alexey Budankov93f20c02018-11-06 12:07:19 +0300409 if (unset) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300410 opts->nr_cblocks = 0;
Alexey Budankov93f20c02018-11-06 12:07:19 +0300411 } else {
412 if (str)
413 opts->nr_cblocks = strtol(str, NULL, 0);
414 if (!opts->nr_cblocks)
415 opts->nr_cblocks = nr_cblocks_default;
416 }
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300417
418 return 0;
419}
420#else /* HAVE_AIO_SUPPORT */
Alexey Budankov93f20c02018-11-06 12:07:19 +0300421static int nr_cblocks_max = 0;
422
Jiri Olsaa5830532019-07-27 20:30:53 +0200423static int record__aio_push(struct record *rec __maybe_unused, struct mmap *map __maybe_unused,
Alexey Budankovef781122019-03-18 20:44:12 +0300424 off_t *off __maybe_unused)
Alexey Budankovd3d1af62018-11-06 12:04:58 +0300425{
426 return -1;
427}
428
429static off_t record__aio_get_pos(int trace_fd __maybe_unused)
430{
431 return -1;
432}
433
434static void record__aio_set_pos(int trace_fd __maybe_unused, off_t pos __maybe_unused)
435{
436}
437
438static void record__aio_mmap_read_sync(struct record *rec __maybe_unused)
439{
440}
441#endif
442
443static int record__aio_enabled(struct record *rec)
444{
445 return rec->opts.nr_cblocks > 0;
446}
447
Alexey Budankov470530b2019-03-18 20:40:26 +0300448#define MMAP_FLUSH_DEFAULT 1
449static int record__mmap_flush_parse(const struct option *opt,
450 const char *str,
451 int unset)
452{
453 int flush_max;
454 struct record_opts *opts = (struct record_opts *)opt->value;
455 static struct parse_tag tags[] = {
456 { .tag = 'B', .mult = 1 },
457 { .tag = 'K', .mult = 1 << 10 },
458 { .tag = 'M', .mult = 1 << 20 },
459 { .tag = 'G', .mult = 1 << 30 },
460 { .tag = 0 },
461 };
462
463 if (unset)
464 return 0;
465
466 if (str) {
467 opts->mmap_flush = parse_tag_value(str, tags);
468 if (opts->mmap_flush == (int)-1)
469 opts->mmap_flush = strtol(str, NULL, 0);
470 }
471
472 if (!opts->mmap_flush)
473 opts->mmap_flush = MMAP_FLUSH_DEFAULT;
474
Jiri Olsa9521b5f2019-07-28 12:45:35 +0200475 flush_max = evlist__mmap_size(opts->mmap_pages);
Alexey Budankov470530b2019-03-18 20:40:26 +0300476 flush_max /= 4;
477 if (opts->mmap_flush > flush_max)
478 opts->mmap_flush = flush_max;
479
480 return 0;
481}
482
Alexey Budankov504c1ad2019-03-18 20:44:42 +0300483#ifdef HAVE_ZSTD_SUPPORT
484static unsigned int comp_level_default = 1;
485
486static int record__parse_comp_level(const struct option *opt, const char *str, int unset)
487{
488 struct record_opts *opts = opt->value;
489
490 if (unset) {
491 opts->comp_level = 0;
492 } else {
493 if (str)
494 opts->comp_level = strtol(str, NULL, 0);
495 if (!opts->comp_level)
496 opts->comp_level = comp_level_default;
497 }
498
499 return 0;
500}
501#endif
Alexey Budankov51255a82019-03-18 20:42:19 +0300502static unsigned int comp_level_max = 22;
503
Alexey Budankov42e1fd82019-03-18 20:41:33 +0300504static int record__comp_enabled(struct record *rec)
505{
506 return rec->opts.comp_level > 0;
507}
508
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200509static int process_synthesized_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200510 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300511 struct perf_sample *sample __maybe_unused,
512 struct machine *machine __maybe_unused)
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200513{
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300514 struct record *rec = container_of(tool, struct record, tool);
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200515 return record__write(rec, NULL, event, event->header.size);
Arnaldo Carvalho de Melo234fbbf2009-10-26 19:23:18 -0200516}
517
Stephane Eraniand99c22e2020-04-22 08:50:38 -0700518static int process_locked_synthesized_event(struct perf_tool *tool,
519 union perf_event *event,
520 struct perf_sample *sample __maybe_unused,
521 struct machine *machine __maybe_unused)
522{
523 static pthread_mutex_t synth_lock = PTHREAD_MUTEX_INITIALIZER;
524 int ret;
525
526 pthread_mutex_lock(&synth_lock);
527 ret = process_synthesized_event(tool, event, sample, machine);
528 pthread_mutex_unlock(&synth_lock);
529 return ret;
530}
531
Jiri Olsaa5830532019-07-27 20:30:53 +0200532static int record__pushfn(struct mmap *map, void *to, void *bf, size_t size)
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300533{
534 struct record *rec = to;
535
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300536 if (record__comp_enabled(rec)) {
Jiri Olsabf59b302019-10-07 14:53:11 +0200537 size = zstd_compress(rec->session, map->data, mmap__mmap_len(map), bf, size);
Alexey Budankov5d7f4112019-03-18 20:43:35 +0300538 bf = map->data;
539 }
540
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300541 rec->samples++;
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200542 return record__write(rec, map, bf, size);
Arnaldo Carvalho de Melod37f1582017-10-05 16:39:55 -0300543}
544
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300545static volatile int signr = -1;
546static volatile int child_finished;
Anand K Mistryda231332020-05-13 12:20:23 +1000547#ifdef HAVE_EVENTFD_SUPPORT
548static int done_fd = -1;
549#endif
Wang Nanc0bdc1c2016-04-13 08:21:06 +0000550
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300551static void sig_handler(int sig)
552{
553 if (sig == SIGCHLD)
554 child_finished = 1;
555 else
556 signr = sig;
557
558 done = 1;
Anand K Mistryda231332020-05-13 12:20:23 +1000559#ifdef HAVE_EVENTFD_SUPPORT
560{
561 u64 tmp = 1;
562 /*
563 * It is possible for this signal handler to run after done is checked
564 * in the main loop, but before the perf counter fds are polled. If this
565 * happens, the poll() will continue to wait even though done is set,
566 * and will only break out if either another signal is received, or the
567 * counters are ready for read. To ensure the poll() doesn't sleep when
568 * done is set, use an eventfd (done_fd) to wake up the poll().
569 */
570 if (write(done_fd, &tmp, sizeof(tmp)) < 0)
571 pr_err("failed to signal wakeup fd, error: %m\n");
572}
573#endif // HAVE_EVENTFD_SUPPORT
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300574}
575
Wang Nana0748652016-11-26 07:03:28 +0000576static void sigsegv_handler(int sig)
577{
578 perf_hooks__recover();
579 sighandler_dump_stack(sig);
580}
581
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300582static void record__sig_exit(void)
583{
584 if (signr == -1)
585 return;
586
587 signal(signr, SIG_DFL);
588 raise(signr);
589}
590
Adrian Huntere31f0d02015-04-30 17:37:27 +0300591#ifdef HAVE_AUXTRACE_SUPPORT
592
Adrian Hunteref149c22015-04-09 18:53:45 +0300593static int record__process_auxtrace(struct perf_tool *tool,
Jiri Olsaa5830532019-07-27 20:30:53 +0200594 struct mmap *map,
Adrian Hunteref149c22015-04-09 18:53:45 +0300595 union perf_event *event, void *data1,
596 size_t len1, void *data2, size_t len2)
597{
598 struct record *rec = container_of(tool, struct record, tool);
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100599 struct perf_data *data = &rec->data;
Adrian Hunteref149c22015-04-09 18:53:45 +0300600 size_t padding;
601 u8 pad[8] = {0};
602
Adrian Hunter46e201e2019-10-04 11:31:20 +0300603 if (!perf_data__is_pipe(data) && perf_data__is_single_file(data)) {
Adrian Hunter99fa2982015-04-30 17:37:25 +0300604 off_t file_offset;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100605 int fd = perf_data__fd(data);
Adrian Hunter99fa2982015-04-30 17:37:25 +0300606 int err;
607
608 file_offset = lseek(fd, 0, SEEK_CUR);
609 if (file_offset == -1)
610 return -1;
611 err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
612 event, file_offset);
613 if (err)
614 return err;
615 }
616
Adrian Hunteref149c22015-04-09 18:53:45 +0300617 /* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
618 padding = (len1 + len2) & 7;
619 if (padding)
620 padding = 8 - padding;
621
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200622 record__write(rec, map, event, event->header.size);
623 record__write(rec, map, data1, len1);
Adrian Hunteref149c22015-04-09 18:53:45 +0300624 if (len2)
Jiri Olsaded2b8f2018-09-13 14:54:06 +0200625 record__write(rec, map, data2, len2);
626 record__write(rec, map, &pad, padding);
Adrian Hunteref149c22015-04-09 18:53:45 +0300627
628 return 0;
629}
630
631static int record__auxtrace_mmap_read(struct record *rec,
Jiri Olsaa5830532019-07-27 20:30:53 +0200632 struct mmap *map)
Adrian Hunteref149c22015-04-09 18:53:45 +0300633{
634 int ret;
635
Jiri Olsae035f4c2018-09-13 14:54:05 +0200636 ret = auxtrace_mmap__read(map, rec->itr, &rec->tool,
Adrian Hunteref149c22015-04-09 18:53:45 +0300637 record__process_auxtrace);
638 if (ret < 0)
639 return ret;
640
641 if (ret)
642 rec->samples++;
643
644 return 0;
645}
646
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300647static int record__auxtrace_mmap_read_snapshot(struct record *rec,
Jiri Olsaa5830532019-07-27 20:30:53 +0200648 struct mmap *map)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300649{
650 int ret;
651
Jiri Olsae035f4c2018-09-13 14:54:05 +0200652 ret = auxtrace_mmap__read_snapshot(map, rec->itr, &rec->tool,
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300653 record__process_auxtrace,
654 rec->opts.auxtrace_snapshot_size);
655 if (ret < 0)
656 return ret;
657
658 if (ret)
659 rec->samples++;
660
661 return 0;
662}
663
664static int record__auxtrace_read_snapshot_all(struct record *rec)
665{
666 int i;
667 int rc = 0;
668
Jiri Olsac976ee12019-07-30 13:04:59 +0200669 for (i = 0; i < rec->evlist->core.nr_mmaps; i++) {
Jiri Olsaa5830532019-07-27 20:30:53 +0200670 struct mmap *map = &rec->evlist->mmap[i];
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300671
Jiri Olsae035f4c2018-09-13 14:54:05 +0200672 if (!map->auxtrace_mmap.base)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300673 continue;
674
Jiri Olsae035f4c2018-09-13 14:54:05 +0200675 if (record__auxtrace_mmap_read_snapshot(rec, map) != 0) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300676 rc = -1;
677 goto out;
678 }
679 }
680out:
681 return rc;
682}
683
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300684static void record__read_auxtrace_snapshot(struct record *rec, bool on_exit)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300685{
686 pr_debug("Recording AUX area tracing snapshot\n");
687 if (record__auxtrace_read_snapshot_all(rec) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +0000688 trigger_error(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300689 } else {
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300690 if (auxtrace_record__snapshot_finish(rec->itr, on_exit))
Wang Nan5f9cf592016-04-20 18:59:49 +0000691 trigger_error(&auxtrace_snapshot_trigger);
692 else
693 trigger_ready(&auxtrace_snapshot_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300694 }
695}
696
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300697static int record__auxtrace_snapshot_exit(struct record *rec)
698{
699 if (trigger_is_error(&auxtrace_snapshot_trigger))
700 return 0;
701
702 if (!auxtrace_record__snapshot_started &&
703 auxtrace_record__snapshot_start(rec->itr))
704 return -1;
705
706 record__read_auxtrace_snapshot(rec, true);
707 if (trigger_is_error(&auxtrace_snapshot_trigger))
708 return -1;
709
710 return 0;
711}
712
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200713static int record__auxtrace_init(struct record *rec)
714{
715 int err;
716
717 if (!rec->itr) {
718 rec->itr = auxtrace_record__init(rec->evlist, &err);
719 if (err)
720 return err;
721 }
722
723 err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
724 rec->opts.auxtrace_snapshot_opts);
725 if (err)
726 return err;
727
Adrian Hunterc0a6de02019-11-15 14:42:16 +0200728 err = auxtrace_parse_sample_options(rec->itr, rec->evlist, &rec->opts,
729 rec->opts.auxtrace_sample_opts);
730 if (err)
731 return err;
732
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200733 return auxtrace_parse_filters(rec->evlist);
734}
735
Adrian Huntere31f0d02015-04-30 17:37:27 +0300736#else
737
738static inline
739int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
Jiri Olsaa5830532019-07-27 20:30:53 +0200740 struct mmap *map __maybe_unused)
Adrian Huntere31f0d02015-04-30 17:37:27 +0300741{
742 return 0;
743}
744
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300745static inline
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300746void record__read_auxtrace_snapshot(struct record *rec __maybe_unused,
747 bool on_exit __maybe_unused)
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +0300748{
749}
750
751static inline
752int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
753{
754 return 0;
755}
756
Alexander Shishkince7b0e42019-08-06 17:41:01 +0300757static inline
758int record__auxtrace_snapshot_exit(struct record *rec __maybe_unused)
759{
760 return 0;
761}
762
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +0200763static int record__auxtrace_init(struct record *rec __maybe_unused)
764{
765 return 0;
766}
767
Adrian Huntere31f0d02015-04-30 17:37:27 +0300768#endif
769
Adrian Hunter246eba82020-05-12 15:19:18 +0300770static int record__config_text_poke(struct evlist *evlist)
771{
772 struct evsel *evsel;
773 int err;
774
775 /* Nothing to do if text poke is already configured */
776 evlist__for_each_entry(evlist, evsel) {
777 if (evsel->core.attr.text_poke)
778 return 0;
779 }
780
781 err = parse_events(evlist, "dummy:u", NULL);
782 if (err)
783 return err;
784
785 evsel = evlist__last(evlist);
786
787 evsel->core.attr.freq = 0;
788 evsel->core.attr.sample_period = 1;
789 evsel->core.attr.text_poke = 1;
790 evsel->core.attr.ksymbol = 1;
791
792 evsel->core.system_wide = true;
793 evsel->no_aux_samples = true;
794 evsel->immediate = true;
795
796 /* Text poke must be collected on all CPUs */
797 perf_cpu_map__put(evsel->core.own_cpus);
798 evsel->core.own_cpus = perf_cpu_map__new(NULL);
799 perf_cpu_map__put(evsel->core.cpus);
800 evsel->core.cpus = perf_cpu_map__get(evsel->core.own_cpus);
801
802 evsel__set_sample_bit(evsel, TIME);
803
804 return 0;
805}
806
Adrian Huntereeb399b2019-10-04 11:31:21 +0300807static bool record__kcore_readable(struct machine *machine)
808{
809 char kcore[PATH_MAX];
810 int fd;
811
812 scnprintf(kcore, sizeof(kcore), "%s/proc/kcore", machine->root_dir);
813
814 fd = open(kcore, O_RDONLY);
815 if (fd < 0)
816 return false;
817
818 close(fd);
819
820 return true;
821}
822
823static int record__kcore_copy(struct machine *machine, struct perf_data *data)
824{
825 char from_dir[PATH_MAX];
826 char kcore_dir[PATH_MAX];
827 int ret;
828
829 snprintf(from_dir, sizeof(from_dir), "%s/proc", machine->root_dir);
830
831 ret = perf_data__make_kcore_dir(data, kcore_dir, sizeof(kcore_dir));
832 if (ret)
833 return ret;
834
835 return kcore_copy(from_dir, kcore_dir);
836}
837
Wang Nancda57a82016-06-27 10:24:03 +0000838static int record__mmap_evlist(struct record *rec,
Jiri Olsa63503db2019-07-21 13:23:52 +0200839 struct evlist *evlist)
Wang Nancda57a82016-06-27 10:24:03 +0000840{
841 struct record_opts *opts = &rec->opts;
Adrian Hunterc0a6de02019-11-15 14:42:16 +0200842 bool auxtrace_overwrite = opts->auxtrace_snapshot_mode ||
843 opts->auxtrace_sample_mode;
Wang Nancda57a82016-06-27 10:24:03 +0000844 char msg[512];
845
Alexey Budankovf13de662019-01-22 20:50:57 +0300846 if (opts->affinity != PERF_AFFINITY_SYS)
847 cpu__setup_cpunode_map();
848
Jiri Olsa9521b5f2019-07-28 12:45:35 +0200849 if (evlist__mmap_ex(evlist, opts->mmap_pages,
Wang Nancda57a82016-06-27 10:24:03 +0000850 opts->auxtrace_mmap_pages,
Adrian Hunterc0a6de02019-11-15 14:42:16 +0200851 auxtrace_overwrite,
Alexey Budankov470530b2019-03-18 20:40:26 +0300852 opts->nr_cblocks, opts->affinity,
Alexey Budankov51255a82019-03-18 20:42:19 +0300853 opts->mmap_flush, opts->comp_level) < 0) {
Wang Nancda57a82016-06-27 10:24:03 +0000854 if (errno == EPERM) {
855 pr_err("Permission error mapping pages.\n"
856 "Consider increasing "
857 "/proc/sys/kernel/perf_event_mlock_kb,\n"
858 "or try again with a smaller value of -m/--mmap_pages.\n"
859 "(current value: %u,%u)\n",
860 opts->mmap_pages, opts->auxtrace_mmap_pages);
861 return -errno;
862 } else {
863 pr_err("failed to mmap with %d (%s)\n", errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300864 str_error_r(errno, msg, sizeof(msg)));
Wang Nancda57a82016-06-27 10:24:03 +0000865 if (errno)
866 return -errno;
867 else
868 return -EINVAL;
869 }
870 }
871 return 0;
872}
873
874static int record__mmap(struct record *rec)
875{
876 return record__mmap_evlist(rec, rec->evlist);
877}
878
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300879static int record__open(struct record *rec)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200880{
Arnaldo Carvalho de Melod6195a62017-02-13 16:45:24 -0300881 char msg[BUFSIZ];
Jiri Olsa32dcd022019-07-21 13:23:51 +0200882 struct evsel *pos;
Jiri Olsa63503db2019-07-21 13:23:52 +0200883 struct evlist *evlist = rec->evlist;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200884 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -0300885 struct record_opts *opts = &rec->opts;
David Ahern8d3eca22012-08-26 12:24:47 -0600886 int rc = 0;
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -0200887
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300888 /*
Ian Rogers0a892c12020-04-22 10:36:15 -0700889 * For initial_delay or system wide, we need to add a dummy event so
890 * that we can track PERF_RECORD_MMAP to cover the delay of waiting or
891 * event synthesis.
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300892 */
Ian Rogers0a892c12020-04-22 10:36:15 -0700893 if (opts->initial_delay || target__has_cpu(&opts->target)) {
Adrian Hunter442ad2252020-06-29 12:19:51 +0300894 pos = perf_evlist__get_tracking_event(evlist);
895 if (!evsel__is_dummy_event(pos)) {
896 /* Set up dummy event. */
Arnaldo Carvalho de Melofacbf0b2020-07-08 13:49:15 -0300897 if (evlist__add_dummy(evlist))
Adrian Hunter442ad2252020-06-29 12:19:51 +0300898 return -ENOMEM;
899 pos = evlist__last(evlist);
900 perf_evlist__set_tracking_event(evlist, pos);
901 }
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300902
Ian Rogers0a892c12020-04-22 10:36:15 -0700903 /*
904 * Enable the dummy event when the process is forked for
905 * initial_delay, immediately for system wide.
906 */
Adrian Hunter442ad2252020-06-29 12:19:51 +0300907 if (opts->initial_delay && !pos->immediate)
Ian Rogers0a892c12020-04-22 10:36:15 -0700908 pos->core.attr.enable_on_exec = 1;
909 else
910 pos->immediate = 1;
Arnaldo Carvalho de Melod3dbf432017-11-03 15:34:34 -0300911 }
912
Arnaldo Carvalho de Meloe68ae9c2016-04-11 18:15:29 -0300913 perf_evlist__config(evlist, opts, &callchain_param);
Jiri Olsacac21422012-11-12 18:34:00 +0100914
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300915 evlist__for_each_entry(evlist, pos) {
Ingo Molnar3da297a2009-06-07 17:39:02 +0200916try_again:
Jiri Olsaaf663bd2019-07-21 13:24:39 +0200917 if (evsel__open(pos, pos->core.cpus, pos->core.threads) < 0) {
Arnaldo Carvalho de Meloae430892020-04-30 11:46:15 -0300918 if (evsel__fallback(pos, errno, msg, sizeof(msg))) {
Namhyung Kimbb963e12017-02-17 17:17:38 +0900919 if (verbose > 0)
Arnaldo Carvalho de Meloc0a54342012-12-13 14:16:30 -0300920 ui__warning("%s\n", msg);
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300921 goto try_again;
922 }
Andi Kleencf99ad12018-10-01 12:59:27 -0700923 if ((errno == EINVAL || errno == EBADF) &&
924 pos->leader != pos &&
925 pos->weak_group) {
Andi Kleen4804e012019-11-20 16:15:19 -0800926 pos = perf_evlist__reset_weak_group(evlist, pos, true);
Andi Kleencf99ad12018-10-01 12:59:27 -0700927 goto try_again;
928 }
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300929 rc = -errno;
Arnaldo Carvalho de Melo2bb72db2020-05-04 13:43:03 -0300930 evsel__open_strerror(pos, &opts->target, errno, msg, sizeof(msg));
Arnaldo Carvalho de Melo56e52e82012-12-13 15:10:58 -0300931 ui__error("%s\n", msg);
David Ahern8d3eca22012-08-26 12:24:47 -0600932 goto out;
Zhang, Yanmind6d901c2010-03-18 11:36:05 -0300933 }
Andi Kleenbfd8f722017-11-17 13:42:58 -0800934
935 pos->supported = true;
Li Zefanc171b552009-10-15 11:22:07 +0800936 }
Arnaldo Carvalho de Meloa43d3f02010-12-25 12:12:25 -0200937
Arnaldo Carvalho de Meloc8b567c2019-09-23 11:07:29 -0300938 if (symbol_conf.kptr_restrict && !perf_evlist__exclude_kernel(evlist)) {
939 pr_warning(
940"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
941"check /proc/sys/kernel/kptr_restrict and /proc/sys/kernel/perf_event_paranoid.\n\n"
942"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
943"file is not found in the buildid cache or in the vmlinux path.\n\n"
944"Samples in kernel modules won't be resolved at all.\n\n"
945"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
946"even with a suitable vmlinux or kallsyms file.\n\n");
947 }
948
Arnaldo Carvalho de Melo23d4aad2015-03-24 19:23:47 -0300949 if (perf_evlist__apply_filters(evlist, &pos)) {
Arnaldo Carvalho de Melo62d94b02017-06-27 11:22:31 -0300950 pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
Arnaldo Carvalho de Melo8ab2e962020-04-29 16:07:09 -0300951 pos->filter, evsel__name(pos), errno,
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -0300952 str_error_r(errno, msg, sizeof(msg)));
David Ahern8d3eca22012-08-26 12:24:47 -0600953 rc = -1;
954 goto out;
Frederic Weisbecker0a102472011-02-26 04:51:54 +0100955 }
956
Wang Nancda57a82016-06-27 10:24:03 +0000957 rc = record__mmap(rec);
958 if (rc)
David Ahern8d3eca22012-08-26 12:24:47 -0600959 goto out;
Arnaldo Carvalho de Melo0a27d7f2011-01-14 15:50:51 -0200960
Jiri Olsa563aecb2013-06-05 13:35:06 +0200961 session->evlist = evlist;
Arnaldo Carvalho de Melo7b56cce2012-08-01 19:31:00 -0300962 perf_session__set_id_hdr_size(session);
David Ahern8d3eca22012-08-26 12:24:47 -0600963out:
964 return rc;
Peter Zijlstra16c8a102009-05-05 17:50:27 +0200965}
966
Namhyung Kime3d59112015-01-29 17:06:44 +0900967static int process_sample_event(struct perf_tool *tool,
968 union perf_event *event,
969 struct perf_sample *sample,
Jiri Olsa32dcd022019-07-21 13:23:51 +0200970 struct evsel *evsel,
Namhyung Kime3d59112015-01-29 17:06:44 +0900971 struct machine *machine)
972{
973 struct record *rec = container_of(tool, struct record, tool);
974
Jin Yao68588ba2017-12-08 21:13:42 +0800975 if (rec->evlist->first_sample_time == 0)
976 rec->evlist->first_sample_time = sample->time;
Namhyung Kime3d59112015-01-29 17:06:44 +0900977
Jin Yao68588ba2017-12-08 21:13:42 +0800978 rec->evlist->last_sample_time = sample->time;
979
980 if (rec->buildid_all)
981 return 0;
982
983 rec->samples++;
Namhyung Kime3d59112015-01-29 17:06:44 +0900984 return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
985}
986
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -0300987static int process_buildids(struct record *rec)
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200988{
Jiri Olsaf5fc14122013-10-15 16:27:32 +0200989 struct perf_session *session = rec->session;
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -0200990
Jiri Olsa45112e82019-02-21 10:41:29 +0100991 if (perf_data__size(&rec->data) == 0)
Arnaldo Carvalho de Melo9f591fd2010-03-11 15:53:11 -0300992 return 0;
993
Namhyung Kim00dc8652014-11-04 10:14:32 +0900994 /*
995 * During this process, it'll load kernel map and replace the
996 * dso->long_name to a real pathname it found. In this case
997 * we prefer the vmlinux path like
998 * /lib/modules/3.16.4/build/vmlinux
999 *
1000 * rather than build-id path (in debug directory).
1001 * $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
1002 */
1003 symbol_conf.ignore_vmlinux_buildid = true;
1004
Namhyung Kim61566812016-01-11 22:37:09 +09001005 /*
1006 * If --buildid-all is given, it marks all DSO regardless of hits,
Jin Yao68588ba2017-12-08 21:13:42 +08001007 * so no need to process samples. But if timestamp_boundary is enabled,
1008 * it still needs to walk on all samples to get the timestamps of
1009 * first/last samples.
Namhyung Kim61566812016-01-11 22:37:09 +09001010 */
Jin Yao68588ba2017-12-08 21:13:42 +08001011 if (rec->buildid_all && !rec->timestamp_boundary)
Namhyung Kim61566812016-01-11 22:37:09 +09001012 rec->tool.sample = NULL;
1013
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -03001014 return perf_session__process_events(session);
Arnaldo Carvalho de Melo6122e4e2010-02-03 16:52:05 -02001015}
1016
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02001017static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001018{
1019 int err;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001020 struct perf_tool *tool = data;
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001021 /*
1022 *As for guest kernel when processing subcommand record&report,
1023 *we arrange module mmap prior to guest kernel mmap and trigger
1024 *a preload dso because default guest module symbols are loaded
1025 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
1026 *method is used to avoid symbol missing when the first addr is
1027 *in module instead of in guest kernel.
1028 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001029 err = perf_event__synthesize_modules(tool, process_synthesized_event,
Arnaldo Carvalho de Melo743eb8682011-11-28 07:56:39 -02001030 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001031 if (err < 0)
1032 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -03001033 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001034
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001035 /*
1036 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
1037 * have no _text sometimes.
1038 */
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001039 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
Adrian Hunter0ae617b2014-01-29 16:14:40 +02001040 machine);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001041 if (err < 0)
1042 pr_err("Couldn't record guest kernel [%d]'s reference"
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -03001043 " relocation symbol.\n", machine->pid);
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001044}
1045
Frederic Weisbecker98402802010-05-02 22:05:29 +02001046static struct perf_event_header finished_round_event = {
1047 .size = sizeof(struct perf_event_header),
1048 .type = PERF_RECORD_FINISHED_ROUND,
1049};
1050
Jiri Olsaa5830532019-07-27 20:30:53 +02001051static void record__adjust_affinity(struct record *rec, struct mmap *map)
Alexey Budankovf13de662019-01-22 20:50:57 +03001052{
1053 if (rec->opts.affinity != PERF_AFFINITY_SYS &&
Alexey Budankov8384a262019-12-03 14:45:27 +03001054 !bitmap_equal(rec->affinity_mask.bits, map->affinity_mask.bits,
1055 rec->affinity_mask.nbits)) {
1056 bitmap_zero(rec->affinity_mask.bits, rec->affinity_mask.nbits);
1057 bitmap_or(rec->affinity_mask.bits, rec->affinity_mask.bits,
1058 map->affinity_mask.bits, rec->affinity_mask.nbits);
1059 sched_setaffinity(0, MMAP_CPU_MASK_BYTES(&rec->affinity_mask),
1060 (cpu_set_t *)rec->affinity_mask.bits);
1061 if (verbose == 2)
1062 mmap_cpu_mask__scnprintf(&rec->affinity_mask, "thread");
Alexey Budankovf13de662019-01-22 20:50:57 +03001063 }
1064}
1065
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001066static size_t process_comp_header(void *record, size_t increment)
1067{
Jiri Olsa72932372019-08-28 15:57:16 +02001068 struct perf_record_compressed *event = record;
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001069 size_t size = sizeof(*event);
1070
1071 if (increment) {
1072 event->header.size += increment;
1073 return increment;
1074 }
1075
1076 event->header.type = PERF_RECORD_COMPRESSED;
1077 event->header.size = size;
1078
1079 return size;
1080}
1081
1082static size_t zstd_compress(struct perf_session *session, void *dst, size_t dst_size,
1083 void *src, size_t src_size)
1084{
1085 size_t compressed;
Jiri Olsa72932372019-08-28 15:57:16 +02001086 size_t max_record_size = PERF_SAMPLE_MAX_SIZE - sizeof(struct perf_record_compressed) - 1;
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001087
1088 compressed = zstd_compress_stream_to_records(&session->zstd_data, dst, dst_size, src, src_size,
1089 max_record_size, process_comp_header);
1090
1091 session->bytes_transferred += src_size;
1092 session->bytes_compressed += compressed;
1093
1094 return compressed;
1095}
1096
Jiri Olsa63503db2019-07-21 13:23:52 +02001097static int record__mmap_read_evlist(struct record *rec, struct evlist *evlist,
Alexey Budankov470530b2019-03-18 20:40:26 +03001098 bool overwrite, bool synch)
Frederic Weisbecker98402802010-05-02 22:05:29 +02001099{
Jiri Olsadcabb502014-07-25 16:56:16 +02001100 u64 bytes_written = rec->bytes_written;
Peter Zijlstra0e2e63d2010-05-20 14:45:26 +02001101 int i;
David Ahern8d3eca22012-08-26 12:24:47 -06001102 int rc = 0;
Jiri Olsaa5830532019-07-27 20:30:53 +02001103 struct mmap *maps;
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001104 int trace_fd = rec->data.file.fd;
Alexey Budankovef781122019-03-18 20:44:12 +03001105 off_t off = 0;
Frederic Weisbecker98402802010-05-02 22:05:29 +02001106
Wang Nancb216862016-06-27 10:24:04 +00001107 if (!evlist)
1108 return 0;
Adrian Hunteref149c22015-04-09 18:53:45 +03001109
Wang Nan0b72d692017-12-04 16:51:07 +00001110 maps = overwrite ? evlist->overwrite_mmap : evlist->mmap;
Wang Nana4ea0ec2016-07-14 08:34:36 +00001111 if (!maps)
1112 return 0;
Wang Nancb216862016-06-27 10:24:04 +00001113
Wang Nan0b72d692017-12-04 16:51:07 +00001114 if (overwrite && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
Wang Nan54cc54d2016-07-14 08:34:42 +00001115 return 0;
1116
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001117 if (record__aio_enabled(rec))
1118 off = record__aio_get_pos(trace_fd);
1119
Jiri Olsac976ee12019-07-30 13:04:59 +02001120 for (i = 0; i < evlist->core.nr_mmaps; i++) {
Alexey Budankov470530b2019-03-18 20:40:26 +03001121 u64 flush = 0;
Jiri Olsaa5830532019-07-27 20:30:53 +02001122 struct mmap *map = &maps[i];
Wang Nana4ea0ec2016-07-14 08:34:36 +00001123
Jiri Olsa547740f2019-07-27 22:07:44 +02001124 if (map->core.base) {
Alexey Budankovf13de662019-01-22 20:50:57 +03001125 record__adjust_affinity(rec, map);
Alexey Budankov470530b2019-03-18 20:40:26 +03001126 if (synch) {
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001127 flush = map->core.flush;
1128 map->core.flush = 1;
Alexey Budankov470530b2019-03-18 20:40:26 +03001129 }
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001130 if (!record__aio_enabled(rec)) {
Alexey Budankovef781122019-03-18 20:44:12 +03001131 if (perf_mmap__push(map, rec, record__pushfn) < 0) {
Alexey Budankov470530b2019-03-18 20:40:26 +03001132 if (synch)
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001133 map->core.flush = flush;
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001134 rc = -1;
1135 goto out;
1136 }
1137 } else {
Alexey Budankovef781122019-03-18 20:44:12 +03001138 if (record__aio_push(rec, map, &off) < 0) {
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001139 record__aio_set_pos(trace_fd, off);
Alexey Budankov470530b2019-03-18 20:40:26 +03001140 if (synch)
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001141 map->core.flush = flush;
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001142 rc = -1;
1143 goto out;
1144 }
David Ahern8d3eca22012-08-26 12:24:47 -06001145 }
Alexey Budankov470530b2019-03-18 20:40:26 +03001146 if (synch)
Jiri Olsa65aa2e62019-08-27 16:05:18 +02001147 map->core.flush = flush;
David Ahern8d3eca22012-08-26 12:24:47 -06001148 }
Adrian Hunteref149c22015-04-09 18:53:45 +03001149
Jiri Olsae035f4c2018-09-13 14:54:05 +02001150 if (map->auxtrace_mmap.base && !rec->opts.auxtrace_snapshot_mode &&
Adrian Hunterc0a6de02019-11-15 14:42:16 +02001151 !rec->opts.auxtrace_sample_mode &&
Jiri Olsae035f4c2018-09-13 14:54:05 +02001152 record__auxtrace_mmap_read(rec, map) != 0) {
Adrian Hunteref149c22015-04-09 18:53:45 +03001153 rc = -1;
1154 goto out;
1155 }
Frederic Weisbecker98402802010-05-02 22:05:29 +02001156 }
1157
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001158 if (record__aio_enabled(rec))
1159 record__aio_set_pos(trace_fd, off);
1160
Jiri Olsadcabb502014-07-25 16:56:16 +02001161 /*
1162 * Mark the round finished in case we wrote
1163 * at least one event.
1164 */
1165 if (bytes_written != rec->bytes_written)
Jiri Olsaded2b8f2018-09-13 14:54:06 +02001166 rc = record__write(rec, NULL, &finished_round_event, sizeof(finished_round_event));
David Ahern8d3eca22012-08-26 12:24:47 -06001167
Wang Nan0b72d692017-12-04 16:51:07 +00001168 if (overwrite)
Wang Nan54cc54d2016-07-14 08:34:42 +00001169 perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
David Ahern8d3eca22012-08-26 12:24:47 -06001170out:
1171 return rc;
Frederic Weisbecker98402802010-05-02 22:05:29 +02001172}
1173
Alexey Budankov470530b2019-03-18 20:40:26 +03001174static int record__mmap_read_all(struct record *rec, bool synch)
Wang Nancb216862016-06-27 10:24:04 +00001175{
1176 int err;
1177
Alexey Budankov470530b2019-03-18 20:40:26 +03001178 err = record__mmap_read_evlist(rec, rec->evlist, false, synch);
Wang Nancb216862016-06-27 10:24:04 +00001179 if (err)
1180 return err;
1181
Alexey Budankov470530b2019-03-18 20:40:26 +03001182 return record__mmap_read_evlist(rec, rec->evlist, true, synch);
Wang Nancb216862016-06-27 10:24:04 +00001183}
1184
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001185static void record__init_features(struct record *rec)
David Ahern57706ab2013-11-06 11:41:34 -07001186{
David Ahern57706ab2013-11-06 11:41:34 -07001187 struct perf_session *session = rec->session;
1188 int feat;
1189
1190 for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
1191 perf_header__set_feat(&session->header, feat);
1192
1193 if (rec->no_buildid)
1194 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
1195
Jiri Olsace9036a2019-07-21 13:24:23 +02001196 if (!have_tracepoints(&rec->evlist->core.entries))
David Ahern57706ab2013-11-06 11:41:34 -07001197 perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
1198
1199 if (!rec->opts.branch_stack)
1200 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
Adrian Hunteref149c22015-04-09 18:53:45 +03001201
1202 if (!rec->opts.full_auxtrace)
1203 perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
Jiri Olsaffa517a2015-10-25 15:51:43 +01001204
Alexey Budankovcf790512018-10-09 17:36:24 +03001205 if (!(rec->opts.use_clockid && rec->opts.clockid_res_ns))
1206 perf_header__clear_feat(&session->header, HEADER_CLOCKID);
1207
Jiri Olsad1e325c2020-08-05 11:34:40 +02001208 if (!rec->opts.use_clockid)
1209 perf_header__clear_feat(&session->header, HEADER_CLOCK_DATA);
1210
Jiri Olsa258031c2019-03-08 14:47:39 +01001211 perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT);
Alexey Budankov42e1fd82019-03-18 20:41:33 +03001212 if (!record__comp_enabled(rec))
1213 perf_header__clear_feat(&session->header, HEADER_COMPRESSED);
Jiri Olsa258031c2019-03-08 14:47:39 +01001214
Jiri Olsaffa517a2015-10-25 15:51:43 +01001215 perf_header__clear_feat(&session->header, HEADER_STAT);
David Ahern57706ab2013-11-06 11:41:34 -07001216}
1217
Wang Nane1ab48b2016-02-26 09:32:10 +00001218static void
1219record__finish_output(struct record *rec)
1220{
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001221 struct perf_data *data = &rec->data;
1222 int fd = perf_data__fd(data);
Wang Nane1ab48b2016-02-26 09:32:10 +00001223
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001224 if (data->is_pipe)
Wang Nane1ab48b2016-02-26 09:32:10 +00001225 return;
1226
1227 rec->session->header.data_size += rec->bytes_written;
Jiri Olsa45112e82019-02-21 10:41:29 +01001228 data->file.size = lseek(perf_data__fd(data), 0, SEEK_CUR);
Wang Nane1ab48b2016-02-26 09:32:10 +00001229
1230 if (!rec->no_buildid) {
1231 process_buildids(rec);
1232
1233 if (rec->buildid_all)
1234 dsos__hit_all(rec->session);
1235 }
1236 perf_session__write_header(rec->session, rec->evlist, fd, true);
1237
1238 return;
1239}
1240
Wang Nan4ea648a2016-07-14 08:34:47 +00001241static int record__synthesize_workload(struct record *rec, bool tail)
Wang Nanbe7b0c92016-04-20 18:59:54 +00001242{
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -03001243 int err;
Jiri Olsa9749b902019-07-21 13:23:50 +02001244 struct perf_thread_map *thread_map;
Wang Nanbe7b0c92016-04-20 18:59:54 +00001245
Wang Nan4ea648a2016-07-14 08:34:47 +00001246 if (rec->opts.tail_synthesize != tail)
1247 return 0;
1248
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -03001249 thread_map = thread_map__new_by_tid(rec->evlist->workload.pid);
1250 if (thread_map == NULL)
1251 return -1;
1252
1253 err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
Wang Nanbe7b0c92016-04-20 18:59:54 +00001254 process_synthesized_event,
1255 &rec->session->machines.host,
Mark Drayton3fcb10e2018-12-04 12:34:20 -08001256 rec->opts.sample_address);
Jiri Olsa7836e522019-07-21 13:24:20 +02001257 perf_thread_map__put(thread_map);
Arnaldo Carvalho de Melo9d6aae72017-02-14 10:59:04 -03001258 return err;
Wang Nanbe7b0c92016-04-20 18:59:54 +00001259}
1260
Wang Nan4ea648a2016-07-14 08:34:47 +00001261static int record__synthesize(struct record *rec, bool tail);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001262
Wang Nanecfd7a92016-04-13 08:21:07 +00001263static int
1264record__switch_output(struct record *rec, bool at_exit)
1265{
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001266 struct perf_data *data = &rec->data;
Wang Nanecfd7a92016-04-13 08:21:07 +00001267 int fd, err;
Andi Kleen03724b22019-03-14 15:49:55 -07001268 char *new_filename;
Wang Nanecfd7a92016-04-13 08:21:07 +00001269
1270 /* Same Size: "2015122520103046"*/
1271 char timestamp[] = "InvalidTimestamp";
1272
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001273 record__aio_mmap_read_sync(rec);
1274
Wang Nan4ea648a2016-07-14 08:34:47 +00001275 record__synthesize(rec, true);
1276 if (target__none(&rec->opts.target))
1277 record__synthesize_workload(rec, true);
1278
Wang Nanecfd7a92016-04-13 08:21:07 +00001279 rec->samples = 0;
1280 record__finish_output(rec);
1281 err = fetch_current_timestamp(timestamp, sizeof(timestamp));
1282 if (err) {
1283 pr_err("Failed to get current timestamp\n");
1284 return -EINVAL;
1285 }
1286
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001287 fd = perf_data__switch(data, timestamp,
Wang Nanecfd7a92016-04-13 08:21:07 +00001288 rec->session->header.data_offset,
Andi Kleen03724b22019-03-14 15:49:55 -07001289 at_exit, &new_filename);
Wang Nanecfd7a92016-04-13 08:21:07 +00001290 if (fd >= 0 && !at_exit) {
1291 rec->bytes_written = 0;
1292 rec->session->header.data_size = 0;
1293 }
1294
1295 if (!quiet)
1296 fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
Jiri Olsa2d4f2792019-02-21 10:41:30 +01001297 data->path, timestamp);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001298
Andi Kleen03724b22019-03-14 15:49:55 -07001299 if (rec->switch_output.num_files) {
1300 int n = rec->switch_output.cur_file + 1;
1301
1302 if (n >= rec->switch_output.num_files)
1303 n = 0;
1304 rec->switch_output.cur_file = n;
1305 if (rec->switch_output.filenames[n]) {
1306 remove(rec->switch_output.filenames[n]);
Arnaldo Carvalho de Melod8f9da22019-07-04 12:06:20 -03001307 zfree(&rec->switch_output.filenames[n]);
Andi Kleen03724b22019-03-14 15:49:55 -07001308 }
1309 rec->switch_output.filenames[n] = new_filename;
1310 } else {
1311 free(new_filename);
1312 }
1313
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001314 /* Output tracking events */
Wang Nanbe7b0c92016-04-20 18:59:54 +00001315 if (!at_exit) {
Wang Nan4ea648a2016-07-14 08:34:47 +00001316 record__synthesize(rec, false);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001317
Wang Nanbe7b0c92016-04-20 18:59:54 +00001318 /*
1319 * In 'perf record --switch-output' without -a,
1320 * record__synthesize() in record__switch_output() won't
1321 * generate tracking events because there's no thread_map
1322 * in evlist. Which causes newly created perf.data doesn't
1323 * contain map and comm information.
1324 * Create a fake thread_map and directly call
1325 * perf_event__synthesize_thread_map() for those events.
1326 */
1327 if (target__none(&rec->opts.target))
Wang Nan4ea648a2016-07-14 08:34:47 +00001328 record__synthesize_workload(rec, false);
Wang Nanbe7b0c92016-04-20 18:59:54 +00001329 }
Wang Nanecfd7a92016-04-13 08:21:07 +00001330 return fd;
1331}
1332
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001333static volatile int workload_exec_errno;
1334
1335/*
1336 * perf_evlist__prepare_workload will send a SIGUSR1
1337 * if the fork fails, since we asked by setting its
1338 * want_signal to true.
1339 */
Namhyung Kim45604712014-05-12 09:47:24 +09001340static void workload_exec_failed_signal(int signo __maybe_unused,
1341 siginfo_t *info,
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001342 void *ucontext __maybe_unused)
1343{
1344 workload_exec_errno = info->si_value.sival_int;
1345 done = 1;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001346 child_finished = 1;
1347}
1348
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001349static void snapshot_sig_handler(int sig);
Jiri Olsabfacbe32017-01-09 10:52:00 +01001350static void alarm_sig_handler(int sig);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001351
Wang Nanee667f92016-06-27 10:24:05 +00001352static const struct perf_event_mmap_page *
Jiri Olsa63503db2019-07-21 13:23:52 +02001353perf_evlist__pick_pc(struct evlist *evlist)
Wang Nanee667f92016-06-27 10:24:05 +00001354{
Wang Nanb2cb6152016-07-14 08:34:39 +00001355 if (evlist) {
Jiri Olsa547740f2019-07-27 22:07:44 +02001356 if (evlist->mmap && evlist->mmap[0].core.base)
1357 return evlist->mmap[0].core.base;
1358 if (evlist->overwrite_mmap && evlist->overwrite_mmap[0].core.base)
1359 return evlist->overwrite_mmap[0].core.base;
Wang Nanb2cb6152016-07-14 08:34:39 +00001360 }
Wang Nanee667f92016-06-27 10:24:05 +00001361 return NULL;
1362}
1363
Wang Nanc45628b2016-05-24 02:28:59 +00001364static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
1365{
Wang Nanee667f92016-06-27 10:24:05 +00001366 const struct perf_event_mmap_page *pc;
1367
1368 pc = perf_evlist__pick_pc(rec->evlist);
1369 if (pc)
1370 return pc;
Wang Nanc45628b2016-05-24 02:28:59 +00001371 return NULL;
1372}
1373
Wang Nan4ea648a2016-07-14 08:34:47 +00001374static int record__synthesize(struct record *rec, bool tail)
Wang Nanc45c86e2016-02-26 09:32:07 +00001375{
1376 struct perf_session *session = rec->session;
1377 struct machine *machine = &session->machines.host;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001378 struct perf_data *data = &rec->data;
Wang Nanc45c86e2016-02-26 09:32:07 +00001379 struct record_opts *opts = &rec->opts;
1380 struct perf_tool *tool = &rec->tool;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001381 int fd = perf_data__fd(data);
Wang Nanc45c86e2016-02-26 09:32:07 +00001382 int err = 0;
Stephane Eraniand99c22e2020-04-22 08:50:38 -07001383 event_op f = process_synthesized_event;
Wang Nanc45c86e2016-02-26 09:32:07 +00001384
Wang Nan4ea648a2016-07-14 08:34:47 +00001385 if (rec->opts.tail_synthesize != tail)
1386 return 0;
1387
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001388 if (data->is_pipe) {
Jiri Olsaa2015512018-03-14 10:22:04 +01001389 /*
1390 * We need to synthesize events first, because some
1391 * features works on top of them (on report side).
1392 */
Jiri Olsa318ec182018-08-30 08:32:15 +02001393 err = perf_event__synthesize_attrs(tool, rec->evlist,
Wang Nanc45c86e2016-02-26 09:32:07 +00001394 process_synthesized_event);
1395 if (err < 0) {
1396 pr_err("Couldn't synthesize attrs.\n");
1397 goto out;
1398 }
1399
Jiri Olsaa2015512018-03-14 10:22:04 +01001400 err = perf_event__synthesize_features(tool, session, rec->evlist,
1401 process_synthesized_event);
1402 if (err < 0) {
1403 pr_err("Couldn't synthesize features.\n");
1404 return err;
1405 }
1406
Jiri Olsace9036a2019-07-21 13:24:23 +02001407 if (have_tracepoints(&rec->evlist->core.entries)) {
Wang Nanc45c86e2016-02-26 09:32:07 +00001408 /*
1409 * FIXME err <= 0 here actually means that
1410 * there were no tracepoints so its not really
1411 * an error, just that we don't need to
1412 * synthesize anything. We really have to
1413 * return this more properly and also
1414 * propagate errors that now are calling die()
1415 */
1416 err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
1417 process_synthesized_event);
1418 if (err <= 0) {
1419 pr_err("Couldn't record tracing data.\n");
1420 goto out;
1421 }
1422 rec->bytes_written += err;
1423 }
1424 }
1425
Wang Nanc45628b2016-05-24 02:28:59 +00001426 err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
Adrian Hunter46bc29b2016-03-08 10:38:44 +02001427 process_synthesized_event, machine);
1428 if (err)
1429 goto out;
1430
Adrian Hunterc0a6de02019-11-15 14:42:16 +02001431 /* Synthesize id_index before auxtrace_info */
1432 if (rec->opts.auxtrace_sample_mode) {
1433 err = perf_event__synthesize_id_index(tool,
1434 process_synthesized_event,
1435 session->evlist, machine);
1436 if (err)
1437 goto out;
1438 }
1439
Wang Nanc45c86e2016-02-26 09:32:07 +00001440 if (rec->opts.full_auxtrace) {
1441 err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
1442 session, process_synthesized_event);
1443 if (err)
1444 goto out;
1445 }
1446
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03001447 if (!perf_evlist__exclude_kernel(rec->evlist)) {
1448 err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
1449 machine);
1450 WARN_ONCE(err < 0, "Couldn't record kernel reference relocation symbol\n"
1451 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
1452 "Check /proc/kallsyms permission or run as root.\n");
Wang Nanc45c86e2016-02-26 09:32:07 +00001453
Arnaldo Carvalho de Melo6c443952017-11-14 11:03:19 -03001454 err = perf_event__synthesize_modules(tool, process_synthesized_event,
1455 machine);
1456 WARN_ONCE(err < 0, "Couldn't record kernel module information.\n"
1457 "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
1458 "Check /proc/modules permission or run as root.\n");
1459 }
Wang Nanc45c86e2016-02-26 09:32:07 +00001460
1461 if (perf_guest) {
1462 machines__process_guests(&session->machines,
1463 perf_event__synthesize_guest_os, tool);
1464 }
1465
Andi Kleenbfd8f722017-11-17 13:42:58 -08001466 err = perf_event__synthesize_extra_attr(&rec->tool,
1467 rec->evlist,
1468 process_synthesized_event,
1469 data->is_pipe);
1470 if (err)
1471 goto out;
1472
Jiri Olsa03617c22019-07-21 13:24:42 +02001473 err = perf_event__synthesize_thread_map2(&rec->tool, rec->evlist->core.threads,
Andi Kleen373565d2017-11-17 13:42:59 -08001474 process_synthesized_event,
1475 NULL);
1476 if (err < 0) {
1477 pr_err("Couldn't synthesize thread map.\n");
1478 return err;
1479 }
1480
Jiri Olsaf72f9012019-07-21 13:24:41 +02001481 err = perf_event__synthesize_cpu_map(&rec->tool, rec->evlist->core.cpus,
Andi Kleen373565d2017-11-17 13:42:59 -08001482 process_synthesized_event, NULL);
1483 if (err < 0) {
1484 pr_err("Couldn't synthesize cpu map.\n");
1485 return err;
1486 }
1487
Song Liue5416952019-03-11 22:30:41 -07001488 err = perf_event__synthesize_bpf_events(session, process_synthesized_event,
Song Liu7b612e22019-01-17 08:15:19 -08001489 machine, opts);
1490 if (err < 0)
1491 pr_warning("Couldn't synthesize bpf events.\n");
1492
Namhyung Kimab640692020-03-25 21:45:33 +09001493 err = perf_event__synthesize_cgroups(tool, process_synthesized_event,
1494 machine);
1495 if (err < 0)
1496 pr_warning("Couldn't synthesize cgroup events.\n");
1497
Stephane Eraniand99c22e2020-04-22 08:50:38 -07001498 if (rec->opts.nr_threads_synthesize > 1) {
1499 perf_set_multithreaded();
1500 f = process_locked_synthesized_event;
1501 }
1502
Jiri Olsa03617c22019-07-21 13:24:42 +02001503 err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->core.threads,
Stephane Eraniand99c22e2020-04-22 08:50:38 -07001504 f, opts->sample_address,
1505 rec->opts.nr_threads_synthesize);
1506
1507 if (rec->opts.nr_threads_synthesize > 1)
1508 perf_set_singlethreaded();
1509
Wang Nanc45c86e2016-02-26 09:32:07 +00001510out:
1511 return err;
1512}
1513
Arnaldo Carvalho de Melo899e5ff2020-04-27 17:56:37 -03001514static int record__process_signal_event(union perf_event *event __maybe_unused, void *data)
1515{
1516 struct record *rec = data;
1517 pthread_kill(rec->thread_id, SIGUSR2);
1518 return 0;
1519}
1520
Arnaldo Carvalho de Melo23cbb412020-04-28 14:58:29 -03001521static int record__setup_sb_evlist(struct record *rec)
1522{
1523 struct record_opts *opts = &rec->opts;
1524
1525 if (rec->sb_evlist != NULL) {
1526 /*
1527 * We get here if --switch-output-event populated the
1528 * sb_evlist, so associate a callback that will send a SIGUSR2
1529 * to the main thread.
1530 */
1531 evlist__set_cb(rec->sb_evlist, record__process_signal_event, rec);
1532 rec->thread_id = pthread_self();
1533 }
Jin Yao1101c872020-08-05 10:29:37 +08001534#ifdef HAVE_LIBBPF_SUPPORT
Arnaldo Carvalho de Melo23cbb412020-04-28 14:58:29 -03001535 if (!opts->no_bpf_event) {
1536 if (rec->sb_evlist == NULL) {
1537 rec->sb_evlist = evlist__new();
1538
1539 if (rec->sb_evlist == NULL) {
1540 pr_err("Couldn't create side band evlist.\n.");
1541 return -1;
1542 }
1543 }
1544
1545 if (evlist__add_bpf_sb_event(rec->sb_evlist, &rec->session->header.env)) {
1546 pr_err("Couldn't ask for PERF_RECORD_BPF_EVENT side band events.\n.");
1547 return -1;
1548 }
1549 }
Jin Yao1101c872020-08-05 10:29:37 +08001550#endif
Arnaldo Carvalho de Melo23cbb412020-04-28 14:58:29 -03001551 if (perf_evlist__start_sb_thread(rec->sb_evlist, &rec->opts.target)) {
1552 pr_debug("Couldn't start the BPF side band thread:\nBPF programs starting from now on won't be annotatable\n");
1553 opts->no_bpf_event = true;
1554 }
1555
1556 return 0;
1557}
1558
Jiri Olsad1e325c2020-08-05 11:34:40 +02001559static int record__init_clock(struct record *rec)
1560{
1561 struct perf_session *session = rec->session;
1562 struct timespec ref_clockid;
1563 struct timeval ref_tod;
1564 u64 ref;
1565
1566 if (!rec->opts.use_clockid)
1567 return 0;
1568
Jiri Olsa9d88a1a12020-08-05 11:34:41 +02001569 if (rec->opts.use_clockid && rec->opts.clockid_res_ns)
1570 session->header.env.clock.clockid_res_ns = rec->opts.clockid_res_ns;
1571
Jiri Olsad1e325c2020-08-05 11:34:40 +02001572 session->header.env.clock.clockid = rec->opts.clockid;
1573
1574 if (gettimeofday(&ref_tod, NULL) != 0) {
1575 pr_err("gettimeofday failed, cannot set reference time.\n");
1576 return -1;
1577 }
1578
1579 if (clock_gettime(rec->opts.clockid, &ref_clockid)) {
1580 pr_err("clock_gettime failed, cannot set reference time.\n");
1581 return -1;
1582 }
1583
1584 ref = (u64) ref_tod.tv_sec * NSEC_PER_SEC +
1585 (u64) ref_tod.tv_usec * NSEC_PER_USEC;
1586
1587 session->header.env.clock.tod_ns = ref;
1588
1589 ref = (u64) ref_clockid.tv_sec * NSEC_PER_SEC +
1590 (u64) ref_clockid.tv_nsec;
1591
1592 session->header.env.clock.clockid_ns = ref;
1593 return 0;
1594}
1595
Adrian Hunterd20aff12020-09-01 12:37:57 +03001596static void hit_auxtrace_snapshot_trigger(struct record *rec)
1597{
1598 if (trigger_is_ready(&auxtrace_snapshot_trigger)) {
1599 trigger_hit(&auxtrace_snapshot_trigger);
1600 auxtrace_record__snapshot_started = 1;
1601 if (auxtrace_record__snapshot_start(rec->itr))
1602 trigger_error(&auxtrace_snapshot_trigger);
1603 }
1604}
1605
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001606static int __cmd_record(struct record *rec, int argc, const char **argv)
Peter Zijlstra16c8a102009-05-05 17:50:27 +02001607{
David Ahern57706ab2013-11-06 11:41:34 -07001608 int err;
Namhyung Kim45604712014-05-12 09:47:24 +09001609 int status = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001610 unsigned long waking = 0;
Zhang, Yanmin46be6042010-03-18 11:36:04 -03001611 const bool forks = argc > 0;
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001612 struct perf_tool *tool = &rec->tool;
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03001613 struct record_opts *opts = &rec->opts;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001614 struct perf_data *data = &rec->data;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001615 struct perf_session *session;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001616 bool disabled = false, draining = false;
Namhyung Kim42aa2762015-01-29 17:06:48 +09001617 int fd;
Alexey Budankovd3c8c082019-03-18 20:41:02 +03001618 float ratio = 0;
Alexey Budankovacce0222020-07-17 10:07:50 +03001619 enum evlist_ctl_cmd cmd = EVLIST_CTL_CMD_UNSUPPORTED;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001620
Namhyung Kim45604712014-05-12 09:47:24 +09001621 atexit(record__sig_exit);
Peter Zijlstraf5970552009-06-18 23:22:55 +02001622 signal(SIGCHLD, sig_handler);
1623 signal(SIGINT, sig_handler);
David Ahern804f7ac2013-05-06 12:24:23 -06001624 signal(SIGTERM, sig_handler);
Wang Nana0748652016-11-26 07:03:28 +00001625 signal(SIGSEGV, sigsegv_handler);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001626
Hari Bathinif3b36142017-03-08 02:11:43 +05301627 if (rec->opts.record_namespaces)
1628 tool->namespace_events = true;
1629
Namhyung Kim8fb4b672020-03-25 21:45:34 +09001630 if (rec->opts.record_cgroup) {
1631#ifdef HAVE_FILE_HANDLE
1632 tool->cgroup_events = true;
1633#else
1634 pr_err("cgroup tracking is not supported\n");
1635 return -1;
1636#endif
1637 }
1638
Jiri Olsadc0c6122017-01-09 10:51:58 +01001639 if (rec->opts.auxtrace_snapshot_mode || rec->switch_output.enabled) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001640 signal(SIGUSR2, snapshot_sig_handler);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001641 if (rec->opts.auxtrace_snapshot_mode)
1642 trigger_on(&auxtrace_snapshot_trigger);
Jiri Olsadc0c6122017-01-09 10:51:58 +01001643 if (rec->switch_output.enabled)
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001644 trigger_on(&switch_output_trigger);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001645 } else {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001646 signal(SIGUSR2, SIG_IGN);
Wang Nanc0bdc1c2016-04-13 08:21:06 +00001647 }
Peter Zijlstraf5970552009-06-18 23:22:55 +02001648
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001649 session = perf_session__new(data, false, tool);
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +05301650 if (IS_ERR(session)) {
Adrien BAKffa91882014-04-18 11:00:43 +09001651 pr_err("Perf session creation failed.\n");
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +05301652 return PTR_ERR(session);
Arnaldo Carvalho de Meloa9a70bb2009-11-17 01:18:11 -02001653 }
1654
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001655 fd = perf_data__fd(data);
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001656 rec->session = session;
1657
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001658 if (zstd_init(&session->zstd_data, rec->opts.comp_level) < 0) {
1659 pr_err("Compression initialization failed.\n");
1660 return -1;
1661 }
Anand K Mistryda231332020-05-13 12:20:23 +10001662#ifdef HAVE_EVENTFD_SUPPORT
1663 done_fd = eventfd(0, EFD_NONBLOCK);
1664 if (done_fd < 0) {
1665 pr_err("Failed to create wakeup eventfd, error: %m\n");
1666 status = -1;
1667 goto out_delete_session;
1668 }
1669 err = evlist__add_pollfd(rec->evlist, done_fd);
1670 if (err < 0) {
1671 pr_err("Failed to add wakeup eventfd to poll list\n");
1672 status = err;
1673 goto out_delete_session;
1674 }
1675#endif // HAVE_EVENTFD_SUPPORT
Alexey Budankov5d7f4112019-03-18 20:43:35 +03001676
1677 session->header.env.comp_type = PERF_COMP_ZSTD;
1678 session->header.env.comp_level = rec->opts.comp_level;
1679
Adrian Huntereeb399b2019-10-04 11:31:21 +03001680 if (rec->opts.kcore &&
1681 !record__kcore_readable(&session->machines.host)) {
1682 pr_err("ERROR: kcore is not readable.\n");
1683 return -1;
1684 }
1685
Jiri Olsad1e325c2020-08-05 11:34:40 +02001686 if (record__init_clock(rec))
1687 return -1;
1688
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001689 record__init_features(rec);
Stephane Eranian330aa672012-03-08 23:47:46 +01001690
Arnaldo Carvalho de Melod4db3f12009-12-27 21:36:57 -02001691 if (forks) {
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001692 err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001693 argv, data->is_pipe,
Arnaldo Carvalho de Melo735f7e02014-01-03 14:56:49 -03001694 workload_exec_failed_signal);
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -02001695 if (err < 0) {
1696 pr_err("Couldn't run the workload!\n");
Namhyung Kim45604712014-05-12 09:47:24 +09001697 status = err;
Arnaldo Carvalho de Melo35b9d882011-11-09 08:47:15 -02001698 goto out_delete_session;
Jens Axboe0a5ac842009-08-12 11:18:01 +02001699 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001700 }
1701
Jiri Olsaad46e48c2018-03-02 17:13:54 +01001702 /*
1703 * If we have just single event and are sending data
1704 * through pipe, we need to force the ids allocation,
1705 * because we synthesize event name through the pipe
1706 * and need the id for that.
1707 */
Jiri Olsa6484d2f2019-07-21 13:24:28 +02001708 if (data->is_pipe && rec->evlist->core.nr_entries == 1)
Jiri Olsaad46e48c2018-03-02 17:13:54 +01001709 rec->opts.sample_id = true;
1710
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03001711 if (record__open(rec) != 0) {
David Ahern8d3eca22012-08-26 12:24:47 -06001712 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001713 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001714 }
Jiri Olsaf6fa4372019-08-06 15:14:05 +02001715 session->header.env.comp_mmap_len = session->evlist->core.mmap_len;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001716
Adrian Huntereeb399b2019-10-04 11:31:21 +03001717 if (rec->opts.kcore) {
1718 err = record__kcore_copy(&session->machines.host, data);
1719 if (err) {
1720 pr_err("ERROR: Failed to copy kcore\n");
1721 goto out_child;
1722 }
1723 }
1724
Wang Nan8690a2a2016-02-22 09:10:32 +00001725 err = bpf__apply_obj_config();
1726 if (err) {
1727 char errbuf[BUFSIZ];
1728
1729 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
1730 pr_err("ERROR: Apply config to BPF failed: %s\n",
1731 errbuf);
1732 goto out_child;
1733 }
1734
Adrian Huntercca84822015-08-19 17:29:21 +03001735 /*
1736 * Normally perf_session__new would do this, but it doesn't have the
1737 * evlist.
1738 */
Arnaldo Carvalho de Melo8cedf3a52020-06-17 09:29:48 -03001739 if (rec->tool.ordered_events && !evlist__sample_id_all(rec->evlist)) {
Adrian Huntercca84822015-08-19 17:29:21 +03001740 pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
1741 rec->tool.ordered_events = false;
1742 }
1743
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001744 if (!rec->evlist->nr_groups)
Namhyung Kima8bb5592013-01-22 18:09:31 +09001745 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
1746
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001747 if (data->is_pipe) {
Namhyung Kim42aa2762015-01-29 17:06:48 +09001748 err = perf_header__write_pipe(fd);
Tom Zanussi529870e2010-04-01 23:59:16 -05001749 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001750 goto out_child;
Jiri Olsa563aecb2013-06-05 13:35:06 +02001751 } else {
Namhyung Kim42aa2762015-01-29 17:06:48 +09001752 err = perf_session__write_header(session, rec->evlist, fd, false);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001753 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001754 goto out_child;
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001755 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001756
Arnaldo Carvalho de Melob38d85e2020-04-24 12:24:51 -03001757 err = -1;
David Ahernd3665492012-02-06 15:27:52 -07001758 if (!rec->no_buildid
Robert Richtere20960c2011-12-07 10:02:55 +01001759 && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
David Ahernd3665492012-02-06 15:27:52 -07001760 pr_err("Couldn't generate buildids. "
Robert Richtere20960c2011-12-07 10:02:55 +01001761 "Use --no-buildid to profile anyway.\n");
Namhyung Kim45604712014-05-12 09:47:24 +09001762 goto out_child;
Robert Richtere20960c2011-12-07 10:02:55 +01001763 }
1764
Arnaldo Carvalho de Melo23cbb412020-04-28 14:58:29 -03001765 err = record__setup_sb_evlist(rec);
1766 if (err)
1767 goto out_child;
Song Liu657ee552019-03-11 22:30:50 -07001768
Wang Nan4ea648a2016-07-14 08:34:47 +00001769 err = record__synthesize(rec, false);
Wang Nanc45c86e2016-02-26 09:32:07 +00001770 if (err < 0)
Namhyung Kim45604712014-05-12 09:47:24 +09001771 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001772
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001773 if (rec->realtime_prio) {
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001774 struct sched_param param;
1775
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001776 param.sched_priority = rec->realtime_prio;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001777 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -02001778 pr_err("Could not set realtime priority.\n");
David Ahern8d3eca22012-08-26 12:24:47 -06001779 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001780 goto out_child;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001781 }
1782 }
1783
Jiri Olsa774cb492012-11-12 18:34:01 +01001784 /*
1785 * When perf is starting the traced process, all the events
1786 * (apart from group members) have enable_on_exec=1 set,
1787 * so don't spoil it by prematurely enabling them.
1788 */
Andi Kleen6619a532014-01-11 13:38:27 -08001789 if (!target__none(&opts->target) && !opts->initial_delay)
Jiri Olsa1c87f162019-07-21 13:24:08 +02001790 evlist__enable(rec->evlist);
David Ahern764e16a32011-08-25 10:17:55 -06001791
Peter Zijlstra856e9662009-12-16 17:55:55 +01001792 /*
1793 * Let the child rip
1794 */
Namhyung Kime803cf92015-09-22 09:24:55 +09001795 if (forks) {
Jiri Olsa20a8a3c2018-03-07 16:50:04 +01001796 struct machine *machine = &session->machines.host;
Namhyung Kime5bed5642015-09-30 10:45:24 +09001797 union perf_event *event;
Hari Bathinie907caf2017-03-08 02:11:51 +05301798 pid_t tgid;
Namhyung Kime5bed5642015-09-30 10:45:24 +09001799
1800 event = malloc(sizeof(event->comm) + machine->id_hdr_size);
1801 if (event == NULL) {
1802 err = -ENOMEM;
1803 goto out_child;
1804 }
1805
Namhyung Kime803cf92015-09-22 09:24:55 +09001806 /*
1807 * Some H/W events are generated before COMM event
1808 * which is emitted during exec(), so perf script
1809 * cannot see a correct process name for those events.
1810 * Synthesize COMM event to prevent it.
1811 */
Hari Bathinie907caf2017-03-08 02:11:51 +05301812 tgid = perf_event__synthesize_comm(tool, event,
1813 rec->evlist->workload.pid,
1814 process_synthesized_event,
1815 machine);
1816 free(event);
1817
1818 if (tgid == -1)
1819 goto out_child;
1820
1821 event = malloc(sizeof(event->namespaces) +
1822 (NR_NAMESPACES * sizeof(struct perf_ns_link_info)) +
1823 machine->id_hdr_size);
1824 if (event == NULL) {
1825 err = -ENOMEM;
1826 goto out_child;
1827 }
1828
1829 /*
1830 * Synthesize NAMESPACES event for the command specified.
1831 */
1832 perf_event__synthesize_namespaces(tool, event,
1833 rec->evlist->workload.pid,
1834 tgid, process_synthesized_event,
1835 machine);
Namhyung Kime5bed5642015-09-30 10:45:24 +09001836 free(event);
Namhyung Kime803cf92015-09-22 09:24:55 +09001837
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03001838 perf_evlist__start_workload(rec->evlist);
Namhyung Kime803cf92015-09-22 09:24:55 +09001839 }
Peter Zijlstra856e9662009-12-16 17:55:55 +01001840
Alexey Budankov1d078cc2020-07-17 10:08:23 +03001841 if (evlist__initialize_ctlfd(rec->evlist, opts->ctl_fd, opts->ctl_fd_ack))
1842 goto out_child;
1843
Andi Kleen6619a532014-01-11 13:38:27 -08001844 if (opts->initial_delay) {
Alexey Budankov68cd3b42020-07-17 10:07:03 +03001845 pr_info(EVLIST_DISABLED_MSG);
1846 if (opts->initial_delay > 0) {
1847 usleep(opts->initial_delay * USEC_PER_MSEC);
1848 evlist__enable(rec->evlist);
1849 pr_info(EVLIST_ENABLED_MSG);
1850 }
Andi Kleen6619a532014-01-11 13:38:27 -08001851 }
1852
Wang Nan5f9cf592016-04-20 18:59:49 +00001853 trigger_ready(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001854 trigger_ready(&switch_output_trigger);
Wang Nana0748652016-11-26 07:03:28 +00001855 perf_hooks__invoke_record_start();
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001856 for (;;) {
Yang Shi9f065192015-09-29 14:49:43 -07001857 unsigned long long hits = rec->samples;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001858
Wang Nan057374642016-07-14 08:34:43 +00001859 /*
1860 * rec->evlist->bkw_mmap_state is possible to be
1861 * BKW_MMAP_EMPTY here: when done == true and
1862 * hits != rec->samples in previous round.
1863 *
1864 * perf_evlist__toggle_bkw_mmap ensure we never
1865 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
1866 */
1867 if (trigger_is_hit(&switch_output_trigger) || done || draining)
1868 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
1869
Alexey Budankov470530b2019-03-18 20:40:26 +03001870 if (record__mmap_read_all(rec, false) < 0) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001871 trigger_error(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001872 trigger_error(&switch_output_trigger);
David Ahern8d3eca22012-08-26 12:24:47 -06001873 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001874 goto out_child;
David Ahern8d3eca22012-08-26 12:24:47 -06001875 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001876
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001877 if (auxtrace_record__snapshot_started) {
1878 auxtrace_record__snapshot_started = 0;
Wang Nan5f9cf592016-04-20 18:59:49 +00001879 if (!trigger_is_error(&auxtrace_snapshot_trigger))
Alexander Shishkince7b0e42019-08-06 17:41:01 +03001880 record__read_auxtrace_snapshot(rec, false);
Wang Nan5f9cf592016-04-20 18:59:49 +00001881 if (trigger_is_error(&auxtrace_snapshot_trigger)) {
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03001882 pr_err("AUX area tracing snapshot failed\n");
1883 err = -1;
1884 goto out_child;
1885 }
1886 }
1887
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001888 if (trigger_is_hit(&switch_output_trigger)) {
Wang Nan057374642016-07-14 08:34:43 +00001889 /*
1890 * If switch_output_trigger is hit, the data in
1891 * overwritable ring buffer should have been collected,
1892 * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
1893 *
1894 * If SIGUSR2 raise after or during record__mmap_read_all(),
1895 * record__mmap_read_all() didn't collect data from
1896 * overwritable ring buffer. Read again.
1897 */
1898 if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
1899 continue;
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001900 trigger_ready(&switch_output_trigger);
1901
Wang Nan057374642016-07-14 08:34:43 +00001902 /*
1903 * Reenable events in overwrite ring buffer after
1904 * record__mmap_read_all(): we should have collected
1905 * data from it.
1906 */
1907 perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
1908
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001909 if (!quiet)
1910 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
1911 waking);
1912 waking = 0;
1913 fd = record__switch_output(rec, false);
1914 if (fd < 0) {
1915 pr_err("Failed to switch to new file\n");
1916 trigger_error(&switch_output_trigger);
1917 err = fd;
1918 goto out_child;
1919 }
Jiri Olsabfacbe32017-01-09 10:52:00 +01001920
1921 /* re-arm the alarm */
1922 if (rec->switch_output.time)
1923 alarm(rec->switch_output.time);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001924 }
1925
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001926 if (hits == rec->samples) {
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001927 if (done || draining)
Peter Zijlstra649c48a2009-06-24 21:12:48 +02001928 break;
Jiri Olsa80ab2982019-08-31 22:48:33 +02001929 err = evlist__poll(rec->evlist, -1);
Jiri Olsaa5151142014-06-02 13:44:23 -04001930 /*
1931 * Propagate error, only if there's any. Ignore positive
1932 * number of returned events and interrupt error.
1933 */
1934 if (err > 0 || (err < 0 && errno == EINTR))
Namhyung Kim45604712014-05-12 09:47:24 +09001935 err = 0;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001936 waking++;
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001937
Jiri Olsaf4009e72019-08-16 16:00:45 +02001938 if (evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
Arnaldo Carvalho de Melo6dcf45ef2014-08-13 11:33:59 -03001939 draining = true;
Peter Zijlstra8b412662009-09-17 19:59:05 +02001940 }
1941
Alexey Budankovacce0222020-07-17 10:07:50 +03001942 if (evlist__ctlfd_process(rec->evlist, &cmd) > 0) {
1943 switch (cmd) {
1944 case EVLIST_CTL_CMD_ENABLE:
1945 pr_info(EVLIST_ENABLED_MSG);
1946 break;
1947 case EVLIST_CTL_CMD_DISABLE:
1948 pr_info(EVLIST_DISABLED_MSG);
1949 break;
Adrian Hunterd20aff12020-09-01 12:37:57 +03001950 case EVLIST_CTL_CMD_SNAPSHOT:
1951 hit_auxtrace_snapshot_trigger(rec);
1952 evlist__ctlfd_ack(rec->evlist);
1953 break;
Alexey Budankovacce0222020-07-17 10:07:50 +03001954 case EVLIST_CTL_CMD_ACK:
1955 case EVLIST_CTL_CMD_UNSUPPORTED:
1956 default:
1957 break;
1958 }
1959 }
1960
Jiri Olsa774cb492012-11-12 18:34:01 +01001961 /*
1962 * When perf is starting the traced process, at the end events
1963 * die with the process and we wait for that. Thus no need to
1964 * disable events in this case.
1965 */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001966 if (done && !disabled && !target__none(&opts->target)) {
Wang Nan5f9cf592016-04-20 18:59:49 +00001967 trigger_off(&auxtrace_snapshot_trigger);
Jiri Olsae74676d2019-07-21 13:24:09 +02001968 evlist__disable(rec->evlist);
Jiri Olsa27119262012-11-12 18:34:02 +01001969 disabled = true;
1970 }
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001971 }
Alexander Shishkince7b0e42019-08-06 17:41:01 +03001972
Wang Nan5f9cf592016-04-20 18:59:49 +00001973 trigger_off(&auxtrace_snapshot_trigger);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00001974 trigger_off(&switch_output_trigger);
Peter Zijlstrade9ac072009-04-08 15:01:31 +02001975
Alexander Shishkince7b0e42019-08-06 17:41:01 +03001976 if (opts->auxtrace_snapshot_on_exit)
1977 record__auxtrace_snapshot_exit(rec);
1978
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001979 if (forks && workload_exec_errno) {
Masami Hiramatsu35550da2014-08-14 02:22:43 +00001980 char msg[STRERR_BUFSIZE];
Arnaldo Carvalho de Meloc8b5f2c2016-07-06 11:56:20 -03001981 const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001982 pr_err("Workload failed: %s\n", emsg);
1983 err = -1;
Namhyung Kim45604712014-05-12 09:47:24 +09001984 goto out_child;
Arnaldo Carvalho de Melof33cbe72014-01-02 15:11:25 -03001985 }
1986
Namhyung Kime3d59112015-01-29 17:06:44 +09001987 if (!quiet)
Namhyung Kim45604712014-05-12 09:47:24 +09001988 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02001989
Wang Nan4ea648a2016-07-14 08:34:47 +00001990 if (target__none(&rec->opts.target))
1991 record__synthesize_workload(rec, true);
1992
Namhyung Kim45604712014-05-12 09:47:24 +09001993out_child:
Alexey Budankov1d078cc2020-07-17 10:08:23 +03001994 evlist__finalize_ctlfd(rec->evlist);
Alexey Budankov470530b2019-03-18 20:40:26 +03001995 record__mmap_read_all(rec, true);
Alexey Budankovd3d1af62018-11-06 12:04:58 +03001996 record__aio_mmap_read_sync(rec);
1997
Alexey Budankovd3c8c082019-03-18 20:41:02 +03001998 if (rec->session->bytes_transferred && rec->session->bytes_compressed) {
1999 ratio = (float)rec->session->bytes_transferred/(float)rec->session->bytes_compressed;
2000 session->header.env.comp_ratio = ratio + 0.5;
2001 }
2002
Namhyung Kim45604712014-05-12 09:47:24 +09002003 if (forks) {
2004 int exit_status;
Ingo Molnaraddc2782009-06-02 23:43:11 +02002005
Namhyung Kim45604712014-05-12 09:47:24 +09002006 if (!child_finished)
2007 kill(rec->evlist->workload.pid, SIGTERM);
2008
2009 wait(&exit_status);
2010
2011 if (err < 0)
2012 status = err;
2013 else if (WIFEXITED(exit_status))
2014 status = WEXITSTATUS(exit_status);
2015 else if (WIFSIGNALED(exit_status))
2016 signr = WTERMSIG(exit_status);
2017 } else
2018 status = err;
2019
Wang Nan4ea648a2016-07-14 08:34:47 +00002020 record__synthesize(rec, true);
Namhyung Kime3d59112015-01-29 17:06:44 +09002021 /* this will be recalculated during process_buildids() */
2022 rec->samples = 0;
2023
Wang Nanecfd7a92016-04-13 08:21:07 +00002024 if (!err) {
2025 if (!rec->timestamp_filename) {
2026 record__finish_output(rec);
2027 } else {
2028 fd = record__switch_output(rec, true);
2029 if (fd < 0) {
2030 status = fd;
2031 goto out_delete_session;
2032 }
2033 }
2034 }
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002035
Wang Nana0748652016-11-26 07:03:28 +00002036 perf_hooks__invoke_record_end();
2037
Namhyung Kime3d59112015-01-29 17:06:44 +09002038 if (!err && !quiet) {
2039 char samples[128];
Wang Nanecfd7a92016-04-13 08:21:07 +00002040 const char *postfix = rec->timestamp_filename ?
2041 ".<timestamp>" : "";
Namhyung Kime3d59112015-01-29 17:06:44 +09002042
Adrian Hunteref149c22015-04-09 18:53:45 +03002043 if (rec->samples && !rec->opts.full_auxtrace)
Namhyung Kime3d59112015-01-29 17:06:44 +09002044 scnprintf(samples, sizeof(samples),
2045 " (%" PRIu64 " samples)", rec->samples);
2046 else
2047 samples[0] = '\0';
2048
Alexey Budankovd3c8c082019-03-18 20:41:02 +03002049 fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s%s",
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01002050 perf_data__size(data) / 1024.0 / 1024.0,
Jiri Olsa2d4f2792019-02-21 10:41:30 +01002051 data->path, postfix, samples);
Alexey Budankovd3c8c082019-03-18 20:41:02 +03002052 if (ratio) {
2053 fprintf(stderr, ", compressed (original %.3f MB, ratio is %.3f)",
2054 rec->session->bytes_transferred / 1024.0 / 1024.0,
2055 ratio);
2056 }
2057 fprintf(stderr, " ]\n");
Namhyung Kime3d59112015-01-29 17:06:44 +09002058 }
2059
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002060out_delete_session:
Anand K Mistryda231332020-05-13 12:20:23 +10002061#ifdef HAVE_EVENTFD_SUPPORT
2062 if (done_fd >= 0)
2063 close(done_fd);
2064#endif
Alexey Budankov5d7f4112019-03-18 20:43:35 +03002065 zstd_fini(&session->zstd_data);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002066 perf_session__delete(session);
Song Liu657ee552019-03-11 22:30:50 -07002067
2068 if (!opts->no_bpf_event)
Arnaldo Carvalho de Melobc477d72020-04-24 10:24:04 -03002069 perf_evlist__stop_sb_thread(rec->sb_evlist);
Namhyung Kim45604712014-05-12 09:47:24 +09002070 return status;
Peter Zijlstrade9ac072009-04-08 15:01:31 +02002071}
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002072
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03002073static void callchain_debug(struct callchain_param *callchain)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002074{
Kan Liangaad2b212015-01-05 13:23:04 -05002075 static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
Jiri Olsaa601fdf2014-02-03 12:44:43 +01002076
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03002077 pr_debug("callchain: type %s\n", str[callchain->record_mode]);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002078
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03002079 if (callchain->record_mode == CALLCHAIN_DWARF)
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002080 pr_debug("callchain: stack dump size %d\n",
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03002081 callchain->dump_size);
2082}
2083
2084int record_opts__parse_callchain(struct record_opts *record,
2085 struct callchain_param *callchain,
2086 const char *arg, bool unset)
2087{
2088 int ret;
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03002089 callchain->enabled = !unset;
2090
2091 /* --no-call-graph */
2092 if (unset) {
2093 callchain->record_mode = CALLCHAIN_NONE;
2094 pr_debug("callchain: disabled\n");
2095 return 0;
2096 }
2097
2098 ret = parse_callchain_record_opt(arg, callchain);
2099 if (!ret) {
2100 /* Enable data address sampling for DWARF unwind. */
2101 if (callchain->record_mode == CALLCHAIN_DWARF)
2102 record->sample_address = true;
2103 callchain_debug(callchain);
2104 }
2105
2106 return ret;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002107}
2108
Kan Liangc421e802015-07-29 05:42:12 -04002109int record_parse_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002110 const char *arg,
2111 int unset)
2112{
Arnaldo Carvalho de Melo0883e822016-04-15 16:37:17 -03002113 return record_opts__parse_callchain(opt->value, &callchain_param, arg, unset);
Jiri Olsa26d33022012-08-07 15:20:47 +02002114}
2115
Kan Liangc421e802015-07-29 05:42:12 -04002116int record_callchain_opt(const struct option *opt,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002117 const char *arg __maybe_unused,
2118 int unset __maybe_unused)
2119{
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03002120 struct callchain_param *callchain = opt->value;
Kan Liangc421e802015-07-29 05:42:12 -04002121
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03002122 callchain->enabled = true;
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002123
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03002124 if (callchain->record_mode == CALLCHAIN_NONE)
2125 callchain->record_mode = CALLCHAIN_FP;
Jiri Olsaeb853e82014-02-03 12:44:42 +01002126
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03002127 callchain_debug(callchain);
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002128 return 0;
2129}
2130
Jiri Olsaeb853e82014-02-03 12:44:42 +01002131static int perf_record_config(const char *var, const char *value, void *cb)
2132{
Namhyung Kim7a29c082015-12-15 10:49:56 +09002133 struct record *rec = cb;
2134
2135 if (!strcmp(var, "record.build-id")) {
2136 if (!strcmp(value, "cache"))
2137 rec->no_buildid_cache = false;
2138 else if (!strcmp(value, "no-cache"))
2139 rec->no_buildid_cache = true;
2140 else if (!strcmp(value, "skip"))
2141 rec->no_buildid = true;
2142 else
2143 return -1;
2144 return 0;
2145 }
Yisheng Xiecff17202018-03-12 19:25:57 +08002146 if (!strcmp(var, "record.call-graph")) {
2147 var = "call-graph.record-mode";
2148 return perf_default_config(var, value, cb);
2149 }
Alexey Budankov93f20c02018-11-06 12:07:19 +03002150#ifdef HAVE_AIO_SUPPORT
2151 if (!strcmp(var, "record.aio")) {
2152 rec->opts.nr_cblocks = strtol(value, NULL, 0);
2153 if (!rec->opts.nr_cblocks)
2154 rec->opts.nr_cblocks = nr_cblocks_default;
2155 }
2156#endif
Jiri Olsaeb853e82014-02-03 12:44:42 +01002157
Yisheng Xiecff17202018-03-12 19:25:57 +08002158 return 0;
Jiri Olsaeb853e82014-02-03 12:44:42 +01002159}
2160
Peter Zijlstra814c8c32015-03-31 00:19:31 +02002161
Alexey Budankovf4fe11b2019-01-22 20:52:03 +03002162static int record__parse_affinity(const struct option *opt, const char *str, int unset)
2163{
2164 struct record_opts *opts = (struct record_opts *)opt->value;
2165
2166 if (unset || !str)
2167 return 0;
2168
2169 if (!strcasecmp(str, "node"))
2170 opts->affinity = PERF_AFFINITY_NODE;
2171 else if (!strcasecmp(str, "cpu"))
2172 opts->affinity = PERF_AFFINITY_CPU;
2173
2174 return 0;
2175}
2176
Jiwei Sun6d575812019-10-22 16:09:01 +08002177static int parse_output_max_size(const struct option *opt,
2178 const char *str, int unset)
2179{
2180 unsigned long *s = (unsigned long *)opt->value;
2181 static struct parse_tag tags_size[] = {
2182 { .tag = 'B', .mult = 1 },
2183 { .tag = 'K', .mult = 1 << 10 },
2184 { .tag = 'M', .mult = 1 << 20 },
2185 { .tag = 'G', .mult = 1 << 30 },
2186 { .tag = 0 },
2187 };
2188 unsigned long val;
2189
2190 if (unset) {
2191 *s = 0;
2192 return 0;
2193 }
2194
2195 val = parse_tag_value(str, tags_size);
2196 if (val != (unsigned long) -1) {
2197 *s = val;
2198 return 0;
2199 }
2200
2201 return -1;
2202}
2203
Adrian Huntere9db1312015-04-09 18:53:46 +03002204static int record__parse_mmap_pages(const struct option *opt,
2205 const char *str,
2206 int unset __maybe_unused)
2207{
2208 struct record_opts *opts = opt->value;
2209 char *s, *p;
2210 unsigned int mmap_pages;
2211 int ret;
2212
2213 if (!str)
2214 return -EINVAL;
2215
2216 s = strdup(str);
2217 if (!s)
2218 return -ENOMEM;
2219
2220 p = strchr(s, ',');
2221 if (p)
2222 *p = '\0';
2223
2224 if (*s) {
2225 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
2226 if (ret)
2227 goto out_free;
2228 opts->mmap_pages = mmap_pages;
2229 }
2230
2231 if (!p) {
2232 ret = 0;
2233 goto out_free;
2234 }
2235
2236 ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
2237 if (ret)
2238 goto out_free;
2239
2240 opts->auxtrace_mmap_pages = mmap_pages;
2241
2242out_free:
2243 free(s);
2244 return ret;
2245}
2246
Alexey Budankov1d078cc2020-07-17 10:08:23 +03002247static int parse_control_option(const struct option *opt,
2248 const char *str,
2249 int unset __maybe_unused)
2250{
Adrian Hunter9864a662020-09-01 12:37:53 +03002251 struct record_opts *opts = opt->value;
Alexey Budankov1d078cc2020-07-17 10:08:23 +03002252
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002253 return evlist__parse_control(str, &opts->ctl_fd, &opts->ctl_fd_ack, &opts->ctl_fd_close);
2254}
2255
Jiri Olsa0c582442017-01-09 10:51:59 +01002256static void switch_output_size_warn(struct record *rec)
2257{
Jiri Olsa9521b5f2019-07-28 12:45:35 +02002258 u64 wakeup_size = evlist__mmap_size(rec->opts.mmap_pages);
Jiri Olsa0c582442017-01-09 10:51:59 +01002259 struct switch_output *s = &rec->switch_output;
2260
2261 wakeup_size /= 2;
2262
2263 if (s->size < wakeup_size) {
2264 char buf[100];
2265
2266 unit_number__scnprintf(buf, sizeof(buf), wakeup_size);
2267 pr_warning("WARNING: switch-output data size lower than "
2268 "wakeup kernel buffer size (%s) "
2269 "expect bigger perf.data sizes\n", buf);
2270 }
2271}
2272
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002273static int switch_output_setup(struct record *rec)
2274{
2275 struct switch_output *s = &rec->switch_output;
Jiri Olsadc0c6122017-01-09 10:51:58 +01002276 static struct parse_tag tags_size[] = {
2277 { .tag = 'B', .mult = 1 },
2278 { .tag = 'K', .mult = 1 << 10 },
2279 { .tag = 'M', .mult = 1 << 20 },
2280 { .tag = 'G', .mult = 1 << 30 },
2281 { .tag = 0 },
2282 };
Jiri Olsabfacbe32017-01-09 10:52:00 +01002283 static struct parse_tag tags_time[] = {
2284 { .tag = 's', .mult = 1 },
2285 { .tag = 'm', .mult = 60 },
2286 { .tag = 'h', .mult = 60*60 },
2287 { .tag = 'd', .mult = 60*60*24 },
2288 { .tag = 0 },
2289 };
Jiri Olsadc0c6122017-01-09 10:51:58 +01002290 unsigned long val;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002291
Arnaldo Carvalho de Melo899e5ff2020-04-27 17:56:37 -03002292 /*
2293 * If we're using --switch-output-events, then we imply its
2294 * --switch-output=signal, as we'll send a SIGUSR2 from the side band
2295 * thread to its parent.
2296 */
2297 if (rec->switch_output_event_set)
2298 goto do_signal;
2299
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002300 if (!s->set)
2301 return 0;
2302
2303 if (!strcmp(s->str, "signal")) {
Arnaldo Carvalho de Melo899e5ff2020-04-27 17:56:37 -03002304do_signal:
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002305 s->signal = true;
2306 pr_debug("switch-output with SIGUSR2 signal\n");
Jiri Olsadc0c6122017-01-09 10:51:58 +01002307 goto enabled;
2308 }
2309
2310 val = parse_tag_value(s->str, tags_size);
2311 if (val != (unsigned long) -1) {
2312 s->size = val;
2313 pr_debug("switch-output with %s size threshold\n", s->str);
2314 goto enabled;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002315 }
2316
Jiri Olsabfacbe32017-01-09 10:52:00 +01002317 val = parse_tag_value(s->str, tags_time);
2318 if (val != (unsigned long) -1) {
2319 s->time = val;
2320 pr_debug("switch-output with %s time threshold (%lu seconds)\n",
2321 s->str, s->time);
2322 goto enabled;
2323 }
2324
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002325 return -1;
Jiri Olsadc0c6122017-01-09 10:51:58 +01002326
2327enabled:
2328 rec->timestamp_filename = true;
2329 s->enabled = true;
Jiri Olsa0c582442017-01-09 10:51:59 +01002330
2331 if (s->size && !rec->opts.no_buffering)
2332 switch_output_size_warn(rec);
2333
Jiri Olsadc0c6122017-01-09 10:51:58 +01002334 return 0;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002335}
2336
Namhyung Kime5b2c202014-10-23 00:15:46 +09002337static const char * const __record_usage[] = {
Mike Galbraith9e0967532009-05-28 16:25:34 +02002338 "perf record [<options>] [<command>]",
2339 "perf record [<options>] -- <command> [<options>]",
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002340 NULL
2341};
Namhyung Kime5b2c202014-10-23 00:15:46 +09002342const char * const *record_usage = __record_usage;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002343
Arnaldo Carvalho de Melo6e0a9b3d2019-11-14 12:15:34 -03002344static int build_id__process_mmap(struct perf_tool *tool, union perf_event *event,
2345 struct perf_sample *sample, struct machine *machine)
2346{
2347 /*
2348 * We already have the kernel maps, put in place via perf_session__create_kernel_maps()
2349 * no need to add them twice.
2350 */
2351 if (!(event->header.misc & PERF_RECORD_MISC_USER))
2352 return 0;
2353 return perf_event__process_mmap(tool, event, sample, machine);
2354}
2355
2356static int build_id__process_mmap2(struct perf_tool *tool, union perf_event *event,
2357 struct perf_sample *sample, struct machine *machine)
2358{
2359 /*
2360 * We already have the kernel maps, put in place via perf_session__create_kernel_maps()
2361 * no need to add them twice.
2362 */
2363 if (!(event->header.misc & PERF_RECORD_MISC_USER))
2364 return 0;
2365
2366 return perf_event__process_mmap2(tool, event, sample, machine);
2367}
2368
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002369/*
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002370 * XXX Ideally would be local to cmd_record() and passed to a record__new
2371 * because we need to have access to it in record__exit, that is called
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002372 * after cmd_record() exits, but since record_options need to be accessible to
2373 * builtin-script, leave it here.
2374 *
2375 * At least we don't ouch it in all the other functions here directly.
2376 *
2377 * Just say no to tons of global variables, sigh.
2378 */
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002379static struct record record = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002380 .opts = {
Andi Kleen8affc2b2014-07-31 14:45:04 +08002381 .sample_time = true,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002382 .mmap_pages = UINT_MAX,
2383 .user_freq = UINT_MAX,
2384 .user_interval = ULLONG_MAX,
Arnaldo Carvalho de Melo447a6012012-05-22 13:14:18 -03002385 .freq = 4000,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09002386 .target = {
2387 .uses_mmap = true,
Adrian Hunter3aa59392013-11-15 15:52:29 +02002388 .default_per_cpu = true,
Namhyung Kimd1cb9fc2012-05-16 18:45:49 +09002389 },
Alexey Budankov470530b2019-03-18 20:40:26 +03002390 .mmap_flush = MMAP_FLUSH_DEFAULT,
Stephane Eraniand99c22e2020-04-22 08:50:38 -07002391 .nr_threads_synthesize = 1,
Alexey Budankov1d078cc2020-07-17 10:08:23 +03002392 .ctl_fd = -1,
2393 .ctl_fd_ack = -1,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002394 },
Namhyung Kime3d59112015-01-29 17:06:44 +09002395 .tool = {
2396 .sample = process_sample_event,
2397 .fork = perf_event__process_fork,
Adrian Huntercca84822015-08-19 17:29:21 +03002398 .exit = perf_event__process_exit,
Namhyung Kime3d59112015-01-29 17:06:44 +09002399 .comm = perf_event__process_comm,
Hari Bathinif3b36142017-03-08 02:11:43 +05302400 .namespaces = perf_event__process_namespaces,
Arnaldo Carvalho de Melo6e0a9b3d2019-11-14 12:15:34 -03002401 .mmap = build_id__process_mmap,
2402 .mmap2 = build_id__process_mmap2,
Adrian Huntercca84822015-08-19 17:29:21 +03002403 .ordered_events = true,
Namhyung Kime3d59112015-01-29 17:06:44 +09002404 },
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002405};
Frederic Weisbecker7865e812010-04-14 19:42:07 +02002406
Namhyung Kim76a26542015-10-22 23:28:32 +09002407const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
2408 "\n\t\t\t\tDefault: fp";
Arnaldo Carvalho de Melo61eaa3b2012-10-01 15:20:58 -03002409
Wang Nan0aab2132016-06-16 08:02:41 +00002410static bool dry_run;
2411
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002412/*
2413 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
2414 * with it and switch to use the library functions in perf_evlist that came
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03002415 * from builtin-record.c, i.e. use record_opts,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002416 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
2417 * using pipes, etc.
2418 */
Jiri Olsaefd21302017-01-03 09:19:55 +01002419static struct option __record_options[] = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002420 OPT_CALLBACK('e', "event", &record.evlist, "event",
Thomas Gleixner86847b62009-06-06 12:24:17 +02002421 "event selector. use 'perf list' to list available events",
Jiri Olsaf120f9d2011-07-14 11:25:32 +02002422 parse_events_option),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002423 OPT_CALLBACK(0, "filter", &record.evlist, "filter",
Li Zefanc171b552009-10-15 11:22:07 +08002424 "event filter", parse_filter),
Wang Nan4ba1faa2015-07-10 07:36:10 +00002425 OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
2426 NULL, "don't record events from perf itself",
2427 exclude_perf),
Namhyung Kimbea03402012-04-26 14:15:15 +09002428 OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03002429 "record events on existing process id"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002430 OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
Zhang, Yanmind6d901c2010-03-18 11:36:05 -03002431 "record events on existing thread id"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002432 OPT_INTEGER('r', "realtime", &record.realtime_prio,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002433 "collect data with this RT SCHED_FIFO priority"),
Arnaldo Carvalho de Melo509051e2014-01-14 17:52:14 -03002434 OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
Kirill Smelkovacac03f2011-01-12 17:59:36 +03002435 "collect data without buffering"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002436 OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
Frederic Weisbeckerdaac07b2009-08-13 10:27:19 +02002437 "collect raw sample records from all opened counters"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002438 OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002439 "system-wide collection from all CPUs"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002440 OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
Stephane Eranianc45c6ea2010-05-28 12:00:01 +02002441 "list of cpus to monitor"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002442 OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
Jiri Olsa2d4f2792019-02-21 10:41:30 +01002443 OPT_STRING('o', "output", &record.data.path, "file",
Ingo Molnarabaff322009-06-02 22:59:57 +02002444 "output file name"),
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02002445 OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
2446 &record.opts.no_inherit_set,
2447 "child tasks do not inherit counters"),
Wang Nan4ea648a2016-07-14 08:34:47 +00002448 OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize,
2449 "synthesize non-sample events at the end of output"),
Wang Nan626a6b72016-07-14 08:34:45 +00002450 OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
Wei Lia060c1f2020-08-19 11:19:47 +08002451 OPT_BOOLEAN(0, "no-bpf-event", &record.opts.no_bpf_event, "do not record bpf events"),
Arnaldo Carvalho de Melob09c2362018-03-01 14:52:50 -03002452 OPT_BOOLEAN(0, "strict-freq", &record.opts.strict_freq,
2453 "Fail if the specified frequency can't be used"),
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -03002454 OPT_CALLBACK('F', "freq", &record.opts, "freq or 'max'",
2455 "profile at this frequency",
2456 record__parse_freq),
Adrian Huntere9db1312015-04-09 18:53:46 +03002457 OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
2458 "number of mmap data pages and AUX area tracing mmap pages",
2459 record__parse_mmap_pages),
Alexey Budankov470530b2019-03-18 20:40:26 +03002460 OPT_CALLBACK(0, "mmap-flush", &record.opts, "number",
2461 "Minimal number of bytes that is extracted from mmap data pages (default: 1)",
2462 record__mmap_flush_parse),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002463 OPT_BOOLEAN(0, "group", &record.opts.group,
Lin Ming43bece72011-08-17 18:42:07 +08002464 "put the counters into a counter group"),
Arnaldo Carvalho de Melo2ddd5c02016-04-18 12:09:08 -03002465 OPT_CALLBACK_NOOPT('g', NULL, &callchain_param,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002466 NULL, "enables call-graph recording" ,
2467 &record_callchain_opt),
2468 OPT_CALLBACK(0, "call-graph", &record.opts,
Namhyung Kim76a26542015-10-22 23:28:32 +09002469 "record_mode[,record_size]", record_callchain_help,
Jiri Olsa09b0fd42013-10-26 16:25:33 +02002470 &record_parse_callchain_opt),
Ian Munsiec0555642010-04-13 18:37:33 +10002471 OPT_INCR('v', "verbose", &verbose,
Ingo Molnar3da297a2009-06-07 17:39:02 +02002472 "be more verbose (show counter open errors, etc)"),
Arnaldo Carvalho de Melob44308f2010-10-26 15:20:09 -02002473 OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002474 OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02002475 "per thread counts"),
Peter Zijlstra56100322015-06-10 16:48:50 +02002476 OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
Kan Liang3b0a5da2017-08-29 13:11:08 -04002477 OPT_BOOLEAN(0, "phys-data", &record.opts.sample_phys_addr,
2478 "Record the sample physical addresses"),
Jiri Olsab6f35ed2016-08-01 20:02:35 +02002479 OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"),
Adrian Hunter3abebc552015-07-06 14:51:01 +03002480 OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
2481 &record.opts.sample_time_set,
2482 "Record the sample timestamps"),
Jiri Olsaf290aa12018-02-01 09:38:11 +01002483 OPT_BOOLEAN_SET('P', "period", &record.opts.period, &record.opts.period_set,
2484 "Record the sample period"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002485 OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
Peter Zijlstra649c48a2009-06-24 21:12:48 +02002486 "don't sample"),
Wang Nand2db9a92016-01-25 09:56:19 +00002487 OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
2488 &record.no_buildid_cache_set,
2489 "do not update the buildid cache"),
2490 OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
2491 &record.no_buildid_set,
2492 "do not collect buildids in perf.data"),
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002493 OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
Stephane Eranian023695d2011-02-14 11:20:01 +02002494 "monitor event in cgroup name only",
2495 parse_cgroups),
Alexey Budankov68cd3b42020-07-17 10:07:03 +03002496 OPT_INTEGER('D', "delay", &record.opts.initial_delay,
2497 "ms to wait before starting measurement after program start (-1: start with events disabled)"),
Adrian Huntereeb399b2019-10-04 11:31:21 +03002498 OPT_BOOLEAN(0, "kcore", &record.opts.kcore, "copy /proc/kcore"),
Namhyung Kimbea03402012-04-26 14:15:15 +09002499 OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
2500 "user to profile"),
Stephane Eraniana5aabda2012-03-08 23:47:45 +01002501
2502 OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
2503 "branch any", "sample any taken branches",
2504 parse_branch_stack),
2505
2506 OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
2507 "branch filter mask", "branch stack filter modes",
Roberto Agostino Vitillobdfebd82012-02-09 23:21:02 +01002508 parse_branch_stack),
Andi Kleen05484292013-01-24 16:10:29 +01002509 OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
2510 "sample by weight (on special events only)"),
Andi Kleen475eeab2013-09-20 07:40:43 -07002511 OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
2512 "sample transaction flags (special events only)"),
Adrian Hunter3aa59392013-11-15 15:52:29 +02002513 OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
2514 "use per-thread mmaps"),
Stephane Eranianbcc84ec2015-08-31 18:41:12 +02002515 OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
2516 "sample selected machine registers on interrupt,"
Kan Liangaeea9062019-05-14 13:19:32 -07002517 " use '-I?' to list register names", parse_intr_regs),
Andi Kleen84c41742017-09-05 10:00:28 -07002518 OPT_CALLBACK_OPTARG(0, "user-regs", &record.opts.sample_user_regs, NULL, "any register",
2519 "sample selected machine registers on interrupt,"
Kan Liangaeea9062019-05-14 13:19:32 -07002520 " use '--user-regs=?' to list register names", parse_user_regs),
Andi Kleen85c273d2015-02-24 15:13:40 -08002521 OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
2522 "Record running/enabled time of read (:S) events"),
Peter Zijlstra814c8c32015-03-31 00:19:31 +02002523 OPT_CALLBACK('k', "clockid", &record.opts,
2524 "clockid", "clockid to use for events, see clock_gettime()",
2525 parse_clockid),
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002526 OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
2527 "opts", "AUX area tracing Snapshot Mode", ""),
Adrian Hunterc0a6de02019-11-15 14:42:16 +02002528 OPT_STRING_OPTARG(0, "aux-sample", &record.opts.auxtrace_sample_opts,
2529 "opts", "sample AUX area", ""),
Mark Drayton3fcb10e2018-12-04 12:34:20 -08002530 OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
Kan Liang9d9cad72015-06-17 09:51:11 -04002531 "per thread proc mmap processing timeout in ms"),
Hari Bathinif3b36142017-03-08 02:11:43 +05302532 OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
2533 "Record namespaces events"),
Namhyung Kim8fb4b672020-03-25 21:45:34 +09002534 OPT_BOOLEAN(0, "all-cgroups", &record.opts.record_cgroup,
2535 "Record cgroup events"),
Adrian Hunter16b4b4e2020-05-28 15:08:58 +03002536 OPT_BOOLEAN_SET(0, "switch-events", &record.opts.record_switch_events,
2537 &record.opts.record_switch_events_set,
2538 "Record context switch events"),
Jiri Olsa85723882016-02-15 09:34:31 +01002539 OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
2540 "Configure all used events to run in kernel space.",
2541 PARSE_OPT_EXCLUSIVE),
2542 OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
2543 "Configure all used events to run in user space.",
2544 PARSE_OPT_EXCLUSIVE),
yuzhoujian53651b22019-05-30 14:29:22 +01002545 OPT_BOOLEAN(0, "kernel-callchains", &record.opts.kernel_callchains,
2546 "collect kernel callchains"),
2547 OPT_BOOLEAN(0, "user-callchains", &record.opts.user_callchains,
2548 "collect user callchains"),
Wang Nan71dc23262015-10-14 12:41:19 +00002549 OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
2550 "clang binary to use for compiling BPF scriptlets"),
2551 OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
2552 "options passed to clang when compiling BPF scriptlets"),
He Kuang7efe0e02015-12-14 10:39:23 +00002553 OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
2554 "file", "vmlinux pathname"),
Namhyung Kim61566812016-01-11 22:37:09 +09002555 OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
2556 "Record build-id of all DSOs regardless of hits"),
Wang Nanecfd7a92016-04-13 08:21:07 +00002557 OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
2558 "append timestamp to output filename"),
Jin Yao68588ba2017-12-08 21:13:42 +08002559 OPT_BOOLEAN(0, "timestamp-boundary", &record.timestamp_boundary,
2560 "Record timestamp boundary (time of first/last samples)"),
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002561 OPT_STRING_OPTARG_SET(0, "switch-output", &record.switch_output.str,
Andi Kleenc38dab72019-03-14 15:49:56 -07002562 &record.switch_output.set, "signal or size[BKMG] or time[smhd]",
2563 "Switch output when receiving SIGUSR2 (signal) or cross a size or time threshold",
Jiri Olsadc0c6122017-01-09 10:51:58 +01002564 "signal"),
Arnaldo Carvalho de Melo899e5ff2020-04-27 17:56:37 -03002565 OPT_CALLBACK_SET(0, "switch-output-event", &record.sb_evlist, &record.switch_output_event_set, "switch output event",
2566 "switch output event selector. use 'perf list' to list available events",
2567 parse_events_option_new_evlist),
Andi Kleen03724b22019-03-14 15:49:55 -07002568 OPT_INTEGER(0, "switch-max-files", &record.switch_output.num_files,
2569 "Limit number of switch output generated files"),
Wang Nan0aab2132016-06-16 08:02:41 +00002570 OPT_BOOLEAN(0, "dry-run", &dry_run,
2571 "Parse options then exit"),
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002572#ifdef HAVE_AIO_SUPPORT
Alexey Budankov93f20c02018-11-06 12:07:19 +03002573 OPT_CALLBACK_OPTARG(0, "aio", &record.opts,
2574 &nr_cblocks_default, "n", "Use <n> control blocks in asynchronous trace writing mode (default: 1, max: 4)",
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002575 record__aio_parse),
2576#endif
Alexey Budankovf4fe11b2019-01-22 20:52:03 +03002577 OPT_CALLBACK(0, "affinity", &record.opts, "node|cpu",
2578 "Set affinity mask of trace reading thread to NUMA node cpu mask or cpu of processed mmap buffer",
2579 record__parse_affinity),
Alexey Budankov504c1ad2019-03-18 20:44:42 +03002580#ifdef HAVE_ZSTD_SUPPORT
2581 OPT_CALLBACK_OPTARG('z', "compression-level", &record.opts, &comp_level_default,
2582 "n", "Compressed records using specified level (default: 1 - fastest compression, 22 - greatest compression)",
2583 record__parse_comp_level),
2584#endif
Jiwei Sun6d575812019-10-22 16:09:01 +08002585 OPT_CALLBACK(0, "max-size", &record.output_max_size,
2586 "size", "Limit the maximum size of the output file", parse_output_max_size),
Stephane Eraniand99c22e2020-04-22 08:50:38 -07002587 OPT_UINTEGER(0, "num-thread-synthesize",
2588 &record.opts.nr_threads_synthesize,
2589 "number of threads to run for event synthesis"),
Stephane Eranian70943492020-05-05 11:29:43 -07002590#ifdef HAVE_LIBPFM
2591 OPT_CALLBACK(0, "pfm-events", &record.evlist, "event",
2592 "libpfm4 event selector. use 'perf list' to list available events",
2593 parse_libpfm_events_option),
2594#endif
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002595 OPT_CALLBACK(0, "control", &record.opts, "fd:ctl-fd[,ack-fd] or fifo:ctl-fifo[,ack-fifo]",
Adrian Hunterd20aff12020-09-01 12:37:57 +03002596 "Listen on ctl-fd descriptor for command to control measurement ('enable': enable events, 'disable': disable events,\n"
2597 "\t\t\t 'snapshot': AUX area tracing snapshot).\n"
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002598 "\t\t\t Optionally send control command completion ('ack\\n') to ack-fd descriptor.\n"
2599 "\t\t\t Alternatively, ctl-fifo / ack-fifo will be opened and used as ctl-fd / ack-fd.",
Alexey Budankov1d078cc2020-07-17 10:08:23 +03002600 parse_control_option),
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002601 OPT_END()
2602};
2603
Namhyung Kime5b2c202014-10-23 00:15:46 +09002604struct option *record_options = __record_options;
2605
Arnaldo Carvalho de Melob0ad8ea2017-03-27 11:47:20 -03002606int cmd_record(int argc, const char **argv)
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002607{
Adrian Hunteref149c22015-04-09 18:53:45 +03002608 int err;
Arnaldo Carvalho de Melo8c6f45a2013-12-19 14:38:03 -03002609 struct record *rec = &record;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002610 char errbuf[BUFSIZ];
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002611
Arnaldo Carvalho de Melo67230472018-03-01 13:46:23 -03002612 setlocale(LC_ALL, "");
2613
Wang Nan48e1cab2015-12-14 10:39:22 +00002614#ifndef HAVE_LIBBPF_SUPPORT
2615# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
2616 set_nobuild('\0', "clang-path", true);
2617 set_nobuild('\0', "clang-opt", true);
2618# undef set_nobuild
2619#endif
2620
He Kuang7efe0e02015-12-14 10:39:23 +00002621#ifndef HAVE_BPF_PROLOGUE
2622# if !defined (HAVE_DWARF_SUPPORT)
2623# define REASON "NO_DWARF=1"
2624# elif !defined (HAVE_LIBBPF_SUPPORT)
2625# define REASON "NO_LIBBPF=1"
2626# else
2627# define REASON "this architecture doesn't support BPF prologue"
2628# endif
2629# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
2630 set_nobuild('\0', "vmlinux", true);
2631# undef set_nobuild
2632# undef REASON
2633#endif
2634
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002635 rec->opts.affinity = PERF_AFFINITY_SYS;
2636
Jiri Olsa0f98b112019-07-21 13:23:55 +02002637 rec->evlist = evlist__new();
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002638 if (rec->evlist == NULL)
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02002639 return -ENOMEM;
2640
Arnaldo Carvalho de Meloecc4c562017-01-24 13:44:10 -03002641 err = perf_config(perf_record_config, rec);
2642 if (err)
2643 return err;
Jiri Olsaeb853e82014-02-03 12:44:42 +01002644
Tom Zanussibca647a2010-11-10 08:11:30 -06002645 argc = parse_options(argc, argv, record_options, record_usage,
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02002646 PARSE_OPT_STOP_AT_NON_OPTION);
Namhyung Kim68ba3232017-02-17 17:17:42 +09002647 if (quiet)
2648 perf_quiet_option();
Jiri Olsa483635a2017-02-17 18:00:18 +01002649
2650 /* Make system wide (-a) the default target. */
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002651 if (!argc && target__none(&rec->opts.target))
Jiri Olsa483635a2017-02-17 18:00:18 +01002652 rec->opts.target.system_wide = true;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002653
Namhyung Kimbea03402012-04-26 14:15:15 +09002654 if (nr_cgroups && !rec->opts.target.system_wide) {
Namhyung Kimc7118362015-10-25 00:49:27 +09002655 usage_with_options_msg(record_usage, record_options,
2656 "cgroup monitoring only available in system-wide mode");
2657
Stephane Eranian023695d2011-02-14 11:20:01 +02002658 }
Alexey Budankov504c1ad2019-03-18 20:44:42 +03002659
Adrian Huntereeb399b2019-10-04 11:31:21 +03002660 if (rec->opts.kcore)
2661 rec->data.is_dir = true;
2662
Alexey Budankov504c1ad2019-03-18 20:44:42 +03002663 if (rec->opts.comp_level != 0) {
2664 pr_debug("Compression enabled, disabling build id collection at the end of the session.\n");
2665 rec->no_buildid = true;
2666 }
2667
Adrian Hunterb757bb02015-07-21 12:44:04 +03002668 if (rec->opts.record_switch_events &&
2669 !perf_can_record_switch_events()) {
Namhyung Kimc7118362015-10-25 00:49:27 +09002670 ui__error("kernel does not support recording context switch events\n");
2671 parse_options_usage(record_usage, record_options, "switch-events", 0);
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002672 err = -EINVAL;
2673 goto out_opts;
Adrian Hunterb757bb02015-07-21 12:44:04 +03002674 }
Stephane Eranian023695d2011-02-14 11:20:01 +02002675
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002676 if (switch_output_setup(rec)) {
2677 parse_options_usage(record_usage, record_options, "switch-output", 0);
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002678 err = -EINVAL;
2679 goto out_opts;
Jiri Olsacb4e1eb2017-01-09 10:51:57 +01002680 }
2681
Jiri Olsabfacbe32017-01-09 10:52:00 +01002682 if (rec->switch_output.time) {
2683 signal(SIGALRM, alarm_sig_handler);
2684 alarm(rec->switch_output.time);
2685 }
2686
Andi Kleen03724b22019-03-14 15:49:55 -07002687 if (rec->switch_output.num_files) {
2688 rec->switch_output.filenames = calloc(sizeof(char *),
2689 rec->switch_output.num_files);
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002690 if (!rec->switch_output.filenames) {
2691 err = -EINVAL;
2692 goto out_opts;
2693 }
Andi Kleen03724b22019-03-14 15:49:55 -07002694 }
2695
Adrian Hunter1b36c032016-09-23 17:38:39 +03002696 /*
2697 * Allow aliases to facilitate the lookup of symbols for address
2698 * filters. Refer to auxtrace_parse_filters().
2699 */
2700 symbol_conf.allow_aliases = true;
2701
2702 symbol__init(NULL);
2703
Alexey Budankov8384a262019-12-03 14:45:27 +03002704 if (rec->opts.affinity != PERF_AFFINITY_SYS) {
2705 rec->affinity_mask.nbits = cpu__max_cpu();
2706 rec->affinity_mask.bits = bitmap_alloc(rec->affinity_mask.nbits);
2707 if (!rec->affinity_mask.bits) {
2708 pr_err("Failed to allocate thread mask for %zd cpus\n", rec->affinity_mask.nbits);
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002709 err = -ENOMEM;
2710 goto out_opts;
Alexey Budankov8384a262019-12-03 14:45:27 +03002711 }
2712 pr_debug2("thread mask[%zd]: empty\n", rec->affinity_mask.nbits);
2713 }
2714
Adrian Hunter4b5ea3b2018-03-06 11:13:12 +02002715 err = record__auxtrace_init(rec);
Adrian Hunter1b36c032016-09-23 17:38:39 +03002716 if (err)
2717 goto out;
2718
Wang Nan0aab2132016-06-16 08:02:41 +00002719 if (dry_run)
Adrian Hunter5c01ad602016-09-23 17:38:37 +03002720 goto out;
Wang Nan0aab2132016-06-16 08:02:41 +00002721
Wang Nand7888572016-04-08 15:07:24 +00002722 err = bpf__setup_stdout(rec->evlist);
2723 if (err) {
2724 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
2725 pr_err("ERROR: Setup BPF stdout failed: %s\n",
2726 errbuf);
Adrian Hunter5c01ad602016-09-23 17:38:37 +03002727 goto out;
Wang Nand7888572016-04-08 15:07:24 +00002728 }
2729
Adrian Hunteref149c22015-04-09 18:53:45 +03002730 err = -ENOMEM;
2731
Wang Nan0c1d46a2016-04-20 18:59:52 +00002732 if (rec->no_buildid_cache || rec->no_buildid) {
Stephane Eraniana1ac1d32010-06-17 11:39:01 +02002733 disable_buildid_cache();
Jiri Olsadc0c6122017-01-09 10:51:58 +01002734 } else if (rec->switch_output.enabled) {
Wang Nan0c1d46a2016-04-20 18:59:52 +00002735 /*
2736 * In 'perf record --switch-output', disable buildid
2737 * generation by default to reduce data file switching
2738 * overhead. Still generate buildid if they are required
2739 * explicitly using
2740 *
Jiri Olsa60437ac2017-01-03 09:19:56 +01002741 * perf record --switch-output --no-no-buildid \
Wang Nan0c1d46a2016-04-20 18:59:52 +00002742 * --no-no-buildid-cache
2743 *
2744 * Following code equals to:
2745 *
2746 * if ((rec->no_buildid || !rec->no_buildid_set) &&
2747 * (rec->no_buildid_cache || !rec->no_buildid_cache_set))
2748 * disable_buildid_cache();
2749 */
2750 bool disable = true;
2751
2752 if (rec->no_buildid_set && !rec->no_buildid)
2753 disable = false;
2754 if (rec->no_buildid_cache_set && !rec->no_buildid_cache)
2755 disable = false;
2756 if (disable) {
2757 rec->no_buildid = true;
2758 rec->no_buildid_cache = true;
2759 disable_buildid_cache();
2760 }
2761 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02002762
Wang Nan4ea648a2016-07-14 08:34:47 +00002763 if (record.opts.overwrite)
2764 record.opts.tail_synthesize = true;
2765
Jiri Olsa6484d2f2019-07-21 13:24:28 +02002766 if (rec->evlist->core.nr_entries == 0 &&
Arnaldo Carvalho de Meloe251abe2020-06-17 09:16:20 -03002767 __evlist__add_default(rec->evlist, !record.opts.no_samples) < 0) {
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02002768 pr_err("Not enough memory for event selector list\n");
Adrian Hunter394c01e2016-09-23 17:38:36 +03002769 goto out;
Peter Zijlstrabbd36e52009-06-11 23:11:50 +02002770 }
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002771
Adrian Hunter69e7e5b2013-11-18 11:55:57 +02002772 if (rec->opts.target.tid && !rec->opts.no_inherit_set)
2773 rec->opts.no_inherit = true;
2774
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002775 err = target__validate(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002776 if (err) {
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002777 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Jiri Olsac3dec272018-02-06 19:17:58 +01002778 ui__warning("%s\n", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002779 }
Namhyung Kim4bd0f2d2012-04-26 14:15:18 +09002780
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002781 err = target__parse_uid(&rec->opts.target);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002782 if (err) {
2783 int saved_errno = errno;
2784
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03002785 target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
Namhyung Kim3780f482012-05-29 13:22:57 +09002786 ui__error("%s", errbuf);
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002787
2788 err = -saved_errno;
Adrian Hunter394c01e2016-09-23 17:38:36 +03002789 goto out;
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002790 }
Arnaldo Carvalho de Melo0d37aa32012-01-19 14:08:15 -02002791
Mengting Zhangca800062017-12-13 15:01:53 +08002792 /* Enable ignoring missing threads when -u/-p option is defined. */
2793 rec->opts.ignore_missing_thread = rec->opts.target.uid != UINT_MAX || rec->opts.target.pid;
Jiri Olsa23dc4f12016-12-12 11:35:43 +01002794
Namhyung Kim16ad2ff2012-05-07 14:09:02 +09002795 err = -ENOMEM;
Arnaldo Carvalho de Melo3e2be2d2014-01-03 15:03:26 -03002796 if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
Arnaldo Carvalho de Melodd7927f2011-01-12 14:28:51 -02002797 usage_with_options(record_usage, record_options);
Arnaldo Carvalho de Melo69aad6f2011-01-03 16:39:04 -02002798
Adrian Hunteref149c22015-04-09 18:53:45 +03002799 err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
2800 if (err)
Adrian Hunter394c01e2016-09-23 17:38:36 +03002801 goto out;
Adrian Hunteref149c22015-04-09 18:53:45 +03002802
Namhyung Kim61566812016-01-11 22:37:09 +09002803 /*
2804 * We take all buildids when the file contains
2805 * AUX area tracing data because we do not decode the
2806 * trace because it would take too long.
2807 */
2808 if (rec->opts.full_auxtrace)
2809 rec->buildid_all = true;
2810
Adrian Hunter246eba82020-05-12 15:19:18 +03002811 if (rec->opts.text_poke) {
2812 err = record__config_text_poke(rec->evlist);
2813 if (err) {
2814 pr_err("record__config_text_poke failed, error %d\n", err);
2815 goto out;
2816 }
2817 }
2818
Arnaldo Carvalho de Melob4006792013-12-19 14:43:45 -03002819 if (record_opts__config(&rec->opts)) {
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002820 err = -EINVAL;
Adrian Hunter394c01e2016-09-23 17:38:36 +03002821 goto out;
Mike Galbraith7e4ff9e2009-10-12 07:56:03 +02002822 }
2823
Alexey Budankov93f20c02018-11-06 12:07:19 +03002824 if (rec->opts.nr_cblocks > nr_cblocks_max)
2825 rec->opts.nr_cblocks = nr_cblocks_max;
Alexey Budankov5d7f4112019-03-18 20:43:35 +03002826 pr_debug("nr_cblocks: %d\n", rec->opts.nr_cblocks);
Alexey Budankovd3d1af62018-11-06 12:04:58 +03002827
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002828 pr_debug("affinity: %s\n", affinity_tags[rec->opts.affinity]);
Alexey Budankov470530b2019-03-18 20:40:26 +03002829 pr_debug("mmap flush: %d\n", rec->opts.mmap_flush);
Alexey Budankov9d2ed642019-01-22 20:47:43 +03002830
Alexey Budankov51255a82019-03-18 20:42:19 +03002831 if (rec->opts.comp_level > comp_level_max)
2832 rec->opts.comp_level = comp_level_max;
2833 pr_debug("comp level: %d\n", rec->opts.comp_level);
2834
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002835 err = __cmd_record(&record, argc, argv);
Adrian Hunter394c01e2016-09-23 17:38:36 +03002836out:
Alexey Budankov8384a262019-12-03 14:45:27 +03002837 bitmap_free(rec->affinity_mask.bits);
Jiri Olsac12995a2019-07-21 13:23:56 +02002838 evlist__delete(rec->evlist);
Arnaldo Carvalho de Melod65a4582010-07-30 18:31:28 -03002839 symbol__exit();
Adrian Hunteref149c22015-04-09 18:53:45 +03002840 auxtrace_record__free(rec->itr);
Adrian Huntera8fcbd22020-09-02 13:57:07 +03002841out_opts:
Adrian Hunteree7fe312020-09-03 15:29:37 +03002842 evlist__close_control(rec->opts.ctl_fd, rec->opts.ctl_fd_ack, &rec->opts.ctl_fd_close);
Arnaldo Carvalho de Melo39d17da2010-07-29 14:08:55 -03002843 return err;
Ingo Molnar0e9b20b2009-05-26 09:17:18 +02002844}
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002845
2846static void snapshot_sig_handler(int sig __maybe_unused)
2847{
Jiri Olsadc0c6122017-01-09 10:51:58 +01002848 struct record *rec = &record;
2849
Adrian Hunterd20aff12020-09-01 12:37:57 +03002850 hit_auxtrace_snapshot_trigger(rec);
Wang Nan3c1cb7e2016-04-20 18:59:50 +00002851
Jiri Olsadc0c6122017-01-09 10:51:58 +01002852 if (switch_output_signal(rec))
Wang Nan3c1cb7e2016-04-20 18:59:50 +00002853 trigger_hit(&switch_output_trigger);
Adrian Hunter2dd6d8a2015-04-30 17:37:32 +03002854}
Jiri Olsabfacbe32017-01-09 10:52:00 +01002855
2856static void alarm_sig_handler(int sig __maybe_unused)
2857{
2858 struct record *rec = &record;
2859
2860 if (switch_output_time(rec))
2861 trigger_hit(&switch_output_trigger);
2862}