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 filename__read_build_id(dso->long_name, build_id, BUILD_ID_SIZE) > 0) 1465 dso__set_build_id(dso, build_id); 1466 1467 /* 1468 * Iterate over candidate debug images. 1469 * Keep track of "interesting" ones (those which have a symtab, dynsym, 1470 * and/or opd section) for processing. 1471 */ 1472 for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) { 1473 struct symsrc *ss = &ss_[ss_pos]; 1474 bool next_slot = false; 1475 1476 enum dso_binary_type symtab_type = binary_type_symtab[i]; 1477 1478 if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type)) 1479 continue; 1480 1481 if (dso__read_binary_type_filename(dso, symtab_type, 1482 root_dir, name, PATH_MAX)) 1483 continue; 1484 1485 if (!is_regular_file(name)) 1486 continue; 1487 1488 /* Name is now the name of the next image to try */ 1489 if (symsrc__init(ss, dso, name, symtab_type) < 0) 1490 continue; 1491 1492 if (!syms_ss && symsrc__has_symtab(ss)) { 1493 syms_ss = ss; 1494 next_slot = true; 1495 if (!dso->symsrc_filename) 1496 dso->symsrc_filename = strdup(name); 1497 } 1498 1499 if (!runtime_ss && symsrc__possibly_runtime(ss)) { 1500 runtime_ss = ss; 1501 next_slot = true; 1502 } 1503 1504 if (next_slot) { 1505 ss_pos++; 1506 1507 if (syms_ss && runtime_ss) 1508 break; 1509 } else { 1510 symsrc__destroy(ss); 1511 } 1512 1513 } 1514 1515 if (!runtime_ss && !syms_ss) 1516 goto out_free; 1517 1518 if (runtime_ss && !syms_ss) { 1519 syms_ss = runtime_ss; 1520 } 1521 1522 /* We'll have to hope for the best */ 1523 if (!runtime_ss && syms_ss) 1524 runtime_ss = syms_ss; 1525 1526 if (syms_ss && syms_ss->type == DSO_BINARY_TYPE__BUILD_ID_CACHE) 1527 if (dso__build_id_is_kmod(dso, name, PATH_MAX)) 1528 kmod = true; 1529 1530 if (syms_ss) 1531 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod); 1532 else 1533 ret = -1; 1534 1535 if (ret > 0) { 1536 int nr_plt; 1537 1538 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map); 1539 if (nr_plt > 0) 1540 ret += nr_plt; 1541 } 1542 1543 for (; ss_pos > 0; ss_pos--) 1544 symsrc__destroy(&ss_[ss_pos - 1]); 1545 out_free: 1546 free(name); 1547 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL) 1548 ret = 0; 1549 out: 1550 dso__set_loaded(dso, map->type); 1551 pthread_mutex_unlock(&dso->lock); 1552 1553 return ret; 1554 } 1555 1556 struct map *map_groups__find_by_name(struct map_groups *mg, 1557 enum map_type type, const char *name) 1558 { 1559 struct maps *maps = &mg->maps[type]; 1560 struct map *map; 1561 1562 pthread_rwlock_rdlock(&maps->lock); 1563 1564 for (map = maps__first(maps); map; map = map__next(map)) { 1565 if (map->dso && strcmp(map->dso->short_name, name) == 0) 1566 goto out_unlock; 1567 } 1568 1569 map = NULL; 1570 1571 out_unlock: 1572 pthread_rwlock_unlock(&maps->lock); 1573 return map; 1574 } 1575 1576 int dso__load_vmlinux(struct dso *dso, struct map *map, 1577 const char *vmlinux, bool vmlinux_allocated) 1578 { 1579 int err = -1; 1580 struct symsrc ss; 1581 char symfs_vmlinux[PATH_MAX]; 1582 enum dso_binary_type symtab_type; 1583 1584 if (vmlinux[0] == '/') 1585 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux); 1586 else 1587 symbol__join_symfs(symfs_vmlinux, vmlinux); 1588 1589 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1590 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 1591 else 1592 symtab_type = DSO_BINARY_TYPE__VMLINUX; 1593 1594 if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type)) 1595 return -1; 1596 1597 err = dso__load_sym(dso, map, &ss, &ss, 0); 1598 symsrc__destroy(&ss); 1599 1600 if (err > 0) { 1601 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1602 dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 1603 else 1604 dso->binary_type = DSO_BINARY_TYPE__VMLINUX; 1605 dso__set_long_name(dso, vmlinux, vmlinux_allocated); 1606 dso__set_loaded(dso, map->type); 1607 pr_debug("Using %s for symbols\n", symfs_vmlinux); 1608 } 1609 1610 return err; 1611 } 1612 1613 int dso__load_vmlinux_path(struct dso *dso, struct map *map) 1614 { 1615 int i, err = 0; 1616 char *filename = NULL; 1617 1618 pr_debug("Looking at the vmlinux_path (%d entries long)\n", 1619 vmlinux_path__nr_entries + 1); 1620 1621 for (i = 0; i < vmlinux_path__nr_entries; ++i) { 1622 err = dso__load_vmlinux(dso, map, vmlinux_path[i], false); 1623 if (err > 0) 1624 goto out; 1625 } 1626 1627 if (!symbol_conf.ignore_vmlinux_buildid) 1628 filename = dso__build_id_filename(dso, NULL, 0); 1629 if (filename != NULL) { 1630 err = dso__load_vmlinux(dso, map, filename, true); 1631 if (err > 0) 1632 goto out; 1633 free(filename); 1634 } 1635 out: 1636 return err; 1637 } 1638 1639 static bool visible_dir_filter(const char *name, struct dirent *d) 1640 { 1641 if (d->d_type != DT_DIR) 1642 return false; 1643 return lsdir_no_dot_filter(name, d); 1644 } 1645 1646 static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz) 1647 { 1648 char kallsyms_filename[PATH_MAX]; 1649 int ret = -1; 1650 struct strlist *dirs; 1651 struct str_node *nd; 1652 1653 dirs = lsdir(dir, visible_dir_filter); 1654 if (!dirs) 1655 return -1; 1656 1657 strlist__for_each_entry(nd, dirs) { 1658 scnprintf(kallsyms_filename, sizeof(kallsyms_filename), 1659 "%s/%s/kallsyms", dir, nd->s); 1660 if (!validate_kcore_addresses(kallsyms_filename, map)) { 1661 strlcpy(dir, kallsyms_filename, dir_sz); 1662 ret = 0; 1663 break; 1664 } 1665 } 1666 1667 strlist__delete(dirs); 1668 1669 return ret; 1670 } 1671 1672 /* 1673 * Use open(O_RDONLY) to check readability directly instead of access(R_OK) 1674 * since access(R_OK) only checks with real UID/GID but open() use effective 1675 * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO). 1676 */ 1677 static bool filename__readable(const char *file) 1678 { 1679 int fd = open(file, O_RDONLY); 1680 if (fd < 0) 1681 return false; 1682 close(fd); 1683 return true; 1684 } 1685 1686 static char *dso__find_kallsyms(struct dso *dso, struct map *map) 1687 { 1688 u8 host_build_id[BUILD_ID_SIZE]; 1689 char sbuild_id[SBUILD_ID_SIZE]; 1690 bool is_host = false; 1691 char path[PATH_MAX]; 1692 1693 if (!dso->has_build_id) { 1694 /* 1695 * Last resort, if we don't have a build-id and couldn't find 1696 * any vmlinux file, try the running kernel kallsyms table. 1697 */ 1698 goto proc_kallsyms; 1699 } 1700 1701 if (sysfs__read_build_id("/sys/kernel/notes", host_build_id, 1702 sizeof(host_build_id)) == 0) 1703 is_host = dso__build_id_equal(dso, host_build_id); 1704 1705 /* Try a fast path for /proc/kallsyms if possible */ 1706 if (is_host) { 1707 /* 1708 * Do not check the build-id cache, unless we know we cannot use 1709 * /proc/kcore or module maps don't match to /proc/kallsyms. 1710 * To check readability of /proc/kcore, do not use access(R_OK) 1711 * since /proc/kcore requires CAP_SYS_RAWIO to read and access 1712 * can't check it. 1713 */ 1714 if (filename__readable("/proc/kcore") && 1715 !validate_kcore_addresses("/proc/kallsyms", map)) 1716 goto proc_kallsyms; 1717 } 1718 1719 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id); 1720 1721 /* Find kallsyms in build-id cache with kcore */ 1722 scnprintf(path, sizeof(path), "%s/%s/%s", 1723 buildid_dir, DSO__NAME_KCORE, sbuild_id); 1724 1725 if (!find_matching_kcore(map, path, sizeof(path))) 1726 return strdup(path); 1727 1728 /* Use current /proc/kallsyms if possible */ 1729 if (is_host) { 1730 proc_kallsyms: 1731 return strdup("/proc/kallsyms"); 1732 } 1733 1734 /* Finally, find a cache of kallsyms */ 1735 if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) { 1736 pr_err("No kallsyms or vmlinux with build-id %s was found\n", 1737 sbuild_id); 1738 return NULL; 1739 } 1740 1741 return strdup(path); 1742 } 1743 1744 static int dso__load_kernel_sym(struct dso *dso, struct map *map) 1745 { 1746 int err; 1747 const char *kallsyms_filename = NULL; 1748 char *kallsyms_allocated_filename = NULL; 1749 /* 1750 * Step 1: if the user specified a kallsyms or vmlinux filename, use 1751 * it and only it, reporting errors to the user if it cannot be used. 1752 * 1753 * For instance, try to analyse an ARM perf.data file _without_ a 1754 * build-id, or if the user specifies the wrong path to the right 1755 * vmlinux file, obviously we can't fallback to another vmlinux (a 1756 * x86_86 one, on the machine where analysis is being performed, say), 1757 * or worse, /proc/kallsyms. 1758 * 1759 * If the specified file _has_ a build-id and there is a build-id 1760 * section in the perf.data file, we will still do the expected 1761 * validation in dso__load_vmlinux and will bail out if they don't 1762 * match. 1763 */ 1764 if (symbol_conf.kallsyms_name != NULL) { 1765 kallsyms_filename = symbol_conf.kallsyms_name; 1766 goto do_kallsyms; 1767 } 1768 1769 if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) { 1770 return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false); 1771 } 1772 1773 if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) { 1774 err = dso__load_vmlinux_path(dso, map); 1775 if (err > 0) 1776 return err; 1777 } 1778 1779 /* do not try local files if a symfs was given */ 1780 if (symbol_conf.symfs[0] != 0) 1781 return -1; 1782 1783 kallsyms_allocated_filename = dso__find_kallsyms(dso, map); 1784 if (!kallsyms_allocated_filename) 1785 return -1; 1786 1787 kallsyms_filename = kallsyms_allocated_filename; 1788 1789 do_kallsyms: 1790 err = dso__load_kallsyms(dso, kallsyms_filename, map); 1791 if (err > 0) 1792 pr_debug("Using %s for symbols\n", kallsyms_filename); 1793 free(kallsyms_allocated_filename); 1794 1795 if (err > 0 && !dso__is_kcore(dso)) { 1796 dso->binary_type = DSO_BINARY_TYPE__KALLSYMS; 1797 dso__set_long_name(dso, DSO__NAME_KALLSYMS, false); 1798 map__fixup_start(map); 1799 map__fixup_end(map); 1800 } 1801 1802 return err; 1803 } 1804 1805 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map) 1806 { 1807 int err; 1808 const char *kallsyms_filename = NULL; 1809 struct machine *machine; 1810 char path[PATH_MAX]; 1811 1812 if (!map->groups) { 1813 pr_debug("Guest kernel map hasn't the point to groups\n"); 1814 return -1; 1815 } 1816 machine = map->groups->machine; 1817 1818 if (machine__is_default_guest(machine)) { 1819 /* 1820 * if the user specified a vmlinux filename, use it and only 1821 * it, reporting errors to the user if it cannot be used. 1822 * Or use file guest_kallsyms inputted by user on commandline 1823 */ 1824 if (symbol_conf.default_guest_vmlinux_name != NULL) { 1825 err = dso__load_vmlinux(dso, map, 1826 symbol_conf.default_guest_vmlinux_name, 1827 false); 1828 return err; 1829 } 1830 1831 kallsyms_filename = symbol_conf.default_guest_kallsyms; 1832 if (!kallsyms_filename) 1833 return -1; 1834 } else { 1835 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 1836 kallsyms_filename = path; 1837 } 1838 1839 err = dso__load_kallsyms(dso, kallsyms_filename, map); 1840 if (err > 0) 1841 pr_debug("Using %s for symbols\n", kallsyms_filename); 1842 if (err > 0 && !dso__is_kcore(dso)) { 1843 dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 1844 machine__mmap_name(machine, path, sizeof(path)); 1845 dso__set_long_name(dso, strdup(path), true); 1846 map__fixup_start(map); 1847 map__fixup_end(map); 1848 } 1849 1850 return err; 1851 } 1852 1853 static void vmlinux_path__exit(void) 1854 { 1855 while (--vmlinux_path__nr_entries >= 0) 1856 zfree(&vmlinux_path[vmlinux_path__nr_entries]); 1857 vmlinux_path__nr_entries = 0; 1858 1859 zfree(&vmlinux_path); 1860 } 1861 1862 static const char * const vmlinux_paths[] = { 1863 "vmlinux", 1864 "/boot/vmlinux" 1865 }; 1866 1867 static const char * const vmlinux_paths_upd[] = { 1868 "/boot/vmlinux-%s", 1869 "/usr/lib/debug/boot/vmlinux-%s", 1870 "/lib/modules/%s/build/vmlinux", 1871 "/usr/lib/debug/lib/modules/%s/vmlinux", 1872 "/usr/lib/debug/boot/vmlinux-%s.debug" 1873 }; 1874 1875 static int vmlinux_path__add(const char *new_entry) 1876 { 1877 vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry); 1878 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 1879 return -1; 1880 ++vmlinux_path__nr_entries; 1881 1882 return 0; 1883 } 1884 1885 static int vmlinux_path__init(struct perf_env *env) 1886 { 1887 struct utsname uts; 1888 char bf[PATH_MAX]; 1889 char *kernel_version; 1890 unsigned int i; 1891 1892 vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) + 1893 ARRAY_SIZE(vmlinux_paths_upd))); 1894 if (vmlinux_path == NULL) 1895 return -1; 1896 1897 for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++) 1898 if (vmlinux_path__add(vmlinux_paths[i]) < 0) 1899 goto out_fail; 1900 1901 /* only try kernel version if no symfs was given */ 1902 if (symbol_conf.symfs[0] != 0) 1903 return 0; 1904 1905 if (env) { 1906 kernel_version = env->os_release; 1907 } else { 1908 if (uname(&uts) < 0) 1909 goto out_fail; 1910 1911 kernel_version = uts.release; 1912 } 1913 1914 for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) { 1915 snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version); 1916 if (vmlinux_path__add(bf) < 0) 1917 goto out_fail; 1918 } 1919 1920 return 0; 1921 1922 out_fail: 1923 vmlinux_path__exit(); 1924 return -1; 1925 } 1926 1927 int setup_list(struct strlist **list, const char *list_str, 1928 const char *list_name) 1929 { 1930 if (list_str == NULL) 1931 return 0; 1932 1933 *list = strlist__new(list_str, NULL); 1934 if (!*list) { 1935 pr_err("problems parsing %s list\n", list_name); 1936 return -1; 1937 } 1938 1939 symbol_conf.has_filter = true; 1940 return 0; 1941 } 1942 1943 int setup_intlist(struct intlist **list, const char *list_str, 1944 const char *list_name) 1945 { 1946 if (list_str == NULL) 1947 return 0; 1948 1949 *list = intlist__new(list_str); 1950 if (!*list) { 1951 pr_err("problems parsing %s list\n", list_name); 1952 return -1; 1953 } 1954 return 0; 1955 } 1956 1957 static bool symbol__read_kptr_restrict(void) 1958 { 1959 bool value = false; 1960 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r"); 1961 1962 if (fp != NULL) { 1963 char line[8]; 1964 1965 if (fgets(line, sizeof(line), fp) != NULL) 1966 value = ((geteuid() != 0) || (getuid() != 0)) ? 1967 (atoi(line) != 0) : 1968 (atoi(line) == 2); 1969 1970 fclose(fp); 1971 } 1972 1973 return value; 1974 } 1975 1976 int symbol__annotation_init(void) 1977 { 1978 if (symbol_conf.initialized) { 1979 pr_err("Annotation needs to be init before symbol__init()\n"); 1980 return -1; 1981 } 1982 1983 if (symbol_conf.init_annotation) { 1984 pr_warning("Annotation being initialized multiple times\n"); 1985 return 0; 1986 } 1987 1988 symbol_conf.priv_size += sizeof(struct annotation); 1989 symbol_conf.init_annotation = true; 1990 return 0; 1991 } 1992 1993 int symbol__init(struct perf_env *env) 1994 { 1995 const char *symfs; 1996 1997 if (symbol_conf.initialized) 1998 return 0; 1999 2000 symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64)); 2001 2002 symbol__elf_init(); 2003 2004 if (symbol_conf.sort_by_name) 2005 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) - 2006 sizeof(struct symbol)); 2007 2008 if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0) 2009 return -1; 2010 2011 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') { 2012 pr_err("'.' is the only non valid --field-separator argument\n"); 2013 return -1; 2014 } 2015 2016 if (setup_list(&symbol_conf.dso_list, 2017 symbol_conf.dso_list_str, "dso") < 0) 2018 return -1; 2019 2020 if (setup_list(&symbol_conf.comm_list, 2021 symbol_conf.comm_list_str, "comm") < 0) 2022 goto out_free_dso_list; 2023 2024 if (setup_intlist(&symbol_conf.pid_list, 2025 symbol_conf.pid_list_str, "pid") < 0) 2026 goto out_free_comm_list; 2027 2028 if (setup_intlist(&symbol_conf.tid_list, 2029 symbol_conf.tid_list_str, "tid") < 0) 2030 goto out_free_pid_list; 2031 2032 if (setup_list(&symbol_conf.sym_list, 2033 symbol_conf.sym_list_str, "symbol") < 0) 2034 goto out_free_tid_list; 2035 2036 if (setup_list(&symbol_conf.bt_stop_list, 2037 symbol_conf.bt_stop_list_str, "symbol") < 0) 2038 goto out_free_sym_list; 2039 2040 /* 2041 * A path to symbols of "/" is identical to "" 2042 * reset here for simplicity. 2043 */ 2044 symfs = realpath(symbol_conf.symfs, NULL); 2045 if (symfs == NULL) 2046 symfs = symbol_conf.symfs; 2047 if (strcmp(symfs, "/") == 0) 2048 symbol_conf.symfs = ""; 2049 if (symfs != symbol_conf.symfs) 2050 free((void *)symfs); 2051 2052 symbol_conf.kptr_restrict = symbol__read_kptr_restrict(); 2053 2054 symbol_conf.initialized = true; 2055 return 0; 2056 2057 out_free_sym_list: 2058 strlist__delete(symbol_conf.sym_list); 2059 out_free_tid_list: 2060 intlist__delete(symbol_conf.tid_list); 2061 out_free_pid_list: 2062 intlist__delete(symbol_conf.pid_list); 2063 out_free_comm_list: 2064 strlist__delete(symbol_conf.comm_list); 2065 out_free_dso_list: 2066 strlist__delete(symbol_conf.dso_list); 2067 return -1; 2068 } 2069 2070 void symbol__exit(void) 2071 { 2072 if (!symbol_conf.initialized) 2073 return; 2074 strlist__delete(symbol_conf.bt_stop_list); 2075 strlist__delete(symbol_conf.sym_list); 2076 strlist__delete(symbol_conf.dso_list); 2077 strlist__delete(symbol_conf.comm_list); 2078 intlist__delete(symbol_conf.tid_list); 2079 intlist__delete(symbol_conf.pid_list); 2080 vmlinux_path__exit(); 2081 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL; 2082 symbol_conf.bt_stop_list = NULL; 2083 symbol_conf.initialized = false; 2084 } 2085 2086 int symbol__config_symfs(const struct option *opt __maybe_unused, 2087 const char *dir, int unset __maybe_unused) 2088 { 2089 char *bf = NULL; 2090 int ret; 2091 2092 symbol_conf.symfs = strdup(dir); 2093 if (symbol_conf.symfs == NULL) 2094 return -ENOMEM; 2095 2096 /* skip the locally configured cache if a symfs is given, and 2097 * config buildid dir to symfs/.debug 2098 */ 2099 ret = asprintf(&bf, "%s/%s", dir, ".debug"); 2100 if (ret < 0) 2101 return -ENOMEM; 2102 2103 set_buildid_dir(bf); 2104 2105 free(bf); 2106 return 0; 2107 } 2108