1#define _GNU_SOURCE 2#include <ctype.h> 3#include <dirent.h> 4#include <errno.h> 5#include <libgen.h> 6#include <stdlib.h> 7#include <stdio.h> 8#include <string.h> 9#include <sys/types.h> 10#include <sys/stat.h> 11#include <sys/param.h> 12#include <fcntl.h> 13#include <unistd.h> 14#include <inttypes.h> 15#include "build-id.h" 16#include "debug.h" 17#include "symbol.h" 18#include "strlist.h" 19 20#include <libelf.h> 21#include <gelf.h> 22#include <elf.h> 23#include <limits.h> 24#include <sys/utsname.h> 25 26#ifndef KSYM_NAME_LEN 27#define KSYM_NAME_LEN 128 28#endif 29 30#ifndef NT_GNU_BUILD_ID 31#define NT_GNU_BUILD_ID 3 32#endif 33 34/* ANDROID_CHANGE_BEGIN */ 35#ifdef __BIONIC__ 36#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y)) 37#endif 38/* ANDROID_CHANGE_END */ 39 40static bool dso__build_id_equal(const struct dso *dso, u8 *build_id); 41static int elf_read_build_id(Elf *elf, void *bf, size_t size); 42static void dsos__add(struct list_head *head, struct dso *dso); 43static struct map *map__new2(u64 start, struct dso *dso, enum map_type type); 44static int dso__load_kernel_sym(struct dso *dso, struct map *map, 45 symbol_filter_t filter); 46static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map, 47 symbol_filter_t filter); 48static int vmlinux_path__nr_entries; 49static char **vmlinux_path; 50 51struct symbol_conf symbol_conf = { 52 .exclude_other = true, 53 .use_modules = true, 54 .try_vmlinux_path = true, 55 .symfs = "", 56}; 57 58int dso__name_len(const struct dso *dso) 59{ 60 if (verbose) 61 return dso->long_name_len; 62 63 return dso->short_name_len; 64} 65 66bool dso__loaded(const struct dso *dso, enum map_type type) 67{ 68 return dso->loaded & (1 << type); 69} 70 71bool dso__sorted_by_name(const struct dso *dso, enum map_type type) 72{ 73 return dso->sorted_by_name & (1 << type); 74} 75 76static void dso__set_sorted_by_name(struct dso *dso, enum map_type type) 77{ 78 dso->sorted_by_name |= (1 << type); 79} 80 81bool symbol_type__is_a(char symbol_type, enum map_type map_type) 82{ 83 switch (map_type) { 84 case MAP__FUNCTION: 85 return symbol_type == 'T' || symbol_type == 'W'; 86 case MAP__VARIABLE: 87 return symbol_type == 'D' || symbol_type == 'd'; 88 default: 89 return false; 90 } 91} 92 93static void symbols__fixup_end(struct rb_root *symbols) 94{ 95 struct rb_node *nd, *prevnd = rb_first(symbols); 96 struct symbol *curr, *prev; 97 98 if (prevnd == NULL) 99 return; 100 101 curr = rb_entry(prevnd, struct symbol, rb_node); 102 103 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 104 prev = curr; 105 curr = rb_entry(nd, struct symbol, rb_node); 106 107 if (prev->end == prev->start && prev->end != curr->start) 108 prev->end = curr->start - 1; 109 } 110 111 /* Last entry */ 112 if (curr->end == curr->start) 113 curr->end = roundup(curr->start, 4096); 114} 115 116static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type) 117{ 118 struct map *prev, *curr; 119 struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]); 120 121 if (prevnd == NULL) 122 return; 123 124 curr = rb_entry(prevnd, struct map, rb_node); 125 126 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 127 prev = curr; 128 curr = rb_entry(nd, struct map, rb_node); 129 prev->end = curr->start - 1; 130 } 131 132 /* 133 * We still haven't the actual symbols, so guess the 134 * last map final address. 135 */ 136 curr->end = ~0ULL; 137} 138 139static void map_groups__fixup_end(struct map_groups *mg) 140{ 141 int i; 142 for (i = 0; i < MAP__NR_TYPES; ++i) 143 __map_groups__fixup_end(mg, i); 144} 145 146static struct symbol *symbol__new(u64 start, u64 len, u8 binding, 147 const char *name) 148{ 149 size_t namelen = strlen(name) + 1; 150 struct symbol *sym = calloc(1, (symbol_conf.priv_size + 151 sizeof(*sym) + namelen)); 152 if (sym == NULL) 153 return NULL; 154 155 if (symbol_conf.priv_size) 156 sym = ((void *)sym) + symbol_conf.priv_size; 157 158 sym->start = start; 159 sym->end = len ? start + len - 1 : start; 160 sym->binding = binding; 161 sym->namelen = namelen - 1; 162 163 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n", 164 __func__, name, start, sym->end); 165 memcpy(sym->name, name, namelen); 166 167 return sym; 168} 169 170void symbol__delete(struct symbol *sym) 171{ 172 free(((void *)sym) - symbol_conf.priv_size); 173} 174 175static size_t symbol__fprintf(struct symbol *sym, FILE *fp) 176{ 177 return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n", 178 sym->start, sym->end, 179 sym->binding == STB_GLOBAL ? 'g' : 180 sym->binding == STB_LOCAL ? 'l' : 'w', 181 sym->name); 182} 183 184void dso__set_long_name(struct dso *dso, char *name) 185{ 186 if (name == NULL) 187 return; 188 dso->long_name = name; 189 dso->long_name_len = strlen(name); 190} 191 192static void dso__set_short_name(struct dso *dso, const char *name) 193{ 194 if (name == NULL) 195 return; 196 dso->short_name = name; 197 dso->short_name_len = strlen(name); 198} 199 200static void dso__set_basename(struct dso *dso) 201{ 202 dso__set_short_name(dso, basename(dso->long_name)); 203} 204 205struct dso *dso__new(const char *name) 206{ 207 struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1); 208 209 if (dso != NULL) { 210 int i; 211 strcpy(dso->name, name); 212 dso__set_long_name(dso, dso->name); 213 dso__set_short_name(dso, dso->name); 214 for (i = 0; i < MAP__NR_TYPES; ++i) 215 dso->symbols[i] = dso->symbol_names[i] = RB_ROOT; 216 dso->symtab_type = SYMTAB__NOT_FOUND; 217 dso->loaded = 0; 218 dso->sorted_by_name = 0; 219 dso->has_build_id = 0; 220 dso->kernel = DSO_TYPE_USER; 221 INIT_LIST_HEAD(&dso->node); 222 } 223 224 return dso; 225} 226 227static void symbols__delete(struct rb_root *symbols) 228{ 229 struct symbol *pos; 230 struct rb_node *next = rb_first(symbols); 231 232 while (next) { 233 pos = rb_entry(next, struct symbol, rb_node); 234 next = rb_next(&pos->rb_node); 235 rb_erase(&pos->rb_node, symbols); 236 symbol__delete(pos); 237 } 238} 239 240void dso__delete(struct dso *dso) 241{ 242 int i; 243 for (i = 0; i < MAP__NR_TYPES; ++i) 244 symbols__delete(&dso->symbols[i]); 245 if (dso->sname_alloc) 246 free((char *)dso->short_name); 247 if (dso->lname_alloc) 248 free(dso->long_name); 249 free(dso); 250} 251 252void dso__set_build_id(struct dso *dso, void *build_id) 253{ 254 memcpy(dso->build_id, build_id, sizeof(dso->build_id)); 255 dso->has_build_id = 1; 256} 257 258static void symbols__insert(struct rb_root *symbols, struct symbol *sym) 259{ 260 struct rb_node **p = &symbols->rb_node; 261 struct rb_node *parent = NULL; 262 const u64 ip = sym->start; 263 struct symbol *s; 264 265 while (*p != NULL) { 266 parent = *p; 267 s = rb_entry(parent, struct symbol, rb_node); 268 if (ip < s->start) 269 p = &(*p)->rb_left; 270 else 271 p = &(*p)->rb_right; 272 } 273 rb_link_node(&sym->rb_node, parent, p); 274 rb_insert_color(&sym->rb_node, symbols); 275} 276 277static struct symbol *symbols__find(struct rb_root *symbols, u64 ip) 278{ 279 struct rb_node *n; 280 281 if (symbols == NULL) 282 return NULL; 283 284 n = symbols->rb_node; 285 286 while (n) { 287 struct symbol *s = rb_entry(n, struct symbol, rb_node); 288 289 if (ip < s->start) 290 n = n->rb_left; 291 else if (ip > s->end) 292 n = n->rb_right; 293 else 294 return s; 295 } 296 297 return NULL; 298} 299 300struct symbol_name_rb_node { 301 struct rb_node rb_node; 302 struct symbol sym; 303}; 304 305static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym) 306{ 307 struct rb_node **p = &symbols->rb_node; 308 struct rb_node *parent = NULL; 309 struct symbol_name_rb_node *symn, *s; 310 311 symn = container_of(sym, struct symbol_name_rb_node, sym); 312 313 while (*p != NULL) { 314 parent = *p; 315 s = rb_entry(parent, struct symbol_name_rb_node, rb_node); 316 if (strcmp(sym->name, s->sym.name) < 0) 317 p = &(*p)->rb_left; 318 else 319 p = &(*p)->rb_right; 320 } 321 rb_link_node(&symn->rb_node, parent, p); 322 rb_insert_color(&symn->rb_node, symbols); 323} 324 325static void symbols__sort_by_name(struct rb_root *symbols, 326 struct rb_root *source) 327{ 328 struct rb_node *nd; 329 330 for (nd = rb_first(source); nd; nd = rb_next(nd)) { 331 struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 332 symbols__insert_by_name(symbols, pos); 333 } 334} 335 336static struct symbol *symbols__find_by_name(struct rb_root *symbols, 337 const char *name) 338{ 339 struct rb_node *n; 340 341 if (symbols == NULL) 342 return NULL; 343 344 n = symbols->rb_node; 345 346 while (n) { 347 struct symbol_name_rb_node *s; 348 int cmp; 349 350 s = rb_entry(n, struct symbol_name_rb_node, rb_node); 351 cmp = strcmp(name, s->sym.name); 352 353 if (cmp < 0) 354 n = n->rb_left; 355 else if (cmp > 0) 356 n = n->rb_right; 357 else 358 return &s->sym; 359 } 360 361 return NULL; 362} 363 364struct symbol *dso__find_symbol(struct dso *dso, 365 enum map_type type, u64 addr) 366{ 367 return symbols__find(&dso->symbols[type], addr); 368} 369 370struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type, 371 const char *name) 372{ 373 return symbols__find_by_name(&dso->symbol_names[type], name); 374} 375 376void dso__sort_by_name(struct dso *dso, enum map_type type) 377{ 378 dso__set_sorted_by_name(dso, type); 379 return symbols__sort_by_name(&dso->symbol_names[type], 380 &dso->symbols[type]); 381} 382 383int build_id__sprintf(const u8 *build_id, int len, char *bf) 384{ 385 char *bid = bf; 386 const u8 *raw = build_id; 387 int i; 388 389 for (i = 0; i < len; ++i) { 390 sprintf(bid, "%02x", *raw); 391 ++raw; 392 bid += 2; 393 } 394 395 return raw - build_id; 396} 397 398size_t dso__fprintf_buildid(struct dso *dso, FILE *fp) 399{ 400 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 401 402 build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id); 403 return fprintf(fp, "%s", sbuild_id); 404} 405 406size_t dso__fprintf_symbols_by_name(struct dso *dso, 407 enum map_type type, FILE *fp) 408{ 409 size_t ret = 0; 410 struct rb_node *nd; 411 struct symbol_name_rb_node *pos; 412 413 for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) { 414 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node); 415 fprintf(fp, "%s\n", pos->sym.name); 416 } 417 418 return ret; 419} 420 421size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp) 422{ 423 struct rb_node *nd; 424 size_t ret = fprintf(fp, "dso: %s (", dso->short_name); 425 426 if (dso->short_name != dso->long_name) 427 ret += fprintf(fp, "%s, ", dso->long_name); 428 ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type], 429 dso->loaded ? "" : "NOT "); 430 ret += dso__fprintf_buildid(dso, fp); 431 ret += fprintf(fp, ")\n"); 432 for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) { 433 struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 434 ret += symbol__fprintf(pos, fp); 435 } 436 437 return ret; 438} 439 440int kallsyms__parse(const char *filename, void *arg, 441 int (*process_symbol)(void *arg, const char *name, 442 char type, u64 start, u64 end)) 443{ 444 char *line = NULL; 445 size_t n; 446 int err = -1; 447 u64 prev_start = 0; 448 char prev_symbol_type = 0; 449 char *prev_symbol_name; 450 FILE *file = fopen(filename, "r"); 451 452 if (file == NULL) 453 goto out_failure; 454 455 prev_symbol_name = malloc(KSYM_NAME_LEN); 456 if (prev_symbol_name == NULL) 457 goto out_close; 458 459 err = 0; 460 461 while (!feof(file)) { 462 u64 start; 463 int line_len, len; 464 char symbol_type; 465 char *symbol_name; 466 467 line_len = getline(&line, &n, file); 468 if (line_len < 0 || !line) 469 break; 470 471 line[--line_len] = '\0'; /* \n */ 472 473 len = hex2u64(line, &start); 474 475 len++; 476 if (len + 2 >= line_len) 477 continue; 478 479 symbol_type = toupper(line[len]); 480 len += 2; 481 symbol_name = line + len; 482 len = line_len - len; 483 484 if (len >= KSYM_NAME_LEN) { 485 err = -1; 486 break; 487 } 488 489 if (prev_symbol_type) { 490 u64 end = start; 491 if (end != prev_start) 492 --end; 493 err = process_symbol(arg, prev_symbol_name, 494 prev_symbol_type, prev_start, end); 495 if (err) 496 break; 497 } 498 499 memcpy(prev_symbol_name, symbol_name, len + 1); 500 prev_symbol_type = symbol_type; 501 prev_start = start; 502 } 503 504 free(prev_symbol_name); 505 free(line); 506out_close: 507 fclose(file); 508 return err; 509 510out_failure: 511 return -1; 512} 513 514struct process_kallsyms_args { 515 struct map *map; 516 struct dso *dso; 517}; 518 519static u8 kallsyms2elf_type(char type) 520{ 521 if (type == 'W') 522 return STB_WEAK; 523 524 return isupper(type) ? STB_GLOBAL : STB_LOCAL; 525} 526 527static int map__process_kallsym_symbol(void *arg, const char *name, 528 char type, u64 start, u64 end) 529{ 530 struct symbol *sym; 531 struct process_kallsyms_args *a = arg; 532 struct rb_root *root = &a->dso->symbols[a->map->type]; 533 534 if (!symbol_type__is_a(type, a->map->type)) 535 return 0; 536 537 sym = symbol__new(start, end - start + 1, 538 kallsyms2elf_type(type), name); 539 if (sym == NULL) 540 return -ENOMEM; 541 /* 542 * We will pass the symbols to the filter later, in 543 * map__split_kallsyms, when we have split the maps per module 544 */ 545 symbols__insert(root, sym); 546 547 return 0; 548} 549 550/* 551 * Loads the function entries in /proc/kallsyms into kernel_map->dso, 552 * so that we can in the next step set the symbol ->end address and then 553 * call kernel_maps__split_kallsyms. 554 */ 555static int dso__load_all_kallsyms(struct dso *dso, const char *filename, 556 struct map *map) 557{ 558 struct process_kallsyms_args args = { .map = map, .dso = dso, }; 559 return kallsyms__parse(filename, &args, map__process_kallsym_symbol); 560} 561 562/* 563 * Split the symbols into maps, making sure there are no overlaps, i.e. the 564 * kernel range is broken in several maps, named [kernel].N, as we don't have 565 * the original ELF section names vmlinux have. 566 */ 567static int dso__split_kallsyms(struct dso *dso, struct map *map, 568 symbol_filter_t filter) 569{ 570 struct map_groups *kmaps = map__kmap(map)->kmaps; 571 struct machine *machine = kmaps->machine; 572 struct map *curr_map = map; 573 struct symbol *pos; 574 int count = 0, moved = 0; 575 struct rb_root *root = &dso->symbols[map->type]; 576 struct rb_node *next = rb_first(root); 577 int kernel_range = 0; 578 579 while (next) { 580 char *module; 581 582 pos = rb_entry(next, struct symbol, rb_node); 583 next = rb_next(&pos->rb_node); 584 585 module = strchr(pos->name, '\t'); 586 if (module) { 587 if (!symbol_conf.use_modules) 588 goto discard_symbol; 589 590 *module++ = '\0'; 591 592 if (strcmp(curr_map->dso->short_name, module)) { 593 if (curr_map != map && 594 dso->kernel == DSO_TYPE_GUEST_KERNEL && 595 machine__is_default_guest(machine)) { 596 /* 597 * We assume all symbols of a module are 598 * continuous in * kallsyms, so curr_map 599 * points to a module and all its 600 * symbols are in its kmap. Mark it as 601 * loaded. 602 */ 603 dso__set_loaded(curr_map->dso, 604 curr_map->type); 605 } 606 607 curr_map = map_groups__find_by_name(kmaps, 608 map->type, module); 609 if (curr_map == NULL) { 610 pr_debug("%s/proc/{kallsyms,modules} " 611 "inconsistency while looking " 612 "for \"%s\" module!\n", 613 machine->root_dir, module); 614 curr_map = map; 615 goto discard_symbol; 616 } 617 618 if (curr_map->dso->loaded && 619 !machine__is_default_guest(machine)) 620 goto discard_symbol; 621 } 622 /* 623 * So that we look just like we get from .ko files, 624 * i.e. not prelinked, relative to map->start. 625 */ 626 pos->start = curr_map->map_ip(curr_map, pos->start); 627 pos->end = curr_map->map_ip(curr_map, pos->end); 628 } else if (curr_map != map) { 629 char dso_name[PATH_MAX]; 630 struct dso *ndso; 631 632 if (count == 0) { 633 curr_map = map; 634 goto filter_symbol; 635 } 636 637 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 638 snprintf(dso_name, sizeof(dso_name), 639 "[guest.kernel].%d", 640 kernel_range++); 641 else 642 snprintf(dso_name, sizeof(dso_name), 643 "[kernel].%d", 644 kernel_range++); 645 646 ndso = dso__new(dso_name); 647 if (ndso == NULL) 648 return -1; 649 650 ndso->kernel = dso->kernel; 651 652 curr_map = map__new2(pos->start, ndso, map->type); 653 if (curr_map == NULL) { 654 dso__delete(ndso); 655 return -1; 656 } 657 658 curr_map->map_ip = curr_map->unmap_ip = identity__map_ip; 659 map_groups__insert(kmaps, curr_map); 660 ++kernel_range; 661 } 662filter_symbol: 663 if (filter && filter(curr_map, pos)) { 664discard_symbol: rb_erase(&pos->rb_node, root); 665 symbol__delete(pos); 666 } else { 667 if (curr_map != map) { 668 rb_erase(&pos->rb_node, root); 669 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos); 670 ++moved; 671 } else 672 ++count; 673 } 674 } 675 676 if (curr_map != map && 677 dso->kernel == DSO_TYPE_GUEST_KERNEL && 678 machine__is_default_guest(kmaps->machine)) { 679 dso__set_loaded(curr_map->dso, curr_map->type); 680 } 681 682 return count + moved; 683} 684 685static bool symbol__restricted_filename(const char *filename, 686 const char *restricted_filename) 687{ 688 bool restricted = false; 689 690 if (symbol_conf.kptr_restrict) { 691 char *r = realpath(filename, NULL); 692 693 if (r != NULL) { 694 restricted = strcmp(r, restricted_filename) == 0; 695 free(r); 696 return restricted; 697 } 698 } 699 700 return restricted; 701} 702 703int dso__load_kallsyms(struct dso *dso, const char *filename, 704 struct map *map, symbol_filter_t filter) 705{ 706 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 707 return -1; 708 709 if (dso__load_all_kallsyms(dso, filename, map) < 0) 710 return -1; 711 712 if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 713 dso->symtab_type = SYMTAB__GUEST_KALLSYMS; 714 else 715 dso->symtab_type = SYMTAB__KALLSYMS; 716 717 return dso__split_kallsyms(dso, map, filter); 718} 719 720static int dso__load_perf_map(struct dso *dso, struct map *map, 721 symbol_filter_t filter) 722{ 723 char *line = NULL; 724 size_t n; 725 FILE *file; 726 int nr_syms = 0; 727 728 file = fopen(dso->long_name, "r"); 729 if (file == NULL) 730 goto out_failure; 731 732 while (!feof(file)) { 733 u64 start, size; 734 struct symbol *sym; 735 int line_len, len; 736 737 line_len = getline(&line, &n, file); 738 if (line_len < 0) 739 break; 740 741 if (!line) 742 goto out_failure; 743 744 line[--line_len] = '\0'; /* \n */ 745 746 len = hex2u64(line, &start); 747 748 len++; 749 if (len + 2 >= line_len) 750 continue; 751 752 len += hex2u64(line + len, &size); 753 754 len++; 755 if (len + 2 >= line_len) 756 continue; 757 758 sym = symbol__new(start, size, STB_GLOBAL, line + len); 759 760 if (sym == NULL) 761 goto out_delete_line; 762 763 if (filter && filter(map, sym)) 764 symbol__delete(sym); 765 else { 766 symbols__insert(&dso->symbols[map->type], sym); 767 nr_syms++; 768 } 769 } 770 771 free(line); 772 fclose(file); 773 774 return nr_syms; 775 776out_delete_line: 777 free(line); 778out_failure: 779 return -1; 780} 781 782/** 783 * elf_symtab__for_each_symbol - iterate thru all the symbols 784 * 785 * @syms: struct elf_symtab instance to iterate 786 * @idx: uint32_t idx 787 * @sym: GElf_Sym iterator 788 */ 789#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \ 790 for (idx = 0, gelf_getsym(syms, idx, &sym);\ 791 idx < nr_syms; \ 792 idx++, gelf_getsym(syms, idx, &sym)) 793 794static inline uint8_t elf_sym__type(const GElf_Sym *sym) 795{ 796 return GELF_ST_TYPE(sym->st_info); 797} 798 799static inline int elf_sym__is_function(const GElf_Sym *sym) 800{ 801 return elf_sym__type(sym) == STT_FUNC && 802 sym->st_name != 0 && 803 sym->st_shndx != SHN_UNDEF; 804} 805 806static inline bool elf_sym__is_object(const GElf_Sym *sym) 807{ 808 return elf_sym__type(sym) == STT_OBJECT && 809 sym->st_name != 0 && 810 sym->st_shndx != SHN_UNDEF; 811} 812 813static inline int elf_sym__is_label(const GElf_Sym *sym) 814{ 815 return elf_sym__type(sym) == STT_NOTYPE && 816 sym->st_name != 0 && 817 sym->st_shndx != SHN_UNDEF && 818 sym->st_shndx != SHN_ABS; 819} 820 821static inline const char *elf_sec__name(const GElf_Shdr *shdr, 822 const Elf_Data *secstrs) 823{ 824 return secstrs->d_buf + shdr->sh_name; 825} 826 827static inline int elf_sec__is_text(const GElf_Shdr *shdr, 828 const Elf_Data *secstrs) 829{ 830 return strstr(elf_sec__name(shdr, secstrs), "text") != NULL; 831} 832 833static inline bool elf_sec__is_data(const GElf_Shdr *shdr, 834 const Elf_Data *secstrs) 835{ 836 return strstr(elf_sec__name(shdr, secstrs), "data") != NULL; 837} 838 839static inline const char *elf_sym__name(const GElf_Sym *sym, 840 const Elf_Data *symstrs) 841{ 842 return symstrs->d_buf + sym->st_name; 843} 844 845static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep, 846 GElf_Shdr *shp, const char *name, 847 size_t *idx) 848{ 849 Elf_Scn *sec = NULL; 850 size_t cnt = 1; 851 852 while ((sec = elf_nextscn(elf, sec)) != NULL) { 853 char *str; 854 855 gelf_getshdr(sec, shp); 856 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name); 857 if (!strcmp(name, str)) { 858 if (idx) 859 *idx = cnt; 860 break; 861 } 862 ++cnt; 863 } 864 865 return sec; 866} 867 868#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \ 869 for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \ 870 idx < nr_entries; \ 871 ++idx, pos = gelf_getrel(reldata, idx, &pos_mem)) 872 873#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \ 874 for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \ 875 idx < nr_entries; \ 876 ++idx, pos = gelf_getrela(reldata, idx, &pos_mem)) 877 878/* 879 * We need to check if we have a .dynsym, so that we can handle the 880 * .plt, synthesizing its symbols, that aren't on the symtabs (be it 881 * .dynsym or .symtab). 882 * And always look at the original dso, not at debuginfo packages, that 883 * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS). 884 */ 885static int dso__synthesize_plt_symbols(struct dso *dso, struct map *map, 886 symbol_filter_t filter) 887{ 888 uint32_t nr_rel_entries, idx; 889 GElf_Sym sym; 890 u64 plt_offset; 891 GElf_Shdr shdr_plt; 892 struct symbol *f; 893 GElf_Shdr shdr_rel_plt, shdr_dynsym; 894 Elf_Data *reldata, *syms, *symstrs; 895 Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym; 896 size_t dynsym_idx; 897 GElf_Ehdr ehdr; 898 char sympltname[1024]; 899 Elf *elf; 900 int nr = 0, symidx, fd, err = 0; 901 char name[PATH_MAX]; 902 903 snprintf(name, sizeof(name), "%s%s", 904 symbol_conf.symfs, dso->long_name); 905 fd = open(name, O_RDONLY); 906 if (fd < 0) 907 goto out; 908 909 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 910 if (elf == NULL) 911 goto out_close; 912 913 if (gelf_getehdr(elf, &ehdr) == NULL) 914 goto out_elf_end; 915 916 scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym, 917 ".dynsym", &dynsym_idx); 918 if (scn_dynsym == NULL) 919 goto out_elf_end; 920 921 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt, 922 ".rela.plt", NULL); 923 if (scn_plt_rel == NULL) { 924 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt, 925 ".rel.plt", NULL); 926 if (scn_plt_rel == NULL) 927 goto out_elf_end; 928 } 929 930 err = -1; 931 932 if (shdr_rel_plt.sh_link != dynsym_idx) 933 goto out_elf_end; 934 935 if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL) 936 goto out_elf_end; 937 938 /* 939 * Fetch the relocation section to find the idxes to the GOT 940 * and the symbols in the .dynsym they refer to. 941 */ 942 reldata = elf_getdata(scn_plt_rel, NULL); 943 if (reldata == NULL) 944 goto out_elf_end; 945 946 syms = elf_getdata(scn_dynsym, NULL); 947 if (syms == NULL) 948 goto out_elf_end; 949 950 scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link); 951 if (scn_symstrs == NULL) 952 goto out_elf_end; 953 954 symstrs = elf_getdata(scn_symstrs, NULL); 955 if (symstrs == NULL) 956 goto out_elf_end; 957 958 nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize; 959 plt_offset = shdr_plt.sh_offset; 960 961 if (shdr_rel_plt.sh_type == SHT_RELA) { 962 GElf_Rela pos_mem, *pos; 963 964 elf_section__for_each_rela(reldata, pos, pos_mem, idx, 965 nr_rel_entries) { 966 symidx = GELF_R_SYM(pos->r_info); 967 plt_offset += shdr_plt.sh_entsize; 968 gelf_getsym(syms, symidx, &sym); 969 snprintf(sympltname, sizeof(sympltname), 970 "%s@plt", elf_sym__name(&sym, symstrs)); 971 972 f = symbol__new(plt_offset, shdr_plt.sh_entsize, 973 STB_GLOBAL, sympltname); 974 if (!f) 975 goto out_elf_end; 976 977 if (filter && filter(map, f)) 978 symbol__delete(f); 979 else { 980 symbols__insert(&dso->symbols[map->type], f); 981 ++nr; 982 } 983 } 984 } else if (shdr_rel_plt.sh_type == SHT_REL) { 985 GElf_Rel pos_mem, *pos; 986 elf_section__for_each_rel(reldata, pos, pos_mem, idx, 987 nr_rel_entries) { 988 symidx = GELF_R_SYM(pos->r_info); 989 plt_offset += shdr_plt.sh_entsize; 990 gelf_getsym(syms, symidx, &sym); 991 snprintf(sympltname, sizeof(sympltname), 992 "%s@plt", elf_sym__name(&sym, symstrs)); 993 994 f = symbol__new(plt_offset, shdr_plt.sh_entsize, 995 STB_GLOBAL, sympltname); 996 if (!f) 997 goto out_elf_end; 998 999 if (filter && filter(map, f)) 1000 symbol__delete(f); 1001 else { 1002 symbols__insert(&dso->symbols[map->type], f); 1003 ++nr; 1004 } 1005 } 1006 } 1007 1008 err = 0; 1009out_elf_end: 1010 elf_end(elf); 1011out_close: 1012 close(fd); 1013 1014 if (err == 0) 1015 return nr; 1016out: 1017 pr_debug("%s: problems reading %s PLT info.\n", 1018 __func__, dso->long_name); 1019 return 0; 1020} 1021 1022static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type) 1023{ 1024 switch (type) { 1025 case MAP__FUNCTION: 1026 return elf_sym__is_function(sym); 1027 case MAP__VARIABLE: 1028 return elf_sym__is_object(sym); 1029 default: 1030 return false; 1031 } 1032} 1033 1034static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs, 1035 enum map_type type) 1036{ 1037 switch (type) { 1038 case MAP__FUNCTION: 1039 return elf_sec__is_text(shdr, secstrs); 1040 case MAP__VARIABLE: 1041 return elf_sec__is_data(shdr, secstrs); 1042 default: 1043 return false; 1044 } 1045} 1046 1047static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr) 1048{ 1049 Elf_Scn *sec = NULL; 1050 GElf_Shdr shdr; 1051 size_t cnt = 1; 1052 1053 while ((sec = elf_nextscn(elf, sec)) != NULL) { 1054 gelf_getshdr(sec, &shdr); 1055 1056 if ((addr >= shdr.sh_addr) && 1057 (addr < (shdr.sh_addr + shdr.sh_size))) 1058 return cnt; 1059 1060 ++cnt; 1061 } 1062 1063 return -1; 1064} 1065 1066static int dso__load_sym(struct dso *dso, struct map *map, const char *name, 1067 int fd, symbol_filter_t filter, int kmodule, 1068 int want_symtab) 1069{ 1070 struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL; 1071 struct map *curr_map = map; 1072 struct dso *curr_dso = dso; 1073 Elf_Data *symstrs, *secstrs; 1074 uint32_t nr_syms; 1075 int err = -1; 1076 uint32_t idx; 1077 GElf_Ehdr ehdr; 1078 GElf_Shdr shdr, opdshdr; 1079 Elf_Data *syms, *opddata = NULL; 1080 GElf_Sym sym; 1081 Elf_Scn *sec, *sec_strndx, *opdsec; 1082 Elf *elf; 1083 int nr = 0; 1084 size_t opdidx = 0; 1085 1086 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 1087 if (elf == NULL) { 1088 pr_debug("%s: cannot read %s ELF file.\n", __func__, name); 1089 goto out_close; 1090 } 1091 1092 if (gelf_getehdr(elf, &ehdr) == NULL) { 1093 pr_debug("%s: cannot get elf header.\n", __func__); 1094 goto out_elf_end; 1095 } 1096 1097 /* Always reject images with a mismatched build-id: */ 1098 if (dso->has_build_id) { 1099 u8 build_id[BUILD_ID_SIZE]; 1100 1101 if (elf_read_build_id(elf, build_id, 1102 BUILD_ID_SIZE) != BUILD_ID_SIZE) 1103 goto out_elf_end; 1104 1105 if (!dso__build_id_equal(dso, build_id)) 1106 goto out_elf_end; 1107 } 1108 1109 sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL); 1110 if (sec == NULL) { 1111 if (want_symtab) 1112 goto out_elf_end; 1113 1114 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL); 1115 if (sec == NULL) 1116 goto out_elf_end; 1117 } 1118 1119 opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx); 1120 if (opdshdr.sh_type != SHT_PROGBITS) 1121 opdsec = NULL; 1122 if (opdsec) 1123 opddata = elf_rawdata(opdsec, NULL); 1124 1125 syms = elf_getdata(sec, NULL); 1126 if (syms == NULL) 1127 goto out_elf_end; 1128 1129 sec = elf_getscn(elf, shdr.sh_link); 1130 if (sec == NULL) 1131 goto out_elf_end; 1132 1133 symstrs = elf_getdata(sec, NULL); 1134 if (symstrs == NULL) 1135 goto out_elf_end; 1136 1137 sec_strndx = elf_getscn(elf, ehdr.e_shstrndx); 1138 if (sec_strndx == NULL) 1139 goto out_elf_end; 1140 1141 secstrs = elf_getdata(sec_strndx, NULL); 1142 if (secstrs == NULL) 1143 goto out_elf_end; 1144 1145 nr_syms = shdr.sh_size / shdr.sh_entsize; 1146 1147 memset(&sym, 0, sizeof(sym)); 1148 if (dso->kernel == DSO_TYPE_USER) { 1149 dso->adjust_symbols = (ehdr.e_type == ET_EXEC || 1150 elf_section_by_name(elf, &ehdr, &shdr, 1151 ".gnu.prelink_undo", 1152 NULL) != NULL); 1153 } else { 1154 dso->adjust_symbols = 0; 1155 } 1156 elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) { 1157 struct symbol *f; 1158 const char *elf_name = elf_sym__name(&sym, symstrs); 1159 char *demangled = NULL; 1160 int is_label = elf_sym__is_label(&sym); 1161 const char *section_name; 1162 1163 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name && 1164 strcmp(elf_name, kmap->ref_reloc_sym->name) == 0) 1165 kmap->ref_reloc_sym->unrelocated_addr = sym.st_value; 1166 1167 if (!is_label && !elf_sym__is_a(&sym, map->type)) 1168 continue; 1169 1170 /* Reject ARM ELF "mapping symbols": these aren't unique and 1171 * don't identify functions, so will confuse the profile 1172 * output: */ 1173 if (ehdr.e_machine == EM_ARM) { 1174 if (!strcmp(elf_name, "$a") || 1175 !strcmp(elf_name, "$d") || 1176 !strcmp(elf_name, "$t")) 1177 continue; 1178 } 1179 1180 if (opdsec && sym.st_shndx == opdidx) { 1181 u32 offset = sym.st_value - opdshdr.sh_addr; 1182 u64 *opd = opddata->d_buf + offset; 1183 sym.st_value = *opd; 1184 sym.st_shndx = elf_addr_to_index(elf, sym.st_value); 1185 } 1186 1187 sec = elf_getscn(elf, sym.st_shndx); 1188 if (!sec) 1189 goto out_elf_end; 1190 1191 gelf_getshdr(sec, &shdr); 1192 1193 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type)) 1194 continue; 1195 1196 section_name = elf_sec__name(&shdr, secstrs); 1197 1198 /* On ARM, symbols for thumb functions have 1 added to 1199 * the symbol address as a flag - remove it */ 1200 if ((ehdr.e_machine == EM_ARM) && 1201 (map->type == MAP__FUNCTION) && 1202 (sym.st_value & 1)) 1203 --sym.st_value; 1204 1205 if (dso->kernel != DSO_TYPE_USER || kmodule) { 1206 char dso_name[PATH_MAX]; 1207 1208 if (strcmp(section_name, 1209 (curr_dso->short_name + 1210 dso->short_name_len)) == 0) 1211 goto new_symbol; 1212 1213 if (strcmp(section_name, ".text") == 0) { 1214 curr_map = map; 1215 curr_dso = dso; 1216 goto new_symbol; 1217 } 1218 1219 snprintf(dso_name, sizeof(dso_name), 1220 "%s%s", dso->short_name, section_name); 1221 1222 curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name); 1223 if (curr_map == NULL) { 1224 u64 start = sym.st_value; 1225 1226 if (kmodule) 1227 start += map->start + shdr.sh_offset; 1228 1229 curr_dso = dso__new(dso_name); 1230 if (curr_dso == NULL) 1231 goto out_elf_end; 1232 curr_dso->kernel = dso->kernel; 1233 curr_dso->long_name = dso->long_name; 1234 curr_dso->long_name_len = dso->long_name_len; 1235 curr_map = map__new2(start, curr_dso, 1236 map->type); 1237 if (curr_map == NULL) { 1238 dso__delete(curr_dso); 1239 goto out_elf_end; 1240 } 1241 curr_map->map_ip = identity__map_ip; 1242 curr_map->unmap_ip = identity__map_ip; 1243 curr_dso->symtab_type = dso->symtab_type; 1244 map_groups__insert(kmap->kmaps, curr_map); 1245 dsos__add(&dso->node, curr_dso); 1246 dso__set_loaded(curr_dso, map->type); 1247 } else 1248 curr_dso = curr_map->dso; 1249 1250 goto new_symbol; 1251 } 1252 1253 if (curr_dso->adjust_symbols) { 1254 pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " " 1255 "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__, 1256 (u64)sym.st_value, (u64)shdr.sh_addr, 1257 (u64)shdr.sh_offset); 1258 sym.st_value -= shdr.sh_addr - shdr.sh_offset; 1259 } 1260 /* 1261 * We need to figure out if the object was created from C++ sources 1262 * DWARF DW_compile_unit has this, but we don't always have access 1263 * to it... 1264 */ 1265 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI); 1266 if (demangled != NULL) 1267 elf_name = demangled; 1268new_symbol: 1269 f = symbol__new(sym.st_value, sym.st_size, 1270 GELF_ST_BIND(sym.st_info), elf_name); 1271 free(demangled); 1272 if (!f) 1273 goto out_elf_end; 1274 1275 if (filter && filter(curr_map, f)) 1276 symbol__delete(f); 1277 else { 1278 symbols__insert(&curr_dso->symbols[curr_map->type], f); 1279 nr++; 1280 } 1281 } 1282 1283 /* 1284 * For misannotated, zeroed, ASM function sizes. 1285 */ 1286 if (nr > 0) { 1287 symbols__fixup_end(&dso->symbols[map->type]); 1288 if (kmap) { 1289 /* 1290 * We need to fixup this here too because we create new 1291 * maps here, for things like vsyscall sections. 1292 */ 1293 __map_groups__fixup_end(kmap->kmaps, map->type); 1294 } 1295 } 1296 err = nr; 1297out_elf_end: 1298 elf_end(elf); 1299out_close: 1300 return err; 1301} 1302 1303static bool dso__build_id_equal(const struct dso *dso, u8 *build_id) 1304{ 1305 return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0; 1306} 1307 1308bool __dsos__read_build_ids(struct list_head *head, bool with_hits) 1309{ 1310 bool have_build_id = false; 1311 struct dso *pos; 1312 1313 list_for_each_entry(pos, head, node) { 1314 if (with_hits && !pos->hit) 1315 continue; 1316 if (pos->has_build_id) { 1317 have_build_id = true; 1318 continue; 1319 } 1320 if (filename__read_build_id(pos->long_name, pos->build_id, 1321 sizeof(pos->build_id)) > 0) { 1322 have_build_id = true; 1323 pos->has_build_id = true; 1324 } 1325 } 1326 1327 return have_build_id; 1328} 1329 1330/* 1331 * Align offset to 4 bytes as needed for note name and descriptor data. 1332 */ 1333#define NOTE_ALIGN(n) (((n) + 3) & -4U) 1334 1335static int elf_read_build_id(Elf *elf, void *bf, size_t size) 1336{ 1337 int err = -1; 1338 GElf_Ehdr ehdr; 1339 GElf_Shdr shdr; 1340 Elf_Data *data; 1341 Elf_Scn *sec; 1342 Elf_Kind ek; 1343 void *ptr; 1344 1345 if (size < BUILD_ID_SIZE) 1346 goto out; 1347 1348 ek = elf_kind(elf); 1349 if (ek != ELF_K_ELF) 1350 goto out; 1351 1352 if (gelf_getehdr(elf, &ehdr) == NULL) { 1353 pr_err("%s: cannot get elf header.\n", __func__); 1354 goto out; 1355 } 1356 1357 sec = elf_section_by_name(elf, &ehdr, &shdr, 1358 ".note.gnu.build-id", NULL); 1359 if (sec == NULL) { 1360 sec = elf_section_by_name(elf, &ehdr, &shdr, 1361 ".notes", NULL); 1362 if (sec == NULL) 1363 goto out; 1364 } 1365 1366 data = elf_getdata(sec, NULL); 1367 if (data == NULL) 1368 goto out; 1369 1370 ptr = data->d_buf; 1371 while (ptr < (data->d_buf + data->d_size)) { 1372 GElf_Nhdr *nhdr = ptr; 1373 int namesz = NOTE_ALIGN(nhdr->n_namesz), 1374 descsz = NOTE_ALIGN(nhdr->n_descsz); 1375 const char *name; 1376 1377 ptr += sizeof(*nhdr); 1378 name = ptr; 1379 ptr += namesz; 1380 if (nhdr->n_type == NT_GNU_BUILD_ID && 1381 nhdr->n_namesz == sizeof("GNU")) { 1382 if (memcmp(name, "GNU", sizeof("GNU")) == 0) { 1383 memcpy(bf, ptr, BUILD_ID_SIZE); 1384 err = BUILD_ID_SIZE; 1385 break; 1386 } 1387 } 1388 ptr += descsz; 1389 } 1390 1391out: 1392 return err; 1393} 1394 1395int filename__read_build_id(const char *filename, void *bf, size_t size) 1396{ 1397 int fd, err = -1; 1398 Elf *elf; 1399 1400 if (size < BUILD_ID_SIZE) 1401 goto out; 1402 1403 fd = open(filename, O_RDONLY); 1404 if (fd < 0) 1405 goto out; 1406 1407 elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 1408 if (elf == NULL) { 1409 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename); 1410 goto out_close; 1411 } 1412 1413 err = elf_read_build_id(elf, bf, size); 1414 1415 elf_end(elf); 1416out_close: 1417 close(fd); 1418out: 1419 return err; 1420} 1421 1422int sysfs__read_build_id(const char *filename, void *build_id, size_t size) 1423{ 1424 int fd, err = -1; 1425 1426 if (size < BUILD_ID_SIZE) 1427 goto out; 1428 1429 fd = open(filename, O_RDONLY); 1430 if (fd < 0) 1431 goto out; 1432 1433 while (1) { 1434 char bf[BUFSIZ]; 1435 GElf_Nhdr nhdr; 1436 int namesz, descsz; 1437 1438 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr)) 1439 break; 1440 1441 namesz = NOTE_ALIGN(nhdr.n_namesz); 1442 descsz = NOTE_ALIGN(nhdr.n_descsz); 1443 if (nhdr.n_type == NT_GNU_BUILD_ID && 1444 nhdr.n_namesz == sizeof("GNU")) { 1445 if (read(fd, bf, namesz) != namesz) 1446 break; 1447 if (memcmp(bf, "GNU", sizeof("GNU")) == 0) { 1448 if (read(fd, build_id, 1449 BUILD_ID_SIZE) == BUILD_ID_SIZE) { 1450 err = 0; 1451 break; 1452 } 1453 } else if (read(fd, bf, descsz) != descsz) 1454 break; 1455 } else { 1456 int n = namesz + descsz; 1457 if (read(fd, bf, n) != n) 1458 break; 1459 } 1460 } 1461 close(fd); 1462out: 1463 return err; 1464} 1465 1466char dso__symtab_origin(const struct dso *dso) 1467{ 1468 static const char origin[] = { 1469 [SYMTAB__KALLSYMS] = 'k', 1470 [SYMTAB__JAVA_JIT] = 'j', 1471 [SYMTAB__BUILD_ID_CACHE] = 'B', 1472 [SYMTAB__FEDORA_DEBUGINFO] = 'f', 1473 [SYMTAB__UBUNTU_DEBUGINFO] = 'u', 1474 [SYMTAB__BUILDID_DEBUGINFO] = 'b', 1475 [SYMTAB__SYSTEM_PATH_DSO] = 'd', 1476 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K', 1477 [SYMTAB__GUEST_KALLSYMS] = 'g', 1478 [SYMTAB__GUEST_KMODULE] = 'G', 1479 }; 1480 1481 if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND) 1482 return '!'; 1483 return origin[dso->symtab_type]; 1484} 1485 1486int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter) 1487{ 1488 int size = PATH_MAX; 1489 char *name; 1490 int ret = -1; 1491 int fd; 1492 struct machine *machine; 1493 const char *root_dir; 1494 int want_symtab; 1495 1496 dso__set_loaded(dso, map->type); 1497 1498 if (dso->kernel == DSO_TYPE_KERNEL) 1499 return dso__load_kernel_sym(dso, map, filter); 1500 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL) 1501 return dso__load_guest_kernel_sym(dso, map, filter); 1502 1503 if (map->groups && map->groups->machine) 1504 machine = map->groups->machine; 1505 else 1506 machine = NULL; 1507 1508 name = malloc(size); 1509 if (!name) 1510 return -1; 1511 1512 dso->adjust_symbols = 0; 1513 1514 if (strncmp(dso->name, "/tmp/perf-", 10) == 0) { 1515 ret = dso__load_perf_map(dso, map, filter); 1516 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT : 1517 SYMTAB__NOT_FOUND; 1518 return ret; 1519 } 1520 1521 /* Iterate over candidate debug images. 1522 * On the first pass, only load images if they have a full symtab. 1523 * Failing that, do a second pass where we accept .dynsym also 1524 */ 1525 want_symtab = 1; 1526restart: 1527 for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE; 1528 dso->symtab_type != SYMTAB__NOT_FOUND; 1529 dso->symtab_type++) { 1530 switch (dso->symtab_type) { 1531 case SYMTAB__BUILD_ID_CACHE: 1532 /* skip the locally configured cache if a symfs is given */ 1533 if (symbol_conf.symfs[0] || 1534 (dso__build_id_filename(dso, name, size) == NULL)) { 1535 continue; 1536 } 1537 break; 1538 case SYMTAB__FEDORA_DEBUGINFO: 1539 snprintf(name, size, "%s/usr/lib/debug%s.debug", 1540 symbol_conf.symfs, dso->long_name); 1541 break; 1542 case SYMTAB__UBUNTU_DEBUGINFO: 1543 snprintf(name, size, "%s/usr/lib/debug%s", 1544 symbol_conf.symfs, dso->long_name); 1545 break; 1546 case SYMTAB__BUILDID_DEBUGINFO: { 1547 char build_id_hex[BUILD_ID_SIZE * 2 + 1]; 1548 1549 if (!dso->has_build_id) 1550 continue; 1551 1552 build_id__sprintf(dso->build_id, 1553 sizeof(dso->build_id), 1554 build_id_hex); 1555 snprintf(name, size, 1556 "%s/usr/lib/debug/.build-id/%.2s/%s.debug", 1557 symbol_conf.symfs, build_id_hex, build_id_hex + 2); 1558 } 1559 break; 1560 case SYMTAB__SYSTEM_PATH_DSO: 1561 snprintf(name, size, "%s%s", 1562 symbol_conf.symfs, dso->long_name); 1563 break; 1564 case SYMTAB__GUEST_KMODULE: 1565 if (map->groups && machine) 1566 root_dir = machine->root_dir; 1567 else 1568 root_dir = ""; 1569 snprintf(name, size, "%s%s%s", symbol_conf.symfs, 1570 root_dir, dso->long_name); 1571 break; 1572 1573 case SYMTAB__SYSTEM_PATH_KMODULE: 1574 snprintf(name, size, "%s%s", symbol_conf.symfs, 1575 dso->long_name); 1576 break; 1577 default:; 1578 } 1579 1580 /* Name is now the name of the next image to try */ 1581 fd = open(name, O_RDONLY); 1582 if (fd < 0) 1583 continue; 1584 1585 ret = dso__load_sym(dso, map, name, fd, filter, 0, 1586 want_symtab); 1587 close(fd); 1588 1589 /* 1590 * Some people seem to have debuginfo files _WITHOUT_ debug 1591 * info!?!? 1592 */ 1593 if (!ret) 1594 continue; 1595 1596 if (ret > 0) { 1597 int nr_plt = dso__synthesize_plt_symbols(dso, map, 1598 filter); 1599 if (nr_plt > 0) 1600 ret += nr_plt; 1601 break; 1602 } 1603 } 1604 1605 /* 1606 * If we wanted a full symtab but no image had one, 1607 * relax our requirements and repeat the search. 1608 */ 1609 if (ret <= 0 && want_symtab) { 1610 want_symtab = 0; 1611 goto restart; 1612 } 1613 1614 free(name); 1615 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL) 1616 return 0; 1617 return ret; 1618} 1619 1620struct map *map_groups__find_by_name(struct map_groups *mg, 1621 enum map_type type, const char *name) 1622{ 1623 struct rb_node *nd; 1624 1625 for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) { 1626 struct map *map = rb_entry(nd, struct map, rb_node); 1627 1628 if (map->dso && strcmp(map->dso->short_name, name) == 0) 1629 return map; 1630 } 1631 1632 return NULL; 1633} 1634 1635static int dso__kernel_module_get_build_id(struct dso *dso, 1636 const char *root_dir) 1637{ 1638 char filename[PATH_MAX]; 1639 /* 1640 * kernel module short names are of the form "[module]" and 1641 * we need just "module" here. 1642 */ 1643 const char *name = dso->short_name + 1; 1644 1645 snprintf(filename, sizeof(filename), 1646 "%s/sys/module/%.*s/notes/.note.gnu.build-id", 1647 root_dir, (int)strlen(name) - 1, name); 1648 1649 if (sysfs__read_build_id(filename, dso->build_id, 1650 sizeof(dso->build_id)) == 0) 1651 dso->has_build_id = true; 1652 1653 return 0; 1654} 1655 1656static int map_groups__set_modules_path_dir(struct map_groups *mg, 1657 const char *dir_name) 1658{ 1659 struct dirent *dent; 1660 DIR *dir = opendir(dir_name); 1661 int ret = 0; 1662 1663 if (!dir) { 1664 pr_debug("%s: cannot open %s dir\n", __func__, dir_name); 1665 return -1; 1666 } 1667 1668 while ((dent = readdir(dir)) != NULL) { 1669 char path[PATH_MAX]; 1670 struct stat st; 1671 1672 /*sshfs might return bad dent->d_type, so we have to stat*/ 1673 sprintf(path, "%s/%s", dir_name, dent->d_name); 1674 if (stat(path, &st)) 1675 continue; 1676 1677 if (S_ISDIR(st.st_mode)) { 1678 if (!strcmp(dent->d_name, ".") || 1679 !strcmp(dent->d_name, "..")) 1680 continue; 1681 1682 snprintf(path, sizeof(path), "%s/%s", 1683 dir_name, dent->d_name); 1684 ret = map_groups__set_modules_path_dir(mg, path); 1685 if (ret < 0) 1686 goto out; 1687 } else { 1688 char *dot = strrchr(dent->d_name, '.'), 1689 dso_name[PATH_MAX]; 1690 struct map *map; 1691 char *long_name; 1692 1693 if (dot == NULL || strcmp(dot, ".ko")) 1694 continue; 1695 snprintf(dso_name, sizeof(dso_name), "[%.*s]", 1696 (int)(dot - dent->d_name), dent->d_name); 1697 1698 strxfrchar(dso_name, '-', '_'); 1699 map = map_groups__find_by_name(mg, MAP__FUNCTION, 1700 dso_name); 1701 if (map == NULL) 1702 continue; 1703 1704 snprintf(path, sizeof(path), "%s/%s", 1705 dir_name, dent->d_name); 1706 1707 long_name = strdup(path); 1708 if (long_name == NULL) { 1709 ret = -1; 1710 goto out; 1711 } 1712 dso__set_long_name(map->dso, long_name); 1713 map->dso->lname_alloc = 1; 1714 dso__kernel_module_get_build_id(map->dso, ""); 1715 } 1716 } 1717 1718out: 1719 closedir(dir); 1720 return ret; 1721} 1722 1723static char *get_kernel_version(const char *root_dir) 1724{ 1725 char version[PATH_MAX]; 1726 FILE *file; 1727 char *name, *tmp; 1728 const char *prefix = "Linux version "; 1729 1730 sprintf(version, "%s/proc/version", root_dir); 1731 file = fopen(version, "r"); 1732 if (!file) 1733 return NULL; 1734 1735 version[0] = '\0'; 1736 tmp = fgets(version, sizeof(version), file); 1737 fclose(file); 1738 1739 name = strstr(version, prefix); 1740 if (!name) 1741 return NULL; 1742 name += strlen(prefix); 1743 tmp = strchr(name, ' '); 1744 if (tmp) 1745 *tmp = '\0'; 1746 1747 return strdup(name); 1748} 1749 1750static int machine__set_modules_path(struct machine *machine) 1751{ 1752 char *version; 1753 char modules_path[PATH_MAX]; 1754 1755 version = get_kernel_version(machine->root_dir); 1756 if (!version) 1757 return -1; 1758 1759 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel", 1760 machine->root_dir, version); 1761 free(version); 1762 1763 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path); 1764} 1765 1766/* 1767 * Constructor variant for modules (where we know from /proc/modules where 1768 * they are loaded) and for vmlinux, where only after we load all the 1769 * symbols we'll know where it starts and ends. 1770 */ 1771static struct map *map__new2(u64 start, struct dso *dso, enum map_type type) 1772{ 1773 struct map *map = calloc(1, (sizeof(*map) + 1774 (dso->kernel ? sizeof(struct kmap) : 0))); 1775 if (map != NULL) { 1776 /* 1777 * ->end will be filled after we load all the symbols 1778 */ 1779 map__init(map, type, start, 0, 0, dso); 1780 } 1781 1782 return map; 1783} 1784 1785struct map *machine__new_module(struct machine *machine, u64 start, 1786 const char *filename) 1787{ 1788 struct map *map; 1789 struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename); 1790 1791 if (dso == NULL) 1792 return NULL; 1793 1794 map = map__new2(start, dso, MAP__FUNCTION); 1795 if (map == NULL) 1796 return NULL; 1797 1798 if (machine__is_host(machine)) 1799 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE; 1800 else 1801 dso->symtab_type = SYMTAB__GUEST_KMODULE; 1802 map_groups__insert(&machine->kmaps, map); 1803 return map; 1804} 1805 1806static int machine__create_modules(struct machine *machine) 1807{ 1808 char *line = NULL; 1809 size_t n; 1810 FILE *file; 1811 struct map *map; 1812 const char *modules; 1813 char path[PATH_MAX]; 1814 1815 if (machine__is_default_guest(machine)) 1816 modules = symbol_conf.default_guest_modules; 1817 else { 1818 sprintf(path, "%s/proc/modules", machine->root_dir); 1819 modules = path; 1820 } 1821 1822 if (symbol__restricted_filename(path, "/proc/modules")) 1823 return -1; 1824 1825 file = fopen(modules, "r"); 1826 if (file == NULL) 1827 return -1; 1828 1829 while (!feof(file)) { 1830 char name[PATH_MAX]; 1831 u64 start; 1832 char *sep; 1833 int line_len; 1834 1835 line_len = getline(&line, &n, file); 1836 if (line_len < 0) 1837 break; 1838 1839 if (!line) 1840 goto out_failure; 1841 1842 line[--line_len] = '\0'; /* \n */ 1843 1844 sep = strrchr(line, 'x'); 1845 if (sep == NULL) 1846 continue; 1847 1848 hex2u64(sep + 1, &start); 1849 1850 sep = strchr(line, ' '); 1851 if (sep == NULL) 1852 continue; 1853 1854 *sep = '\0'; 1855 1856 snprintf(name, sizeof(name), "[%s]", line); 1857 map = machine__new_module(machine, start, name); 1858 if (map == NULL) 1859 goto out_delete_line; 1860 dso__kernel_module_get_build_id(map->dso, machine->root_dir); 1861 } 1862 1863 free(line); 1864 fclose(file); 1865 1866 return machine__set_modules_path(machine); 1867 1868out_delete_line: 1869 free(line); 1870out_failure: 1871 return -1; 1872} 1873 1874int dso__load_vmlinux(struct dso *dso, struct map *map, 1875 const char *vmlinux, symbol_filter_t filter) 1876{ 1877 int err = -1, fd; 1878 char symfs_vmlinux[PATH_MAX]; 1879 1880 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s", 1881 symbol_conf.symfs, vmlinux); 1882 fd = open(symfs_vmlinux, O_RDONLY); 1883 if (fd < 0) 1884 return -1; 1885 1886 dso__set_long_name(dso, (char *)vmlinux); 1887 dso__set_loaded(dso, map->type); 1888 err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0); 1889 close(fd); 1890 1891 if (err > 0) 1892 pr_debug("Using %s for symbols\n", symfs_vmlinux); 1893 1894 return err; 1895} 1896 1897int dso__load_vmlinux_path(struct dso *dso, struct map *map, 1898 symbol_filter_t filter) 1899{ 1900 int i, err = 0; 1901 char *filename; 1902 1903 pr_debug("Looking at the vmlinux_path (%d entries long)\n", 1904 vmlinux_path__nr_entries + 1); 1905 1906 filename = dso__build_id_filename(dso, NULL, 0); 1907 if (filename != NULL) { 1908 err = dso__load_vmlinux(dso, map, filename, filter); 1909 if (err > 0) { 1910 dso__set_long_name(dso, filename); 1911 goto out; 1912 } 1913 free(filename); 1914 } 1915 1916 for (i = 0; i < vmlinux_path__nr_entries; ++i) { 1917 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter); 1918 if (err > 0) { 1919 dso__set_long_name(dso, strdup(vmlinux_path[i])); 1920 break; 1921 } 1922 } 1923out: 1924 return err; 1925} 1926 1927static int dso__load_kernel_sym(struct dso *dso, struct map *map, 1928 symbol_filter_t filter) 1929{ 1930 int err; 1931 const char *kallsyms_filename = NULL; 1932 char *kallsyms_allocated_filename = NULL; 1933 /* 1934 * Step 1: if the user specified a kallsyms or vmlinux filename, use 1935 * it and only it, reporting errors to the user if it cannot be used. 1936 * 1937 * For instance, try to analyse an ARM perf.data file _without_ a 1938 * build-id, or if the user specifies the wrong path to the right 1939 * vmlinux file, obviously we can't fallback to another vmlinux (a 1940 * x86_86 one, on the machine where analysis is being performed, say), 1941 * or worse, /proc/kallsyms. 1942 * 1943 * If the specified file _has_ a build-id and there is a build-id 1944 * section in the perf.data file, we will still do the expected 1945 * validation in dso__load_vmlinux and will bail out if they don't 1946 * match. 1947 */ 1948 if (symbol_conf.kallsyms_name != NULL) { 1949 kallsyms_filename = symbol_conf.kallsyms_name; 1950 goto do_kallsyms; 1951 } 1952 1953 if (symbol_conf.vmlinux_name != NULL) { 1954 err = dso__load_vmlinux(dso, map, 1955 symbol_conf.vmlinux_name, filter); 1956 if (err > 0) { 1957 dso__set_long_name(dso, 1958 strdup(symbol_conf.vmlinux_name)); 1959 goto out_fixup; 1960 } 1961 return err; 1962 } 1963 1964 if (vmlinux_path != NULL) { 1965 err = dso__load_vmlinux_path(dso, map, filter); 1966 if (err > 0) 1967 goto out_fixup; 1968 } 1969 1970 /* do not try local files if a symfs was given */ 1971 if (symbol_conf.symfs[0] != 0) 1972 return -1; 1973 1974 /* 1975 * Say the kernel DSO was created when processing the build-id header table, 1976 * we have a build-id, so check if it is the same as the running kernel, 1977 * using it if it is. 1978 */ 1979 if (dso->has_build_id) { 1980 u8 kallsyms_build_id[BUILD_ID_SIZE]; 1981 char sbuild_id[BUILD_ID_SIZE * 2 + 1]; 1982 1983 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id, 1984 sizeof(kallsyms_build_id)) == 0) { 1985 if (dso__build_id_equal(dso, kallsyms_build_id)) { 1986 kallsyms_filename = "/proc/kallsyms"; 1987 goto do_kallsyms; 1988 } 1989 } 1990 /* 1991 * Now look if we have it on the build-id cache in 1992 * $HOME/.debug/[kernel.kallsyms]. 1993 */ 1994 build_id__sprintf(dso->build_id, sizeof(dso->build_id), 1995 sbuild_id); 1996 1997 if (asprintf(&kallsyms_allocated_filename, 1998 "%s/.debug/[kernel.kallsyms]/%s", 1999 getenv("HOME"), sbuild_id) == -1) { 2000 pr_err("Not enough memory for kallsyms file lookup\n"); 2001 return -1; 2002 } 2003 2004 kallsyms_filename = kallsyms_allocated_filename; 2005 2006 if (access(kallsyms_filename, F_OK)) { 2007 pr_err("No kallsyms or vmlinux with build-id %s " 2008 "was found\n", sbuild_id); 2009 free(kallsyms_allocated_filename); 2010 return -1; 2011 } 2012 } else { 2013 /* 2014 * Last resort, if we don't have a build-id and couldn't find 2015 * any vmlinux file, try the running kernel kallsyms table. 2016 */ 2017 kallsyms_filename = "/proc/kallsyms"; 2018 } 2019 2020do_kallsyms: 2021 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter); 2022 if (err > 0) 2023 pr_debug("Using %s for symbols\n", kallsyms_filename); 2024 free(kallsyms_allocated_filename); 2025 2026 if (err > 0) { 2027out_fixup: 2028 if (kallsyms_filename != NULL) 2029 dso__set_long_name(dso, strdup("[kernel.kallsyms]")); 2030 map__fixup_start(map); 2031 map__fixup_end(map); 2032 } 2033 2034 return err; 2035} 2036 2037static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map, 2038 symbol_filter_t filter) 2039{ 2040 int err; 2041 const char *kallsyms_filename = NULL; 2042 struct machine *machine; 2043 char path[PATH_MAX]; 2044 2045 if (!map->groups) { 2046 pr_debug("Guest kernel map hasn't the point to groups\n"); 2047 return -1; 2048 } 2049 machine = map->groups->machine; 2050 2051 if (machine__is_default_guest(machine)) { 2052 /* 2053 * if the user specified a vmlinux filename, use it and only 2054 * it, reporting errors to the user if it cannot be used. 2055 * Or use file guest_kallsyms inputted by user on commandline 2056 */ 2057 if (symbol_conf.default_guest_vmlinux_name != NULL) { 2058 err = dso__load_vmlinux(dso, map, 2059 symbol_conf.default_guest_vmlinux_name, filter); 2060 goto out_try_fixup; 2061 } 2062 2063 kallsyms_filename = symbol_conf.default_guest_kallsyms; 2064 if (!kallsyms_filename) 2065 return -1; 2066 } else { 2067 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 2068 kallsyms_filename = path; 2069 } 2070 2071 err = dso__load_kallsyms(dso, kallsyms_filename, map, filter); 2072 if (err > 0) 2073 pr_debug("Using %s for symbols\n", kallsyms_filename); 2074 2075out_try_fixup: 2076 if (err > 0) { 2077 if (kallsyms_filename != NULL) { 2078 machine__mmap_name(machine, path, sizeof(path)); 2079 dso__set_long_name(dso, strdup(path)); 2080 } 2081 map__fixup_start(map); 2082 map__fixup_end(map); 2083 } 2084 2085 return err; 2086} 2087 2088static void dsos__add(struct list_head *head, struct dso *dso) 2089{ 2090 list_add_tail(&dso->node, head); 2091} 2092 2093static struct dso *dsos__find(struct list_head *head, const char *name) 2094{ 2095 struct dso *pos; 2096 2097 list_for_each_entry(pos, head, node) 2098 if (strcmp(pos->long_name, name) == 0) 2099 return pos; 2100 return NULL; 2101} 2102 2103struct dso *__dsos__findnew(struct list_head *head, const char *name) 2104{ 2105 struct dso *dso = dsos__find(head, name); 2106 2107 if (!dso) { 2108 dso = dso__new(name); 2109 if (dso != NULL) { 2110 dsos__add(head, dso); 2111 dso__set_basename(dso); 2112 } 2113 } 2114 2115 return dso; 2116} 2117 2118size_t __dsos__fprintf(struct list_head *head, FILE *fp) 2119{ 2120 struct dso *pos; 2121 size_t ret = 0; 2122 2123 list_for_each_entry(pos, head, node) { 2124 int i; 2125 for (i = 0; i < MAP__NR_TYPES; ++i) 2126 ret += dso__fprintf(pos, i, fp); 2127 } 2128 2129 return ret; 2130} 2131 2132size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp) 2133{ 2134 struct rb_node *nd; 2135 size_t ret = 0; 2136 2137 for (nd = rb_first(machines); nd; nd = rb_next(nd)) { 2138 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2139 ret += __dsos__fprintf(&pos->kernel_dsos, fp); 2140 ret += __dsos__fprintf(&pos->user_dsos, fp); 2141 } 2142 2143 return ret; 2144} 2145 2146static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp, 2147 bool with_hits) 2148{ 2149 struct dso *pos; 2150 size_t ret = 0; 2151 2152 list_for_each_entry(pos, head, node) { 2153 if (with_hits && !pos->hit) 2154 continue; 2155 ret += dso__fprintf_buildid(pos, fp); 2156 ret += fprintf(fp, " %s\n", pos->long_name); 2157 } 2158 return ret; 2159} 2160 2161size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp, 2162 bool with_hits) 2163{ 2164 return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) + 2165 __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits); 2166} 2167 2168size_t machines__fprintf_dsos_buildid(struct rb_root *machines, 2169 FILE *fp, bool with_hits) 2170{ 2171 struct rb_node *nd; 2172 size_t ret = 0; 2173 2174 for (nd = rb_first(machines); nd; nd = rb_next(nd)) { 2175 struct machine *pos = rb_entry(nd, struct machine, rb_node); 2176 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits); 2177 } 2178 return ret; 2179} 2180 2181struct dso *dso__new_kernel(const char *name) 2182{ 2183 struct dso *dso = dso__new(name ?: "[kernel.kallsyms]"); 2184 2185 if (dso != NULL) { 2186 dso__set_short_name(dso, "[kernel]"); 2187 dso->kernel = DSO_TYPE_KERNEL; 2188 } 2189 2190 return dso; 2191} 2192 2193static struct dso *dso__new_guest_kernel(struct machine *machine, 2194 const char *name) 2195{ 2196 char bf[PATH_MAX]; 2197 struct dso *dso = dso__new(name ?: machine__mmap_name(machine, bf, 2198 sizeof(bf))); 2199 if (dso != NULL) { 2200 dso__set_short_name(dso, "[guest.kernel]"); 2201 dso->kernel = DSO_TYPE_GUEST_KERNEL; 2202 } 2203 2204 return dso; 2205} 2206 2207void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine) 2208{ 2209 char path[PATH_MAX]; 2210 2211 if (machine__is_default_guest(machine)) 2212 return; 2213 sprintf(path, "%s/sys/kernel/notes", machine->root_dir); 2214 if (sysfs__read_build_id(path, dso->build_id, 2215 sizeof(dso->build_id)) == 0) 2216 dso->has_build_id = true; 2217} 2218 2219static struct dso *machine__create_kernel(struct machine *machine) 2220{ 2221 const char *vmlinux_name = NULL; 2222 struct dso *kernel; 2223 2224 if (machine__is_host(machine)) { 2225 vmlinux_name = symbol_conf.vmlinux_name; 2226 kernel = dso__new_kernel(vmlinux_name); 2227 } else { 2228 if (machine__is_default_guest(machine)) 2229 vmlinux_name = symbol_conf.default_guest_vmlinux_name; 2230 kernel = dso__new_guest_kernel(machine, vmlinux_name); 2231 } 2232 2233 if (kernel != NULL) { 2234 dso__read_running_kernel_build_id(kernel, machine); 2235 dsos__add(&machine->kernel_dsos, kernel); 2236 } 2237 return kernel; 2238} 2239 2240struct process_args { 2241 u64 start; 2242}; 2243 2244static int symbol__in_kernel(void *arg, const char *name, 2245 char type __used, u64 start, u64 end __used) 2246{ 2247 struct process_args *args = arg; 2248 2249 if (strchr(name, '[')) 2250 return 0; 2251 2252 args->start = start; 2253 return 1; 2254} 2255 2256/* Figure out the start address of kernel map from /proc/kallsyms */ 2257static u64 machine__get_kernel_start_addr(struct machine *machine) 2258{ 2259 const char *filename; 2260 char path[PATH_MAX]; 2261 struct process_args args = {0LL}; 2262 2263 if (machine__is_host(machine)) { 2264 filename = "/proc/kallsyms"; 2265 } else { 2266 if (machine__is_default_guest(machine)) 2267 filename = (char *)symbol_conf.default_guest_kallsyms; 2268 else { 2269 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 2270 filename = path; 2271 } 2272 } 2273 2274 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 2275 return 0; 2276 2277 if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0) 2278 return 0; 2279 2280 return args.start; 2281} 2282 2283int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel) 2284{ 2285 enum map_type type; 2286 u64 start = machine__get_kernel_start_addr(machine); 2287 2288 for (type = 0; type < MAP__NR_TYPES; ++type) { 2289 struct kmap *kmap; 2290 2291 machine->vmlinux_maps[type] = map__new2(start, kernel, type); 2292 if (machine->vmlinux_maps[type] == NULL) 2293 return -1; 2294 2295 machine->vmlinux_maps[type]->map_ip = 2296 machine->vmlinux_maps[type]->unmap_ip = 2297 identity__map_ip; 2298 kmap = map__kmap(machine->vmlinux_maps[type]); 2299 kmap->kmaps = &machine->kmaps; 2300 map_groups__insert(&machine->kmaps, 2301 machine->vmlinux_maps[type]); 2302 } 2303 2304 return 0; 2305} 2306 2307void machine__destroy_kernel_maps(struct machine *machine) 2308{ 2309 enum map_type type; 2310 2311 for (type = 0; type < MAP__NR_TYPES; ++type) { 2312 struct kmap *kmap; 2313 2314 if (machine->vmlinux_maps[type] == NULL) 2315 continue; 2316 2317 kmap = map__kmap(machine->vmlinux_maps[type]); 2318 map_groups__remove(&machine->kmaps, 2319 machine->vmlinux_maps[type]); 2320 if (kmap->ref_reloc_sym) { 2321 /* 2322 * ref_reloc_sym is shared among all maps, so free just 2323 * on one of them. 2324 */ 2325 if (type == MAP__FUNCTION) { 2326 free((char *)kmap->ref_reloc_sym->name); 2327 kmap->ref_reloc_sym->name = NULL; 2328 free(kmap->ref_reloc_sym); 2329 } 2330 kmap->ref_reloc_sym = NULL; 2331 } 2332 2333 map__delete(machine->vmlinux_maps[type]); 2334 machine->vmlinux_maps[type] = NULL; 2335 } 2336} 2337 2338int machine__create_kernel_maps(struct machine *machine) 2339{ 2340 struct dso *kernel = machine__create_kernel(machine); 2341 2342 if (kernel == NULL || 2343 __machine__create_kernel_maps(machine, kernel) < 0) 2344 return -1; 2345 2346 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) 2347 pr_debug("Problems creating module maps, continuing anyway...\n"); 2348 /* 2349 * Now that we have all the maps created, just set the ->end of them: 2350 */ 2351 map_groups__fixup_end(&machine->kmaps); 2352 return 0; 2353} 2354 2355static void vmlinux_path__exit(void) 2356{ 2357 while (--vmlinux_path__nr_entries >= 0) { 2358 free(vmlinux_path[vmlinux_path__nr_entries]); 2359 vmlinux_path[vmlinux_path__nr_entries] = NULL; 2360 } 2361 2362 free(vmlinux_path); 2363 vmlinux_path = NULL; 2364} 2365 2366static int vmlinux_path__init(void) 2367{ 2368 struct utsname uts; 2369 char bf[PATH_MAX]; 2370 2371 vmlinux_path = malloc(sizeof(char *) * 5); 2372 if (vmlinux_path == NULL) 2373 return -1; 2374 2375 vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux"); 2376 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2377 goto out_fail; 2378 ++vmlinux_path__nr_entries; 2379 vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux"); 2380 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2381 goto out_fail; 2382 ++vmlinux_path__nr_entries; 2383 2384 /* only try running kernel version if no symfs was given */ 2385 if (symbol_conf.symfs[0] != 0) 2386 return 0; 2387 2388 if (uname(&uts) < 0) 2389 return -1; 2390 2391 snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release); 2392 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf); 2393 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2394 goto out_fail; 2395 ++vmlinux_path__nr_entries; 2396 snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release); 2397 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf); 2398 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2399 goto out_fail; 2400 ++vmlinux_path__nr_entries; 2401 snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux", 2402 uts.release); 2403 vmlinux_path[vmlinux_path__nr_entries] = strdup(bf); 2404 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2405 goto out_fail; 2406 ++vmlinux_path__nr_entries; 2407 2408 return 0; 2409 2410out_fail: 2411 vmlinux_path__exit(); 2412 return -1; 2413} 2414 2415size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp) 2416{ 2417 int i; 2418 size_t printed = 0; 2419 struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso; 2420 2421 if (kdso->has_build_id) { 2422 char filename[PATH_MAX]; 2423 if (dso__build_id_filename(kdso, filename, sizeof(filename))) 2424 printed += fprintf(fp, "[0] %s\n", filename); 2425 } 2426 2427 for (i = 0; i < vmlinux_path__nr_entries; ++i) 2428 printed += fprintf(fp, "[%d] %s\n", 2429 i + kdso->has_build_id, vmlinux_path[i]); 2430 2431 return printed; 2432} 2433 2434static int setup_list(struct strlist **list, const char *list_str, 2435 const char *list_name) 2436{ 2437 if (list_str == NULL) 2438 return 0; 2439 2440 *list = strlist__new(true, list_str); 2441 if (!*list) { 2442 pr_err("problems parsing %s list\n", list_name); 2443 return -1; 2444 } 2445 return 0; 2446} 2447 2448static bool symbol__read_kptr_restrict(void) 2449{ 2450 bool value = false; 2451 2452 if (geteuid() != 0) { 2453 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r"); 2454 if (fp != NULL) { 2455 char line[8]; 2456 2457 if (fgets(line, sizeof(line), fp) != NULL) 2458 value = atoi(line) != 0; 2459 2460 fclose(fp); 2461 } 2462 } 2463 2464 return value; 2465} 2466 2467int symbol__init(void) 2468{ 2469 const char *symfs; 2470 2471 if (symbol_conf.initialized) 2472 return 0; 2473 2474 /* ANDROID_CHANGE_BEGIN */ 2475#if defined(__BIONIC__) || defined(__APPLE__) 2476 symbol_conf.priv_size = KERNEL_ALIGN(symbol_conf.priv_size, sizeof(u64)); 2477#else 2478 symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64)); 2479#endif 2480 /* ANDROID_CHANGE_END */ 2481 2482 elf_version(EV_CURRENT); 2483 if (symbol_conf.sort_by_name) 2484 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) - 2485 sizeof(struct symbol)); 2486 2487 if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0) 2488 return -1; 2489 2490 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') { 2491 pr_err("'.' is the only non valid --field-separator argument\n"); 2492 return -1; 2493 } 2494 2495 if (setup_list(&symbol_conf.dso_list, 2496 symbol_conf.dso_list_str, "dso") < 0) 2497 return -1; 2498 2499 if (setup_list(&symbol_conf.comm_list, 2500 symbol_conf.comm_list_str, "comm") < 0) 2501 goto out_free_dso_list; 2502 2503 if (setup_list(&symbol_conf.sym_list, 2504 symbol_conf.sym_list_str, "symbol") < 0) 2505 goto out_free_comm_list; 2506 2507 /* 2508 * A path to symbols of "/" is identical to "" 2509 * reset here for simplicity. 2510 */ 2511 symfs = realpath(symbol_conf.symfs, NULL); 2512 if (symfs == NULL) 2513 symfs = symbol_conf.symfs; 2514 if (strcmp(symfs, "/") == 0) 2515 symbol_conf.symfs = ""; 2516 if (symfs != symbol_conf.symfs) 2517 free((void *)symfs); 2518 2519 symbol_conf.kptr_restrict = symbol__read_kptr_restrict(); 2520 2521 symbol_conf.initialized = true; 2522 return 0; 2523 2524out_free_dso_list: 2525 strlist__delete(symbol_conf.dso_list); 2526out_free_comm_list: 2527 strlist__delete(symbol_conf.comm_list); 2528 return -1; 2529} 2530 2531void symbol__exit(void) 2532{ 2533 if (!symbol_conf.initialized) 2534 return; 2535 strlist__delete(symbol_conf.sym_list); 2536 strlist__delete(symbol_conf.dso_list); 2537 strlist__delete(symbol_conf.comm_list); 2538 vmlinux_path__exit(); 2539 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL; 2540 symbol_conf.initialized = false; 2541} 2542 2543int machines__create_kernel_maps(struct rb_root *machines, pid_t pid) 2544{ 2545 struct machine *machine = machines__findnew(machines, pid); 2546 2547 if (machine == NULL) 2548 return -1; 2549 2550 return machine__create_kernel_maps(machine); 2551} 2552 2553static int hex(char ch) 2554{ 2555 if ((ch >= '0') && (ch <= '9')) 2556 return ch - '0'; 2557 if ((ch >= 'a') && (ch <= 'f')) 2558 return ch - 'a' + 10; 2559 if ((ch >= 'A') && (ch <= 'F')) 2560 return ch - 'A' + 10; 2561 return -1; 2562} 2563 2564/* 2565 * While we find nice hex chars, build a long_val. 2566 * Return number of chars processed. 2567 */ 2568int hex2u64(const char *ptr, u64 *long_val) 2569{ 2570 const char *p = ptr; 2571 *long_val = 0; 2572 2573 while (*p) { 2574 const int hex_val = hex(*p); 2575 2576 if (hex_val < 0) 2577 break; 2578 2579 *long_val = (*long_val << 4) | hex_val; 2580 p++; 2581 } 2582 2583 return p - ptr; 2584} 2585 2586char *strxfrchar(char *s, char from, char to) 2587{ 2588 char *p = s; 2589 2590 while ((p = strchr(p, from)) != NULL) 2591 *p++ = to; 2592 2593 return s; 2594} 2595 2596int machines__create_guest_kernel_maps(struct rb_root *machines) 2597{ 2598 int ret = 0; 2599 struct dirent **namelist = NULL; 2600 int i, items = 0; 2601 char path[PATH_MAX]; 2602 pid_t pid; 2603 2604 if (symbol_conf.default_guest_vmlinux_name || 2605 symbol_conf.default_guest_modules || 2606 symbol_conf.default_guest_kallsyms) { 2607 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID); 2608 } 2609 2610 if (symbol_conf.guestmount) { 2611 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL); 2612 if (items <= 0) 2613 return -ENOENT; 2614 for (i = 0; i < items; i++) { 2615 if (!isdigit(namelist[i]->d_name[0])) { 2616 /* Filter out . and .. */ 2617 continue; 2618 } 2619 pid = atoi(namelist[i]->d_name); 2620 sprintf(path, "%s/%s/proc/kallsyms", 2621 symbol_conf.guestmount, 2622 namelist[i]->d_name); 2623 ret = access(path, R_OK); 2624 if (ret) { 2625 pr_debug("Can't access file %s\n", path); 2626 goto failure; 2627 } 2628 machines__create_kernel_maps(machines, pid); 2629 } 2630failure: 2631 free(namelist); 2632 } 2633 2634 return ret; 2635} 2636 2637void machines__destroy_guest_kernel_maps(struct rb_root *machines) 2638{ 2639 struct rb_node *next = rb_first(machines); 2640 2641 while (next) { 2642 struct machine *pos = rb_entry(next, struct machine, rb_node); 2643 2644 next = rb_next(&pos->rb_node); 2645 rb_erase(&pos->rb_node, machines); 2646 machine__delete(pos); 2647 } 2648} 2649 2650int machine__load_kallsyms(struct machine *machine, const char *filename, 2651 enum map_type type, symbol_filter_t filter) 2652{ 2653 struct map *map = machine->vmlinux_maps[type]; 2654 int ret = dso__load_kallsyms(map->dso, filename, map, filter); 2655 2656 if (ret > 0) { 2657 dso__set_loaded(map->dso, type); 2658 /* 2659 * Since /proc/kallsyms will have multiple sessions for the 2660 * kernel, with modules between them, fixup the end of all 2661 * sections. 2662 */ 2663 __map_groups__fixup_end(&machine->kmaps, type); 2664 } 2665 2666 return ret; 2667} 2668 2669int machine__load_vmlinux_path(struct machine *machine, enum map_type type, 2670 symbol_filter_t filter) 2671{ 2672 struct map *map = machine->vmlinux_maps[type]; 2673 int ret = dso__load_vmlinux_path(map->dso, map, filter); 2674 2675 if (ret > 0) { 2676 dso__set_loaded(map->dso, type); 2677 map__reloc_vmlinux(map); 2678 } 2679 2680 return ret; 2681} 2682