builtin-record.c 22.8 KB
Newer Older
I
Ingo Molnar 已提交
1
/*
2 3 4 5 6
 * builtin-record.c
 *
 * Builtin record command: Record the profile of a workload
 * (or a CPU, or a PID) into the perf.data output file - for
 * later analysis via perf report.
I
Ingo Molnar 已提交
7
 */
8
#include "builtin.h"
9 10 11

#include "perf.h"

12
#include "util/build-id.h"
13
#include "util/util.h"
14
#include "util/parse-options.h"
15
#include "util/parse-events.h"
16

17
#include "util/header.h"
18
#include "util/event.h"
19
#include "util/evlist.h"
20
#include "util/evsel.h"
21
#include "util/debug.h"
22
#include "util/session.h"
23
#include "util/tool.h"
24
#include "util/symbol.h"
25
#include "util/cpumap.h"
26
#include "util/thread_map.h"
27
#include "util/data.h"
28

29
#include <unistd.h>
30
#include <sched.h>
31
#include <sys/mman.h>
32

33

34
struct record {
35
	struct perf_tool	tool;
36
	struct record_opts	opts;
37
	u64			bytes_written;
38
	struct perf_data_file	file;
39 40 41 42 43 44 45
	struct perf_evlist	*evlist;
	struct perf_session	*session;
	const char		*progname;
	int			realtime_prio;
	bool			no_buildid;
	bool			no_buildid_cache;
	long			samples;
46
};
47

48
static int record__write(struct record *rec, void *bf, size_t size)
49
{
50
	if (perf_data_file__write(rec->session->file, bf, size) < 0) {
51 52
		pr_err("failed to write perf data, error: %m\n");
		return -1;
53
	}
54

55
	rec->bytes_written += size;
56
	return 0;
57 58
}

59
static int process_synthesized_event(struct perf_tool *tool,
60
				     union perf_event *event,
61 62
				     struct perf_sample *sample __maybe_unused,
				     struct machine *machine __maybe_unused)
63
{
64 65
	struct record *rec = container_of(tool, struct record, tool);
	return record__write(rec, event, event->header.size);
66 67
}

68
static int record__mmap_read(struct record *rec, int idx)
69
{
70
	struct perf_mmap *md = &rec->evlist->mmap[idx];
71
	unsigned int head = perf_mmap__read_head(md);
72
	unsigned int old = md->prev;
J
Jiri Olsa 已提交
73
	unsigned char *data = md->base + page_size;
74 75
	unsigned long size;
	void *buf;
76
	int rc = 0;
77

78
	if (old == head)
79
		return 0;
80

81
	rec->samples++;
82 83 84 85 86 87 88

	size = head - old;

	if ((old & md->mask) + size != (head & md->mask)) {
		buf = &data[old & md->mask];
		size = md->mask + 1 - (old & md->mask);
		old += size;
89

90
		if (record__write(rec, buf, size) < 0) {
91 92 93
			rc = -1;
			goto out;
		}
94 95 96 97 98
	}

	buf = &data[old & md->mask];
	size = head - old;
	old += size;
99

100
	if (record__write(rec, buf, size) < 0) {
101 102 103
		rc = -1;
		goto out;
	}
104 105

	md->prev = old;
106
	perf_evlist__mmap_consume(rec->evlist, idx);
107 108
out:
	return rc;
109 110 111
}

static volatile int done = 0;
112
static volatile int signr = -1;
113
static volatile int child_finished = 0;
114

115
static void sig_handler(int sig)
116
{
117 118
	if (sig == SIGCHLD)
		child_finished = 1;
119 120
	else
		signr = sig;
121

122
	done = 1;
123 124
}

125
static void record__sig_exit(void)
126
{
127
	if (signr == -1)
128 129 130
		return;

	signal(signr, SIG_DFL);
131
	raise(signr);
132 133
}

134
static int record__open(struct record *rec)
135
{
136
	char msg[512];
137
	struct perf_evsel *pos;
138 139
	struct perf_evlist *evlist = rec->evlist;
	struct perf_session *session = rec->session;
140
	struct record_opts *opts = &rec->opts;
141
	int rc = 0;
142

143
	perf_evlist__config(evlist, opts);
144

145
	evlist__for_each(evlist, pos) {
146
try_again:
147
		if (perf_evsel__open(pos, evlist->cpus, evlist->threads) < 0) {
148
			if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
149
				if (verbose)
150
					ui__warning("%s\n", msg);
151 152
				goto try_again;
			}
153

154 155 156 157
			rc = -errno;
			perf_evsel__open_strerror(pos, &opts->target,
						  errno, msg, sizeof(msg));
			ui__error("%s\n", msg);
158
			goto out;
L
Li Zefan 已提交
159 160
		}
	}
161

162
	if (perf_evlist__apply_filters(evlist)) {
163
		error("failed to set filter with %d (%s)\n", errno,
164
			strerror_r(errno, msg, sizeof(msg)));
165 166
		rc = -1;
		goto out;
167 168
	}

169
	if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
170 171 172 173 174
		if (errno == EPERM) {
			pr_err("Permission error mapping pages.\n"
			       "Consider increasing "
			       "/proc/sys/kernel/perf_event_mlock_kb,\n"
			       "or try again with a smaller value of -m/--mmap_pages.\n"
175
			       "(current value: %u)\n", opts->mmap_pages);
176 177
			rc = -errno;
		} else {
178 179
			pr_err("failed to mmap with %d (%s)\n", errno,
				strerror_r(errno, msg, sizeof(msg)));
180 181 182
			rc = -errno;
		}
		goto out;
183
	}
184

185
	session->evlist = evlist;
186
	perf_session__set_id_hdr_size(session);
187 188
out:
	return rc;
189 190
}

191
static int process_buildids(struct record *rec)
192
{
193 194
	struct perf_data_file *file  = &rec->file;
	struct perf_session *session = rec->session;
195
	u64 start = session->header.data_offset;
196

197
	u64 size = lseek(file->fd, 0, SEEK_CUR);
198 199 200
	if (size == 0)
		return 0;

201 202
	return __perf_session__process_events(session, start,
					      size - start,
203 204 205
					      size, &build_id__mark_dso_hit_ops);
}

206
static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
207 208
{
	int err;
209
	struct perf_tool *tool = data;
210 211 212 213 214 215 216 217
	/*
	 *As for guest kernel when processing subcommand record&report,
	 *we arrange module mmap prior to guest kernel mmap and trigger
	 *a preload dso because default guest module symbols are loaded
	 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
	 *method is used to avoid symbol missing when the first addr is
	 *in module instead of in guest kernel.
	 */
218
	err = perf_event__synthesize_modules(tool, process_synthesized_event,
219
					     machine);
220 221
	if (err < 0)
		pr_err("Couldn't record guest kernel [%d]'s reference"
222
		       " relocation symbol.\n", machine->pid);
223 224 225 226 227

	/*
	 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
	 * have no _text sometimes.
	 */
228
	err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
229
						 machine);
230 231
	if (err < 0)
		pr_err("Couldn't record guest kernel [%d]'s reference"
232
		       " relocation symbol.\n", machine->pid);
233 234
}

235 236 237 238 239
static struct perf_event_header finished_round_event = {
	.size = sizeof(struct perf_event_header),
	.type = PERF_RECORD_FINISHED_ROUND,
};

240
static int record__mmap_read_all(struct record *rec)
241
{
242
	u64 bytes_written = rec->bytes_written;
243
	int i;
244
	int rc = 0;
245

246
	for (i = 0; i < rec->evlist->nr_mmaps; i++) {
247
		if (rec->evlist->mmap[i].base) {
248
			if (record__mmap_read(rec, i) != 0) {
249 250 251 252
				rc = -1;
				goto out;
			}
		}
253 254
	}

255 256 257 258 259 260
	/*
	 * Mark the round finished in case we wrote
	 * at least one event.
	 */
	if (bytes_written != rec->bytes_written)
		rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
261 262 263

out:
	return rc;
264 265
}

266
static void record__init_features(struct record *rec)
267 268 269 270 271 272 273 274 275 276
{
	struct perf_session *session = rec->session;
	int feat;

	for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
		perf_header__set_feat(&session->header, feat);

	if (rec->no_buildid)
		perf_header__clear_feat(&session->header, HEADER_BUILD_ID);

277
	if (!have_tracepoints(&rec->evlist->entries))
278 279 280 281 282 283
		perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);

	if (!rec->opts.branch_stack)
		perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
}

284 285 286 287 288 289 290
static volatile int workload_exec_errno;

/*
 * perf_evlist__prepare_workload will send a SIGUSR1
 * if the fork fails, since we asked by setting its
 * want_signal to true.
 */
291 292
static void workload_exec_failed_signal(int signo __maybe_unused,
					siginfo_t *info,
293 294 295 296 297 298 299
					void *ucontext __maybe_unused)
{
	workload_exec_errno = info->si_value.sival_int;
	done = 1;
	child_finished = 1;
}

300
static int __cmd_record(struct record *rec, int argc, const char **argv)
301
{
302
	int err;
303
	int status = 0;
304
	unsigned long waking = 0;
305
	const bool forks = argc > 0;
306
	struct machine *machine;
307
	struct perf_tool *tool = &rec->tool;
308
	struct record_opts *opts = &rec->opts;
309
	struct perf_data_file *file = &rec->file;
310
	struct perf_session *session;
311
	bool disabled = false, draining = false;
312

313
	rec->progname = argv[0];
314

315
	atexit(record__sig_exit);
316 317
	signal(SIGCHLD, sig_handler);
	signal(SIGINT, sig_handler);
318
	signal(SIGTERM, sig_handler);
319

320
	session = perf_session__new(file, false, NULL);
321
	if (session == NULL) {
A
Adrien BAK 已提交
322
		pr_err("Perf session creation failed.\n");
323 324 325
		return -1;
	}

326 327
	rec->session = session;

328
	record__init_features(rec);
329

330
	if (forks) {
331
		err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
332
						    argv, file->is_pipe,
333
						    workload_exec_failed_signal);
334 335
		if (err < 0) {
			pr_err("Couldn't run the workload!\n");
336
			status = err;
337
			goto out_delete_session;
338 339 340
		}
	}

341
	if (record__open(rec) != 0) {
342
		err = -1;
343
		goto out_child;
344
	}
345

346
	if (!rec->evlist->nr_groups)
347 348
		perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);

349 350
	if (file->is_pipe) {
		err = perf_header__write_pipe(file->fd);
351
		if (err < 0)
352
			goto out_child;
353
	} else {
354
		err = perf_session__write_header(session, rec->evlist,
355
						 file->fd, false);
356
		if (err < 0)
357
			goto out_child;
358 359
	}

360
	if (!rec->no_buildid
361
	    && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
362
		pr_err("Couldn't generate buildids. "
363
		       "Use --no-buildid to profile anyway.\n");
364
		err = -1;
365
		goto out_child;
366 367
	}

368
	machine = &session->machines.host;
369

370
	if (file->is_pipe) {
371
		err = perf_event__synthesize_attrs(tool, session,
372
						   process_synthesized_event);
373 374
		if (err < 0) {
			pr_err("Couldn't synthesize attrs.\n");
375
			goto out_child;
376
		}
377

378
		if (have_tracepoints(&rec->evlist->entries)) {
379 380 381 382 383 384 385 386
			/*
			 * FIXME err <= 0 here actually means that
			 * there were no tracepoints so its not really
			 * an error, just that we don't need to
			 * synthesize anything.  We really have to
			 * return this more properly and also
			 * propagate errors that now are calling die()
			 */
387
			err = perf_event__synthesize_tracing_data(tool, file->fd, rec->evlist,
388
								  process_synthesized_event);
389 390
			if (err <= 0) {
				pr_err("Couldn't record tracing data.\n");
391
				goto out_child;
392
			}
393
			rec->bytes_written += err;
394
		}
395 396
	}

397
	err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
398
						 machine);
399 400 401 402
	if (err < 0)
		pr_err("Couldn't record kernel reference relocation symbol\n"
		       "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
		       "Check /proc/kallsyms permission or run as root.\n");
403

404
	err = perf_event__synthesize_modules(tool, process_synthesized_event,
405
					     machine);
406 407 408 409 410
	if (err < 0)
		pr_err("Couldn't record kernel module information.\n"
		       "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
		       "Check /proc/modules permission or run as root.\n");

411
	if (perf_guest) {
412 413
		machines__process_guests(&session->machines,
					 perf_event__synthesize_guest_os, tool);
414
	}
415

416
	err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
417
					    process_synthesized_event, opts->sample_address);
418
	if (err != 0)
419
		goto out_child;
420

421
	if (rec->realtime_prio) {
422 423
		struct sched_param param;

424
		param.sched_priority = rec->realtime_prio;
425
		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
426
			pr_err("Could not set realtime priority.\n");
427
			err = -1;
428
			goto out_child;
429 430 431
		}
	}

432 433 434 435 436
	/*
	 * When perf is starting the traced process, all the events
	 * (apart from group members) have enable_on_exec=1 set,
	 * so don't spoil it by prematurely enabling them.
	 */
437
	if (!target__none(&opts->target) && !opts->initial_delay)
438
		perf_evlist__enable(rec->evlist);
439

440 441 442
	/*
	 * Let the child rip
	 */
443
	if (forks)
444
		perf_evlist__start_workload(rec->evlist);
445

446 447 448 449 450
	if (opts->initial_delay) {
		usleep(opts->initial_delay * 1000);
		perf_evlist__enable(rec->evlist);
	}

451
	for (;;) {
452
		int hits = rec->samples;
453

454
		if (record__mmap_read_all(rec) < 0) {
455
			err = -1;
456
			goto out_child;
457
		}
458

459
		if (hits == rec->samples) {
460
			if (done || draining)
461
				break;
462
			err = perf_evlist__poll(rec->evlist, -1);
463 464 465 466 467
			/*
			 * Propagate error, only if there's any. Ignore positive
			 * number of returned events and interrupt error.
			 */
			if (err > 0 || (err < 0 && errno == EINTR))
468
				err = 0;
469
			waking++;
470 471 472

			if (perf_evlist__filter_pollfd(rec->evlist, POLLERR | POLLHUP) == 0)
				draining = true;
473 474
		}

475 476 477 478 479
		/*
		 * When perf is starting the traced process, at the end events
		 * die with the process and we wait for that. Thus no need to
		 * disable events in this case.
		 */
480
		if (done && !disabled && !target__none(&opts->target)) {
481
			perf_evlist__disable(rec->evlist);
482 483
			disabled = true;
		}
484 485
	}

486
	if (forks && workload_exec_errno) {
487
		char msg[STRERR_BUFSIZE];
488 489 490
		const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
		pr_err("Workload failed: %s\n", emsg);
		err = -1;
491
		goto out_child;
492 493
	}

494 495
	if (!quiet) {
		fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
496

497 498 499 500 501 502 503 504 505
		/*
		 * Approximate RIP event size: 24 bytes.
		 */
		fprintf(stderr,
			"[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
			(double)rec->bytes_written / 1024.0 / 1024.0,
			file->path,
			rec->bytes_written / 24);
	}
506

507 508 509
out_child:
	if (forks) {
		int exit_status;
510

511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
		if (!child_finished)
			kill(rec->evlist->workload.pid, SIGTERM);

		wait(&exit_status);

		if (err < 0)
			status = err;
		else if (WIFEXITED(exit_status))
			status = WEXITSTATUS(exit_status);
		else if (WIFSIGNALED(exit_status))
			signr = WTERMSIG(exit_status);
	} else
		status = err;

	if (!err && !file->is_pipe) {
		rec->session->header.data_size += rec->bytes_written;

		if (!rec->no_buildid)
			process_buildids(rec);
		perf_session__write_header(rec->session, rec->evlist,
					   file->fd, true);
	}
533 534 535

out_delete_session:
	perf_session__delete(session);
536
	return status;
537
}
538

539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
#define BRANCH_OPT(n, m) \
	{ .name = n, .mode = (m) }

#define BRANCH_END { .name = NULL }

struct branch_mode {
	const char *name;
	int mode;
};

static const struct branch_mode branch_modes[] = {
	BRANCH_OPT("u", PERF_SAMPLE_BRANCH_USER),
	BRANCH_OPT("k", PERF_SAMPLE_BRANCH_KERNEL),
	BRANCH_OPT("hv", PERF_SAMPLE_BRANCH_HV),
	BRANCH_OPT("any", PERF_SAMPLE_BRANCH_ANY),
	BRANCH_OPT("any_call", PERF_SAMPLE_BRANCH_ANY_CALL),
	BRANCH_OPT("any_ret", PERF_SAMPLE_BRANCH_ANY_RETURN),
	BRANCH_OPT("ind_call", PERF_SAMPLE_BRANCH_IND_CALL),
557 558 559
	BRANCH_OPT("abort_tx", PERF_SAMPLE_BRANCH_ABORT_TX),
	BRANCH_OPT("in_tx", PERF_SAMPLE_BRANCH_IN_TX),
	BRANCH_OPT("no_tx", PERF_SAMPLE_BRANCH_NO_TX),
560
	BRANCH_OPT("cond", PERF_SAMPLE_BRANCH_COND),
561 562 563 564
	BRANCH_END
};

static int
565
parse_branch_stack(const struct option *opt, const char *str, int unset)
566 567 568 569 570 571 572 573
{
#define ONLY_PLM \
	(PERF_SAMPLE_BRANCH_USER	|\
	 PERF_SAMPLE_BRANCH_KERNEL	|\
	 PERF_SAMPLE_BRANCH_HV)

	uint64_t *mode = (uint64_t *)opt->value;
	const struct branch_mode *br;
574
	char *s, *os = NULL, *p;
575 576
	int ret = -1;

577 578
	if (unset)
		return 0;
579

580 581 582 583
	/*
	 * cannot set it twice, -b + --branch-filter for instance
	 */
	if (*mode)
584 585
		return -1;

586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
	/* str may be NULL in case no arg is passed to -b */
	if (str) {
		/* because str is read-only */
		s = os = strdup(str);
		if (!s)
			return -1;

		for (;;) {
			p = strchr(s, ',');
			if (p)
				*p = '\0';

			for (br = branch_modes; br->name; br++) {
				if (!strcasecmp(s, br->name))
					break;
			}
			if (!br->name) {
				ui__warning("unknown branch filter %s,"
					    " check man page\n", s);
				goto error;
			}
607

608
			*mode |= br->mode;
609

610 611
			if (!p)
				break;
612

613 614
			s = p + 1;
		}
615 616 617
	}
	ret = 0;

618
	/* default to any branch */
619
	if ((*mode & ~ONLY_PLM) == 0) {
620
		*mode = PERF_SAMPLE_BRANCH_ANY;
621 622 623 624 625 626
	}
error:
	free(os);
	return ret;
}

627
static void callchain_debug(void)
J
Jiri Olsa 已提交
628
{
629 630
	static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF" };

631
	pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
632

633
	if (callchain_param.record_mode == CALLCHAIN_DWARF)
J
Jiri Olsa 已提交
634
		pr_debug("callchain: stack dump size %d\n",
635
			 callchain_param.dump_size);
J
Jiri Olsa 已提交
636 637
}

638
int record_parse_callchain_opt(const struct option *opt __maybe_unused,
J
Jiri Olsa 已提交
639 640 641 642 643
			       const char *arg,
			       int unset)
{
	int ret;

644
	callchain_param.enabled = !unset;
645

J
Jiri Olsa 已提交
646 647
	/* --no-call-graph */
	if (unset) {
648
		callchain_param.record_mode = CALLCHAIN_NONE;
J
Jiri Olsa 已提交
649 650 651 652
		pr_debug("callchain: disabled\n");
		return 0;
	}

653
	ret = parse_callchain_record_opt(arg);
654
	if (!ret)
655
		callchain_debug();
656 657 658 659

	return ret;
}

660
int record_callchain_opt(const struct option *opt __maybe_unused,
J
Jiri Olsa 已提交
661 662 663
			 const char *arg __maybe_unused,
			 int unset __maybe_unused)
{
664
	callchain_param.enabled = true;
J
Jiri Olsa 已提交
665

666 667
	if (callchain_param.record_mode == CALLCHAIN_NONE)
		callchain_param.record_mode = CALLCHAIN_FP;
668

669
	callchain_debug();
J
Jiri Olsa 已提交
670 671 672
	return 0;
}

673 674 675
static int perf_record_config(const char *var, const char *value, void *cb)
{
	if (!strcmp(var, "record.call-graph"))
676
		var = "call-graph.record-mode"; /* fall-through */
677 678 679 680

	return perf_default_config(var, value, cb);
}

681
static const char * const record_usage[] = {
682 683
	"perf record [<options>] [<command>]",
	"perf record [<options>] -- <command> [<options>]",
684 685 686
	NULL
};

687
/*
688 689
 * XXX Ideally would be local to cmd_record() and passed to a record__new
 * because we need to have access to it in record__exit, that is called
690 691 692 693 694 695 696
 * after cmd_record() exits, but since record_options need to be accessible to
 * builtin-script, leave it here.
 *
 * At least we don't ouch it in all the other functions here directly.
 *
 * Just say no to tons of global variables, sigh.
 */
697
static struct record record = {
698
	.opts = {
699
		.sample_time	     = true,
700 701 702
		.mmap_pages	     = UINT_MAX,
		.user_freq	     = UINT_MAX,
		.user_interval	     = ULLONG_MAX,
703
		.freq		     = 4000,
N
Namhyung Kim 已提交
704 705
		.target		     = {
			.uses_mmap   = true,
706
			.default_per_cpu = true,
N
Namhyung Kim 已提交
707
		},
708 709
	},
};
710

J
Jiri Olsa 已提交
711
#define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
712

713
#ifdef HAVE_DWARF_UNWIND_SUPPORT
J
Jiri Olsa 已提交
714
const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf";
715
#else
J
Jiri Olsa 已提交
716
const char record_callchain_help[] = CALLCHAIN_HELP "fp";
717 718
#endif

719 720 721
/*
 * XXX Will stay a global variable till we fix builtin-script.c to stop messing
 * with it and switch to use the library functions in perf_evlist that came
722
 * from builtin-record.c, i.e. use record_opts,
723 724 725
 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
 * using pipes, etc.
 */
726
const struct option record_options[] = {
727
	OPT_CALLBACK('e', "event", &record.evlist, "event",
728
		     "event selector. use 'perf list' to list available events",
729
		     parse_events_option),
730
	OPT_CALLBACK(0, "filter", &record.evlist, "filter",
L
Li Zefan 已提交
731
		     "event filter", parse_filter),
732
	OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
733
		    "record events on existing process id"),
734
	OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
735
		    "record events on existing thread id"),
736
	OPT_INTEGER('r', "realtime", &record.realtime_prio,
737
		    "collect data with this RT SCHED_FIFO priority"),
738
	OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
739
		    "collect data without buffering"),
740
	OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
741
		    "collect raw sample records from all opened counters"),
742
	OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
743
			    "system-wide collection from all CPUs"),
744
	OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
745
		    "list of cpus to monitor"),
746
	OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
747
	OPT_STRING('o', "output", &record.file.path, "file",
I
Ingo Molnar 已提交
748
		    "output file name"),
749 750 751
	OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
			&record.opts.no_inherit_set,
			"child tasks do not inherit counters"),
752
	OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
753 754 755
	OPT_CALLBACK('m', "mmap-pages", &record.opts.mmap_pages, "pages",
		     "number of mmap data pages",
		     perf_evlist__parse_mmap_pages),
756
	OPT_BOOLEAN(0, "group", &record.opts.group,
757
		    "put the counters into a counter group"),
J
Jiri Olsa 已提交
758 759 760 761 762 763
	OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
			   NULL, "enables call-graph recording" ,
			   &record_callchain_opt),
	OPT_CALLBACK(0, "call-graph", &record.opts,
		     "mode[,dump_size]", record_callchain_help,
		     &record_parse_callchain_opt),
764
	OPT_INCR('v', "verbose", &verbose,
765
		    "be more verbose (show counter open errors, etc)"),
766
	OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
767
	OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
768
		    "per thread counts"),
769
	OPT_BOOLEAN('d', "data", &record.opts.sample_address,
770
		    "Sample addresses"),
771
	OPT_BOOLEAN('T', "timestamp", &record.opts.sample_time, "Sample timestamps"),
772
	OPT_BOOLEAN('P', "period", &record.opts.period, "Sample period"),
773
	OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
774
		    "don't sample"),
775
	OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
776
		    "do not update the buildid cache"),
777
	OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
778
		    "do not collect buildids in perf.data"),
779
	OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
S
Stephane Eranian 已提交
780 781
		     "monitor event in cgroup name only",
		     parse_cgroups),
782
	OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
783
		  "ms to wait before starting measurement after program start"),
784 785
	OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
		   "user to profile"),
786 787 788 789 790 791 792

	OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
		     "branch any", "sample any taken branches",
		     parse_branch_stack),

	OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
		     "branch filter mask", "branch stack filter modes",
793
		     parse_branch_stack),
794 795
	OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
		    "sample by weight (on special events only)"),
796 797
	OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
		    "sample transaction flags (special events only)"),
798 799
	OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
		    "use per-thread mmaps"),
800 801 802
	OPT_END()
};

803
int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
804
{
805
	int err = -ENOMEM;
806
	struct record *rec = &record;
807
	char errbuf[BUFSIZ];
808

809 810
	rec->evlist = perf_evlist__new();
	if (rec->evlist == NULL)
811 812
		return -ENOMEM;

813 814
	perf_config(perf_record_config, rec);

815
	argc = parse_options(argc, argv, record_options, record_usage,
816
			    PARSE_OPT_STOP_AT_NON_OPTION);
817
	if (!argc && target__none(&rec->opts.target))
818
		usage_with_options(record_usage, record_options);
819

820
	if (nr_cgroups && !rec->opts.target.system_wide) {
821 822
		ui__error("cgroup monitoring only available in"
			  " system-wide mode\n");
S
Stephane Eranian 已提交
823 824 825
		usage_with_options(record_usage, record_options);
	}

826
	symbol__init(NULL);
827

828
	if (symbol_conf.kptr_restrict)
829 830 831 832 833 834 835 836
		pr_warning(
"WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
"check /proc/sys/kernel/kptr_restrict.\n\n"
"Samples in kernel functions may not be resolved if a suitable vmlinux\n"
"file is not found in the buildid cache or in the vmlinux path.\n\n"
"Samples in kernel modules won't be resolved at all.\n\n"
"If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
"even with a suitable vmlinux or kallsyms file.\n\n");
837

838
	if (rec->no_buildid_cache || rec->no_buildid)
839
		disable_buildid_cache();
840

841 842
	if (rec->evlist->nr_entries == 0 &&
	    perf_evlist__add_default(rec->evlist) < 0) {
843 844
		pr_err("Not enough memory for event selector list\n");
		goto out_symbol_exit;
845
	}
846

847 848 849
	if (rec->opts.target.tid && !rec->opts.no_inherit_set)
		rec->opts.no_inherit = true;

850
	err = target__validate(&rec->opts.target);
851
	if (err) {
852
		target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
853 854 855
		ui__warning("%s", errbuf);
	}

856
	err = target__parse_uid(&rec->opts.target);
857 858
	if (err) {
		int saved_errno = errno;
859

860
		target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
861
		ui__error("%s", errbuf);
862 863

		err = -saved_errno;
864
		goto out_symbol_exit;
865
	}
866

867
	err = -ENOMEM;
868
	if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
869
		usage_with_options(record_usage, record_options);
870

871
	if (record_opts__config(&rec->opts)) {
872
		err = -EINVAL;
873
		goto out_symbol_exit;
874 875
	}

876
	err = __cmd_record(&record, argc, argv);
877
out_symbol_exit:
878
	perf_evlist__delete(rec->evlist);
879
	symbol__exit();
880
	return err;
881
}