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