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