tools/perf/builtin-stat.c

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