1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * builtin-stat.c
   4 *
   5 * Builtin stat command: Give a precise performance counters summary
   6 * overview about any workload, CPU or specific PID.
   7 *
   8 * Sample output:
   9
  10   $ perf stat ./hackbench 10
  11
  12  Time: 0.118
  13
  14  Performance counter stats for './hackbench 10':
  15
  16       1708.761321 task-clock                #   11.037 CPUs utilized
  17            41,190 context-switches          #    0.024 M/sec
  18             6,735 CPU-migrations            #    0.004 M/sec
  19            17,318 page-faults               #    0.010 M/sec
  20     5,205,202,243 cycles                    #    3.046 GHz
  21     3,856,436,920 stalled-cycles-frontend   #   74.09% frontend cycles idle
  22     1,600,790,871 stalled-cycles-backend    #   30.75% backend  cycles idle
  23     2,603,501,247 instructions              #    0.50  insns per cycle
  24                                             #    1.48  stalled cycles per insn
  25       484,357,498 branches                  #  283.455 M/sec
  26         6,388,934 branch-misses             #    1.32% of all branches
  27
  28        0.154822978  seconds time elapsed
  29
  30 *
  31 * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
  32 *
  33 * Improvements and fixes by:
  34 *
  35 *   Arjan van de Ven <arjan@linux.intel.com>
  36 *   Yanmin Zhang <yanmin.zhang@intel.com>
  37 *   Wu Fengguang <fengguang.wu@intel.com>
  38 *   Mike Galbraith <efault@gmx.de>
  39 *   Paul Mackerras <paulus@samba.org>
  40 *   Jaswinder Singh Rajput <jaswinder@kernel.org>
  41 */
  42
  43#include "builtin.h"
  44#include "perf.h"
  45#include "util/cgroup.h"
  46#include <subcmd/parse-options.h>
  47#include "util/parse-events.h"
  48#include "util/pmu.h"
  49#include "util/event.h"
  50#include "util/evlist.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/group.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 "asm/bug.h"
  69
  70#include <linux/time64.h>
  71#include <linux/zalloc.h>
  72#include <api/fs/fs.h>
  73#include <errno.h>
  74#include <signal.h>
  75#include <stdlib.h>
  76#include <sys/prctl.h>
  77#include <inttypes.h>
  78#include <locale.h>
  79#include <math.h>
  80#include <sys/types.h>
  81#include <sys/stat.h>
  82#include <sys/wait.h>
  83#include <unistd.h>
  84#include <sys/time.h>
  85#include <sys/resource.h>
  86#include <linux/err.h>
  87
  88#include <linux/ctype.h>
  89#include <perf/evlist.h>
  90
  91#define DEFAULT_SEPARATOR	" "
  92#define FREEZE_ON_SMI_PATH	"devices/cpu/freeze_on_smi"
  93
  94static void print_counters(struct timespec *ts, int argc, const char **argv);
  95
  96/* Default events used for perf stat -T */
  97static const char *transaction_attrs = {
  98	"task-clock,"
  99	"{"
 100	"instructions,"
 101	"cycles,"
 102	"cpu/cycles-t/,"
 103	"cpu/tx-start/,"
 104	"cpu/el-start/,"
 105	"cpu/cycles-ct/"
 106	"}"
 107};
 108
 109/* More limited version when the CPU does not have all events. */
 110static const char * transaction_limited_attrs = {
 111	"task-clock,"
 112	"{"
 113	"instructions,"
 114	"cycles,"
 115	"cpu/cycles-t/,"
 116	"cpu/tx-start/"
 117	"}"
 118};
 119
 120static const char * topdown_attrs[] = {
 121	"topdown-total-slots",
 122	"topdown-slots-retired",
 123	"topdown-recovery-bubbles",
 124	"topdown-fetch-bubbles",
 125	"topdown-slots-issued",
 126	NULL,
 127};
 128
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 129static const char *smi_cost_attrs = {
 130	"{"
 131	"msr/aperf/,"
 132	"msr/smi/,"
 133	"cycles"
 134	"}"
 135};
 136
 137static struct evlist	*evsel_list;
 
 138
 139static struct target target = {
 140	.uid	= UINT_MAX,
 141};
 142
 143#define METRIC_ONLY_LEN 20
 144
 145static volatile pid_t		child_pid			= -1;
 146static int			detailed_run			=  0;
 147static bool			transaction_run;
 148static bool			topdown_run			= false;
 149static bool			smi_cost			= false;
 150static bool			smi_reset			= false;
 151static int			big_num_opt			=  -1;
 152static bool			group				= false;
 153static const char		*pre_cmd			= NULL;
 154static const char		*post_cmd			= NULL;
 155static bool			sync_run			= false;
 156static bool			forever				= false;
 157static bool			force_metric_only		= false;
 158static struct timespec		ref_time;
 159static bool			append_file;
 160static bool			interval_count;
 161static const char		*output_name;
 162static int			output_fd;
 163
 164struct perf_stat {
 165	bool			 record;
 166	struct perf_data	 data;
 167	struct perf_session	*session;
 168	u64			 bytes_written;
 169	struct perf_tool	 tool;
 170	bool			 maps_allocated;
 171	struct perf_cpu_map	*cpus;
 172	struct perf_thread_map *threads;
 173	enum aggr_mode		 aggr_mode;
 174};
 175
 176static struct perf_stat		perf_stat;
 177#define STAT_RECORD		perf_stat.record
 178
 179static volatile int done = 0;
 180
 181static struct perf_stat_config stat_config = {
 182	.aggr_mode		= AGGR_GLOBAL,
 183	.scale			= true,
 184	.unit_width		= 4, /* strlen("unit") */
 185	.run_count		= 1,
 186	.metric_only_len	= METRIC_ONLY_LEN,
 187	.walltime_nsecs_stats	= &walltime_nsecs_stats,
 188	.big_num		= true,
 
 
 
 189};
 190
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 191static inline void diff_timespec(struct timespec *r, struct timespec *a,
 192				 struct timespec *b)
 193{
 194	r->tv_sec = a->tv_sec - b->tv_sec;
 195	if (a->tv_nsec < b->tv_nsec) {
 196		r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec;
 197		r->tv_sec--;
 198	} else {
 199		r->tv_nsec = a->tv_nsec - b->tv_nsec ;
 200	}
 201}
 202
 203static void perf_stat__reset_stats(void)
 204{
 205	int i;
 206
 207	perf_evlist__reset_stats(evsel_list);
 208	perf_stat__reset_shadow_stats();
 209
 210	for (i = 0; i < stat_config.stats_num; i++)
 211		perf_stat__reset_shadow_per_stat(&stat_config.stats[i]);
 212}
 213
 214static int process_synthesized_event(struct perf_tool *tool __maybe_unused,
 215				     union perf_event *event,
 216				     struct perf_sample *sample __maybe_unused,
 217				     struct machine *machine __maybe_unused)
 218{
 219	if (perf_data__write(&perf_stat.data, event, event->header.size) < 0) {
 220		pr_err("failed to write perf data, error: %m\n");
 221		return -1;
 222	}
 223
 224	perf_stat.bytes_written += event->header.size;
 225	return 0;
 226}
 227
 228static int write_stat_round_event(u64 tm, u64 type)
 229{
 230	return perf_event__synthesize_stat_round(NULL, tm, type,
 231						 process_synthesized_event,
 232						 NULL);
 233}
 234
 235#define WRITE_STAT_ROUND_EVENT(time, interval) \
 236	write_stat_round_event(time, PERF_STAT_ROUND_TYPE__ ## interval)
 237
 238#define SID(e, x, y) xyarray__entry(e->core.sample_id, x, y)
 239
 240static int
 241perf_evsel__write_stat_event(struct evsel *counter, u32 cpu, u32 thread,
 242			     struct perf_counts_values *count)
 243{
 244	struct perf_sample_id *sid = SID(counter, cpu, thread);
 245
 246	return perf_event__synthesize_stat(NULL, cpu, thread, sid->id, count,
 247					   process_synthesized_event, NULL);
 248}
 249
 250static int read_single_counter(struct evsel *counter, int cpu,
 251			       int thread, struct timespec *rs)
 252{
 253	if (counter->tool_event == PERF_TOOL_DURATION_TIME) {
 254		u64 val = rs->tv_nsec + rs->tv_sec*1000000000ULL;
 255		struct perf_counts_values *count =
 256			perf_counts(counter->counts, cpu, thread);
 257		count->ena = count->run = val;
 258		count->val = val;
 259		return 0;
 260	}
 261	return perf_evsel__read_counter(counter, cpu, thread);
 262}
 263
 264/*
 265 * Read out the results of a single counter:
 266 * do not aggregate counts across CPUs in system-wide mode
 267 */
 268static int read_counter(struct evsel *counter, struct timespec *rs)
 269{
 270	int nthreads = perf_thread_map__nr(evsel_list->core.threads);
 271	int ncpus, cpu, thread;
 272
 273	if (target__has_cpu(&target) && !target__has_per_thread(&target))
 274		ncpus = perf_evsel__nr_cpus(counter);
 275	else
 276		ncpus = 1;
 277
 278	if (!counter->supported)
 279		return -ENOENT;
 280
 281	if (counter->core.system_wide)
 282		nthreads = 1;
 283
 284	for (thread = 0; thread < nthreads; thread++) {
 285		for (cpu = 0; cpu < ncpus; cpu++) {
 286			struct perf_counts_values *count;
 287
 288			count = perf_counts(counter->counts, cpu, thread);
 289
 290			/*
 291			 * The leader's group read loads data into its group members
 292			 * (via perf_evsel__read_counter) and sets threir count->loaded.
 293			 */
 294			if (!perf_counts__is_loaded(counter->counts, cpu, thread) &&
 295			    read_single_counter(counter, cpu, thread, rs)) {
 296				counter->counts->scaled = -1;
 297				perf_counts(counter->counts, cpu, thread)->ena = 0;
 298				perf_counts(counter->counts, cpu, thread)->run = 0;
 
 
 
 
 
 
 
 
 299				return -1;
 300			}
 
 
 
 
 
 
 
 
 
 
 301
 302			perf_counts__set_loaded(counter->counts, cpu, thread, false);
 
 303
 304			if (STAT_RECORD) {
 305				if (perf_evsel__write_stat_event(counter, cpu, thread, count)) {
 306					pr_err("failed to write stat event\n");
 307					return -1;
 308				}
 309			}
 310
 311			if (verbose > 1) {
 312				fprintf(stat_config.output,
 313					"%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
 314						perf_evsel__name(counter),
 315						cpu,
 316						count->val, count->ena, count->run);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 317			}
 318		}
 319	}
 
 
 
 320
 
 
 
 
 
 
 
 
 
 
 
 
 
 321	return 0;
 322}
 323
 324static void read_counters(struct timespec *rs)
 325{
 326	struct evsel *counter;
 327	int ret;
 
 
 
 
 
 328
 329	evlist__for_each_entry(evsel_list, counter) {
 330		ret = read_counter(counter, rs);
 331		if (ret)
 332			pr_debug("failed to read counter %s\n", counter->name);
 333
 334		if (ret == 0 && perf_stat_process_counter(&stat_config, counter))
 335			pr_warning("failed to process counter %s\n", counter->name);
 
 336	}
 337}
 338
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 339static void process_interval(void)
 340{
 341	struct timespec ts, rs;
 342
 343	clock_gettime(CLOCK_MONOTONIC, &ts);
 344	diff_timespec(&rs, &ts, &ref_time);
 345
 
 
 346	read_counters(&rs);
 347
 348	if (STAT_RECORD) {
 349		if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL))
 350			pr_err("failed to write stat round event\n");
 351	}
 352
 353	init_stats(&walltime_nsecs_stats);
 354	update_stats(&walltime_nsecs_stats, stat_config.interval * 1000000);
 355	print_counters(&rs, 0, NULL);
 356}
 357
 358static void enable_counters(void)
 
 
 
 
 
 
 
 
 
 
 359{
 360	if (stat_config.initial_delay)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 361		usleep(stat_config.initial_delay * USEC_PER_MSEC);
 
 362
 363	/*
 364	 * We need to enable counters only if:
 365	 * - we don't have tracee (attaching to task or cpu)
 366	 * - we have initial delay configured
 367	 */
 368	if (!target__none(&target) || stat_config.initial_delay)
 369		evlist__enable(evsel_list);
 
 
 
 
 
 370}
 371
 372static void disable_counters(void)
 373{
 
 
 374	/*
 375	 * If we don't have tracee (attaching to task or cpu), counters may
 376	 * still be running. To get accurate group ratios, we must stop groups
 377	 * from counting before reading their constituent counters.
 378	 */
 379	if (!target__none(&target))
 380		evlist__disable(evsel_list);
 
 
 
 
 381}
 382
 383static volatile int workload_exec_errno;
 384
 385/*
 386 * perf_evlist__prepare_workload will send a SIGUSR1
 387 * if the fork fails, since we asked by setting its
 388 * want_signal to true.
 389 */
 390static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info,
 391					void *ucontext __maybe_unused)
 392{
 393	workload_exec_errno = info->si_value.sival_int;
 394}
 395
 396static bool perf_evsel__should_store_id(struct evsel *counter)
 397{
 398	return STAT_RECORD || counter->core.attr.read_format & PERF_FORMAT_ID;
 399}
 400
 401static bool is_target_alive(struct target *_target,
 402			    struct perf_thread_map *threads)
 403{
 404	struct stat st;
 405	int i;
 406
 407	if (!target__has_task(_target))
 408		return true;
 409
 410	for (i = 0; i < threads->nr; i++) {
 411		char path[PATH_MAX];
 412
 413		scnprintf(path, PATH_MAX, "%s/%d", procfs__mountpoint(),
 414			  threads->map[i].pid);
 415
 416		if (!stat(path, &st))
 417			return true;
 418	}
 419
 420	return false;
 421}
 422
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 423static int __run_perf_stat(int argc, const char **argv, int run_idx)
 424{
 425	int interval = stat_config.interval;
 426	int times = stat_config.times;
 427	int timeout = stat_config.timeout;
 428	char msg[BUFSIZ];
 429	unsigned long long t0, t1;
 430	struct evsel *counter;
 431	struct timespec ts;
 432	size_t l;
 433	int status = 0;
 434	const bool forks = (argc > 0);
 435	bool is_pipe = STAT_RECORD ? perf_stat.data.is_pipe : false;
 436
 437	if (interval) {
 438		ts.tv_sec  = interval / USEC_PER_MSEC;
 439		ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC;
 440	} else if (timeout) {
 441		ts.tv_sec  = timeout / USEC_PER_MSEC;
 442		ts.tv_nsec = (timeout % USEC_PER_MSEC) * NSEC_PER_MSEC;
 443	} else {
 444		ts.tv_sec  = 1;
 445		ts.tv_nsec = 0;
 446	}
 447
 448	if (forks) {
 449		if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe,
 450						  workload_exec_failed_signal) < 0) {
 451			perror("failed to prepare workload");
 452			return -1;
 453		}
 454		child_pid = evsel_list->workload.pid;
 455	}
 456
 457	if (group)
 458		perf_evlist__set_leader(evsel_list);
 
 
 
 459
 460	evlist__for_each_entry(evsel_list, counter) {
 461try_again:
 462		if (create_perf_stat_counter(counter, &stat_config, &target) < 0) {
 
 
 
 463
 464			/* Weak group failed. Reset the group. */
 465			if ((errno == EINVAL || errno == EBADF) &&
 466			    counter->leader != counter &&
 467			    counter->weak_group) {
 468				counter = perf_evlist__reset_weak_group(evsel_list, counter);
 469				goto try_again;
 470			}
 
 471
 472			/*
 473			 * PPC returns ENXIO for HW counters until 2.6.37
 474			 * (behavior changed with commit b0a873e).
 475			 */
 476			if (errno == EINVAL || errno == ENOSYS ||
 477			    errno == ENOENT || errno == EOPNOTSUPP ||
 478			    errno == ENXIO) {
 479				if (verbose > 0)
 480					ui__warning("%s event is not supported by the kernel.\n",
 481						    perf_evsel__name(counter));
 482				counter->supported = false;
 483
 484				if ((counter->leader != counter) ||
 485				    !(counter->leader->core.nr_members > 1))
 486					continue;
 487			} else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) {
 488                                if (verbose > 0)
 489                                        ui__warning("%s\n", msg);
 490                                goto try_again;
 491			} else if (target__has_per_thread(&target) &&
 492				   evsel_list->core.threads &&
 493				   evsel_list->core.threads->err_thread != -1) {
 494				/*
 495				 * For global --per-thread case, skip current
 496				 * error thread.
 
 
 
 497				 */
 498				if (!thread_map__remove(evsel_list->core.threads,
 499							evsel_list->core.threads->err_thread)) {
 500					evsel_list->core.threads->err_thread = -1;
 
 
 
 
 
 
 
 
 
 
 501					goto try_again;
 
 
 
 
 502				}
 
 503			}
 
 
 
 504
 505			perf_evsel__open_strerror(counter, &target,
 506						  errno, msg, sizeof(msg));
 507			ui__error("%s\n", msg);
 
 
 508
 509			if (child_pid != -1)
 510				kill(child_pid, SIGTERM);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 511
 512			return -1;
 
 
 
 513		}
 514		counter->supported = true;
 515
 516		l = strlen(counter->unit);
 517		if (l > stat_config.unit_width)
 518			stat_config.unit_width = l;
 519
 520		if (perf_evsel__should_store_id(counter) &&
 521		    perf_evsel__store_ids(counter, evsel_list))
 522			return -1;
 523	}
 524
 525	if (perf_evlist__apply_filters(evsel_list, &counter)) {
 526		pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
 527			counter->filter, perf_evsel__name(counter), errno,
 528			str_error_r(errno, msg, sizeof(msg)));
 529		return -1;
 530	}
 531
 532	if (STAT_RECORD) {
 533		int err, fd = perf_data__fd(&perf_stat.data);
 534
 535		if (is_pipe) {
 536			err = perf_header__write_pipe(perf_data__fd(&perf_stat.data));
 537		} else {
 538			err = perf_session__write_header(perf_stat.session, evsel_list,
 539							 fd, false);
 540		}
 541
 542		if (err < 0)
 543			return err;
 544
 545		err = perf_event__synthesize_stat_events(&stat_config, NULL, evsel_list,
 546							 process_synthesized_event, is_pipe);
 547		if (err < 0)
 548			return err;
 549	}
 550
 551	/*
 552	 * Enable counters and exec the command:
 553	 */
 554	t0 = rdclock();
 555	clock_gettime(CLOCK_MONOTONIC, &ref_time);
 556
 557	if (forks) {
 558		perf_evlist__start_workload(evsel_list);
 559		enable_counters();
 
 
 560
 561		if (interval || timeout) {
 562			while (!waitpid(child_pid, &status, WNOHANG)) {
 563				nanosleep(&ts, NULL);
 564				if (timeout)
 565					break;
 566				process_interval();
 567				if (interval_count && !(--times))
 568					break;
 569			}
 570		}
 571		if (child_pid != -1)
 572			wait4(child_pid, &status, 0, &stat_config.ru_data);
 
 573
 574		if (workload_exec_errno) {
 575			const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
 576			pr_err("Workload failed: %s\n", emsg);
 577			return -1;
 578		}
 579
 580		if (WIFSIGNALED(status))
 581			psignal(WTERMSIG(status), argv[0]);
 582	} else {
 583		enable_counters();
 584		while (!done) {
 585			nanosleep(&ts, NULL);
 586			if (!is_target_alive(&target, evsel_list->core.threads))
 587				break;
 588			if (timeout)
 589				break;
 590			if (interval) {
 591				process_interval();
 592				if (interval_count && !(--times))
 593					break;
 594			}
 595		}
 596	}
 597
 598	disable_counters();
 599
 600	t1 = rdclock();
 601
 602	if (stat_config.walltime_run_table)
 603		stat_config.walltime_run[run_idx] = t1 - t0;
 604
 605	update_stats(&walltime_nsecs_stats, t1 - t0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 606
 607	/*
 608	 * Closing a group leader splits the group, and as we only disable
 609	 * group leaders, results in remaining events becoming enabled. To
 610	 * avoid arbitrary skew, we must read all counters before closing any
 611	 * group leaders.
 612	 */
 613	read_counters(&(struct timespec) { .tv_nsec = t1-t0 });
 614
 615	/*
 616	 * We need to keep evsel_list alive, because it's processed
 617	 * later the evsel_list will be closed after.
 618	 */
 619	if (!STAT_RECORD)
 620		evlist__close(evsel_list);
 621
 622	return WEXITSTATUS(status);
 623}
 624
 625static int run_perf_stat(int argc, const char **argv, int run_idx)
 626{
 627	int ret;
 628
 629	if (pre_cmd) {
 630		ret = system(pre_cmd);
 631		if (ret)
 632			return ret;
 633	}
 634
 635	if (sync_run)
 636		sync();
 637
 638	ret = __run_perf_stat(argc, argv, run_idx);
 639	if (ret)
 640		return ret;
 641
 642	if (post_cmd) {
 643		ret = system(post_cmd);
 644		if (ret)
 645			return ret;
 646	}
 647
 648	return ret;
 649}
 650
 651static void print_counters(struct timespec *ts, int argc, const char **argv)
 652{
 653	/* Do not print anything if we record to the pipe. */
 654	if (STAT_RECORD && perf_stat.data.is_pipe)
 655		return;
 
 
 656
 657	perf_evlist__print_counters(evsel_list, &stat_config, &target,
 658				    ts, argc, argv);
 659}
 660
 661static volatile int signr = -1;
 662
 663static void skip_signal(int signo)
 664{
 665	if ((child_pid == -1) || stat_config.interval)
 666		done = 1;
 667
 668	signr = signo;
 669	/*
 670	 * render child_pid harmless
 671	 * won't send SIGTERM to a random
 672	 * process in case of race condition
 673	 * and fast PID recycling
 674	 */
 675	child_pid = -1;
 676}
 677
 678static void sig_atexit(void)
 679{
 680	sigset_t set, oset;
 681
 682	/*
 683	 * avoid race condition with SIGCHLD handler
 684	 * in skip_signal() which is modifying child_pid
 685	 * goal is to avoid send SIGTERM to a random
 686	 * process
 687	 */
 688	sigemptyset(&set);
 689	sigaddset(&set, SIGCHLD);
 690	sigprocmask(SIG_BLOCK, &set, &oset);
 691
 692	if (child_pid != -1)
 693		kill(child_pid, SIGTERM);
 694
 695	sigprocmask(SIG_SETMASK, &oset, NULL);
 696
 697	if (signr == -1)
 698		return;
 699
 700	signal(signr, SIG_DFL);
 701	kill(getpid(), signr);
 702}
 703
 
 
 
 
 
 
 
 
 
 
 704static int stat__set_big_num(const struct option *opt __maybe_unused,
 705			     const char *s __maybe_unused, int unset)
 706{
 707	big_num_opt = unset ? 0 : 1;
 
 708	return 0;
 709}
 710
 711static int enable_metric_only(const struct option *opt __maybe_unused,
 712			      const char *s __maybe_unused, int unset)
 713{
 714	force_metric_only = true;
 715	stat_config.metric_only = !unset;
 716	return 0;
 717}
 718
 719static int parse_metric_groups(const struct option *opt,
 720			       const char *str,
 721			       int unset __maybe_unused)
 722{
 723	return metricgroup__parse_groups(opt, str, &stat_config.metric_events);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 724}
 725
 726static struct option stat_options[] = {
 727	OPT_BOOLEAN('T', "transaction", &transaction_run,
 728		    "hardware transaction statistics"),
 729	OPT_CALLBACK('e', "event", &evsel_list, "event",
 730		     "event selector. use 'perf list' to list available events",
 731		     parse_events_option),
 732	OPT_CALLBACK(0, "filter", &evsel_list, "filter",
 733		     "event filter", parse_filter),
 734	OPT_BOOLEAN('i', "no-inherit", &stat_config.no_inherit,
 735		    "child tasks do not inherit counters"),
 736	OPT_STRING('p', "pid", &target.pid, "pid",
 737		   "stat events on existing process id"),
 738	OPT_STRING('t', "tid", &target.tid, "tid",
 739		   "stat events on existing thread id"),
 
 
 
 
 
 
 
 
 740	OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
 741		    "system-wide collection from all CPUs"),
 742	OPT_BOOLEAN('g', "group", &group,
 743		    "put the counters into a counter group"),
 744	OPT_BOOLEAN(0, "scale", &stat_config.scale,
 745		    "Use --no-scale to disable counter scaling for multiplexing"),
 746	OPT_INCR('v', "verbose", &verbose,
 747		    "be more verbose (show counter open errors, etc)"),
 748	OPT_INTEGER('r', "repeat", &stat_config.run_count,
 749		    "repeat command and print average + stddev (max: 100, forever: 0)"),
 750	OPT_BOOLEAN(0, "table", &stat_config.walltime_run_table,
 751		    "display details about each run (only with -r option)"),
 752	OPT_BOOLEAN('n', "null", &stat_config.null_run,
 753		    "null run - dont start any counters"),
 754	OPT_INCR('d', "detailed", &detailed_run,
 755		    "detailed run - start a lot of events"),
 756	OPT_BOOLEAN('S', "sync", &sync_run,
 757		    "call sync() before starting a run"),
 758	OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
 759			   "print large numbers with thousands\' separators",
 760			   stat__set_big_num),
 761	OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
 762		    "list of cpus to monitor in system-wide"),
 763	OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
 764		    "disable CPU count aggregation", AGGR_NONE),
 765	OPT_BOOLEAN(0, "no-merge", &stat_config.no_merge, "Do not merge identical named events"),
 766	OPT_STRING('x', "field-separator", &stat_config.csv_sep, "separator",
 767		   "print counts with custom separator"),
 768	OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
 769		     "monitor event in cgroup name only", parse_cgroups),
 
 
 770	OPT_STRING('o', "output", &output_name, "file", "output file name"),
 771	OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
 772	OPT_INTEGER(0, "log-fd", &output_fd,
 773		    "log output to fd, instead of stderr"),
 774	OPT_STRING(0, "pre", &pre_cmd, "command",
 775			"command to run prior to the measured command"),
 776	OPT_STRING(0, "post", &post_cmd, "command",
 777			"command to run after to the measured command"),
 778	OPT_UINTEGER('I', "interval-print", &stat_config.interval,
 779		    "print counts at regular interval in ms "
 780		    "(overhead is possible for values <= 100ms)"),
 781	OPT_INTEGER(0, "interval-count", &stat_config.times,
 782		    "print counts for fixed number of times"),
 783	OPT_BOOLEAN(0, "interval-clear", &stat_config.interval_clear,
 784		    "clear screen in between new interval"),
 785	OPT_UINTEGER(0, "timeout", &stat_config.timeout,
 786		    "stop workload and print counts after a timeout period in ms (>= 10ms)"),
 787	OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode,
 788		     "aggregate counts per processor socket", AGGR_SOCKET),
 789	OPT_SET_UINT(0, "per-die", &stat_config.aggr_mode,
 790		     "aggregate counts per processor die", AGGR_DIE),
 791	OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode,
 792		     "aggregate counts per physical processor core", AGGR_CORE),
 793	OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode,
 794		     "aggregate counts per thread", AGGR_THREAD),
 795	OPT_UINTEGER('D', "delay", &stat_config.initial_delay,
 796		     "ms to wait before starting measurement after program start"),
 
 
 797	OPT_CALLBACK_NOOPT(0, "metric-only", &stat_config.metric_only, NULL,
 798			"Only print computed metrics. No raw values", enable_metric_only),
 
 
 
 
 799	OPT_BOOLEAN(0, "topdown", &topdown_run,
 800			"measure topdown level 1 statistics"),
 
 
 801	OPT_BOOLEAN(0, "smi-cost", &smi_cost,
 802			"measure SMI cost"),
 803	OPT_CALLBACK('M', "metrics", &evsel_list, "metric/metric group list",
 804		     "monitor specified metrics or metric groups (separated by ,)",
 805		     parse_metric_groups),
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 806	OPT_END()
 807};
 808
 809static int perf_stat__get_socket(struct perf_stat_config *config __maybe_unused,
 810				 struct perf_cpu_map *map, int cpu)
 811{
 812	return cpu_map__get_socket(map, cpu, NULL);
 813}
 814
 815static int perf_stat__get_die(struct perf_stat_config *config __maybe_unused,
 816			      struct perf_cpu_map *map, int cpu)
 817{
 818	return cpu_map__get_die(map, cpu, NULL);
 819}
 820
 821static int perf_stat__get_core(struct perf_stat_config *config __maybe_unused,
 822			       struct perf_cpu_map *map, int cpu)
 823{
 824	return cpu_map__get_core(map, cpu, NULL);
 825}
 826
 827static int perf_stat__get_aggr(struct perf_stat_config *config,
 
 
 
 
 
 
 828			       aggr_get_id_t get_id, struct perf_cpu_map *map, int idx)
 829{
 830	int cpu;
 
 831
 832	if (idx >= map->nr)
 833		return -1;
 834
 835	cpu = map->map[idx];
 836
 837	if (config->cpus_aggr_map->map[cpu] == -1)
 838		config->cpus_aggr_map->map[cpu] = get_id(config, map, idx);
 839
 840	return config->cpus_aggr_map->map[cpu];
 
 841}
 842
 843static int perf_stat__get_socket_cached(struct perf_stat_config *config,
 844					struct perf_cpu_map *map, int idx)
 845{
 846	return perf_stat__get_aggr(config, perf_stat__get_socket, map, idx);
 847}
 848
 849static int perf_stat__get_die_cached(struct perf_stat_config *config,
 850					struct perf_cpu_map *map, int idx)
 851{
 852	return perf_stat__get_aggr(config, perf_stat__get_die, map, idx);
 853}
 854
 855static int perf_stat__get_core_cached(struct perf_stat_config *config,
 856				      struct perf_cpu_map *map, int idx)
 857{
 858	return perf_stat__get_aggr(config, perf_stat__get_core, map, idx);
 859}
 860
 
 
 
 
 
 
 861static bool term_percore_set(void)
 862{
 863	struct evsel *counter;
 864
 865	evlist__for_each_entry(evsel_list, counter) {
 866		if (counter->percore)
 867			return true;
 868	}
 869
 870	return false;
 871}
 872
 873static int perf_stat_init_aggr_mode(void)
 874{
 875	int nr;
 876
 877	switch (stat_config.aggr_mode) {
 878	case AGGR_SOCKET:
 879		if (cpu_map__build_socket_map(evsel_list->core.cpus, &stat_config.aggr_map)) {
 880			perror("cannot build socket map");
 881			return -1;
 882		}
 883		stat_config.aggr_get_id = perf_stat__get_socket_cached;
 884		break;
 885	case AGGR_DIE:
 886		if (cpu_map__build_die_map(evsel_list->core.cpus, &stat_config.aggr_map)) {
 887			perror("cannot build die map");
 888			return -1;
 889		}
 890		stat_config.aggr_get_id = perf_stat__get_die_cached;
 891		break;
 892	case AGGR_CORE:
 893		if (cpu_map__build_core_map(evsel_list->core.cpus, &stat_config.aggr_map)) {
 894			perror("cannot build core map");
 895			return -1;
 896		}
 897		stat_config.aggr_get_id = perf_stat__get_core_cached;
 898		break;
 
 
 
 
 
 
 
 899	case AGGR_NONE:
 900		if (term_percore_set()) {
 901			if (cpu_map__build_core_map(evsel_list->core.cpus,
 902						    &stat_config.aggr_map)) {
 903				perror("cannot build core map");
 904				return -1;
 905			}
 906			stat_config.aggr_get_id = perf_stat__get_core_cached;
 907		}
 908		break;
 909	case AGGR_GLOBAL:
 910	case AGGR_THREAD:
 911	case AGGR_UNSET:
 912	default:
 913		break;
 914	}
 915
 916	/*
 917	 * The evsel_list->cpus is the base we operate on,
 918	 * taking the highest cpu number to be the size of
 919	 * the aggregation translate cpumap.
 920	 */
 921	nr = perf_cpu_map__max(evsel_list->core.cpus);
 922	stat_config.cpus_aggr_map = perf_cpu_map__empty_new(nr + 1);
 923	return stat_config.cpus_aggr_map ? 0 : -ENOMEM;
 924}
 925
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 926static void perf_stat__exit_aggr_mode(void)
 927{
 928	perf_cpu_map__put(stat_config.aggr_map);
 929	perf_cpu_map__put(stat_config.cpus_aggr_map);
 930	stat_config.aggr_map = NULL;
 931	stat_config.cpus_aggr_map = NULL;
 932}
 933
 934static inline int perf_env__get_cpu(struct perf_env *env, struct perf_cpu_map *map, int idx)
 935{
 936	int cpu;
 937
 938	if (idx > map->nr)
 939		return -1;
 940
 941	cpu = map->map[idx];
 942
 943	if (cpu >= env->nr_cpus_avail)
 944		return -1;
 945
 946	return cpu;
 947}
 948
 949static int perf_env__get_socket(struct perf_cpu_map *map, int idx, void *data)
 950{
 951	struct perf_env *env = data;
 952	int cpu = perf_env__get_cpu(env, map, idx);
 
 
 
 
 953
 954	return cpu == -1 ? -1 : env->cpu[cpu].socket_id;
 955}
 956
 957static int perf_env__get_die(struct perf_cpu_map *map, int idx, void *data)
 958{
 959	struct perf_env *env = data;
 960	int die_id = -1, cpu = perf_env__get_cpu(env, map, idx);
 
 961
 962	if (cpu != -1) {
 963		/*
 964		 * Encode socket in bit range 15:8
 965		 * die_id is relative to socket,
 966		 * we need a global id. So we combine
 967		 * socket + die id
 968		 */
 969		if (WARN_ONCE(env->cpu[cpu].socket_id >> 8, "The socket id number is too big.\n"))
 970			return -1;
 971
 972		if (WARN_ONCE(env->cpu[cpu].die_id >> 8, "The die id number is too big.\n"))
 973			return -1;
 974
 975		die_id = (env->cpu[cpu].socket_id << 8) | (env->cpu[cpu].die_id & 0xff);
 976	}
 977
 978	return die_id;
 979}
 980
 981static int perf_env__get_core(struct perf_cpu_map *map, int idx, void *data)
 982{
 983	struct perf_env *env = data;
 984	int core = -1, cpu = perf_env__get_cpu(env, map, idx);
 
 985
 986	if (cpu != -1) {
 987		/*
 988		 * Encode socket in bit range 31:24
 989		 * encode die id in bit range 23:16
 990		 * core_id is relative to socket and die,
 991		 * we need a global id. So we combine
 992		 * socket + die id + core id
 993		 */
 994		if (WARN_ONCE(env->cpu[cpu].socket_id >> 8, "The socket id number is too big.\n"))
 995			return -1;
 996
 997		if (WARN_ONCE(env->cpu[cpu].die_id >> 8, "The die id number is too big.\n"))
 998			return -1;
 999
1000		if (WARN_ONCE(env->cpu[cpu].core_id >> 16, "The core id number is too big.\n"))
1001			return -1;
1002
1003		core = (env->cpu[cpu].socket_id << 24) |
1004		       (env->cpu[cpu].die_id << 16) |
1005		       (env->cpu[cpu].core_id & 0xffff);
1006	}
1007
1008	return core;
 
1009}
1010
1011static int perf_env__build_socket_map(struct perf_env *env, struct perf_cpu_map *cpus,
1012				      struct perf_cpu_map **sockp)
1013{
1014	return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env);
1015}
1016
1017static int perf_env__build_die_map(struct perf_env *env, struct perf_cpu_map *cpus,
1018				   struct perf_cpu_map **diep)
1019{
1020	return cpu_map__build_map(cpus, diep, perf_env__get_die, env);
1021}
1022
1023static int perf_env__build_core_map(struct perf_env *env, struct perf_cpu_map *cpus,
1024				    struct perf_cpu_map **corep)
1025{
1026	return cpu_map__build_map(cpus, corep, perf_env__get_core, env);
1027}
1028
1029static int perf_stat__get_socket_file(struct perf_stat_config *config __maybe_unused,
 
 
 
 
 
 
1030				      struct perf_cpu_map *map, int idx)
1031{
1032	return perf_env__get_socket(map, idx, &perf_stat.session->header.env);
1033}
1034static int perf_stat__get_die_file(struct perf_stat_config *config __maybe_unused,
1035				   struct perf_cpu_map *map, int idx)
1036{
1037	return perf_env__get_die(map, idx, &perf_stat.session->header.env);
1038}
1039
1040static int perf_stat__get_core_file(struct perf_stat_config *config __maybe_unused,
1041				    struct perf_cpu_map *map, int idx)
1042{
1043	return perf_env__get_core(map, idx, &perf_stat.session->header.env);
1044}
1045
 
 
 
 
 
 
1046static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
1047{
1048	struct perf_env *env = &st->session->header.env;
1049
1050	switch (stat_config.aggr_mode) {
1051	case AGGR_SOCKET:
1052		if (perf_env__build_socket_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) {
1053			perror("cannot build socket map");
1054			return -1;
1055		}
1056		stat_config.aggr_get_id = perf_stat__get_socket_file;
1057		break;
1058	case AGGR_DIE:
1059		if (perf_env__build_die_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) {
1060			perror("cannot build die map");
1061			return -1;
1062		}
1063		stat_config.aggr_get_id = perf_stat__get_die_file;
1064		break;
1065	case AGGR_CORE:
1066		if (perf_env__build_core_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) {
1067			perror("cannot build core map");
1068			return -1;
1069		}
1070		stat_config.aggr_get_id = perf_stat__get_core_file;
1071		break;
 
 
 
 
 
 
 
1072	case AGGR_NONE:
1073	case AGGR_GLOBAL:
1074	case AGGR_THREAD:
1075	case AGGR_UNSET:
1076	default:
1077		break;
1078	}
1079
1080	return 0;
1081}
1082
1083static int topdown_filter_events(const char **attr, char **str, bool use_group)
1084{
1085	int off = 0;
1086	int i;
1087	int len = 0;
1088	char *s;
1089
1090	for (i = 0; attr[i]; i++) {
1091		if (pmu_have_event("cpu", attr[i])) {
1092			len += strlen(attr[i]) + 1;
1093			attr[i - off] = attr[i];
1094		} else
1095			off++;
1096	}
1097	attr[i - off] = NULL;
1098
1099	*str = malloc(len + 1 + 2);
1100	if (!*str)
1101		return -1;
1102	s = *str;
1103	if (i - off == 0) {
1104		*s = 0;
1105		return 0;
1106	}
1107	if (use_group)
1108		*s++ = '{';
1109	for (i = 0; attr[i]; i++) {
1110		strcpy(s, attr[i]);
1111		s += strlen(s);
1112		*s++ = ',';
1113	}
1114	if (use_group) {
1115		s[-1] = '}';
1116		*s = 0;
1117	} else
1118		s[-1] = 0;
1119	return 0;
1120}
1121
1122__weak bool arch_topdown_check_group(bool *warn)
1123{
1124	*warn = false;
1125	return false;
1126}
1127
1128__weak void arch_topdown_group_warn(void)
1129{
1130}
1131
1132/*
1133 * Add default attributes, if there were no attributes specified or
1134 * if -d/--detailed, -d -d or -d -d -d is used:
1135 */
1136static int add_default_attributes(void)
1137{
1138	int err;
1139	struct perf_event_attr default_attrs0[] = {
1140
1141  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK		},
1142  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES	},
1143  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS		},
1144  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS		},
1145
1146  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES		},
1147};
1148	struct perf_event_attr frontend_attrs[] = {
1149  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND	},
1150};
1151	struct perf_event_attr backend_attrs[] = {
1152  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND	},
1153};
1154	struct perf_event_attr default_attrs1[] = {
1155  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS		},
1156  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS	},
1157  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES		},
1158
1159};
 
 
 
 
 
 
1160
1161/*
1162 * Detailed stats (-d), covering the L1 and last level data caches:
1163 */
1164	struct perf_event_attr detailed_attrs[] = {
1165
1166  { .type = PERF_TYPE_HW_CACHE,
1167    .config =
1168	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
1169	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1170	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},
1171
1172  { .type = PERF_TYPE_HW_CACHE,
1173    .config =
1174	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
1175	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1176	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
1177
1178  { .type = PERF_TYPE_HW_CACHE,
1179    .config =
1180	 PERF_COUNT_HW_CACHE_LL			<<  0  |
1181	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1182	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},
1183
1184  { .type = PERF_TYPE_HW_CACHE,
1185    .config =
1186	 PERF_COUNT_HW_CACHE_LL			<<  0  |
1187	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1188	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
1189};
1190
1191/*
1192 * Very detailed stats (-d -d), covering the instruction cache and the TLB caches:
1193 */
1194	struct perf_event_attr very_detailed_attrs[] = {
1195
1196  { .type = PERF_TYPE_HW_CACHE,
1197    .config =
1198	 PERF_COUNT_HW_CACHE_L1I		<<  0  |
1199	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1200	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},
1201
1202  { .type = PERF_TYPE_HW_CACHE,
1203    .config =
1204	 PERF_COUNT_HW_CACHE_L1I		<<  0  |
1205	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1206	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
1207
1208  { .type = PERF_TYPE_HW_CACHE,
1209    .config =
1210	 PERF_COUNT_HW_CACHE_DTLB		<<  0  |
1211	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1212	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},
1213
1214  { .type = PERF_TYPE_HW_CACHE,
1215    .config =
1216	 PERF_COUNT_HW_CACHE_DTLB		<<  0  |
1217	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1218	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
1219
1220  { .type = PERF_TYPE_HW_CACHE,
1221    .config =
1222	 PERF_COUNT_HW_CACHE_ITLB		<<  0  |
1223	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1224	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},
1225
1226  { .type = PERF_TYPE_HW_CACHE,
1227    .config =
1228	 PERF_COUNT_HW_CACHE_ITLB		<<  0  |
1229	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
1230	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
1231
1232};
1233
1234/*
1235 * Very, very detailed stats (-d -d -d), adding prefetch events:
1236 */
1237	struct perf_event_attr very_very_detailed_attrs[] = {
1238
1239  { .type = PERF_TYPE_HW_CACHE,
1240    .config =
1241	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
1242	(PERF_COUNT_HW_CACHE_OP_PREFETCH	<<  8) |
1243	(PERF_COUNT_HW_CACHE_RESULT_ACCESS	<< 16)				},
1244
1245  { .type = PERF_TYPE_HW_CACHE,
1246    .config =
1247	 PERF_COUNT_HW_CACHE_L1D		<<  0  |
1248	(PERF_COUNT_HW_CACHE_OP_PREFETCH	<<  8) |
1249	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16)				},
1250};
1251	struct parse_events_error errinfo;
1252
1253	/* Set attrs if no event is selected and !null_run: */
1254	if (stat_config.null_run)
1255		return 0;
1256
 
1257	if (transaction_run) {
1258		/* Handle -T as -M transaction. Once platform specific metrics
1259		 * support has been added to the json files, all archictures
1260		 * will use this approach. To determine transaction support
1261		 * on an architecture test for such a metric name.
1262		 */
1263		if (metricgroup__has_metric("transaction")) {
1264			struct option opt = { .value = &evsel_list };
1265
1266			return metricgroup__parse_groups(&opt, "transaction",
 
 
1267							 &stat_config.metric_events);
1268		}
1269
1270		if (pmu_have_event("cpu", "cycles-ct") &&
1271		    pmu_have_event("cpu", "el-start"))
1272			err = parse_events(evsel_list, transaction_attrs,
1273					   &errinfo);
1274		else
1275			err = parse_events(evsel_list,
1276					   transaction_limited_attrs,
1277					   &errinfo);
1278		if (err) {
1279			fprintf(stderr, "Cannot set up transaction events\n");
1280			parse_events_print_error(&errinfo, transaction_attrs);
1281			return -1;
1282		}
1283		return 0;
1284	}
1285
1286	if (smi_cost) {
1287		int smi;
1288
1289		if (sysfs__read_int(FREEZE_ON_SMI_PATH, &smi) < 0) {
1290			fprintf(stderr, "freeze_on_smi is not supported.\n");
1291			return -1;
1292		}
1293
1294		if (!smi) {
1295			if (sysfs__write_int(FREEZE_ON_SMI_PATH, 1) < 0) {
1296				fprintf(stderr, "Failed to set freeze_on_smi.\n");
1297				return -1;
1298			}
1299			smi_reset = true;
1300		}
1301
1302		if (pmu_have_event("msr", "aperf") &&
1303		    pmu_have_event("msr", "smi")) {
1304			if (!force_metric_only)
1305				stat_config.metric_only = true;
1306			err = parse_events(evsel_list, smi_cost_attrs, &errinfo);
1307		} else {
1308			fprintf(stderr, "To measure SMI cost, it needs "
1309				"msr/aperf/, msr/smi/ and cpu/cycles/ support\n");
1310			parse_events_print_error(&errinfo, smi_cost_attrs);
1311			return -1;
1312		}
1313		if (err) {
 
1314			fprintf(stderr, "Cannot set up SMI cost events\n");
1315			return -1;
1316		}
1317		return 0;
1318	}
1319
1320	if (topdown_run) {
 
 
1321		char *str = NULL;
1322		bool warn = false;
1323
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1324		if (stat_config.aggr_mode != AGGR_GLOBAL &&
1325		    stat_config.aggr_mode != AGGR_CORE) {
1326			pr_err("top down event configuration requires --per-core mode\n");
1327			return -1;
1328		}
1329		stat_config.aggr_mode = AGGR_CORE;
1330		if (nr_cgroups || !target__has_cpu(&target)) {
1331			pr_err("top down event configuration requires system-wide mode (-a)\n");
1332			return -1;
1333		}
1334
1335		if (!force_metric_only)
1336			stat_config.metric_only = true;
1337		if (topdown_filter_events(topdown_attrs, &str,
1338				arch_topdown_check_group(&warn)) < 0) {
1339			pr_err("Out of memory\n");
1340			return -1;
1341		}
1342		if (topdown_attrs[0] && str) {
1343			if (warn)
1344				arch_topdown_group_warn();
 
1345			err = parse_events(evsel_list, str, &errinfo);
1346			if (err) {
1347				fprintf(stderr,
1348					"Cannot set up top down events %s: %d\n",
1349					str, err);
1350				parse_events_print_error(&errinfo, str);
1351				free(str);
1352				return -1;
1353			}
1354		} else {
1355			fprintf(stderr, "System does not support topdown\n");
1356			return -1;
1357		}
1358		free(str);
1359	}
1360
1361	if (!evsel_list->core.nr_entries) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1362		if (target__has_cpu(&target))
1363			default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK;
1364
1365		if (perf_evlist__add_default_attrs(evsel_list, default_attrs0) < 0)
1366			return -1;
1367		if (pmu_have_event("cpu", "stalled-cycles-frontend")) {
1368			if (perf_evlist__add_default_attrs(evsel_list,
1369						frontend_attrs) < 0)
1370				return -1;
1371		}
1372		if (pmu_have_event("cpu", "stalled-cycles-backend")) {
1373			if (perf_evlist__add_default_attrs(evsel_list,
1374						backend_attrs) < 0)
1375				return -1;
1376		}
1377		if (perf_evlist__add_default_attrs(evsel_list, default_attrs1) < 0)
 
 
 
 
1378			return -1;
1379	}
1380
1381	/* Detailed events get appended to the event list: */
1382
1383	if (detailed_run <  1)
1384		return 0;
1385
1386	/* Append detailed run extra attributes: */
1387	if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0)
1388		return -1;
1389
1390	if (detailed_run < 2)
1391		return 0;
1392
1393	/* Append very detailed run extra attributes: */
1394	if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0)
1395		return -1;
1396
1397	if (detailed_run < 3)
1398		return 0;
1399
1400	/* Append very, very detailed run extra attributes: */
1401	return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs);
1402}
1403
1404static const char * const stat_record_usage[] = {
1405	"perf stat record [<options>]",
1406	NULL,
1407};
1408
1409static void init_features(struct perf_session *session)
1410{
1411	int feat;
1412
1413	for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
1414		perf_header__set_feat(&session->header, feat);
1415
1416	perf_header__clear_feat(&session->header, HEADER_DIR_FORMAT);
1417	perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
1418	perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
1419	perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
1420	perf_header__clear_feat(&session->header, HEADER_AUXTRACE);
1421}
1422
1423static int __cmd_record(int argc, const char **argv)
1424{
1425	struct perf_session *session;
1426	struct perf_data *data = &perf_stat.data;
1427
1428	argc = parse_options(argc, argv, stat_options, stat_record_usage,
1429			     PARSE_OPT_STOP_AT_NON_OPTION);
1430
1431	if (output_name)
1432		data->path = output_name;
1433
1434	if (stat_config.run_count != 1 || forever) {
1435		pr_err("Cannot use -r option with perf stat record.\n");
1436		return -1;
1437	}
1438
1439	session = perf_session__new(data, false, NULL);
1440	if (IS_ERR(session)) {
1441		pr_err("Perf session creation failed\n");
1442		return PTR_ERR(session);
1443	}
1444
1445	init_features(session);
1446
1447	session->evlist   = evsel_list;
1448	perf_stat.session = session;
1449	perf_stat.record  = true;
1450	return argc;
1451}
1452
1453static int process_stat_round_event(struct perf_session *session,
1454				    union perf_event *event)
1455{
1456	struct perf_record_stat_round *stat_round = &event->stat_round;
1457	struct evsel *counter;
1458	struct timespec tsh, *ts = NULL;
1459	const char **argv = session->header.env.cmdline_argv;
1460	int argc = session->header.env.nr_cmdline;
1461
1462	evlist__for_each_entry(evsel_list, counter)
1463		perf_stat_process_counter(&stat_config, counter);
1464
1465	if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL)
1466		update_stats(&walltime_nsecs_stats, stat_round->time);
1467
1468	if (stat_config.interval && stat_round->time) {
1469		tsh.tv_sec  = stat_round->time / NSEC_PER_SEC;
1470		tsh.tv_nsec = stat_round->time % NSEC_PER_SEC;
1471		ts = &tsh;
1472	}
1473
1474	print_counters(ts, argc, argv);
1475	return 0;
1476}
1477
1478static
1479int process_stat_config_event(struct perf_session *session,
1480			      union perf_event *event)
1481{
1482	struct perf_tool *tool = session->tool;
1483	struct perf_stat *st = container_of(tool, struct perf_stat, tool);
1484
1485	perf_event__read_stat_config(&stat_config, &event->stat_config);
1486
1487	if (perf_cpu_map__empty(st->cpus)) {
1488		if (st->aggr_mode != AGGR_UNSET)
1489			pr_warning("warning: processing task data, aggregation mode not set\n");
1490		return 0;
1491	}
1492
1493	if (st->aggr_mode != AGGR_UNSET)
1494		stat_config.aggr_mode = st->aggr_mode;
1495
1496	if (perf_stat.data.is_pipe)
1497		perf_stat_init_aggr_mode();
1498	else
1499		perf_stat_init_aggr_mode_file(st);
1500
1501	return 0;
1502}
1503
1504static int set_maps(struct perf_stat *st)
1505{
1506	if (!st->cpus || !st->threads)
1507		return 0;
1508
1509	if (WARN_ONCE(st->maps_allocated, "stats double allocation\n"))
1510		return -EINVAL;
1511
1512	perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads);
1513
1514	if (perf_evlist__alloc_stats(evsel_list, true))
1515		return -ENOMEM;
1516
1517	st->maps_allocated = true;
1518	return 0;
1519}
1520
1521static
1522int process_thread_map_event(struct perf_session *session,
1523			     union perf_event *event)
1524{
1525	struct perf_tool *tool = session->tool;
1526	struct perf_stat *st = container_of(tool, struct perf_stat, tool);
1527
1528	if (st->threads) {
1529		pr_warning("Extra thread map event, ignoring.\n");
1530		return 0;
1531	}
1532
1533	st->threads = thread_map__new_event(&event->thread_map);
1534	if (!st->threads)
1535		return -ENOMEM;
1536
1537	return set_maps(st);
1538}
1539
1540static
1541int process_cpu_map_event(struct perf_session *session,
1542			  union perf_event *event)
1543{
1544	struct perf_tool *tool = session->tool;
1545	struct perf_stat *st = container_of(tool, struct perf_stat, tool);
1546	struct perf_cpu_map *cpus;
1547
1548	if (st->cpus) {
1549		pr_warning("Extra cpu map event, ignoring.\n");
1550		return 0;
1551	}
1552
1553	cpus = cpu_map__new_data(&event->cpu_map.data);
1554	if (!cpus)
1555		return -ENOMEM;
1556
1557	st->cpus = cpus;
1558	return set_maps(st);
1559}
1560
1561static int runtime_stat_new(struct perf_stat_config *config, int nthreads)
1562{
1563	int i;
1564
1565	config->stats = calloc(nthreads, sizeof(struct runtime_stat));
1566	if (!config->stats)
1567		return -1;
1568
1569	config->stats_num = nthreads;
1570
1571	for (i = 0; i < nthreads; i++)
1572		runtime_stat__init(&config->stats[i]);
1573
1574	return 0;
1575}
1576
1577static void runtime_stat_delete(struct perf_stat_config *config)
1578{
1579	int i;
1580
1581	if (!config->stats)
1582		return;
1583
1584	for (i = 0; i < config->stats_num; i++)
1585		runtime_stat__exit(&config->stats[i]);
1586
1587	zfree(&config->stats);
1588}
1589
1590static const char * const stat_report_usage[] = {
1591	"perf stat report [<options>]",
1592	NULL,
1593};
1594
1595static struct perf_stat perf_stat = {
1596	.tool = {
1597		.attr		= perf_event__process_attr,
1598		.event_update	= perf_event__process_event_update,
1599		.thread_map	= process_thread_map_event,
1600		.cpu_map	= process_cpu_map_event,
1601		.stat_config	= process_stat_config_event,
1602		.stat		= perf_event__process_stat_event,
1603		.stat_round	= process_stat_round_event,
1604	},
1605	.aggr_mode = AGGR_UNSET,
1606};
1607
1608static int __cmd_report(int argc, const char **argv)
1609{
1610	struct perf_session *session;
1611	const struct option options[] = {
1612	OPT_STRING('i', "input", &input_name, "file", "input file name"),
1613	OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode,
1614		     "aggregate counts per processor socket", AGGR_SOCKET),
1615	OPT_SET_UINT(0, "per-die", &perf_stat.aggr_mode,
1616		     "aggregate counts per processor die", AGGR_DIE),
1617	OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode,
1618		     "aggregate counts per physical processor core", AGGR_CORE),
 
 
1619	OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode,
1620		     "disable CPU count aggregation", AGGR_NONE),
1621	OPT_END()
1622	};
1623	struct stat st;
1624	int ret;
1625
1626	argc = parse_options(argc, argv, options, stat_report_usage, 0);
1627
1628	if (!input_name || !strlen(input_name)) {
1629		if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
1630			input_name = "-";
1631		else
1632			input_name = "perf.data";
1633	}
1634
1635	perf_stat.data.path = input_name;
1636	perf_stat.data.mode = PERF_DATA_MODE_READ;
1637
1638	session = perf_session__new(&perf_stat.data, false, &perf_stat.tool);
1639	if (IS_ERR(session))
1640		return PTR_ERR(session);
1641
1642	perf_stat.session  = session;
1643	stat_config.output = stderr;
1644	evsel_list         = session->evlist;
1645
1646	ret = perf_session__process_events(session);
1647	if (ret)
1648		return ret;
1649
1650	perf_session__delete(session);
1651	return 0;
1652}
1653
1654static void setup_system_wide(int forks)
1655{
1656	/*
1657	 * Make system wide (-a) the default target if
1658	 * no target was specified and one of following
1659	 * conditions is met:
1660	 *
1661	 *   - there's no workload specified
1662	 *   - there is workload specified but all requested
1663	 *     events are system wide events
1664	 */
1665	if (!target__none(&target))
1666		return;
1667
1668	if (!forks)
1669		target.system_wide = true;
1670	else {
1671		struct evsel *counter;
1672
1673		evlist__for_each_entry(evsel_list, counter) {
1674			if (!counter->core.system_wide)
 
1675				return;
 
1676		}
1677
1678		if (evsel_list->core.nr_entries)
1679			target.system_wide = true;
1680	}
1681}
1682
1683int cmd_stat(int argc, const char **argv)
1684{
1685	const char * const stat_usage[] = {
1686		"perf stat [<options>] [<command>]",
1687		NULL
1688	};
1689	int status = -EINVAL, run_idx;
1690	const char *mode;
1691	FILE *output = stderr;
1692	unsigned int interval, timeout;
1693	const char * const stat_subcommands[] = { "record", "report" };
 
1694
1695	setlocale(LC_ALL, "");
1696
1697	evsel_list = evlist__new();
1698	if (evsel_list == NULL)
1699		return -ENOMEM;
1700
1701	parse_events__shrink_config_terms();
1702
1703	/* String-parsing callback-based options would segfault when negated */
1704	set_option_flag(stat_options, 'e', "event", PARSE_OPT_NONEG);
1705	set_option_flag(stat_options, 'M', "metrics", PARSE_OPT_NONEG);
1706	set_option_flag(stat_options, 'G', "cgroup", PARSE_OPT_NONEG);
1707
1708	argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
1709					(const char **) stat_usage,
1710					PARSE_OPT_STOP_AT_NON_OPTION);
1711	perf_stat__collect_metric_expr(evsel_list);
1712	perf_stat__init_shadow_stats();
1713
1714	if (stat_config.csv_sep) {
1715		stat_config.csv_output = true;
1716		if (!strcmp(stat_config.csv_sep, "\\t"))
1717			stat_config.csv_sep = "\t";
1718	} else
1719		stat_config.csv_sep = DEFAULT_SEPARATOR;
1720
1721	if (argc && !strncmp(argv[0], "rec", 3)) {
1722		argc = __cmd_record(argc, argv);
1723		if (argc < 0)
1724			return -1;
1725	} else if (argc && !strncmp(argv[0], "rep", 3))
1726		return __cmd_report(argc, argv);
1727
1728	interval = stat_config.interval;
1729	timeout = stat_config.timeout;
1730
1731	/*
1732	 * For record command the -o is already taken care of.
1733	 */
1734	if (!STAT_RECORD && output_name && strcmp(output_name, "-"))
1735		output = NULL;
1736
1737	if (output_name && output_fd) {
1738		fprintf(stderr, "cannot use both --output and --log-fd\n");
1739		parse_options_usage(stat_usage, stat_options, "o", 1);
1740		parse_options_usage(NULL, stat_options, "log-fd", 0);
1741		goto out;
1742	}
1743
1744	if (stat_config.metric_only && stat_config.aggr_mode == AGGR_THREAD) {
1745		fprintf(stderr, "--metric-only is not supported with --per-thread\n");
1746		goto out;
1747	}
1748
1749	if (stat_config.metric_only && stat_config.run_count > 1) {
1750		fprintf(stderr, "--metric-only is not supported with -r\n");
1751		goto out;
1752	}
1753
1754	if (stat_config.walltime_run_table && stat_config.run_count <= 1) {
1755		fprintf(stderr, "--table is only supported with -r\n");
1756		parse_options_usage(stat_usage, stat_options, "r", 1);
1757		parse_options_usage(NULL, stat_options, "table", 0);
1758		goto out;
1759	}
1760
1761	if (output_fd < 0) {
1762		fprintf(stderr, "argument to --log-fd must be a > 0\n");
1763		parse_options_usage(stat_usage, stat_options, "log-fd", 0);
1764		goto out;
1765	}
1766
1767	if (!output) {
1768		struct timespec tm;
1769		mode = append_file ? "a" : "w";
1770
1771		output = fopen(output_name, mode);
1772		if (!output) {
1773			perror("failed to create output file");
1774			return -1;
1775		}
1776		clock_gettime(CLOCK_REALTIME, &tm);
1777		fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
1778	} else if (output_fd > 0) {
1779		mode = append_file ? "a" : "w";
1780		output = fdopen(output_fd, mode);
1781		if (!output) {
1782			perror("Failed opening logfd");
1783			return -errno;
1784		}
1785	}
1786
1787	stat_config.output = output;
1788
1789	/*
1790	 * let the spreadsheet do the pretty-printing
1791	 */
1792	if (stat_config.csv_output) {
1793		/* User explicitly passed -B? */
1794		if (big_num_opt == 1) {
1795			fprintf(stderr, "-B option not supported with -x\n");
1796			parse_options_usage(stat_usage, stat_options, "B", 1);
1797			parse_options_usage(NULL, stat_options, "x", 1);
1798			goto out;
1799		} else /* Nope, so disable big number formatting */
1800			stat_config.big_num = false;
1801	} else if (big_num_opt == 0) /* User passed --no-big-num */
1802		stat_config.big_num = false;
1803
 
 
 
 
 
 
1804	setup_system_wide(argc);
1805
1806	/*
1807	 * Display user/system times only for single
1808	 * run and when there's specified tracee.
1809	 */
1810	if ((stat_config.run_count == 1) && target__none(&target))
1811		stat_config.ru_display = true;
1812
1813	if (stat_config.run_count < 0) {
1814		pr_err("Run count must be a positive number\n");
1815		parse_options_usage(stat_usage, stat_options, "r", 1);
1816		goto out;
1817	} else if (stat_config.run_count == 0) {
1818		forever = true;
1819		stat_config.run_count = 1;
1820	}
1821
1822	if (stat_config.walltime_run_table) {
1823		stat_config.walltime_run = zalloc(stat_config.run_count * sizeof(stat_config.walltime_run[0]));
1824		if (!stat_config.walltime_run) {
1825			pr_err("failed to setup -r option");
1826			goto out;
1827		}
1828	}
1829
1830	if ((stat_config.aggr_mode == AGGR_THREAD) &&
1831		!target__has_task(&target)) {
1832		if (!target.system_wide || target.cpu_list) {
1833			fprintf(stderr, "The --per-thread option is only "
1834				"available when monitoring via -p -t -a "
1835				"options or only --per-thread.\n");
1836			parse_options_usage(NULL, stat_options, "p", 1);
1837			parse_options_usage(NULL, stat_options, "t", 1);
1838			goto out;
1839		}
1840	}
1841
1842	/*
1843	 * no_aggr, cgroup are for system-wide only
1844	 * --per-thread is aggregated per thread, we dont mix it with cpu mode
1845	 */
1846	if (((stat_config.aggr_mode != AGGR_GLOBAL &&
1847	      stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) &&
1848	    !target__has_cpu(&target)) {
1849		fprintf(stderr, "both cgroup and no-aggregation "
1850			"modes only available in system-wide mode\n");
1851
1852		parse_options_usage(stat_usage, stat_options, "G", 1);
1853		parse_options_usage(NULL, stat_options, "A", 1);
1854		parse_options_usage(NULL, stat_options, "a", 1);
1855		goto out;
1856	}
1857
 
 
 
 
 
 
 
 
 
 
 
 
 
1858	if (add_default_attributes())
1859		goto out;
1860
1861	target__validate(&target);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1862
1863	if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide))
1864		target.per_thread = true;
1865
1866	if (perf_evlist__create_maps(evsel_list, &target) < 0) {
1867		if (target__has_task(&target)) {
1868			pr_err("Problems finding threads of monitor\n");
1869			parse_options_usage(stat_usage, stat_options, "p", 1);
1870			parse_options_usage(NULL, stat_options, "t", 1);
1871		} else if (target__has_cpu(&target)) {
1872			perror("failed to parse CPUs map");
1873			parse_options_usage(stat_usage, stat_options, "C", 1);
1874			parse_options_usage(NULL, stat_options, "a", 1);
1875		}
1876		goto out;
1877	}
1878
 
 
1879	/*
1880	 * Initialize thread_map with comm names,
1881	 * so we could print it out on output.
1882	 */
1883	if (stat_config.aggr_mode == AGGR_THREAD) {
1884		thread_map__read_comms(evsel_list->core.threads);
1885		if (target.system_wide) {
1886			if (runtime_stat_new(&stat_config,
1887				perf_thread_map__nr(evsel_list->core.threads))) {
1888				goto out;
1889			}
1890		}
1891	}
1892
 
 
 
1893	if (stat_config.times && interval)
1894		interval_count = true;
1895	else if (stat_config.times && !interval) {
1896		pr_err("interval-count option should be used together with "
1897				"interval-print.\n");
1898		parse_options_usage(stat_usage, stat_options, "interval-count", 0);
1899		parse_options_usage(stat_usage, stat_options, "I", 1);
1900		goto out;
1901	}
1902
1903	if (timeout && timeout < 100) {
1904		if (timeout < 10) {
1905			pr_err("timeout must be >= 10ms.\n");
1906			parse_options_usage(stat_usage, stat_options, "timeout", 0);
1907			goto out;
1908		} else
1909			pr_warning("timeout < 100ms. "
1910				   "The overhead percentage could be high in some cases. "
1911				   "Please proceed with caution.\n");
1912	}
1913	if (timeout && interval) {
1914		pr_err("timeout option is not supported with interval-print.\n");
1915		parse_options_usage(stat_usage, stat_options, "timeout", 0);
1916		parse_options_usage(stat_usage, stat_options, "I", 1);
1917		goto out;
1918	}
1919
1920	if (perf_evlist__alloc_stats(evsel_list, interval))
1921		goto out;
1922
1923	if (perf_stat_init_aggr_mode())
1924		goto out;
1925
1926	/*
1927	 * Set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless
1928	 * while avoiding that older tools show confusing messages.
1929	 *
1930	 * However for pipe sessions we need to keep it zero,
1931	 * because script's perf_evsel__check_attr is triggered
1932	 * by attr->sample_type != 0, and we can't run it on
1933	 * stat sessions.
1934	 */
1935	stat_config.identifier = !(STAT_RECORD && perf_stat.data.is_pipe);
1936
1937	/*
1938	 * We dont want to block the signals - that would cause
1939	 * child tasks to inherit that and Ctrl-C would not work.
1940	 * What we want is for Ctrl-C to work in the exec()-ed
1941	 * task, but being ignored by perf stat itself:
1942	 */
1943	atexit(sig_atexit);
1944	if (!forever)
1945		signal(SIGINT,  skip_signal);
1946	signal(SIGCHLD, skip_signal);
1947	signal(SIGALRM, skip_signal);
1948	signal(SIGABRT, skip_signal);
1949
 
 
 
1950	status = 0;
1951	for (run_idx = 0; forever || run_idx < stat_config.run_count; run_idx++) {
1952		if (stat_config.run_count != 1 && verbose > 0)
1953			fprintf(output, "[ perf stat: executing run #%d ... ]\n",
1954				run_idx + 1);
1955
1956		if (run_idx != 0)
1957			perf_evlist__reset_prev_raw_counts(evsel_list);
1958
1959		status = run_perf_stat(argc, argv, run_idx);
1960		if (forever && status != -1 && !interval) {
1961			print_counters(NULL, argc, argv);
1962			perf_stat__reset_stats();
1963		}
1964	}
1965
1966	if (!forever && status != -1 && !interval)
1967		print_counters(NULL, argc, argv);
1968
 
 
1969	if (STAT_RECORD) {
1970		/*
1971		 * We synthesize the kernel mmap record just so that older tools
1972		 * don't emit warnings about not being able to resolve symbols
1973		 * due to /proc/sys/kernel/kptr_restrict settings and instear provide
1974		 * a saner message about no samples being in the perf.data file.
1975		 *
1976		 * This also serves to suppress a warning about f_header.data.size == 0
1977		 * in header.c at the moment 'perf stat record' gets introduced, which
1978		 * is not really needed once we start adding the stat specific PERF_RECORD_
1979		 * records, but the need to suppress the kptr_restrict messages in older
1980		 * tools remain  -acme
1981		 */
1982		int fd = perf_data__fd(&perf_stat.data);
1983		int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat,
1984							     process_synthesized_event,
1985							     &perf_stat.session->machines.host);
 
1986		if (err) {
1987			pr_warning("Couldn't synthesize the kernel mmap record, harmless, "
1988				   "older tools may produce warnings about this file\n.");
1989		}
1990
1991		if (!interval) {
1992			if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL))
1993				pr_err("failed to write stat round event\n");
1994		}
1995
1996		if (!perf_stat.data.is_pipe) {
1997			perf_stat.session->header.data_size += perf_stat.bytes_written;
1998			perf_session__write_header(perf_stat.session, evsel_list, fd, true);
1999		}
2000
2001		evlist__close(evsel_list);
2002		perf_session__delete(perf_stat.session);
2003	}
2004
2005	perf_stat__exit_aggr_mode();
2006	perf_evlist__free_stats(evsel_list);
2007out:
 
 
 
2008	zfree(&stat_config.walltime_run);
2009
2010	if (smi_cost && smi_reset)
2011		sysfs__write_int(FREEZE_ON_SMI_PATH, 0);
2012
2013	evlist__delete(evsel_list);
2014
 
2015	runtime_stat_delete(&stat_config);
 
2016
2017	return status;
2018}