builtin-record.c 34.6 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/parse-branch-options.h"
33
#include "util/parse-regs-options.h"
34
#include "util/llvm-utils.h"
35
#include "util/bpf-loader.h"
36
#include "asm/bug.h"
37

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

42

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

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

68
	rec->bytes_written += size;
69
	return 0;
70 71
}

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

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

91
	if (old == head)
92
		return 0;
93

94
	rec->samples++;
95 96 97 98 99 100 101

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

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

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

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

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

124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
static volatile int done;
static volatile int signr = -1;
static volatile int child_finished;
static volatile int auxtrace_snapshot_enabled;
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);
}

150 151
#ifdef HAVE_AUXTRACE_SUPPORT

152 153 154 155 156
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);
157
	struct perf_data_file *file = &rec->file;
158 159 160
	size_t padding;
	u8 pad[8] = {0};

161 162 163 164 165 166 167 168 169 170 171 172 173 174
	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;
	}

175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
	/* 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;
}

205 206 207 208 209 210 211 212 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 243 244 245 246 247 248 249 250 251 252 253 254
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)
			auxtrace_snapshot_enabled = 1;
	}
}

255 256 257 258 259 260 261 262 263
#else

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

264 265
static inline
void record__read_auxtrace_snapshot(struct record *rec __maybe_unused)
266
{
267 268
}

269 270
static inline
int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
271
{
272
	return 0;
273 274
}

275 276
#endif

277
static int record__open(struct record *rec)
278
{
279
	char msg[512];
280
	struct perf_evsel *pos;
281 282
	struct perf_evlist *evlist = rec->evlist;
	struct perf_session *session = rec->session;
283
	struct record_opts *opts = &rec->opts;
284
	int rc = 0;
285

286
	perf_evlist__config(evlist, opts);
287

288
	evlist__for_each(evlist, pos) {
289
try_again:
290
		if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
291
			if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
292
				if (verbose)
293
					ui__warning("%s\n", msg);
294 295
				goto try_again;
			}
296

297 298 299 300
			rc = -errno;
			perf_evsel__open_strerror(pos, &opts->target,
						  errno, msg, sizeof(msg));
			ui__error("%s\n", msg);
301
			goto out;
L
Li Zefan 已提交
302 303
		}
	}
304

305 306 307
	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,
308
			strerror_r(errno, msg, sizeof(msg)));
309 310
		rc = -1;
		goto out;
311 312
	}

313
	if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
314 315
				 opts->auxtrace_mmap_pages,
				 opts->auxtrace_snapshot_mode) < 0) {
316 317 318 319 320
		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"
321 322
			       "(current value: %u,%u)\n",
			       opts->mmap_pages, opts->auxtrace_mmap_pages);
323 324
			rc = -errno;
		} else {
325 326
			pr_err("failed to mmap with %d (%s)\n", errno,
				strerror_r(errno, msg, sizeof(msg)));
327 328 329 330
			if (errno)
				rc = -errno;
			else
				rc = -EINVAL;
331 332
		}
		goto out;
333
	}
334

335
	session->evlist = evlist;
336
	perf_session__set_id_hdr_size(session);
337 338
out:
	return rc;
339 340
}

341 342 343 344 345 346 347 348 349 350 351 352 353
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);
}

354
static int process_buildids(struct record *rec)
355
{
356 357
	struct perf_data_file *file  = &rec->file;
	struct perf_session *session = rec->session;
358

359
	if (file->size == 0)
360 361
		return 0;

362 363 364 365 366 367 368 369 370 371 372
	/*
	 * 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;

373 374 375 376 377 378 379
	/*
	 * 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;

380
	return perf_session__process_events(session);
381 382
}

383
static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
384 385
{
	int err;
386
	struct perf_tool *tool = data;
387 388 389 390 391 392 393 394
	/*
	 *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.
	 */
395
	err = perf_event__synthesize_modules(tool, process_synthesized_event,
396
					     machine);
397 398
	if (err < 0)
		pr_err("Couldn't record guest kernel [%d]'s reference"
399
		       " relocation symbol.\n", machine->pid);
400 401 402 403 404

	/*
	 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
	 * have no _text sometimes.
	 */
405
	err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
406
						 machine);
407 408
	if (err < 0)
		pr_err("Couldn't record guest kernel [%d]'s reference"
409
		       " relocation symbol.\n", machine->pid);
410 411
}

412 413 414 415 416
static struct perf_event_header finished_round_event = {
	.size = sizeof(struct perf_event_header),
	.type = PERF_RECORD_FINISHED_ROUND,
};

417
static int record__mmap_read_all(struct record *rec)
418
{
419
	u64 bytes_written = rec->bytes_written;
420
	int i;
421
	int rc = 0;
422

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

426
		if (rec->evlist->mmap[i].base) {
427
			if (record__mmap_read(rec, i) != 0) {
428 429 430 431
				rc = -1;
				goto out;
			}
		}
432

433
		if (mm->base && !rec->opts.auxtrace_snapshot_mode &&
434 435 436 437
		    record__auxtrace_mmap_read(rec, mm) != 0) {
			rc = -1;
			goto out;
		}
438 439
	}

440 441 442 443 444 445
	/*
	 * 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));
446 447 448

out:
	return rc;
449 450
}

451
static void record__init_features(struct record *rec)
452 453 454 455 456 457 458 459 460 461
{
	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);

462
	if (!have_tracepoints(&rec->evlist->entries))
463 464 465 466
		perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);

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

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

	perf_header__clear_feat(&session->header, HEADER_STAT);
472 473
}

474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
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;
}

497 498 499 500 501 502 503
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.
 */
504 505
static void workload_exec_failed_signal(int signo __maybe_unused,
					siginfo_t *info,
506 507 508 509 510 511 512
					void *ucontext __maybe_unused)
{
	workload_exec_errno = info->si_value.sival_int;
	done = 1;
	child_finished = 1;
}

513 514
static void snapshot_sig_handler(int sig);

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 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 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
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;
		}
	}

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

583
static int __cmd_record(struct record *rec, int argc, const char **argv)
584
{
585
	int err;
586
	int status = 0;
587
	unsigned long waking = 0;
588
	const bool forks = argc > 0;
589
	struct machine *machine;
590
	struct perf_tool *tool = &rec->tool;
591
	struct record_opts *opts = &rec->opts;
592
	struct perf_data_file *file = &rec->file;
593
	struct perf_session *session;
594
	bool disabled = false, draining = false;
595
	int fd;
596

597
	rec->progname = argv[0];
598

599
	atexit(record__sig_exit);
600 601
	signal(SIGCHLD, sig_handler);
	signal(SIGINT, sig_handler);
602
	signal(SIGTERM, sig_handler);
603 604 605 606
	if (rec->opts.auxtrace_snapshot_mode)
		signal(SIGUSR2, snapshot_sig_handler);
	else
		signal(SIGUSR2, SIG_IGN);
607

608
	session = perf_session__new(file, false, tool);
609
	if (session == NULL) {
A
Adrien BAK 已提交
610
		pr_err("Perf session creation failed.\n");
611 612 613
		return -1;
	}

614
	fd = perf_data_file__fd(file);
615 616
	rec->session = session;

617
	record__init_features(rec);
618

619
	if (forks) {
620
		err = perf_evlist__prepare_workload(rec->evlist, &opts->target,
621
						    argv, file->is_pipe,
622
						    workload_exec_failed_signal);
623 624
		if (err < 0) {
			pr_err("Couldn't run the workload!\n");
625
			status = err;
626
			goto out_delete_session;
627 628 629
		}
	}

630
	if (record__open(rec) != 0) {
631
		err = -1;
632
		goto out_child;
633
	}
634

635 636 637 638 639 640 641 642 643 644
	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;
	}

645 646 647 648 649 650 651 652 653
	/*
	 * 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;
	}

654
	if (!rec->evlist->nr_groups)
655 656
		perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);

657
	if (file->is_pipe) {
658
		err = perf_header__write_pipe(fd);
659
		if (err < 0)
660
			goto out_child;
661
	} else {
662
		err = perf_session__write_header(session, rec->evlist, fd, false);
663
		if (err < 0)
664
			goto out_child;
665 666
	}

667
	if (!rec->no_buildid
668
	    && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
669
		pr_err("Couldn't generate buildids. "
670
		       "Use --no-buildid to profile anyway.\n");
671
		err = -1;
672
		goto out_child;
673 674
	}

675
	machine = &session->machines.host;
676

677 678
	err = record__synthesize(rec);
	if (err < 0)
679
		goto out_child;
680

681
	if (rec->realtime_prio) {
682 683
		struct sched_param param;

684
		param.sched_priority = rec->realtime_prio;
685
		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
686
			pr_err("Could not set realtime priority.\n");
687
			err = -1;
688
			goto out_child;
689 690 691
		}
	}

692 693 694 695 696
	/*
	 * 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.
	 */
697
	if (!target__none(&opts->target) && !opts->initial_delay)
698
		perf_evlist__enable(rec->evlist);
699

700 701 702
	/*
	 * Let the child rip
	 */
703
	if (forks) {
704 705 706 707 708 709 710 711
		union perf_event *event;

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

712 713 714 715 716 717
		/*
		 * 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.
		 */
718
		perf_event__synthesize_comm(tool, event,
719 720 721
					    rec->evlist->workload.pid,
					    process_synthesized_event,
					    machine);
722
		free(event);
723

724
		perf_evlist__start_workload(rec->evlist);
725
	}
726

727 728 729 730 731
	if (opts->initial_delay) {
		usleep(opts->initial_delay * 1000);
		perf_evlist__enable(rec->evlist);
	}

732
	auxtrace_snapshot_enabled = 1;
733
	for (;;) {
734
		unsigned long long hits = rec->samples;
735

736
		if (record__mmap_read_all(rec) < 0) {
737
			auxtrace_snapshot_enabled = 0;
738
			err = -1;
739
			goto out_child;
740
		}
741

742 743 744 745 746 747 748 749 750 751 752
		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;
			}
		}

753
		if (hits == rec->samples) {
754
			if (done || draining)
755
				break;
756
			err = perf_evlist__poll(rec->evlist, -1);
757 758 759 760 761
			/*
			 * Propagate error, only if there's any. Ignore positive
			 * number of returned events and interrupt error.
			 */
			if (err > 0 || (err < 0 && errno == EINTR))
762
				err = 0;
763
			waking++;
764 765 766

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

769 770 771 772 773
		/*
		 * 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.
		 */
774
		if (done && !disabled && !target__none(&opts->target)) {
775
			auxtrace_snapshot_enabled = 0;
776
			perf_evlist__disable(rec->evlist);
777 778
			disabled = true;
		}
779
	}
780
	auxtrace_snapshot_enabled = 0;
781

782
	if (forks && workload_exec_errno) {
783
		char msg[STRERR_BUFSIZE];
784 785 786
		const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
		pr_err("Workload failed: %s\n", emsg);
		err = -1;
787
		goto out_child;
788 789
	}

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

793 794 795
out_child:
	if (forks) {
		int exit_status;
796

797 798 799 800 801 802 803 804 805 806 807 808 809 810
		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;

811 812 813
	/* this will be recalculated during process_buildids() */
	rec->samples = 0;

814 815
	if (!err)
		record__finish_output(rec);
816

817 818 819
	if (!err && !quiet) {
		char samples[128];

820
		if (rec->samples && !rec->opts.full_auxtrace)
821 822 823 824 825 826 827 828 829 830
			scnprintf(samples, sizeof(samples),
				  " (%" PRIu64 " samples)", rec->samples);
		else
			samples[0] = '\0';

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

831 832
out_delete_session:
	perf_session__delete(session);
833
	return status;
834
}
835

836
static void callchain_debug(void)
J
Jiri Olsa 已提交
837
{
838
	static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
839

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

842
	if (callchain_param.record_mode == CALLCHAIN_DWARF)
J
Jiri Olsa 已提交
843
		pr_debug("callchain: stack dump size %d\n",
844
			 callchain_param.dump_size);
J
Jiri Olsa 已提交
845 846
}

847
int record_parse_callchain_opt(const struct option *opt,
J
Jiri Olsa 已提交
848 849 850 851
			       const char *arg,
			       int unset)
{
	int ret;
852
	struct record_opts *record = (struct record_opts *)opt->value;
J
Jiri Olsa 已提交
853

854
	record->callgraph_set = true;
855
	callchain_param.enabled = !unset;
856

J
Jiri Olsa 已提交
857 858
	/* --no-call-graph */
	if (unset) {
859
		callchain_param.record_mode = CALLCHAIN_NONE;
J
Jiri Olsa 已提交
860 861 862 863
		pr_debug("callchain: disabled\n");
		return 0;
	}

864
	ret = parse_callchain_record_opt(arg, &callchain_param);
865 866 867 868
	if (!ret) {
		/* Enable data address sampling for DWARF unwind. */
		if (callchain_param.record_mode == CALLCHAIN_DWARF)
			record->sample_address = true;
869
		callchain_debug();
870
	}
871 872 873 874

	return ret;
}

875
int record_callchain_opt(const struct option *opt,
J
Jiri Olsa 已提交
876 877 878
			 const char *arg __maybe_unused,
			 int unset __maybe_unused)
{
879 880 881
	struct record_opts *record = (struct record_opts *)opt->value;

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

884 885
	if (callchain_param.record_mode == CALLCHAIN_NONE)
		callchain_param.record_mode = CALLCHAIN_FP;
886

887
	callchain_debug();
J
Jiri Olsa 已提交
888 889 890
	return 0;
}

891 892
static int perf_record_config(const char *var, const char *value, void *cb)
{
893 894 895 896 897 898 899 900 901 902 903 904 905
	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;
	}
906
	if (!strcmp(var, "record.call-graph"))
907
		var = "call-graph.record-mode"; /* fall-through */
908 909 910 911

	return perf_default_config(var, value, cb);
}

912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995
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;
}

996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 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
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;
}

1039
static const char * const __record_usage[] = {
1040 1041
	"perf record [<options>] [<command>]",
	"perf record [<options>] -- <command> [<options>]",
1042 1043
	NULL
};
1044
const char * const *record_usage = __record_usage;
1045

1046
/*
1047 1048
 * 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
1049 1050 1051 1052 1053 1054 1055
 * 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.
 */
1056
static struct record record = {
1057
	.opts = {
1058
		.sample_time	     = true,
1059 1060 1061
		.mmap_pages	     = UINT_MAX,
		.user_freq	     = UINT_MAX,
		.user_interval	     = ULLONG_MAX,
1062
		.freq		     = 4000,
N
Namhyung Kim 已提交
1063 1064
		.target		     = {
			.uses_mmap   = true,
1065
			.default_per_cpu = true,
N
Namhyung Kim 已提交
1066
		},
1067
		.proc_map_timeout     = 500,
1068
	},
1069 1070 1071
	.tool = {
		.sample		= process_sample_event,
		.fork		= perf_event__process_fork,
1072
		.exit		= perf_event__process_exit,
1073 1074 1075
		.comm		= perf_event__process_comm,
		.mmap		= perf_event__process_mmap,
		.mmap2		= perf_event__process_mmap2,
1076
		.ordered_events	= true,
1077
	},
1078
};
1079

1080 1081
const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
	"\n\t\t\t\tDefault: fp";
1082

1083 1084 1085
/*
 * 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
1086
 * from builtin-record.c, i.e. use record_opts,
1087 1088 1089
 * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
 * using pipes, etc.
 */
1090
struct option __record_options[] = {
1091
	OPT_CALLBACK('e', "event", &record.evlist, "event",
1092
		     "event selector. use 'perf list' to list available events",
1093
		     parse_events_option),
1094
	OPT_CALLBACK(0, "filter", &record.evlist, "filter",
L
Li Zefan 已提交
1095
		     "event filter", parse_filter),
1096 1097 1098
	OPT_CALLBACK_NOOPT(0, "exclude-perf", &record.evlist,
			   NULL, "don't record events from perf itself",
			   exclude_perf),
1099
	OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
1100
		    "record events on existing process id"),
1101
	OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
1102
		    "record events on existing thread id"),
1103
	OPT_INTEGER('r', "realtime", &record.realtime_prio,
1104
		    "collect data with this RT SCHED_FIFO priority"),
1105
	OPT_BOOLEAN(0, "no-buffering", &record.opts.no_buffering,
1106
		    "collect data without buffering"),
1107
	OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
1108
		    "collect raw sample records from all opened counters"),
1109
	OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
1110
			    "system-wide collection from all CPUs"),
1111
	OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
1112
		    "list of cpus to monitor"),
1113
	OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
1114
	OPT_STRING('o', "output", &record.file.path, "file",
I
Ingo Molnar 已提交
1115
		    "output file name"),
1116 1117 1118
	OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
			&record.opts.no_inherit_set,
			"child tasks do not inherit counters"),
1119
	OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
1120 1121 1122
	OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
		     "number of mmap data pages and AUX area tracing mmap pages",
		     record__parse_mmap_pages),
1123
	OPT_BOOLEAN(0, "group", &record.opts.group,
1124
		    "put the counters into a counter group"),
J
Jiri Olsa 已提交
1125 1126 1127 1128
	OPT_CALLBACK_NOOPT('g', NULL, &record.opts,
			   NULL, "enables call-graph recording" ,
			   &record_callchain_opt),
	OPT_CALLBACK(0, "call-graph", &record.opts,
1129
		     "record_mode[,record_size]", record_callchain_help,
J
Jiri Olsa 已提交
1130
		     &record_parse_callchain_opt),
1131
	OPT_INCR('v', "verbose", &verbose,
1132
		    "be more verbose (show counter open errors, etc)"),
1133
	OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
1134
	OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
1135
		    "per thread counts"),
1136
	OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
1137 1138 1139
	OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
			&record.opts.sample_time_set,
			"Record the sample timestamps"),
1140
	OPT_BOOLEAN('P', "period", &record.opts.period, "Record the sample period"),
1141
	OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
1142
		    "don't sample"),
1143 1144 1145 1146 1147 1148
	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"),
1149
	OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
S
Stephane Eranian 已提交
1150 1151
		     "monitor event in cgroup name only",
		     parse_cgroups),
1152
	OPT_UINTEGER('D', "delay", &record.opts.initial_delay,
1153
		  "ms to wait before starting measurement after program start"),
1154 1155
	OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
		   "user to profile"),
1156 1157 1158 1159 1160 1161 1162

	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",
1163
		     parse_branch_stack),
1164 1165
	OPT_BOOLEAN('W', "weight", &record.opts.sample_weight,
		    "sample by weight (on special events only)"),
1166 1167
	OPT_BOOLEAN(0, "transaction", &record.opts.sample_transaction,
		    "sample transaction flags (special events only)"),
1168 1169
	OPT_BOOLEAN(0, "per-thread", &record.opts.target.per_thread,
		    "use per-thread mmaps"),
1170 1171 1172
	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),
1173 1174
	OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
		    "Record running/enabled time of read (:S) events"),
1175 1176 1177
	OPT_CALLBACK('k', "clockid", &record.opts,
	"clockid", "clockid to use for events, see clock_gettime()",
	parse_clockid),
1178 1179
	OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
			  "opts", "AUX area tracing Snapshot Mode", ""),
1180 1181
	OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout,
			"per thread proc mmap processing timeout in ms"),
1182 1183
	OPT_BOOLEAN(0, "switch-events", &record.opts.record_switch_events,
		    "Record context switch events"),
1184 1185 1186 1187 1188 1189
	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),
1190 1191 1192 1193
	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"),
1194 1195
	OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
1196 1197
	OPT_BOOLEAN(0, "buildid-all", &record.buildid_all,
		    "Record build-id of all DSOs regardless of hits"),
1198 1199 1200
	OPT_END()
};

1201 1202
struct option *record_options = __record_options;

1203
int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
1204
{
1205
	int err;
1206
	struct record *rec = &record;
1207
	char errbuf[BUFSIZ];
1208

1209 1210 1211 1212 1213
#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
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
#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
1228 1229
#endif

1230 1231
	rec->evlist = perf_evlist__new();
	if (rec->evlist == NULL)
1232 1233
		return -ENOMEM;

1234 1235
	perf_config(perf_record_config, rec);

1236
	argc = parse_options(argc, argv, record_options, record_usage,
1237
			    PARSE_OPT_STOP_AT_NON_OPTION);
1238
	if (!argc && target__none(&rec->opts.target))
1239
		usage_with_options(record_usage, record_options);
1240

1241
	if (nr_cgroups && !rec->opts.target.system_wide) {
1242 1243 1244
		usage_with_options_msg(record_usage, record_options,
			"cgroup monitoring only available in system-wide mode");

S
Stephane Eranian 已提交
1245
	}
1246 1247
	if (rec->opts.record_switch_events &&
	    !perf_can_record_switch_events()) {
1248 1249 1250
		ui__error("kernel does not support recording context switch events\n");
		parse_options_usage(record_usage, record_options, "switch-events", 0);
		return -EINVAL;
1251
	}
S
Stephane Eranian 已提交
1252

1253 1254 1255 1256 1257 1258
	if (!rec->itr) {
		rec->itr = auxtrace_record__init(rec->evlist, &err);
		if (err)
			return err;
	}

1259 1260 1261 1262 1263
	err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
					      rec->opts.auxtrace_snapshot_opts);
	if (err)
		return err;

1264 1265
	err = -ENOMEM;

1266
	symbol__init(NULL);
1267

1268
	if (symbol_conf.kptr_restrict)
1269 1270 1271 1272 1273 1274 1275 1276
		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");
1277

1278
	if (rec->no_buildid_cache || rec->no_buildid)
1279
		disable_buildid_cache();
1280

1281 1282
	if (rec->evlist->nr_entries == 0 &&
	    perf_evlist__add_default(rec->evlist) < 0) {
1283 1284
		pr_err("Not enough memory for event selector list\n");
		goto out_symbol_exit;
1285
	}
1286

1287 1288 1289
	if (rec->opts.target.tid && !rec->opts.no_inherit_set)
		rec->opts.no_inherit = true;

1290
	err = target__validate(&rec->opts.target);
1291
	if (err) {
1292
		target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1293 1294 1295
		ui__warning("%s", errbuf);
	}

1296
	err = target__parse_uid(&rec->opts.target);
1297 1298
	if (err) {
		int saved_errno = errno;
1299

1300
		target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
1301
		ui__error("%s", errbuf);
1302 1303

		err = -saved_errno;
1304
		goto out_symbol_exit;
1305
	}
1306

1307
	err = -ENOMEM;
1308
	if (perf_evlist__create_maps(rec->evlist, &rec->opts.target) < 0)
1309
		usage_with_options(record_usage, record_options);
1310

1311 1312 1313 1314
	err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
	if (err)
		goto out_symbol_exit;

1315 1316 1317 1318 1319 1320 1321 1322
	/*
	 * 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;

1323
	if (record_opts__config(&rec->opts)) {
1324
		err = -EINVAL;
1325
		goto out_symbol_exit;
1326 1327
	}

1328
	err = __cmd_record(&record, argc, argv);
1329
out_symbol_exit:
1330
	perf_evlist__delete(rec->evlist);
1331
	symbol__exit();
1332
	auxtrace_record__free(rec->itr);
1333
	return err;
1334
}
1335 1336 1337 1338 1339 1340 1341 1342 1343

static void snapshot_sig_handler(int sig __maybe_unused)
{
	if (!auxtrace_snapshot_enabled)
		return;
	auxtrace_snapshot_enabled = 0;
	auxtrace_snapshot_err = auxtrace_record__snapshot_start(record.itr);
	auxtrace_record__snapshot_started = 1;
}