builtin-stat.c 71.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2
/*
3 4 5 6 7 8
 * builtin-stat.c
 *
 * Builtin stat command: Give a precise performance counters summary
 * overview about any workload, CPU or specific PID.
 *
 * Sample output:
9

10
   $ perf stat ./hackbench 10
11

12
  Time: 0.118
13

14
  Performance counter stats for './hackbench 10':
15

16 17 18 19 20 21 22 23 24 25 26 27 28
       1708.761321 task-clock                #   11.037 CPUs utilized
            41,190 context-switches          #    0.024 M/sec
             6,735 CPU-migrations            #    0.004 M/sec
            17,318 page-faults               #    0.010 M/sec
     5,205,202,243 cycles                    #    3.046 GHz
     3,856,436,920 stalled-cycles-frontend   #   74.09% frontend cycles idle
     1,600,790,871 stalled-cycles-backend    #   30.75% backend  cycles idle
     2,603,501,247 instructions              #    0.50  insns per cycle
                                             #    1.48  stalled cycles per insn
       484,357,498 branches                  #  283.455 M/sec
         6,388,934 branch-misses             #    1.32% of all branches

        0.154822978  seconds time elapsed
29

30
 *
31
 * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
32 33 34 35 36 37 38 39
 *
 * Improvements and fixes by:
 *
 *   Arjan van de Ven <arjan@linux.intel.com>
 *   Yanmin Zhang <yanmin.zhang@intel.com>
 *   Wu Fengguang <fengguang.wu@intel.com>
 *   Mike Galbraith <efault@gmx.de>
 *   Paul Mackerras <paulus@samba.org>
40
 *   Jaswinder Singh Rajput <jaswinder@kernel.org>
41 42
 */

43
#include "builtin.h"
44
#include "util/cgroup.h"
45
#include <subcmd/parse-options.h>
46
#include "util/parse-events.h"
47
#include "util/pmu.h"
48
#include "util/event.h"
49
#include "util/evlist.h"
50
#include "util/evlist-hybrid.h"
51
#include "util/evsel.h"
52
#include "util/debug.h"
53
#include "util/color.h"
54
#include "util/stat.h"
55
#include "util/header.h"
56
#include "util/cpumap.h"
57
#include "util/thread_map.h"
58
#include "util/counts.h"
59
#include "util/topdown.h"
60
#include "util/session.h"
61
#include "util/tool.h"
62
#include "util/string2.h"
63
#include "util/metricgroup.h"
64
#include "util/synthetic-events.h"
65
#include "util/target.h"
66
#include "util/time-utils.h"
67
#include "util/top.h"
68
#include "util/affinity.h"
69
#include "util/pfm.h"
70
#include "util/bpf_counter.h"
71
#include "util/iostat.h"
72
#include "util/pmu-hybrid.h"
73
#include "util/util.h"
74
#include "asm/bug.h"
75

76
#include <linux/time64.h>
77
#include <linux/zalloc.h>
78
#include <api/fs/fs.h>
79
#include <errno.h>
80
#include <signal.h>
81
#include <stdlib.h>
82
#include <sys/prctl.h>
83
#include <inttypes.h>
84
#include <locale.h>
85
#include <math.h>
86 87
#include <sys/types.h>
#include <sys/stat.h>
88
#include <sys/wait.h>
89
#include <unistd.h>
90 91
#include <sys/time.h>
#include <sys/resource.h>
92
#include <linux/err.h>
93

94
#include <linux/ctype.h>
95
#include <perf/evlist.h>
96
#include <internal/threadmap.h>
97

98
#define DEFAULT_SEPARATOR	" "
99
#define FREEZE_ON_SMI_PATH	"devices/cpu/freeze_on_smi"
100

101
static void print_counters(struct timespec *ts, int argc, const char **argv);
102

103
static struct evlist	*evsel_list;
104
static bool all_counters_use_bpf = true;
105

106
static struct target target = {
107 108
	.uid	= UINT_MAX,
};
109

110 111
#define METRIC_ONLY_LEN 20

112
static volatile sig_atomic_t	child_pid			= -1;
113
static int			detailed_run			=  0;
114
static bool			transaction_run;
115
static bool			topdown_run			= false;
116 117
static bool			smi_cost			= false;
static bool			smi_reset			= false;
118
static int			big_num_opt			=  -1;
119 120 121
static const char		*pre_cmd			= NULL;
static const char		*post_cmd			= NULL;
static bool			sync_run			= false;
122
static bool			forever				= false;
123
static bool			force_metric_only		= false;
124
static struct timespec		ref_time;
125
static bool			append_file;
126
static bool			interval_count;
127 128
static const char		*output_name;
static int			output_fd;
129
static char			*metrics;
130

131 132
struct perf_stat {
	bool			 record;
133
	struct perf_data	 data;
134 135
	struct perf_session	*session;
	u64			 bytes_written;
136
	struct perf_tool	 tool;
137
	bool			 maps_allocated;
138
	struct perf_cpu_map	*cpus;
139
	struct perf_thread_map *threads;
140
	enum aggr_mode		 aggr_mode;
141 142 143 144 145
};

static struct perf_stat		perf_stat;
#define STAT_RECORD		perf_stat.record

146
static volatile sig_atomic_t done = 0;
147

148
static struct perf_stat_config stat_config = {
149 150 151 152 153 154
	.aggr_mode		= AGGR_GLOBAL,
	.scale			= true,
	.unit_width		= 4, /* strlen("unit") */
	.run_count		= 1,
	.metric_only_len	= METRIC_ONLY_LEN,
	.walltime_nsecs_stats	= &walltime_nsecs_stats,
155
	.ru_stats		= &ru_stats,
156
	.big_num		= true,
157
	.ctl_fd			= -1,
158 159
	.ctl_fd_ack		= -1,
	.iostat_run		= false,
160 161
};

162 163 164 165 166 167 168 169
static bool cpus_map_matched(struct evsel *a, struct evsel *b)
{
	if (!a->core.cpus && !b->core.cpus)
		return true;

	if (!a->core.cpus || !b->core.cpus)
		return false;

170
	if (perf_cpu_map__nr(a->core.cpus) != perf_cpu_map__nr(b->core.cpus))
171 172
		return false;

173 174 175
	for (int i = 0; i < perf_cpu_map__nr(a->core.cpus); i++) {
		if (perf_cpu_map__cpu(a->core.cpus, i).cpu !=
		    perf_cpu_map__cpu(b->core.cpus, i).cpu)
176 177 178 179 180 181 182 183
			return false;
	}

	return true;
}

static void evlist__check_cpu_maps(struct evlist *evlist)
{
184
	struct evsel *evsel, *warned_leader = NULL;
185

186 187 188
	if (evlist__has_hybrid(evlist))
		evlist__warn_hybrid_group(evlist);

189
	evlist__for_each_entry(evlist, evsel) {
190
		struct evsel *leader = evsel__leader(evsel);
191 192 193 194 195 196 197 198

		/* Check that leader matches cpus with each member. */
		if (leader == evsel)
			continue;
		if (cpus_map_matched(leader, evsel))
			continue;

		/* If there's mismatch disable the group and warn user. */
199 200 201 202 203 204 205 206 207 208
		if (warned_leader != leader) {
			char buf[200];

			pr_warning("WARNING: grouped events cpus do not match.\n"
				"Events with CPUs not matching the leader will "
				"be removed from the group.\n");
			evsel__group_desc(leader, buf, sizeof(buf));
			pr_warning("  %s\n", buf);
			warned_leader = leader;
		}
209
		if (verbose > 0) {
210 211
			char buf[200];

212 213 214 215 216 217
			cpu_map__snprint(leader->core.cpus, buf, sizeof(buf));
			pr_warning("     %s: %s\n", leader->name, buf);
			cpu_map__snprint(evsel->core.cpus, buf, sizeof(buf));
			pr_warning("     %s: %s\n", evsel->name, buf);
		}

218
		evsel__remove_from_group(evsel, leader);
219 220 221
	}
}

222 223 224 225 226
static inline void diff_timespec(struct timespec *r, struct timespec *a,
				 struct timespec *b)
{
	r->tv_sec = a->tv_sec - b->tv_sec;
	if (a->tv_nsec < b->tv_nsec) {
227
		r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec;
228 229 230 231 232 233
		r->tv_sec--;
	} else {
		r->tv_nsec = a->tv_nsec - b->tv_nsec ;
	}
}

234 235
static void perf_stat__reset_stats(void)
{
236
	evlist__reset_stats(evsel_list);
237
	perf_stat__reset_shadow_stats();
238 239
}

240 241 242 243
static int process_synthesized_event(struct perf_tool *tool __maybe_unused,
				     union perf_event *event,
				     struct perf_sample *sample __maybe_unused,
				     struct machine *machine __maybe_unused)
244
{
245
	if (perf_data__write(&perf_stat.data, event, event->header.size) < 0) {
246 247 248 249
		pr_err("failed to write perf data, error: %m\n");
		return -1;
	}

250
	perf_stat.bytes_written += event->header.size;
251 252 253
	return 0;
}

254
static int write_stat_round_event(u64 tm, u64 type)
255
{
256
	return perf_event__synthesize_stat_round(NULL, tm, type,
257 258 259 260 261 262 263
						 process_synthesized_event,
						 NULL);
}

#define WRITE_STAT_ROUND_EVENT(time, interval) \
	write_stat_round_event(time, PERF_STAT_ROUND_TYPE__ ## interval)

264
#define SID(e, x, y) xyarray__entry(e->core.sample_id, x, y)
265

266
static int evsel__write_stat_event(struct evsel *counter, int cpu_map_idx, u32 thread,
267
				   struct perf_counts_values *count)
268
{
269
	struct perf_sample_id *sid = SID(counter, cpu_map_idx, thread);
270
	struct perf_cpu cpu = perf_cpu_map__cpu(evsel__cpus(counter), cpu_map_idx);
271 272 273 274 275

	return perf_event__synthesize_stat(NULL, cpu, thread, sid->id, count,
					   process_synthesized_event, NULL);
}

276
static int read_single_counter(struct evsel *counter, int cpu_map_idx,
277 278
			       int thread, struct timespec *rs)
{
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	switch(counter->tool_event) {
		case PERF_TOOL_DURATION_TIME: {
			u64 val = rs->tv_nsec + rs->tv_sec*1000000000ULL;
			struct perf_counts_values *count =
				perf_counts(counter->counts, cpu_map_idx, thread);
			count->ena = count->run = val;
			count->val = val;
			return 0;
		}
		case PERF_TOOL_USER_TIME:
		case PERF_TOOL_SYSTEM_TIME: {
			u64 val;
			struct perf_counts_values *count =
				perf_counts(counter->counts, cpu_map_idx, thread);
			if (counter->tool_event == PERF_TOOL_USER_TIME)
				val = ru_stats.ru_utime_usec_stat.mean;
			else
				val = ru_stats.ru_stime_usec_stat.mean;
			count->ena = count->run = val;
			count->val = val;
			return 0;
		}
		default:
		case PERF_TOOL_NONE:
			return evsel__read_counter(counter, cpu_map_idx, thread);
		case PERF_TOOL_MAX:
			/* This should never be reached */
			return 0;
307 308 309
	}
}

310 311 312 313
/*
 * Read out the results of a single counter:
 * do not aggregate counts across CPUs in system-wide mode
 */
314
static int read_counter_cpu(struct evsel *counter, struct timespec *rs, int cpu_map_idx)
315
{
316
	int nthreads = perf_thread_map__nr(evsel_list->core.threads);
317
	int thread;
318

319 320 321
	if (!counter->supported)
		return -ENOENT;

322
	for (thread = 0; thread < nthreads; thread++) {
323 324
		struct perf_counts_values *count;

325
		count = perf_counts(counter->counts, cpu_map_idx, thread);
326 327 328

		/*
		 * The leader's group read loads data into its group members
329
		 * (via evsel__read_counter()) and sets their count->loaded.
330
		 */
331 332
		if (!perf_counts__is_loaded(counter->counts, cpu_map_idx, thread) &&
		    read_single_counter(counter, cpu_map_idx, thread, rs)) {
333
			counter->counts->scaled = -1;
334 335
			perf_counts(counter->counts, cpu_map_idx, thread)->ena = 0;
			perf_counts(counter->counts, cpu_map_idx, thread)->run = 0;
336 337
			return -1;
		}
338

339
		perf_counts__set_loaded(counter->counts, cpu_map_idx, thread, false);
340

341
		if (STAT_RECORD) {
342
			if (evsel__write_stat_event(counter, cpu_map_idx, thread, count)) {
343 344
				pr_err("failed to write stat event\n");
				return -1;
345
			}
346
		}
347

348 349 350
		if (verbose > 1) {
			fprintf(stat_config.output,
				"%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
351
					evsel__name(counter),
352 353
					perf_cpu_map__cpu(evsel__cpus(counter),
							  cpu_map_idx).cpu,
354
					count->val, count->ena, count->run);
355
		}
356
	}
357 358

	return 0;
359 360
}

361
static int read_affinity_counters(struct timespec *rs)
362
{
363 364
	struct evlist_cpu_iterator evlist_cpu_itr;
	struct affinity saved_affinity, *affinity;
365

366 367 368
	if (all_counters_use_bpf)
		return 0;

369 370 371
	if (!target__has_cpu(&target) || target__has_per_thread(&target))
		affinity = NULL;
	else if (affinity__setup(&saved_affinity) < 0)
372
		return -1;
373 374
	else
		affinity = &saved_affinity;
375

376 377
	evlist__for_each_cpu(evlist_cpu_itr, evsel_list, affinity) {
		struct evsel *counter = evlist_cpu_itr.evsel;
378

379 380 381 382 383 384
		if (evsel__is_bpf(counter))
			continue;

		if (!counter->err) {
			counter->err = read_counter_cpu(counter, rs,
							evlist_cpu_itr.cpu_map_idx);
385 386
		}
	}
387 388 389
	if (affinity)
		affinity__cleanup(&saved_affinity);

390 391 392
	return 0;
}

393 394 395 396 397 398
static int read_bpf_map_counters(void)
{
	struct evsel *counter;
	int err;

	evlist__for_each_entry(evsel_list, counter) {
399 400 401
		if (!evsel__is_bpf(counter))
			continue;

402 403 404 405 406 407 408
		err = bpf_counter__read(counter);
		if (err)
			return err;
	}
	return 0;
}

409
static int read_counters(struct timespec *rs)
410
{
411
	if (!stat_config.stop_read_counter) {
412 413
		if (read_bpf_map_counters() ||
		    read_affinity_counters(rs))
414
			return -1;
415
	}
416 417 418 419 420 421
	return 0;
}

static void process_counters(void)
{
	struct evsel *counter;
422

423
	evlist__for_each_entry(evsel_list, counter) {
424
		if (counter->err)
425
			pr_debug("failed to read counter %s\n", counter->name);
426
		if (counter->err == 0 && perf_stat_process_counter(&stat_config, counter))
427
			pr_warning("failed to process counter %s\n", counter->name);
428
		counter->err = 0;
429
	}
430 431

	perf_stat_merge_counters(&stat_config, evsel_list);
432
	perf_stat_process_percore(&stat_config, evsel_list);
433 434
}

435
static void process_interval(void)
436 437 438
{
	struct timespec ts, rs;

439 440 441
	clock_gettime(CLOCK_MONOTONIC, &ts);
	diff_timespec(&rs, &ts, &ref_time);

442 443
	evlist__reset_aggr_stats(evsel_list);

444 445
	if (read_counters(&rs) == 0)
		process_counters();
446

447
	if (STAT_RECORD) {
448
		if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL))
449 450 451
			pr_err("failed to write stat round event\n");
	}

452
	init_stats(&walltime_nsecs_stats);
453
	update_stats(&walltime_nsecs_stats, stat_config.interval * 1000000ULL);
454
	print_counters(&rs, 0, NULL);
455 456
}

457 458 459 460 461 462 463 464 465 466
static bool handle_interval(unsigned int interval, int *times)
{
	if (interval) {
		process_interval();
		if (interval_count && !(--(*times)))
			return true;
	}
	return false;
}

467
static int enable_counters(void)
468
{
469 470 471
	struct evsel *evsel;
	int err;

472 473 474 475 476 477 478
	evlist__for_each_entry(evsel_list, evsel) {
		if (!evsel__is_bpf(evsel))
			continue;

		err = bpf_counter__enable(evsel);
		if (err)
			return err;
479 480
	}

481
	if (!target__enable_on_exec(&target)) {
482 483
		if (!all_counters_use_bpf)
			evlist__enable(evsel_list);
484
	}
485
	return 0;
486 487
}

488 489
static void disable_counters(void)
{
490 491
	struct evsel *counter;

492 493 494 495 496
	/*
	 * If we don't have tracee (attaching to task or cpu), counters may
	 * still be running. To get accurate group ratios, we must stop groups
	 * from counting before reading their constituent counters.
	 */
497 498 499 500 501 502
	if (!target__none(&target)) {
		evlist__for_each_entry(evsel_list, counter)
			bpf_counter__disable(counter);
		if (!all_counters_use_bpf)
			evlist__disable(evsel_list);
	}
503 504
}

505
static volatile sig_atomic_t workload_exec_errno;
506 507

/*
508
 * evlist__prepare_workload will send a SIGUSR1
509 510 511
 * if the fork fails, since we asked by setting its
 * want_signal to true.
 */
512 513
static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info,
					void *ucontext __maybe_unused)
514
{
515
	workload_exec_errno = info->si_value.sival_int;
516 517
}

518
static bool evsel__should_store_id(struct evsel *counter)
519
{
520
	return STAT_RECORD || counter->core.attr.read_format & PERF_FORMAT_ID;
521 522
}

523
static bool is_target_alive(struct target *_target,
524
			    struct perf_thread_map *threads)
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
{
	struct stat st;
	int i;

	if (!target__has_task(_target))
		return true;

	for (i = 0; i < threads->nr; i++) {
		char path[PATH_MAX];

		scnprintf(path, PATH_MAX, "%s/%d", procfs__mountpoint(),
			  threads->map[i].pid);

		if (!stat(path, &st))
			return true;
	}

	return false;
}

545 546 547 548 549 550 551
static void process_evlist(struct evlist *evlist, unsigned int interval)
{
	enum evlist_ctl_cmd cmd = EVLIST_CTL_CMD_UNSUPPORTED;

	if (evlist__ctlfd_process(evlist, &cmd) > 0) {
		switch (cmd) {
		case EVLIST_CTL_CMD_ENABLE:
552
			fallthrough;
553 554 555 556
		case EVLIST_CTL_CMD_DISABLE:
			if (interval)
				process_interval();
			break;
557
		case EVLIST_CTL_CMD_SNAPSHOT:
558 559
		case EVLIST_CTL_CMD_ACK:
		case EVLIST_CTL_CMD_UNSUPPORTED:
560
		case EVLIST_CTL_CMD_EVLIST:
561
		case EVLIST_CTL_CMD_STOP:
562
		case EVLIST_CTL_CMD_PING:
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
		default:
			break;
		}
	}
}

static void compute_tts(struct timespec *time_start, struct timespec *time_stop,
			int *time_to_sleep)
{
	int tts = *time_to_sleep;
	struct timespec time_diff;

	diff_timespec(&time_diff, time_stop, time_start);

	tts -= time_diff.tv_sec * MSEC_PER_SEC +
	       time_diff.tv_nsec / NSEC_PER_MSEC;

	if (tts < 0)
		tts = 0;

	*time_to_sleep = tts;
}

static int dispatch_events(bool forks, int timeout, int interval, int *times)
587 588
{
	int child_exited = 0, status = 0;
589 590 591 592 593 594 595 596 597 598 599
	int time_to_sleep, sleep_time;
	struct timespec time_start, time_stop;

	if (interval)
		sleep_time = interval;
	else if (timeout)
		sleep_time = timeout;
	else
		sleep_time = 1000;

	time_to_sleep = sleep_time;
600 601 602 603 604 605 606 607 608 609

	while (!done) {
		if (forks)
			child_exited = waitpid(child_pid, &status, WNOHANG);
		else
			child_exited = !is_target_alive(&target, evsel_list->core.threads) ? 1 : 0;

		if (child_exited)
			break;

610 611 612 613 614 615 616 617 618 619
		clock_gettime(CLOCK_MONOTONIC, &time_start);
		if (!(evlist__poll(evsel_list, time_to_sleep) > 0)) { /* poll timeout or EINTR */
			if (timeout || handle_interval(interval, times))
				break;
			time_to_sleep = sleep_time;
		} else { /* fd revent */
			process_evlist(evsel_list, interval);
			clock_gettime(CLOCK_MONOTONIC, &time_stop);
			compute_tts(&time_start, &time_stop, &time_to_sleep);
		}
620 621 622 623 624
	}

	return status;
}

625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
enum counter_recovery {
	COUNTER_SKIP,
	COUNTER_RETRY,
	COUNTER_FATAL,
};

static enum counter_recovery stat_handle_error(struct evsel *counter)
{
	char msg[BUFSIZ];
	/*
	 * PPC returns ENXIO for HW counters until 2.6.37
	 * (behavior changed with commit b0a873e).
	 */
	if (errno == EINVAL || errno == ENOSYS ||
	    errno == ENOENT || errno == EOPNOTSUPP ||
	    errno == ENXIO) {
		if (verbose > 0)
			ui__warning("%s event is not supported by the kernel.\n",
643
				    evsel__name(counter));
644
		counter->supported = false;
645 646 647 648 649
		/*
		 * errored is a sticky flag that means one of the counter's
		 * cpu event had a problem and needs to be reexamined.
		 */
		counter->errored = true;
650

651 652
		if ((evsel__leader(counter) != counter) ||
		    !(counter->core.leader->nr_members > 1))
653
			return COUNTER_SKIP;
654
	} else if (evsel__fallback(counter, errno, msg, sizeof(msg))) {
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
		if (verbose > 0)
			ui__warning("%s\n", msg);
		return COUNTER_RETRY;
	} else if (target__has_per_thread(&target) &&
		   evsel_list->core.threads &&
		   evsel_list->core.threads->err_thread != -1) {
		/*
		 * For global --per-thread case, skip current
		 * error thread.
		 */
		if (!thread_map__remove(evsel_list->core.threads,
					evsel_list->core.threads->err_thread)) {
			evsel_list->core.threads->err_thread = -1;
			return COUNTER_RETRY;
		}
670 671 672 673 674 675 676
	} else if (counter->skippable) {
		if (verbose > 0)
			ui__warning("skipping event %s that kernel failed to open .\n",
				    evsel__name(counter));
		counter->supported = false;
		counter->errored = true;
		return COUNTER_SKIP;
677 678
	}

679
	evsel__open_strerror(counter, &target, errno, msg, sizeof(msg));
680 681 682 683 684 685 686
	ui__error("%s\n", msg);

	if (child_pid != -1)
		kill(child_pid, SIGTERM);
	return COUNTER_FATAL;
}

687
static int __run_perf_stat(int argc, const char **argv, int run_idx)
688
{
689
	int interval = stat_config.interval;
690
	int times = stat_config.times;
691
	int timeout = stat_config.timeout;
692
	char msg[BUFSIZ];
693
	unsigned long long t0, t1;
694
	struct evsel *counter;
695
	size_t l;
696
	int status = 0;
697
	const bool forks = (argc > 0);
698
	bool is_pipe = STAT_RECORD ? perf_stat.data.is_pipe : false;
699
	struct evlist_cpu_iterator evlist_cpu_itr;
700
	struct affinity saved_affinity, *affinity = NULL;
701
	int err;
702
	bool second_pass = false;
703

704
	if (forks) {
705
		if (evlist__prepare_workload(evsel_list, &target, argv, is_pipe, workload_exec_failed_signal) < 0) {
706 707
			perror("failed to prepare workload");
			return -1;
708
		}
709
		child_pid = evsel_list->workload.pid;
710 711
	}

712
	if (!cpu_map__is_dummy(evsel_list->core.user_requested_cpus)) {
713 714 715 716
		if (affinity__setup(&saved_affinity) < 0)
			return -1;
		affinity = &saved_affinity;
	}
717

718
	evlist__for_each_entry(evsel_list, counter) {
719
		counter->reset_group = false;
720 721
		if (bpf_counter__load(counter, &target))
			return -1;
722
		if (!(evsel__is_bperf(counter)))
723
			all_counters_use_bpf = false;
724 725
	}

726
	evlist__for_each_cpu(evlist_cpu_itr, evsel_list, affinity) {
727 728
		counter = evlist_cpu_itr.evsel;

729 730 731 732 733 734
		/*
		 * bperf calls evsel__open_per_cpu() in bperf__load(), so
		 * no need to call it again here.
		 */
		if (target.use_bpf)
			break;
735

736 737
		if (counter->reset_group || counter->errored)
			continue;
738
		if (evsel__is_bperf(counter))
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
			continue;
try_again:
		if (create_perf_stat_counter(counter, &stat_config, &target,
					     evlist_cpu_itr.cpu_map_idx) < 0) {

			/*
			 * Weak group failed. We cannot just undo this here
			 * because earlier CPUs might be in group mode, and the kernel
			 * doesn't support mixing group and non group reads. Defer
			 * it to later.
			 * Don't close here because we're in the wrong affinity.
			 */
			if ((errno == EINVAL || errno == EBADF) &&
				evsel__leader(counter) != counter &&
				counter->weak_group) {
				evlist__reset_weak_group(evsel_list, counter, false);
				assert(counter->reset_group);
				second_pass = true;
757
				continue;
758 759 760 761 762 763 764 765
			}

			switch (stat_handle_error(counter)) {
			case COUNTER_FATAL:
				return -1;
			case COUNTER_RETRY:
				goto try_again;
			case COUNTER_SKIP:
766
				continue;
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
			default:
				break;
			}

		}
		counter->supported = true;
	}

	if (second_pass) {
		/*
		 * Now redo all the weak group after closing them,
		 * and also close errored counters.
		 */

		/* First close errored or weak retry */
782
		evlist__for_each_cpu(evlist_cpu_itr, evsel_list, affinity) {
783 784 785
			counter = evlist_cpu_itr.evsel;

			if (!counter->reset_group && !counter->errored)
786
				continue;
787 788 789 790

			perf_evsel__close_cpu(&counter->core, evlist_cpu_itr.cpu_map_idx);
		}
		/* Now reopen weak */
791
		evlist__for_each_cpu(evlist_cpu_itr, evsel_list, affinity) {
792 793 794 795 796 797
			counter = evlist_cpu_itr.evsel;

			if (!counter->reset_group)
				continue;
try_again_reset:
			pr_debug2("reopening weak %s\n", evsel__name(counter));
798
			if (create_perf_stat_counter(counter, &stat_config, &target,
799
						     evlist_cpu_itr.cpu_map_idx) < 0) {
800 801 802 803 804

				switch (stat_handle_error(counter)) {
				case COUNTER_FATAL:
					return -1;
				case COUNTER_RETRY:
805
					goto try_again_reset;
806 807 808 809 810
				case COUNTER_SKIP:
					continue;
				default:
					break;
				}
811
			}
812 813 814
			counter->supported = true;
		}
	}
815
	affinity__cleanup(affinity);
816 817 818 819 820

	evlist__for_each_entry(evsel_list, counter) {
		if (!counter->supported) {
			perf_evsel__free_fd(&counter->core);
			continue;
821
		}
822 823

		l = strlen(counter->unit);
824 825
		if (l > stat_config.unit_width)
			stat_config.unit_width = l;
826

827
		if (evsel__should_store_id(counter) &&
828
		    evsel__store_ids(counter, evsel_list))
829
			return -1;
830
	}
831

832
	if (evlist__apply_filters(evsel_list, &counter)) {
833
		pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
834
			counter->filter, evsel__name(counter), errno,
835
			str_error_r(errno, msg, sizeof(msg)));
836 837 838
		return -1;
	}

839
	if (STAT_RECORD) {
840
		int fd = perf_data__fd(&perf_stat.data);
841

842
		if (is_pipe) {
843
			err = perf_header__write_pipe(perf_data__fd(&perf_stat.data));
844 845 846 847 848
		} else {
			err = perf_session__write_header(perf_stat.session, evsel_list,
							 fd, false);
		}

849 850
		if (err < 0)
			return err;
851

852 853
		err = perf_event__synthesize_stat_events(&stat_config, NULL, evsel_list,
							 process_synthesized_event, is_pipe);
854 855
		if (err < 0)
			return err;
856 857
	}

858
	if (target.initial_delay) {
859 860 861 862 863 864
		pr_info(EVLIST_DISABLED_MSG);
	} else {
		err = enable_counters();
		if (err)
			return -1;
	}
865 866 867

	/* Exec the command, if any */
	if (forks)
868
		evlist__start_workload(evsel_list);
869

870 871
	if (target.initial_delay > 0) {
		usleep(target.initial_delay * USEC_PER_MSEC);
872 873 874 875 876 877 878
		err = enable_counters();
		if (err)
			return -1;

		pr_info(EVLIST_ENABLED_MSG);
	}

879 880
	t0 = rdclock();
	clock_gettime(CLOCK_MONOTONIC, &ref_time);
881

882
	if (forks) {
883
		if (interval || timeout || evlist__ctlfd_initialized(evsel_list))
884
			status = dispatch_events(forks, timeout, interval, &times);
885 886 887
		if (child_pid != -1) {
			if (timeout)
				kill(child_pid, SIGTERM);
888
			wait4(child_pid, &status, 0, &stat_config.ru_data);
889
		}
890

891
		if (workload_exec_errno) {
892
			const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
893
			pr_err("Workload failed: %s\n", emsg);
894
			return -1;
895
		}
896

897 898
		if (WIFSIGNALED(status))
			psignal(WTERMSIG(status), argv[0]);
899
	} else {
900
		status = dispatch_events(forks, timeout, interval, &times);
901
	}
902

903 904
	disable_counters();

905 906
	t1 = rdclock();

907 908
	if (stat_config.walltime_run_table)
		stat_config.walltime_run[run_idx] = t1 - t0;
909

910
	if (interval && stat_config.summary) {
911
		stat_config.interval = 0;
912
		stat_config.stop_read_counter = true;
913 914 915
		init_stats(&walltime_nsecs_stats);
		update_stats(&walltime_nsecs_stats, t1 - t0);

916 917
		evlist__copy_prev_raw_counts(evsel_list);
		evlist__reset_prev_raw_counts(evsel_list);
918
		evlist__reset_aggr_stats(evsel_list);
919
	} else {
920
		update_stats(&walltime_nsecs_stats, t1 - t0);
921 922
		update_rusage_stats(&ru_stats, &stat_config.ru_data);
	}
923

924 925 926 927 928 929
	/*
	 * Closing a group leader splits the group, and as we only disable
	 * group leaders, results in remaining events becoming enabled. To
	 * avoid arbitrary skew, we must read all counters before closing any
	 * group leaders.
	 */
930 931
	if (read_counters(&(struct timespec) { .tv_nsec = t1-t0 }) == 0)
		process_counters();
932 933 934 935 936 937

	/*
	 * We need to keep evsel_list alive, because it's processed
	 * later the evsel_list will be closed after.
	 */
	if (!STAT_RECORD)
938
		evlist__close(evsel_list);
939

940 941 942
	return WEXITSTATUS(status);
}

943
static int run_perf_stat(int argc, const char **argv, int run_idx)
944 945 946 947 948 949 950 951 952 953 954 955
{
	int ret;

	if (pre_cmd) {
		ret = system(pre_cmd);
		if (ret)
			return ret;
	}

	if (sync_run)
		sync();

956
	ret = __run_perf_stat(argc, argv, run_idx);
957 958 959 960 961 962 963 964 965 966 967 968
	if (ret)
		return ret;

	if (post_cmd) {
		ret = system(post_cmd);
		if (ret)
			return ret;
	}

	return ret;
}

969 970
static void print_counters(struct timespec *ts, int argc, const char **argv)
{
971 972 973
	/* Do not print anything if we record to the pipe. */
	if (STAT_RECORD && perf_stat.data.is_pipe)
		return;
974
	if (quiet)
Andi Kleen's avatar
Andi Kleen committed
975
		return;
976

977
	evlist__print_counters(evsel_list, &stat_config, &target, ts, argc, argv);
978 979
}

980
static volatile sig_atomic_t signr = -1;
981

982
static void skip_signal(int signo)
983
{
984
	if ((child_pid == -1) || stat_config.interval)
985 986
		done = 1;

987
	signr = signo;
988 989 990 991 992 993 994
	/*
	 * render child_pid harmless
	 * won't send SIGTERM to a random
	 * process in case of race condition
	 * and fast PID recycling
	 */
	child_pid = -1;
995 996 997 998
}

static void sig_atexit(void)
{
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
	sigset_t set, oset;

	/*
	 * avoid race condition with SIGCHLD handler
	 * in skip_signal() which is modifying child_pid
	 * goal is to avoid send SIGTERM to a random
	 * process
	 */
	sigemptyset(&set);
	sigaddset(&set, SIGCHLD);
	sigprocmask(SIG_BLOCK, &set, &oset);

1011 1012 1013
	if (child_pid != -1)
		kill(child_pid, SIGTERM);

1014 1015
	sigprocmask(SIG_SETMASK, &oset, NULL);

1016 1017 1018 1019 1020
	if (signr == -1)
		return;

	signal(signr, SIG_DFL);
	kill(getpid(), signr);
1021 1022
}

1023 1024 1025 1026 1027
void perf_stat__set_big_num(int set)
{
	stat_config.big_num = (set != 0);
}

1028 1029 1030 1031 1032
void perf_stat__set_no_csv_summary(int set)
{
	stat_config.no_csv_summary = (set != 0);
}

1033 1034
static int stat__set_big_num(const struct option *opt __maybe_unused,
			     const char *s __maybe_unused, int unset)
1035 1036
{
	big_num_opt = unset ? 0 : 1;
1037
	perf_stat__set_big_num(!unset);
1038 1039 1040
	return 0;
}

1041 1042 1043 1044
static int enable_metric_only(const struct option *opt __maybe_unused,
			      const char *s __maybe_unused, int unset)
{
	force_metric_only = true;
1045
	stat_config.metric_only = !unset;
1046 1047 1048
	return 0;
}

1049
static int append_metric_groups(const struct option *opt __maybe_unused,
1050 1051 1052
			       const char *str,
			       int unset __maybe_unused)
{
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
	if (metrics) {
		char *tmp;

		if (asprintf(&tmp, "%s,%s", metrics, str) < 0)
			return -ENOMEM;
		free(metrics);
		metrics = tmp;
	} else {
		metrics = strdup(str);
		if (!metrics)
			return -ENOMEM;
	}
	return 0;
1066 1067
}

1068 1069 1070 1071
static int parse_control_option(const struct option *opt,
				const char *str,
				int unset __maybe_unused)
{
1072
	struct perf_stat_config *config = opt->value;
1073

1074 1075 1076
	return evlist__parse_control(str, &config->ctl_fd, &config->ctl_fd_ack, &config->ctl_fd_close);
}

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
static int parse_stat_cgroups(const struct option *opt,
			      const char *str, int unset)
{
	if (stat_config.cgroup_list) {
		pr_err("--cgroup and --for-each-cgroup cannot be used together\n");
		return -1;
	}

	return parse_cgroups(opt, str, unset);
}

1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
static int parse_hybrid_type(const struct option *opt,
			     const char *str,
			     int unset __maybe_unused)
{
	struct evlist *evlist = *(struct evlist **)opt->value;

	if (!list_empty(&evlist->core.entries)) {
		fprintf(stderr, "Must define cputype before events/metrics\n");
		return -1;
	}

	evlist->hybrid_pmu_name = perf_pmu__hybrid_type_to_pmu(str);
	if (!evlist->hybrid_pmu_name) {
		fprintf(stderr, "--cputype %s is not supported!\n", str);
		return -1;
	}

	return 0;
}

1108
static struct option stat_options[] = {
1109 1110 1111 1112 1113 1114 1115
	OPT_BOOLEAN('T', "transaction", &transaction_run,
		    "hardware transaction statistics"),
	OPT_CALLBACK('e', "event", &evsel_list, "event",
		     "event selector. use 'perf list' to list available events",
		     parse_events_option),
	OPT_CALLBACK(0, "filter", &evsel_list, "filter",
		     "event filter", parse_filter),
1116
	OPT_BOOLEAN('i', "no-inherit", &stat_config.no_inherit,
1117 1118 1119 1120 1121
		    "child tasks do not inherit counters"),
	OPT_STRING('p', "pid", &target.pid, "pid",
		   "stat events on existing process id"),
	OPT_STRING('t', "tid", &target.tid, "tid",
		   "stat events on existing thread id"),
1122 1123 1124
#ifdef HAVE_BPF_SKEL
	OPT_STRING('b', "bpf-prog", &target.bpf_str, "bpf-prog-id",
		   "stat events on existing bpf program id"),
1125 1126 1127 1128
	OPT_BOOLEAN(0, "bpf-counters", &target.use_bpf,
		    "use bpf program to count events"),
	OPT_STRING(0, "bpf-attr-map", &target.attr_map, "attr-map-path",
		   "path to perf_event_attr map"),
1129
#endif
1130 1131
	OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
		    "system-wide collection from all CPUs"),
Andi Kleen's avatar
Andi Kleen committed
1132 1133
	OPT_BOOLEAN(0, "scale", &stat_config.scale,
		    "Use --no-scale to disable counter scaling for multiplexing"),
1134 1135
	OPT_INCR('v', "verbose", &verbose,
		    "be more verbose (show counter open errors, etc)"),
1136
	OPT_INTEGER('r', "repeat", &stat_config.run_count,
1137
		    "repeat command and print average + stddev (max: 100, forever: 0)"),
1138
	OPT_BOOLEAN(0, "table", &stat_config.walltime_run_table,
1139
		    "display details about each run (only with -r option)"),
1140
	OPT_BOOLEAN('n', "null", &stat_config.null_run,
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
		    "null run - dont start any counters"),
	OPT_INCR('d', "detailed", &detailed_run,
		    "detailed run - start a lot of events"),
	OPT_BOOLEAN('S', "sync", &sync_run,
		    "call sync() before starting a run"),
	OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
			   "print large numbers with thousands\' separators",
			   stat__set_big_num),
	OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
		    "list of cpus to monitor in system-wide"),
	OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
		    "disable CPU count aggregation", AGGR_NONE),
1153
	OPT_BOOLEAN(0, "no-merge", &stat_config.no_merge, "Do not merge identical named events"),
1154 1155
	OPT_BOOLEAN(0, "hybrid-merge", &stat_config.hybrid_merge,
		    "Merge identical named hybrid events"),
1156
	OPT_STRING('x', "field-separator", &stat_config.csv_sep, "separator",
1157
		   "print counts with custom separator"),
1158 1159
	OPT_BOOLEAN('j', "json-output", &stat_config.json_output,
		   "print counts in JSON format"),
1160
	OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
1161 1162 1163
		     "monitor event in cgroup name only", parse_stat_cgroups),
	OPT_STRING(0, "for-each-cgroup", &stat_config.cgroup_list, "name",
		    "expand events for each cgroup"),
1164 1165 1166 1167 1168 1169 1170 1171 1172
	OPT_STRING('o', "output", &output_name, "file", "output file name"),
	OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
	OPT_INTEGER(0, "log-fd", &output_fd,
		    "log output to fd, instead of stderr"),
	OPT_STRING(0, "pre", &pre_cmd, "command",
			"command to run prior to the measured command"),
	OPT_STRING(0, "post", &post_cmd, "command",
			"command to run after to the measured command"),
	OPT_UINTEGER('I', "interval-print", &stat_config.interval,
1173 1174
		    "print counts at regular interval in ms "
		    "(overhead is possible for values <= 100ms)"),
1175 1176
	OPT_INTEGER(0, "interval-count", &stat_config.times,
		    "print counts for fixed number of times"),
1177
	OPT_BOOLEAN(0, "interval-clear", &stat_config.interval_clear,
1178
		    "clear screen in between new interval"),
1179 1180
	OPT_UINTEGER(0, "timeout", &stat_config.timeout,
		    "stop workload and print counts after a timeout period in ms (>= 10ms)"),
1181 1182
	OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode,
		     "aggregate counts per processor socket", AGGR_SOCKET),
1183 1184
	OPT_SET_UINT(0, "per-die", &stat_config.aggr_mode,
		     "aggregate counts per processor die", AGGR_DIE),
1185 1186 1187 1188
	OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode,
		     "aggregate counts per physical processor core", AGGR_CORE),
	OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode,
		     "aggregate counts per thread", AGGR_THREAD),
1189 1190
	OPT_SET_UINT(0, "per-node", &stat_config.aggr_mode,
		     "aggregate counts per numa node", AGGR_NODE),
1191
	OPT_INTEGER('D', "delay", &target.initial_delay,
1192
		    "ms to wait before starting measurement after program start (-1: start with events disabled)"),
1193
	OPT_CALLBACK_NOOPT(0, "metric-only", &stat_config.metric_only, NULL,
1194
			"Only print computed metrics. No raw values", enable_metric_only),
1195 1196 1197 1198
	OPT_BOOLEAN(0, "metric-no-group", &stat_config.metric_no_group,
		       "don't group metric events, impacts multiplexing"),
	OPT_BOOLEAN(0, "metric-no-merge", &stat_config.metric_no_merge,
		       "don't try to share events between metrics in a group"),
1199 1200
	OPT_BOOLEAN(0, "metric-no-threshold", &stat_config.metric_no_threshold,
		       "don't try to share events between metrics in a group  "),
1201
	OPT_BOOLEAN(0, "topdown", &topdown_run,
1202 1203 1204
			"measure top-down statistics"),
	OPT_UINTEGER(0, "td-level", &stat_config.topdown_level,
			"Set the metrics level for the top-down statistics (0: max level)"),
1205 1206
	OPT_BOOLEAN(0, "smi-cost", &smi_cost,
			"measure SMI cost"),
1207 1208
	OPT_CALLBACK('M', "metrics", &evsel_list, "metric/metric group list",
		     "monitor specified metrics or metric groups (separated by ,)",
1209
		     append_metric_groups),
1210 1211 1212 1213 1214 1215
	OPT_BOOLEAN_FLAG(0, "all-kernel", &stat_config.all_kernel,
			 "Configure all used events to run in kernel space.",
			 PARSE_OPT_EXCLUSIVE),
	OPT_BOOLEAN_FLAG(0, "all-user", &stat_config.all_user,
			 "Configure all used events to run in user space.",
			 PARSE_OPT_EXCLUSIVE),
1216 1217 1218 1219
	OPT_BOOLEAN(0, "percore-show-thread", &stat_config.percore_show_thread,
		    "Use with 'percore' event qualifier to show the event "
		    "counts of one hardware thread by sum up total hardware "
		    "threads of same physical core"),
1220 1221
	OPT_BOOLEAN(0, "summary", &stat_config.summary,
		       "print summary for interval mode"),
1222 1223
	OPT_BOOLEAN(0, "no-csv-summary", &stat_config.no_csv_summary,
		       "don't print 'summary' for CSV summary output"),
1224 1225
	OPT_BOOLEAN(0, "quiet", &quiet,
			"don't print any output, messages or warnings (useful with record)"),
1226 1227 1228 1229
	OPT_CALLBACK(0, "cputype", &evsel_list, "hybrid cpu type",
		     "Only enable events on applying cpu with this type "
		     "for hybrid platform (e.g. core or atom)",
		     parse_hybrid_type),
1230 1231 1232 1233 1234
#ifdef HAVE_LIBPFM
	OPT_CALLBACK(0, "pfm-events", &evsel_list, "event",
		"libpfm4 event selector. use 'perf list' to list available events",
		parse_libpfm_events_option),
#endif
1235
	OPT_CALLBACK(0, "control", &stat_config, "fd:ctl-fd[,ack-fd] or fifo:ctl-fifo[,ack-fifo]",
1236
		     "Listen on ctl-fd descriptor for command to control measurement ('enable': enable events, 'disable': disable events).\n"
1237 1238
		     "\t\t\t  Optionally send control command completion ('ack\\n') to ack-fd descriptor.\n"
		     "\t\t\t  Alternatively, ctl-fifo / ack-fifo will be opened and used as ctl-fd / ack-fd.",
1239
		      parse_control_option),
1240 1241 1242
	OPT_CALLBACK_OPTARG(0, "iostat", &evsel_list, &stat_config, "default",
			    "measure I/O performance metrics provided by arch/platform",
			    iostat_parse),
1243 1244 1245
	OPT_END()
};

1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
static const char *const aggr_mode__string[] = {
	[AGGR_CORE] = "core",
	[AGGR_DIE] = "die",
	[AGGR_GLOBAL] = "global",
	[AGGR_NODE] = "node",
	[AGGR_NONE] = "none",
	[AGGR_SOCKET] = "socket",
	[AGGR_THREAD] = "thread",
	[AGGR_UNSET] = "unset",
};

1257
static struct aggr_cpu_id perf_stat__get_socket(struct perf_stat_config *config __maybe_unused,
1258
						struct perf_cpu cpu)
1259
{
1260
	return aggr_cpu_id__socket(cpu, /*data=*/NULL);
1261 1262
}

1263
static struct aggr_cpu_id perf_stat__get_die(struct perf_stat_config *config __maybe_unused,
1264
					     struct perf_cpu cpu)
1265
{
1266
	return aggr_cpu_id__die(cpu, /*data=*/NULL);
1267 1268
}

1269
static struct aggr_cpu_id perf_stat__get_core(struct perf_stat_config *config __maybe_unused,
1270
					      struct perf_cpu cpu)
1271
{
1272
	return aggr_cpu_id__core(cpu, /*data=*/NULL);
1273 1274
}

1275
static struct aggr_cpu_id perf_stat__get_node(struct perf_stat_config *config __maybe_unused,
1276
					      struct perf_cpu cpu)
1277
{
1278
	return aggr_cpu_id__node(cpu, /*data=*/NULL);
1279 1280
}

1281 1282 1283 1284 1285 1286
static struct aggr_cpu_id perf_stat__get_global(struct perf_stat_config *config __maybe_unused,
						struct perf_cpu cpu)
{
	return aggr_cpu_id__global(cpu, /*data=*/NULL);
}

1287 1288 1289 1290 1291 1292
static struct aggr_cpu_id perf_stat__get_cpu(struct perf_stat_config *config __maybe_unused,
					     struct perf_cpu cpu)
{
	return aggr_cpu_id__cpu(cpu, /*data=*/NULL);
}

1293
static struct aggr_cpu_id perf_stat__get_aggr(struct perf_stat_config *config,
1294
					      aggr_get_id_t get_id, struct perf_cpu cpu)
1295
{
1296 1297 1298 1299 1300
	struct aggr_cpu_id id;

	/* per-process mode - should use global aggr mode */
	if (cpu.cpu == -1)
		return get_id(config, cpu);
1301

1302 1303
	if (aggr_cpu_id__is_empty(&config->cpus_aggr_map->map[cpu.cpu]))
		config->cpus_aggr_map->map[cpu.cpu] = get_id(config, cpu);
1304

1305
	id = config->cpus_aggr_map->map[cpu.cpu];
1306
	return id;
1307 1308
}

1309
static struct aggr_cpu_id perf_stat__get_socket_cached(struct perf_stat_config *config,
1310
						       struct perf_cpu cpu)
1311
{
1312
	return perf_stat__get_aggr(config, perf_stat__get_socket, cpu);
1313 1314
}

1315
static struct aggr_cpu_id perf_stat__get_die_cached(struct perf_stat_config *config,
1316
						    struct perf_cpu cpu)
1317
{
1318
	return perf_stat__get_aggr(config, perf_stat__get_die, cpu);
1319 1320
}

1321
static struct aggr_cpu_id perf_stat__get_core_cached(struct perf_stat_config *config,
1322
						     struct perf_cpu cpu)
1323
{
1324
	return perf_stat__get_aggr(config, perf_stat__get_core, cpu);
1325 1326
}

1327
static struct aggr_cpu_id perf_stat__get_node_cached(struct perf_stat_config *config,
1328
						     struct perf_cpu cpu)
1329
{
1330
	return perf_stat__get_aggr(config, perf_stat__get_node, cpu);
1331 1332
}

1333 1334 1335 1336 1337 1338
static struct aggr_cpu_id perf_stat__get_global_cached(struct perf_stat_config *config,
						       struct perf_cpu cpu)
{
	return perf_stat__get_aggr(config, perf_stat__get_global, cpu);
}

1339 1340 1341 1342 1343 1344
static struct aggr_cpu_id perf_stat__get_cpu_cached(struct perf_stat_config *config,
						    struct perf_cpu cpu)
{
	return perf_stat__get_aggr(config, perf_stat__get_cpu, cpu);
}

1345
static aggr_cpu_id_get_t aggr_mode__get_aggr(enum aggr_mode aggr_mode)
1346
{
1347 1348
	switch (aggr_mode) {
	case AGGR_SOCKET:
1349
		return aggr_cpu_id__socket;
1350
	case AGGR_DIE:
1351
		return aggr_cpu_id__die;
1352
	case AGGR_CORE:
1353
		return aggr_cpu_id__core;
1354
	case AGGR_NODE:
1355
		return aggr_cpu_id__node;
1356
	case AGGR_NONE:
1357
		return aggr_cpu_id__cpu;
1358
	case AGGR_GLOBAL:
1359
		return aggr_cpu_id__global;
1360 1361
	case AGGR_THREAD:
	case AGGR_UNSET:
1362
	case AGGR_MAX:
1363 1364 1365 1366
	default:
		return NULL;
	}
}
1367

1368 1369 1370
static aggr_get_id_t aggr_mode__get_id(enum aggr_mode aggr_mode)
{
	switch (aggr_mode) {
1371
	case AGGR_SOCKET:
1372
		return perf_stat__get_socket_cached;
1373
	case AGGR_DIE:
1374
		return perf_stat__get_die_cached;
1375
	case AGGR_CORE:
1376
		return perf_stat__get_core_cached;
1377
	case AGGR_NODE:
1378
		return perf_stat__get_node_cached;
1379
	case AGGR_NONE:
1380
		return perf_stat__get_cpu_cached;
1381
	case AGGR_GLOBAL:
1382
		return perf_stat__get_global_cached;
1383
	case AGGR_THREAD:
Jiri Olsa's avatar
Jiri Olsa committed
1384
	case AGGR_UNSET:
1385
	case AGGR_MAX:
1386
	default:
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
		return NULL;
	}
}

static int perf_stat_init_aggr_mode(void)
{
	int nr;
	aggr_cpu_id_get_t get_id = aggr_mode__get_aggr(stat_config.aggr_mode);

	if (get_id) {
1397
		bool needs_sort = stat_config.aggr_mode != AGGR_NONE;
1398
		stat_config.aggr_map = cpu_aggr_map__new(evsel_list->core.user_requested_cpus,
1399
							 get_id, /*data=*/NULL, needs_sort);
1400 1401 1402 1403 1404
		if (!stat_config.aggr_map) {
			pr_err("cannot build %s map", aggr_mode__string[stat_config.aggr_mode]);
			return -1;
		}
		stat_config.aggr_get_id = aggr_mode__get_id(stat_config.aggr_mode);
1405
	}
1406

1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
	if (stat_config.aggr_mode == AGGR_THREAD) {
		nr = perf_thread_map__nr(evsel_list->core.threads);
		stat_config.aggr_map = cpu_aggr_map__empty_new(nr);
		if (stat_config.aggr_map == NULL)
			return -ENOMEM;

		for (int s = 0; s < nr; s++) {
			struct aggr_cpu_id id = aggr_cpu_id__empty();

			id.thread_idx = s;
			stat_config.aggr_map->map[s] = id;
		}
		return 0;
	}

1422 1423 1424 1425 1426
	/*
	 * The evsel_list->cpus is the base we operate on,
	 * taking the highest cpu number to be the size of
	 * the aggregation translate cpumap.
	 */
1427 1428
	if (evsel_list->core.user_requested_cpus)
		nr = perf_cpu_map__max(evsel_list->core.user_requested_cpus).cpu;
1429 1430
	else
		nr = 0;
1431
	stat_config.cpus_aggr_map = cpu_aggr_map__empty_new(nr + 1);
1432
	return stat_config.cpus_aggr_map ? 0 : -ENOMEM;
1433 1434
}

1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
static void cpu_aggr_map__delete(struct cpu_aggr_map *map)
{
	if (map) {
		WARN_ONCE(refcount_read(&map->refcnt) != 0,
			  "cpu_aggr_map refcnt unbalanced\n");
		free(map);
	}
}

static void cpu_aggr_map__put(struct cpu_aggr_map *map)
{
	if (map && refcount_dec_and_test(&map->refcnt))
		cpu_aggr_map__delete(map);
}

1450 1451
static void perf_stat__exit_aggr_mode(void)
{
1452 1453
	cpu_aggr_map__put(stat_config.aggr_map);
	cpu_aggr_map__put(stat_config.cpus_aggr_map);
1454 1455
	stat_config.aggr_map = NULL;
	stat_config.cpus_aggr_map = NULL;
1456 1457
}

1458
static struct aggr_cpu_id perf_env__get_socket_aggr_by_cpu(struct perf_cpu cpu, void *data)
1459 1460
{
	struct perf_env *env = data;
1461
	struct aggr_cpu_id id = aggr_cpu_id__empty();
1462

1463 1464
	if (cpu.cpu != -1)
		id.socket = env->cpu[cpu.cpu].socket_id;
1465

1466
	return id;
1467 1468
}

1469
static struct aggr_cpu_id perf_env__get_die_aggr_by_cpu(struct perf_cpu cpu, void *data)
1470 1471
{
	struct perf_env *env = data;
1472
	struct aggr_cpu_id id = aggr_cpu_id__empty();
1473

1474
	if (cpu.cpu != -1) {
1475
		/*
1476 1477 1478
		 * die_id is relative to socket, so start
		 * with the socket ID and then add die to
		 * make a unique ID.
1479
		 */
1480 1481
		id.socket = env->cpu[cpu.cpu].socket_id;
		id.die = env->cpu[cpu.cpu].die_id;
1482 1483
	}

1484
	return id;
1485 1486
}

1487
static struct aggr_cpu_id perf_env__get_core_aggr_by_cpu(struct perf_cpu cpu, void *data)
1488 1489
{
	struct perf_env *env = data;
1490
	struct aggr_cpu_id id = aggr_cpu_id__empty();
1491

1492
	if (cpu.cpu != -1) {
1493
		/*
1494
		 * core_id is relative to socket and die,
1495 1496
		 * we need a global id. So we set
		 * socket, die id and core id
1497
		 */
1498 1499 1500
		id.socket = env->cpu[cpu.cpu].socket_id;
		id.die = env->cpu[cpu.cpu].die_id;
		id.core = env->cpu[cpu.cpu].core_id;
1501 1502
	}

1503
	return id;
1504 1505
}

1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
static struct aggr_cpu_id perf_env__get_cpu_aggr_by_cpu(struct perf_cpu cpu, void *data)
{
	struct perf_env *env = data;
	struct aggr_cpu_id id = aggr_cpu_id__empty();

	if (cpu.cpu != -1) {
		/*
		 * core_id is relative to socket and die,
		 * we need a global id. So we set
		 * socket, die id and core id
		 */
		id.socket = env->cpu[cpu.cpu].socket_id;
		id.die = env->cpu[cpu.cpu].die_id;
		id.core = env->cpu[cpu.cpu].core_id;
		id.cpu = cpu;
	}

	return id;
}

1526
static struct aggr_cpu_id perf_env__get_node_aggr_by_cpu(struct perf_cpu cpu, void *data)
1527
{
1528
	struct aggr_cpu_id id = aggr_cpu_id__empty();
1529

1530
	id.node = perf_env__numa_node(data, cpu);
1531
	return id;
1532 1533
}

1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
static struct aggr_cpu_id perf_env__get_global_aggr_by_cpu(struct perf_cpu cpu __maybe_unused,
							   void *data __maybe_unused)
{
	struct aggr_cpu_id id = aggr_cpu_id__empty();

	/* it always aggregates to the cpu 0 */
	id.cpu = (struct perf_cpu){ .cpu = 0 };
	return id;
}

1544
static struct aggr_cpu_id perf_stat__get_socket_file(struct perf_stat_config *config __maybe_unused,
1545
						     struct perf_cpu cpu)
1546
{
1547
	return perf_env__get_socket_aggr_by_cpu(cpu, &perf_stat.session->header.env);
1548
}
1549
static struct aggr_cpu_id perf_stat__get_die_file(struct perf_stat_config *config __maybe_unused,
1550
						  struct perf_cpu cpu)
1551
{
1552
	return perf_env__get_die_aggr_by_cpu(cpu, &perf_stat.session->header.env);
1553
}
1554

1555
static struct aggr_cpu_id perf_stat__get_core_file(struct perf_stat_config *config __maybe_unused,
1556
						   struct perf_cpu cpu)
1557
{
1558
	return perf_env__get_core_aggr_by_cpu(cpu, &perf_stat.session->header.env);
1559 1560
}

1561 1562 1563 1564 1565 1566
static struct aggr_cpu_id perf_stat__get_cpu_file(struct perf_stat_config *config __maybe_unused,
						  struct perf_cpu cpu)
{
	return perf_env__get_cpu_aggr_by_cpu(cpu, &perf_stat.session->header.env);
}

1567
static struct aggr_cpu_id perf_stat__get_node_file(struct perf_stat_config *config __maybe_unused,
1568
						   struct perf_cpu cpu)
1569
{
1570
	return perf_env__get_node_aggr_by_cpu(cpu, &perf_stat.session->header.env);
1571 1572
}

1573 1574 1575 1576 1577 1578
static struct aggr_cpu_id perf_stat__get_global_file(struct perf_stat_config *config __maybe_unused,
						     struct perf_cpu cpu)
{
	return perf_env__get_global_aggr_by_cpu(cpu, &perf_stat.session->header.env);
}

1579
static aggr_cpu_id_get_t aggr_mode__get_aggr_file(enum aggr_mode aggr_mode)
1580
{
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
	switch (aggr_mode) {
	case AGGR_SOCKET:
		return perf_env__get_socket_aggr_by_cpu;
	case AGGR_DIE:
		return perf_env__get_die_aggr_by_cpu;
	case AGGR_CORE:
		return perf_env__get_core_aggr_by_cpu;
	case AGGR_NODE:
		return perf_env__get_node_aggr_by_cpu;
	case AGGR_GLOBAL:
1591 1592
		return perf_env__get_global_aggr_by_cpu;
	case AGGR_NONE:
1593
		return perf_env__get_cpu_aggr_by_cpu;
1594 1595
	case AGGR_THREAD:
	case AGGR_UNSET:
1596
	case AGGR_MAX:
1597 1598 1599 1600
	default:
		return NULL;
	}
}
1601

1602 1603 1604
static aggr_get_id_t aggr_mode__get_id_file(enum aggr_mode aggr_mode)
{
	switch (aggr_mode) {
1605
	case AGGR_SOCKET:
1606
		return perf_stat__get_socket_file;
1607
	case AGGR_DIE:
1608
		return perf_stat__get_die_file;
1609
	case AGGR_CORE:
1610
		return perf_stat__get_core_file;
1611
	case AGGR_NODE:
1612
		return perf_stat__get_node_file;
1613
	case AGGR_GLOBAL:
1614 1615
		return perf_stat__get_global_file;
	case AGGR_NONE:
1616
		return perf_stat__get_cpu_file;
1617 1618
	case AGGR_THREAD:
	case AGGR_UNSET:
1619
	case AGGR_MAX:
1620
	default:
1621
		return NULL;
1622
	}
1623 1624 1625 1626 1627 1628
}

static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
{
	struct perf_env *env = &st->session->header.env;
	aggr_cpu_id_get_t get_id = aggr_mode__get_aggr_file(stat_config.aggr_mode);
1629
	bool needs_sort = stat_config.aggr_mode != AGGR_NONE;
1630

1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
	if (stat_config.aggr_mode == AGGR_THREAD) {
		int nr = perf_thread_map__nr(evsel_list->core.threads);

		stat_config.aggr_map = cpu_aggr_map__empty_new(nr);
		if (stat_config.aggr_map == NULL)
			return -ENOMEM;

		for (int s = 0; s < nr; s++) {
			struct aggr_cpu_id id = aggr_cpu_id__empty();

			id.thread_idx = s;
			stat_config.aggr_map->map[s] = id;
		}
		return 0;
	}

1647 1648 1649
	if (!get_id)
		return 0;

1650 1651
	stat_config.aggr_map = cpu_aggr_map__new(evsel_list->core.user_requested_cpus,
						 get_id, env, needs_sort);
1652 1653 1654 1655 1656
	if (!stat_config.aggr_map) {
		pr_err("cannot build %s map", aggr_mode__string[stat_config.aggr_mode]);
		return -1;
	}
	stat_config.aggr_get_id = aggr_mode__get_id_file(stat_config.aggr_mode);
1657 1658 1659
	return 0;
}

1660 1661 1662 1663 1664 1665
/*
 * Add default attributes, if there were no attributes specified or
 * if -d/--detailed, -d -d or -d -d -d is used:
 */
static int add_default_attributes(void)
{
1666
	struct perf_event_attr default_attrs0[] = {
1667 1668 1669 1670 1671 1672 1673

  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK		},
  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES	},
  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS		},
  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS		},

  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES		},
1674 1675
};
	struct perf_event_attr frontend_attrs[] = {
1676
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND	},
1677 1678
};
	struct perf_event_attr backend_attrs[] = {
1679
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND	},
1680 1681
};
	struct perf_event_attr default_attrs1[] = {
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS		},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS	},
  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES		},

};

/*
 * Detailed stats (-d), covering the L1 and last level data caches:
 */
	struct perf_event_attr detailed_attrs[] = {

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_LL			<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_LL			<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
};

/*
 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
 */
	struct perf_event_attr very_detailed_attrs[] = {

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1I		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1I		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_DTLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_DTLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_ITLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_ITLB		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},

};

/*
 * Very, very detailed stats (-d -d -d), adding prefetch events:
 */
	struct perf_event_attr very_very_detailed_attrs[] = {

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_PREFETCH	<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},

  { .type = PERF_TYPE_HW_CACHE,
    .config =
	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
	(PERF_COUNT_HW_CACHE_OP_PREFETCH	<<  8) |
	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
};
1778 1779 1780

	struct perf_event_attr default_null_attrs[] = {};

1781
	/* Set attrs if no event is selected and !null_run: */
1782
	if (stat_config.null_run)
1783 1784
		return 0;

1785
	if (transaction_run) {
1786
		/* Handle -T as -M transaction. Once platform specific metrics
1787
		 * support has been added to the json files, all architectures
1788 1789 1790
		 * will use this approach. To determine transaction support
		 * on an architecture test for such a metric name.
		 */
1791 1792 1793
		if (!metricgroup__has_metric("transaction")) {
			pr_err("Missing transaction metrics");
			return -1;
1794
		}
1795 1796 1797 1798 1799 1800 1801
		return metricgroup__parse_groups(evsel_list, "transaction",
						stat_config.metric_no_group,
						stat_config.metric_no_merge,
						stat_config.metric_no_threshold,
						stat_config.user_requested_cpu_list,
						stat_config.system_wide,
						&stat_config.metric_events);
1802 1803
	}

1804 1805 1806 1807
	if (smi_cost) {
		int smi;

		if (sysfs__read_int(FREEZE_ON_SMI_PATH, &smi) < 0) {
1808
			pr_err("freeze_on_smi is not supported.");
1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
			return -1;
		}

		if (!smi) {
			if (sysfs__write_int(FREEZE_ON_SMI_PATH, 1) < 0) {
				fprintf(stderr, "Failed to set freeze_on_smi.\n");
				return -1;
			}
			smi_reset = true;
		}

1820 1821
		if (!metricgroup__has_metric("smi")) {
			pr_err("Missing smi metrics");
1822 1823
			return -1;
		}
1824

1825 1826 1827
		if (!force_metric_only)
			stat_config.metric_only = true;

1828 1829 1830 1831 1832 1833 1834
		return metricgroup__parse_groups(evsel_list, "smi",
						stat_config.metric_no_group,
						stat_config.metric_no_merge,
						stat_config.metric_no_threshold,
						stat_config.user_requested_cpu_list,
						stat_config.system_wide,
						&stat_config.metric_events);
1835 1836
	}

1837
	if (topdown_run) {
1838 1839
		unsigned int max_level = metricgroups__topdown_max_level();
		char str[] = "TopdownL1";
1840

1841 1842 1843
		if (!force_metric_only)
			stat_config.metric_only = true;

1844 1845 1846 1847
		if (!max_level) {
			pr_err("Topdown requested but the topdown metric groups aren't present.\n"
				"(See perf list the metric groups have names like TopdownL1)");
			return -1;
1848 1849 1850 1851 1852
		}
		if (stat_config.topdown_level > max_level) {
			pr_err("Invalid top-down metrics level. The max level is %u.\n", max_level);
			return -1;
		} else if (!stat_config.topdown_level)
1853
			stat_config.topdown_level = 1;
1854

1855 1856 1857 1858
		if (!stat_config.interval && !stat_config.metric_only) {
			fprintf(stat_config.output,
				"Topdown accuracy may decrease when measuring long periods.\n"
				"Please print the result regularly, e.g. -I1000\n");
1859
		}
1860 1861 1862 1863 1864 1865 1866 1867
		str[8] = stat_config.topdown_level + '0';
		if (metricgroup__parse_groups(evsel_list, str,
						/*metric_no_group=*/false,
						/*metric_no_merge=*/false,
						/*metric_no_threshold=*/true,
						stat_config.user_requested_cpu_list,
						stat_config.system_wide,
						&stat_config.metric_events) < 0)
1868 1869 1870
			return -1;
	}

1871
	if (!stat_config.topdown_level)
1872
		stat_config.topdown_level = 1;
1873

1874
	if (!evsel_list->core.nr_entries) {
1875
		/* No events so add defaults. */
1876 1877 1878
		if (target__has_cpu(&target))
			default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK;

1879
		if (evlist__add_default_attrs(evsel_list, default_attrs0) < 0)
1880 1881
			return -1;
		if (pmu_have_event("cpu", "stalled-cycles-frontend")) {
1882
			if (evlist__add_default_attrs(evsel_list, frontend_attrs) < 0)
1883 1884 1885
				return -1;
		}
		if (pmu_have_event("cpu", "stalled-cycles-backend")) {
1886
			if (evlist__add_default_attrs(evsel_list, backend_attrs) < 0)
1887 1888
				return -1;
		}
1889
		if (evlist__add_default_attrs(evsel_list, default_attrs1) < 0)
1890
			return -1;
1891 1892 1893 1894
		/*
		 * Add TopdownL1 metrics if they exist. To minimize
		 * multiplexing, don't request threshold computation.
		 */
1895 1896 1897 1898 1899
		/*
		 * TODO: TopdownL1 is disabled on hybrid CPUs to avoid a crashes
		 * caused by exposing latent bugs. This is fixed properly in:
		 * https://lore.kernel.org/lkml/bff481ba-e60a-763f-0aa0-3ee53302c480@linux.intel.com/
		 */
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
		if (metricgroup__has_metric("TopdownL1") && !perf_pmu__has_hybrid()) {
			struct evlist *metric_evlist = evlist__new();
			struct evsel *metric_evsel;

			if (!metric_evlist)
				return -1;

			if (metricgroup__parse_groups(metric_evlist, "TopdownL1",
							/*metric_no_group=*/false,
							/*metric_no_merge=*/false,
							/*metric_no_threshold=*/true,
							stat_config.user_requested_cpu_list,
							stat_config.system_wide,
							&stat_config.metric_events) < 0)
				return -1;

			evlist__for_each_entry(metric_evlist, metric_evsel) {
				metric_evsel->skippable = true;
			}
			evlist__splice_list_tail(evsel_list, &metric_evlist->core.entries);
			evlist__delete(metric_evlist);
		}
1922

1923 1924
		/* Platform specific attrs */
		if (evlist__add_default_attrs(evsel_list, default_null_attrs) < 0)
1925
			return -1;
1926 1927 1928 1929 1930 1931 1932 1933
	}

	/* Detailed events get appended to the event list: */

	if (detailed_run <  1)
		return 0;

	/* Append detailed run extra attributes: */
1934
	if (evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
1935
		return -1;
1936 1937 1938 1939 1940

	if (detailed_run < 2)
		return 0;

	/* Append very detailed run extra attributes: */
1941
	if (evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
1942
		return -1;
1943 1944 1945 1946 1947

	if (detailed_run < 3)
		return 0;

	/* Append very, very detailed run extra attributes: */
1948
	return evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
1949 1950
}

1951
static const char * const stat_record_usage[] = {
1952 1953 1954 1955
	"perf stat record [<options>]",
	NULL,
};

1956 1957 1958 1959 1960 1961 1962
static void init_features(struct perf_session *session)
{
	int feat;

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

1963
	perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT);
1964 1965 1966 1967 1968 1969
	perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
	perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
	perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
	perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
}

1970 1971 1972
static int __cmd_record(int argc, const char **argv)
{
	struct perf_session *session;
1973
	struct perf_data *data = &perf_stat.data;
1974

1975
	argc = parse_options(argc, argv, stat_options, stat_record_usage,
1976 1977 1978
			     PARSE_OPT_STOP_AT_NON_OPTION);

	if (output_name)
1979
		data->path = output_name;
1980

1981
	if (stat_config.run_count != 1 || forever) {
1982 1983 1984 1985
		pr_err("Cannot use -r option with perf stat record.\n");
		return -1;
	}

1986
	session = perf_session__new(data, NULL);
1987 1988 1989
	if (IS_ERR(session)) {
		pr_err("Perf session creation failed\n");
		return PTR_ERR(session);
1990 1991
	}

1992 1993
	init_features(session);

1994 1995 1996 1997 1998 1999
	session->evlist   = evsel_list;
	perf_stat.session = session;
	perf_stat.record  = true;
	return argc;
}

2000 2001
static int process_stat_round_event(struct perf_session *session,
				    union perf_event *event)
2002
{
2003
	struct perf_record_stat_round *stat_round = &event->stat_round;
2004 2005 2006 2007
	struct timespec tsh, *ts = NULL;
	const char **argv = session->header.env.cmdline_argv;
	int argc = session->header.env.nr_cmdline;

2008
	process_counters();
2009

2010 2011
	if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL)
		update_stats(&walltime_nsecs_stats, stat_round->time);
2012

2013
	if (stat_config.interval && stat_round->time) {
2014 2015
		tsh.tv_sec  = stat_round->time / NSEC_PER_SEC;
		tsh.tv_nsec = stat_round->time % NSEC_PER_SEC;
2016 2017 2018 2019 2020 2021 2022
		ts = &tsh;
	}

	print_counters(ts, argc, argv);
	return 0;
}

2023
static
2024 2025
int process_stat_config_event(struct perf_session *session,
			      union perf_event *event)
2026
{
2027
	struct perf_tool *tool = session->tool;
2028 2029
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);

2030
	perf_event__read_stat_config(&stat_config, &event->stat_config);
2031

2032
	if (perf_cpu_map__empty(st->cpus)) {
2033 2034
		if (st->aggr_mode != AGGR_UNSET)
			pr_warning("warning: processing task data, aggregation mode not set\n");
2035
	} else if (st->aggr_mode != AGGR_UNSET) {
2036
		stat_config.aggr_mode = st->aggr_mode;
2037
	}
2038

2039
	if (perf_stat.data.is_pipe)
2040 2041 2042 2043
		perf_stat_init_aggr_mode();
	else
		perf_stat_init_aggr_mode_file(st);

2044 2045 2046 2047 2048 2049 2050 2051
	if (stat_config.aggr_map) {
		int nr_aggr = stat_config.aggr_map->nr;

		if (evlist__alloc_aggr_stats(session->evlist, nr_aggr) < 0) {
			pr_err("cannot allocate aggr counts\n");
			return -1;
		}
	}
2052 2053 2054
	return 0;
}

2055 2056 2057 2058 2059 2060 2061 2062
static int set_maps(struct perf_stat *st)
{
	if (!st->cpus || !st->threads)
		return 0;

	if (WARN_ONCE(st->maps_allocated, "stats double allocation\n"))
		return -EINVAL;

2063
	perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads);
2064

2065
	if (evlist__alloc_stats(&stat_config, evsel_list, /*alloc_raw=*/true))
2066 2067 2068 2069 2070 2071 2072
		return -ENOMEM;

	st->maps_allocated = true;
	return 0;
}

static
2073 2074
int process_thread_map_event(struct perf_session *session,
			     union perf_event *event)
2075
{
2076
	struct perf_tool *tool = session->tool;
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);

	if (st->threads) {
		pr_warning("Extra thread map event, ignoring.\n");
		return 0;
	}

	st->threads = thread_map__new_event(&event->thread_map);
	if (!st->threads)
		return -ENOMEM;

	return set_maps(st);
}

static
2092 2093
int process_cpu_map_event(struct perf_session *session,
			  union perf_event *event)
2094
{
2095
	struct perf_tool *tool = session->tool;
2096
	struct perf_stat *st = container_of(tool, struct perf_stat, tool);
2097
	struct perf_cpu_map *cpus;
2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111

	if (st->cpus) {
		pr_warning("Extra cpu map event, ignoring.\n");
		return 0;
	}

	cpus = cpu_map__new_data(&event->cpu_map.data);
	if (!cpus)
		return -ENOMEM;

	st->cpus = cpus;
	return set_maps(st);
}

2112
static const char * const stat_report_usage[] = {
2113 2114 2115 2116 2117 2118 2119
	"perf stat report [<options>]",
	NULL,
};

static struct perf_stat perf_stat = {
	.tool = {
		.attr		= perf_event__process_attr,
2120
		.event_update	= perf_event__process_event_update,
2121 2122
		.thread_map	= process_thread_map_event,
		.cpu_map	= process_cpu_map_event,
2123
		.stat_config	= process_stat_config_event,
2124 2125
		.stat		= perf_event__process_stat_event,
		.stat_round	= process_stat_round_event,
2126
	},
2127
	.aggr_mode = AGGR_UNSET,
2128 2129 2130 2131 2132 2133 2134
};

static int __cmd_report(int argc, const char **argv)
{
	struct perf_session *session;
	const struct option options[] = {
	OPT_STRING('i', "input", &input_name, "file", "input file name"),
2135 2136
	OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode,
		     "aggregate counts per processor socket", AGGR_SOCKET),
2137 2138
	OPT_SET_UINT(0, "per-die", &perf_stat.aggr_mode,
		     "aggregate counts per processor die", AGGR_DIE),
2139 2140
	OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode,
		     "aggregate counts per physical processor core", AGGR_CORE),
2141 2142
	OPT_SET_UINT(0, "per-node", &perf_stat.aggr_mode,
		     "aggregate counts per numa node", AGGR_NODE),
2143 2144
	OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode,
		     "disable CPU count aggregation", AGGR_NONE),
2145 2146 2147 2148 2149
	OPT_END()
	};
	struct stat st;
	int ret;

2150
	argc = parse_options(argc, argv, options, stat_report_usage, 0);
2151 2152 2153 2154 2155 2156 2157 2158

	if (!input_name || !strlen(input_name)) {
		if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
			input_name = "-";
		else
			input_name = "perf.data";
	}

2159 2160
	perf_stat.data.path = input_name;
	perf_stat.data.mode = PERF_DATA_MODE_READ;
2161

2162
	session = perf_session__new(&perf_stat.data, &perf_stat.tool);
2163 2164
	if (IS_ERR(session))
		return PTR_ERR(session);
2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177

	perf_stat.session  = session;
	stat_config.output = stderr;
	evsel_list         = session->evlist;

	ret = perf_session__process_events(session);
	if (ret)
		return ret;

	perf_session__delete(session);
	return 0;
}

2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194
static void setup_system_wide(int forks)
{
	/*
	 * Make system wide (-a) the default target if
	 * no target was specified and one of following
	 * conditions is met:
	 *
	 *   - there's no workload specified
	 *   - there is workload specified but all requested
	 *     events are system wide events
	 */
	if (!target__none(&target))
		return;

	if (!forks)
		target.system_wide = true;
	else {
2195
		struct evsel *counter;
2196 2197

		evlist__for_each_entry(evsel_list, counter) {
2198
			if (!counter->core.requires_cpu &&
2199
			    !evsel__name_is(counter, "duration_time")) {
2200
				return;
2201
			}
2202 2203
		}

2204
		if (evsel_list->core.nr_entries)
2205 2206 2207 2208
			target.system_wide = true;
	}
}

2209
int cmd_stat(int argc, const char **argv)
2210
{
2211 2212 2213 2214
	const char * const stat_usage[] = {
		"perf stat [<options>] [<command>]",
		NULL
	};
2215
	int status = -EINVAL, run_idx, err;
2216
	const char *mode;
2217
	FILE *output = stderr;
2218
	unsigned int interval, timeout;
2219
	const char * const stat_subcommands[] = { "record", "report" };
2220
	char errbuf[BUFSIZ];
2221

2222 2223
	setlocale(LC_ALL, "");

2224
	evsel_list = evlist__new();
2225 2226 2227
	if (evsel_list == NULL)
		return -ENOMEM;

2228
	parse_events__shrink_config_terms();
2229 2230 2231 2232 2233 2234

	/* String-parsing callback-based options would segfault when negated */
	set_option_flag(stat_options, 'e', "event", PARSE_OPT_NONEG);
	set_option_flag(stat_options, 'M', "metrics", PARSE_OPT_NONEG);
	set_option_flag(stat_options, 'G', "cgroup", PARSE_OPT_NONEG);

2235 2236 2237 2238
	argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
					(const char **) stat_usage,
					PARSE_OPT_STOP_AT_NON_OPTION);

2239 2240 2241 2242
	if (stat_config.csv_sep) {
		stat_config.csv_output = true;
		if (!strcmp(stat_config.csv_sep, "\\t"))
			stat_config.csv_sep = "\t";
2243
	} else
2244
		stat_config.csv_sep = DEFAULT_SEPARATOR;
2245

2246
	if (argc && strlen(argv[0]) > 2 && strstarts("record", argv[0])) {
2247 2248 2249
		argc = __cmd_record(argc, argv);
		if (argc < 0)
			return -1;
2250
	} else if (argc && strlen(argv[0]) > 2 && strstarts("report", argv[0]))
2251
		return __cmd_report(argc, argv);
2252

2253
	interval = stat_config.interval;
2254
	timeout = stat_config.timeout;
2255

2256 2257 2258 2259
	/*
	 * For record command the -o is already taken care of.
	 */
	if (!STAT_RECORD && output_name && strcmp(output_name, "-"))
2260 2261
		output = NULL;

2262 2263
	if (output_name && output_fd) {
		fprintf(stderr, "cannot use both --output and --log-fd\n");
2264 2265
		parse_options_usage(stat_usage, stat_options, "o", 1);
		parse_options_usage(NULL, stat_options, "log-fd", 0);
2266
		goto out;
2267
	}
2268

2269
	if (stat_config.metric_only && stat_config.aggr_mode == AGGR_THREAD) {
2270 2271 2272 2273
		fprintf(stderr, "--metric-only is not supported with --per-thread\n");
		goto out;
	}

2274
	if (stat_config.metric_only && stat_config.run_count > 1) {
2275 2276 2277 2278
		fprintf(stderr, "--metric-only is not supported with -r\n");
		goto out;
	}

2279
	if (stat_config.walltime_run_table && stat_config.run_count <= 1) {
2280 2281 2282 2283 2284 2285
		fprintf(stderr, "--table is only supported with -r\n");
		parse_options_usage(stat_usage, stat_options, "r", 1);
		parse_options_usage(NULL, stat_options, "table", 0);
		goto out;
	}

2286 2287
	if (output_fd < 0) {
		fprintf(stderr, "argument to --log-fd must be a > 0\n");
2288
		parse_options_usage(stat_usage, stat_options, "log-fd", 0);
2289
		goto out;
2290 2291
	}

2292
	if (!output && !quiet) {
2293 2294 2295 2296 2297 2298
		struct timespec tm;
		mode = append_file ? "a" : "w";

		output = fopen(output_name, mode);
		if (!output) {
			perror("failed to create output file");
2299
			return -1;
2300
		}
2301 2302 2303 2304
		if (!stat_config.json_output) {
			clock_gettime(CLOCK_REALTIME, &tm);
			fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
		}
2305
	} else if (output_fd > 0) {
2306 2307 2308 2309 2310 2311
		mode = append_file ? "a" : "w";
		output = fdopen(output_fd, mode);
		if (!output) {
			perror("Failed opening logfd");
			return -errno;
		}
2312 2313
	}

2314 2315 2316 2317 2318 2319 2320 2321
	if (stat_config.interval_clear && !isatty(fileno(output))) {
		fprintf(stderr, "--interval-clear does not work with output\n");
		parse_options_usage(stat_usage, stat_options, "o", 1);
		parse_options_usage(NULL, stat_options, "log-fd", 0);
		parse_options_usage(NULL, stat_options, "interval-clear", 0);
		return -1;
	}

2322 2323
	stat_config.output = output;

2324 2325 2326
	/*
	 * let the spreadsheet do the pretty-printing
	 */
2327
	if (stat_config.csv_output) {
2328
		/* User explicitly passed -B? */
2329 2330
		if (big_num_opt == 1) {
			fprintf(stderr, "-B option not supported with -x\n");
2331 2332
			parse_options_usage(stat_usage, stat_options, "B", 1);
			parse_options_usage(NULL, stat_options, "x", 1);
2333
			goto out;
2334
		} else /* Nope, so disable big number formatting */
2335
			stat_config.big_num = false;
2336
	} else if (big_num_opt == 0) /* User passed --no-big-num */
2337
		stat_config.big_num = false;
2338

2339 2340 2341 2342 2343 2344
	err = target__validate(&target);
	if (err) {
		target__strerror(&target, err, errbuf, BUFSIZ);
		pr_warning("%s\n", errbuf);
	}

2345
	setup_system_wide(argc);
2346

2347 2348 2349 2350
	/*
	 * Display user/system times only for single
	 * run and when there's specified tracee.
	 */
2351
	if ((stat_config.run_count == 1) && target__none(&target))
2352
		stat_config.ru_display = true;
2353

2354
	if (stat_config.run_count < 0) {
2355
		pr_err("Run count must be a positive number\n");
2356
		parse_options_usage(stat_usage, stat_options, "r", 1);
2357
		goto out;
2358
	} else if (stat_config.run_count == 0) {
2359
		forever = true;
2360
		stat_config.run_count = 1;
2361
	}
2362

2363 2364 2365
	if (stat_config.walltime_run_table) {
		stat_config.walltime_run = zalloc(stat_config.run_count * sizeof(stat_config.walltime_run[0]));
		if (!stat_config.walltime_run) {
2366 2367 2368 2369 2370
			pr_err("failed to setup -r option");
			goto out;
		}
	}

2371 2372 2373 2374 2375 2376 2377 2378 2379 2380
	if ((stat_config.aggr_mode == AGGR_THREAD) &&
		!target__has_task(&target)) {
		if (!target.system_wide || target.cpu_list) {
			fprintf(stderr, "The --per-thread option is only "
				"available when monitoring via -p -t -a "
				"options or only --per-thread.\n");
			parse_options_usage(NULL, stat_options, "p", 1);
			parse_options_usage(NULL, stat_options, "t", 1);
			goto out;
		}
2381 2382 2383 2384 2385 2386
	}

	/*
	 * no_aggr, cgroup are for system-wide only
	 * --per-thread is aggregated per thread, we dont mix it with cpu mode
	 */
2387
	if (((stat_config.aggr_mode != AGGR_GLOBAL &&
2388 2389
	      stat_config.aggr_mode != AGGR_THREAD) ||
	     (nr_cgroups || stat_config.cgroup_list)) &&
2390
	    !target__has_cpu(&target)) {
2391 2392 2393
		fprintf(stderr, "both cgroup and no-aggregation "
			"modes only available in system-wide mode\n");

2394 2395 2396
		parse_options_usage(stat_usage, stat_options, "G", 1);
		parse_options_usage(NULL, stat_options, "A", 1);
		parse_options_usage(NULL, stat_options, "a", 1);
2397
		parse_options_usage(NULL, stat_options, "for-each-cgroup", 0);
2398
		goto out;
2399 2400
	}

2401 2402 2403 2404 2405 2406 2407
	if (stat_config.iostat_run) {
		status = iostat_prepare(evsel_list, &stat_config);
		if (status)
			goto out;
		if (iostat_mode == IOSTAT_LIST) {
			iostat_list(evsel_list, &stat_config);
			goto out;
2408
		} else if (verbose > 0)
2409
			iostat_list(evsel_list, &stat_config);
2410 2411
		if (iostat_mode == IOSTAT_RUN && !target__has_cpu(&target))
			target.system_wide = true;
2412 2413
	}

2414 2415 2416
	if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide))
		target.per_thread = true;

2417 2418 2419 2420 2421 2422 2423 2424 2425
	stat_config.system_wide = target.system_wide;
	if (target.cpu_list) {
		stat_config.user_requested_cpu_list = strdup(target.cpu_list);
		if (!stat_config.user_requested_cpu_list) {
			status = -ENOMEM;
			goto out;
		}
	}

2426 2427 2428 2429 2430 2431 2432 2433
	/*
	 * Metric parsing needs to be delayed as metrics may optimize events
	 * knowing the target is system-wide.
	 */
	if (metrics) {
		metricgroup__parse_groups(evsel_list, metrics,
					stat_config.metric_no_group,
					stat_config.metric_no_merge,
2434
					stat_config.metric_no_threshold,
2435 2436
					stat_config.user_requested_cpu_list,
					stat_config.system_wide,
2437 2438 2439 2440
					&stat_config.metric_events);
		zfree(&metrics);
	}

2441 2442
	if (add_default_attributes())
		goto out;
2443

2444 2445 2446 2447 2448 2449 2450 2451
	if (stat_config.cgroup_list) {
		if (nr_cgroups > 0) {
			pr_err("--cgroup and --for-each-cgroup cannot be used together\n");
			parse_options_usage(stat_usage, stat_options, "G", 1);
			parse_options_usage(NULL, stat_options, "for-each-cgroup", 0);
			goto out;
		}

2452
		if (evlist__expand_cgroup(evsel_list, stat_config.cgroup_list,
2453 2454 2455
					  &stat_config.metric_events, true) < 0) {
			parse_options_usage(stat_usage, stat_options,
					    "for-each-cgroup", 0);
2456
			goto out;
2457
		}
2458 2459
	}

2460 2461 2462 2463 2464 2465
	if (evlist__fix_hybrid_cpus(evsel_list, target.cpu_list)) {
		pr_err("failed to use cpu list %s\n", target.cpu_list);
		goto out;
	}

	target.hybrid = perf_pmu__has_hybrid();
2466
	if (evlist__create_maps(evsel_list, &target) < 0) {
2467
		if (target__has_task(&target)) {
2468
			pr_err("Problems finding threads of monitor\n");
2469 2470
			parse_options_usage(stat_usage, stat_options, "p", 1);
			parse_options_usage(NULL, stat_options, "t", 1);
2471
		} else if (target__has_cpu(&target)) {
2472
			perror("failed to parse CPUs map");
2473 2474
			parse_options_usage(stat_usage, stat_options, "C", 1);
			parse_options_usage(NULL, stat_options, "a", 1);
2475 2476
		}
		goto out;
2477
	}
2478

2479 2480
	evlist__check_cpu_maps(evsel_list);

2481 2482 2483 2484
	/*
	 * Initialize thread_map with comm names,
	 * so we could print it out on output.
	 */
2485
	if (stat_config.aggr_mode == AGGR_THREAD) {
2486
		thread_map__read_comms(evsel_list->core.threads);
2487
	}
2488

2489 2490 2491
	if (stat_config.aggr_mode == AGGR_NODE)
		cpu__setup_cpunode_map();

2492 2493 2494 2495 2496 2497 2498 2499 2500
	if (stat_config.times && interval)
		interval_count = true;
	else if (stat_config.times && !interval) {
		pr_err("interval-count option should be used together with "
				"interval-print.\n");
		parse_options_usage(stat_usage, stat_options, "interval-count", 0);
		parse_options_usage(stat_usage, stat_options, "I", 1);
		goto out;
	}
2501

2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
	if (timeout && timeout < 100) {
		if (timeout < 10) {
			pr_err("timeout must be >= 10ms.\n");
			parse_options_usage(stat_usage, stat_options, "timeout", 0);
			goto out;
		} else
			pr_warning("timeout < 100ms. "
				   "The overhead percentage could be high in some cases. "
				   "Please proceed with caution.\n");
	}
	if (timeout && interval) {
		pr_err("timeout option is not supported with interval-print.\n");
		parse_options_usage(stat_usage, stat_options, "timeout", 0);
		parse_options_usage(stat_usage, stat_options, "I", 1);
		goto out;
	}

2519
	if (perf_stat_init_aggr_mode())
2520
		goto out;
2521

2522
	if (evlist__alloc_stats(&stat_config, evsel_list, interval))
2523
		goto out;
2524

2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
	/*
	 * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
	 * while avoiding that older tools show confusing messages.
	 *
	 * However for pipe sessions we need to keep it zero,
	 * because script's perf_evsel__check_attr is triggered
	 * by attr->sample_type != 0, and we can't run it on
	 * stat sessions.
	 */
	stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe);

Ingo Molnar's avatar
Ingo Molnar committed
2536 2537 2538 2539 2540 2541
	/*
	 * We dont want to block the signals - that would cause
	 * child tasks to inherit that and Ctrl-C would not work.
	 * What we want is for Ctrl-C to work in the exec()-ed
	 * task, but being ignored by perf stat itself:
	 */
2542
	atexit(sig_atexit);
2543 2544
	if (!forever)
		signal(SIGINT,  skip_signal);
2545
	signal(SIGCHLD, skip_signal);
Ingo Molnar's avatar
Ingo Molnar committed
2546 2547 2548
	signal(SIGALRM, skip_signal);
	signal(SIGABRT, skip_signal);

2549 2550 2551
	if (evlist__initialize_ctlfd(evsel_list, stat_config.ctl_fd, stat_config.ctl_fd_ack))
		goto out;

2552 2553
	/* Enable ignoring missing threads when -p option is defined. */
	evlist__first(evsel_list)->ignore_missing_thread = target.pid;
2554
	status = 0;
2555 2556
	for (run_idx = 0; forever || run_idx < stat_config.run_count; run_idx++) {
		if (stat_config.run_count != 1 && verbose > 0)
2557 2558
			fprintf(output, "[ perf stat: executing run #%d ... ]\n",
				run_idx + 1);
2559

2560
		if (run_idx != 0)
2561
			evlist__reset_prev_raw_counts(evsel_list);
2562

2563
		status = run_perf_stat(argc, argv, run_idx);
2564
		if (forever && status != -1 && !interval) {
2565
			print_counters(NULL, argc, argv);
2566
			perf_stat__reset_stats();
2567
		}
2568 2569
	}

2570
	if (!forever && status != -1 && (!interval || stat_config.summary))
2571
		print_counters(NULL, argc, argv);
2572

2573 2574
	evlist__finalize_ctlfd(evsel_list);

2575 2576 2577 2578
	if (STAT_RECORD) {
		/*
		 * We synthesize the kernel mmap record just so that older tools
		 * don't emit warnings about not being able to resolve symbols
2579
		 * due to /proc/sys/kernel/kptr_restrict settings and instead provide
2580 2581 2582
		 * a saner message about no samples being in the perf.data file.
		 *
		 * This also serves to suppress a warning about f_header.data.size == 0
2583 2584 2585 2586
		 * in header.c at the moment 'perf stat record' gets introduced, which
		 * is not really needed once we start adding the stat specific PERF_RECORD_
		 * records, but the need to suppress the kptr_restrict messages in older
		 * tools remain  -acme
2587
		 */
2588
		int fd = perf_data__fd(&perf_stat.data);
2589 2590 2591 2592

		err = perf_event__synthesize_kernel_mmap((void *)&perf_stat,
							 process_synthesized_event,
							 &perf_stat.session->machines.host);
2593 2594 2595 2596 2597
		if (err) {
			pr_warning("Couldn't synthesize the kernel mmap record, harmless, "
				   "older tools may produce warnings about this file\n.");
		}

2598 2599 2600 2601 2602
		if (!interval) {
			if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL))
				pr_err("failed to write stat round event\n");
		}

2603
		if (!perf_stat.data.is_pipe) {
2604 2605 2606
			perf_stat.session->header.data_size += perf_stat.bytes_written;
			perf_session__write_header(perf_stat.session, evsel_list, fd, true);
		}
2607

2608
		evlist__close(evsel_list);
2609 2610 2611
		perf_session__delete(perf_stat.session);
	}

2612
	perf_stat__exit_aggr_mode();
2613
	evlist__free_stats(evsel_list);
2614
out:
2615 2616 2617
	if (stat_config.iostat_run)
		iostat_release(evsel_list);

2618
	zfree(&stat_config.walltime_run);
2619
	zfree(&stat_config.user_requested_cpu_list);
2620

2621 2622 2623
	if (smi_cost && smi_reset)
		sysfs__write_int(FREEZE_ON_SMI_PATH, 0);

2624
	evlist__delete(evsel_list);
2625

2626
	metricgroup__rblist_exit(&stat_config.metric_events);
2627
	evlist__close_control(stat_config.ctl_fd, stat_config.ctl_fd_ack, &stat_config.ctl_fd_close);
2628

2629
	return status;
2630
}