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