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