1 #include <dirent.h> 2 #include <errno.h> 3 #include <stdlib.h> 4 #include <stdio.h> 5 #include <string.h> 6 #include <sys/types.h> 7 #include <sys/stat.h> 8 #include <sys/param.h> 9 #include <fcntl.h> 10 #include <unistd.h> 11 #include <inttypes.h> 12 #include "annotate.h" 13 #include "build-id.h" 14 #include "util.h" 15 #include "debug.h" 16 #include "machine.h" 17 #include "symbol.h" 18 #include "strlist.h" 19 #include "intlist.h" 20 #include "header.h" 21 22 #include <elf.h> 23 #include <limits.h> 24 #include <symbol/kallsyms.h> 25 #include <sys/utsname.h> 26 27 static int dso__load_kernel_sym(struct dso *dso, struct map *map); 28 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map); 29 static bool symbol__is_idle(const char *name); 30 31 int vmlinux_path__nr_entries; 32 char **vmlinux_path; 33 34 struct symbol_conf symbol_conf = { 35 .use_modules = true, 36 .try_vmlinux_path = true, 37 .annotate_src = true, 38 .demangle = true, 39 .demangle_kernel = false, 40 .cumulate_callchain = true, 41 .show_hist_headers = true, 42 .symfs = "", 43 .event_group = true, 44 }; 45 46 static enum dso_binary_type binary_type_symtab[] = { 47 DSO_BINARY_TYPE__KALLSYMS, 48 DSO_BINARY_TYPE__GUEST_KALLSYMS, 49 DSO_BINARY_TYPE__JAVA_JIT, 50 DSO_BINARY_TYPE__DEBUGLINK, 51 DSO_BINARY_TYPE__BUILD_ID_CACHE, 52 DSO_BINARY_TYPE__FEDORA_DEBUGINFO, 53 DSO_BINARY_TYPE__UBUNTU_DEBUGINFO, 54 DSO_BINARY_TYPE__BUILDID_DEBUGINFO, 55 DSO_BINARY_TYPE__SYSTEM_PATH_DSO, 56 DSO_BINARY_TYPE__GUEST_KMODULE, 57 DSO_BINARY_TYPE__GUEST_KMODULE_COMP, 58 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE, 59 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP, 60 DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO, 61 DSO_BINARY_TYPE__NOT_FOUND, 62 }; 63 64 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab) 65 66 bool symbol_type__is_a(char symbol_type, enum map_type map_type) 67 { 68 symbol_type = toupper(symbol_type); 69 70 switch (map_type) { 71 case MAP__FUNCTION: 72 return symbol_type == 'T' || symbol_type == 'W'; 73 case MAP__VARIABLE: 74 return symbol_type == 'D'; 75 default: 76 return false; 77 } 78 } 79 80 static int prefix_underscores_count(const char *str) 81 { 82 const char *tail = str; 83 84 while (*tail == '_') 85 tail++; 86 87 return tail - str; 88 } 89 90 int __weak arch__choose_best_symbol(struct symbol *syma, 91 struct symbol *symb __maybe_unused) 92 { 93 /* Avoid "SyS" kernel syscall aliases */ 94 if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3)) 95 return SYMBOL_B; 96 if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10)) 97 return SYMBOL_B; 98 99 return SYMBOL_A; 100 } 101 102 static int choose_best_symbol(struct symbol *syma, struct symbol *symb) 103 { 104 s64 a; 105 s64 b; 106 size_t na, nb; 107 108 /* Prefer a symbol with non zero length */ 109 a = syma->end - syma->start; 110 b = symb->end - symb->start; 111 if ((b == 0) && (a > 0)) 112 return SYMBOL_A; 113 else if ((a == 0) && (b > 0)) 114 return SYMBOL_B; 115 116 /* Prefer a non weak symbol over a weak one */ 117 a = syma->binding == STB_WEAK; 118 b = symb->binding == STB_WEAK; 119 if (b && !a) 120 return SYMBOL_A; 121 if (a && !b) 122 return SYMBOL_B; 123 124 /* Prefer a global symbol over a non global one */ 125 a = syma->binding == STB_GLOBAL; 126 b = symb->binding == STB_GLOBAL; 127 if (a && !b) 128 return SYMBOL_A; 129 if (b && !a) 130 return SYMBOL_B; 131 132 /* Prefer a symbol with less underscores */ 133 a = prefix_underscores_count(syma->name); 134 b = prefix_underscores_count(symb->name); 135 if (b > a) 136 return SYMBOL_A; 137 else if (a > b) 138 return SYMBOL_B; 139 140 /* Choose the symbol with the longest name */ 141 na = strlen(syma->name); 142 nb = strlen(symb->name); 143 if (na > nb) 144 return SYMBOL_A; 145 else if (na < nb) 146 return SYMBOL_B; 147 148 return arch__choose_best_symbol(syma, symb); 149 } 150 151 void symbols__fixup_duplicate(struct rb_root *symbols) 152 { 153 struct rb_node *nd; 154 struct symbol *curr, *next; 155 156 if (symbol_conf.allow_aliases) 157 return; 158 159 nd = rb_first(symbols); 160 161 while (nd) { 162 curr = rb_entry(nd, struct symbol, rb_node); 163 again: 164 nd = rb_next(&curr->rb_node); 165 next = rb_entry(nd, struct symbol, rb_node); 166 167 if (!nd) 168 break; 169 170 if (curr->start != next->start) 171 continue; 172 173 if (choose_best_symbol(curr, next) == SYMBOL_A) { 174 rb_erase(&next->rb_node, symbols); 175 symbol__delete(next); 176 goto again; 177 } else { 178 nd = rb_next(&curr->rb_node); 179 rb_erase(&curr->rb_node, symbols); 180 symbol__delete(curr); 181 } 182 } 183 } 184 185 void symbols__fixup_end(struct rb_root *symbols) 186 { 187 struct rb_node *nd, *prevnd = rb_first(symbols); 188 struct symbol *curr, *prev; 189 190 if (prevnd == NULL) 191 return; 192 193 curr = rb_entry(prevnd, struct symbol, rb_node); 194 195 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 196 prev = curr; 197 curr = rb_entry(nd, struct symbol, rb_node); 198 199 if (prev->end == prev->start && prev->end != curr->start) 200 prev->end = curr->start; 201 } 202 203 /* Last entry */ 204 if (curr->end == curr->start) 205 curr->end = roundup(curr->start, 4096); 206 } 207 208 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type) 209 { 210 struct maps *maps = &mg->maps[type]; 211 struct map *next, *curr; 212 213 pthread_rwlock_wrlock(&maps->lock); 214 215 curr = maps__first(maps); 216 if (curr == NULL) 217 goto out_unlock; 218 219 for (next = map__next(curr); next; next = map__next(curr)) { 220 curr->end = next->start; 221 curr = next; 222 } 223 224 /* 225 * We still haven't the actual symbols, so guess the 226 * last map final address. 227 */ 228 curr->end = ~0ULL; 229 230 out_unlock: 231 pthread_rwlock_unlock(&maps->lock); 232 } 233 234 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name) 235 { 236 size_t namelen = strlen(name) + 1; 237 struct symbol *sym = calloc(1, (symbol_conf.priv_size + 238 sizeof(*sym) + namelen)); 239 if (sym == NULL) 240 return NULL; 241 242 if (symbol_conf.priv_size) { 243 if (symbol_conf.init_annotation) { 244 struct annotation *notes = (void *)sym; 245 pthread_mutex_init(¬es->lock, NULL); 246 } 247 sym = ((void *)sym) + symbol_conf.priv_size; 248 } 249 250 sym->start = start; 251 sym->end = len ? start + len : start; 252 sym->binding = binding; 253 sym->namelen = namelen - 1; 254 255 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n", 256 __func__, name, start, sym->end); 257 memcpy(sym->name, name, namelen); 258 259 return sym; 260 } 261 262 void symbol__delete(struct symbol *sym) 263 { 264 free(((void *)sym) - symbol_conf.priv_size); 265 } 266 267 void symbols__delete(struct rb_root *symbols) 268 { 269 struct symbol *pos; 270 struct rb_node *next = rb_first(symbols); 271 272 while (next) { 273 pos = rb_entry(next, struct symbol, rb_node); 274 next = rb_next(&pos->rb_node); 275 rb_erase(&pos->rb_node, symbols); 276 symbol__delete(pos); 277 } 278 } 279 280 void __symbols__insert(struct rb_root *symbols, struct symbol *sym, bool kernel) 281 { 282 struct rb_node **p = &symbols->rb_node; 283 struct rb_node *parent = NULL; 284 const u64 ip = sym->start; 285 struct symbol *s; 286 287 if (kernel) { 288 const char *name = sym->name; 289 /* 290 * ppc64 uses function descriptors and appends a '.' to the 291 * start of every instruction address. Remove it. 292 */ 293 if (name[0] == '.') 294 name++; 295 sym->idle = symbol__is_idle(name); 296 } 297 298 while (*p != NULL) { 299 parent = *p; 300 s = rb_entry(parent, struct symbol, rb_node); 301 if (ip < s->start) 302 p = &(*p)->rb_left; 303 else 304 p = &(*p)->rb_right; 305 } 306 rb_link_node(&sym->rb_node, parent, p); 307 rb_insert_color(&sym->rb_node, symbols); 308 } 309 310 void symbols__insert(struct rb_root *symbols, struct symbol *sym) 311 { 312 __symbols__insert(symbols, sym, false); 313 } 314 315 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip) 316 { 317 struct rb_node *n; 318 319 if (symbols == NULL) 320 return NULL; 321 322 n = symbols->rb_node; 323 324 while (n) { 325 struct symbol *s = rb_entry(n, struct symbol, rb_node); 326 327 if (ip < s->start) 328 n = n->rb_left; 329 else if (ip > s->end || (ip == s->end && ip != s->start)) 330 n = n->rb_right; 331 else 332 return s; 333 } 334 335 return NULL; 336 } 337 338 static struct symbol *symbols__first(struct rb_root *symbols) 339 { 340 struct rb_node *n = rb_first(symbols); 341 342 if (n) 343 return rb_entry(n, struct symbol, rb_node); 344 345 return NULL; 346 } 347 348 static struct symbol *symbols__last(struct rb_root *symbols) 349 { 350 struct rb_node *n = rb_last(symbols); 351 352 if (n) 353 return rb_entry(n, struct symbol, rb_node); 354 355 return NULL; 356 } 357 358 static struct symbol *symbols__next(struct symbol *sym) 359 { 360 struct rb_node *n = rb_next(&sym->rb_node); 361 362 if (n) 363 return rb_entry(n, struct symbol, rb_node); 364 365 return NULL; 366 } 367 368 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym) 369 { 370 struct rb_node **p = &symbols->rb_node; 371 struct rb_node *parent = NULL; 372 struct symbol_name_rb_node *symn, *s; 373 374 symn = container_of(sym, struct symbol_name_rb_node, sym); 375 376 while (*p != NULL) { 377 parent = *p; 378 s = rb_entry(parent, struct symbol_name_rb_node, rb_node); 379 if (strcmp(sym->name, s->sym.name) < 0) 380 p = &(*p)->rb_left; 381 else 382 p = &(*p)->rb_right; 383 } 384 rb_link_node(&symn->rb_node, parent, p); 385 rb_insert_color(&symn->rb_node, symbols); 386 } 387 388 static void symbols__sort_by_name(struct rb_root *symbols, 389 struct rb_root *source) 390 { 391 struct rb_node *nd; 392 393 for (nd = rb_first(source); nd; nd = rb_next(nd)) { 394 struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 395 symbols__insert_by_name(symbols, pos); 396 } 397 } 398 399 static struct symbol *symbols__find_by_name(struct rb_root *symbols, 400 const char *name) 401 { 402 struct rb_node *n; 403 struct symbol_name_rb_node *s = NULL; 404 405 if (symbols == NULL) 406 return NULL; 407 408 n = symbols->rb_node; 409 410 while (n) { 411 int cmp; 412 413 s = rb_entry(n, struct symbol_name_rb_node, rb_node); 414 cmp = arch__compare_symbol_names(name, s->sym.name); 415 416 if (cmp < 0) 417 n = n->rb_left; 418 else if (cmp > 0) 419 n = n->rb_right; 420 else 421 break; 422 } 423 424 if (n == NULL) 425 return NULL; 426 427 /* return first symbol that has same name (if any) */ 428 for (n = rb_prev(n); n; n = rb_prev(n)) { 429 struct symbol_name_rb_node *tmp; 430 431 tmp = rb_entry(n, struct symbol_name_rb_node, rb_node); 432 if (arch__compare_symbol_names(tmp->sym.name, s->sym.name)) 433 break; 434 435 s = tmp; 436 } 437 438 return &s->sym; 439 } 440 441 void dso__reset_find_symbol_cache(struct dso *dso) 442 { 443 enum map_type type; 444 445 for (type = MAP__FUNCTION; type <= MAP__VARIABLE; ++type) { 446 dso->last_find_result[type].addr = 0; 447 dso->last_find_result[type].symbol = NULL; 448 } 449 } 450 451 void dso__insert_symbol(struct dso *dso, enum map_type type, struct symbol *sym) 452 { 453 __symbols__insert(&dso->symbols[type], sym, dso->kernel); 454 455 /* update the symbol cache if necessary */ 456 if (dso->last_find_result[type].addr >= sym->start && 457 (dso->last_find_result[type].addr < sym->end || 458 sym->start == sym->end)) { 459 dso->last_find_result[type].symbol = sym; 460 } 461 } 462 463 struct symbol *dso__find_symbol(struct dso *dso, 464 enum map_type type, u64 addr) 465 { 466 if (dso->last_find_result[type].addr != addr) { 467 dso->last_find_result[type].addr = addr; 468 dso->last_find_result[type].symbol = symbols__find(&dso->symbols[type], addr); 469 } 470 471 return dso->last_find_result[type].symbol; 472 } 473 474 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type) 475 { 476 return symbols__first(&dso->symbols[type]); 477 } 478 479 struct symbol *dso__last_symbol(struct dso *dso, enum map_type type) 480 { 481 return symbols__last(&dso->symbols[type]); 482 } 483 484 struct symbol *dso__next_symbol(struct symbol *sym) 485 { 486 return symbols__next(sym); 487 } 488 489 struct symbol *symbol__next_by_name(struct symbol *sym) 490 { 491 struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym); 492 struct rb_node *n = rb_next(&s->rb_node); 493 494 return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL; 495 } 496 497 /* 498 * Teturns first symbol that matched with @name. 499 */ 500 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type, 501 const char *name) 502 { 503 return symbols__find_by_name(&dso->symbol_names[type], name); 504 } 505 506 void dso__sort_by_name(struct dso *dso, enum map_type type) 507 { 508 dso__set_sorted_by_name(dso, type); 509 return symbols__sort_by_name(&dso->symbol_names[type], 510 &dso->symbols[type]); 511 } 512 513 int modules__parse(const char *filename, void *arg, 514 int (*process_module)(void *arg, const char *name, 515 u64 start)) 516 { 517 char *line = NULL; 518 size_t n; 519 FILE *file; 520 int err = 0; 521 522 file = fopen(filename, "r"); 523 if (file == NULL) 524 return -1; 525 526 while (1) { 527 char name[PATH_MAX]; 528 u64 start; 529 char *sep; 530 ssize_t line_len; 531 532 line_len = getline(&line, &n, file); 533 if (line_len < 0) { 534 if (feof(file)) 535 break; 536 err = -1; 537 goto out; 538 } 539 540 if (!line) { 541 err = -1; 542 goto out; 543 } 544 545 line[--line_len] = '\0'; /* \n */ 546 547 sep = strrchr(line, 'x'); 548 if (sep == NULL) 549 continue; 550 551 hex2u64(sep + 1, &start); 552 553 sep = strchr(line, ' '); 554 if (sep == NULL) 555 continue; 556 557 *sep = '\0'; 558 559 scnprintf(name, sizeof(name), "[%s]", line); 560 561 err = process_module(arg, name, start); 562 if (err) 563 break; 564 } 565 out: 566 free(line); 567 fclose(file); 568 return err; 569 } 570 571 struct process_kallsyms_args { 572 struct map *map; 573 struct dso *dso; 574 }; 575 576 /* 577 * These are symbols in the kernel image, so make sure that 578 * sym is from a kernel DSO. 579 */ 580 static bool symbol__is_idle(const char *name) 581 { 582 const char * const idle_symbols[] = { 583 "cpu_idle", 584 "cpu_startup_entry", 585 "intel_idle", 586 "default_idle", 587 "native_safe_halt", 588 "enter_idle", 589 "exit_idle", 590 "mwait_idle", 591 "mwait_idle_with_hints", 592 "poll_idle", 593 "ppc64_runlatch_off", 594 "pseries_dedicated_idle_sleep", 595 NULL 596 }; 597 int i; 598 599 for (i = 0; idle_symbols[i]; i++) { 600 if (!strcmp(idle_symbols[i], name)) 601 return true; 602 } 603 604 return false; 605 } 606 607 static int map__process_kallsym_symbol(void *arg, const char *name, 608 char type, u64 start) 609 { 610 struct symbol *sym; 611 struct process_kallsyms_args *a = arg; 612 struct rb_root *root = &a->dso->symbols[a->map->type]; 613 614 if (!symbol_type__is_a(type, a->map->type)) 615 return 0; 616 617 /* 618 * module symbols are not sorted so we add all 619 * symbols, setting length to 0, and rely on 620 * symbols__fixup_end() to fix it up. 621 */ 622 sym = symbol__new(start, 0, kallsyms2elf_binding(type), name); 623 if (sym == NULL) 624 return -ENOMEM; 625 /* 626 * We will pass the symbols to the filter later, in 627 * map__split_kallsyms, when we have split the maps per module 628 */ 629 __symbols__insert(root, sym, !strchr(name, '[')); 630 631 return 0; 632 } 633 634 /* 635 * Loads the function entries in /proc/kallsyms into kernel_map->dso, 636 * so that we can in the next step set the symbol ->end address and then 637 * call kernel_maps__split_kallsyms. 638 */ 639 static int dso__load_all_kallsyms(struct dso *dso, const char *filename, 640 struct map *map) 641 { 642 struct process_kallsyms_args args = { .map = map, .dso = dso, }; 643 return kallsyms__parse(filename, &args, map__process_kallsym_symbol); 644 } 645 646 static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map) 647 { 648 struct map_groups *kmaps = map__kmaps(map); 649 struct map *curr_map; 650 struct symbol *pos; 651 int count = 0; 652 struct rb_root old_root = dso->symbols[map->type]; 653 struct rb_root *root = &dso->symbols[map->type]; 654 struct rb_node *next = rb_first(root); 655 656 if (!kmaps) 657 return -1; 658 659 *root = RB_ROOT; 660 661 while (next) { 662 char *module; 663 664 pos = rb_entry(next, struct symbol, rb_node); 665 next = rb_next(&pos->rb_node); 666 667 rb_erase_init(&pos->rb_node, &old_root); 668 669 module = strchr(pos->name, '\t'); 670 if (module) 671 *module = '\0'; 672 673 curr_map = map_groups__find(kmaps, map->type, pos->start); 674 675 if (!curr_map) { 676 symbol__delete(pos); 677 continue; 678 } 679 680 pos->start -= curr_map->start - curr_map->pgoff; 681 if (pos->end) 682 pos->end -= curr_map->start - curr_map->pgoff; 683 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos); 684 ++count; 685 } 686 687 /* Symbols have been adjusted */ 688 dso->adjust_symbols = 1; 689 690 return count; 691 } 692 693 /* 694 * Split the symbols into maps, making sure there are no overlaps, i.e. the 695 * kernel range is broken in several maps, named [kernel].N, as we don't have 696 * the original ELF section names vmlinux have. 697 */ 698 static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta) 699 { 700 struct map_groups *kmaps = map__kmaps(map); 701 struct machine *machine; 702 struct map *curr_map = map; 703 struct symbol *pos; 704 int count = 0, moved = 0; 705 struct rb_root *root = &dso->symbols[map->type]; 706 struct rb_node *next = rb_first(root); 707 int kernel_range = 0; 708 709 if (!kmaps) 710 return -1; 711 712 machine = kmaps->machine; 713 714 while (next) { 715 char *module; 716 717 pos = rb_entry(next, struct symbol, rb_node); 718 next = rb_next(&pos->rb_node); 719 720 module = strchr(pos->name, '\t'); 721 if (module) { 722 if (!symbol_conf.use_modules) 723 goto discard_symbol; 724 725 *module++ = '\0'; 726 727 if (strcmp(curr_map->dso->short_name, module)) { 728 if (curr_map != map && 729 dso->kernel == DSO_TYPE_GUEST_KERNEL && 730 machine__is_default_guest(machine)) { 731 /* 732 * We assume all symbols of a module are 733 * continuous in * kallsyms, so curr_map 734 * points to a module and all its 735 * symbols are in its kmap. Mark it as 736 * loaded. 737 */ 738 dso__set_loaded(curr_map->dso, 739 curr_map->type); 740 } 741 742 curr_map = map_groups__find_by_name(kmaps, 743 map->type, module); 744 if (curr_map == NULL) { 745 pr_debug("%s/proc/{kallsyms,modules} " 746 "inconsistency while looking " 747 "for \"%s\" module!\n", 748 machine->root_dir, module); 749 curr_map = map; 750 goto discard_symbol; 751 } 752 753 if (curr_map->dso->loaded && 754 !machine__is_default_guest(machine)) 755 goto discard_symbol; 756 } 757 /* 758 * So that we look just like we get from .ko files, 759 * i.e. not prelinked, relative to map->start. 760 */ 761 pos->start = curr_map->map_ip(curr_map, pos->start); 762 pos->end = curr_map->map_ip(curr_map, pos->end); 763 } else if (curr_map != map) { 764 char dso_name[PATH_MAX]; 765 struct dso *ndso; 766 767 if (delta) { 768 /* Kernel was relocated at boot time */ 769 pos->start -= delta; 770 pos->end -= delta; 771 } 772 773 if (count == 0) { 774 curr_map = map; 775 goto add_symbol; 776 } 777 778 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 779 snprintf(dso_name, sizeof(dso_name), 780 "[guest.kernel].%d", 781 kernel_range++); 782 else 783 snprintf(dso_name, sizeof(dso_name), 784 "[kernel].%d", 785 kernel_range++); 786 787 ndso = dso__new(dso_name); 788 if (ndso == NULL) 789 return -1; 790 791 ndso->kernel = dso->kernel; 792 793 curr_map = map__new2(pos->start, ndso, map->type); 794 if (curr_map == NULL) { 795 dso__put(ndso); 796 return -1; 797 } 798 799 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip; 800 map_groups__insert(kmaps, curr_map); 801 ++kernel_range; 802 } else if (delta) { 803 /* Kernel was relocated at boot time */ 804 pos->start -= delta; 805 pos->end -= delta; 806 } 807 add_symbol: 808 if (curr_map != map) { 809 rb_erase(&pos->rb_node, root); 810 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos); 811 ++moved; 812 } else 813 ++count; 814 815 continue; 816 discard_symbol: 817 rb_erase(&pos->rb_node, root); 818 symbol__delete(pos); 819 } 820 821 if (curr_map != map && 822 dso->kernel == DSO_TYPE_GUEST_KERNEL && 823 machine__is_default_guest(kmaps->machine)) { 824 dso__set_loaded(curr_map->dso, curr_map->type); 825 } 826 827 return count + moved; 828 } 829 830 bool symbol__restricted_filename(const char *filename, 831 const char *restricted_filename) 832 { 833 bool restricted = false; 834 835 if (symbol_conf.kptr_restrict) { 836 char *r = realpath(filename, NULL); 837 838 if (r != NULL) { 839 restricted = strcmp(r, restricted_filename) == 0; 840 free(r); 841 return restricted; 842 } 843 } 844 845 return restricted; 846 } 847 848 struct module_info { 849 struct rb_node rb_node; 850 char *name; 851 u64 start; 852 }; 853 854 static void add_module(struct module_info *mi, struct rb_root *modules) 855 { 856 struct rb_node **p = &modules->rb_node; 857 struct rb_node *parent = NULL; 858 struct module_info *m; 859 860 while (*p != NULL) { 861 parent = *p; 862 m = rb_entry(parent, struct module_info, rb_node); 863 if (strcmp(mi->name, m->name) < 0) 864 p = &(*p)->rb_left; 865 else 866 p = &(*p)->rb_right; 867 } 868 rb_link_node(&mi->rb_node, parent, p); 869 rb_insert_color(&mi->rb_node, modules); 870 } 871 872 static void delete_modules(struct rb_root *modules) 873 { 874 struct module_info *mi; 875 struct rb_node *next = rb_first(modules); 876 877 while (next) { 878 mi = rb_entry(next, struct module_info, rb_node); 879 next = rb_next(&mi->rb_node); 880 rb_erase(&mi->rb_node, modules); 881 zfree(&mi->name); 882 free(mi); 883 } 884 } 885 886 static struct module_info *find_module(const char *name, 887 struct rb_root *modules) 888 { 889 struct rb_node *n = modules->rb_node; 890 891 while (n) { 892 struct module_info *m; 893 int cmp; 894 895 m = rb_entry(n, struct module_info, rb_node); 896 cmp = strcmp(name, m->name); 897 if (cmp < 0) 898 n = n->rb_left; 899 else if (cmp > 0) 900 n = n->rb_right; 901 else 902 return m; 903 } 904 905 return NULL; 906 } 907 908 static int __read_proc_modules(void *arg, const char *name, u64 start) 909 { 910 struct rb_root *modules = arg; 911 struct module_info *mi; 912 913 mi = zalloc(sizeof(struct module_info)); 914 if (!mi) 915 return -ENOMEM; 916 917 mi->name = strdup(name); 918 mi->start = start; 919 920 if (!mi->name) { 921 free(mi); 922 return -ENOMEM; 923 } 924 925 add_module(mi, modules); 926 927 return 0; 928 } 929 930 static int read_proc_modules(const char *filename, struct rb_root *modules) 931 { 932 if (symbol__restricted_filename(filename, "/proc/modules")) 933 return -1; 934 935 if (modules__parse(filename, modules, __read_proc_modules)) { 936 delete_modules(modules); 937 return -1; 938 } 939 940 return 0; 941 } 942 943 int compare_proc_modules(const char *from, const char *to) 944 { 945 struct rb_root from_modules = RB_ROOT; 946 struct rb_root to_modules = RB_ROOT; 947 struct rb_node *from_node, *to_node; 948 struct module_info *from_m, *to_m; 949 int ret = -1; 950 951 if (read_proc_modules(from, &from_modules)) 952 return -1; 953 954 if (read_proc_modules(to, &to_modules)) 955 goto out_delete_from; 956 957 from_node = rb_first(&from_modules); 958 to_node = rb_first(&to_modules); 959 while (from_node) { 960 if (!to_node) 961 break; 962 963 from_m = rb_entry(from_node, struct module_info, rb_node); 964 to_m = rb_entry(to_node, struct module_info, rb_node); 965 966 if (from_m->start != to_m->start || 967 strcmp(from_m->name, to_m->name)) 968 break; 969 970 from_node = rb_next(from_node); 971 to_node = rb_next(to_node); 972 } 973 974 if (!from_node && !to_node) 975 ret = 0; 976 977 delete_modules(&to_modules); 978 out_delete_from: 979 delete_modules(&from_modules); 980 981 return ret; 982 } 983 984 static int do_validate_kcore_modules(const char *filename, struct map *map, 985 struct map_groups *kmaps) 986 { 987 struct rb_root modules = RB_ROOT; 988 struct map *old_map; 989 int err; 990 991 err = read_proc_modules(filename, &modules); 992 if (err) 993 return err; 994 995 old_map = map_groups__first(kmaps, map->type); 996 while (old_map) { 997 struct map *next = map_groups__next(old_map); 998 struct module_info *mi; 999 1000 if (old_map == map || old_map->start == map->start) { 1001 /* The kernel map */ 1002 old_map = next; 1003 continue; 1004 } 1005 1006 /* Module must be in memory at the same address */ 1007 mi = find_module(old_map->dso->short_name, &modules); 1008 if (!mi || mi->start != old_map->start) { 1009 err = -EINVAL; 1010 goto out; 1011 } 1012 1013 old_map = next; 1014 } 1015 out: 1016 delete_modules(&modules); 1017 return err; 1018 } 1019 1020 /* 1021 * If kallsyms is referenced by name then we look for filename in the same 1022 * directory. 1023 */ 1024 static bool filename_from_kallsyms_filename(char *filename, 1025 const char *base_name, 1026 const char *kallsyms_filename) 1027 { 1028 char *name; 1029 1030 strcpy(filename, kallsyms_filename); 1031 name = strrchr(filename, '/'); 1032 if (!name) 1033 return false; 1034 1035 name += 1; 1036 1037 if (!strcmp(name, "kallsyms")) { 1038 strcpy(name, base_name); 1039 return true; 1040 } 1041 1042 return false; 1043 } 1044 1045 static int validate_kcore_modules(const char *kallsyms_filename, 1046 struct map *map) 1047 { 1048 struct map_groups *kmaps = map__kmaps(map); 1049 char modules_filename[PATH_MAX]; 1050 1051 if (!kmaps) 1052 return -EINVAL; 1053 1054 if (!filename_from_kallsyms_filename(modules_filename, "modules", 1055 kallsyms_filename)) 1056 return -EINVAL; 1057 1058 if (do_validate_kcore_modules(modules_filename, map, kmaps)) 1059 return -EINVAL; 1060 1061 return 0; 1062 } 1063 1064 static int validate_kcore_addresses(const char *kallsyms_filename, 1065 struct map *map) 1066 { 1067 struct kmap *kmap = map__kmap(map); 1068 1069 if (!kmap) 1070 return -EINVAL; 1071 1072 if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) { 1073 u64 start; 1074 1075 start = kallsyms__get_function_start(kallsyms_filename, 1076 kmap->ref_reloc_sym->name); 1077 if (start != kmap->ref_reloc_sym->addr) 1078 return -EINVAL; 1079 } 1080 1081 return validate_kcore_modules(kallsyms_filename, map); 1082 } 1083 1084 struct kcore_mapfn_data { 1085 struct dso *dso; 1086 enum map_type type; 1087 struct list_head maps; 1088 }; 1089 1090 static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data) 1091 { 1092 struct kcore_mapfn_data *md = data; 1093 struct map *map; 1094 1095 map = map__new2(start, md->dso, md->type); 1096 if (map == NULL) 1097 return -ENOMEM; 1098 1099 map->end = map->start + len; 1100 map->pgoff = pgoff; 1101 1102 list_add(&map->node, &md->maps); 1103 1104 return 0; 1105 } 1106 1107 static int dso__load_kcore(struct dso *dso, struct map *map, 1108 const char *kallsyms_filename) 1109 { 1110 struct map_groups *kmaps = map__kmaps(map); 1111 struct machine *machine; 1112 struct kcore_mapfn_data md; 1113 struct map *old_map, *new_map, *replacement_map = NULL; 1114 bool is_64_bit; 1115 int err, fd; 1116 char kcore_filename[PATH_MAX]; 1117 struct symbol *sym; 1118 1119 if (!kmaps) 1120 return -EINVAL; 1121 1122 machine = kmaps->machine; 1123 1124 /* This function requires that the map is the kernel map */ 1125 if (map != machine->vmlinux_maps[map->type]) 1126 return -EINVAL; 1127 1128 if (!filename_from_kallsyms_filename(kcore_filename, "kcore", 1129 kallsyms_filename)) 1130 return -EINVAL; 1131 1132 /* Modules and kernel must be present at their original addresses */ 1133 if (validate_kcore_addresses(kallsyms_filename, map)) 1134 return -EINVAL; 1135 1136 md.dso = dso; 1137 md.type = map->type; 1138 INIT_LIST_HEAD(&md.maps); 1139 1140 fd = open(kcore_filename, O_RDONLY); 1141 if (fd < 0) { 1142 pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n", 1143 kcore_filename); 1144 return -EINVAL; 1145 } 1146 1147 /* Read new maps into temporary lists */ 1148 err = file__read_maps(fd, md.type == MAP__FUNCTION, kcore_mapfn, &md, 1149 &is_64_bit); 1150 if (err) 1151 goto out_err; 1152 dso->is_64_bit = is_64_bit; 1153 1154 if (list_empty(&md.maps)) { 1155 err = -EINVAL; 1156 goto out_err; 1157 } 1158 1159 /* Remove old maps */ 1160 old_map = map_groups__first(kmaps, map->type); 1161 while (old_map) { 1162 struct map *next = map_groups__next(old_map); 1163 1164 if (old_map != map) 1165 map_groups__remove(kmaps, old_map); 1166 old_map = next; 1167 } 1168 1169 /* Find the kernel map using the first symbol */ 1170 sym = dso__first_symbol(dso, map->type); 1171 list_for_each_entry(new_map, &md.maps, node) { 1172 if (sym && sym->start >= new_map->start && 1173 sym->start < new_map->end) { 1174 replacement_map = new_map; 1175 break; 1176 } 1177 } 1178 1179 if (!replacement_map) 1180 replacement_map = list_entry(md.maps.next, struct map, node); 1181 1182 /* Add new maps */ 1183 while (!list_empty(&md.maps)) { 1184 new_map = list_entry(md.maps.next, struct map, node); 1185 list_del_init(&new_map->node); 1186 if (new_map == replacement_map) { 1187 map->start = new_map->start; 1188 map->end = new_map->end; 1189 map->pgoff = new_map->pgoff; 1190 map->map_ip = new_map->map_ip; 1191 map->unmap_ip = new_map->unmap_ip; 1192 /* Ensure maps are correctly ordered */ 1193 map__get(map); 1194 map_groups__remove(kmaps, map); 1195 map_groups__insert(kmaps, map); 1196 map__put(map); 1197 } else { 1198 map_groups__insert(kmaps, new_map); 1199 } 1200 1201 map__put(new_map); 1202 } 1203 1204 /* 1205 * Set the data type and long name so that kcore can be read via 1206 * dso__data_read_addr(). 1207 */ 1208 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1209 dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE; 1210 else 1211 dso->binary_type = DSO_BINARY_TYPE__KCORE; 1212 dso__set_long_name(dso, strdup(kcore_filename), true); 1213 1214 close(fd); 1215 1216 if (map->type == MAP__FUNCTION) 1217 pr_debug("Using %s for kernel object code\n", kcore_filename); 1218 else 1219 pr_debug("Using %s for kernel data\n", kcore_filename); 1220 1221 return 0; 1222 1223 out_err: 1224 while (!list_empty(&md.maps)) { 1225 map = list_entry(md.maps.next, struct map, node); 1226 list_del_init(&map->node); 1227 map__put(map); 1228 } 1229 close(fd); 1230 return -EINVAL; 1231 } 1232 1233 /* 1234 * If the kernel is relocated at boot time, kallsyms won't match. Compute the 1235 * delta based on the relocation reference symbol. 1236 */ 1237 static int kallsyms__delta(struct map *map, const char *filename, u64 *delta) 1238 { 1239 struct kmap *kmap = map__kmap(map); 1240 u64 addr; 1241 1242 if (!kmap) 1243 return -1; 1244 1245 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name) 1246 return 0; 1247 1248 addr = kallsyms__get_function_start(filename, 1249 kmap->ref_reloc_sym->name); 1250 if (!addr) 1251 return -1; 1252 1253 *delta = addr - kmap->ref_reloc_sym->addr; 1254 return 0; 1255 } 1256 1257 int __dso__load_kallsyms(struct dso *dso, const char *filename, 1258 struct map *map, bool no_kcore) 1259 { 1260 u64 delta = 0; 1261 1262 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 1263 return -1; 1264 1265 if (dso__load_all_kallsyms(dso, filename, map) < 0) 1266 return -1; 1267 1268 if (kallsyms__delta(map, filename, &delta)) 1269 return -1; 1270 1271 symbols__fixup_end(&dso->symbols[map->type]); 1272 symbols__fixup_duplicate(&dso->symbols[map->type]); 1273 1274 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1275 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 1276 else 1277 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS; 1278 1279 if (!no_kcore && !dso__load_kcore(dso, map, filename)) 1280 return dso__split_kallsyms_for_kcore(dso, map); 1281 else 1282 return dso__split_kallsyms(dso, map, delta); 1283 } 1284 1285 int dso__load_kallsyms(struct dso *dso, const char *filename, 1286 struct map *map) 1287 { 1288 return __dso__load_kallsyms(dso, filename, map, false); 1289 } 1290 1291 static int dso__load_perf_map(struct dso *dso, struct map *map) 1292 { 1293 char *line = NULL; 1294 size_t n; 1295 FILE *file; 1296 int nr_syms = 0; 1297 1298 file = fopen(dso->long_name, "r"); 1299 if (file == NULL) 1300 goto out_failure; 1301 1302 while (!feof(file)) { 1303 u64 start, size; 1304 struct symbol *sym; 1305 int line_len, len; 1306 1307 line_len = getline(&line, &n, file); 1308 if (line_len < 0) 1309 break; 1310 1311 if (!line) 1312 goto out_failure; 1313 1314 line[--line_len] = '\0'; /* \n */ 1315 1316 len = hex2u64(line, &start); 1317 1318 len++; 1319 if (len + 2 >= line_len) 1320 continue; 1321 1322 len += hex2u64(line + len, &size); 1323 1324 len++; 1325 if (len + 2 >= line_len) 1326 continue; 1327 1328 sym = symbol__new(start, size, STB_GLOBAL, line + len); 1329 1330 if (sym == NULL) 1331 goto out_delete_line; 1332 1333 symbols__insert(&dso->symbols[map->type], sym); 1334 nr_syms++; 1335 } 1336 1337 free(line); 1338 fclose(file); 1339 1340 return nr_syms; 1341 1342 out_delete_line: 1343 free(line); 1344 out_failure: 1345 return -1; 1346 } 1347 1348 static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod, 1349 enum dso_binary_type type) 1350 { 1351 switch (type) { 1352 case DSO_BINARY_TYPE__JAVA_JIT: 1353 case DSO_BINARY_TYPE__DEBUGLINK: 1354 case DSO_BINARY_TYPE__SYSTEM_PATH_DSO: 1355 case DSO_BINARY_TYPE__FEDORA_DEBUGINFO: 1356 case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO: 1357 case DSO_BINARY_TYPE__BUILDID_DEBUGINFO: 1358 case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO: 1359 return !kmod && dso->kernel == DSO_TYPE_USER; 1360 1361 case DSO_BINARY_TYPE__KALLSYMS: 1362 case DSO_BINARY_TYPE__VMLINUX: 1363 case DSO_BINARY_TYPE__KCORE: 1364 return dso->kernel == DSO_TYPE_KERNEL; 1365 1366 case DSO_BINARY_TYPE__GUEST_KALLSYMS: 1367 case DSO_BINARY_TYPE__GUEST_VMLINUX: 1368 case DSO_BINARY_TYPE__GUEST_KCORE: 1369 return dso->kernel == DSO_TYPE_GUEST_KERNEL; 1370 1371 case DSO_BINARY_TYPE__GUEST_KMODULE: 1372 case DSO_BINARY_TYPE__GUEST_KMODULE_COMP: 1373 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE: 1374 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP: 1375 /* 1376 * kernel modules know their symtab type - it's set when 1377 * creating a module dso in machine__findnew_module_map(). 1378 */ 1379 return kmod && dso->symtab_type == type; 1380 1381 case DSO_BINARY_TYPE__BUILD_ID_CACHE: 1382 return true; 1383 1384 case DSO_BINARY_TYPE__NOT_FOUND: 1385 default: 1386 return false; 1387 } 1388 } 1389 1390 int dso__load(struct dso *dso, struct map *map) 1391 { 1392 char *name; 1393 int ret = -1; 1394 u_int i; 1395 struct machine *machine; 1396 char *root_dir = (char *) ""; 1397 int ss_pos = 0; 1398 struct symsrc ss_[2]; 1399 struct symsrc *syms_ss = NULL, *runtime_ss = NULL; 1400 bool kmod; 1401 unsigned char build_id[BUILD_ID_SIZE]; 1402 1403 pthread_mutex_lock(&dso->lock); 1404 1405 /* check again under the dso->lock */ 1406 if (dso__loaded(dso, map->type)) { 1407 ret = 1; 1408 goto out; 1409 } 1410 1411 if (dso->kernel) { 1412 if (dso->kernel == DSO_TYPE_KERNEL) 1413 ret = dso__load_kernel_sym(dso, map); 1414 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1415 ret = dso__load_guest_kernel_sym(dso, map); 1416 1417 goto out; 1418 } 1419 1420 if (map->groups && map->groups->machine) 1421 machine = map->groups->machine; 1422 else 1423 machine = NULL; 1424 1425 dso->adjust_symbols = 0; 1426 1427 if (strncmp(dso->name, "/tmp/perf-", 10) == 0) { 1428 struct stat st; 1429 1430 if (lstat(dso->name, &st) < 0) 1431 goto out; 1432 1433 if (!symbol_conf.force && st.st_uid && (st.st_uid != geteuid())) { 1434 pr_warning("File %s not owned by current user or root, " 1435 "ignoring it (use -f to override).\n", dso->name); 1436 goto out; 1437 } 1438 1439 ret = dso__load_perf_map(dso, map); 1440 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT : 1441 DSO_BINARY_TYPE__NOT_FOUND; 1442 goto out; 1443 } 1444 1445 if (machine) 1446 root_dir = machine->root_dir; 1447 1448 name = malloc(PATH_MAX); 1449 if (!name) 1450 goto out; 1451 1452 kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE || 1453 dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP || 1454 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE || 1455 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP; 1456 1457 1458 /* 1459 * Read the build id if possible. This is required for 1460 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work 1461 */ 1462 if (!dso->has_build_id && 1463 is_regular_file(dso->long_name)) { 1464 __symbol__join_symfs(name, PATH_MAX, dso->long_name); 1465 if (filename__read_build_id(name, build_id, BUILD_ID_SIZE) > 0) 1466 dso__set_build_id(dso, build_id); 1467 } 1468 1469 /* 1470 * Iterate over candidate debug images. 1471 * Keep track of "interesting" ones (those which have a symtab, dynsym, 1472 * and/or opd section) for processing. 1473 */ 1474 for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) { 1475 struct symsrc *ss = &ss_[ss_pos]; 1476 bool next_slot = false; 1477 1478 enum dso_binary_type symtab_type = binary_type_symtab[i]; 1479 1480 if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type)) 1481 continue; 1482 1483 if (dso__read_binary_type_filename(dso, symtab_type, 1484 root_dir, name, PATH_MAX)) 1485 continue; 1486 1487 if (!is_regular_file(name)) 1488 continue; 1489 1490 /* Name is now the name of the next image to try */ 1491 if (symsrc__init(ss, dso, name, symtab_type) < 0) 1492 continue; 1493 1494 if (!syms_ss && symsrc__has_symtab(ss)) { 1495 syms_ss = ss; 1496 next_slot = true; 1497 if (!dso->symsrc_filename) 1498 dso->symsrc_filename = strdup(name); 1499 } 1500 1501 if (!runtime_ss && symsrc__possibly_runtime(ss)) { 1502 runtime_ss = ss; 1503 next_slot = true; 1504 } 1505 1506 if (next_slot) { 1507 ss_pos++; 1508 1509 if (syms_ss && runtime_ss) 1510 break; 1511 } else { 1512 symsrc__destroy(ss); 1513 } 1514 1515 } 1516 1517 if (!runtime_ss && !syms_ss) 1518 goto out_free; 1519 1520 if (runtime_ss && !syms_ss) { 1521 syms_ss = runtime_ss; 1522 } 1523 1524 /* We'll have to hope for the best */ 1525 if (!runtime_ss && syms_ss) 1526 runtime_ss = syms_ss; 1527 1528 if (syms_ss && syms_ss->type == DSO_BINARY_TYPE__BUILD_ID_CACHE) 1529 if (dso__build_id_is_kmod(dso, name, PATH_MAX)) 1530 kmod = true; 1531 1532 if (syms_ss) 1533 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod); 1534 else 1535 ret = -1; 1536 1537 if (ret > 0) { 1538 int nr_plt; 1539 1540 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map); 1541 if (nr_plt > 0) 1542 ret += nr_plt; 1543 } 1544 1545 for (; ss_pos > 0; ss_pos--) 1546 symsrc__destroy(&ss_[ss_pos - 1]); 1547 out_free: 1548 free(name); 1549 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL) 1550 ret = 0; 1551 out: 1552 dso__set_loaded(dso, map->type); 1553 pthread_mutex_unlock(&dso->lock); 1554 1555 return ret; 1556 } 1557 1558 struct map *map_groups__find_by_name(struct map_groups *mg, 1559 enum map_type type, const char *name) 1560 { 1561 struct maps *maps = &mg->maps[type]; 1562 struct map *map; 1563 1564 pthread_rwlock_rdlock(&maps->lock); 1565 1566 for (map = maps__first(maps); map; map = map__next(map)) { 1567 if (map->dso && strcmp(map->dso->short_name, name) == 0) 1568 goto out_unlock; 1569 } 1570 1571 map = NULL; 1572 1573 out_unlock: 1574 pthread_rwlock_unlock(&maps->lock); 1575 return map; 1576 } 1577 1578 int dso__load_vmlinux(struct dso *dso, struct map *map, 1579 const char *vmlinux, bool vmlinux_allocated) 1580 { 1581 int err = -1; 1582 struct symsrc ss; 1583 char symfs_vmlinux[PATH_MAX]; 1584 enum dso_binary_type symtab_type; 1585 1586 if (vmlinux[0] == '/') 1587 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux); 1588 else 1589 symbol__join_symfs(symfs_vmlinux, vmlinux); 1590 1591 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1592 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 1593 else 1594 symtab_type = DSO_BINARY_TYPE__VMLINUX; 1595 1596 if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type)) 1597 return -1; 1598 1599 err = dso__load_sym(dso, map, &ss, &ss, 0); 1600 symsrc__destroy(&ss); 1601 1602 if (err > 0) { 1603 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1604 dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 1605 else 1606 dso->binary_type = DSO_BINARY_TYPE__VMLINUX; 1607 dso__set_long_name(dso, vmlinux, vmlinux_allocated); 1608 dso__set_loaded(dso, map->type); 1609 pr_debug("Using %s for symbols\n", symfs_vmlinux); 1610 } 1611 1612 return err; 1613 } 1614 1615 int dso__load_vmlinux_path(struct dso *dso, struct map *map) 1616 { 1617 int i, err = 0; 1618 char *filename = NULL; 1619 1620 pr_debug("Looking at the vmlinux_path (%d entries long)\n", 1621 vmlinux_path__nr_entries + 1); 1622 1623 for (i = 0; i < vmlinux_path__nr_entries; ++i) { 1624 err = dso__load_vmlinux(dso, map, vmlinux_path[i], false); 1625 if (err > 0) 1626 goto out; 1627 } 1628 1629 if (!symbol_conf.ignore_vmlinux_buildid) 1630 filename = dso__build_id_filename(dso, NULL, 0); 1631 if (filename != NULL) { 1632 err = dso__load_vmlinux(dso, map, filename, true); 1633 if (err > 0) 1634 goto out; 1635 free(filename); 1636 } 1637 out: 1638 return err; 1639 } 1640 1641 static bool visible_dir_filter(const char *name, struct dirent *d) 1642 { 1643 if (d->d_type != DT_DIR) 1644 return false; 1645 return lsdir_no_dot_filter(name, d); 1646 } 1647 1648 static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz) 1649 { 1650 char kallsyms_filename[PATH_MAX]; 1651 int ret = -1; 1652 struct strlist *dirs; 1653 struct str_node *nd; 1654 1655 dirs = lsdir(dir, visible_dir_filter); 1656 if (!dirs) 1657 return -1; 1658 1659 strlist__for_each_entry(nd, dirs) { 1660 scnprintf(kallsyms_filename, sizeof(kallsyms_filename), 1661 "%s/%s/kallsyms", dir, nd->s); 1662 if (!validate_kcore_addresses(kallsyms_filename, map)) { 1663 strlcpy(dir, kallsyms_filename, dir_sz); 1664 ret = 0; 1665 break; 1666 } 1667 } 1668 1669 strlist__delete(dirs); 1670 1671 return ret; 1672 } 1673 1674 /* 1675 * Use open(O_RDONLY) to check readability directly instead of access(R_OK) 1676 * since access(R_OK) only checks with real UID/GID but open() use effective 1677 * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO). 1678 */ 1679 static bool filename__readable(const char *file) 1680 { 1681 int fd = open(file, O_RDONLY); 1682 if (fd < 0) 1683 return false; 1684 close(fd); 1685 return true; 1686 } 1687 1688 static char *dso__find_kallsyms(struct dso *dso, struct map *map) 1689 { 1690 u8 host_build_id[BUILD_ID_SIZE]; 1691 char sbuild_id[SBUILD_ID_SIZE]; 1692 bool is_host = false; 1693 char path[PATH_MAX]; 1694 1695 if (!dso->has_build_id) { 1696 /* 1697 * Last resort, if we don't have a build-id and couldn't find 1698 * any vmlinux file, try the running kernel kallsyms table. 1699 */ 1700 goto proc_kallsyms; 1701 } 1702 1703 if (sysfs__read_build_id("/sys/kernel/notes", host_build_id, 1704 sizeof(host_build_id)) == 0) 1705 is_host = dso__build_id_equal(dso, host_build_id); 1706 1707 /* Try a fast path for /proc/kallsyms if possible */ 1708 if (is_host) { 1709 /* 1710 * Do not check the build-id cache, unless we know we cannot use 1711 * /proc/kcore or module maps don't match to /proc/kallsyms. 1712 * To check readability of /proc/kcore, do not use access(R_OK) 1713 * since /proc/kcore requires CAP_SYS_RAWIO to read and access 1714 * can't check it. 1715 */ 1716 if (filename__readable("/proc/kcore") && 1717 !validate_kcore_addresses("/proc/kallsyms", map)) 1718 goto proc_kallsyms; 1719 } 1720 1721 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id); 1722 1723 /* Find kallsyms in build-id cache with kcore */ 1724 scnprintf(path, sizeof(path), "%s/%s/%s", 1725 buildid_dir, DSO__NAME_KCORE, sbuild_id); 1726 1727 if (!find_matching_kcore(map, path, sizeof(path))) 1728 return strdup(path); 1729 1730 /* Use current /proc/kallsyms if possible */ 1731 if (is_host) { 1732 proc_kallsyms: 1733 return strdup("/proc/kallsyms"); 1734 } 1735 1736 /* Finally, find a cache of kallsyms */ 1737 if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) { 1738 pr_err("No kallsyms or vmlinux with build-id %s was found\n", 1739 sbuild_id); 1740 return NULL; 1741 } 1742 1743 return strdup(path); 1744 } 1745 1746 static int dso__load_kernel_sym(struct dso *dso, struct map *map) 1747 { 1748 int err; 1749 const char *kallsyms_filename = NULL; 1750 char *kallsyms_allocated_filename = NULL; 1751 /* 1752 * Step 1: if the user specified a kallsyms or vmlinux filename, use 1753 * it and only it, reporting errors to the user if it cannot be used. 1754 * 1755 * For instance, try to analyse an ARM perf.data file _without_ a 1756 * build-id, or if the user specifies the wrong path to the right 1757 * vmlinux file, obviously we can't fallback to another vmlinux (a 1758 * x86_86 one, on the machine where analysis is being performed, say), 1759 * or worse, /proc/kallsyms. 1760 * 1761 * If the specified file _has_ a build-id and there is a build-id 1762 * section in the perf.data file, we will still do the expected 1763 * validation in dso__load_vmlinux and will bail out if they don't 1764 * match. 1765 */ 1766 if (symbol_conf.kallsyms_name != NULL) { 1767 kallsyms_filename = symbol_conf.kallsyms_name; 1768 goto do_kallsyms; 1769 } 1770 1771 if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) { 1772 return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false); 1773 } 1774 1775 if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) { 1776 err = dso__load_vmlinux_path(dso, map); 1777 if (err > 0) 1778 return err; 1779 } 1780 1781 /* do not try local files if a symfs was given */ 1782 if (symbol_conf.symfs[0] != 0) 1783 return -1; 1784 1785 kallsyms_allocated_filename = dso__find_kallsyms(dso, map); 1786 if (!kallsyms_allocated_filename) 1787 return -1; 1788 1789 kallsyms_filename = kallsyms_allocated_filename; 1790 1791 do_kallsyms: 1792 err = dso__load_kallsyms(dso, kallsyms_filename, map); 1793 if (err > 0) 1794 pr_debug("Using %s for symbols\n", kallsyms_filename); 1795 free(kallsyms_allocated_filename); 1796 1797 if (err > 0 && !dso__is_kcore(dso)) { 1798 dso->binary_type = DSO_BINARY_TYPE__KALLSYMS; 1799 dso__set_long_name(dso, DSO__NAME_KALLSYMS, false); 1800 map__fixup_start(map); 1801 map__fixup_end(map); 1802 } 1803 1804 return err; 1805 } 1806 1807 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map) 1808 { 1809 int err; 1810 const char *kallsyms_filename = NULL; 1811 struct machine *machine; 1812 char path[PATH_MAX]; 1813 1814 if (!map->groups) { 1815 pr_debug("Guest kernel map hasn't the point to groups\n"); 1816 return -1; 1817 } 1818 machine = map->groups->machine; 1819 1820 if (machine__is_default_guest(machine)) { 1821 /* 1822 * if the user specified a vmlinux filename, use it and only 1823 * it, reporting errors to the user if it cannot be used. 1824 * Or use file guest_kallsyms inputted by user on commandline 1825 */ 1826 if (symbol_conf.default_guest_vmlinux_name != NULL) { 1827 err = dso__load_vmlinux(dso, map, 1828 symbol_conf.default_guest_vmlinux_name, 1829 false); 1830 return err; 1831 } 1832 1833 kallsyms_filename = symbol_conf.default_guest_kallsyms; 1834 if (!kallsyms_filename) 1835 return -1; 1836 } else { 1837 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 1838 kallsyms_filename = path; 1839 } 1840 1841 err = dso__load_kallsyms(dso, kallsyms_filename, map); 1842 if (err > 0) 1843 pr_debug("Using %s for symbols\n", kallsyms_filename); 1844 if (err > 0 && !dso__is_kcore(dso)) { 1845 dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 1846 machine__mmap_name(machine, path, sizeof(path)); 1847 dso__set_long_name(dso, strdup(path), true); 1848 map__fixup_start(map); 1849 map__fixup_end(map); 1850 } 1851 1852 return err; 1853 } 1854 1855 static void vmlinux_path__exit(void) 1856 { 1857 while (--vmlinux_path__nr_entries >= 0) 1858 zfree(&vmlinux_path[vmlinux_path__nr_entries]); 1859 vmlinux_path__nr_entries = 0; 1860 1861 zfree(&vmlinux_path); 1862 } 1863 1864 static const char * const vmlinux_paths[] = { 1865 "vmlinux", 1866 "/boot/vmlinux" 1867 }; 1868 1869 static const char * const vmlinux_paths_upd[] = { 1870 "/boot/vmlinux-%s", 1871 "/usr/lib/debug/boot/vmlinux-%s", 1872 "/lib/modules/%s/build/vmlinux", 1873 "/usr/lib/debug/lib/modules/%s/vmlinux", 1874 "/usr/lib/debug/boot/vmlinux-%s.debug" 1875 }; 1876 1877 static int vmlinux_path__add(const char *new_entry) 1878 { 1879 vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry); 1880 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 1881 return -1; 1882 ++vmlinux_path__nr_entries; 1883 1884 return 0; 1885 } 1886 1887 static int vmlinux_path__init(struct perf_env *env) 1888 { 1889 struct utsname uts; 1890 char bf[PATH_MAX]; 1891 char *kernel_version; 1892 unsigned int i; 1893 1894 vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) + 1895 ARRAY_SIZE(vmlinux_paths_upd))); 1896 if (vmlinux_path == NULL) 1897 return -1; 1898 1899 for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++) 1900 if (vmlinux_path__add(vmlinux_paths[i]) < 0) 1901 goto out_fail; 1902 1903 /* only try kernel version if no symfs was given */ 1904 if (symbol_conf.symfs[0] != 0) 1905 return 0; 1906 1907 if (env) { 1908 kernel_version = env->os_release; 1909 } else { 1910 if (uname(&uts) < 0) 1911 goto out_fail; 1912 1913 kernel_version = uts.release; 1914 } 1915 1916 for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) { 1917 snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version); 1918 if (vmlinux_path__add(bf) < 0) 1919 goto out_fail; 1920 } 1921 1922 return 0; 1923 1924 out_fail: 1925 vmlinux_path__exit(); 1926 return -1; 1927 } 1928 1929 int setup_list(struct strlist **list, const char *list_str, 1930 const char *list_name) 1931 { 1932 if (list_str == NULL) 1933 return 0; 1934 1935 *list = strlist__new(list_str, NULL); 1936 if (!*list) { 1937 pr_err("problems parsing %s list\n", list_name); 1938 return -1; 1939 } 1940 1941 symbol_conf.has_filter = true; 1942 return 0; 1943 } 1944 1945 int setup_intlist(struct intlist **list, const char *list_str, 1946 const char *list_name) 1947 { 1948 if (list_str == NULL) 1949 return 0; 1950 1951 *list = intlist__new(list_str); 1952 if (!*list) { 1953 pr_err("problems parsing %s list\n", list_name); 1954 return -1; 1955 } 1956 return 0; 1957 } 1958 1959 static bool symbol__read_kptr_restrict(void) 1960 { 1961 bool value = false; 1962 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r"); 1963 1964 if (fp != NULL) { 1965 char line[8]; 1966 1967 if (fgets(line, sizeof(line), fp) != NULL) 1968 value = ((geteuid() != 0) || (getuid() != 0)) ? 1969 (atoi(line) != 0) : 1970 (atoi(line) == 2); 1971 1972 fclose(fp); 1973 } 1974 1975 return value; 1976 } 1977 1978 int symbol__annotation_init(void) 1979 { 1980 if (symbol_conf.initialized) { 1981 pr_err("Annotation needs to be init before symbol__init()\n"); 1982 return -1; 1983 } 1984 1985 if (symbol_conf.init_annotation) { 1986 pr_warning("Annotation being initialized multiple times\n"); 1987 return 0; 1988 } 1989 1990 symbol_conf.priv_size += sizeof(struct annotation); 1991 symbol_conf.init_annotation = true; 1992 return 0; 1993 } 1994 1995 int symbol__init(struct perf_env *env) 1996 { 1997 const char *symfs; 1998 1999 if (symbol_conf.initialized) 2000 return 0; 2001 2002 symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64)); 2003 2004 symbol__elf_init(); 2005 2006 if (symbol_conf.sort_by_name) 2007 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) - 2008 sizeof(struct symbol)); 2009 2010 if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0) 2011 return -1; 2012 2013 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') { 2014 pr_err("'.' is the only non valid --field-separator argument\n"); 2015 return -1; 2016 } 2017 2018 if (setup_list(&symbol_conf.dso_list, 2019 symbol_conf.dso_list_str, "dso") < 0) 2020 return -1; 2021 2022 if (setup_list(&symbol_conf.comm_list, 2023 symbol_conf.comm_list_str, "comm") < 0) 2024 goto out_free_dso_list; 2025 2026 if (setup_intlist(&symbol_conf.pid_list, 2027 symbol_conf.pid_list_str, "pid") < 0) 2028 goto out_free_comm_list; 2029 2030 if (setup_intlist(&symbol_conf.tid_list, 2031 symbol_conf.tid_list_str, "tid") < 0) 2032 goto out_free_pid_list; 2033 2034 if (setup_list(&symbol_conf.sym_list, 2035 symbol_conf.sym_list_str, "symbol") < 0) 2036 goto out_free_tid_list; 2037 2038 if (setup_list(&symbol_conf.bt_stop_list, 2039 symbol_conf.bt_stop_list_str, "symbol") < 0) 2040 goto out_free_sym_list; 2041 2042 /* 2043 * A path to symbols of "/" is identical to "" 2044 * reset here for simplicity. 2045 */ 2046 symfs = realpath(symbol_conf.symfs, NULL); 2047 if (symfs == NULL) 2048 symfs = symbol_conf.symfs; 2049 if (strcmp(symfs, "/") == 0) 2050 symbol_conf.symfs = ""; 2051 if (symfs != symbol_conf.symfs) 2052 free((void *)symfs); 2053 2054 symbol_conf.kptr_restrict = symbol__read_kptr_restrict(); 2055 2056 symbol_conf.initialized = true; 2057 return 0; 2058 2059 out_free_sym_list: 2060 strlist__delete(symbol_conf.sym_list); 2061 out_free_tid_list: 2062 intlist__delete(symbol_conf.tid_list); 2063 out_free_pid_list: 2064 intlist__delete(symbol_conf.pid_list); 2065 out_free_comm_list: 2066 strlist__delete(symbol_conf.comm_list); 2067 out_free_dso_list: 2068 strlist__delete(symbol_conf.dso_list); 2069 return -1; 2070 } 2071 2072 void symbol__exit(void) 2073 { 2074 if (!symbol_conf.initialized) 2075 return; 2076 strlist__delete(symbol_conf.bt_stop_list); 2077 strlist__delete(symbol_conf.sym_list); 2078 strlist__delete(symbol_conf.dso_list); 2079 strlist__delete(symbol_conf.comm_list); 2080 intlist__delete(symbol_conf.tid_list); 2081 intlist__delete(symbol_conf.pid_list); 2082 vmlinux_path__exit(); 2083 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL; 2084 symbol_conf.bt_stop_list = NULL; 2085 symbol_conf.initialized = false; 2086 } 2087 2088 int symbol__config_symfs(const struct option *opt __maybe_unused, 2089 const char *dir, int unset __maybe_unused) 2090 { 2091 char *bf = NULL; 2092 int ret; 2093 2094 symbol_conf.symfs = strdup(dir); 2095 if (symbol_conf.symfs == NULL) 2096 return -ENOMEM; 2097 2098 /* skip the locally configured cache if a symfs is given, and 2099 * config buildid dir to symfs/.debug 2100 */ 2101 ret = asprintf(&bf, "%s/%s", dir, ".debug"); 2102 if (ret < 0) 2103 return -ENOMEM; 2104 2105 set_buildid_dir(bf); 2106 2107 free(bf); 2108 return 0; 2109 } 2110