builtin-record.c 37.0 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 <subcmd/parse-options.h>
15
#include "util/parse-events.h"
16

17
#include "util/callchain.h"
18
#include "util/cgroup.h"
19
#include "util/header.h"
20
#include "util/event.h"
21
#include "util/evlist.h"
22
#include "util/evsel.h"
23
#include "util/debug.h"
24
#include "util/session.h"
25
#include "util/tool.h"
26
#include "util/symbol.h"
27
#include "util/cpumap.h"
28
#include "util/thread_map.h"
29
#include "util/data.h"
30
#include "util/perf_regs.h"
31
#include "util/auxtrace.h"
32
#include "util/tsc.h"
33
#include "util/parse-branch-options.h"
34
#include "util/parse-regs-options.h"
35
#include "util/llvm-utils.h"
36
#include "util/bpf-loader.h"
37
#include "asm/bug.h"
38

39
#include <unistd.h>
40
#include <sched.h>
41
#include <sys/mman.h>
42

43

44
struct record {
45
	struct perf_tool	tool;
46
	struct record_opts	opts;
47
	u64			bytes_written;
48
	struct perf_data_file	file;
49
	struct auxtrace_record	*itr;
50 51 52 53 54
	struct perf_evlist	*evlist;
	struct perf_session	*session;
	const char		*progname;
	int			realtime_prio;
	bool			no_buildid;
55
	bool			no_buildid_set;
56
	bool			no_buildid_cache;
57
	bool			no_buildid_cache_set;
58
	bool			buildid_all;
59
	bool			timestamp_filename;
60
	unsigned long long	samples;
61
};
62

63
static int record__write(struct record *rec, void *bf, size_t size)
64
{
65
	if (perf_data_file__write(rec->session->file, bf, size) < 0) {
66 67
		pr_err("failed to write perf data, error: %m\n");
		return -1;
68
	}
69

70
	rec->bytes_written += size;
71
	return 0;
72 73
}

74
static int process_synthesized_event(struct perf_tool *tool,
75
				     union perf_event *event,
76 77
				     struct perf_sample *sample __maybe_unused,
				     struct machine *machine __maybe_unused)
78
{
79 80
	struct record *rec = container_of(tool, struct record, tool);
	return record__write(rec, event, event->header.size);
81 82
}

83
static int record__mmap_read(struct record *rec, int idx)
84
{
85
	struct perf_mmap *md = &rec->evlist->mmap[idx];
86 87
	u64 head = perf_mmap__read_head(md);
	u64 old = md->prev;
J
Jiri Olsa 已提交
88
	unsigned char *data = md->base + page_size;
89 90
	unsigned long size;
	void *buf;
91
	int rc = 0;
92

93
	if (old == head)
94
		return 0;
95

96
	rec->samples++;
97 98 99 100 101 102 103

	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;
104

105
		if (record__write(rec, buf, size) < 0) {
106 107 108
			rc = -1;
			goto out;
		}
109 110 111 112 113
	}

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

115
	if (record__write(rec, buf, size) < 0) {
116 117 118
		rc = -1;
		goto out;
	}
119 120

	md->prev = old;
121
	perf_evlist__mmap_consume(rec->evlist, idx);
122 123
out:
	return rc;
124 125
}

126 127 128
static volatile int done;
static volatile int signr = -1;
static volatile int child_finished;
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165

static volatile enum {
	AUXTRACE_SNAPSHOT_OFF = -1,
	AUXTRACE_SNAPSHOT_DISABLED = 0,
	AUXTRACE_SNAPSHOT_ENABLED = 1,
} auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_OFF;

static inline void
auxtrace_snapshot_on(void)
{
	auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_DISABLED;
}

static inline void
auxtrace_snapshot_enable(void)
{
	if (auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_OFF)
		return;
	auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_ENABLED;
}

static inline void
auxtrace_snapshot_disable(void)
{
	if (auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_OFF)
		return;
	auxtrace_snapshot_state = AUXTRACE_SNAPSHOT_DISABLED;
}

static inline bool
auxtrace_snapshot_is_enabled(void)
{
	if (auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_OFF)
		return false;
	return auxtrace_snapshot_state == AUXTRACE_SNAPSHOT_ENABLED;
}

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
static volatile int auxtrace_snapshot_err;
static volatile int auxtrace_record__snapshot_started;

static void sig_handler(int sig)
{
	if (sig == SIGCHLD)
		child_finished = 1;
	else
		signr = sig;

	done = 1;
}

static void record__sig_exit(void)
{
	if (signr == -1)
		return;

	signal(signr, SIG_DFL);
	raise(signr);
}

188 189
#ifdef HAVE_AUXTRACE_SUPPORT

190 191 192 193 194
static int record__process_auxtrace(struct perf_tool *tool,
				    union perf_event *event, void *data1,
				    size_t len1, void *data2, size_t len2)
{
	struct record *rec = container_of(tool, struct record, tool);
195
	struct perf_data_file *file = &rec->file;
196 197 198
	size_t padding;
	u8 pad[8] = {0};

199 200 201 202 203 204 205 206 207 208 209 210 211 212
	if (!perf_data_file__is_pipe(file)) {
		off_t file_offset;
		int fd = perf_data_file__fd(file);
		int err;

		file_offset = lseek(fd, 0, SEEK_CUR);
		if (file_offset == -1)
			return -1;
		err = auxtrace_index__auxtrace_event(&rec->session->auxtrace_index,
						     event, file_offset);
		if (err)
			return err;
	}

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
	/* event.auxtrace.size includes padding, see __auxtrace_mmap__read() */
	padding = (len1 + len2) & 7;
	if (padding)
		padding = 8 - padding;

	record__write(rec, event, event->header.size);
	record__write(rec, data1, len1);
	if (len2)
		record__write(rec, data2, len2);
	record__write(rec, &pad, padding);

	return 0;
}

static int record__auxtrace_mmap_read(struct record *rec,
				      struct auxtrace_mmap *mm)
{
	int ret;

	ret = auxtrace_mmap__read(mm, rec->itr, &rec->tool,
				  record__process_auxtrace);
	if (ret < 0)
		return ret;

	if (ret)
		rec->samples++;

	return 0;
}

243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
static int record__auxtrace_mmap_read_snapshot(struct record *rec,
					       struct auxtrace_mmap *mm)
{
	int ret;

	ret = auxtrace_mmap__read_snapshot(mm, rec->itr, &rec->tool,
					   record__process_auxtrace,
					   rec->opts.auxtrace_snapshot_size);
	if (ret < 0)
		return ret;

	if (ret)
		rec->samples++;

	return 0;
}

static int record__auxtrace_read_snapshot_all(struct record *rec)
{
	int i;
	int rc = 0;

	for (i = 0; i < rec->evlist->nr_mmaps; i++) {
		struct auxtrace_mmap *mm =
				&rec->evlist->mmap[i].auxtrace_mmap;

		if (!mm->base)
			continue;

		if (record__auxtrace_mmap_read_snapshot(rec, mm) != 0) {
			rc = -1;
			goto out;
		}
	}
out:
	return rc;
}

static void record__read_auxtrace_snapshot(struct record *rec)
{
	pr_debug("Recording AUX area tracing snapshot\n");
	if (record__auxtrace_read_snapshot_all(rec) < 0) {
		auxtrace_snapshot_err = -1;
	} else {
		auxtrace_snapshot_err = auxtrace_record__snapshot_finish(rec->itr);
		if (!auxtrace_snapshot_err)
289
			auxtrace_snapshot_enable();
290 291 292
	}
}

293 294 295 296 297 298 299 300 301
#else

static inline
int record__auxtrace_mmap_read(struct record *rec __maybe_unused,
			       struct auxtrace_mmap *mm __maybe_unused)
{
	return 0;
}

302 303
static inline
void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
304
{
305 306
}

307 308
static inline
int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
309
{
310
	return 0;
311 312
}

313 314
#endif

315
static int record__open(struct record *rec)
316
{
317
	char msg[512];
318
	struct perf_evsel *pos;
319 320
	struct perf_evlist *evlist = rec->evlist;
	struct perf_session *session = rec->session;
321
	struct record_opts *opts = &rec->opts;
322
	int rc = 0;
323

324
	perf_evlist__config(evlist, opts, &callchain_param);
325

326
	evlist__for_each(evlist, pos) {
327
try_again:
328
		if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
329
			if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
330
				if (verbose)
331
					ui__warning("%s\n", msg);
332 333
				goto try_again;
			}
334

335 336 337 338
			rc = -errno;
			perf_evsel__open_strerror(pos, &opts->target,
						  errno, msg, sizeof(msg));
			ui__error("%s\n", msg);
339
			goto out;
L
Li Zefan 已提交
340 341
		}
	}
342

343 344 345
	if (perf_evlist__apply_filters(evlist, &pos)) {
		error("failed to set filter \"%s\" on event %s with %d (%s)\n",
			pos->filter, perf_evsel__name(pos), errno,
346
			strerror_r(errno, msg, sizeof(msg)));
347 348
		rc = -1;
		goto out;
349 350
	}

351
	if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
352 353
				 opts->auxtrace_mmap_pages,
				 opts->auxtrace_snapshot_mode) < 0) {
354 355 356 357 358
		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"
359 360
			       "(current value: %u,%u)\n",
			       opts->mmap_pages, opts->auxtrace_mmap_pages);
361 362
			rc = -errno;
		} else {
363 364
			pr_err("failed to mmap with %d (%s)\n", errno,
				strerror_r(errno, msg, sizeof(msg)));
365 366 367 368
			if (errno)
				rc = -errno;
			else
				rc = -EINVAL;
369 370
		}
		goto out;
371
	}
372

373
	session->evlist = evlist;
374
	perf_session__set_id_hdr_size(session);
375 376
out:
	return rc;
377 378
}

379 380 381 382 383 384 385 386 387 388 389 390 391
static int process_sample_event(struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct perf_evsel *evsel,
				struct machine *machine)
{
	struct record *rec = container_of(tool, struct record, tool);

	rec->samples++;

	return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
}

392
static int process_buildids(struct record *rec)
393
{
394 395
	struct perf_data_file *file  = &rec->file;
	struct perf_session *session = rec->session;
396

397
	if (file->size == 0)
398 399
		return 0;

400 401 402 403 404 405 406 407 408 409 410
	/*
	 * During this process, it'll load kernel map and replace the
	 * dso->long_name to a real pathname it found.  In this case
	 * we prefer the vmlinux path like
	 *   /lib/modules/3.16.4/build/vmlinux
	 *
	 * rather than build-id path (in debug directory).
	 *   $HOME/.debug/.build-id/f0/6e17aa50adf4d00b88925e03775de107611551
	 */
	symbol_conf.ignore_vmlinux_buildid = true;

411 412 413 414 415 416 417
	/*
	 * If --buildid-all is given, it marks all DSO regardless of hits,
	 * so no need to process samples.
	 */
	if (rec->buildid_all)
		rec->tool.sample = NULL;

418
	return perf_session__process_events(session);
419 420
}

421
static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
422 423
{
	int err;
424
	struct perf_tool *tool = data;
425 426 427 428 429 430 431 432
	/*
	 *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.
	 */
433
	err = perf_event__synthesize_modules(tool, process_synthesized_event,
434
					     machine);
435 436
	if (err < 0)
		pr_err("Couldn't record guest kernel [%d]'s reference"
437
		       " relocation symbol.\n", machine->pid);
438 439 440 441 442

	/*
	 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
	 * have no _text sometimes.
	 */
443
	err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
444
						 machine);
445 446
	if (err < 0)
		pr_err("Couldn't record guest kernel [%d]'s reference"
447
		       " relocation symbol.\n", machine->pid);
448 449
}

450 451 452 453 454
static struct perf_event_header finished_round_event = {
	.size = sizeof(struct perf_event_header),
	.type = PERF_RECORD_FINISHED_ROUND,
};

455
static int record__mmap_read_all(struct record *rec)
456
{
457
	u64 bytes_written = rec->bytes_written;
458
	int i;
459
	int rc = 0;
460

461
	for (i = 0; i < rec->evlist->nr_mmaps; i++) {
462 463
		struct auxtrace_mmap *mm = &rec->evlist->mmap[i].auxtrace_mmap;

464
		if (rec->evlist->mmap[i].base) {
465
			if (record__mmap_read(rec, i) != 0) {
466 467 468 469
				rc = -1;
				goto out;
			}
		}
470

471
		if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
472 473 474 475
		    record__auxtrace_mmap_read(rec, mm) != 0) {
			rc = -1;
			goto out;
		}
476 477
	}

478 479 480 481 482 483
	/*
	 * 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));
484 485 486

out:
	return rc;
487 488
}

489
static void record__init_features(struct record *rec)
490 491 492 493 494 495 496 497 498 499
{
	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);

500
	if (!have_tracepoints(&rec->evlist->entries))
501 502 503 504
		perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);

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

	if (!rec->opts.full_auxtrace)
		perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
508 509

	perf_header__clear_feat(&session->header, HEADER_STAT);
510 511
}

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
static void
record__finish_output(struct record *rec)
{
	struct perf_data_file *file = &rec->file;
	int fd = perf_data_file__fd(file);

	if (file->is_pipe)
		return;

	rec->session->header.data_size += rec->bytes_written;
	file->size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);

	if (!rec->no_buildid) {
		process_buildids(rec);

		if (rec->buildid_all)
			dsos__hit_all(rec->session);
	}
	perf_session__write_header(rec->session, rec->evlist, fd, true);

	return;
}

535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
static int
record__switch_output(struct record *rec, bool at_exit)
{
	struct perf_data_file *file = &rec->file;
	int fd, err;

	/* Same Size:      "2015122520103046"*/
	char timestamp[] = "InvalidTimestamp";

	rec->samples = 0;
	record__finish_output(rec);
	err = fetch_current_timestamp(timestamp, sizeof(timestamp));
	if (err) {
		pr_err("Failed to get current timestamp\n");
		return -EINVAL;
	}

	fd = perf_data_file__switch(file, timestamp,
				    rec->session->header.data_offset,
				    at_exit);
	if (fd >= 0 && !at_exit) {
		rec->bytes_written = 0;
		rec->session->header.data_size = 0;
	}

	if (!quiet)
		fprintf(stderr, "[ perf record: Dump %s.%s ]\n",
			file->path, timestamp);
	return fd;
}

566 567 568 569 570 571 572
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.
 */
573 574
static void workload_exec_failed_signal(int signo __maybe_unused,
					siginfo_t *info,
575 576 577 578 579 580 581
					void *ucontext __maybe_unused)
{
	workload_exec_errno = info->si_value.sival_int;
	done = 1;
	child_finished = 1;
}

582 583
static void snapshot_sig_handler(int sig);

584 585 586 587 588 589 590 591 592
int __weak
perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused,
			    struct perf_tool *tool __maybe_unused,
			    perf_event__handler_t process __maybe_unused,
			    struct machine *machine __maybe_unused)
{
	return 0;
}

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
static int record__synthesize(struct record *rec)
{
	struct perf_session *session = rec->session;
	struct machine *machine = &session->machines.host;
	struct perf_data_file *file = &rec->file;
	struct record_opts *opts = &rec->opts;
	struct perf_tool *tool = &rec->tool;
	int fd = perf_data_file__fd(file);
	int err = 0;

	if (file->is_pipe) {
		err = perf_event__synthesize_attrs(tool, session,
						   process_synthesized_event);
		if (err < 0) {
			pr_err("Couldn't synthesize attrs.\n");
			goto out;
		}

		if (have_tracepoints(&rec->evlist->entries)) {
			/*
			 * 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()
			 */
			err = perf_event__synthesize_tracing_data(tool,	fd, rec->evlist,
								  process_synthesized_event);
			if (err <= 0) {
				pr_err("Couldn't record tracing data.\n");
				goto out;
			}
			rec->bytes_written += err;
		}
	}

630 631 632 633 634
	err = perf_event__synth_time_conv(rec->evlist->mmap[0].base, tool,
					  process_synthesized_event, machine);
	if (err)
		goto out;

635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
	if (rec->opts.full_auxtrace) {
		err = perf_event__synthesize_auxtrace_info(rec->itr, tool,
					session, process_synthesized_event);
		if (err)
			goto out;
	}

	err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
						 machine);
	WARN_ONCE(err < 0, "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");

	err = perf_event__synthesize_modules(tool, process_synthesized_event,
					     machine);
	WARN_ONCE(err < 0, "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");

	if (perf_guest) {
		machines__process_guests(&session->machines,
					 perf_event__synthesize_guest_os, tool);
	}

	err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
					    process_synthesized_event, opts->sample_address,
					    opts->proc_map_timeout);
out:
	return err;
}

666
static int __cmd_record(struct record *rec, int argc, const char **argv)
667
{
668
	int err;
669
	int status = 0;
670
	unsigned long waking = 0;
671
	const bool forks = argc > 0;
672
	struct machine *machine;
673
	struct perf_tool *tool = &rec->tool;
674
	struct record_opts *opts = &rec->opts;
675
	struct perf_data_file *file = &rec->file;
676
	struct perf_session *session;
677
	bool disabled = false, draining = false;
678
	int fd;
679

680
	rec->progname = argv[0];
681

682
	atexit(record__sig_exit);
683 684
	signal(SIGCHLD, sig_handler);
	signal(SIGINT, sig_handler);
685
	signal(SIGTERM, sig_handler);
686 687

	if (rec->opts.auxtrace_snapshot_mode) {
688
		signal(SIGUSR2, snapshot_sig_handler);
689 690
		auxtrace_snapshot_on();
	} else {
691
		signal(SIGUSR2, SIG_IGN);
692
	}
693

694
	session = perf_session__new(file, false, tool);
695
	if (session == NULL) {
A
Adrien BAK 已提交
696
		pr_err("Perf session creation failed.\n");
697 698 699
		return -1;
	}

700
	fd = perf_data_file__fd(file);
701 702
	rec->session = session;

703
	record__init_features(rec);
704

705
	if (forks) {
706
		err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
707
						    argv, file->is_pipe,
708
						    workload_exec_failed_signal);
709 710
		if (err < 0) {
			pr_err("Couldn't run the workload!\n");
711
			status = err;
712
			goto out_delete_session;
713 714 715
		}
	}

716
	if (record__open(rec) != 0) {
717
		err = -1;
718
		goto out_child;
719
	}
720

721 722 723 724 725 726 727 728 729 730
	err = bpf__apply_obj_config();
	if (err) {
		char errbuf[BUFSIZ];

		bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
		pr_err("ERROR: Apply config to BPF failed: %s\n",
			 errbuf);
		goto out_child;
	}

731 732 733 734 735 736 737 738 739
	/*
	 * Normally perf_session__new would do this, but it doesn't have the
	 * evlist.
	 */
	if (rec->tool.ordered_events && !perf_evlist__sample_id_all(rec->evlist)) {
		pr_warning("WARNING: No sample_id_all support, falling back to unordered processing\n");
		rec->tool.ordered_events = false;
	}

740
	if (!rec->evlist->nr_groups)
741 742
		perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);

743
	if (file->is_pipe) {
744
		err = perf_header__write_pipe(fd);
745
		if (err < 0)
746
			goto out_child;
747
	} else {
748
		err = perf_session__write_header(session, rec->evlist, fd, false);
749
		if (err < 0)
750
			goto out_child;
751 752
	}

753
	if (!rec->no_buildid
754
	    && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
755
		pr_err("Couldn't generate buildids. "
756
		       "Use --no-buildid to profile anyway.\n");
757
		err = -1;
758
		goto out_child;
759 760
	}

761
	machine = &session->machines.host;
762

763 764
	err = record__synthesize(rec);
	if (err < 0)
765
		goto out_child;
766

767
	if (rec->realtime_prio) {
768 769
		struct sched_param param;

770
		param.sched_priority = rec->realtime_prio;
771
		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
772
			pr_err("Could not set realtime priority.\n");
773
			err = -1;
774
			goto out_child;
775 776 777
		}
	}

778 779 780 781 782
	/*
	 * 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.
	 */
783
	if (!target__none(&opts->target) && !opts->initial_delay)
784
		perf_evlist__enable(rec->evlist);
785

786 787 788
	/*
	 * Let the child rip
	 */
789
	if (forks) {
790 791 792 793 794 795 796 797
		union perf_event *event;

		event = malloc(sizeof(event->comm) + machine->id_hdr_size);
		if (event == NULL) {
			err = -ENOMEM;
			goto out_child;
		}

798 799 800 801 802 803
		/*
		 * Some H/W events are generated before COMM event
		 * which is emitted during exec(), so perf script
		 * cannot see a correct process name for those events.
		 * Synthesize COMM event to prevent it.
		 */
804
		perf_event__synthesize_comm(tool, event,
805 806 807
					    rec->evlist->workload.pid,
					    process_synthesized_event,
					    machine);
808
		free(event);
809

810
		perf_evlist__start_workload(rec->evlist);
811
	}
812

813 814 815 816 817
	if (opts->initial_delay) {
		usleep(opts->initial_delay * 1000);
		perf_evlist__enable(rec->evlist);
	}

818
	auxtrace_snapshot_enable();
819
	for (;;) {
820
		unsigned long long hits = rec->samples;
821

822
		if (record__mmap_read_all(rec) < 0) {
823
			auxtrace_snapshot_disable();
824
			err = -1;
825
			goto out_child;
826
		}
827

828 829 830 831 832 833 834 835 836 837 838
		if (auxtrace_record__snapshot_started) {
			auxtrace_record__snapshot_started = 0;
			if (!auxtrace_snapshot_err)
				record__read_auxtrace_snapshot(rec);
			if (auxtrace_snapshot_err) {
				pr_err("AUX area tracing snapshot failed\n");
				err = -1;
				goto out_child;
			}
		}

839
		if (hits == rec->samples) {
840
			if (done || draining)
841
				break;
842
			err = perf_evlist__poll(rec->evlist, -1);
843 844 845 846 847
			/*
			 * Propagate error, only if there's any. Ignore positive
			 * number of returned events and interrupt error.
			 */
			if (err > 0 || (err < 0 && errno == EINTR))
848
				err = 0;
849
			waking++;
850 851 852

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

855 856 857 858 859
		/*
		 * 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.
		 */
860
		if (done && !disabled && !target__none(&opts->target)) {
861
			auxtrace_snapshot_disable();
862
			perf_evlist__disable(rec->evlist);
863 864
			disabled = true;
		}
865
	}
866
	auxtrace_snapshot_disable();
867

868
	if (forks && workload_exec_errno) {
869
		char msg[STRERR_BUFSIZE];
870 871 872
		const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
		pr_err("Workload failed: %s\n", emsg);
		err = -1;
873
		goto out_child;
874 875
	}

876
	if (!quiet)
877
		fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
878

879 880 881
out_child:
	if (forks) {
		int exit_status;
882

883 884 885 886 887 888 889 890 891 892 893 894 895 896
		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;

897 898 899
	/* this will be recalculated during process_buildids() */
	rec->samples = 0;

900 901 902 903 904 905 906 907 908 909 910
	if (!err) {
		if (!rec->timestamp_filename) {
			record__finish_output(rec);
		} else {
			fd = record__switch_output(rec, true);
			if (fd < 0) {
				status = fd;
				goto out_delete_session;
			}
		}
	}
911

912 913
	if (!err && !quiet) {
		char samples[128];
914 915
		const char *postfix = rec->timestamp_filename ?
					".<timestamp>" : "";
916

917
		if (rec->samples && !rec->opts.full_auxtrace)
918 919 920 921 922
			scnprintf(samples, sizeof(samples),
				  " (%" PRIu64 " samples)", rec->samples);
		else
			samples[0] = '\0';

923
		fprintf(stderr,	"[ perf record: Captured and wrote %.3f MB %s%s%s ]\n",
924
			perf_data_file__size(file) / 1024.0 / 1024.0,
925
			file->path, postfix, samples);
926 927
	}

928 929
out_delete_session:
	perf_session__delete(session);
930
	return status;
931
}
932

933
static void callchain_debug(void)
J
Jiri Olsa 已提交
934
{
935
	static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
936

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

939
	if (callchain_param.record_mode == CALLCHAIN_DWARF)
J
Jiri Olsa 已提交
940
		pr_debug("callchain: stack dump size %d\n",
941
			 callchain_param.dump_size);
J
Jiri Olsa 已提交
942 943
}

944
int record_parse_callchain_opt(const struct option *opt,
J
Jiri Olsa 已提交
945 946 947 948
			       const char *arg,
			       int unset)
{
	int ret;
949
	struct record_opts *record = (struct record_opts *)opt->value;
J
Jiri Olsa 已提交
950

951
	record->callgraph_set = true;
952
	callchain_param.enabled = !unset;
953

J
Jiri Olsa 已提交
954 955
	/* --no-call-graph */
	if (unset) {
956
		callchain_param.record_mode = CALLCHAIN_NONE;
J
Jiri Olsa 已提交
957 958 959 960
		pr_debug("callchain: disabled\n");
		return 0;
	}

961
	ret = parse_callchain_record_opt(arg, &callchain_param);
962 963 964 965
	if (!ret) {
		/* Enable data address sampling for DWARF unwind. */
		if (callchain_param.record_mode == CALLCHAIN_DWARF)
			record->sample_address = true;
966
		callchain_debug();
967
	}
968 969 970 971

	return ret;
}

972
int record_callchain_opt(const struct option *opt,
J
Jiri Olsa 已提交
973 974 975
			 const char *arg __maybe_unused,
			 int unset __maybe_unused)
{
976 977 978
	struct record_opts *record = (struct record_opts *)opt->value;

	record->callgraph_set = true;
979
	callchain_param.enabled = true;
J
Jiri Olsa 已提交
980

981 982
	if (callchain_param.record_mode == CALLCHAIN_NONE)
		callchain_param.record_mode = CALLCHAIN_FP;
983

984
	callchain_debug();
J
Jiri Olsa 已提交
985 986 987
	return 0;
}

988 989
static int perf_record_config(const char *var, const char *value, void *cb)
{
990 991 992 993 994 995 996 997 998 999 1000 1001 1002
	struct record *rec = cb;

	if (!strcmp(var, "record.build-id")) {
		if (!strcmp(value, "cache"))
			rec->no_buildid_cache = false;
		else if (!strcmp(value, "no-cache"))
			rec->no_buildid_cache = true;
		else if (!strcmp(value, "skip"))
			rec->no_buildid = true;
		else
			return -1;
		return 0;
	}
1003
	if (!strcmp(var, "record.call-graph"))
1004
		var = "call-graph.record-mode"; /* fall-through */
1005 1006 1007 1008

	return perf_default_config(var, value, cb);
}

1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
struct clockid_map {
	const char *name;
	int clockid;
};

#define CLOCKID_MAP(n, c)	\
	{ .name = n, .clockid = (c), }

#define CLOCKID_END	{ .name = NULL, }


/*
 * Add the missing ones, we need to build on many distros...
 */
#ifndef CLOCK_MONOTONIC_RAW
#define CLOCK_MONOTONIC_RAW 4
#endif
#ifndef CLOCK_BOOTTIME
#define CLOCK_BOOTTIME 7
#endif
#ifndef CLOCK_TAI
#define CLOCK_TAI 11
#endif

static const struct clockid_map clockids[] = {
	/* available for all events, NMI safe */
	CLOCKID_MAP("monotonic", CLOCK_MONOTONIC),
	CLOCKID_MAP("monotonic_raw", CLOCK_MONOTONIC_RAW),

	/* available for some events */
	CLOCKID_MAP("realtime", CLOCK_REALTIME),
	CLOCKID_MAP("boottime", CLOCK_BOOTTIME),
	CLOCKID_MAP("tai", CLOCK_TAI),

	/* available for the lazy */
	CLOCKID_MAP("mono", CLOCK_MONOTONIC),
	CLOCKID_MAP("raw", CLOCK_MONOTONIC_RAW),
	CLOCKID_MAP("real", CLOCK_REALTIME),
	CLOCKID_MAP("boot", CLOCK_BOOTTIME),

	CLOCKID_END,
};

static int parse_clockid(const struct option *opt, const char *str, int unset)
{
	struct record_opts *opts = (struct record_opts *)opt->value;
	const struct clockid_map *cm;
	const char *ostr = str;

	if (unset) {
		opts->use_clockid = 0;
		return 0;
	}

	/* no arg passed */
	if (!str)
		return 0;

	/* no setting it twice */
	if (opts->use_clockid)
		return -1;

	opts->use_clockid = true;

	/* if its a number, we're done */
	if (sscanf(str, "%d", &opts->clockid) == 1)
		return 0;

	/* allow a "CLOCK_" prefix to the name */
	if (!strncasecmp(str, "CLOCK_", 6))
		str += 6;

	for (cm = clockids; cm->name; cm++) {
		if (!strcasecmp(str, cm->name)) {
			opts->clockid = cm->clockid;
			return 0;
		}
	}

	opts->use_clockid = false;
	ui__warning("unknown clockid %s, check man page\n", ostr);
	return -1;
}

1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
static int record__parse_mmap_pages(const struct option *opt,
				    const char *str,
				    int unset __maybe_unused)
{
	struct record_opts *opts = opt->value;
	char *s, *p;
	unsigned int mmap_pages;
	int ret;

	if (!str)
		return -EINVAL;

	s = strdup(str);
	if (!s)
		return -ENOMEM;

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

	if (*s) {
		ret = __perf_evlist__parse_mmap_pages(&mmap_pages, s);
		if (ret)
			goto out_free;
		opts->mmap_pages = mmap_pages;
	}

	if (!p) {
		ret = 0;
		goto out_free;
	}

	ret = __perf_evlist__parse_mmap_pages(&mmap_pages, p + 1);
	if (ret)
		goto out_free;

	opts->auxtrace_mmap_pages = mmap_pages;

out_free:
	free(s);
	return ret;
}

1136
static const char * const __record_usage[] = {
1137 1138
	"perf record [<options>] [<command>]",
	"perf record [<options>] -- <command> [<options>]",
1139 1140
	NULL
};
1141
const char * const *record_usage = __record_usage;
1142

1143
/*
1144 1145
 * 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
1146 1147 1148 1149 1150 1151 1152
 * 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.
 */
1153
static struct record record = {
1154
	.opts = {
1155
		.sample_time	     = true,
1156 1157 1158
		.mmap_pages	     = UINT_MAX,
		.user_freq	     = UINT_MAX,
		.user_interval	     = ULLONG_MAX,
1159
		.freq		     = 4000,
N
Namhyung Kim 已提交
1160 1161
		.target		     = {
			.uses_mmap   = true,
1162
			.default_per_cpu = true,
N
Namhyung Kim 已提交
1163
		},
1164
		.proc_map_timeout     = 500,
1165
	},
1166 1167 1168
	.tool = {
		.sample		= process_sample_event,
		.fork		= perf_event__process_fork,
1169
		.exit		= perf_event__process_exit,
1170 1171 1172
		.comm		= perf_event__process_comm,
		.mmap		= perf_event__process_mmap,
		.mmap2		= perf_event__process_mmap2,
1173
		.ordered_events	= true,
1174
	},
1175
};
1176

1177 1178
const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
	"\n\t\t\t\tDefault: fp";
1179

1180 1181 1182
/*
 * 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
1183
 * from builtin-record.c, i.e. use record_opts,
1184 1185 1186
 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
 * using pipes, etc.
 */
1187
struct option __record_options[] = {
1188
	OPT_CALLBACK('e', "event", &record.evlist, "event",
1189
		     "event selector. use 'perf list' to list available events",
1190
		     parse_events_option),
1191
	OPT_CALLBACK(0, "filter", &record.evlist, "filter",
L
Li Zefan 已提交
1192
		     "event filter", parse_filter),
1193 1194 1195
	OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
			   NULL, "don't record events from perf itself",
			   exclude_perf),
1196
	OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
1197
		    "record events on existing process id"),
1198
	OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
1199
		    "record events on existing thread id"),
1200
	OPT_INTEGER('r', "realtime", &record.realtime_prio,
1201
		    "collect data with this RT SCHED_FIFO priority"),
1202
	OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
1203
		    "collect data without buffering"),
1204
	OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
1205
		    "collect raw sample records from all opened counters"),
1206
	OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
1207
			    "system-wide collection from all CPUs"),
1208
	OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
1209
		    "list of cpus to monitor"),
1210
	OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
1211
	OPT_STRING('o', "output", &record.file.path, "file",
I
Ingo Molnar 已提交
1212
		    "output file name"),
1213 1214 1215
	OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
			&record.opts.no_inherit_set,
			"child tasks do not inherit counters"),
1216
	OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
1217 1218 1219
	OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
		     "number of mmap data pages and AUX area tracing mmap pages",
		     record__parse_mmap_pages),
1220
	OPT_BOOLEAN(0, "group", &record.opts.group,
1221
		    "put the counters into a counter group"),
J
Jiri Olsa 已提交
1222 1223 1224 1225
	OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
			   NULL, "enables call-graph recording" ,
			   &record_callchain_opt),
	OPT_CALLBACK(0, "call-graph", &record.opts,
1226
		     "record_mode[,record_size]", record_callchain_help,
J
Jiri Olsa 已提交
1227
		     &record_parse_callchain_opt),
1228
	OPT_INCR('v', "verbose", &verbose,
1229
		    "be more verbose (show counter open errors, etc)"),
1230
	OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
1231
	OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
1232
		    "per thread counts"),
1233
	OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
1234 1235 1236
	OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
			&record.opts.sample_time_set,
			"Record the sample timestamps"),
1237
	OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
1238
	OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
1239
		    "don't sample"),
1240 1241 1242 1243 1244 1245
	OPT_BOOLEAN_SET('N', "no-buildid-cache", &record.no_buildid_cache,
			&record.no_buildid_cache_set,
			"do not update the buildid cache"),
	OPT_BOOLEAN_SET('B', "no-buildid", &record.no_buildid,
			&record.no_buildid_set,
			"do not collect buildids in perf.data"),
1246
	OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
S
Stephane Eranian 已提交
1247 1248
		     "monitor event in cgroup name only",
		     parse_cgroups),
1249
	OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
1250
		  "ms to wait before starting measurement after program start"),
1251 1252
	OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
		   "user to profile"),
1253 1254 1255 1256 1257 1258 1259

	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",
1260
		     parse_branch_stack),
1261 1262
	OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
		    "sample by weight (on special events only)"),
1263 1264
	OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
		    "sample transaction flags (special events only)"),
1265 1266
	OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
		    "use per-thread mmaps"),
1267 1268 1269
	OPT_CALLBACK_OPTARG('I', "intr-regs", &record.opts.sample_intr_regs, NULL, "any register",
		    "sample selected machine registers on interrupt,"
		    " use -I ? to list register names", parse_regs),
1270 1271
	OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
		    "Record running/enabled time of read (:S) events"),
1272 1273 1274
	OPT_CALLBACK('k', "clockid", &record.opts,
	"clockid", "clockid to use for events, see clock_gettime()",
	parse_clockid),
1275 1276
	OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
			  "opts", "AUX area tracing Snapshot Mode", ""),
1277 1278
	OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
			"per thread proc mmap processing timeout in ms"),
1279 1280
	OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
		    "Record context switch events"),
1281 1282 1283 1284 1285 1286
	OPT_BOOLEAN_FLAG(0, "all-kernel", &record.opts.all_kernel,
			 "Configure all used events to run in kernel space.",
			 PARSE_OPT_EXCLUSIVE),
	OPT_BOOLEAN_FLAG(0, "all-user", &record.opts.all_user,
			 "Configure all used events to run in user space.",
			 PARSE_OPT_EXCLUSIVE),
1287 1288 1289 1290
	OPT_STRING(0, "clang-path", &llvm_param.clang_path, "clang path",
		   "clang binary to use for compiling BPF scriptlets"),
	OPT_STRING(0, "clang-opt", &llvm_param.clang_opt, "clang options",
		   "options passed to clang when compiling BPF scriptlets"),
1291 1292
	OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
1293 1294
	OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
		    "Record build-id of all DSOs regardless of hits"),
1295 1296
	OPT_BOOLEAN(0, "timestamp-filename", &record.timestamp_filename,
		    "append timestamp to output filename"),
1297 1298 1299
	OPT_END()
};

1300 1301
struct option *record_options = __record_options;

1302
int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
1303
{
1304
	int err;
1305
	struct record *rec = &record;
1306
	char errbuf[BUFSIZ];
1307

1308 1309 1310 1311 1312
#ifndef HAVE_LIBBPF_SUPPORT
# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, "NO_LIBBPF=1", c)
	set_nobuild('\0', "clang-path", true);
	set_nobuild('\0', "clang-opt", true);
# undef set_nobuild
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
#endif

#ifndef HAVE_BPF_PROLOGUE
# if !defined (HAVE_DWARF_SUPPORT)
#  define REASON  "NO_DWARF=1"
# elif !defined (HAVE_LIBBPF_SUPPORT)
#  define REASON  "NO_LIBBPF=1"
# else
#  define REASON  "this architecture doesn't support BPF prologue"
# endif
# define set_nobuild(s, l, c) set_option_nobuild(record_options, s, l, REASON, c)
	set_nobuild('\0', "vmlinux", true);
# undef set_nobuild
# undef REASON
1327 1328
#endif

1329 1330
	rec->evlist = perf_evlist__new();
	if (rec->evlist == NULL)
1331 1332
		return -ENOMEM;

1333 1334
	perf_config(perf_record_config, rec);

1335
	argc = parse_options(argc, argv, record_options, record_usage,
1336
			    PARSE_OPT_STOP_AT_NON_OPTION);
1337
	if (!argc && target__none(&rec->opts.target))
1338
		usage_with_options(record_usage, record_options);
1339

1340
	if (nr_cgroups && !rec->opts.target.system_wide) {
1341 1342 1343
		usage_with_options_msg(record_usage, record_options,
			"cgroup monitoring only available in system-wide mode");

S
Stephane Eranian 已提交
1344
	}
1345 1346
	if (rec->opts.record_switch_events &&
	    !perf_can_record_switch_events()) {
1347 1348 1349
		ui__error("kernel does not support recording context switch events\n");
		parse_options_usage(record_usage, record_options, "switch-events", 0);
		return -EINVAL;
1350
	}
S
Stephane Eranian 已提交
1351

1352 1353 1354 1355 1356 1357
	if (!rec->itr) {
		rec->itr = auxtrace_record__init(rec->evlist, &err);
		if (err)
			return err;
	}

1358 1359 1360 1361 1362
	err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
					      rec->opts.auxtrace_snapshot_opts);
	if (err)
		return err;

1363 1364 1365 1366 1367 1368 1369 1370
	err = bpf__setup_stdout(rec->evlist);
	if (err) {
		bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
		pr_err("ERROR: Setup BPF stdout failed: %s\n",
			 errbuf);
		return err;
	}

1371 1372
	err = -ENOMEM;

1373
	symbol__init(NULL);
1374

1375
	if (symbol_conf.kptr_restrict)
1376 1377 1378 1379 1380 1381 1382 1383
		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");
1384

1385
	if (rec->no_buildid_cache || rec->no_buildid)
1386
		disable_buildid_cache();
1387

1388 1389
	if (rec->evlist->nr_entries == 0 &&
	    perf_evlist__add_default(rec->evlist) < 0) {
1390 1391
		pr_err("Not enough memory for event selector list\n");
		goto out_symbol_exit;
1392
	}
1393

1394 1395 1396
	if (rec->opts.target.tid && !rec->opts.no_inherit_set)
		rec->opts.no_inherit = true;

1397
	err = target__validate(&rec->opts.target);
1398
	if (err) {
1399
		target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1400 1401 1402
		ui__warning("%s", errbuf);
	}

1403
	err = target__parse_uid(&rec->opts.target);
1404 1405
	if (err) {
		int saved_errno = errno;
1406

1407
		target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1408
		ui__error("%s", errbuf);
1409 1410

		err = -saved_errno;
1411
		goto out_symbol_exit;
1412
	}
1413

1414
	err = -ENOMEM;
1415
	if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1416
		usage_with_options(record_usage, record_options);
1417

1418 1419 1420 1421
	err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
	if (err)
		goto out_symbol_exit;

1422 1423 1424 1425 1426 1427 1428 1429
	/*
	 * We take all buildids when the file contains
	 * AUX area tracing data because we do not decode the
	 * trace because it would take too long.
	 */
	if (rec->opts.full_auxtrace)
		rec->buildid_all = true;

1430
	if (record_opts__config(&rec->opts)) {
1431
		err = -EINVAL;
1432
		goto out_symbol_exit;
1433 1434
	}

1435
	err = __cmd_record(&record, argc, argv);
1436
out_symbol_exit:
1437
	perf_evlist__delete(rec->evlist);
1438
	symbol__exit();
1439
	auxtrace_record__free(rec->itr);
1440
	return err;
1441
}
1442 1443 1444

static void snapshot_sig_handler(int sig __maybe_unused)
{
1445
	if (!auxtrace_snapshot_is_enabled())
1446
		return;
1447
	auxtrace_snapshot_disable();
1448 1449 1450
	auxtrace_snapshot_err = auxtrace_record__snapshot_start(record.itr);
	auxtrace_record__snapshot_started = 1;
}