1 #include <linux/types.h> 2 #include "event.h" 3 #include "debug.h" 4 #include "machine.h" 5 #include "sort.h" 6 #include "string.h" 7 #include "strlist.h" 8 #include "thread.h" 9 #include "thread_map.h" 10 11 static const char *perf_event__names[] = { 12 [0] = "TOTAL", 13 [PERF_RECORD_MMAP] = "MMAP", 14 [PERF_RECORD_MMAP2] = "MMAP2", 15 [PERF_RECORD_LOST] = "LOST", 16 [PERF_RECORD_COMM] = "COMM", 17 [PERF_RECORD_EXIT] = "EXIT", 18 [PERF_RECORD_THROTTLE] = "THROTTLE", 19 [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE", 20 [PERF_RECORD_FORK] = "FORK", 21 [PERF_RECORD_READ] = "READ", 22 [PERF_RECORD_SAMPLE] = "SAMPLE", 23 [PERF_RECORD_HEADER_ATTR] = "ATTR", 24 [PERF_RECORD_HEADER_EVENT_TYPE] = "EVENT_TYPE", 25 [PERF_RECORD_HEADER_TRACING_DATA] = "TRACING_DATA", 26 [PERF_RECORD_HEADER_BUILD_ID] = "BUILD_ID", 27 [PERF_RECORD_FINISHED_ROUND] = "FINISHED_ROUND", 28 }; 29 30 const char *perf_event__name(unsigned int id) 31 { 32 if (id >= ARRAY_SIZE(perf_event__names)) 33 return "INVALID"; 34 if (!perf_event__names[id]) 35 return "UNKNOWN"; 36 return perf_event__names[id]; 37 } 38 39 static struct perf_sample synth_sample = { 40 .pid = -1, 41 .tid = -1, 42 .time = -1, 43 .stream_id = -1, 44 .cpu = -1, 45 .period = 1, 46 }; 47 48 static pid_t perf_event__get_comm_tgid(pid_t pid, char *comm, size_t len) 49 { 50 char filename[PATH_MAX]; 51 char bf[BUFSIZ]; 52 FILE *fp; 53 size_t size = 0; 54 pid_t tgid = -1; 55 56 snprintf(filename, sizeof(filename), "/proc/%d/status", pid); 57 58 fp = fopen(filename, "r"); 59 if (fp == NULL) { 60 pr_debug("couldn't open %s\n", filename); 61 return 0; 62 } 63 64 while (!comm[0] || (tgid < 0)) { 65 if (fgets(bf, sizeof(bf), fp) == NULL) { 66 pr_warning("couldn't get COMM and pgid, malformed %s\n", 67 filename); 68 break; 69 } 70 71 if (memcmp(bf, "Name:", 5) == 0) { 72 char *name = bf + 5; 73 while (*name && isspace(*name)) 74 ++name; 75 size = strlen(name) - 1; 76 if (size >= len) 77 size = len - 1; 78 memcpy(comm, name, size); 79 comm[size] = '\0'; 80 81 } else if (memcmp(bf, "Tgid:", 5) == 0) { 82 char *tgids = bf + 5; 83 while (*tgids && isspace(*tgids)) 84 ++tgids; 85 tgid = atoi(tgids); 86 } 87 } 88 89 fclose(fp); 90 91 return tgid; 92 } 93 94 static pid_t perf_event__synthesize_comm(struct perf_tool *tool, 95 union perf_event *event, pid_t pid, 96 int full, 97 perf_event__handler_t process, 98 struct machine *machine) 99 { 100 char filename[PATH_MAX]; 101 size_t size; 102 DIR *tasks; 103 struct dirent dirent, *next; 104 pid_t tgid; 105 106 memset(&event->comm, 0, sizeof(event->comm)); 107 108 tgid = perf_event__get_comm_tgid(pid, event->comm.comm, 109 sizeof(event->comm.comm)); 110 if (tgid < 0) 111 goto out; 112 113 event->comm.pid = tgid; 114 event->comm.header.type = PERF_RECORD_COMM; 115 116 size = strlen(event->comm.comm) + 1; 117 size = PERF_ALIGN(size, sizeof(u64)); 118 memset(event->comm.comm + size, 0, machine->id_hdr_size); 119 event->comm.header.size = (sizeof(event->comm) - 120 (sizeof(event->comm.comm) - size) + 121 machine->id_hdr_size); 122 if (!full) { 123 event->comm.tid = pid; 124 125 if (process(tool, event, &synth_sample, machine) != 0) 126 return -1; 127 128 goto out; 129 } 130 131 snprintf(filename, sizeof(filename), "/proc/%d/task", pid); 132 133 tasks = opendir(filename); 134 if (tasks == NULL) { 135 pr_debug("couldn't open %s\n", filename); 136 return 0; 137 } 138 139 while (!readdir_r(tasks, &dirent, &next) && next) { 140 char *end; 141 pid = strtol(dirent.d_name, &end, 10); 142 if (*end) 143 continue; 144 145 /* already have tgid; jut want to update the comm */ 146 (void) perf_event__get_comm_tgid(pid, event->comm.comm, 147 sizeof(event->comm.comm)); 148 149 size = strlen(event->comm.comm) + 1; 150 size = PERF_ALIGN(size, sizeof(u64)); 151 memset(event->comm.comm + size, 0, machine->id_hdr_size); 152 event->comm.header.size = (sizeof(event->comm) - 153 (sizeof(event->comm.comm) - size) + 154 machine->id_hdr_size); 155 156 event->comm.tid = pid; 157 158 if (process(tool, event, &synth_sample, machine) != 0) { 159 tgid = -1; 160 break; 161 } 162 } 163 164 closedir(tasks); 165 out: 166 return tgid; 167 } 168 169 static int perf_event__synthesize_mmap_events(struct perf_tool *tool, 170 union perf_event *event, 171 pid_t pid, pid_t tgid, 172 perf_event__handler_t process, 173 struct machine *machine) 174 { 175 char filename[PATH_MAX]; 176 FILE *fp; 177 int rc = 0; 178 179 snprintf(filename, sizeof(filename), "/proc/%d/maps", pid); 180 181 fp = fopen(filename, "r"); 182 if (fp == NULL) { 183 /* 184 * We raced with a task exiting - just return: 185 */ 186 pr_debug("couldn't open %s\n", filename); 187 return -1; 188 } 189 190 event->header.type = PERF_RECORD_MMAP; 191 /* 192 * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c 193 */ 194 event->header.misc = PERF_RECORD_MISC_USER; 195 196 while (1) { 197 char bf[BUFSIZ]; 198 char prot[5]; 199 char execname[PATH_MAX]; 200 char anonstr[] = "//anon"; 201 size_t size; 202 ssize_t n; 203 204 if (fgets(bf, sizeof(bf), fp) == NULL) 205 break; 206 207 /* ensure null termination since stack will be reused. */ 208 strcpy(execname, ""); 209 210 /* 00400000-0040c000 r-xp 00000000 fd:01 41038 /bin/cat */ 211 n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %*x:%*x %*u %s\n", 212 &event->mmap.start, &event->mmap.len, prot, 213 &event->mmap.pgoff, 214 execname); 215 /* 216 * Anon maps don't have the execname. 217 */ 218 if (n < 4) 219 continue; 220 221 if (prot[2] != 'x') 222 continue; 223 224 if (!strcmp(execname, "")) 225 strcpy(execname, anonstr); 226 227 size = strlen(execname) + 1; 228 memcpy(event->mmap.filename, execname, size); 229 size = PERF_ALIGN(size, sizeof(u64)); 230 event->mmap.len -= event->mmap.start; 231 event->mmap.header.size = (sizeof(event->mmap) - 232 (sizeof(event->mmap.filename) - size)); 233 memset(event->mmap.filename + size, 0, machine->id_hdr_size); 234 event->mmap.header.size += machine->id_hdr_size; 235 event->mmap.pid = tgid; 236 event->mmap.tid = pid; 237 238 if (process(tool, event, &synth_sample, machine) != 0) { 239 rc = -1; 240 break; 241 } 242 } 243 244 fclose(fp); 245 return rc; 246 } 247 248 int perf_event__synthesize_modules(struct perf_tool *tool, 249 perf_event__handler_t process, 250 struct machine *machine) 251 { 252 int rc = 0; 253 struct rb_node *nd; 254 struct map_groups *kmaps = &machine->kmaps; 255 union perf_event *event = zalloc((sizeof(event->mmap) + 256 machine->id_hdr_size)); 257 if (event == NULL) { 258 pr_debug("Not enough memory synthesizing mmap event " 259 "for kernel modules\n"); 260 return -1; 261 } 262 263 event->header.type = PERF_RECORD_MMAP; 264 265 /* 266 * kernel uses 0 for user space maps, see kernel/perf_event.c 267 * __perf_event_mmap 268 */ 269 if (machine__is_host(machine)) 270 event->header.misc = PERF_RECORD_MISC_KERNEL; 271 else 272 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; 273 274 for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]); 275 nd; nd = rb_next(nd)) { 276 size_t size; 277 struct map *pos = rb_entry(nd, struct map, rb_node); 278 279 if (pos->dso->kernel) 280 continue; 281 282 size = PERF_ALIGN(pos->dso->long_name_len + 1, sizeof(u64)); 283 event->mmap.header.type = PERF_RECORD_MMAP; 284 event->mmap.header.size = (sizeof(event->mmap) - 285 (sizeof(event->mmap.filename) - size)); 286 memset(event->mmap.filename + size, 0, machine->id_hdr_size); 287 event->mmap.header.size += machine->id_hdr_size; 288 event->mmap.start = pos->start; 289 event->mmap.len = pos->end - pos->start; 290 event->mmap.pid = machine->pid; 291 292 memcpy(event->mmap.filename, pos->dso->long_name, 293 pos->dso->long_name_len + 1); 294 if (process(tool, event, &synth_sample, machine) != 0) { 295 rc = -1; 296 break; 297 } 298 } 299 300 free(event); 301 return rc; 302 } 303 304 static int __event__synthesize_thread(union perf_event *comm_event, 305 union perf_event *mmap_event, 306 pid_t pid, int full, 307 perf_event__handler_t process, 308 struct perf_tool *tool, 309 struct machine *machine) 310 { 311 pid_t tgid = perf_event__synthesize_comm(tool, comm_event, pid, full, 312 process, machine); 313 if (tgid == -1) 314 return -1; 315 return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, 316 process, machine); 317 } 318 319 int perf_event__synthesize_thread_map(struct perf_tool *tool, 320 struct thread_map *threads, 321 perf_event__handler_t process, 322 struct machine *machine) 323 { 324 union perf_event *comm_event, *mmap_event; 325 int err = -1, thread, j; 326 327 comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); 328 if (comm_event == NULL) 329 goto out; 330 331 mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size); 332 if (mmap_event == NULL) 333 goto out_free_comm; 334 335 err = 0; 336 for (thread = 0; thread < threads->nr; ++thread) { 337 if (__event__synthesize_thread(comm_event, mmap_event, 338 threads->map[thread], 0, 339 process, tool, machine)) { 340 err = -1; 341 break; 342 } 343 344 /* 345 * comm.pid is set to thread group id by 346 * perf_event__synthesize_comm 347 */ 348 if ((int) comm_event->comm.pid != threads->map[thread]) { 349 bool need_leader = true; 350 351 /* is thread group leader in thread_map? */ 352 for (j = 0; j < threads->nr; ++j) { 353 if ((int) comm_event->comm.pid == threads->map[j]) { 354 need_leader = false; 355 break; 356 } 357 } 358 359 /* if not, generate events for it */ 360 if (need_leader && 361 __event__synthesize_thread(comm_event, 362 mmap_event, 363 comm_event->comm.pid, 0, 364 process, tool, machine)) { 365 err = -1; 366 break; 367 } 368 } 369 } 370 free(mmap_event); 371 out_free_comm: 372 free(comm_event); 373 out: 374 return err; 375 } 376 377 int perf_event__synthesize_threads(struct perf_tool *tool, 378 perf_event__handler_t process, 379 struct machine *machine) 380 { 381 DIR *proc; 382 struct dirent dirent, *next; 383 union perf_event *comm_event, *mmap_event; 384 int err = -1; 385 386 comm_event = malloc(sizeof(comm_event->comm) + machine->id_hdr_size); 387 if (comm_event == NULL) 388 goto out; 389 390 mmap_event = malloc(sizeof(mmap_event->mmap) + machine->id_hdr_size); 391 if (mmap_event == NULL) 392 goto out_free_comm; 393 394 proc = opendir("/proc"); 395 if (proc == NULL) 396 goto out_free_mmap; 397 398 while (!readdir_r(proc, &dirent, &next) && next) { 399 char *end; 400 pid_t pid = strtol(dirent.d_name, &end, 10); 401 402 if (*end) /* only interested in proper numerical dirents */ 403 continue; 404 /* 405 * We may race with exiting thread, so don't stop just because 406 * one thread couldn't be synthesized. 407 */ 408 __event__synthesize_thread(comm_event, mmap_event, pid, 1, 409 process, tool, machine); 410 } 411 412 err = 0; 413 closedir(proc); 414 out_free_mmap: 415 free(mmap_event); 416 out_free_comm: 417 free(comm_event); 418 out: 419 return err; 420 } 421 422 struct process_symbol_args { 423 const char *name; 424 u64 start; 425 }; 426 427 static int find_symbol_cb(void *arg, const char *name, char type, 428 u64 start) 429 { 430 struct process_symbol_args *args = arg; 431 432 /* 433 * Must be a function or at least an alias, as in PARISC64, where "_text" is 434 * an 'A' to the same address as "_stext". 435 */ 436 if (!(symbol_type__is_a(type, MAP__FUNCTION) || 437 type == 'A') || strcmp(name, args->name)) 438 return 0; 439 440 args->start = start; 441 return 1; 442 } 443 444 int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, 445 perf_event__handler_t process, 446 struct machine *machine, 447 const char *symbol_name) 448 { 449 size_t size; 450 const char *filename, *mmap_name; 451 char path[PATH_MAX]; 452 char name_buff[PATH_MAX]; 453 struct map *map; 454 int err; 455 /* 456 * We should get this from /sys/kernel/sections/.text, but till that is 457 * available use this, and after it is use this as a fallback for older 458 * kernels. 459 */ 460 struct process_symbol_args args = { .name = symbol_name, }; 461 union perf_event *event = zalloc((sizeof(event->mmap) + 462 machine->id_hdr_size)); 463 if (event == NULL) { 464 pr_debug("Not enough memory synthesizing mmap event " 465 "for kernel modules\n"); 466 return -1; 467 } 468 469 mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff)); 470 if (machine__is_host(machine)) { 471 /* 472 * kernel uses PERF_RECORD_MISC_USER for user space maps, 473 * see kernel/perf_event.c __perf_event_mmap 474 */ 475 event->header.misc = PERF_RECORD_MISC_KERNEL; 476 filename = "/proc/kallsyms"; 477 } else { 478 event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; 479 if (machine__is_default_guest(machine)) 480 filename = (char *) symbol_conf.default_guest_kallsyms; 481 else { 482 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 483 filename = path; 484 } 485 } 486 487 if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0) { 488 free(event); 489 return -ENOENT; 490 } 491 492 map = machine->vmlinux_maps[MAP__FUNCTION]; 493 size = snprintf(event->mmap.filename, sizeof(event->mmap.filename), 494 "%s%s", mmap_name, symbol_name) + 1; 495 size = PERF_ALIGN(size, sizeof(u64)); 496 event->mmap.header.type = PERF_RECORD_MMAP; 497 event->mmap.header.size = (sizeof(event->mmap) - 498 (sizeof(event->mmap.filename) - size) + machine->id_hdr_size); 499 event->mmap.pgoff = args.start; 500 event->mmap.start = map->start; 501 event->mmap.len = map->end - event->mmap.start; 502 event->mmap.pid = machine->pid; 503 504 err = process(tool, event, &synth_sample, machine); 505 free(event); 506 507 return err; 508 } 509 510 size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp) 511 { 512 return fprintf(fp, ": %s:%d\n", event->comm.comm, event->comm.tid); 513 } 514 515 int perf_event__process_comm(struct perf_tool *tool __maybe_unused, 516 union perf_event *event, 517 struct perf_sample *sample __maybe_unused, 518 struct machine *machine) 519 { 520 return machine__process_comm_event(machine, event); 521 } 522 523 int perf_event__process_lost(struct perf_tool *tool __maybe_unused, 524 union perf_event *event, 525 struct perf_sample *sample __maybe_unused, 526 struct machine *machine) 527 { 528 return machine__process_lost_event(machine, event); 529 } 530 531 size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp) 532 { 533 return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 "]: %s\n", 534 event->mmap.pid, event->mmap.tid, event->mmap.start, 535 event->mmap.len, event->mmap.pgoff, event->mmap.filename); 536 } 537 538 size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp) 539 { 540 return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64 541 " %02x:%02x %"PRIu64" %"PRIu64"]: %s\n", 542 event->mmap2.pid, event->mmap2.tid, event->mmap2.start, 543 event->mmap2.len, event->mmap2.pgoff, event->mmap2.maj, 544 event->mmap2.min, event->mmap2.ino, 545 event->mmap2.ino_generation, 546 event->mmap2.filename); 547 } 548 549 int perf_event__process_mmap(struct perf_tool *tool __maybe_unused, 550 union perf_event *event, 551 struct perf_sample *sample __maybe_unused, 552 struct machine *machine) 553 { 554 return machine__process_mmap_event(machine, event); 555 } 556 557 int perf_event__process_mmap2(struct perf_tool *tool __maybe_unused, 558 union perf_event *event, 559 struct perf_sample *sample __maybe_unused, 560 struct machine *machine) 561 { 562 return machine__process_mmap2_event(machine, event); 563 } 564 565 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp) 566 { 567 return fprintf(fp, "(%d:%d):(%d:%d)\n", 568 event->fork.pid, event->fork.tid, 569 event->fork.ppid, event->fork.ptid); 570 } 571 572 int perf_event__process_fork(struct perf_tool *tool __maybe_unused, 573 union perf_event *event, 574 struct perf_sample *sample __maybe_unused, 575 struct machine *machine) 576 { 577 return machine__process_fork_event(machine, event); 578 } 579 580 int perf_event__process_exit(struct perf_tool *tool __maybe_unused, 581 union perf_event *event, 582 struct perf_sample *sample __maybe_unused, 583 struct machine *machine) 584 { 585 return machine__process_exit_event(machine, event); 586 } 587 588 size_t perf_event__fprintf(union perf_event *event, FILE *fp) 589 { 590 size_t ret = fprintf(fp, "PERF_RECORD_%s", 591 perf_event__name(event->header.type)); 592 593 switch (event->header.type) { 594 case PERF_RECORD_COMM: 595 ret += perf_event__fprintf_comm(event, fp); 596 break; 597 case PERF_RECORD_FORK: 598 case PERF_RECORD_EXIT: 599 ret += perf_event__fprintf_task(event, fp); 600 break; 601 case PERF_RECORD_MMAP: 602 ret += perf_event__fprintf_mmap(event, fp); 603 break; 604 case PERF_RECORD_MMAP2: 605 ret += perf_event__fprintf_mmap2(event, fp); 606 break; 607 default: 608 ret += fprintf(fp, "\n"); 609 } 610 611 return ret; 612 } 613 614 int perf_event__process(struct perf_tool *tool __maybe_unused, 615 union perf_event *event, 616 struct perf_sample *sample __maybe_unused, 617 struct machine *machine) 618 { 619 return machine__process_event(machine, event); 620 } 621 622 void thread__find_addr_map(struct thread *self, 623 struct machine *machine, u8 cpumode, 624 enum map_type type, u64 addr, 625 struct addr_location *al) 626 { 627 struct map_groups *mg = &self->mg; 628 bool load_map = false; 629 630 al->thread = self; 631 al->addr = addr; 632 al->cpumode = cpumode; 633 al->filtered = false; 634 635 if (machine == NULL) { 636 al->map = NULL; 637 return; 638 } 639 640 if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) { 641 al->level = 'k'; 642 mg = &machine->kmaps; 643 load_map = true; 644 } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) { 645 al->level = '.'; 646 } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) { 647 al->level = 'g'; 648 mg = &machine->kmaps; 649 load_map = true; 650 } else { 651 /* 652 * 'u' means guest os user space. 653 * TODO: We don't support guest user space. Might support late. 654 */ 655 if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest) 656 al->level = 'u'; 657 else 658 al->level = 'H'; 659 al->map = NULL; 660 661 if ((cpumode == PERF_RECORD_MISC_GUEST_USER || 662 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) && 663 !perf_guest) 664 al->filtered = true; 665 if ((cpumode == PERF_RECORD_MISC_USER || 666 cpumode == PERF_RECORD_MISC_KERNEL) && 667 !perf_host) 668 al->filtered = true; 669 670 return; 671 } 672 try_again: 673 al->map = map_groups__find(mg, type, al->addr); 674 if (al->map == NULL) { 675 /* 676 * If this is outside of all known maps, and is a negative 677 * address, try to look it up in the kernel dso, as it might be 678 * a vsyscall or vdso (which executes in user-mode). 679 * 680 * XXX This is nasty, we should have a symbol list in the 681 * "[vdso]" dso, but for now lets use the old trick of looking 682 * in the whole kernel symbol list. 683 */ 684 if ((long long)al->addr < 0 && 685 cpumode == PERF_RECORD_MISC_USER && 686 machine && mg != &machine->kmaps) { 687 mg = &machine->kmaps; 688 goto try_again; 689 } 690 } else { 691 /* 692 * Kernel maps might be changed when loading symbols so loading 693 * must be done prior to using kernel maps. 694 */ 695 if (load_map) 696 map__load(al->map, machine->symbol_filter); 697 al->addr = al->map->map_ip(al->map, al->addr); 698 } 699 } 700 701 void thread__find_addr_location(struct thread *thread, struct machine *machine, 702 u8 cpumode, enum map_type type, u64 addr, 703 struct addr_location *al) 704 { 705 thread__find_addr_map(thread, machine, cpumode, type, addr, al); 706 if (al->map != NULL) 707 al->sym = map__find_symbol(al->map, al->addr, 708 machine->symbol_filter); 709 else 710 al->sym = NULL; 711 } 712 713 int perf_event__preprocess_sample(const union perf_event *event, 714 struct machine *machine, 715 struct addr_location *al, 716 struct perf_sample *sample) 717 { 718 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 719 struct thread *thread = machine__findnew_thread(machine, sample->pid, 720 sample->pid); 721 722 if (thread == NULL) 723 return -1; 724 725 if (symbol_conf.comm_list && 726 !strlist__has_entry(symbol_conf.comm_list, thread->comm)) 727 goto out_filtered; 728 729 dump_printf(" ... thread: %s:%d\n", thread->comm, thread->tid); 730 /* 731 * Have we already created the kernel maps for this machine? 732 * 733 * This should have happened earlier, when we processed the kernel MMAP 734 * events, but for older perf.data files there was no such thing, so do 735 * it now. 736 */ 737 if (cpumode == PERF_RECORD_MISC_KERNEL && 738 machine->vmlinux_maps[MAP__FUNCTION] == NULL) 739 machine__create_kernel_maps(machine); 740 741 thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION, 742 sample->ip, al); 743 dump_printf(" ...... dso: %s\n", 744 al->map ? al->map->dso->long_name : 745 al->level == 'H' ? "[hypervisor]" : "<not found>"); 746 al->sym = NULL; 747 al->cpu = sample->cpu; 748 749 if (al->map) { 750 struct dso *dso = al->map->dso; 751 752 if (symbol_conf.dso_list && 753 (!dso || !(strlist__has_entry(symbol_conf.dso_list, 754 dso->short_name) || 755 (dso->short_name != dso->long_name && 756 strlist__has_entry(symbol_conf.dso_list, 757 dso->long_name))))) 758 goto out_filtered; 759 760 al->sym = map__find_symbol(al->map, al->addr, 761 machine->symbol_filter); 762 } 763 764 if (symbol_conf.sym_list && 765 (!al->sym || !strlist__has_entry(symbol_conf.sym_list, 766 al->sym->name))) 767 goto out_filtered; 768 769 return 0; 770 771 out_filtered: 772 al->filtered = true; 773 return 0; 774 } 775
