1 #include <errno.h> 2 #include <fcntl.h> 3 #include <inttypes.h> 4 #include <linux/kernel.h> 5 #include <linux/types.h> 6 #include <perf/cpumap.h> 7 #include <sys/types.h> 8 #include <sys/stat.h> 9 #include <unistd.h> 10 #include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */ 11 #include <linux/perf_event.h> 12 #include <linux/zalloc.h> 13 #include "cpumap.h" 14 #include "dso.h" 15 #include "event.h" 16 #include "debug.h" 17 #include "hist.h" 18 #include "machine.h" 19 #include "sort.h" 20 #include "string2.h" 21 #include "strlist.h" 22 #include "thread.h" 23 #include "thread_map.h" 24 #include "time-utils.h" 25 #include <linux/ctype.h> 26 #include "map.h" 27 #include "util/namespaces.h" 28 #include "symbol.h" 29 #include "symbol/kallsyms.h" 30 #include "asm/bug.h" 31 #include "stat.h" 32 #include "session.h" 33 #include "bpf-event.h" 34 #include "print_binary.h" 35 #include "tool.h" 36 #include "util.h" 37 38 static const char *perf_event__names[] = { 39 [0] = "TOTAL", 40 [PERF_RECORD_MMAP] = "MMAP", 41 [PERF_RECORD_MMAP2] = "MMAP2", 42 [PERF_RECORD_LOST] = "LOST", 43 [PERF_RECORD_COMM] = "COMM", 44 [PERF_RECORD_EXIT] = "EXIT", 45 [PERF_RECORD_THROTTLE] = "THROTTLE", 46 [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE", 47 [PERF_RECORD_FORK] = "FORK", 48 [PERF_RECORD_READ] = "READ", 49 [PERF_RECORD_SAMPLE] = "SAMPLE", 50 [PERF_RECORD_AUX] = "AUX", 51 [PERF_RECORD_ITRACE_START] = "ITRACE_START", 52 [PERF_RECORD_LOST_SAMPLES] = "LOST_SAMPLES", 53 [PERF_RECORD_SWITCH] = "SWITCH", 54 [PERF_RECORD_SWITCH_CPU_WIDE] = "SWITCH_CPU_WIDE", 55 [PERF_RECORD_NAMESPACES] = "NAMESPACES", 56 [PERF_RECORD_KSYMBOL] = "KSYMBOL", 57 [PERF_RECORD_BPF_EVENT] = "BPF_EVENT", 58 [PERF_RECORD_CGROUP] = "CGROUP", 59 [PERF_RECORD_TEXT_POKE] = "TEXT_POKE", 60 [PERF_RECORD_AUX_OUTPUT_HW_ID] = "AUX_OUTPUT_HW_ID", 61 [PERF_RECORD_HEADER_ATTR] = "ATTR", 62 [PERF_RECORD_HEADER_EVENT_TYPE] = "EVENT_TYPE", 63 [PERF_RECORD_HEADER_TRACING_DATA] = "TRACING_DATA", 64 [PERF_RECORD_HEADER_BUILD_ID] = "BUILD_ID", 65 [PERF_RECORD_FINISHED_ROUND] = "FINISHED_ROUND", 66 [PERF_RECORD_ID_INDEX] = "ID_INDEX", 67 [PERF_RECORD_AUXTRACE_INFO] = "AUXTRACE_INFO", 68 [PERF_RECORD_AUXTRACE] = "AUXTRACE", 69 [PERF_RECORD_AUXTRACE_ERROR] = "AUXTRACE_ERROR", 70 [PERF_RECORD_THREAD_MAP] = "THREAD_MAP", 71 [PERF_RECORD_CPU_MAP] = "CPU_MAP", 72 [PERF_RECORD_STAT_CONFIG] = "STAT_CONFIG", 73 [PERF_RECORD_STAT] = "STAT", 74 [PERF_RECORD_STAT_ROUND] = "STAT_ROUND", 75 [PERF_RECORD_EVENT_UPDATE] = "EVENT_UPDATE", 76 [PERF_RECORD_TIME_CONV] = "TIME_CONV", 77 [PERF_RECORD_HEADER_FEATURE] = "FEATURE", 78 [PERF_RECORD_COMPRESSED] = "COMPRESSED", 79 [PERF_RECORD_FINISHED_INIT] = "FINISHED_INIT", 80 }; 81 82 const char *perf_event__name(unsigned int id) 83 { 84 if (id >= ARRAY_SIZE(perf_event__names)) 85 return "INVALID"; 86 if (!perf_event__names[id]) 87 return "UNKNOWN"; 88 return perf_event__names[id]; 89 } 90 91 struct process_symbol_args { 92 const char *name; 93 u64 start; 94 }; 95 96 static int find_symbol_cb(void *arg, const char *name, char type, 97 u64 start) 98 { 99 struct process_symbol_args *args = arg; 100 101 /* 102 * Must be a function or at least an alias, as in PARISC64, where "_text" is 103 * an 'A' to the same address as "_stext". 104 */ 105 if (!(kallsyms__is_function(type) || 106 type == 'A') || strcmp(name, args->name)) 107 return 0; 108 109 args->start = start; 110 return 1; 111 } 112 113 int kallsyms__get_function_start(const char *kallsyms_filename, 114 const char *symbol_name, u64 *addr) 115 { 116 struct process_symbol_args args = { .name = symbol_name, }; 117 118 if (kallsyms__parse(kallsyms_filename, &args, find_symbol_cb) <= 0) 119 return -1; 120 121 *addr = args.start; 122 return 0; 123 } 124 125 void perf_event__read_stat_config(struct perf_stat_config *config, 126 struct perf_record_stat_config *event) 127 { 128 unsigned i; 129 130 for (i = 0; i < event->nr; i++) { 131 132 switch (event->data[i].tag) { 133 #define CASE(__term, __val) \ 134 case PERF_STAT_CONFIG_TERM__##__term: \ 135 config->__val = event->data[i].val; \ 136 break; 137 138 CASE(AGGR_MODE, aggr_mode) 139 CASE(SCALE, scale) 140 CASE(INTERVAL, interval) 141 #undef CASE 142 default: 143 pr_warning("unknown stat config term %" PRI_lu64 "\n", 144 event->data[i].tag); 145 } 146 } 147 } 148 149 size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp) 150 { 151 const char *s; 152 153 if (event->header.misc & PERF_RECORD_MISC_COMM_EXEC) 154 s = " exec"; 155 else 156 s = ""; 157 158 return fprintf(fp, "%s: %s:%d/%d\n", s, event->comm.comm, event->comm.pid, event->comm.tid); 159 } 160 161 size_t perf_event__fprintf_namespaces(union perf_event *event, FILE *fp) 162 { 163 size_t ret = 0; 164 struct perf_ns_link_info *ns_link_info; 165 u32 nr_namespaces, idx; 166 167 ns_link_info = event->namespaces.link_info; 168 nr_namespaces = event->namespaces.nr_namespaces; 169 170 ret += fprintf(fp, " %d/%d - nr_namespaces: %u\n\t\t[", 171 event->namespaces.pid, 172 event->namespaces.tid, 173 nr_namespaces); 174 175 for (idx = 0; idx < nr_namespaces; idx++) { 176 if (idx && (idx % 4 == 0)) 177 ret += fprintf(fp, "\n\t\t "); 178 179 ret += fprintf(fp, "%u/%s: %" PRIu64 "/%#" PRIx64 "%s", idx, 180 perf_ns__name(idx), (u64)ns_link_info[idx].dev, 181 (u64)ns_link_info[idx].ino, 182 ((idx + 1) != nr_namespaces) ? ", " : "]\n"); 183 } 184 185 return ret; 186 } 187 188 size_t perf_event__fprintf_cgroup(union perf_event *event, FILE *fp) 189 { 190 return fprintf(fp, " cgroup: %" PRI_lu64 " %s\n", 191 event->cgroup.id, event->cgroup.path); 192 } 193 194 int perf_event__process_comm(struct perf_tool *tool __maybe_unused, 195 union perf_event *event, 196 struct perf_sample *sample, 197 struct machine *machine) 198 { 199 return machine__process_comm_event(machine, event, sample); 200 } 201 202 int perf_event__process_namespaces(struct perf_tool *tool __maybe_unused, 203 union perf_event *event, 204 struct perf_sample *sample, 205 struct machine *machine) 206 { 207 return machine__process_namespaces_event(machine, event, sample); 208 } 209 210 int perf_event__process_cgroup(struct perf_tool *tool __maybe_unused, 211 union perf_event *event, 212 struct perf_sample *sample, 213 struct machine *machine) 214 { 215 return machine__process_cgroup_event(machine, event, sample); 216 } 217 218 int perf_event__process_lost(struct perf_tool *tool __maybe_unused, 219 union perf_event *event, 220 struct perf_sample *sample, 221 struct machine *machine) 222 { 223 return machine__process_lost_event(machine, event, sample); 224 } 225 226 int perf_event__process_aux(struct perf_tool *tool __maybe_unused, 227 union perf_event *event, 228 struct perf_sample *sample __maybe_unused, 229 struct machine *machine) 230 { 231 return machine__process_aux_event(machine, event); 232 } 233 234 int perf_event__process_itrace_start(struct perf_tool *tool __maybe_unused, 235 union perf_event *event, 236 struct perf_sample *sample __maybe_unused, 237 struct machine *machine) 238 { 239 return machine__process_itrace_start_event(machine, event); 240 } 241 242 int perf_event__process_aux_output_hw_id(struct perf_tool *tool __maybe_unused, 243 union perf_event *event, 244 struct perf_sample *sample __maybe_unused, 245 struct machine *machine) 246 { 247 return machine__process_aux_output_hw_id_event(machine, event); 248 } 249 250 int perf_event__process_lost_samples(struct perf_tool *tool __maybe_unused, 251 union perf_event *event, 252 struct perf_sample *sample, 253 struct machine *machine) 254 { 255 return machine__process_lost_samples_event(machine, event, sample); 256 } 257 258 int perf_event__process_switch(struct perf_tool *tool __maybe_unused, 259 union perf_event *event, 260 struct perf_sample *sample __maybe_unused, 261 struct machine *machine) 262 { 263 return machine__process_switch_event(machine, event); 264 } 265 266 int perf_event__process_ksymbol(struct perf_tool *tool __maybe_unused, 267 union perf_event *event, 268 struct perf_sample *sample __maybe_unused, 269 struct machine *machine) 270 { 271 return machine__process_ksymbol(machine, event, sample); 272 } 273 274 int perf_event__process_bpf(struct perf_tool *tool __maybe_unused, 275 union perf_event *event, 276 struct perf_sample *sample, 277 struct machine *machine) 278 { 279 return machine__process_bpf(machine, event, sample); 280 } 281 282 int perf_event__process_text_poke(struct perf_tool *tool __maybe_unused, 283 union perf_event *event, 284 struct perf_sample *sample, 285 struct machine *machine) 286 { 287 return machine__process_text_poke(machine, event, sample); 288 } 289 290 size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp) 291 { 292 return fprintf(fp, " %d/%d: [%#" PRI_lx64 "(%#" PRI_lx64 ") @ %#" PRI_lx64 "]: %c %s\n", 293 event->mmap.pid, event->mmap.tid, event->mmap.start, 294 event->mmap.len, event->mmap.pgoff, 295 (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) ? 'r' : 'x', 296 event->mmap.filename); 297 } 298 299 size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp) 300 { 301 if (event->header.misc & PERF_RECORD_MISC_MMAP_BUILD_ID) { 302 char sbuild_id[SBUILD_ID_SIZE]; 303 struct build_id bid; 304 305 build_id__init(&bid, event->mmap2.build_id, 306 event->mmap2.build_id_size); 307 build_id__sprintf(&bid, sbuild_id); 308 309 return fprintf(fp, " %d/%d: [%#" PRI_lx64 "(%#" PRI_lx64 ") @ %#" PRI_lx64 310 " <%s>]: %c%c%c%c %s\n", 311 event->mmap2.pid, event->mmap2.tid, event->mmap2.start, 312 event->mmap2.len, event->mmap2.pgoff, sbuild_id, 313 (event->mmap2.prot & PROT_READ) ? 'r' : '-', 314 (event->mmap2.prot & PROT_WRITE) ? 'w' : '-', 315 (event->mmap2.prot & PROT_EXEC) ? 'x' : '-', 316 (event->mmap2.flags & MAP_SHARED) ? 's' : 'p', 317 event->mmap2.filename); 318 } else { 319 return fprintf(fp, " %d/%d: [%#" PRI_lx64 "(%#" PRI_lx64 ") @ %#" PRI_lx64 320 " %02x:%02x %"PRI_lu64" %"PRI_lu64"]: %c%c%c%c %s\n", 321 event->mmap2.pid, event->mmap2.tid, event->mmap2.start, 322 event->mmap2.len, event->mmap2.pgoff, event->mmap2.maj, 323 event->mmap2.min, event->mmap2.ino, 324 event->mmap2.ino_generation, 325 (event->mmap2.prot & PROT_READ) ? 'r' : '-', 326 (event->mmap2.prot & PROT_WRITE) ? 'w' : '-', 327 (event->mmap2.prot & PROT_EXEC) ? 'x' : '-', 328 (event->mmap2.flags & MAP_SHARED) ? 's' : 'p', 329 event->mmap2.filename); 330 } 331 } 332 333 size_t perf_event__fprintf_thread_map(union perf_event *event, FILE *fp) 334 { 335 struct perf_thread_map *threads = thread_map__new_event(&event->thread_map); 336 size_t ret; 337 338 ret = fprintf(fp, " nr: "); 339 340 if (threads) 341 ret += thread_map__fprintf(threads, fp); 342 else 343 ret += fprintf(fp, "failed to get threads from event\n"); 344 345 perf_thread_map__put(threads); 346 return ret; 347 } 348 349 size_t perf_event__fprintf_cpu_map(union perf_event *event, FILE *fp) 350 { 351 struct perf_cpu_map *cpus = cpu_map__new_data(&event->cpu_map.data); 352 size_t ret; 353 354 ret = fprintf(fp, ": "); 355 356 if (cpus) 357 ret += cpu_map__fprintf(cpus, fp); 358 else 359 ret += fprintf(fp, "failed to get cpumap from event\n"); 360 361 perf_cpu_map__put(cpus); 362 return ret; 363 } 364 365 int perf_event__process_mmap(struct perf_tool *tool __maybe_unused, 366 union perf_event *event, 367 struct perf_sample *sample, 368 struct machine *machine) 369 { 370 return machine__process_mmap_event(machine, event, sample); 371 } 372 373 int perf_event__process_mmap2(struct perf_tool *tool __maybe_unused, 374 union perf_event *event, 375 struct perf_sample *sample, 376 struct machine *machine) 377 { 378 return machine__process_mmap2_event(machine, event, sample); 379 } 380 381 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp) 382 { 383 return fprintf(fp, "(%d:%d):(%d:%d)\n", 384 event->fork.pid, event->fork.tid, 385 event->fork.ppid, event->fork.ptid); 386 } 387 388 int perf_event__process_fork(struct perf_tool *tool __maybe_unused, 389 union perf_event *event, 390 struct perf_sample *sample, 391 struct machine *machine) 392 { 393 return machine__process_fork_event(machine, event, sample); 394 } 395 396 int perf_event__process_exit(struct perf_tool *tool __maybe_unused, 397 union perf_event *event, 398 struct perf_sample *sample, 399 struct machine *machine) 400 { 401 return machine__process_exit_event(machine, event, sample); 402 } 403 404 size_t perf_event__fprintf_aux(union perf_event *event, FILE *fp) 405 { 406 return fprintf(fp, " offset: %#"PRI_lx64" size: %#"PRI_lx64" flags: %#"PRI_lx64" [%s%s%s]\n", 407 event->aux.aux_offset, event->aux.aux_size, 408 event->aux.flags, 409 event->aux.flags & PERF_AUX_FLAG_TRUNCATED ? "T" : "", 410 event->aux.flags & PERF_AUX_FLAG_OVERWRITE ? "O" : "", 411 event->aux.flags & PERF_AUX_FLAG_PARTIAL ? "P" : ""); 412 } 413 414 size_t perf_event__fprintf_itrace_start(union perf_event *event, FILE *fp) 415 { 416 return fprintf(fp, " pid: %u tid: %u\n", 417 event->itrace_start.pid, event->itrace_start.tid); 418 } 419 420 size_t perf_event__fprintf_aux_output_hw_id(union perf_event *event, FILE *fp) 421 { 422 return fprintf(fp, " hw_id: %#"PRI_lx64"\n", 423 event->aux_output_hw_id.hw_id); 424 } 425 426 size_t perf_event__fprintf_switch(union perf_event *event, FILE *fp) 427 { 428 bool out = event->header.misc & PERF_RECORD_MISC_SWITCH_OUT; 429 const char *in_out = !out ? "IN " : 430 !(event->header.misc & PERF_RECORD_MISC_SWITCH_OUT_PREEMPT) ? 431 "OUT " : "OUT preempt"; 432 433 if (event->header.type == PERF_RECORD_SWITCH) 434 return fprintf(fp, " %s\n", in_out); 435 436 return fprintf(fp, " %s %s pid/tid: %5d/%-5d\n", 437 in_out, out ? "next" : "prev", 438 event->context_switch.next_prev_pid, 439 event->context_switch.next_prev_tid); 440 } 441 442 static size_t perf_event__fprintf_lost(union perf_event *event, FILE *fp) 443 { 444 return fprintf(fp, " lost %" PRI_lu64 "\n", event->lost.lost); 445 } 446 447 size_t perf_event__fprintf_ksymbol(union perf_event *event, FILE *fp) 448 { 449 return fprintf(fp, " addr %" PRI_lx64 " len %u type %u flags 0x%x name %s\n", 450 event->ksymbol.addr, event->ksymbol.len, 451 event->ksymbol.ksym_type, 452 event->ksymbol.flags, event->ksymbol.name); 453 } 454 455 size_t perf_event__fprintf_bpf(union perf_event *event, FILE *fp) 456 { 457 return fprintf(fp, " type %u, flags %u, id %u\n", 458 event->bpf.type, event->bpf.flags, event->bpf.id); 459 } 460 461 static int text_poke_printer(enum binary_printer_ops op, unsigned int val, 462 void *extra, FILE *fp) 463 { 464 bool old = *(bool *)extra; 465 466 switch ((int)op) { 467 case BINARY_PRINT_LINE_BEGIN: 468 return fprintf(fp, " %s bytes:", old ? "Old" : "New"); 469 case BINARY_PRINT_NUM_DATA: 470 return fprintf(fp, " %02x", val); 471 case BINARY_PRINT_LINE_END: 472 return fprintf(fp, "\n"); 473 default: 474 return 0; 475 } 476 } 477 478 size_t perf_event__fprintf_text_poke(union perf_event *event, struct machine *machine, FILE *fp) 479 { 480 struct perf_record_text_poke_event *tp = &event->text_poke; 481 size_t ret; 482 bool old; 483 484 ret = fprintf(fp, " %" PRI_lx64 " ", tp->addr); 485 if (machine) { 486 struct addr_location al; 487 488 al.map = map__get(maps__find(machine__kernel_maps(machine), tp->addr)); 489 if (al.map && map__load(al.map) >= 0) { 490 al.addr = map__map_ip(al.map, tp->addr); 491 al.sym = map__find_symbol(al.map, al.addr); 492 if (al.sym) 493 ret += symbol__fprintf_symname_offs(al.sym, &al, fp); 494 } 495 map__put(al.map); 496 } 497 ret += fprintf(fp, " old len %u new len %u\n", tp->old_len, tp->new_len); 498 old = true; 499 ret += binary__fprintf(tp->bytes, tp->old_len, 16, text_poke_printer, 500 &old, fp); 501 old = false; 502 ret += binary__fprintf(tp->bytes + tp->old_len, tp->new_len, 16, 503 text_poke_printer, &old, fp); 504 return ret; 505 } 506 507 size_t perf_event__fprintf(union perf_event *event, struct machine *machine, FILE *fp) 508 { 509 size_t ret = fprintf(fp, "PERF_RECORD_%s", 510 perf_event__name(event->header.type)); 511 512 switch (event->header.type) { 513 case PERF_RECORD_COMM: 514 ret += perf_event__fprintf_comm(event, fp); 515 break; 516 case PERF_RECORD_FORK: 517 case PERF_RECORD_EXIT: 518 ret += perf_event__fprintf_task(event, fp); 519 break; 520 case PERF_RECORD_MMAP: 521 ret += perf_event__fprintf_mmap(event, fp); 522 break; 523 case PERF_RECORD_NAMESPACES: 524 ret += perf_event__fprintf_namespaces(event, fp); 525 break; 526 case PERF_RECORD_CGROUP: 527 ret += perf_event__fprintf_cgroup(event, fp); 528 break; 529 case PERF_RECORD_MMAP2: 530 ret += perf_event__fprintf_mmap2(event, fp); 531 break; 532 case PERF_RECORD_AUX: 533 ret += perf_event__fprintf_aux(event, fp); 534 break; 535 case PERF_RECORD_ITRACE_START: 536 ret += perf_event__fprintf_itrace_start(event, fp); 537 break; 538 case PERF_RECORD_SWITCH: 539 case PERF_RECORD_SWITCH_CPU_WIDE: 540 ret += perf_event__fprintf_switch(event, fp); 541 break; 542 case PERF_RECORD_LOST: 543 ret += perf_event__fprintf_lost(event, fp); 544 break; 545 case PERF_RECORD_KSYMBOL: 546 ret += perf_event__fprintf_ksymbol(event, fp); 547 break; 548 case PERF_RECORD_BPF_EVENT: 549 ret += perf_event__fprintf_bpf(event, fp); 550 break; 551 case PERF_RECORD_TEXT_POKE: 552 ret += perf_event__fprintf_text_poke(event, machine, fp); 553 break; 554 case PERF_RECORD_AUX_OUTPUT_HW_ID: 555 ret += perf_event__fprintf_aux_output_hw_id(event, fp); 556 break; 557 default: 558 ret += fprintf(fp, "\n"); 559 } 560 561 return ret; 562 } 563 564 int perf_event__process(struct perf_tool *tool __maybe_unused, 565 union perf_event *event, 566 struct perf_sample *sample, 567 struct machine *machine) 568 { 569 return machine__process_event(machine, event, sample); 570 } 571 572 struct map *thread__find_map(struct thread *thread, u8 cpumode, u64 addr, 573 struct addr_location *al) 574 { 575 struct maps *maps = thread->maps; 576 struct machine *machine = maps__machine(maps); 577 bool load_map = false; 578 579 al->maps = maps; 580 al->thread = thread; 581 al->addr = addr; 582 al->cpumode = cpumode; 583 al->filtered = 0; 584 585 if (machine == NULL) { 586 al->map = NULL; 587 return NULL; 588 } 589 590 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) { 591 al->level = 'k'; 592 al->maps = maps = machine__kernel_maps(machine); 593 load_map = true; 594 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) { 595 al->level = '.'; 596 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) { 597 al->level = 'g'; 598 al->maps = maps = machine__kernel_maps(machine); 599 load_map = true; 600 } else if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest) { 601 al->level = 'u'; 602 } else { 603 al->level = 'H'; 604 al->map = NULL; 605 606 if ((cpumode == PERF_RECORD_MISC_GUEST_USER || 607 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) && 608 !perf_guest) 609 al->filtered |= (1 << HIST_FILTER__GUEST); 610 if ((cpumode == PERF_RECORD_MISC_USER || 611 cpumode == PERF_RECORD_MISC_KERNEL) && 612 !perf_host) 613 al->filtered |= (1 << HIST_FILTER__HOST); 614 615 return NULL; 616 } 617 618 al->map = map__get(maps__find(maps, al->addr)); 619 if (al->map != NULL) { 620 /* 621 * Kernel maps might be changed when loading symbols so loading 622 * must be done prior to using kernel maps. 623 */ 624 if (load_map) 625 map__load(al->map); 626 al->addr = map__map_ip(al->map, al->addr); 627 } 628 629 return al->map; 630 } 631 632 /* 633 * For branch stacks or branch samples, the sample cpumode might not be correct 634 * because it applies only to the sample 'ip' and not necessary to 'addr' or 635 * branch stack addresses. If possible, use a fallback to deal with those cases. 636 */ 637 struct map *thread__find_map_fb(struct thread *thread, u8 cpumode, u64 addr, 638 struct addr_location *al) 639 { 640 struct map *map = thread__find_map(thread, cpumode, addr, al); 641 struct machine *machine = maps__machine(thread->maps); 642 u8 addr_cpumode = machine__addr_cpumode(machine, cpumode, addr); 643 644 if (map || addr_cpumode == cpumode) 645 return map; 646 647 return thread__find_map(thread, addr_cpumode, addr, al); 648 } 649 650 struct symbol *thread__find_symbol(struct thread *thread, u8 cpumode, 651 u64 addr, struct addr_location *al) 652 { 653 al->sym = NULL; 654 if (thread__find_map(thread, cpumode, addr, al)) 655 al->sym = map__find_symbol(al->map, al->addr); 656 return al->sym; 657 } 658 659 struct symbol *thread__find_symbol_fb(struct thread *thread, u8 cpumode, 660 u64 addr, struct addr_location *al) 661 { 662 al->sym = NULL; 663 if (thread__find_map_fb(thread, cpumode, addr, al)) 664 al->sym = map__find_symbol(al->map, al->addr); 665 return al->sym; 666 } 667 668 static bool check_address_range(struct intlist *addr_list, int addr_range, 669 unsigned long addr) 670 { 671 struct int_node *pos; 672 673 intlist__for_each_entry(pos, addr_list) { 674 if (addr >= pos->i && addr < pos->i + addr_range) 675 return true; 676 } 677 678 return false; 679 } 680 681 /* 682 * Callers need to drop the reference to al->thread, obtained in 683 * machine__findnew_thread() 684 */ 685 int machine__resolve(struct machine *machine, struct addr_location *al, 686 struct perf_sample *sample) 687 { 688 struct thread *thread; 689 struct dso *dso; 690 691 if (symbol_conf.guest_code && !machine__is_host(machine)) 692 thread = machine__findnew_guest_code(machine, sample->pid); 693 else 694 thread = machine__findnew_thread(machine, sample->pid, sample->tid); 695 if (thread == NULL) 696 return -1; 697 698 dump_printf(" ... thread: %s:%d\n", thread__comm_str(thread), thread->tid); 699 thread__find_map(thread, sample->cpumode, sample->ip, al); 700 dso = al->map ? map__dso(al->map) : NULL; 701 dump_printf(" ...... dso: %s\n", 702 dso 703 ? dso->long_name 704 : (al->level == 'H' ? "[hypervisor]" : "<not found>")); 705 706 if (thread__is_filtered(thread)) 707 al->filtered |= (1 << HIST_FILTER__THREAD); 708 709 al->sym = NULL; 710 al->cpu = sample->cpu; 711 al->socket = -1; 712 al->srcline = NULL; 713 714 if (al->cpu >= 0) { 715 struct perf_env *env = machine->env; 716 717 if (env && env->cpu) 718 al->socket = env->cpu[al->cpu].socket_id; 719 } 720 721 if (al->map) { 722 if (symbol_conf.dso_list && 723 (!dso || !(strlist__has_entry(symbol_conf.dso_list, 724 dso->short_name) || 725 (dso->short_name != dso->long_name && 726 strlist__has_entry(symbol_conf.dso_list, 727 dso->long_name))))) { 728 al->filtered |= (1 << HIST_FILTER__DSO); 729 } 730 731 al->sym = map__find_symbol(al->map, al->addr); 732 } else if (symbol_conf.dso_list) { 733 al->filtered |= (1 << HIST_FILTER__DSO); 734 } 735 736 if (symbol_conf.sym_list) { 737 int ret = 0; 738 char al_addr_str[32]; 739 size_t sz = sizeof(al_addr_str); 740 741 if (al->sym) { 742 ret = strlist__has_entry(symbol_conf.sym_list, 743 al->sym->name); 744 } 745 if (!ret && al->sym) { 746 snprintf(al_addr_str, sz, "0x%"PRIx64, 747 map__unmap_ip(al->map, al->sym->start)); 748 ret = strlist__has_entry(symbol_conf.sym_list, 749 al_addr_str); 750 } 751 if (!ret && symbol_conf.addr_list && al->map) { 752 unsigned long addr = map__unmap_ip(al->map, al->addr); 753 754 ret = intlist__has_entry(symbol_conf.addr_list, addr); 755 if (!ret && symbol_conf.addr_range) { 756 ret = check_address_range(symbol_conf.addr_list, 757 symbol_conf.addr_range, 758 addr); 759 } 760 } 761 762 if (!ret) 763 al->filtered |= (1 << HIST_FILTER__SYMBOL); 764 } 765 766 return 0; 767 } 768 769 /* 770 * The preprocess_sample method will return with reference counts for the 771 * in it, when done using (and perhaps getting ref counts if needing to 772 * keep a pointer to one of those entries) it must be paired with 773 * addr_location__put(), so that the refcounts can be decremented. 774 */ 775 void addr_location__put(struct addr_location *al) 776 { 777 map__zput(al->map); 778 thread__zput(al->thread); 779 } 780 781 bool is_bts_event(struct perf_event_attr *attr) 782 { 783 return attr->type == PERF_TYPE_HARDWARE && 784 (attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) && 785 attr->sample_period == 1; 786 } 787 788 bool sample_addr_correlates_sym(struct perf_event_attr *attr) 789 { 790 if (attr->type == PERF_TYPE_SOFTWARE && 791 (attr->config == PERF_COUNT_SW_PAGE_FAULTS || 792 attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN || 793 attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)) 794 return true; 795 796 if (is_bts_event(attr)) 797 return true; 798 799 return false; 800 } 801 802 void thread__resolve(struct thread *thread, struct addr_location *al, 803 struct perf_sample *sample) 804 { 805 thread__find_map_fb(thread, sample->cpumode, sample->addr, al); 806 807 al->cpu = sample->cpu; 808 al->sym = NULL; 809 810 if (al->map) 811 al->sym = map__find_symbol(al->map, al->addr); 812 } 813