tools/perf/util/evsel.c

   1 /*
   2  * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
   3  *
   4  * Parts came from builtin-{top,stat,record}.c, see those files for further
   5  * copyright notes.
   6  *
   7  * Released under the GPL v2. (and only v2, not any later version)
   8  */
   9
  10 #include <byteswap.h>
  11 #include <errno.h>
  12 #include <inttypes.h>
  13 #include <linux/bitops.h>
  14 #include <api/fs/fs.h>
  15 #include <api/fs/tracing_path.h>
  16 #include <traceevent/event-parse.h>
  17 #include <linux/hw_breakpoint.h>
  18 #include <linux/perf_event.h>
  19 #include <linux/compiler.h>
  20 #include <linux/err.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/resource.h>
  23 #include <sys/types.h>
  24 #include <dirent.h>
  25 #include "asm/bug.h"
  26 #include "callchain.h"
  27 #include "cgroup.h"
  28 #include "event.h"
  29 #include "evsel.h"
  30 #include "evlist.h"
  31 #include "util.h"
  32 #include "cpumap.h"
  33 #include "thread_map.h"
  34 #include "target.h"
  35 #include "perf_regs.h"
  36 #include "debug.h"
  37 #include "trace-event.h"
  38 #include "stat.h"
  39 #include "memswap.h"
  40 #include "util/parse-branch-options.h"
  41
  42 #include "sane_ctype.h"
  43
  44 struct perf_missing_features perf_missing_features;
  45
  46 static clockid_t clockid;
  47
  48 static int perf_evsel__no_extra_init(struct perf_evsel *evsel __maybe_unused)
  49 {
  50         return 0;
  51 }
  52
  53 void __weak test_attr__ready(void) { }
  54
  55 static void perf_evsel__no_extra_fini(struct perf_evsel *evsel __maybe_unused)
  56 {
  57 }
  58
  59 static struct {
  60         size_t  size;
  61         int     (*init)(struct perf_evsel *evsel);
  62         void    (*fini)(struct perf_evsel *evsel);
  63 } perf_evsel__object = {
  64         .size = sizeof(struct perf_evsel),
  65         .init = perf_evsel__no_extra_init,
  66         .fini = perf_evsel__no_extra_fini,
  67 };
  68
  69 int perf_evsel__object_config(size_t object_size,
  70                               int (*init)(struct perf_evsel *evsel),
  71                               void (*fini)(struct perf_evsel *evsel))
  72 {
  73
  74         if (object_size == 0)
  75                 goto set_methods;
  76
  77         if (perf_evsel__object.size > object_size)
  78                 return -EINVAL;
  79
  80         perf_evsel__object.size = object_size;
  81
  82 set_methods:
  83         if (init != NULL)
  84                 perf_evsel__object.init = init;
  85
  86         if (fini != NULL)
  87                 perf_evsel__object.fini = fini;
  88
  89         return 0;
  90 }
  91
  92 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
  93
  94 int __perf_evsel__sample_size(u64 sample_type)
  95 {
  96         u64 mask = sample_type & PERF_SAMPLE_MASK;
  97         int size = 0;
  98         int i;
  99
 100         for (i = 0; i < 64; i++) {
 101                 if (mask & (1ULL << i))
 102                         size++;
 103         }
 104
 105         size *= sizeof(u64);
 106
 107         return size;
 108 }
 109
 110 /**
 111  * __perf_evsel__calc_id_pos - calculate id_pos.
 112  * @sample_type: sample type
 113  *
 114  * This function returns the position of the event id (PERF_SAMPLE_ID or
 115  * PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of struct
 116  * sample_event.
 117  */
 118 static int __perf_evsel__calc_id_pos(u64 sample_type)
 119 {
 120         int idx = 0;
 121
 122         if (sample_type & PERF_SAMPLE_IDENTIFIER)
 123                 return 0;
 124
 125         if (!(sample_type & PERF_SAMPLE_ID))
 126                 return -1;
 127
 128         if (sample_type & PERF_SAMPLE_IP)
 129                 idx += 1;
 130
 131         if (sample_type & PERF_SAMPLE_TID)
 132                 idx += 1;
 133
 134         if (sample_type & PERF_SAMPLE_TIME)
 135                 idx += 1;
 136
 137         if (sample_type & PERF_SAMPLE_ADDR)
 138                 idx += 1;
 139
 140         return idx;
 141 }
 142
 143 /**
 144  * __perf_evsel__calc_is_pos - calculate is_pos.
 145  * @sample_type: sample type
 146  *
 147  * This function returns the position (counting backwards) of the event id
 148  * (PERF_SAMPLE_ID or PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if
 149  * sample_id_all is used there is an id sample appended to non-sample events.
 150  */
 151 static int __perf_evsel__calc_is_pos(u64 sample_type)
 152 {
 153         int idx = 1;
 154
 155         if (sample_type & PERF_SAMPLE_IDENTIFIER)
 156                 return 1;
 157
 158         if (!(sample_type & PERF_SAMPLE_ID))
 159                 return -1;
 160
 161         if (sample_type & PERF_SAMPLE_CPU)
 162                 idx += 1;
 163
 164         if (sample_type & PERF_SAMPLE_STREAM_ID)
 165                 idx += 1;
 166
 167         return idx;
 168 }
 169
 170 void perf_evsel__calc_id_pos(struct perf_evsel *evsel)
 171 {
 172         evsel->id_pos = __perf_evsel__calc_id_pos(evsel->attr.sample_type);
 173         evsel->is_pos = __perf_evsel__calc_is_pos(evsel->attr.sample_type);
 174 }
 175
 176 void __perf_evsel__set_sample_bit(struct perf_evsel *evsel,
 177                                   enum perf_event_sample_format bit)
 178 {
 179         if (!(evsel->attr.sample_type & bit)) {
 180                 evsel->attr.sample_type |= bit;
 181                 evsel->sample_size += sizeof(u64);
 182                 perf_evsel__calc_id_pos(evsel);
 183         }
 184 }
 185
 186 void __perf_evsel__reset_sample_bit(struct perf_evsel *evsel,
 187                                     enum perf_event_sample_format bit)
 188 {
 189         if (evsel->attr.sample_type & bit) {
 190                 evsel->attr.sample_type &= ~bit;
 191                 evsel->sample_size -= sizeof(u64);
 192                 perf_evsel__calc_id_pos(evsel);
 193         }
 194 }
 195
 196 void perf_evsel__set_sample_id(struct perf_evsel *evsel,
 197                                bool can_sample_identifier)
 198 {
 199         if (can_sample_identifier) {
 200                 perf_evsel__reset_sample_bit(evsel, ID);
 201                 perf_evsel__set_sample_bit(evsel, IDENTIFIER);
 202         } else {
 203                 perf_evsel__set_sample_bit(evsel, ID);
 204         }
 205         evsel->attr.read_format |= PERF_FORMAT_ID;
 206 }
 207
 208 /**
 209  * perf_evsel__is_function_event - Return whether given evsel is a function
 210  * trace event
 211  *
 212  * @evsel - evsel selector to be tested
 213  *
 214  * Return %true if event is function trace event
 215  */
 216 bool perf_evsel__is_function_event(struct perf_evsel *evsel)
 217 {
 218 #define FUNCTION_EVENT "ftrace:function"
 219
 220         return evsel->name &&
 221                !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT));
 222
 223 #undef FUNCTION_EVENT
 224 }
 225
 226 void perf_evsel__init(struct perf_evsel *evsel,
 227                       struct perf_event_attr *attr, int idx)
 228 {
 229         evsel->idx         = idx;
 230         evsel->tracking    = !idx;
 231         evsel->attr        = *attr;
 232         evsel->leader      = evsel;
 233         evsel->unit        = "";
 234         evsel->scale       = 1.0;
 235         evsel->evlist      = NULL;
 236         evsel->bpf_fd      = -1;
 237         INIT_LIST_HEAD(&evsel->node);
 238         INIT_LIST_HEAD(&evsel->config_terms);
 239         perf_evsel__object.init(evsel);
 240         evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
 241         perf_evsel__calc_id_pos(evsel);
 242         evsel->cmdline_group_boundary = false;
 243         evsel->metric_expr   = NULL;
 244         evsel->metric_name   = NULL;
 245         evsel->metric_events = NULL;
 246         evsel->collect_stat  = false;
 247         evsel->pmu_name      = NULL;
 248 }
 249
 250 struct perf_evsel *perf_evsel__new_idx(struct perf_event_attr *attr, int idx)
 251 {
 252         struct perf_evsel *evsel = zalloc(perf_evsel__object.size);
 253
 254         if (!evsel)
 255                 return NULL;
 256         perf_evsel__init(evsel, attr, idx);
 257
 258         if (perf_evsel__is_bpf_output(evsel)) {
 259                 evsel->attr.sample_type |= (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
 260                                             PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD),
 261                 evsel->attr.sample_period = 1;
 262         }
 263
 264         if (perf_evsel__is_clock(evsel)) {
 265                 /*
 266                  * The evsel->unit points to static alias->unit
 267                  * so it's ok to use static string in here.
 268                  */
 269                 static const char *unit = "msec";
 270
 271                 evsel->unit = unit;
 272                 evsel->scale = 1e-6;
 273         }
 274
 275         return evsel;
 276 }
 277
 278 static bool perf_event_can_profile_kernel(void)
 279 {
 280         return geteuid() == 0 || perf_event_paranoid() == -1;
 281 }
 282
 283 struct perf_evsel *perf_evsel__new_cycles(bool precise)
 284 {
 285         struct perf_event_attr attr = {
 286                 .type   = PERF_TYPE_HARDWARE,
 287                 .config = PERF_COUNT_HW_CPU_CYCLES,
 288                 .exclude_kernel = !perf_event_can_profile_kernel(),
 289         };
 290         struct perf_evsel *evsel;
 291
 292         event_attr_init(&attr);
 293
 294         if (!precise)
 295                 goto new_event;
 296         /*
 297          * Unnamed union member, not supported as struct member named
 298          * initializer in older compilers such as gcc 4.4.7
 299          *
 300          * Just for probing the precise_ip:
 301          */
 302         attr.sample_period = 1;
 303
 304         perf_event_attr__set_max_precise_ip(&attr);
 305         /*
 306          * Now let the usual logic to set up the perf_event_attr defaults
 307          * to kick in when we return and before perf_evsel__open() is called.
 308          */
 309         attr.sample_period = 0;
 310 new_event:
 311         evsel = perf_evsel__new(&attr);
 312         if (evsel == NULL)
 313                 goto out;
 314
 315         /* use asprintf() because free(evsel) assumes name is allocated */
 316         if (asprintf(&evsel->name, "cycles%s%s%.*s",
 317                      (attr.precise_ip || attr.exclude_kernel) ? ":" : "",
 318                      attr.exclude_kernel ? "u" : "",
 319                      attr.precise_ip ? attr.precise_ip + 1 : 0, "ppp") < 0)
 320                 goto error_free;
 321 out:
 322         return evsel;
 323 error_free:
 324         perf_evsel__delete(evsel);
 325         evsel = NULL;
 326         goto out;
 327 }
 328
 329 /*
 330  * Returns pointer with encoded error via <linux/err.h> interface.
 331  */
 332 struct perf_evsel *perf_evsel__newtp_idx(const char *sys, const char *name, int idx)
 333 {
 334         struct perf_evsel *evsel = zalloc(perf_evsel__object.size);
 335         int err = -ENOMEM;
 336
 337         if (evsel == NULL) {
 338                 goto out_err;
 339         } else {
 340                 struct perf_event_attr attr = {
 341                         .type          = PERF_TYPE_TRACEPOINT,
 342                         .sample_type   = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
 343                                           PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD),
 344                 };
 345
 346                 if (asprintf(&evsel->name, "%s:%s", sys, name) < 0)
 347                         goto out_free;
 348
 349                 evsel->tp_format = trace_event__tp_format(sys, name);
 350                 if (IS_ERR(evsel->tp_format)) {
 351                         err = PTR_ERR(evsel->tp_format);
 352                         goto out_free;
 353                 }
 354
 355                 event_attr_init(&attr);
 356                 attr.config = evsel->tp_format->id;
 357                 attr.sample_period = 1;
 358                 perf_evsel__init(evsel, &attr, idx);
 359         }
 360
 361         return evsel;
 362
 363 out_free:
 364         zfree(&evsel->name);
 365         free(evsel);
 366 out_err:
 367         return ERR_PTR(err);
 368 }
 369
 370 const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
 371         "cycles",
 372         "instructions",
 373         "cache-references",
 374         "cache-misses",
 375         "branches",
 376         "branch-misses",
 377         "bus-cycles",
 378         "stalled-cycles-frontend",
 379         "stalled-cycles-backend",
 380         "ref-cycles",
 381 };
 382
 383 static const char *__perf_evsel__hw_name(u64 config)
 384 {
 385         if (config < PERF_COUNT_HW_MAX && perf_evsel__hw_names[config])
 386                 return perf_evsel__hw_names[config];
 387
 388         return "unknown-hardware";
 389 }
 390
 391 static int perf_evsel__add_modifiers(struct perf_evsel *evsel, char *bf, size_t size)
 392 {
 393         int colon = 0, r = 0;
 394         struct perf_event_attr *attr = &evsel->attr;
 395         bool exclude_guest_default = false;
 396
 397 #define MOD_PRINT(context, mod) do {                                    \
 398                 if (!attr->exclude_##context) {                         \
 399                         if (!colon) colon = ++r;                        \
 400                         r += scnprintf(bf + r, size - r, "%c", mod);    \
 401                 } } while(0)
 402
 403         if (attr->exclude_kernel || attr->exclude_user || attr->exclude_hv) {
 404                 MOD_PRINT(kernel, 'k');
 405                 MOD_PRINT(user, 'u');
 406                 MOD_PRINT(hv, 'h');
 407                 exclude_guest_default = true;
 408         }
 409
 410         if (attr->precise_ip) {
 411                 if (!colon)
 412                         colon = ++r;
 413                 r += scnprintf(bf + r, size - r, "%.*s", attr->precise_ip, "ppp");
 414                 exclude_guest_default = true;
 415         }
 416
 417         if (attr->exclude_host || attr->exclude_guest == exclude_guest_default) {
 418                 MOD_PRINT(host, 'H');
 419                 MOD_PRINT(guest, 'G');
 420         }
 421 #undef MOD_PRINT
 422         if (colon)
 423                 bf[colon - 1] = ':';
 424         return r;
 425 }
 426
 427 static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
 428 {
 429         int r = scnprintf(bf, size, "%s", __perf_evsel__hw_name(evsel->attr.config));
 430         return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
 431 }
 432
 433 const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
 434         "cpu-clock",
 435         "task-clock",
 436         "page-faults",
 437         "context-switches",
 438         "cpu-migrations",
 439         "minor-faults",
 440         "major-faults",
 441         "alignment-faults",
 442         "emulation-faults",
 443         "dummy",
 444 };
 445
 446 static const char *__perf_evsel__sw_name(u64 config)
 447 {
 448         if (config < PERF_COUNT_SW_MAX && perf_evsel__sw_names[config])
 449                 return perf_evsel__sw_names[config];
 450         return "unknown-software";
 451 }
 452
 453 static int perf_evsel__sw_name(struct perf_evsel *evsel, char *bf, size_t size)
 454 {
 455         int r = scnprintf(bf, size, "%s", __perf_evsel__sw_name(evsel->attr.config));
 456         return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
 457 }
 458
 459 static int __perf_evsel__bp_name(char *bf, size_t size, u64 addr, u64 type)
 460 {
 461         int r;
 462
 463         r = scnprintf(bf, size, "mem:0x%" PRIx64 ":", addr);
 464
 465         if (type & HW_BREAKPOINT_R)
 466                 r += scnprintf(bf + r, size - r, "r");
 467
 468         if (type & HW_BREAKPOINT_W)
 469                 r += scnprintf(bf + r, size - r, "w");
 470
 471         if (type & HW_BREAKPOINT_X)
 472                 r += scnprintf(bf + r, size - r, "x");
 473
 474         return r;
 475 }
 476
 477 static int perf_evsel__bp_name(struct perf_evsel *evsel, char *bf, size_t size)
 478 {
 479         struct perf_event_attr *attr = &evsel->attr;
 480         int r = __perf_evsel__bp_name(bf, size, attr->bp_addr, attr->bp_type);
 481         return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
 482 }
 483
 484 const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
 485                                 [PERF_EVSEL__MAX_ALIASES] = {
 486  { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
 487  { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
 488  { "LLC",       "L2",                                                   },
 489  { "dTLB",      "d-tlb",        "Data-TLB",                             },
 490  { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
 491  { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
 492  { "node",                                                              },
 493 };
 494
 495 const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
 496                                    [PERF_EVSEL__MAX_ALIASES] = {
 497  { "load",      "loads",        "read",                                 },
 498  { "store",     "stores",       "write",                                },
 499  { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
 500 };
 501
 502 const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
 503                                        [PERF_EVSEL__MAX_ALIASES] = {
 504  { "refs",      "Reference",    "ops",          "access",               },
 505  { "misses",    "miss",                                                 },
 506 };
 507
 508 #define C(x)            PERF_COUNT_HW_CACHE_##x
 509 #define CACHE_READ      (1 << C(OP_READ))
 510 #define CACHE_WRITE     (1 << C(OP_WRITE))
 511 #define CACHE_PREFETCH  (1 << C(OP_PREFETCH))
 512 #define COP(x)          (1 << x)
 513
 514 /*
 515  * cache operartion stat
 516  * L1I : Read and prefetch only
 517  * ITLB and BPU : Read-only
 518  */
 519 static unsigned long perf_evsel__hw_cache_stat[C(MAX)] = {
 520  [C(L1D)]       = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 521  [C(L1I)]       = (CACHE_READ | CACHE_PREFETCH),
 522  [C(LL)]        = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 523  [C(DTLB)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 524  [C(ITLB)]      = (CACHE_READ),
 525  [C(BPU)]       = (CACHE_READ),
 526  [C(NODE)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 527 };
 528
 529 bool perf_evsel__is_cache_op_valid(u8 type, u8 op)
 530 {
 531         if (perf_evsel__hw_cache_stat[type] & COP(op))
 532                 return true;    /* valid */
 533         else
 534                 return false;   /* invalid */
 535 }
 536
 537 int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
 538                                             char *bf, size_t size)
 539 {
 540         if (result) {
 541                 return scnprintf(bf, size, "%s-%s-%s", perf_evsel__hw_cache[type][0],
 542                                  perf_evsel__hw_cache_op[op][0],
 543                                  perf_evsel__hw_cache_result[result][0]);
 544         }
 545
 546         return scnprintf(bf, size, "%s-%s", perf_evsel__hw_cache[type][0],
 547                          perf_evsel__hw_cache_op[op][1]);
 548 }
 549
 550 static int __perf_evsel__hw_cache_name(u64 config, char *bf, size_t size)
 551 {
 552         u8 op, result, type = (config >>  0) & 0xff;
 553         const char *err = "unknown-ext-hardware-cache-type";
 554
 555         if (type >= PERF_COUNT_HW_CACHE_MAX)
 556                 goto out_err;
 557
 558         op = (config >>  8) & 0xff;
 559         err = "unknown-ext-hardware-cache-op";
 560         if (op >= PERF_COUNT_HW_CACHE_OP_MAX)
 561                 goto out_err;
 562
 563         result = (config >> 16) & 0xff;
 564         err = "unknown-ext-hardware-cache-result";
 565         if (result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
 566                 goto out_err;
 567
 568         err = "invalid-cache";
 569         if (!perf_evsel__is_cache_op_valid(type, op))
 570                 goto out_err;
 571
 572         return __perf_evsel__hw_cache_type_op_res_name(type, op, result, bf, size);
 573 out_err:
 574         return scnprintf(bf, size, "%s", err);
 575 }
 576
 577 static int perf_evsel__hw_cache_name(struct perf_evsel *evsel, char *bf, size_t size)
 578 {
 579         int ret = __perf_evsel__hw_cache_name(evsel->attr.config, bf, size);
 580         return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
 581 }
 582
 583 static int perf_evsel__raw_name(struct perf_evsel *evsel, char *bf, size_t size)
 584 {
 585         int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->attr.config);
 586         return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
 587 }
 588
 589 const char *perf_evsel__name(struct perf_evsel *evsel)
 590 {
 591         char bf[128];
 592
 593         if (evsel->name)
 594                 return evsel->name;
 595
 596         switch (evsel->attr.type) {
 597         case PERF_TYPE_RAW:
 598                 perf_evsel__raw_name(evsel, bf, sizeof(bf));
 599                 break;
 600
 601         case PERF_TYPE_HARDWARE:
 602                 perf_evsel__hw_name(evsel, bf, sizeof(bf));
 603                 break;
 604
 605         case PERF_TYPE_HW_CACHE:
 606                 perf_evsel__hw_cache_name(evsel, bf, sizeof(bf));
 607                 break;
 608
 609         case PERF_TYPE_SOFTWARE:
 610                 perf_evsel__sw_name(evsel, bf, sizeof(bf));
 611                 break;
 612
 613         case PERF_TYPE_TRACEPOINT:
 614                 scnprintf(bf, sizeof(bf), "%s", "unknown tracepoint");
 615                 break;
 616
 617         case PERF_TYPE_BREAKPOINT:
 618                 perf_evsel__bp_name(evsel, bf, sizeof(bf));
 619                 break;
 620
 621         default:
 622                 scnprintf(bf, sizeof(bf), "unknown attr type: %d",
 623                           evsel->attr.type);
 624                 break;
 625         }
 626
 627         evsel->name = strdup(bf);
 628
 629         return evsel->name ?: "unknown";
 630 }
 631
 632 const char *perf_evsel__group_name(struct perf_evsel *evsel)
 633 {
 634         return evsel->group_name ?: "anon group";
 635 }
 636
 637 /*
 638  * Returns the group details for the specified leader,
 639  * with following rules.
 640  *
 641  *  For record -e '{cycles,instructions}'
 642  *    'anon group { cycles:u, instructions:u }'
 643  *
 644  *  For record -e 'cycles,instructions' and report --group
 645  *    'cycles:u, instructions:u'
 646  */
 647 int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size)
 648 {
 649         int ret = 0;
 650         struct perf_evsel *pos;
 651         const char *group_name = perf_evsel__group_name(evsel);
 652
 653         if (!evsel->forced_leader)
 654                 ret = scnprintf(buf, size, "%s { ", group_name);
 655
 656         ret += scnprintf(buf + ret, size - ret, "%s",
 657                          perf_evsel__name(evsel));
 658
 659         for_each_group_member(pos, evsel)
 660                 ret += scnprintf(buf + ret, size - ret, ", %s",
 661                                  perf_evsel__name(pos));
 662
 663         if (!evsel->forced_leader)
 664                 ret += scnprintf(buf + ret, size - ret, " }");
 665
 666         return ret;
 667 }
 668
 669 static void __perf_evsel__config_callchain(struct perf_evsel *evsel,
 670                                            struct record_opts *opts,
 671                                            struct callchain_param *param)
 672 {
 673         bool function = perf_evsel__is_function_event(evsel);
 674         struct perf_event_attr *attr = &evsel->attr;
 675
 676         perf_evsel__set_sample_bit(evsel, CALLCHAIN);
 677
 678         attr->sample_max_stack = param->max_stack;
 679
 680         if (param->record_mode == CALLCHAIN_LBR) {
 681                 if (!opts->branch_stack) {
 682                         if (attr->exclude_user) {
 683                                 pr_warning("LBR callstack option is only available "
 684                                            "to get user callchain information. "
 685                                            "Falling back to framepointers.\n");
 686                         } else {
 687                                 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
 688                                 attr->branch_sample_type = PERF_SAMPLE_BRANCH_USER |
 689                                                         PERF_SAMPLE_BRANCH_CALL_STACK |
 690                                                         PERF_SAMPLE_BRANCH_NO_CYCLES |
 691                                                         PERF_SAMPLE_BRANCH_NO_FLAGS;
 692                         }
 693                 } else
 694                          pr_warning("Cannot use LBR callstack with branch stack. "
 695                                     "Falling back to framepointers.\n");
 696         }
 697
 698         if (param->record_mode == CALLCHAIN_DWARF) {
 699                 if (!function) {
 700                         perf_evsel__set_sample_bit(evsel, REGS_USER);
 701                         perf_evsel__set_sample_bit(evsel, STACK_USER);
 702                         attr->sample_regs_user |= PERF_REGS_MASK;
 703                         attr->sample_stack_user = param->dump_size;
 704                         attr->exclude_callchain_user = 1;
 705                 } else {
 706                         pr_info("Cannot use DWARF unwind for function trace event,"
 707                                 " falling back to framepointers.\n");
 708                 }
 709         }
 710
 711         if (function) {
 712                 pr_info("Disabling user space callchains for function trace event.\n");
 713                 attr->exclude_callchain_user = 1;
 714         }
 715 }
 716
 717 void perf_evsel__config_callchain(struct perf_evsel *evsel,
 718                                   struct record_opts *opts,
 719                                   struct callchain_param *param)
 720 {
 721         if (param->enabled)
 722                 return __perf_evsel__config_callchain(evsel, opts, param);
 723 }
 724
 725 static void
 726 perf_evsel__reset_callgraph(struct perf_evsel *evsel,
 727                             struct callchain_param *param)
 728 {
 729         struct perf_event_attr *attr = &evsel->attr;
 730
 731         perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
 732         if (param->record_mode == CALLCHAIN_LBR) {
 733                 perf_evsel__reset_sample_bit(evsel, BRANCH_STACK);
 734                 attr->branch_sample_type &= ~(PERF_SAMPLE_BRANCH_USER |
 735                                               PERF_SAMPLE_BRANCH_CALL_STACK);
 736         }
 737         if (param->record_mode == CALLCHAIN_DWARF) {
 738                 perf_evsel__reset_sample_bit(evsel, REGS_USER);
 739                 perf_evsel__reset_sample_bit(evsel, STACK_USER);
 740         }
 741 }
 742
 743 static void apply_config_terms(struct perf_evsel *evsel,
 744                                struct record_opts *opts, bool track)
 745 {
 746         struct perf_evsel_config_term *term;
 747         struct list_head *config_terms = &evsel->config_terms;
 748         struct perf_event_attr *attr = &evsel->attr;
 749         /* callgraph default */
 750         struct callchain_param param = {
 751                 .record_mode = callchain_param.record_mode,
 752         };
 753         u32 dump_size = 0;
 754         int max_stack = 0;
 755         const char *callgraph_buf = NULL;
 756
 757         list_for_each_entry(term, config_terms, list) {
 758                 switch (term->type) {
 759                 case PERF_EVSEL__CONFIG_TERM_PERIOD:
 760                         if (!(term->weak && opts->user_interval != ULLONG_MAX)) {
 761                                 attr->sample_period = term->val.period;
 762                                 attr->freq = 0;
 763                                 perf_evsel__reset_sample_bit(evsel, PERIOD);
 764                         }
 765                         break;
 766                 case PERF_EVSEL__CONFIG_TERM_FREQ:
 767                         if (!(term->weak && opts->user_freq != UINT_MAX)) {
 768                                 attr->sample_freq = term->val.freq;
 769                                 attr->freq = 1;
 770                                 perf_evsel__set_sample_bit(evsel, PERIOD);
 771                         }
 772                         break;
 773                 case PERF_EVSEL__CONFIG_TERM_TIME:
 774                         if (term->val.time)
 775                                 perf_evsel__set_sample_bit(evsel, TIME);
 776                         else
 777                                 perf_evsel__reset_sample_bit(evsel, TIME);
 778                         break;
 779                 case PERF_EVSEL__CONFIG_TERM_CALLGRAPH:
 780                         callgraph_buf = term->val.callgraph;
 781                         break;
 782                 case PERF_EVSEL__CONFIG_TERM_BRANCH:
 783                         if (term->val.branch && strcmp(term->val.branch, "no")) {
 784                                 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
 785                                 parse_branch_str(term->val.branch,
 786                                                  &attr->branch_sample_type);
 787                         } else
 788                                 perf_evsel__reset_sample_bit(evsel, BRANCH_STACK);
 789                         break;
 790                 case PERF_EVSEL__CONFIG_TERM_STACK_USER:
 791                         dump_size = term->val.stack_user;
 792                         break;
 793                 case PERF_EVSEL__CONFIG_TERM_MAX_STACK:
 794                         max_stack = term->val.max_stack;
 795                         break;
 796                 case PERF_EVSEL__CONFIG_TERM_INHERIT:
 797                         /*
 798                          * attr->inherit should has already been set by
 799                          * perf_evsel__config. If user explicitly set
 800                          * inherit using config terms, override global
 801                          * opt->no_inherit setting.
 802                          */
 803                         attr->inherit = term->val.inherit ? 1 : 0;
 804                         break;
 805                 case PERF_EVSEL__CONFIG_TERM_OVERWRITE:
 806                         attr->write_backward = term->val.overwrite ? 1 : 0;
 807                         break;
 808                 case PERF_EVSEL__CONFIG_TERM_DRV_CFG:
 809                         break;
 810                 default:
 811                         break;
 812                 }
 813         }
 814
 815         /* User explicitly set per-event callgraph, clear the old setting and reset. */
 816         if ((callgraph_buf != NULL) || (dump_size > 0) || max_stack) {
 817                 bool sample_address = false;
 818
 819                 if (max_stack) {
 820                         param.max_stack = max_stack;
 821                         if (callgraph_buf == NULL)
 822                                 callgraph_buf = "fp";
 823                 }
 824
 825                 /* parse callgraph parameters */
 826                 if (callgraph_buf != NULL) {
 827                         if (!strcmp(callgraph_buf, "no")) {
 828                                 param.enabled = false;
 829                                 param.record_mode = CALLCHAIN_NONE;
 830                         } else {
 831                                 param.enabled = true;
 832                                 if (parse_callchain_record(callgraph_buf, &param)) {
 833                                         pr_err("per-event callgraph setting for %s failed. "
 834                                                "Apply callgraph global setting for it\n",
 835                                                evsel->name);
 836                                         return;
 837                                 }
 838                                 if (param.record_mode == CALLCHAIN_DWARF)
 839                                         sample_address = true;
 840                         }
 841                 }
 842                 if (dump_size > 0) {
 843                         dump_size = round_up(dump_size, sizeof(u64));
 844                         param.dump_size = dump_size;
 845                 }
 846
 847                 /* If global callgraph set, clear it */
 848                 if (callchain_param.enabled)
 849                         perf_evsel__reset_callgraph(evsel, &callchain_param);
 850
 851                 /* set perf-event callgraph */
 852                 if (param.enabled) {
 853                         if (sample_address) {
 854                                 perf_evsel__set_sample_bit(evsel, ADDR);
 855                                 perf_evsel__set_sample_bit(evsel, DATA_SRC);
 856                                 evsel->attr.mmap_data = track;
 857                         }
 858                         perf_evsel__config_callchain(evsel, opts, &param);
 859                 }
 860         }
 861 }
 862
 863 static bool is_dummy_event(struct perf_evsel *evsel)
 864 {
 865         return (evsel->attr.type == PERF_TYPE_SOFTWARE) &&
 866                (evsel->attr.config == PERF_COUNT_SW_DUMMY);
 867 }
 868
 869 /*
 870  * The enable_on_exec/disabled value strategy:
 871  *
 872  *  1) For any type of traced program:
 873  *    - all independent events and group leaders are disabled
 874  *    - all group members are enabled
 875  *
 876  *     Group members are ruled by group leaders. They need to
 877  *     be enabled, because the group scheduling relies on that.
 878  *
 879  *  2) For traced programs executed by perf:
 880  *     - all independent events and group leaders have
 881  *       enable_on_exec set
 882  *     - we don't specifically enable or disable any event during
 883  *       the record command
 884  *
 885  *     Independent events and group leaders are initially disabled
 886  *     and get enabled by exec. Group members are ruled by group
 887  *     leaders as stated in 1).
 888  *
 889  *  3) For traced programs attached by perf (pid/tid):
 890  *     - we specifically enable or disable all events during
 891  *       the record command
 892  *
 893  *     When attaching events to already running traced we
 894  *     enable/disable events specifically, as there's no
 895  *     initial traced exec call.
 896  */
 897 void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
 898                         struct callchain_param *callchain)
 899 {
 900         struct perf_evsel *leader = evsel->leader;
 901         struct perf_event_attr *attr = &evsel->attr;
 902         int track = evsel->tracking;
 903         bool per_cpu = opts->target.default_per_cpu && !opts->target.per_thread;
 904
 905         attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1;
 906         attr->inherit       = !opts->no_inherit;
 907         attr->write_backward = opts->overwrite ? 1 : 0;
 908
 909         perf_evsel__set_sample_bit(evsel, IP);
 910         perf_evsel__set_sample_bit(evsel, TID);
 911
 912         if (evsel->sample_read) {
 913                 perf_evsel__set_sample_bit(evsel, READ);
 914
 915                 /*
 916                  * We need ID even in case of single event, because
 917                  * PERF_SAMPLE_READ process ID specific data.
 918                  */
 919                 perf_evsel__set_sample_id(evsel, false);
 920
 921                 /*
 922                  * Apply group format only if we belong to group
 923                  * with more than one members.
 924                  */
 925                 if (leader->nr_members > 1) {
 926                         attr->read_format |= PERF_FORMAT_GROUP;
 927                         attr->inherit = 0;
 928                 }
 929         }
 930
 931         /*
 932          * We default some events to have a default interval. But keep
 933          * it a weak assumption overridable by the user.
 934          */
 935         if (!attr->sample_period || (opts->user_freq != UINT_MAX ||
 936                                      opts->user_interval != ULLONG_MAX)) {
 937                 if (opts->freq) {
 938                         perf_evsel__set_sample_bit(evsel, PERIOD);
 939                         attr->freq              = 1;
 940                         attr->sample_freq       = opts->freq;
 941                 } else {
 942                         attr->sample_period = opts->default_interval;
 943                 }
 944         }
 945
 946         /*
 947          * Disable sampling for all group members other
 948          * than leader in case leader 'leads' the sampling.
 949          */
 950         if ((leader != evsel) && leader->sample_read) {
 951                 attr->freq           = 0;
 952                 attr->sample_freq    = 0;
 953                 attr->sample_period  = 0;
 954                 attr->write_backward = 0;
 955                 attr->sample_id_all  = 0;
 956         }
 957
 958         if (opts->no_samples)
 959                 attr->sample_freq = 0;
 960
 961         if (opts->inherit_stat) {
 962                 evsel->attr.read_format |=
 963                         PERF_FORMAT_TOTAL_TIME_ENABLED |
 964                         PERF_FORMAT_TOTAL_TIME_RUNNING |
 965                         PERF_FORMAT_ID;
 966                 attr->inherit_stat = 1;
 967         }
 968
 969         if (opts->sample_address) {
 970                 perf_evsel__set_sample_bit(evsel, ADDR);
 971                 attr->mmap_data = track;
 972         }
 973
 974         /*
 975          * We don't allow user space callchains for  function trace
 976          * event, due to issues with page faults while tracing page
 977          * fault handler and its overall trickiness nature.
 978          */
 979         if (perf_evsel__is_function_event(evsel))
 980                 evsel->attr.exclude_callchain_user = 1;
 981
 982         if (callchain && callchain->enabled && !evsel->no_aux_samples)
 983                 perf_evsel__config_callchain(evsel, opts, callchain);
 984
 985         if (opts->sample_intr_regs) {
 986                 attr->sample_regs_intr = opts->sample_intr_regs;
 987                 perf_evsel__set_sample_bit(evsel, REGS_INTR);
 988         }
 989
 990         if (opts->sample_user_regs) {
 991                 attr->sample_regs_user |= opts->sample_user_regs;
 992                 perf_evsel__set_sample_bit(evsel, REGS_USER);
 993         }
 994
 995         if (target__has_cpu(&opts->target) || opts->sample_cpu)
 996                 perf_evsel__set_sample_bit(evsel, CPU);
 997
 998         /*
 999          * When the user explicitly disabled time don't force it here.
1000          */
1001         if (opts->sample_time &&
1002             (!perf_missing_features.sample_id_all &&
1003             (!opts->no_inherit || target__has_cpu(&opts->target) || per_cpu ||
1004              opts->sample_time_set)))
1005                 perf_evsel__set_sample_bit(evsel, TIME);
1006
1007         if (opts->raw_samples && !evsel->no_aux_samples) {
1008                 perf_evsel__set_sample_bit(evsel, TIME);
1009                 perf_evsel__set_sample_bit(evsel, RAW);
1010                 perf_evsel__set_sample_bit(evsel, CPU);
1011         }
1012
1013         if (opts->sample_address)
1014                 perf_evsel__set_sample_bit(evsel, DATA_SRC);
1015
1016         if (opts->sample_phys_addr)
1017                 perf_evsel__set_sample_bit(evsel, PHYS_ADDR);
1018
1019         if (opts->no_buffering) {
1020                 attr->watermark = 0;
1021                 attr->wakeup_events = 1;
1022         }
1023         if (opts->branch_stack && !evsel->no_aux_samples) {
1024                 perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
1025                 attr->branch_sample_type = opts->branch_stack;
1026         }
1027
1028         if (opts->sample_weight)
1029                 perf_evsel__set_sample_bit(evsel, WEIGHT);
1030
1031         attr->task  = track;
1032         attr->mmap  = track;
1033         attr->mmap2 = track && !perf_missing_features.mmap2;
1034         attr->comm  = track;
1035
1036         if (opts->record_namespaces)
1037                 attr->namespaces  = track;
1038
1039         if (opts->record_switch_events)
1040                 attr->context_switch = track;
1041
1042         if (opts->sample_transaction)
1043                 perf_evsel__set_sample_bit(evsel, TRANSACTION);
1044
1045         if (opts->running_time) {
1046                 evsel->attr.read_format |=
1047                         PERF_FORMAT_TOTAL_TIME_ENABLED |
1048                         PERF_FORMAT_TOTAL_TIME_RUNNING;
1049         }
1050
1051         /*
1052          * XXX see the function comment above
1053          *
1054          * Disabling only independent events or group leaders,
1055          * keeping group members enabled.
1056          */
1057         if (perf_evsel__is_group_leader(evsel))
1058                 attr->disabled = 1;
1059
1060         /*
1061          * Setting enable_on_exec for independent events and
1062          * group leaders for traced executed by perf.
1063          */
1064         if (target__none(&opts->target) && perf_evsel__is_group_leader(evsel) &&
1065                 !opts->initial_delay)
1066                 attr->enable_on_exec = 1;
1067
1068         if (evsel->immediate) {
1069                 attr->disabled = 0;
1070                 attr->enable_on_exec = 0;
1071         }
1072
1073         clockid = opts->clockid;
1074         if (opts->use_clockid) {
1075                 attr->use_clockid = 1;
1076                 attr->clockid = opts->clockid;
1077         }
1078
1079         if (evsel->precise_max)
1080                 perf_event_attr__set_max_precise_ip(attr);
1081
1082         if (opts->all_user) {
1083                 attr->exclude_kernel = 1;
1084                 attr->exclude_user   = 0;
1085         }
1086
1087         if (opts->all_kernel) {
1088                 attr->exclude_kernel = 0;
1089                 attr->exclude_user   = 1;
1090         }
1091
1092         /*
1093          * Apply event specific term settings,
1094          * it overloads any global configuration.
1095          */
1096         apply_config_terms(evsel, opts, track);
1097
1098         evsel->ignore_missing_thread = opts->ignore_missing_thread;
1099
1100         /* The --period option takes the precedence. */
1101         if (opts->period_set) {
1102                 if (opts->period)
1103                         perf_evsel__set_sample_bit(evsel, PERIOD);
1104                 else
1105                         perf_evsel__reset_sample_bit(evsel, PERIOD);
1106         }
1107
1108         /*
1109          * For initial_delay, a dummy event is added implicitly.
1110          * The software event will trigger -EOPNOTSUPP error out,
1111          * if BRANCH_STACK bit is set.
1112          */
1113         if (opts->initial_delay && is_dummy_event(evsel))
1114                 perf_evsel__reset_sample_bit(evsel, BRANCH_STACK);
1115 }
1116
1117 static int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
1118 {
1119         if (evsel->system_wide)
1120                 nthreads = 1;
1121
1122         evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
1123
1124         if (evsel->fd) {
1125                 int cpu, thread;
1126                 for (cpu = 0; cpu < ncpus; cpu++) {
1127                         for (thread = 0; thread < nthreads; thread++) {
1128                                 FD(evsel, cpu, thread) = -1;
1129                         }
1130                 }
1131         }
1132
1133         return evsel->fd != NULL ? 0 : -ENOMEM;
1134 }
1135
1136 static int perf_evsel__run_ioctl(struct perf_evsel *evsel,
1137                           int ioc,  void *arg)
1138 {
1139         int cpu, thread;
1140
1141         for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++) {
1142                 for (thread = 0; thread < xyarray__max_y(evsel->fd); thread++) {
1143                         int fd = FD(evsel, cpu, thread),
1144                             err = ioctl(fd, ioc, arg);
1145
1146                         if (err)
1147                                 return err;
1148                 }
1149         }
1150
1151         return 0;
1152 }
1153
1154 int perf_evsel__apply_filter(struct perf_evsel *evsel, const char *filter)
1155 {
1156         return perf_evsel__run_ioctl(evsel,
1157                                      PERF_EVENT_IOC_SET_FILTER,
1158                                      (void *)filter);
1159 }
1160
1161 int perf_evsel__set_filter(struct perf_evsel *evsel, const char *filter)
1162 {
1163         char *new_filter = strdup(filter);
1164
1165         if (new_filter != NULL) {
1166                 free(evsel->filter);
1167                 evsel->filter = new_filter;
1168                 return 0;
1169         }
1170
1171         return -1;
1172 }
1173
1174 static int perf_evsel__append_filter(struct perf_evsel *evsel,
1175                                      const char *fmt, const char *filter)
1176 {
1177         char *new_filter;
1178
1179         if (evsel->filter == NULL)
1180                 return perf_evsel__set_filter(evsel, filter);
1181
1182         if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) {
1183                 free(evsel->filter);
1184                 evsel->filter = new_filter;
1185                 return 0;
1186         }
1187
1188         return -1;
1189 }
1190
1191 int perf_evsel__append_tp_filter(struct perf_evsel *evsel, const char *filter)
1192 {
1193         return perf_evsel__append_filter(evsel, "(%s) && (%s)", filter);
1194 }
1195
1196 int perf_evsel__append_addr_filter(struct perf_evsel *evsel, const char *filter)
1197 {
1198         return perf_evsel__append_filter(evsel, "%s,%s", filter);
1199 }
1200
1201 int perf_evsel__enable(struct perf_evsel *evsel)
1202 {
1203         return perf_evsel__run_ioctl(evsel,
1204                                      PERF_EVENT_IOC_ENABLE,
1205                                      0);
1206 }
1207
1208 int perf_evsel__disable(struct perf_evsel *evsel)
1209 {
1210         return perf_evsel__run_ioctl(evsel,
1211                                      PERF_EVENT_IOC_DISABLE,
1212                                      0);
1213 }
1214
1215 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
1216 {
1217         if (ncpus == 0 || nthreads == 0)
1218                 return 0;
1219
1220         if (evsel->system_wide)
1221                 nthreads = 1;
1222
1223         evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
1224         if (evsel->sample_id == NULL)
1225                 return -ENOMEM;
1226
1227         evsel->id = zalloc(ncpus * nthreads * sizeof(u64));
1228         if (evsel->id == NULL) {
1229                 xyarray__delete(evsel->sample_id);
1230                 evsel->sample_id = NULL;
1231                 return -ENOMEM;
1232         }
1233
1234         return 0;
1235 }
1236
1237 static void perf_evsel__free_fd(struct perf_evsel *evsel)
1238 {
1239         xyarray__delete(evsel->fd);
1240         evsel->fd = NULL;
1241 }
1242
1243 static void perf_evsel__free_id(struct perf_evsel *evsel)
1244 {
1245         xyarray__delete(evsel->sample_id);
1246         evsel->sample_id = NULL;
1247         zfree(&evsel->id);
1248 }
1249
1250 static void perf_evsel__free_config_terms(struct perf_evsel *evsel)
1251 {
1252         struct perf_evsel_config_term *term, *h;
1253
1254         list_for_each_entry_safe(term, h, &evsel->config_terms, list) {
1255                 list_del(&term->list);
1256                 free(term);
1257         }
1258 }
1259
1260 void perf_evsel__close_fd(struct perf_evsel *evsel)
1261 {
1262         int cpu, thread;
1263
1264         for (cpu = 0; cpu < xyarray__max_x(evsel->fd); cpu++)
1265                 for (thread = 0; thread < xyarray__max_y(evsel->fd); ++thread) {
1266                         close(FD(evsel, cpu, thread));
1267                         FD(evsel, cpu, thread) = -1;
1268                 }
1269 }
1270
1271 void perf_evsel__exit(struct perf_evsel *evsel)
1272 {
1273         assert(list_empty(&evsel->node));
1274         assert(evsel->evlist == NULL);
1275         perf_evsel__free_fd(evsel);
1276         perf_evsel__free_id(evsel);
1277         perf_evsel__free_config_terms(evsel);
1278         cgroup__put(evsel->cgrp);
1279         cpu_map__put(evsel->cpus);
1280         cpu_map__put(evsel->own_cpus);
1281         thread_map__put(evsel->threads);
1282         zfree(&evsel->group_name);
1283         zfree(&evsel->name);
1284         perf_evsel__object.fini(evsel);
1285 }
1286
1287 void perf_evsel__delete(struct perf_evsel *evsel)
1288 {
1289         perf_evsel__exit(evsel);
1290         free(evsel);
1291 }
1292
1293 void perf_evsel__compute_deltas(struct perf_evsel *evsel, int cpu, int thread,
1294                                 struct perf_counts_values *count)
1295 {
1296         struct perf_counts_values tmp;
1297
1298         if (!evsel->prev_raw_counts)
1299                 return;
1300
1301         if (cpu == -1) {
1302                 tmp = evsel->prev_raw_counts->aggr;
1303                 evsel->prev_raw_counts->aggr = *count;
1304         } else {
1305                 tmp = *perf_counts(evsel->prev_raw_counts, cpu, thread);
1306                 *perf_counts(evsel->prev_raw_counts, cpu, thread) = *count;
1307         }
1308
1309         count->val = count->val - tmp.val;
1310         count->ena = count->ena - tmp.ena;
1311         count->run = count->run - tmp.run;
1312 }
1313
1314 void perf_counts_values__scale(struct perf_counts_values *count,
1315                                bool scale, s8 *pscaled)
1316 {
1317         s8 scaled = 0;
1318
1319         if (scale) {
1320                 if (count->run == 0) {
1321                         scaled = -1;
1322                         count->val = 0;
1323                 } else if (count->run < count->ena) {
1324                         scaled = 1;
1325                         count->val = (u64)((double) count->val * count->ena / count->run + 0.5);
1326                 }
1327         } else
1328                 count->ena = count->run = 0;
1329
1330         if (pscaled)
1331                 *pscaled = scaled;
1332 }
1333
1334 static int perf_evsel__read_size(struct perf_evsel *evsel)
1335 {
1336         u64 read_format = evsel->attr.read_format;
1337         int entry = sizeof(u64); /* value */
1338         int size = 0;
1339         int nr = 1;
1340
1341         if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1342                 size += sizeof(u64);
1343
1344         if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1345                 size += sizeof(u64);
1346
1347         if (read_format & PERF_FORMAT_ID)
1348                 entry += sizeof(u64);
1349
1350         if (read_format & PERF_FORMAT_GROUP) {
1351                 nr = evsel->nr_members;
1352                 size += sizeof(u64);
1353         }
1354
1355         size += entry * nr;
1356         return size;
1357 }
1358
1359 int perf_evsel__read(struct perf_evsel *evsel, int cpu, int thread,
1360                      struct perf_counts_values *count)
1361 {
1362         size_t size = perf_evsel__read_size(evsel);
1363
1364         memset(count, 0, sizeof(*count));
1365
1366         if (FD(evsel, cpu, thread) < 0)
1367                 return -EINVAL;
1368
1369         if (readn(FD(evsel, cpu, thread), count->values, size) <= 0)
1370                 return -errno;
1371
1372         return 0;
1373 }
1374
1375 static int
1376 perf_evsel__read_one(struct perf_evsel *evsel, int cpu, int thread)
1377 {
1378         struct perf_counts_values *count = perf_counts(evsel->counts, cpu, thread);
1379
1380         return perf_evsel__read(evsel, cpu, thread, count);
1381 }
1382
1383 static void
1384 perf_evsel__set_count(struct perf_evsel *counter, int cpu, int thread,
1385                       u64 val, u64 ena, u64 run)
1386 {
1387         struct perf_counts_values *count;
1388
1389         count = perf_counts(counter->counts, cpu, thread);
1390
1391         count->val    = val;
1392         count->ena    = ena;
1393         count->run    = run;
1394         count->loaded = true;
1395 }
1396
1397 static int
1398 perf_evsel__process_group_data(struct perf_evsel *leader,
1399                                int cpu, int thread, u64 *data)
1400 {
1401         u64 read_format = leader->attr.read_format;
1402         struct sample_read_value *v;
1403         u64 nr, ena = 0, run = 0, i;
1404
1405         nr = *data++;
1406
1407         if (nr != (u64) leader->nr_members)
1408                 return -EINVAL;
1409
1410         if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1411                 ena = *data++;
1412
1413         if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1414                 run = *data++;
1415
1416         v = (struct sample_read_value *) data;
1417
1418         perf_evsel__set_count(leader, cpu, thread,
1419                               v[0].value, ena, run);
1420
1421         for (i = 1; i < nr; i++) {
1422                 struct perf_evsel *counter;
1423
1424                 counter = perf_evlist__id2evsel(leader->evlist, v[i].id);
1425                 if (!counter)
1426                         return -EINVAL;
1427
1428                 perf_evsel__set_count(counter, cpu, thread,
1429                                       v[i].value, ena, run);
1430         }
1431
1432         return 0;
1433 }
1434
1435 static int
1436 perf_evsel__read_group(struct perf_evsel *leader, int cpu, int thread)
1437 {
1438         struct perf_stat_evsel *ps = leader->stats;
1439         u64 read_format = leader->attr.read_format;
1440         int size = perf_evsel__read_size(leader);
1441         u64 *data = ps->group_data;
1442
1443         if (!(read_format & PERF_FORMAT_ID))
1444                 return -EINVAL;
1445
1446         if (!perf_evsel__is_group_leader(leader))
1447                 return -EINVAL;
1448
1449         if (!data) {
1450                 data = zalloc(size);
1451                 if (!data)
1452                         return -ENOMEM;
1453
1454                 ps->group_data = data;
1455         }
1456
1457         if (FD(leader, cpu, thread) < 0)
1458                 return -EINVAL;
1459
1460         if (readn(FD(leader, cpu, thread), data, size) <= 0)
1461                 return -errno;
1462
1463         return perf_evsel__process_group_data(leader, cpu, thread, data);
1464 }
1465
1466 int perf_evsel__read_counter(struct perf_evsel *evsel, int cpu, int thread)
1467 {
1468         u64 read_format = evsel->attr.read_format;
1469
1470         if (read_format & PERF_FORMAT_GROUP)
1471                 return perf_evsel__read_group(evsel, cpu, thread);
1472         else
1473                 return perf_evsel__read_one(evsel, cpu, thread);
1474 }
1475
1476 int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
1477                               int cpu, int thread, bool scale)
1478 {
1479         struct perf_counts_values count;
1480         size_t nv = scale ? 3 : 1;
1481
1482         if (FD(evsel, cpu, thread) < 0)
1483                 return -EINVAL;
1484
1485         if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0)
1486                 return -ENOMEM;
1487
1488         if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) <= 0)
1489                 return -errno;
1490
1491         perf_evsel__compute_deltas(evsel, cpu, thread, &count);
1492         perf_counts_values__scale(&count, scale, NULL);
1493         *perf_counts(evsel->counts, cpu, thread) = count;
1494         return 0;
1495 }
1496
1497 static int get_group_fd(struct perf_evsel *evsel, int cpu, int thread)
1498 {
1499         struct perf_evsel *leader = evsel->leader;
1500         int fd;
1501
1502         if (perf_evsel__is_group_leader(evsel))
1503                 return -1;
1504
1505         /*
1506          * Leader must be already processed/open,
1507          * if not it's a bug.
1508          */
1509         BUG_ON(!leader->fd);
1510
1511         fd = FD(leader, cpu, thread);
1512         BUG_ON(fd == -1);
1513
1514         return fd;
1515 }
1516
1517 struct bit_names {
1518         int bit;
1519         const char *name;
1520 };
1521
1522 static void __p_bits(char *buf, size_t size, u64 value, struct bit_names *bits)
1523 {
1524         bool first_bit = true;
1525         int i = 0;
1526
1527         do {
1528                 if (value & bits[i].bit) {
1529                         buf += scnprintf(buf, size, "%s%s", first_bit ? "" : "|", bits[i].name);
1530                         first_bit = false;
1531                 }
1532         } while (bits[++i].name != NULL);
1533 }
1534
1535 static void __p_sample_type(char *buf, size_t size, u64 value)
1536 {
1537 #define bit_name(n) { PERF_SAMPLE_##n, #n }
1538         struct bit_names bits[] = {
1539                 bit_name(IP), bit_name(TID), bit_name(TIME), bit_name(ADDR),
1540                 bit_name(READ), bit_name(CALLCHAIN), bit_name(ID), bit_name(CPU),
1541                 bit_name(PERIOD), bit_name(STREAM_ID), bit_name(RAW),
1542                 bit_name(BRANCH_STACK), bit_name(REGS_USER), bit_name(STACK_USER),
1543                 bit_name(IDENTIFIER), bit_name(REGS_INTR), bit_name(DATA_SRC),
1544                 bit_name(WEIGHT), bit_name(PHYS_ADDR),
1545                 { .name = NULL, }
1546         };
1547 #undef bit_name
1548         __p_bits(buf, size, value, bits);
1549 }
1550
1551 static void __p_branch_sample_type(char *buf, size_t size, u64 value)
1552 {
1553 #define bit_name(n) { PERF_SAMPLE_BRANCH_##n, #n }
1554         struct bit_names bits[] = {
1555                 bit_name(USER), bit_name(KERNEL), bit_name(HV), bit_name(ANY),
1556                 bit_name(ANY_CALL), bit_name(ANY_RETURN), bit_name(IND_CALL),
1557                 bit_name(ABORT_TX), bit_name(IN_TX), bit_name(NO_TX),
1558                 bit_name(COND), bit_name(CALL_STACK), bit_name(IND_JUMP),
1559                 bit_name(CALL), bit_name(NO_FLAGS), bit_name(NO_CYCLES),
1560                 { .name = NULL, }
1561         };
1562 #undef bit_name
1563         __p_bits(buf, size, value, bits);
1564 }
1565
1566 static void __p_read_format(char *buf, size_t size, u64 value)
1567 {
1568 #define bit_name(n) { PERF_FORMAT_##n, #n }
1569         struct bit_names bits[] = {
1570                 bit_name(TOTAL_TIME_ENABLED), bit_name(TOTAL_TIME_RUNNING),
1571                 bit_name(ID), bit_name(GROUP),
1572                 { .name = NULL, }
1573         };
1574 #undef bit_name
1575         __p_bits(buf, size, value, bits);
1576 }
1577
1578 #define BUF_SIZE                1024
1579
1580 #define p_hex(val)              snprintf(buf, BUF_SIZE, "%#"PRIx64, (uint64_t)(val))
1581 #define p_unsigned(val)         snprintf(buf, BUF_SIZE, "%"PRIu64, (uint64_t)(val))
1582 #define p_signed(val)           snprintf(buf, BUF_SIZE, "%"PRId64, (int64_t)(val))
1583 #define p_sample_type(val)      __p_sample_type(buf, BUF_SIZE, val)
1584 #define p_branch_sample_type(val) __p_branch_sample_type(buf, BUF_SIZE, val)
1585 #define p_read_format(val)      __p_read_format(buf, BUF_SIZE, val)
1586
1587 #define PRINT_ATTRn(_n, _f, _p)                         \
1588 do {                                                    \
1589         if (attr->_f) {                                 \
1590                 _p(attr->_f);                           \
1591                 ret += attr__fprintf(fp, _n, buf, priv);\
1592         }                                               \
1593 } while (0)
1594
1595 #define PRINT_ATTRf(_f, _p)     PRINT_ATTRn(#_f, _f, _p)
1596
1597 int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
1598                              attr__fprintf_f attr__fprintf, void *priv)
1599 {
1600         char buf[BUF_SIZE];
1601         int ret = 0;
1602
1603         PRINT_ATTRf(type, p_unsigned);
1604         PRINT_ATTRf(size, p_unsigned);
1605         PRINT_ATTRf(config, p_hex);
1606         PRINT_ATTRn("{ sample_period, sample_freq }", sample_period, p_unsigned);
1607         PRINT_ATTRf(sample_type, p_sample_type);
1608         PRINT_ATTRf(read_format, p_read_format);
1609
1610         PRINT_ATTRf(disabled, p_unsigned);
1611         PRINT_ATTRf(inherit, p_unsigned);
1612         PRINT_ATTRf(pinned, p_unsigned);
1613         PRINT_ATTRf(exclusive, p_unsigned);
1614         PRINT_ATTRf(exclude_user, p_unsigned);
1615         PRINT_ATTRf(exclude_kernel, p_unsigned);
1616         PRINT_ATTRf(exclude_hv, p_unsigned);
1617         PRINT_ATTRf(exclude_idle, p_unsigned);
1618         PRINT_ATTRf(mmap, p_unsigned);
1619         PRINT_ATTRf(comm, p_unsigned);
1620         PRINT_ATTRf(freq, p_unsigned);
1621         PRINT_ATTRf(inherit_stat, p_unsigned);
1622         PRINT_ATTRf(enable_on_exec, p_unsigned);
1623         PRINT_ATTRf(task, p_unsigned);
1624         PRINT_ATTRf(watermark, p_unsigned);
1625         PRINT_ATTRf(precise_ip, p_unsigned);
1626         PRINT_ATTRf(mmap_data, p_unsigned);
1627         PRINT_ATTRf(sample_id_all, p_unsigned);
1628         PRINT_ATTRf(exclude_host, p_unsigned);
1629         PRINT_ATTRf(exclude_guest, p_unsigned);
1630         PRINT_ATTRf(exclude_callchain_kernel, p_unsigned);
1631         PRINT_ATTRf(exclude_callchain_user, p_unsigned);
1632         PRINT_ATTRf(mmap2, p_unsigned);
1633         PRINT_ATTRf(comm_exec, p_unsigned);
1634         PRINT_ATTRf(use_clockid, p_unsigned);
1635         PRINT_ATTRf(context_switch, p_unsigned);
1636         PRINT_ATTRf(write_backward, p_unsigned);
1637         PRINT_ATTRf(namespaces, p_unsigned);
1638
1639         PRINT_ATTRn("{ wakeup_events, wakeup_watermark }", wakeup_events, p_unsigned);
1640         PRINT_ATTRf(bp_type, p_unsigned);
1641         PRINT_ATTRn("{ bp_addr, config1 }", bp_addr, p_hex);
1642         PRINT_ATTRn("{ bp_len, config2 }", bp_len, p_hex);
1643         PRINT_ATTRf(branch_sample_type, p_branch_sample_type);
1644         PRINT_ATTRf(sample_regs_user, p_hex);
1645         PRINT_ATTRf(sample_stack_user, p_unsigned);
1646         PRINT_ATTRf(clockid, p_signed);
1647         PRINT_ATTRf(sample_regs_intr, p_hex);
1648         PRINT_ATTRf(aux_watermark, p_unsigned);
1649         PRINT_ATTRf(sample_max_stack, p_unsigned);
1650
1651         return ret;
1652 }
1653
1654 static int __open_attr__fprintf(FILE *fp, const char *name, const char *val,
1655                                 void *priv __maybe_unused)
1656 {
1657         return fprintf(fp, "  %-32s %s\n", name, val);
1658 }
1659
1660 static void perf_evsel__remove_fd(struct perf_evsel *pos,
1661                                   int nr_cpus, int nr_threads,
1662                                   int thread_idx)
1663 {
1664         for (int cpu = 0; cpu < nr_cpus; cpu++)
1665                 for (int thread = thread_idx; thread < nr_threads - 1; thread++)
1666                         FD(pos, cpu, thread) = FD(pos, cpu, thread + 1);
1667 }
1668
1669 static int update_fds(struct perf_evsel *evsel,
1670                       int nr_cpus, int cpu_idx,
1671                       int nr_threads, int thread_idx)
1672 {
1673         struct perf_evsel *pos;
1674
1675         if (cpu_idx >= nr_cpus || thread_idx >= nr_threads)
1676                 return -EINVAL;
1677
1678         evlist__for_each_entry(evsel->evlist, pos) {
1679                 nr_cpus = pos != evsel ? nr_cpus : cpu_idx;
1680
1681                 perf_evsel__remove_fd(pos, nr_cpus, nr_threads, thread_idx);
1682
1683                 /*
1684                  * Since fds for next evsel has not been created,
1685                  * there is no need to iterate whole event list.
1686                  */
1687                 if (pos == evsel)
1688                         break;
1689         }
1690         return 0;
1691 }
1692
1693 static bool ignore_missing_thread(struct perf_evsel *evsel,
1694                                   int nr_cpus, int cpu,
1695                                   struct thread_map *threads,
1696                                   int thread, int err)
1697 {
1698         pid_t ignore_pid = thread_map__pid(threads, thread);
1699
1700         if (!evsel->ignore_missing_thread)
1701                 return false;
1702
1703         /* The system wide setup does not work with threads. */
1704         if (evsel->system_wide)
1705                 return false;
1706
1707         /* The -ESRCH is perf event syscall errno for pid's not found. */
1708         if (err != -ESRCH)
1709                 return false;
1710
1711         /* If there's only one thread, let it fail. */
1712         if (threads->nr == 1)
1713                 return false;
1714
1715         /*
1716          * We should remove fd for missing_thread first
1717          * because thread_map__remove() will decrease threads->nr.
1718          */
1719         if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread))
1720                 return false;
1721
1722         if (thread_map__remove(threads, thread))
1723                 return false;
1724
1725         pr_warning("WARNING: Ignored open failure for pid %d\n",
1726                    ignore_pid);
1727         return true;
1728 }
1729
1730 int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
1731                      struct thread_map *threads)
1732 {
1733         int cpu, thread, nthreads;
1734         unsigned long flags = PERF_FLAG_FD_CLOEXEC;
1735         int pid = -1, err;
1736         enum { NO_CHANGE, SET_TO_MAX, INCREASED_MAX } set_rlimit = NO_CHANGE;
1737
1738         if (perf_missing_features.write_backward && evsel->attr.write_backward)
1739                 return -EINVAL;
1740
1741         if (cpus == NULL) {
1742                 static struct cpu_map *empty_cpu_map;
1743
1744                 if (empty_cpu_map == NULL) {
1745                         empty_cpu_map = cpu_map__dummy_new();
1746                         if (empty_cpu_map == NULL)
1747                                 return -ENOMEM;
1748                 }
1749
1750                 cpus = empty_cpu_map;
1751         }
1752
1753         if (threads == NULL) {
1754                 static struct thread_map *empty_thread_map;
1755
1756                 if (empty_thread_map == NULL) {
1757                         empty_thread_map = thread_map__new_by_tid(-1);
1758                         if (empty_thread_map == NULL)
1759                                 return -ENOMEM;
1760                 }
1761
1762                 threads = empty_thread_map;
1763         }
1764
1765         if (evsel->system_wide)
1766                 nthreads = 1;
1767         else
1768                 nthreads = threads->nr;
1769
1770         if (evsel->fd == NULL &&
1771             perf_evsel__alloc_fd(evsel, cpus->nr, nthreads) < 0)
1772                 return -ENOMEM;
1773
1774         if (evsel->cgrp) {
1775                 flags |= PERF_FLAG_PID_CGROUP;
1776                 pid = evsel->cgrp->fd;
1777         }
1778
1779 fallback_missing_features:
1780         if (perf_missing_features.clockid_wrong)
1781                 evsel->attr.clockid = CLOCK_MONOTONIC; /* should always work */
1782         if (perf_missing_features.clockid) {
1783                 evsel->attr.use_clockid = 0;
1784                 evsel->attr.clockid = 0;
1785         }
1786         if (perf_missing_features.cloexec)
1787                 flags &= ~(unsigned long)PERF_FLAG_FD_CLOEXEC;
1788         if (perf_missing_features.mmap2)
1789                 evsel->attr.mmap2 = 0;
1790         if (perf_missing_features.exclude_guest)
1791                 evsel->attr.exclude_guest = evsel->attr.exclude_host = 0;
1792         if (perf_missing_features.lbr_flags)
1793                 evsel->attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS |
1794                                      PERF_SAMPLE_BRANCH_NO_CYCLES);
1795         if (perf_missing_features.group_read && evsel->attr.inherit)
1796                 evsel->attr.read_format &= ~(PERF_FORMAT_GROUP|PERF_FORMAT_ID);
1797 retry_sample_id:
1798         if (perf_missing_features.sample_id_all)
1799                 evsel->attr.sample_id_all = 0;
1800
1801         if (verbose >= 2) {
1802                 fprintf(stderr, "%.60s\n", graph_dotted_line);
1803                 fprintf(stderr, "perf_event_attr:\n");
1804                 perf_event_attr__fprintf(stderr, &evsel->attr, __open_attr__fprintf, NULL);
1805                 fprintf(stderr, "%.60s\n", graph_dotted_line);
1806         }
1807
1808         for (cpu = 0; cpu < cpus->nr; cpu++) {
1809
1810                 for (thread = 0; thread < nthreads; thread++) {
1811                         int fd, group_fd;
1812
1813                         if (!evsel->cgrp && !evsel->system_wide)
1814                                 pid = thread_map__pid(threads, thread);
1815
1816                         group_fd = get_group_fd(evsel, cpu, thread);
1817 retry_open:
1818                         pr_debug2("sys_perf_event_open: pid %d  cpu %d  group_fd %d  flags %#lx",
1819                                   pid, cpus->map[cpu], group_fd, flags);
1820
1821                         test_attr__ready();
1822
1823                         fd = sys_perf_event_open(&evsel->attr, pid, cpus->map[cpu],
1824                                                  group_fd, flags);
1825
1826                         FD(evsel, cpu, thread) = fd;
1827
1828                         if (fd < 0) {
1829                                 err = -errno;
1830
1831                                 if (ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) {
1832                                         /*
1833                                          * We just removed 1 thread, so take a step
1834                                          * back on thread index and lower the upper
1835                                          * nthreads limit.
1836                                          */
1837                                         nthreads--;
1838                                         thread--;
1839
1840                                         /* ... and pretend like nothing have happened. */
1841                                         err = 0;
1842                                         continue;
1843                                 }
1844
1845                                 pr_debug2("\nsys_perf_event_open failed, error %d\n",
1846                                           err);
1847                                 goto try_fallback;
1848                         }
1849
1850                         pr_debug2(" = %d\n", fd);
1851
1852                         if (evsel->bpf_fd >= 0) {
1853                                 int evt_fd = fd;
1854                                 int bpf_fd = evsel->bpf_fd;
1855
1856                                 err = ioctl(evt_fd,
1857                                             PERF_EVENT_IOC_SET_BPF,
1858                                             bpf_fd);
1859                                 if (err && errno != EEXIST) {
1860                                         pr_err("failed to attach bpf fd %d: %s\n",
1861                                                bpf_fd, strerror(errno));
1862                                         err = -EINVAL;
1863                                         goto out_close;
1864                                 }
1865                         }
1866
1867                         set_rlimit = NO_CHANGE;
1868
1869                         /*
1870                          * If we succeeded but had to kill clockid, fail and
1871                          * have perf_evsel__open_strerror() print us a nice
1872                          * error.
1873                          */
1874                         if (perf_missing_features.clockid ||
1875                             perf_missing_features.clockid_wrong) {
1876                                 err = -EINVAL;
1877                                 goto out_close;
1878                         }
1879                 }
1880         }
1881
1882         return 0;
1883
1884 try_fallback:
1885         /*
1886          * perf stat needs between 5 and 22 fds per CPU. When we run out
1887          * of them try to increase the limits.
1888          */
1889         if (err == -EMFILE && set_rlimit < INCREASED_MAX) {
1890                 struct rlimit l;
1891                 int old_errno = errno;
1892
1893                 if (getrlimit(RLIMIT_NOFILE, &l) == 0) {
1894                         if (set_rlimit == NO_CHANGE)
1895                                 l.rlim_cur = l.rlim_max;
1896                         else {
1897                                 l.rlim_cur = l.rlim_max + 1000;
1898                                 l.rlim_max = l.rlim_cur;
1899                         }
1900                         if (setrlimit(RLIMIT_NOFILE, &l) == 0) {
1901                                 set_rlimit++;
1902                                 errno = old_errno;
1903                                 goto retry_open;
1904                         }
1905                 }
1906                 errno = old_errno;
1907         }
1908
1909         if (err != -EINVAL || cpu > 0 || thread > 0)
1910                 goto out_close;
1911
1912         /*
1913          * Must probe features in the order they were added to the
1914          * perf_event_attr interface.
1915          */
1916         if (!perf_missing_features.write_backward && evsel->attr.write_backward) {
1917                 perf_missing_features.write_backward = true;
1918                 pr_debug2("switching off write_backward\n");
1919                 goto out_close;
1920         } else if (!perf_missing_features.clockid_wrong && evsel->attr.use_clockid) {
1921                 perf_missing_features.clockid_wrong = true;
1922                 pr_debug2("switching off clockid\n");
1923                 goto fallback_missing_features;
1924         } else if (!perf_missing_features.clockid && evsel->attr.use_clockid) {
1925                 perf_missing_features.clockid = true;
1926                 pr_debug2("switching off use_clockid\n");
1927                 goto fallback_missing_features;
1928         } else if (!perf_missing_features.cloexec && (flags & PERF_FLAG_FD_CLOEXEC)) {
1929                 perf_missing_features.cloexec = true;
1930                 pr_debug2("switching off cloexec flag\n");
1931                 goto fallback_missing_features;
1932         } else if (!perf_missing_features.mmap2 && evsel->attr.mmap2) {
1933                 perf_missing_features.mmap2 = true;
1934                 pr_debug2("switching off mmap2\n");
1935                 goto fallback_missing_features;
1936         } else if (!perf_missing_features.exclude_guest &&
1937                    (evsel->attr.exclude_guest || evsel->attr.exclude_host)) {
1938                 perf_missing_features.exclude_guest = true;
1939                 pr_debug2("switching off exclude_guest, exclude_host\n");
1940                 goto fallback_missing_features;
1941         } else if (!perf_missing_features.sample_id_all) {
1942                 perf_missing_features.sample_id_all = true;
1943                 pr_debug2("switching off sample_id_all\n");
1944                 goto retry_sample_id;
1945         } else if (!perf_missing_features.lbr_flags &&
1946                         (evsel->attr.branch_sample_type &
1947                          (PERF_SAMPLE_BRANCH_NO_CYCLES |
1948                           PERF_SAMPLE_BRANCH_NO_FLAGS))) {
1949                 perf_missing_features.lbr_flags = true;
1950                 pr_debug2("switching off branch sample type no (cycles/flags)\n");
1951                 goto fallback_missing_features;
1952         } else if (!perf_missing_features.group_read &&
1953                     evsel->attr.inherit &&
1954                    (evsel->attr.read_format & PERF_FORMAT_GROUP) &&
1955                    perf_evsel__is_group_leader(evsel)) {
1956                 perf_missing_features.group_read = true;
1957                 pr_debug2("switching off group read\n");
1958                 goto fallback_missing_features;
1959         }
1960 out_close:
1961         if (err)
1962                 threads->err_thread = thread;
1963
1964         do {
1965                 while (--thread >= 0) {
1966                         close(FD(evsel, cpu, thread));
1967                         FD(evsel, cpu, thread) = -1;
1968                 }
1969                 thread = nthreads;
1970         } while (--cpu >= 0);
1971         return err;
1972 }
1973
1974 void perf_evsel__close(struct perf_evsel *evsel)
1975 {
1976         if (evsel->fd == NULL)
1977                 return;
1978
1979         perf_evsel__close_fd(evsel);
1980         perf_evsel__free_fd(evsel);
1981 }
1982
1983 int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
1984                              struct cpu_map *cpus)
1985 {
1986         return perf_evsel__open(evsel, cpus, NULL);
1987 }
1988
1989 int perf_evsel__open_per_thread(struct perf_evsel *evsel,
1990                                 struct thread_map *threads)
1991 {
1992         return perf_evsel__open(evsel, NULL, threads);
1993 }
1994
1995 static int perf_evsel__parse_id_sample(const struct perf_evsel *evsel,
1996                                        const union perf_event *event,
1997                                        struct perf_sample *sample)
1998 {
1999         u64 type = evsel->attr.sample_type;
2000         const u64 *array = event->sample.array;
2001         bool swapped = evsel->needs_swap;
2002         union u64_swap u;
2003
2004         array += ((event->header.size -
2005                    sizeof(event->header)) / sizeof(u64)) - 1;
2006
2007         if (type & PERF_SAMPLE_IDENTIFIER) {
2008                 sample->id = *array;
2009                 array--;
2010         }
2011
2012         if (type & PERF_SAMPLE_CPU) {
2013                 u.val64 = *array;
2014                 if (swapped) {
2015                         /* undo swap of u64, then swap on individual u32s */
2016                         u.val64 = bswap_64(u.val64);
2017                         u.val32[0] = bswap_32(u.val32[0]);
2018                 }
2019
2020                 sample->cpu = u.val32[0];
2021                 array--;
2022         }
2023
2024         if (type & PERF_SAMPLE_STREAM_ID) {
2025                 sample->stream_id = *array;
2026                 array--;
2027         }
2028
2029         if (type & PERF_SAMPLE_ID) {
2030                 sample->id = *array;
2031                 array--;
2032         }
2033
2034         if (type & PERF_SAMPLE_TIME) {
2035                 sample->time = *array;
2036                 array--;
2037         }
2038
2039         if (type & PERF_SAMPLE_TID) {
2040                 u.val64 = *array;
2041                 if (swapped) {
2042                         /* undo swap of u64, then swap on individual u32s */
2043                         u.val64 = bswap_64(u.val64);
2044                         u.val32[0] = bswap_32(u.val32[0]);
2045                         u.val32[1] = bswap_32(u.val32[1]);
2046                 }
2047
2048                 sample->pid = u.val32[0];
2049                 sample->tid = u.val32[1];
2050                 array--;
2051         }
2052
2053         return 0;
2054 }
2055
2056 static inline bool overflow(const void *endp, u16 max_size, const void *offset,
2057                             u64 size)
2058 {
2059         return size > max_size || offset + size > endp;
2060 }
2061
2062 #define OVERFLOW_CHECK(offset, size, max_size)                          \
2063         do {                                                            \
2064                 if (overflow(endp, (max_size), (offset), (size)))       \
2065                         return -EFAULT;                                 \
2066         } while (0)
2067
2068 #define OVERFLOW_CHECK_u64(offset) \
2069         OVERFLOW_CHECK(offset, sizeof(u64), sizeof(u64))
2070
2071 static int
2072 perf_event__check_size(union perf_event *event, unsigned int sample_size)
2073 {
2074         /*
2075          * The evsel's sample_size is based on PERF_SAMPLE_MASK which includes
2076          * up to PERF_SAMPLE_PERIOD.  After that overflow() must be used to
2077          * check the format does not go past the end of the event.
2078          */
2079         if (sample_size + sizeof(event->header) > event->header.size)
2080                 return -EFAULT;
2081
2082         return 0;
2083 }
2084
2085 int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
2086                              struct perf_sample *data)
2087 {
2088         u64 type = evsel->attr.sample_type;
2089         bool swapped = evsel->needs_swap;
2090         const u64 *array;
2091         u16 max_size = event->header.size;
2092         const void *endp = (void *)event + max_size;
2093         u64 sz;
2094
2095         /*
2096          * used for cross-endian analysis. See git commit 65014ab3
2097          * for why this goofiness is needed.
2098          */
2099         union u64_swap u;
2100
2101         memset(data, 0, sizeof(*data));
2102         data->cpu = data->pid = data->tid = -1;
2103         data->stream_id = data->id = data->time = -1ULL;
2104         data->period = evsel->attr.sample_period;
2105         data->cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
2106         data->misc    = event->header.misc;
2107         data->id = -1ULL;
2108         data->data_src = PERF_MEM_DATA_SRC_NONE;
2109
2110         if (event->header.type != PERF_RECORD_SAMPLE) {
2111                 if (!evsel->attr.sample_id_all)
2112                         return 0;
2113                 return perf_evsel__parse_id_sample(evsel, event, data);
2114         }
2115
2116         array = event->sample.array;
2117
2118         if (perf_event__check_size(event, evsel->sample_size))
2119                 return -EFAULT;
2120
2121         if (type & PERF_SAMPLE_IDENTIFIER) {
2122                 data->id = *array;
2123                 array++;
2124         }
2125
2126         if (type & PERF_SAMPLE_IP) {
2127                 data->ip = *array;
2128                 array++;
2129         }
2130
2131         if (type & PERF_SAMPLE_TID) {
2132                 u.val64 = *array;
2133                 if (swapped) {
2134                         /* undo swap of u64, then swap on individual u32s */
2135                         u.val64 = bswap_64(u.val64);
2136                         u.val32[0] = bswap_32(u.val32[0]);
2137                         u.val32[1] = bswap_32(u.val32[1]);
2138                 }
2139
2140                 data->pid = u.val32[0];
2141                 data->tid = u.val32[1];
2142                 array++;
2143         }
2144
2145         if (type & PERF_SAMPLE_TIME) {
2146                 data->time = *array;
2147                 array++;
2148         }
2149
2150         if (type & PERF_SAMPLE_ADDR) {
2151                 data->addr = *array;
2152                 array++;
2153         }
2154
2155         if (type & PERF_SAMPLE_ID) {
2156                 data->id = *array;
2157                 array++;
2158         }
2159
2160         if (type & PERF_SAMPLE_STREAM_ID) {
2161                 data->stream_id = *array;
2162                 array++;
2163         }
2164
2165         if (type & PERF_SAMPLE_CPU) {
2166
2167                 u.val64 = *array;
2168                 if (swapped) {
2169                         /* undo swap of u64, then swap on individual u32s */
2170                         u.val64 = bswap_64(u.val64);
2171                         u.val32[0] = bswap_32(u.val32[0]);
2172                 }
2173
2174                 data->cpu = u.val32[0];
2175                 array++;
2176         }
2177
2178         if (type & PERF_SAMPLE_PERIOD) {
2179                 data->period = *array;
2180                 array++;
2181         }
2182
2183         if (type & PERF_SAMPLE_READ) {
2184                 u64 read_format = evsel->attr.read_format;
2185
2186                 OVERFLOW_CHECK_u64(array);
2187                 if (read_format & PERF_FORMAT_GROUP)
2188                         data->read.group.nr = *array;
2189                 else
2190                         data->read.one.value = *array;
2191
2192                 array++;
2193
2194                 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
2195                         OVERFLOW_CHECK_u64(array);
2196                         data->read.time_enabled = *array;
2197                         array++;
2198                 }
2199
2200                 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
2201                         OVERFLOW_CHECK_u64(array);
2202                         data->read.time_running = *array;
2203                         array++;
2204                 }
2205
2206                 /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
2207                 if (read_format & PERF_FORMAT_GROUP) {
2208                         const u64 max_group_nr = UINT64_MAX /
2209                                         sizeof(struct sample_read_value);
2210
2211                         if (data->read.group.nr > max_group_nr)
2212                                 return -EFAULT;
2213                         sz = data->read.group.nr *
2214                              sizeof(struct sample_read_value);
2215                         OVERFLOW_CHECK(array, sz, max_size);
2216                         data->read.group.values =
2217                                         (struct sample_read_value *)array;
2218                         array = (void *)array + sz;
2219                 } else {
2220                         OVERFLOW_CHECK_u64(array);
2221                         data->read.one.id = *array;
2222                         array++;
2223                 }
2224         }
2225
2226         if (evsel__has_callchain(evsel)) {
2227                 const u64 max_callchain_nr = UINT64_MAX / sizeof(u64);
2228
2229                 OVERFLOW_CHECK_u64(array);
2230                 data->callchain = (struct ip_callchain *)array++;
2231                 if (data->callchain->nr > max_callchain_nr)
2232                         return -EFAULT;
2233                 sz = data->callchain->nr * sizeof(u64);
2234                 OVERFLOW_CHECK(array, sz, max_size);
2235                 array = (void *)array + sz;
2236         }
2237
2238         if (type & PERF_SAMPLE_RAW) {
2239                 OVERFLOW_CHECK_u64(array);
2240                 u.val64 = *array;
2241
2242                 /*
2243                  * Undo swap of u64, then swap on individual u32s,
2244                  * get the size of the raw area and undo all of the
2245                  * swap. The pevent interface handles endianity by
2246                  * itself.
2247                  */
2248                 if (swapped) {
2249                         u.val64 = bswap_64(u.val64);
2250                         u.val32[0] = bswap_32(u.val32[0]);
2251                         u.val32[1] = bswap_32(u.val32[1]);
2252                 }
2253                 data->raw_size = u.val32[0];
2254
2255                 /*
2256                  * The raw data is aligned on 64bits including the
2257                  * u32 size, so it's safe to use mem_bswap_64.
2258                  */
2259                 if (swapped)
2260                         mem_bswap_64((void *) array, data->raw_size);
2261
2262                 array = (void *)array + sizeof(u32);
2263
2264                 OVERFLOW_CHECK(array, data->raw_size, max_size);
2265                 data->raw_data = (void *)array;
2266                 array = (void *)array + data->raw_size;
2267         }
2268
2269         if (type & PERF_SAMPLE_BRANCH_STACK) {
2270                 const u64 max_branch_nr = UINT64_MAX /
2271                                           sizeof(struct branch_entry);
2272
2273                 OVERFLOW_CHECK_u64(array);
2274                 data->branch_stack = (struct branch_stack *)array++;
2275
2276                 if (data->branch_stack->nr > max_branch_nr)
2277                         return -EFAULT;
2278                 sz = data->branch_stack->nr * sizeof(struct branch_entry);
2279                 OVERFLOW_CHECK(array, sz, max_size);
2280                 array = (void *)array + sz;
2281         }
2282
2283         if (type & PERF_SAMPLE_REGS_USER) {
2284                 OVERFLOW_CHECK_u64(array);
2285                 data->user_regs.abi = *array;
2286                 array++;
2287
2288                 if (data->user_regs.abi) {
2289                         u64 mask = evsel->attr.sample_regs_user;
2290
2291                         sz = hweight_long(mask) * sizeof(u64);
2292                         OVERFLOW_CHECK(array, sz, max_size);
2293                         data->user_regs.mask = mask;
2294                         data->user_regs.regs = (u64 *)array;
2295                         array = (void *)array + sz;
2296                 }
2297         }
2298
2299         if (type & PERF_SAMPLE_STACK_USER) {
2300                 OVERFLOW_CHECK_u64(array);
2301                 sz = *array++;
2302
2303                 data->user_stack.offset = ((char *)(array - 1)
2304                                           - (char *) event);
2305
2306                 if (!sz) {
2307                         data->user_stack.size = 0;
2308                 } else {
2309                         OVERFLOW_CHECK(array, sz, max_size);
2310                         data->user_stack.data = (char *)array;
2311                         array = (void *)array + sz;
2312                         OVERFLOW_CHECK_u64(array);
2313                         data->user_stack.size = *array++;
2314                         if (WARN_ONCE(data->user_stack.size > sz,
2315                                       "user stack dump failure\n"))
2316                                 return -EFAULT;
2317                 }
2318         }
2319
2320         if (type & PERF_SAMPLE_WEIGHT) {
2321                 OVERFLOW_CHECK_u64(array);
2322                 data->weight = *array;
2323                 array++;
2324         }
2325
2326         if (type & PERF_SAMPLE_DATA_SRC) {
2327                 OVERFLOW_CHECK_u64(array);
2328                 data->data_src = *array;
2329                 array++;
2330         }
2331
2332         if (type & PERF_SAMPLE_TRANSACTION) {
2333                 OVERFLOW_CHECK_u64(array);
2334                 data->transaction = *array;
2335                 array++;
2336         }
2337
2338         data->intr_regs.abi = PERF_SAMPLE_REGS_ABI_NONE;
2339         if (type & PERF_SAMPLE_REGS_INTR) {
2340                 OVERFLOW_CHECK_u64(array);
2341                 data->intr_regs.abi = *array;
2342                 array++;
2343
2344                 if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) {
2345                         u64 mask = evsel->attr.sample_regs_intr;
2346
2347                         sz = hweight_long(mask) * sizeof(u64);
2348                         OVERFLOW_CHECK(array, sz, max_size);
2349                         data->intr_regs.mask = mask;
2350                         data->intr_regs.regs = (u64 *)array;
2351                         array = (void *)array + sz;
2352                 }
2353         }
2354
2355         data->phys_addr = 0;
2356         if (type & PERF_SAMPLE_PHYS_ADDR) {
2357                 data->phys_addr = *array;
2358                 array++;
2359         }
2360
2361         return 0;
2362 }
2363
2364 int perf_evsel__parse_sample_timestamp(struct perf_evsel *evsel,
2365                                        union perf_event *event,
2366                                        u64 *timestamp)
2367 {
2368         u64 type = evsel->attr.sample_type;
2369         const u64 *array;
2370
2371         if (!(type & PERF_SAMPLE_TIME))
2372                 return -1;
2373
2374         if (event->header.type != PERF_RECORD_SAMPLE) {
2375                 struct perf_sample data = {
2376                         .time = -1ULL,
2377                 };
2378
2379                 if (!evsel->attr.sample_id_all)
2380                         return -1;
2381                 if (perf_evsel__parse_id_sample(evsel, event, &data))
2382                         return -1;
2383
2384                 *timestamp = data.time;
2385                 return 0;
2386         }
2387
2388         array = event->sample.array;
2389
2390         if (perf_event__check_size(event, evsel->sample_size))
2391                 return -EFAULT;
2392
2393         if (type & PERF_SAMPLE_IDENTIFIER)
2394                 array++;
2395
2396         if (type & PERF_SAMPLE_IP)
2397                 array++;
2398
2399         if (type & PERF_SAMPLE_TID)
2400                 array++;
2401
2402         if (type & PERF_SAMPLE_TIME)
2403                 *timestamp = *array;
2404
2405         return 0;
2406 }
2407
2408 size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,
2409                                      u64 read_format)
2410 {
2411         size_t sz, result = sizeof(struct sample_event);
2412
2413         if (type & PERF_SAMPLE_IDENTIFIER)
2414                 result += sizeof(u64);
2415
2416         if (type & PERF_SAMPLE_IP)
2417                 result += sizeof(u64);
2418
2419         if (type & PERF_SAMPLE_TID)
2420                 result += sizeof(u64);
2421
2422         if (type & PERF_SAMPLE_TIME)
2423                 result += sizeof(u64);
2424
2425         if (type & PERF_SAMPLE_ADDR)
2426                 result += sizeof(u64);
2427
2428         if (type & PERF_SAMPLE_ID)
2429                 result += sizeof(u64);
2430
2431         if (type & PERF_SAMPLE_STREAM_ID)
2432                 result += sizeof(u64);
2433
2434         if (type & PERF_SAMPLE_CPU)
2435                 result += sizeof(u64);
2436
2437         if (type & PERF_SAMPLE_PERIOD)
2438                 result += sizeof(u64);
2439
2440         if (type & PERF_SAMPLE_READ) {
2441                 result += sizeof(u64);
2442                 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
2443                         result += sizeof(u64);
2444                 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
2445                         result += sizeof(u64);
2446                 /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
2447                 if (read_format & PERF_FORMAT_GROUP) {
2448                         sz = sample->read.group.nr *
2449                              sizeof(struct sample_read_value);
2450                         result += sz;
2451                 } else {
2452                         result += sizeof(u64);
2453                 }
2454         }
2455
2456         if (type & PERF_SAMPLE_CALLCHAIN) {
2457                 sz = (sample->callchain->nr + 1) * sizeof(u64);
2458                 result += sz;
2459         }
2460
2461         if (type & PERF_SAMPLE_RAW) {
2462                 result += sizeof(u32);
2463                 result += sample->raw_size;
2464         }
2465
2466         if (type & PERF_SAMPLE_BRANCH_STACK) {
2467                 sz = sample->branch_stack->nr * sizeof(struct branch_entry);
2468                 sz += sizeof(u64);
2469                 result += sz;
2470         }
2471
2472         if (type & PERF_SAMPLE_REGS_USER) {
2473                 if (sample->user_regs.abi) {
2474                         result += sizeof(u64);
2475                         sz = hweight_long(sample->user_regs.mask) * sizeof(u64);
2476                         result += sz;
2477                 } else {
2478                         result += sizeof(u64);
2479                 }
2480         }
2481
2482         if (type & PERF_SAMPLE_STACK_USER) {
2483                 sz = sample->user_stack.size;
2484                 result += sizeof(u64);
2485                 if (sz) {
2486                         result += sz;
2487                         result += sizeof(u64);
2488                 }
2489         }
2490
2491         if (type & PERF_SAMPLE_WEIGHT)
2492                 result += sizeof(u64);
2493
2494         if (type & PERF_SAMPLE_DATA_SRC)
2495                 result += sizeof(u64);
2496
2497         if (type & PERF_SAMPLE_TRANSACTION)
2498                 result += sizeof(u64);
2499
2500         if (type & PERF_SAMPLE_REGS_INTR) {
2501                 if (sample->intr_regs.abi) {
2502                         result += sizeof(u64);
2503                         sz = hweight_long(sample->intr_regs.mask) * sizeof(u64);
2504                         result += sz;
2505                 } else {
2506                         result += sizeof(u64);
2507                 }
2508         }
2509
2510         if (type & PERF_SAMPLE_PHYS_ADDR)
2511                 result += sizeof(u64);
2512
2513         return result;
2514 }
2515
2516 int perf_event__synthesize_sample(union perf_event *event, u64 type,
2517                                   u64 read_format,
2518                                   const struct perf_sample *sample)
2519 {
2520         u64 *array;
2521         size_t sz;
2522         /*
2523          * used for cross-endian analysis. See git commit 65014ab3
2524          * for why this goofiness is needed.
2525          */
2526         union u64_swap u;
2527
2528         array = event->sample.array;
2529
2530         if (type & PERF_SAMPLE_IDENTIFIER) {
2531                 *array = sample->id;
2532                 array++;
2533         }
2534
2535         if (type & PERF_SAMPLE_IP) {
2536                 *array = sample->ip;
2537                 array++;
2538         }
2539
2540         if (type & PERF_SAMPLE_TID) {
2541                 u.val32[0] = sample->pid;
2542                 u.val32[1] = sample->tid;
2543                 *array = u.val64;
2544                 array++;
2545         }
2546
2547         if (type & PERF_SAMPLE_TIME) {
2548                 *array = sample->time;
2549                 array++;
2550         }
2551
2552         if (type & PERF_SAMPLE_ADDR) {
2553                 *array = sample->addr;
2554                 array++;
2555         }
2556
2557         if (type & PERF_SAMPLE_ID) {
2558                 *array = sample->id;
2559                 array++;
2560         }
2561
2562         if (type & PERF_SAMPLE_STREAM_ID) {
2563                 *array = sample->stream_id;
2564                 array++;
2565         }
2566
2567         if (type & PERF_SAMPLE_CPU) {
2568                 u.val32[0] = sample->cpu;
2569                 u.val32[1] = 0;
2570                 *array = u.val64;
2571                 array++;
2572         }
2573
2574         if (type & PERF_SAMPLE_PERIOD) {
2575                 *array = sample->period;
2576                 array++;
2577         }
2578
2579         if (type & PERF_SAMPLE_READ) {
2580                 if (read_format & PERF_FORMAT_GROUP)
2581                         *array = sample->read.group.nr;
2582                 else
2583                         *array = sample->read.one.value;
2584                 array++;
2585
2586                 if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
2587                         *array = sample->read.time_enabled;
2588                         array++;
2589                 }
2590
2591                 if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
2592                         *array = sample->read.time_running;
2593                         array++;
2594                 }
2595
2596                 /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
2597                 if (read_format & PERF_FORMAT_GROUP) {
2598                         sz = sample->read.group.nr *
2599                              sizeof(struct sample_read_value);
2600                         memcpy(array, sample->read.group.values, sz);
2601                         array = (void *)array + sz;
2602                 } else {
2603                         *array = sample->read.one.id;
2604                         array++;
2605                 }
2606         }
2607
2608         if (type & PERF_SAMPLE_CALLCHAIN) {
2609                 sz = (sample->callchain->nr + 1) * sizeof(u64);
2610                 memcpy(array, sample->callchain, sz);
2611                 array = (void *)array + sz;
2612         }
2613
2614         if (type & PERF_SAMPLE_RAW) {
2615                 u.val32[0] = sample->raw_size;
2616                 *array = u.val64;
2617                 array = (void *)array + sizeof(u32);
2618
2619                 memcpy(array, sample->raw_data, sample->raw_size);
2620                 array = (void *)array + sample->raw_size;
2621         }
2622
2623         if (type & PERF_SAMPLE_BRANCH_STACK) {
2624                 sz = sample->branch_stack->nr * sizeof(struct branch_entry);
2625                 sz += sizeof(u64);
2626                 memcpy(array, sample->branch_stack, sz);
2627                 array = (void *)array + sz;
2628         }
2629
2630         if (type & PERF_SAMPLE_REGS_USER) {
2631                 if (sample->user_regs.abi) {
2632                         *array++ = sample->user_regs.abi;
2633                         sz = hweight_long(sample->user_regs.mask) * sizeof(u64);
2634                         memcpy(array, sample->user_regs.regs, sz);
2635                         array = (void *)array + sz;
2636                 } else {
2637                         *array++ = 0;
2638                 }
2639         }
2640
2641         if (type & PERF_SAMPLE_STACK_USER) {
2642                 sz = sample->user_stack.size;
2643                 *array++ = sz;
2644                 if (sz) {
2645                         memcpy(array, sample->user_stack.data, sz);
2646                         array = (void *)array + sz;
2647                         *array++ = sz;
2648                 }
2649         }
2650
2651         if (type & PERF_SAMPLE_WEIGHT) {
2652                 *array = sample->weight;
2653                 array++;
2654         }
2655
2656         if (type & PERF_SAMPLE_DATA_SRC) {
2657                 *array = sample->data_src;
2658                 array++;
2659         }
2660
2661         if (type & PERF_SAMPLE_TRANSACTION) {
2662                 *array = sample->transaction;
2663                 array++;
2664         }
2665
2666         if (type & PERF_SAMPLE_REGS_INTR) {
2667                 if (sample->intr_regs.abi) {
2668                         *array++ = sample->intr_regs.abi;
2669                         sz = hweight_long(sample->intr_regs.mask) * sizeof(u64);
2670                         memcpy(array, sample->intr_regs.regs, sz);
2671                         array = (void *)array + sz;
2672                 } else {
2673                         *array++ = 0;
2674                 }
2675         }
2676
2677         if (type & PERF_SAMPLE_PHYS_ADDR) {
2678                 *array = sample->phys_addr;
2679                 array++;
2680         }
2681
2682         return 0;
2683 }
2684
2685 struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
2686 {
2687         return tep_find_field(evsel->tp_format, name);
2688 }
2689
2690 void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
2691                          const char *name)
2692 {
2693         struct format_field *field = perf_evsel__field(evsel, name);
2694         int offset;
2695
2696         if (!field)
2697                 return NULL;
2698
2699         offset = field->offset;
2700
2701         if (field->flags & FIELD_IS_DYNAMIC) {
2702                 offset = *(int *)(sample->raw_data + field->offset);
2703                 offset &= 0xffff;
2704         }
2705
2706         return sample->raw_data + offset;
2707 }
2708
2709 u64 format_field__intval(struct format_field *field, struct perf_sample *sample,
2710                          bool needs_swap)
2711 {
2712         u64 value;
2713         void *ptr = sample->raw_data + field->offset;
2714
2715         switch (field->size) {
2716         case 1:
2717                 return *(u8 *)ptr;
2718         case 2:
2719                 value = *(u16 *)ptr;
2720                 break;
2721         case 4:
2722                 value = *(u32 *)ptr;
2723                 break;
2724         case 8:
2725                 memcpy(&value, ptr, sizeof(u64));
2726                 break;
2727         default:
2728                 return 0;
2729         }
2730
2731         if (!needs_swap)
2732                 return value;
2733
2734         switch (field->size) {
2735         case 2:
2736                 return bswap_16(value);
2737         case 4:
2738                 return bswap_32(value);
2739         case 8:
2740                 return bswap_64(value);
2741         default:
2742                 return 0;
2743         }
2744
2745         return 0;
2746 }
2747
2748 u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
2749                        const char *name)
2750 {
2751         struct format_field *field = perf_evsel__field(evsel, name);
2752
2753         if (!field)
2754                 return 0;
2755
2756         return field ? format_field__intval(field, sample, evsel->needs_swap) : 0;
2757 }
2758
2759 bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
2760                           char *msg, size_t msgsize)
2761 {
2762         int paranoid;
2763
2764         if ((err == ENOENT || err == ENXIO || err == ENODEV) &&
2765             evsel->attr.type   == PERF_TYPE_HARDWARE &&
2766             evsel->attr.config == PERF_COUNT_HW_CPU_CYCLES) {
2767                 /*
2768                  * If it's cycles then fall back to hrtimer based
2769                  * cpu-clock-tick sw counter, which is always available even if
2770                  * no PMU support.
2771                  *
2772                  * PPC returns ENXIO until 2.6.37 (behavior changed with commit
2773                  * b0a873e).
2774                  */
2775                 scnprintf(msg, msgsize, "%s",
2776 "The cycles event is not supported, trying to fall back to cpu-clock-ticks");
2777
2778                 evsel->attr.type   = PERF_TYPE_SOFTWARE;
2779                 evsel->attr.config = PERF_COUNT_SW_CPU_CLOCK;
2780
2781                 zfree(&evsel->name);
2782                 return true;
2783         } else if (err == EACCES && !evsel->attr.exclude_kernel &&
2784                    (paranoid = perf_event_paranoid()) > 1) {
2785                 const char *name = perf_evsel__name(evsel);
2786                 char *new_name;
2787                 const char *sep = ":";
2788
2789                 /* Is there already the separator in the name. */
2790                 if (strchr(name, '/') ||
2791                     strchr(name, ':'))
2792                         sep = "";
2793
2794                 if (asprintf(&new_name, "%s%su", name, sep) < 0)
2795                         return false;
2796
2797                 if (evsel->name)
2798                         free(evsel->name);
2799                 evsel->name = new_name;
2800                 scnprintf(msg, msgsize,
2801 "kernel.perf_event_paranoid=%d, trying to fall back to excluding kernel samples", paranoid);
2802                 evsel->attr.exclude_kernel = 1;
2803
2804                 return true;
2805         }
2806
2807         return false;
2808 }
2809
2810 static bool find_process(const char *name)
2811 {
2812         size_t len = strlen(name);
2813         DIR *dir;
2814         struct dirent *d;
2815         int ret = -1;
2816
2817         dir = opendir(procfs__mountpoint());
2818         if (!dir)
2819                 return false;
2820
2821         /* Walk through the directory. */
2822         while (ret && (d = readdir(dir)) != NULL) {
2823                 char path[PATH_MAX];
2824                 char *data;
2825                 size_t size;
2826
2827                 if ((d->d_type != DT_DIR) ||
2828                      !strcmp(".", d->d_name) ||
2829                      !strcmp("..", d->d_name))
2830                         continue;
2831
2832                 scnprintf(path, sizeof(path), "%s/%s/comm",
2833                           procfs__mountpoint(), d->d_name);
2834
2835                 if (filename__read_str(path, &data, &size))
2836                         continue;
2837
2838                 ret = strncmp(name, data, len);
2839                 free(data);
2840         }
2841
2842         closedir(dir);
2843         return ret ? false : true;
2844 }
2845
2846 int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
2847                               int err, char *msg, size_t size)
2848 {
2849         char sbuf[STRERR_BUFSIZE];
2850         int printed = 0;
2851
2852         switch (err) {
2853         case EPERM:
2854         case EACCES:
2855                 if (err == EPERM)
2856                         printed = scnprintf(msg, size,
2857                                 "No permission to enable %s event.\n\n",
2858                                 perf_evsel__name(evsel));
2859
2860                 return scnprintf(msg + printed, size - printed,
2861                  "You may not have permission to collect %sstats.\n\n"
2862                  "Consider tweaking /proc/sys/kernel/perf_event_paranoid,\n"
2863                  "which controls use of the performance events system by\n"
2864                  "unprivileged users (without CAP_SYS_ADMIN).\n\n"
2865                  "The current value is %d:\n\n"
2866                  "  -1: Allow use of (almost) all events by all users\n"
2867                  "      Ignore mlock limit after perf_event_mlock_kb without CAP_IPC_LOCK\n"
2868                  ">= 0: Disallow ftrace function tracepoint by users without CAP_SYS_ADMIN\n"
2869                  "      Disallow raw tracepoint access by users without CAP_SYS_ADMIN\n"
2870                  ">= 1: Disallow CPU event access by users without CAP_SYS_ADMIN\n"
2871                  ">= 2: Disallow kernel profiling by users without CAP_SYS_ADMIN\n\n"
2872                  "To make this setting permanent, edit /etc/sysctl.conf too, e.g.:\n\n"
2873                  "      kernel.perf_event_paranoid = -1\n" ,
2874                                  target->system_wide ? "system-wide " : "",
2875                                  perf_event_paranoid());
2876         case ENOENT:
2877                 return scnprintf(msg, size, "The %s event is not supported.",
2878                                  perf_evsel__name(evsel));
2879         case EMFILE:
2880                 return scnprintf(msg, size, "%s",
2881                          "Too many events are opened.\n"
2882                          "Probably the maximum number of open file descriptors has been reached.\n"
2883                          "Hint: Try again after reducing the number of events.\n"
2884                          "Hint: Try increasing the limit with 'ulimit -n <limit>'");
2885         case ENOMEM:
2886                 if (evsel__has_callchain(evsel) &&
2887                     access("/proc/sys/kernel/perf_event_max_stack", F_OK) == 0)
2888                         return scnprintf(msg, size,
2889                                          "Not enough memory to setup event with callchain.\n"
2890                                          "Hint: Try tweaking /proc/sys/kernel/perf_event_max_stack\n"
2891                                          "Hint: Current value: %d", sysctl__max_stack());
2892                 break;
2893         case ENODEV:
2894                 if (target->cpu_list)
2895                         return scnprintf(msg, size, "%s",
2896          "No such device - did you specify an out-of-range profile CPU?");
2897                 break;
2898         case EOPNOTSUPP:
2899                 if (evsel->attr.sample_period != 0)
2900                         return scnprintf(msg, size,
2901         "%s: PMU Hardware doesn't support sampling/overflow-interrupts. Try 'perf stat'",
2902                                          perf_evsel__name(evsel));
2903                 if (evsel->attr.precise_ip)
2904                         return scnprintf(msg, size, "%s",
2905         "\'precise\' request may not be supported. Try removing 'p' modifier.");
2906 #if defined(__i386__) || defined(__x86_64__)
2907                 if (evsel->attr.type == PERF_TYPE_HARDWARE)
2908                         return scnprintf(msg, size, "%s",
2909         "No hardware sampling interrupt available.\n");
2910 #endif
2911                 break;
2912         case EBUSY:
2913                 if (find_process("oprofiled"))
2914                         return scnprintf(msg, size,
2915         "The PMU counters are busy/taken by another profiler.\n"
2916         "We found oprofile daemon running, please stop it and try again.");
2917                 break;
2918         case EINVAL:
2919                 if (evsel->attr.write_backward && perf_missing_features.write_backward)
2920                         return scnprintf(msg, size, "Reading from overwrite event is not supported by this kernel.");
2921                 if (perf_missing_features.clockid)
2922                         return scnprintf(msg, size, "clockid feature not supported.");
2923                 if (perf_missing_features.clockid_wrong)
2924                         return scnprintf(msg, size, "wrong clockid (%d).", clockid);
2925                 break;
2926         default:
2927                 break;
2928         }
2929
2930         return scnprintf(msg, size,
2931         "The sys_perf_event_open() syscall returned with %d (%s) for event (%s).\n"
2932         "/bin/dmesg | grep -i perf may provide additional information.\n",
2933                          err, str_error_r(err, sbuf, sizeof(sbuf)),
2934                          perf_evsel__name(evsel));
2935 }
2936
2937 struct perf_env *perf_evsel__env(struct perf_evsel *evsel)
2938 {
2939         if (evsel && evsel->evlist)
2940                 return evsel->evlist->env;
2941         return NULL;
2942 }