1 #include "callchain.h" 2 #include "debug.h" 3 #include "event.h" 4 #include "evsel.h" 5 #include "hist.h" 6 #include "machine.h" 7 #include "map.h" 8 #include "sort.h" 9 #include "strlist.h" 10 #include "thread.h" 11 #include <stdbool.h> 12 #include "unwind.h" 13 14 int machine__init(struct machine *machine, const char *root_dir, pid_t pid) 15 { 16 map_groups__init(&machine->kmaps); 17 RB_CLEAR_NODE(&machine->rb_node); 18 INIT_LIST_HEAD(&machine->user_dsos); 19 INIT_LIST_HEAD(&machine->kernel_dsos); 20 21 machine->threads = RB_ROOT; 22 INIT_LIST_HEAD(&machine->dead_threads); 23 machine->last_match = NULL; 24 25 machine->kmaps.machine = machine; 26 machine->pid = pid; 27 28 machine->symbol_filter = NULL; 29 30 machine->root_dir = strdup(root_dir); 31 if (machine->root_dir == NULL) 32 return -ENOMEM; 33 34 if (pid != HOST_KERNEL_ID) { 35 struct thread *thread = machine__findnew_thread(machine, 0, 36 pid); 37 char comm[64]; 38 39 if (thread == NULL) 40 return -ENOMEM; 41 42 snprintf(comm, sizeof(comm), "[guest/%d]", pid); 43 thread__set_comm(thread, comm, 0); 44 } 45 46 return 0; 47 } 48 49 struct machine *machine__new_host(void) 50 { 51 struct machine *machine = malloc(sizeof(*machine)); 52 53 if (machine != NULL) { 54 machine__init(machine, "", HOST_KERNEL_ID); 55 56 if (machine__create_kernel_maps(machine) < 0) 57 goto out_delete; 58 } 59 60 return machine; 61 out_delete: 62 free(machine); 63 return NULL; 64 } 65 66 static void dsos__delete(struct list_head *dsos) 67 { 68 struct dso *pos, *n; 69 70 list_for_each_entry_safe(pos, n, dsos, node) { 71 list_del(&pos->node); 72 dso__delete(pos); 73 } 74 } 75 76 void machine__delete_dead_threads(struct machine *machine) 77 { 78 struct thread *n, *t; 79 80 list_for_each_entry_safe(t, n, &machine->dead_threads, node) { 81 list_del(&t->node); 82 thread__delete(t); 83 } 84 } 85 86 void machine__delete_threads(struct machine *machine) 87 { 88 struct rb_node *nd = rb_first(&machine->threads); 89 90 while (nd) { 91 struct thread *t = rb_entry(nd, struct thread, rb_node); 92 93 rb_erase(&t->rb_node, &machine->threads); 94 nd = rb_next(nd); 95 thread__delete(t); 96 } 97 } 98 99 void machine__exit(struct machine *machine) 100 { 101 map_groups__exit(&machine->kmaps); 102 dsos__delete(&machine->user_dsos); 103 dsos__delete(&machine->kernel_dsos); 104 free(machine->root_dir); 105 machine->root_dir = NULL; 106 } 107 108 void machine__delete(struct machine *machine) 109 { 110 machine__exit(machine); 111 free(machine); 112 } 113 114 void machines__init(struct machines *machines) 115 { 116 machine__init(&machines->host, "", HOST_KERNEL_ID); 117 machines->guests = RB_ROOT; 118 machines->symbol_filter = NULL; 119 } 120 121 void machines__exit(struct machines *machines) 122 { 123 machine__exit(&machines->host); 124 /* XXX exit guest */ 125 } 126 127 struct machine *machines__add(struct machines *machines, pid_t pid, 128 const char *root_dir) 129 { 130 struct rb_node **p = &machines->guests.rb_node; 131 struct rb_node *parent = NULL; 132 struct machine *pos, *machine = malloc(sizeof(*machine)); 133 134 if (machine == NULL) 135 return NULL; 136 137 if (machine__init(machine, root_dir, pid) != 0) { 138 free(machine); 139 return NULL; 140 } 141 142 machine->symbol_filter = machines->symbol_filter; 143 144 while (*p != NULL) { 145 parent = *p; 146 pos = rb_entry(parent, struct machine, rb_node); 147 if (pid < pos->pid) 148 p = &(*p)->rb_left; 149 else 150 p = &(*p)->rb_right; 151 } 152 153 rb_link_node(&machine->rb_node, parent, p); 154 rb_insert_color(&machine->rb_node, &machines->guests); 155 156 return machine; 157 } 158 159 void machines__set_symbol_filter(struct machines *machines, 160 symbol_filter_t symbol_filter) 161 { 162 struct rb_node *nd; 163 164 machines->symbol_filter = symbol_filter; 165 machines->host.symbol_filter = symbol_filter; 166 167 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 168 struct machine *machine = rb_entry(nd, struct machine, rb_node); 169 170 machine->symbol_filter = symbol_filter; 171 } 172 } 173 174 struct machine *machines__find(struct machines *machines, pid_t pid) 175 { 176 struct rb_node **p = &machines->guests.rb_node; 177 struct rb_node *parent = NULL; 178 struct machine *machine; 179 struct machine *default_machine = NULL; 180 181 if (pid == HOST_KERNEL_ID) 182 return &machines->host; 183 184 while (*p != NULL) { 185 parent = *p; 186 machine = rb_entry(parent, struct machine, rb_node); 187 if (pid < machine->pid) 188 p = &(*p)->rb_left; 189 else if (pid > machine->pid) 190 p = &(*p)->rb_right; 191 else 192 return machine; 193 if (!machine->pid) 194 default_machine = machine; 195 } 196 197 return default_machine; 198 } 199 200 struct machine *machines__findnew(struct machines *machines, pid_t pid) 201 { 202 char path[PATH_MAX]; 203 const char *root_dir = ""; 204 struct machine *machine = machines__find(machines, pid); 205 206 if (machine && (machine->pid == pid)) 207 goto out; 208 209 if ((pid != HOST_KERNEL_ID) && 210 (pid != DEFAULT_GUEST_KERNEL_ID) && 211 (symbol_conf.guestmount)) { 212 sprintf(path, "%s/%d", symbol_conf.guestmount, pid); 213 if (access(path, R_OK)) { 214 static struct strlist *seen; 215 216 if (!seen) 217 seen = strlist__new(true, NULL); 218 219 if (!strlist__has_entry(seen, path)) { 220 pr_err("Can't access file %s\n", path); 221 strlist__add(seen, path); 222 } 223 machine = NULL; 224 goto out; 225 } 226 root_dir = path; 227 } 228 229 machine = machines__add(machines, pid, root_dir); 230 out: 231 return machine; 232 } 233 234 void machines__process_guests(struct machines *machines, 235 machine__process_t process, void *data) 236 { 237 struct rb_node *nd; 238 239 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 240 struct machine *pos = rb_entry(nd, struct machine, rb_node); 241 process(pos, data); 242 } 243 } 244 245 char *machine__mmap_name(struct machine *machine, char *bf, size_t size) 246 { 247 if (machine__is_host(machine)) 248 snprintf(bf, size, "[%s]", "kernel.kallsyms"); 249 else if (machine__is_default_guest(machine)) 250 snprintf(bf, size, "[%s]", "guest.kernel.kallsyms"); 251 else { 252 snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms", 253 machine->pid); 254 } 255 256 return bf; 257 } 258 259 void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size) 260 { 261 struct rb_node *node; 262 struct machine *machine; 263 264 machines->host.id_hdr_size = id_hdr_size; 265 266 for (node = rb_first(&machines->guests); node; node = rb_next(node)) { 267 machine = rb_entry(node, struct machine, rb_node); 268 machine->id_hdr_size = id_hdr_size; 269 } 270 271 return; 272 } 273 274 static struct thread *__machine__findnew_thread(struct machine *machine, 275 pid_t pid, pid_t tid, 276 bool create) 277 { 278 struct rb_node **p = &machine->threads.rb_node; 279 struct rb_node *parent = NULL; 280 struct thread *th; 281 282 /* 283 * Front-end cache - TID lookups come in blocks, 284 * so most of the time we dont have to look up 285 * the full rbtree: 286 */ 287 if (machine->last_match && machine->last_match->tid == tid) { 288 if (pid && pid != machine->last_match->pid_) 289 machine->last_match->pid_ = pid; 290 return machine->last_match; 291 } 292 293 while (*p != NULL) { 294 parent = *p; 295 th = rb_entry(parent, struct thread, rb_node); 296 297 if (th->tid == tid) { 298 machine->last_match = th; 299 if (pid && pid != th->pid_) 300 th->pid_ = pid; 301 return th; 302 } 303 304 if (tid < th->tid) 305 p = &(*p)->rb_left; 306 else 307 p = &(*p)->rb_right; 308 } 309 310 if (!create) 311 return NULL; 312 313 th = thread__new(pid, tid); 314 if (th != NULL) { 315 rb_link_node(&th->rb_node, parent, p); 316 rb_insert_color(&th->rb_node, &machine->threads); 317 machine->last_match = th; 318 } 319 320 return th; 321 } 322 323 struct thread *machine__findnew_thread(struct machine *machine, pid_t pid, 324 pid_t tid) 325 { 326 return __machine__findnew_thread(machine, pid, tid, true); 327 } 328 329 struct thread *machine__find_thread(struct machine *machine, pid_t tid) 330 { 331 return __machine__findnew_thread(machine, 0, tid, false); 332 } 333 334 int machine__process_comm_event(struct machine *machine, union perf_event *event, 335 struct perf_sample *sample) 336 { 337 struct thread *thread = machine__findnew_thread(machine, 338 event->comm.pid, 339 event->comm.tid); 340 341 if (dump_trace) 342 perf_event__fprintf_comm(event, stdout); 343 344 if (thread == NULL || thread__set_comm(thread, event->comm.comm, sample->time)) { 345 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n"); 346 return -1; 347 } 348 349 return 0; 350 } 351 352 int machine__process_lost_event(struct machine *machine __maybe_unused, 353 union perf_event *event, struct perf_sample *sample __maybe_unused) 354 { 355 dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n", 356 event->lost.id, event->lost.lost); 357 return 0; 358 } 359 360 struct map *machine__new_module(struct machine *machine, u64 start, 361 const char *filename) 362 { 363 struct map *map; 364 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename); 365 366 if (dso == NULL) 367 return NULL; 368 369 map = map__new2(start, dso, MAP__FUNCTION); 370 if (map == NULL) 371 return NULL; 372 373 if (machine__is_host(machine)) 374 dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE; 375 else 376 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE; 377 map_groups__insert(&machine->kmaps, map); 378 return map; 379 } 380 381 size_t machines__fprintf_dsos(struct machines *machines, FILE *fp) 382 { 383 struct rb_node *nd; 384 size_t ret = __dsos__fprintf(&machines->host.kernel_dsos, fp) + 385 __dsos__fprintf(&machines->host.user_dsos, fp); 386 387 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 388 struct machine *pos = rb_entry(nd, struct machine, rb_node); 389 ret += __dsos__fprintf(&pos->kernel_dsos, fp); 390 ret += __dsos__fprintf(&pos->user_dsos, fp); 391 } 392 393 return ret; 394 } 395 396 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp, 397 bool (skip)(struct dso *dso, int parm), int parm) 398 { 399 return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, skip, parm) + 400 __dsos__fprintf_buildid(&machine->user_dsos, fp, skip, parm); 401 } 402 403 size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp, 404 bool (skip)(struct dso *dso, int parm), int parm) 405 { 406 struct rb_node *nd; 407 size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm); 408 409 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) { 410 struct machine *pos = rb_entry(nd, struct machine, rb_node); 411 ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm); 412 } 413 return ret; 414 } 415 416 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp) 417 { 418 int i; 419 size_t printed = 0; 420 struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso; 421 422 if (kdso->has_build_id) { 423 char filename[PATH_MAX]; 424 if (dso__build_id_filename(kdso, filename, sizeof(filename))) 425 printed += fprintf(fp, "[0] %s\n", filename); 426 } 427 428 for (i = 0; i < vmlinux_path__nr_entries; ++i) 429 printed += fprintf(fp, "[%d] %s\n", 430 i + kdso->has_build_id, vmlinux_path[i]); 431 432 return printed; 433 } 434 435 size_t machine__fprintf(struct machine *machine, FILE *fp) 436 { 437 size_t ret = 0; 438 struct rb_node *nd; 439 440 for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) { 441 struct thread *pos = rb_entry(nd, struct thread, rb_node); 442 443 ret += thread__fprintf(pos, fp); 444 } 445 446 return ret; 447 } 448 449 static struct dso *machine__get_kernel(struct machine *machine) 450 { 451 const char *vmlinux_name = NULL; 452 struct dso *kernel; 453 454 if (machine__is_host(machine)) { 455 vmlinux_name = symbol_conf.vmlinux_name; 456 if (!vmlinux_name) 457 vmlinux_name = "[kernel.kallsyms]"; 458 459 kernel = dso__kernel_findnew(machine, vmlinux_name, 460 "[kernel]", 461 DSO_TYPE_KERNEL); 462 } else { 463 char bf[PATH_MAX]; 464 465 if (machine__is_default_guest(machine)) 466 vmlinux_name = symbol_conf.default_guest_vmlinux_name; 467 if (!vmlinux_name) 468 vmlinux_name = machine__mmap_name(machine, bf, 469 sizeof(bf)); 470 471 kernel = dso__kernel_findnew(machine, vmlinux_name, 472 "[guest.kernel]", 473 DSO_TYPE_GUEST_KERNEL); 474 } 475 476 if (kernel != NULL && (!kernel->has_build_id)) 477 dso__read_running_kernel_build_id(kernel, machine); 478 479 return kernel; 480 } 481 482 struct process_args { 483 u64 start; 484 }; 485 486 static int symbol__in_kernel(void *arg, const char *name, 487 char type __maybe_unused, u64 start) 488 { 489 struct process_args *args = arg; 490 491 if (strchr(name, '[')) 492 return 0; 493 494 args->start = start; 495 return 1; 496 } 497 498 /* Figure out the start address of kernel map from /proc/kallsyms */ 499 static u64 machine__get_kernel_start_addr(struct machine *machine) 500 { 501 const char *filename; 502 char path[PATH_MAX]; 503 struct process_args args; 504 505 if (machine__is_host(machine)) { 506 filename = "/proc/kallsyms"; 507 } else { 508 if (machine__is_default_guest(machine)) 509 filename = (char *)symbol_conf.default_guest_kallsyms; 510 else { 511 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 512 filename = path; 513 } 514 } 515 516 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 517 return 0; 518 519 if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0) 520 return 0; 521 522 return args.start; 523 } 524 525 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel) 526 { 527 enum map_type type; 528 u64 start = machine__get_kernel_start_addr(machine); 529 530 for (type = 0; type < MAP__NR_TYPES; ++type) { 531 struct kmap *kmap; 532 533 machine->vmlinux_maps[type] = map__new2(start, kernel, type); 534 if (machine->vmlinux_maps[type] == NULL) 535 return -1; 536 537 machine->vmlinux_maps[type]->map_ip = 538 machine->vmlinux_maps[type]->unmap_ip = 539 identity__map_ip; 540 kmap = map__kmap(machine->vmlinux_maps[type]); 541 kmap->kmaps = &machine->kmaps; 542 map_groups__insert(&machine->kmaps, 543 machine->vmlinux_maps[type]); 544 } 545 546 return 0; 547 } 548 549 void machine__destroy_kernel_maps(struct machine *machine) 550 { 551 enum map_type type; 552 553 for (type = 0; type < MAP__NR_TYPES; ++type) { 554 struct kmap *kmap; 555 556 if (machine->vmlinux_maps[type] == NULL) 557 continue; 558 559 kmap = map__kmap(machine->vmlinux_maps[type]); 560 map_groups__remove(&machine->kmaps, 561 machine->vmlinux_maps[type]); 562 if (kmap->ref_reloc_sym) { 563 /* 564 * ref_reloc_sym is shared among all maps, so free just 565 * on one of them. 566 */ 567 if (type == MAP__FUNCTION) { 568 free((char *)kmap->ref_reloc_sym->name); 569 kmap->ref_reloc_sym->name = NULL; 570 free(kmap->ref_reloc_sym); 571 } 572 kmap->ref_reloc_sym = NULL; 573 } 574 575 map__delete(machine->vmlinux_maps[type]); 576 machine->vmlinux_maps[type] = NULL; 577 } 578 } 579 580 int machines__create_guest_kernel_maps(struct machines *machines) 581 { 582 int ret = 0; 583 struct dirent **namelist = NULL; 584 int i, items = 0; 585 char path[PATH_MAX]; 586 pid_t pid; 587 char *endp; 588 589 if (symbol_conf.default_guest_vmlinux_name || 590 symbol_conf.default_guest_modules || 591 symbol_conf.default_guest_kallsyms) { 592 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID); 593 } 594 595 if (symbol_conf.guestmount) { 596 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL); 597 if (items <= 0) 598 return -ENOENT; 599 for (i = 0; i < items; i++) { 600 if (!isdigit(namelist[i]->d_name[0])) { 601 /* Filter out . and .. */ 602 continue; 603 } 604 pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10); 605 if ((*endp != '\0') || 606 (endp == namelist[i]->d_name) || 607 (errno == ERANGE)) { 608 pr_debug("invalid directory (%s). Skipping.\n", 609 namelist[i]->d_name); 610 continue; 611 } 612 sprintf(path, "%s/%s/proc/kallsyms", 613 symbol_conf.guestmount, 614 namelist[i]->d_name); 615 ret = access(path, R_OK); 616 if (ret) { 617 pr_debug("Can't access file %s\n", path); 618 goto failure; 619 } 620 machines__create_kernel_maps(machines, pid); 621 } 622 failure: 623 free(namelist); 624 } 625 626 return ret; 627 } 628 629 void machines__destroy_kernel_maps(struct machines *machines) 630 { 631 struct rb_node *next = rb_first(&machines->guests); 632 633 machine__destroy_kernel_maps(&machines->host); 634 635 while (next) { 636 struct machine *pos = rb_entry(next, struct machine, rb_node); 637 638 next = rb_next(&pos->rb_node); 639 rb_erase(&pos->rb_node, &machines->guests); 640 machine__delete(pos); 641 } 642 } 643 644 int machines__create_kernel_maps(struct machines *machines, pid_t pid) 645 { 646 struct machine *machine = machines__findnew(machines, pid); 647 648 if (machine == NULL) 649 return -1; 650 651 return machine__create_kernel_maps(machine); 652 } 653 654 int machine__load_kallsyms(struct machine *machine, const char *filename, 655 enum map_type type, symbol_filter_t filter) 656 { 657 struct map *map = machine->vmlinux_maps[type]; 658 int ret = dso__load_kallsyms(map->dso, filename, map, filter); 659 660 if (ret > 0) { 661 dso__set_loaded(map->dso, type); 662 /* 663 * Since /proc/kallsyms will have multiple sessions for the 664 * kernel, with modules between them, fixup the end of all 665 * sections. 666 */ 667 __map_groups__fixup_end(&machine->kmaps, type); 668 } 669 670 return ret; 671 } 672 673 int machine__load_vmlinux_path(struct machine *machine, enum map_type type, 674 symbol_filter_t filter) 675 { 676 struct map *map = machine->vmlinux_maps[type]; 677 int ret = dso__load_vmlinux_path(map->dso, map, filter); 678 679 if (ret > 0) 680 dso__set_loaded(map->dso, type); 681 682 return ret; 683 } 684 685 static void map_groups__fixup_end(struct map_groups *mg) 686 { 687 int i; 688 for (i = 0; i < MAP__NR_TYPES; ++i) 689 __map_groups__fixup_end(mg, i); 690 } 691 692 static char *get_kernel_version(const char *root_dir) 693 { 694 char version[PATH_MAX]; 695 FILE *file; 696 char *name, *tmp; 697 const char *prefix = "Linux version "; 698 699 sprintf(version, "%s/proc/version", root_dir); 700 file = fopen(version, "r"); 701 if (!file) 702 return NULL; 703 704 version[0] = '\0'; 705 tmp = fgets(version, sizeof(version), file); 706 fclose(file); 707 708 name = strstr(version, prefix); 709 if (!name) 710 return NULL; 711 name += strlen(prefix); 712 tmp = strchr(name, ' '); 713 if (tmp) 714 *tmp = '\0'; 715 716 return strdup(name); 717 } 718 719 static int map_groups__set_modules_path_dir(struct map_groups *mg, 720 const char *dir_name) 721 { 722 struct dirent *dent; 723 DIR *dir = opendir(dir_name); 724 int ret = 0; 725 726 if (!dir) { 727 pr_debug("%s: cannot open %s dir\n", __func__, dir_name); 728 return -1; 729 } 730 731 while ((dent = readdir(dir)) != NULL) { 732 char path[PATH_MAX]; 733 struct stat st; 734 735 /*sshfs might return bad dent->d_type, so we have to stat*/ 736 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name); 737 if (stat(path, &st)) 738 continue; 739 740 if (S_ISDIR(st.st_mode)) { 741 if (!strcmp(dent->d_name, ".") || 742 !strcmp(dent->d_name, "..")) 743 continue; 744 745 ret = map_groups__set_modules_path_dir(mg, path); 746 if (ret < 0) 747 goto out; 748 } else { 749 char *dot = strrchr(dent->d_name, '.'), 750 dso_name[PATH_MAX]; 751 struct map *map; 752 char *long_name; 753 754 if (dot == NULL || strcmp(dot, ".ko")) 755 continue; 756 snprintf(dso_name, sizeof(dso_name), "[%.*s]", 757 (int)(dot - dent->d_name), dent->d_name); 758 759 strxfrchar(dso_name, '-', '_'); 760 map = map_groups__find_by_name(mg, MAP__FUNCTION, 761 dso_name); 762 if (map == NULL) 763 continue; 764 765 long_name = strdup(path); 766 if (long_name == NULL) { 767 ret = -1; 768 goto out; 769 } 770 dso__set_long_name(map->dso, long_name); 771 map->dso->lname_alloc = 1; 772 dso__kernel_module_get_build_id(map->dso, ""); 773 } 774 } 775 776 out: 777 closedir(dir); 778 return ret; 779 } 780 781 static int machine__set_modules_path(struct machine *machine) 782 { 783 char *version; 784 char modules_path[PATH_MAX]; 785 786 version = get_kernel_version(machine->root_dir); 787 if (!version) 788 return -1; 789 790 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel", 791 machine->root_dir, version); 792 free(version); 793 794 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path); 795 } 796 797 static int machine__create_module(void *arg, const char *name, u64 start) 798 { 799 struct machine *machine = arg; 800 struct map *map; 801 802 map = machine__new_module(machine, start, name); 803 if (map == NULL) 804 return -1; 805 806 dso__kernel_module_get_build_id(map->dso, machine->root_dir); 807 808 return 0; 809 } 810 811 static int machine__create_modules(struct machine *machine) 812 { 813 const char *modules; 814 char path[PATH_MAX]; 815 816 if (machine__is_default_guest(machine)) { 817 modules = symbol_conf.default_guest_modules; 818 } else { 819 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir); 820 modules = path; 821 } 822 823 if (symbol__restricted_filename(modules, "/proc/modules")) 824 return -1; 825 826 if (modules__parse(modules, machine, machine__create_module)) 827 return -1; 828 829 if (!machine__set_modules_path(machine)) 830 return 0; 831 832 pr_debug("Problems setting modules path maps, continuing anyway...\n"); 833 834 return 0; 835 } 836 837 int machine__create_kernel_maps(struct machine *machine) 838 { 839 struct dso *kernel = machine__get_kernel(machine); 840 841 if (kernel == NULL || 842 __machine__create_kernel_maps(machine, kernel) < 0) 843 return -1; 844 845 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) { 846 if (machine__is_host(machine)) 847 pr_debug("Problems creating module maps, " 848 "continuing anyway...\n"); 849 else 850 pr_debug("Problems creating module maps for guest %d, " 851 "continuing anyway...\n", machine->pid); 852 } 853 854 /* 855 * Now that we have all the maps created, just set the ->end of them: 856 */ 857 map_groups__fixup_end(&machine->kmaps); 858 return 0; 859 } 860 861 static void machine__set_kernel_mmap_len(struct machine *machine, 862 union perf_event *event) 863 { 864 int i; 865 866 for (i = 0; i < MAP__NR_TYPES; i++) { 867 machine->vmlinux_maps[i]->start = event->mmap.start; 868 machine->vmlinux_maps[i]->end = (event->mmap.start + 869 event->mmap.len); 870 /* 871 * Be a bit paranoid here, some perf.data file came with 872 * a zero sized synthesized MMAP event for the kernel. 873 */ 874 if (machine->vmlinux_maps[i]->end == 0) 875 machine->vmlinux_maps[i]->end = ~0ULL; 876 } 877 } 878 879 static bool machine__uses_kcore(struct machine *machine) 880 { 881 struct dso *dso; 882 883 list_for_each_entry(dso, &machine->kernel_dsos, node) { 884 if (dso__is_kcore(dso)) 885 return true; 886 } 887 888 return false; 889 } 890 891 static int machine__process_kernel_mmap_event(struct machine *machine, 892 union perf_event *event) 893 { 894 struct map *map; 895 char kmmap_prefix[PATH_MAX]; 896 enum dso_kernel_type kernel_type; 897 bool is_kernel_mmap; 898 899 /* If we have maps from kcore then we do not need or want any others */ 900 if (machine__uses_kcore(machine)) 901 return 0; 902 903 machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix)); 904 if (machine__is_host(machine)) 905 kernel_type = DSO_TYPE_KERNEL; 906 else 907 kernel_type = DSO_TYPE_GUEST_KERNEL; 908 909 is_kernel_mmap = memcmp(event->mmap.filename, 910 kmmap_prefix, 911 strlen(kmmap_prefix) - 1) == 0; 912 if (event->mmap.filename[0] == '/' || 913 (!is_kernel_mmap && event->mmap.filename[0] == '[')) { 914 915 char short_module_name[1024]; 916 char *name, *dot; 917 918 if (event->mmap.filename[0] == '/') { 919 name = strrchr(event->mmap.filename, '/'); 920 if (name == NULL) 921 goto out_problem; 922 923 ++name; /* skip / */ 924 dot = strrchr(name, '.'); 925 if (dot == NULL) 926 goto out_problem; 927 snprintf(short_module_name, sizeof(short_module_name), 928 "[%.*s]", (int)(dot - name), name); 929 strxfrchar(short_module_name, '-', '_'); 930 } else 931 strcpy(short_module_name, event->mmap.filename); 932 933 map = machine__new_module(machine, event->mmap.start, 934 event->mmap.filename); 935 if (map == NULL) 936 goto out_problem; 937 938 name = strdup(short_module_name); 939 if (name == NULL) 940 goto out_problem; 941 942 map->dso->short_name = name; 943 map->dso->sname_alloc = 1; 944 map->end = map->start + event->mmap.len; 945 } else if (is_kernel_mmap) { 946 const char *symbol_name = (event->mmap.filename + 947 strlen(kmmap_prefix)); 948 /* 949 * Should be there already, from the build-id table in 950 * the header. 951 */ 952 struct dso *kernel = __dsos__findnew(&machine->kernel_dsos, 953 kmmap_prefix); 954 if (kernel == NULL) 955 goto out_problem; 956 957 kernel->kernel = kernel_type; 958 if (__machine__create_kernel_maps(machine, kernel) < 0) 959 goto out_problem; 960 961 machine__set_kernel_mmap_len(machine, event); 962 963 /* 964 * Avoid using a zero address (kptr_restrict) for the ref reloc 965 * symbol. Effectively having zero here means that at record 966 * time /proc/sys/kernel/kptr_restrict was non zero. 967 */ 968 if (event->mmap.pgoff != 0) { 969 maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, 970 symbol_name, 971 event->mmap.pgoff); 972 } 973 974 if (machine__is_default_guest(machine)) { 975 /* 976 * preload dso of guest kernel and modules 977 */ 978 dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION], 979 NULL); 980 } 981 } 982 return 0; 983 out_problem: 984 return -1; 985 } 986 987 int machine__process_mmap2_event(struct machine *machine, 988 union perf_event *event, 989 struct perf_sample *sample __maybe_unused) 990 { 991 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 992 struct thread *thread; 993 struct map *map; 994 enum map_type type; 995 int ret = 0; 996 997 if (dump_trace) 998 perf_event__fprintf_mmap2(event, stdout); 999 1000 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL || 1001 cpumode == PERF_RECORD_MISC_KERNEL) { 1002 ret = machine__process_kernel_mmap_event(machine, event); 1003 if (ret < 0) 1004 goto out_problem; 1005 return 0; 1006 } 1007 1008 thread = machine__findnew_thread(machine, event->mmap2.pid, 1009 event->mmap2.pid); 1010 if (thread == NULL) 1011 goto out_problem; 1012 1013 if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) 1014 type = MAP__VARIABLE; 1015 else 1016 type = MAP__FUNCTION; 1017 1018 map = map__new(&machine->user_dsos, event->mmap2.start, 1019 event->mmap2.len, event->mmap2.pgoff, 1020 event->mmap2.pid, event->mmap2.maj, 1021 event->mmap2.min, event->mmap2.ino, 1022 event->mmap2.ino_generation, 1023 event->mmap2.filename, type); 1024 1025 if (map == NULL) 1026 goto out_problem; 1027 1028 thread__insert_map(thread, map); 1029 return 0; 1030 1031 out_problem: 1032 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n"); 1033 return 0; 1034 } 1035 1036 int machine__process_mmap_event(struct machine *machine, union perf_event *event, 1037 struct perf_sample *sample __maybe_unused) 1038 { 1039 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 1040 struct thread *thread; 1041 struct map *map; 1042 enum map_type type; 1043 int ret = 0; 1044 1045 if (dump_trace) 1046 perf_event__fprintf_mmap(event, stdout); 1047 1048 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL || 1049 cpumode == PERF_RECORD_MISC_KERNEL) { 1050 ret = machine__process_kernel_mmap_event(machine, event); 1051 if (ret < 0) 1052 goto out_problem; 1053 return 0; 1054 } 1055 1056 thread = machine__findnew_thread(machine, event->mmap.pid, 1057 event->mmap.pid); 1058 if (thread == NULL) 1059 goto out_problem; 1060 1061 if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA) 1062 type = MAP__VARIABLE; 1063 else 1064 type = MAP__FUNCTION; 1065 1066 map = map__new(&machine->user_dsos, event->mmap.start, 1067 event->mmap.len, event->mmap.pgoff, 1068 event->mmap.pid, 0, 0, 0, 0, 1069 event->mmap.filename, 1070 type); 1071 1072 if (map == NULL) 1073 goto out_problem; 1074 1075 thread__insert_map(thread, map); 1076 return 0; 1077 1078 out_problem: 1079 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n"); 1080 return 0; 1081 } 1082 1083 static void machine__remove_thread(struct machine *machine, struct thread *th) 1084 { 1085 machine->last_match = NULL; 1086 rb_erase(&th->rb_node, &machine->threads); 1087 /* 1088 * We may have references to this thread, for instance in some hist_entry 1089 * instances, so just move them to a separate list. 1090 */ 1091 list_add_tail(&th->node, &machine->dead_threads); 1092 } 1093 1094 int machine__process_fork_event(struct machine *machine, union perf_event *event, 1095 struct perf_sample *sample) 1096 { 1097 struct thread *thread = machine__find_thread(machine, event->fork.tid); 1098 struct thread *parent = machine__findnew_thread(machine, 1099 event->fork.ppid, 1100 event->fork.ptid); 1101 1102 /* if a thread currently exists for the thread id remove it */ 1103 if (thread != NULL) 1104 machine__remove_thread(machine, thread); 1105 1106 thread = machine__findnew_thread(machine, event->fork.pid, 1107 event->fork.tid); 1108 if (dump_trace) 1109 perf_event__fprintf_task(event, stdout); 1110 1111 if (thread == NULL || parent == NULL || 1112 thread__fork(thread, parent, sample->time) < 0) { 1113 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n"); 1114 return -1; 1115 } 1116 1117 return 0; 1118 } 1119 1120 int machine__process_exit_event(struct machine *machine, union perf_event *event, 1121 struct perf_sample *sample __maybe_unused) 1122 { 1123 struct thread *thread = machine__find_thread(machine, event->fork.tid); 1124 1125 if (dump_trace) 1126 perf_event__fprintf_task(event, stdout); 1127 1128 if (thread != NULL) 1129 thread__exited(thread); 1130 1131 return 0; 1132 } 1133 1134 int machine__process_event(struct machine *machine, union perf_event *event, 1135 struct perf_sample *sample) 1136 { 1137 int ret; 1138 1139 switch (event->header.type) { 1140 case PERF_RECORD_COMM: 1141 ret = machine__process_comm_event(machine, event, sample); break; 1142 case PERF_RECORD_MMAP: 1143 ret = machine__process_mmap_event(machine, event, sample); break; 1144 case PERF_RECORD_MMAP2: 1145 ret = machine__process_mmap2_event(machine, event, sample); break; 1146 case PERF_RECORD_FORK: 1147 ret = machine__process_fork_event(machine, event, sample); break; 1148 case PERF_RECORD_EXIT: 1149 ret = machine__process_exit_event(machine, event, sample); break; 1150 case PERF_RECORD_LOST: 1151 ret = machine__process_lost_event(machine, event, sample); break; 1152 default: 1153 ret = -1; 1154 break; 1155 } 1156 1157 return ret; 1158 } 1159 1160 static bool symbol__match_regex(struct symbol *sym, regex_t *regex) 1161 { 1162 if (sym->name && !regexec(regex, sym->name, 0, NULL, 0)) 1163 return 1; 1164 return 0; 1165 } 1166 1167 static const u8 cpumodes[] = { 1168 PERF_RECORD_MISC_USER, 1169 PERF_RECORD_MISC_KERNEL, 1170 PERF_RECORD_MISC_GUEST_USER, 1171 PERF_RECORD_MISC_GUEST_KERNEL 1172 }; 1173 #define NCPUMODES (sizeof(cpumodes)/sizeof(u8)) 1174 1175 static void ip__resolve_ams(struct machine *machine, struct thread *thread, 1176 struct addr_map_symbol *ams, 1177 u64 ip) 1178 { 1179 struct addr_location al; 1180 size_t i; 1181 u8 m; 1182 1183 memset(&al, 0, sizeof(al)); 1184 1185 for (i = 0; i < NCPUMODES; i++) { 1186 m = cpumodes[i]; 1187 /* 1188 * We cannot use the header.misc hint to determine whether a 1189 * branch stack address is user, kernel, guest, hypervisor. 1190 * Branches may straddle the kernel/user/hypervisor boundaries. 1191 * Thus, we have to try consecutively until we find a match 1192 * or else, the symbol is unknown 1193 */ 1194 thread__find_addr_location(thread, machine, m, MAP__FUNCTION, 1195 ip, &al); 1196 if (al.sym) 1197 goto found; 1198 } 1199 found: 1200 ams->addr = ip; 1201 ams->al_addr = al.addr; 1202 ams->sym = al.sym; 1203 ams->map = al.map; 1204 } 1205 1206 static void ip__resolve_data(struct machine *machine, struct thread *thread, 1207 u8 m, struct addr_map_symbol *ams, u64 addr) 1208 { 1209 struct addr_location al; 1210 1211 memset(&al, 0, sizeof(al)); 1212 1213 thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr, 1214 &al); 1215 ams->addr = addr; 1216 ams->al_addr = al.addr; 1217 ams->sym = al.sym; 1218 ams->map = al.map; 1219 } 1220 1221 struct mem_info *machine__resolve_mem(struct machine *machine, 1222 struct thread *thr, 1223 struct perf_sample *sample, 1224 u8 cpumode) 1225 { 1226 struct mem_info *mi = zalloc(sizeof(*mi)); 1227 1228 if (!mi) 1229 return NULL; 1230 1231 ip__resolve_ams(machine, thr, &mi->iaddr, sample->ip); 1232 ip__resolve_data(machine, thr, cpumode, &mi->daddr, sample->addr); 1233 mi->data_src.val = sample->data_src; 1234 1235 return mi; 1236 } 1237 1238 struct branch_info *machine__resolve_bstack(struct machine *machine, 1239 struct thread *thr, 1240 struct branch_stack *bs) 1241 { 1242 struct branch_info *bi; 1243 unsigned int i; 1244 1245 bi = calloc(bs->nr, sizeof(struct branch_info)); 1246 if (!bi) 1247 return NULL; 1248 1249 for (i = 0; i < bs->nr; i++) { 1250 ip__resolve_ams(machine, thr, &bi[i].to, bs->entries[i].to); 1251 ip__resolve_ams(machine, thr, &bi[i].from, bs->entries[i].from); 1252 bi[i].flags = bs->entries[i].flags; 1253 } 1254 return bi; 1255 } 1256 1257 static int machine__resolve_callchain_sample(struct machine *machine, 1258 struct thread *thread, 1259 struct ip_callchain *chain, 1260 struct symbol **parent, 1261 struct addr_location *root_al, 1262 int max_stack) 1263 { 1264 u8 cpumode = PERF_RECORD_MISC_USER; 1265 int chain_nr = min(max_stack, (int)chain->nr); 1266 int i; 1267 int err; 1268 1269 callchain_cursor_reset(&callchain_cursor); 1270 1271 if (chain->nr > PERF_MAX_STACK_DEPTH) { 1272 pr_warning("corrupted callchain. skipping...\n"); 1273 return 0; 1274 } 1275 1276 for (i = 0; i < chain_nr; i++) { 1277 u64 ip; 1278 struct addr_location al; 1279 1280 if (callchain_param.order == ORDER_CALLEE) 1281 ip = chain->ips[i]; 1282 else 1283 ip = chain->ips[chain->nr - i - 1]; 1284 1285 if (ip >= PERF_CONTEXT_MAX) { 1286 switch (ip) { 1287 case PERF_CONTEXT_HV: 1288 cpumode = PERF_RECORD_MISC_HYPERVISOR; 1289 break; 1290 case PERF_CONTEXT_KERNEL: 1291 cpumode = PERF_RECORD_MISC_KERNEL; 1292 break; 1293 case PERF_CONTEXT_USER: 1294 cpumode = PERF_RECORD_MISC_USER; 1295 break; 1296 default: 1297 pr_debug("invalid callchain context: " 1298 "%"PRId64"\n", (s64) ip); 1299 /* 1300 * It seems the callchain is corrupted. 1301 * Discard all. 1302 */ 1303 callchain_cursor_reset(&callchain_cursor); 1304 return 0; 1305 } 1306 continue; 1307 } 1308 1309 al.filtered = false; 1310 thread__find_addr_location(thread, machine, cpumode, 1311 MAP__FUNCTION, ip, &al); 1312 if (al.sym != NULL) { 1313 if (sort__has_parent && !*parent && 1314 symbol__match_regex(al.sym, &parent_regex)) 1315 *parent = al.sym; 1316 else if (have_ignore_callees && root_al && 1317 symbol__match_regex(al.sym, &ignore_callees_regex)) { 1318 /* Treat this symbol as the root, 1319 forgetting its callees. */ 1320 *root_al = al; 1321 callchain_cursor_reset(&callchain_cursor); 1322 } 1323 if (!symbol_conf.use_callchain) 1324 break; 1325 } 1326 1327 err = callchain_cursor_append(&callchain_cursor, 1328 ip, al.map, al.sym); 1329 if (err) 1330 return err; 1331 } 1332 1333 return 0; 1334 } 1335 1336 static int unwind_entry(struct unwind_entry *entry, void *arg) 1337 { 1338 struct callchain_cursor *cursor = arg; 1339 return callchain_cursor_append(cursor, entry->ip, 1340 entry->map, entry->sym); 1341 } 1342 1343 int machine__resolve_callchain(struct machine *machine, 1344 struct perf_evsel *evsel, 1345 struct thread *thread, 1346 struct perf_sample *sample, 1347 struct symbol **parent, 1348 struct addr_location *root_al, 1349 int max_stack) 1350 { 1351 int ret; 1352 1353 ret = machine__resolve_callchain_sample(machine, thread, 1354 sample->callchain, parent, 1355 root_al, max_stack); 1356 if (ret) 1357 return ret; 1358 1359 /* Can we do dwarf post unwind? */ 1360 if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) && 1361 (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER))) 1362 return 0; 1363 1364 /* Bail out if nothing was captured. */ 1365 if ((!sample->user_regs.regs) || 1366 (!sample->user_stack.size)) 1367 return 0; 1368 1369 return unwind__get_entries(unwind_entry, &callchain_cursor, machine, 1370 thread, evsel->attr.sample_regs_user, 1371 sample); 1372 1373 } 1374 1375 int machine__for_each_thread(struct machine *machine, 1376 int (*fn)(struct thread *thread, void *p), 1377 void *priv) 1378 { 1379 struct rb_node *nd; 1380 struct thread *thread; 1381 int rc = 0; 1382 1383 for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) { 1384 thread = rb_entry(nd, struct thread, rb_node); 1385 rc = fn(thread, priv); 1386 if (rc != 0) 1387 return rc; 1388 } 1389 1390 list_for_each_entry(thread, &machine->dead_threads, node) { 1391 rc = fn(thread, priv); 1392 if (rc != 0) 1393 return rc; 1394 } 1395 return rc; 1396 } 1397