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