1// SPDX-License-Identifier: GPL-2.0 2#include <dirent.h> 3#include <errno.h> 4#include <stdlib.h> 5#include <stdio.h> 6#include <string.h> 7#include <linux/capability.h> 8#include <linux/kernel.h> 9#include <linux/mman.h> 10#include <linux/string.h> 11#include <linux/time64.h> 12#include <sys/types.h> 13#include <sys/stat.h> 14#include <sys/param.h> 15#include <fcntl.h> 16#include <unistd.h> 17#include <inttypes.h> 18#include "annotate.h" 19#include "build-id.h" 20#include "cap.h" 21#include "dso.h" 22#include "util.h" // lsdir() 23#include "debug.h" 24#include "event.h" 25#include "machine.h" 26#include "map.h" 27#include "symbol.h" 28#include "map_symbol.h" 29#include "mem-events.h" 30#include "symsrc.h" 31#include "strlist.h" 32#include "intlist.h" 33#include "namespaces.h" 34#include "header.h" 35#include "path.h" 36#include <linux/ctype.h> 37#include <linux/zalloc.h> 38 39#include <elf.h> 40#include <limits.h> 41#include <symbol/kallsyms.h> 42#include <sys/utsname.h> 43 44static int dso__load_kernel_sym(struct dso *dso, struct map *map); 45static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map); 46static bool symbol__is_idle(const char *name); 47 48int vmlinux_path__nr_entries; 49char **vmlinux_path; 50 51struct symbol_conf symbol_conf = { 52 .nanosecs = false, 53 .use_modules = true, 54 .try_vmlinux_path = true, 55 .demangle = true, 56 .demangle_kernel = false, 57 .cumulate_callchain = true, 58 .time_quantum = 100 * NSEC_PER_MSEC, /* 100ms */ 59 .show_hist_headers = true, 60 .symfs = "", 61 .event_group = true, 62 .inline_name = true, 63 .res_sample = 0, 64}; 65 66struct map_list_node { 67 struct list_head node; 68 struct map *map; 69}; 70 71static struct map_list_node *map_list_node__new(void) 72{ 73 return malloc(sizeof(struct map_list_node)); 74} 75 76static enum dso_binary_type binary_type_symtab[] = { 77 DSO_BINARY_TYPE__KALLSYMS, 78 DSO_BINARY_TYPE__GUEST_KALLSYMS, 79 DSO_BINARY_TYPE__JAVA_JIT, 80 DSO_BINARY_TYPE__DEBUGLINK, 81 DSO_BINARY_TYPE__BUILD_ID_CACHE, 82 DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO, 83 DSO_BINARY_TYPE__FEDORA_DEBUGINFO, 84 DSO_BINARY_TYPE__UBUNTU_DEBUGINFO, 85 DSO_BINARY_TYPE__BUILDID_DEBUGINFO, 86 DSO_BINARY_TYPE__SYSTEM_PATH_DSO, 87 DSO_BINARY_TYPE__GUEST_KMODULE, 88 DSO_BINARY_TYPE__GUEST_KMODULE_COMP, 89 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE, 90 DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP, 91 DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO, 92 DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO, 93 DSO_BINARY_TYPE__NOT_FOUND, 94}; 95 96#define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab) 97 98static bool symbol_type__filter(char symbol_type) 99{ 100 symbol_type = toupper(symbol_type); 101 return symbol_type == 'T' || symbol_type == 'W' || symbol_type == 'D' || symbol_type == 'B'; 102} 103 104static int prefix_underscores_count(const char *str) 105{ 106 const char *tail = str; 107 108 while (*tail == '_') 109 tail++; 110 111 return tail - str; 112} 113 114const char * __weak arch__normalize_symbol_name(const char *name) 115{ 116 return name; 117} 118 119int __weak arch__compare_symbol_names(const char *namea, const char *nameb) 120{ 121 return strcmp(namea, nameb); 122} 123 124int __weak arch__compare_symbol_names_n(const char *namea, const char *nameb, 125 unsigned int n) 126{ 127 return strncmp(namea, nameb, n); 128} 129 130int __weak arch__choose_best_symbol(struct symbol *syma, 131 struct symbol *symb __maybe_unused) 132{ 133 /* Avoid "SyS" kernel syscall aliases */ 134 if (strlen(syma->name) >= 3 && !strncmp(syma->name, "SyS", 3)) 135 return SYMBOL_B; 136 if (strlen(syma->name) >= 10 && !strncmp(syma->name, "compat_SyS", 10)) 137 return SYMBOL_B; 138 139 return SYMBOL_A; 140} 141 142static int choose_best_symbol(struct symbol *syma, struct symbol *symb) 143{ 144 s64 a; 145 s64 b; 146 size_t na, nb; 147 148 /* Prefer a symbol with non zero length */ 149 a = syma->end - syma->start; 150 b = symb->end - symb->start; 151 if ((b == 0) && (a > 0)) 152 return SYMBOL_A; 153 else if ((a == 0) && (b > 0)) 154 return SYMBOL_B; 155 156 /* Prefer a non weak symbol over a weak one */ 157 a = syma->binding == STB_WEAK; 158 b = symb->binding == STB_WEAK; 159 if (b && !a) 160 return SYMBOL_A; 161 if (a && !b) 162 return SYMBOL_B; 163 164 /* Prefer a global symbol over a non global one */ 165 a = syma->binding == STB_GLOBAL; 166 b = symb->binding == STB_GLOBAL; 167 if (a && !b) 168 return SYMBOL_A; 169 if (b && !a) 170 return SYMBOL_B; 171 172 /* Prefer a symbol with less underscores */ 173 a = prefix_underscores_count(syma->name); 174 b = prefix_underscores_count(symb->name); 175 if (b > a) 176 return SYMBOL_A; 177 else if (a > b) 178 return SYMBOL_B; 179 180 /* Choose the symbol with the longest name */ 181 na = strlen(syma->name); 182 nb = strlen(symb->name); 183 if (na > nb) 184 return SYMBOL_A; 185 else if (na < nb) 186 return SYMBOL_B; 187 188 return arch__choose_best_symbol(syma, symb); 189} 190 191void symbols__fixup_duplicate(struct rb_root_cached *symbols) 192{ 193 struct rb_node *nd; 194 struct symbol *curr, *next; 195 196 if (symbol_conf.allow_aliases) 197 return; 198 199 nd = rb_first_cached(symbols); 200 201 while (nd) { 202 curr = rb_entry(nd, struct symbol, rb_node); 203again: 204 nd = rb_next(&curr->rb_node); 205 if (!nd) 206 break; 207 208 next = rb_entry(nd, struct symbol, rb_node); 209 if (curr->start != next->start) 210 continue; 211 212 if (choose_best_symbol(curr, next) == SYMBOL_A) { 213 if (next->type == STT_GNU_IFUNC) 214 curr->ifunc_alias = true; 215 rb_erase_cached(&next->rb_node, symbols); 216 symbol__delete(next); 217 goto again; 218 } else { 219 if (curr->type == STT_GNU_IFUNC) 220 next->ifunc_alias = true; 221 nd = rb_next(&curr->rb_node); 222 rb_erase_cached(&curr->rb_node, symbols); 223 symbol__delete(curr); 224 } 225 } 226} 227 228/* Update zero-sized symbols using the address of the next symbol */ 229void symbols__fixup_end(struct rb_root_cached *symbols, bool is_kallsyms) 230{ 231 struct rb_node *nd, *prevnd = rb_first_cached(symbols); 232 struct symbol *curr, *prev; 233 234 if (prevnd == NULL) 235 return; 236 237 curr = rb_entry(prevnd, struct symbol, rb_node); 238 239 for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) { 240 prev = curr; 241 curr = rb_entry(nd, struct symbol, rb_node); 242 243 /* 244 * On some architecture kernel text segment start is located at 245 * some low memory address, while modules are located at high 246 * memory addresses (or vice versa). The gap between end of 247 * kernel text segment and beginning of first module's text 248 * segment is very big. Therefore do not fill this gap and do 249 * not assign it to the kernel dso map (kallsyms). 250 * 251 * Also BPF code can be allocated separately from text segments 252 * and modules. So the last entry in a module should not fill 253 * the gap too. 254 * 255 * In kallsyms, it determines module symbols using '[' character 256 * like in: 257 * ffffffffc1937000 T hdmi_driver_init [snd_hda_codec_hdmi] 258 */ 259 if (prev->end == prev->start) { 260 const char *prev_mod; 261 const char *curr_mod; 262 263 if (!is_kallsyms) { 264 prev->end = curr->start; 265 continue; 266 } 267 268 prev_mod = strchr(prev->name, '['); 269 curr_mod = strchr(curr->name, '['); 270 271 /* Last kernel/module symbol mapped to end of page */ 272 if (!prev_mod != !curr_mod) 273 prev->end = roundup(prev->end + 4096, 4096); 274 /* Last symbol in the previous module */ 275 else if (prev_mod && strcmp(prev_mod, curr_mod)) 276 prev->end = roundup(prev->end + 4096, 4096); 277 else 278 prev->end = curr->start; 279 280 pr_debug4("%s sym:%s end:%#" PRIx64 "\n", 281 __func__, prev->name, prev->end); 282 } 283 } 284 285 /* Last entry */ 286 if (curr->end == curr->start) 287 curr->end = roundup(curr->start, 4096) + 4096; 288} 289 290struct symbol *symbol__new(u64 start, u64 len, u8 binding, u8 type, const char *name) 291{ 292 size_t namelen = strlen(name) + 1; 293 struct symbol *sym = calloc(1, (symbol_conf.priv_size + 294 sizeof(*sym) + namelen)); 295 if (sym == NULL) 296 return NULL; 297 298 if (symbol_conf.priv_size) { 299 if (symbol_conf.init_annotation) { 300 struct annotation *notes = (void *)sym; 301 annotation__init(notes); 302 } 303 sym = ((void *)sym) + symbol_conf.priv_size; 304 } 305 306 sym->start = start; 307 sym->end = len ? start + len : start; 308 sym->type = type; 309 sym->binding = binding; 310 sym->namelen = namelen - 1; 311 312 pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n", 313 __func__, name, start, sym->end); 314 memcpy(sym->name, name, namelen); 315 316 return sym; 317} 318 319void symbol__delete(struct symbol *sym) 320{ 321 if (symbol_conf.priv_size) { 322 if (symbol_conf.init_annotation) { 323 struct annotation *notes = symbol__annotation(sym); 324 325 annotation__exit(notes); 326 } 327 } 328 free(((void *)sym) - symbol_conf.priv_size); 329} 330 331void symbols__delete(struct rb_root_cached *symbols) 332{ 333 struct symbol *pos; 334 struct rb_node *next = rb_first_cached(symbols); 335 336 while (next) { 337 pos = rb_entry(next, struct symbol, rb_node); 338 next = rb_next(&pos->rb_node); 339 rb_erase_cached(&pos->rb_node, symbols); 340 symbol__delete(pos); 341 } 342} 343 344void __symbols__insert(struct rb_root_cached *symbols, 345 struct symbol *sym, bool kernel) 346{ 347 struct rb_node **p = &symbols->rb_root.rb_node; 348 struct rb_node *parent = NULL; 349 const u64 ip = sym->start; 350 struct symbol *s; 351 bool leftmost = true; 352 353 if (kernel) { 354 const char *name = sym->name; 355 /* 356 * ppc64 uses function descriptors and appends a '.' to the 357 * start of every instruction address. Remove it. 358 */ 359 if (name[0] == '.') 360 name++; 361 sym->idle = symbol__is_idle(name); 362 } 363 364 while (*p != NULL) { 365 parent = *p; 366 s = rb_entry(parent, struct symbol, rb_node); 367 if (ip < s->start) 368 p = &(*p)->rb_left; 369 else { 370 p = &(*p)->rb_right; 371 leftmost = false; 372 } 373 } 374 rb_link_node(&sym->rb_node, parent, p); 375 rb_insert_color_cached(&sym->rb_node, symbols, leftmost); 376} 377 378void symbols__insert(struct rb_root_cached *symbols, struct symbol *sym) 379{ 380 __symbols__insert(symbols, sym, false); 381} 382 383static struct symbol *symbols__find(struct rb_root_cached *symbols, u64 ip) 384{ 385 struct rb_node *n; 386 387 if (symbols == NULL) 388 return NULL; 389 390 n = symbols->rb_root.rb_node; 391 392 while (n) { 393 struct symbol *s = rb_entry(n, struct symbol, rb_node); 394 395 if (ip < s->start) 396 n = n->rb_left; 397 else if (ip > s->end || (ip == s->end && ip != s->start)) 398 n = n->rb_right; 399 else 400 return s; 401 } 402 403 return NULL; 404} 405 406static struct symbol *symbols__first(struct rb_root_cached *symbols) 407{ 408 struct rb_node *n = rb_first_cached(symbols); 409 410 if (n) 411 return rb_entry(n, struct symbol, rb_node); 412 413 return NULL; 414} 415 416static struct symbol *symbols__last(struct rb_root_cached *symbols) 417{ 418 struct rb_node *n = rb_last(&symbols->rb_root); 419 420 if (n) 421 return rb_entry(n, struct symbol, rb_node); 422 423 return NULL; 424} 425 426static struct symbol *symbols__next(struct symbol *sym) 427{ 428 struct rb_node *n = rb_next(&sym->rb_node); 429 430 if (n) 431 return rb_entry(n, struct symbol, rb_node); 432 433 return NULL; 434} 435 436static int symbols__sort_name_cmp(const void *vlhs, const void *vrhs) 437{ 438 const struct symbol *lhs = *((const struct symbol **)vlhs); 439 const struct symbol *rhs = *((const struct symbol **)vrhs); 440 441 return strcmp(lhs->name, rhs->name); 442} 443 444static struct symbol **symbols__sort_by_name(struct rb_root_cached *source, size_t *len) 445{ 446 struct rb_node *nd; 447 struct symbol **result; 448 size_t i = 0, size = 0; 449 450 for (nd = rb_first_cached(source); nd; nd = rb_next(nd)) 451 size++; 452 453 result = malloc(sizeof(*result) * size); 454 if (!result) 455 return NULL; 456 457 for (nd = rb_first_cached(source); nd; nd = rb_next(nd)) { 458 struct symbol *pos = rb_entry(nd, struct symbol, rb_node); 459 460 result[i++] = pos; 461 } 462 qsort(result, size, sizeof(*result), symbols__sort_name_cmp); 463 *len = size; 464 return result; 465} 466 467int symbol__match_symbol_name(const char *name, const char *str, 468 enum symbol_tag_include includes) 469{ 470 const char *versioning; 471 472 if (includes == SYMBOL_TAG_INCLUDE__DEFAULT_ONLY && 473 (versioning = strstr(name, "@@"))) { 474 int len = strlen(str); 475 476 if (len < versioning - name) 477 len = versioning - name; 478 479 return arch__compare_symbol_names_n(name, str, len); 480 } else 481 return arch__compare_symbol_names(name, str); 482} 483 484static struct symbol *symbols__find_by_name(struct symbol *symbols[], 485 size_t symbols_len, 486 const char *name, 487 enum symbol_tag_include includes, 488 size_t *found_idx) 489{ 490 size_t i, lower = 0, upper = symbols_len; 491 struct symbol *s = NULL; 492 493 if (found_idx) 494 *found_idx = SIZE_MAX; 495 496 if (!symbols_len) 497 return NULL; 498 499 while (lower < upper) { 500 int cmp; 501 502 i = (lower + upper) / 2; 503 cmp = symbol__match_symbol_name(symbols[i]->name, name, includes); 504 505 if (cmp > 0) 506 upper = i; 507 else if (cmp < 0) 508 lower = i + 1; 509 else { 510 if (found_idx) 511 *found_idx = i; 512 s = symbols[i]; 513 break; 514 } 515 } 516 if (s && includes != SYMBOL_TAG_INCLUDE__DEFAULT_ONLY) { 517 /* return first symbol that has same name (if any) */ 518 for (; i > 0; i--) { 519 struct symbol *tmp = symbols[i - 1]; 520 521 if (!arch__compare_symbol_names(tmp->name, s->name)) { 522 if (found_idx) 523 *found_idx = i - 1; 524 s = tmp; 525 } else 526 break; 527 } 528 } 529 assert(!found_idx || !s || s == symbols[*found_idx]); 530 return s; 531} 532 533void dso__reset_find_symbol_cache(struct dso *dso) 534{ 535 dso->last_find_result.addr = 0; 536 dso->last_find_result.symbol = NULL; 537} 538 539void dso__insert_symbol(struct dso *dso, struct symbol *sym) 540{ 541 __symbols__insert(&dso->symbols, sym, dso->kernel); 542 543 /* update the symbol cache if necessary */ 544 if (dso->last_find_result.addr >= sym->start && 545 (dso->last_find_result.addr < sym->end || 546 sym->start == sym->end)) { 547 dso->last_find_result.symbol = sym; 548 } 549} 550 551void dso__delete_symbol(struct dso *dso, struct symbol *sym) 552{ 553 rb_erase_cached(&sym->rb_node, &dso->symbols); 554 symbol__delete(sym); 555 dso__reset_find_symbol_cache(dso); 556} 557 558struct symbol *dso__find_symbol(struct dso *dso, u64 addr) 559{ 560 if (dso->last_find_result.addr != addr || dso->last_find_result.symbol == NULL) { 561 dso->last_find_result.addr = addr; 562 dso->last_find_result.symbol = symbols__find(&dso->symbols, addr); 563 } 564 565 return dso->last_find_result.symbol; 566} 567 568struct symbol *dso__find_symbol_nocache(struct dso *dso, u64 addr) 569{ 570 return symbols__find(&dso->symbols, addr); 571} 572 573struct symbol *dso__first_symbol(struct dso *dso) 574{ 575 return symbols__first(&dso->symbols); 576} 577 578struct symbol *dso__last_symbol(struct dso *dso) 579{ 580 return symbols__last(&dso->symbols); 581} 582 583struct symbol *dso__next_symbol(struct symbol *sym) 584{ 585 return symbols__next(sym); 586} 587 588struct symbol *dso__next_symbol_by_name(struct dso *dso, size_t *idx) 589{ 590 if (*idx + 1 >= dso->symbol_names_len) 591 return NULL; 592 593 ++*idx; 594 return dso->symbol_names[*idx]; 595} 596 597 /* 598 * Returns first symbol that matched with @name. 599 */ 600struct symbol *dso__find_symbol_by_name(struct dso *dso, const char *name, size_t *idx) 601{ 602 struct symbol *s = symbols__find_by_name(dso->symbol_names, dso->symbol_names_len, 603 name, SYMBOL_TAG_INCLUDE__NONE, idx); 604 if (!s) 605 s = symbols__find_by_name(dso->symbol_names, dso->symbol_names_len, 606 name, SYMBOL_TAG_INCLUDE__DEFAULT_ONLY, idx); 607 return s; 608} 609 610void dso__sort_by_name(struct dso *dso) 611{ 612 mutex_lock(&dso->lock); 613 if (!dso__sorted_by_name(dso)) { 614 size_t len; 615 616 dso->symbol_names = symbols__sort_by_name(&dso->symbols, &len); 617 if (dso->symbol_names) { 618 dso->symbol_names_len = len; 619 dso__set_sorted_by_name(dso); 620 } 621 } 622 mutex_unlock(&dso->lock); 623} 624 625/* 626 * While we find nice hex chars, build a long_val. 627 * Return number of chars processed. 628 */ 629static int hex2u64(const char *ptr, u64 *long_val) 630{ 631 char *p; 632 633 *long_val = strtoull(ptr, &p, 16); 634 635 return p - ptr; 636} 637 638 639int modules__parse(const char *filename, void *arg, 640 int (*process_module)(void *arg, const char *name, 641 u64 start, u64 size)) 642{ 643 char *line = NULL; 644 size_t n; 645 FILE *file; 646 int err = 0; 647 648 file = fopen(filename, "r"); 649 if (file == NULL) 650 return -1; 651 652 while (1) { 653 char name[PATH_MAX]; 654 u64 start, size; 655 char *sep, *endptr; 656 ssize_t line_len; 657 658 line_len = getline(&line, &n, file); 659 if (line_len < 0) { 660 if (feof(file)) 661 break; 662 err = -1; 663 goto out; 664 } 665 666 if (!line) { 667 err = -1; 668 goto out; 669 } 670 671 line[--line_len] = '\0'; /* \n */ 672 673 sep = strrchr(line, 'x'); 674 if (sep == NULL) 675 continue; 676 677 hex2u64(sep + 1, &start); 678 679 sep = strchr(line, ' '); 680 if (sep == NULL) 681 continue; 682 683 *sep = '\0'; 684 685 scnprintf(name, sizeof(name), "[%s]", line); 686 687 size = strtoul(sep + 1, &endptr, 0); 688 if (*endptr != ' ' && *endptr != '\t') 689 continue; 690 691 err = process_module(arg, name, start, size); 692 if (err) 693 break; 694 } 695out: 696 free(line); 697 fclose(file); 698 return err; 699} 700 701/* 702 * These are symbols in the kernel image, so make sure that 703 * sym is from a kernel DSO. 704 */ 705static bool symbol__is_idle(const char *name) 706{ 707 const char * const idle_symbols[] = { 708 "acpi_idle_do_entry", 709 "acpi_processor_ffh_cstate_enter", 710 "arch_cpu_idle", 711 "cpu_idle", 712 "cpu_startup_entry", 713 "idle_cpu", 714 "intel_idle", 715 "intel_idle_ibrs", 716 "default_idle", 717 "native_safe_halt", 718 "enter_idle", 719 "exit_idle", 720 "mwait_idle", 721 "mwait_idle_with_hints", 722 "mwait_idle_with_hints.constprop.0", 723 "poll_idle", 724 "ppc64_runlatch_off", 725 "pseries_dedicated_idle_sleep", 726 "psw_idle", 727 "psw_idle_exit", 728 NULL 729 }; 730 int i; 731 static struct strlist *idle_symbols_list; 732 733 if (idle_symbols_list) 734 return strlist__has_entry(idle_symbols_list, name); 735 736 idle_symbols_list = strlist__new(NULL, NULL); 737 738 for (i = 0; idle_symbols[i]; i++) 739 strlist__add(idle_symbols_list, idle_symbols[i]); 740 741 return strlist__has_entry(idle_symbols_list, name); 742} 743 744static int map__process_kallsym_symbol(void *arg, const char *name, 745 char type, u64 start) 746{ 747 struct symbol *sym; 748 struct dso *dso = arg; 749 struct rb_root_cached *root = &dso->symbols; 750 751 if (!symbol_type__filter(type)) 752 return 0; 753 754 /* Ignore local symbols for ARM modules */ 755 if (name[0] == '$') 756 return 0; 757 758 /* 759 * module symbols are not sorted so we add all 760 * symbols, setting length to 0, and rely on 761 * symbols__fixup_end() to fix it up. 762 */ 763 sym = symbol__new(start, 0, kallsyms2elf_binding(type), kallsyms2elf_type(type), name); 764 if (sym == NULL) 765 return -ENOMEM; 766 /* 767 * We will pass the symbols to the filter later, in 768 * map__split_kallsyms, when we have split the maps per module 769 */ 770 __symbols__insert(root, sym, !strchr(name, '[')); 771 772 return 0; 773} 774 775/* 776 * Loads the function entries in /proc/kallsyms into kernel_map->dso, 777 * so that we can in the next step set the symbol ->end address and then 778 * call kernel_maps__split_kallsyms. 779 */ 780static int dso__load_all_kallsyms(struct dso *dso, const char *filename) 781{ 782 return kallsyms__parse(filename, dso, map__process_kallsym_symbol); 783} 784 785static int maps__split_kallsyms_for_kcore(struct maps *kmaps, struct dso *dso) 786{ 787 struct symbol *pos; 788 int count = 0; 789 struct rb_root_cached old_root = dso->symbols; 790 struct rb_root_cached *root = &dso->symbols; 791 struct rb_node *next = rb_first_cached(root); 792 793 if (!kmaps) 794 return -1; 795 796 *root = RB_ROOT_CACHED; 797 798 while (next) { 799 struct map *curr_map; 800 struct dso *curr_map_dso; 801 char *module; 802 803 pos = rb_entry(next, struct symbol, rb_node); 804 next = rb_next(&pos->rb_node); 805 806 rb_erase_cached(&pos->rb_node, &old_root); 807 RB_CLEAR_NODE(&pos->rb_node); 808 module = strchr(pos->name, '\t'); 809 if (module) 810 *module = '\0'; 811 812 curr_map = maps__find(kmaps, pos->start); 813 814 if (!curr_map) { 815 symbol__delete(pos); 816 continue; 817 } 818 curr_map_dso = map__dso(curr_map); 819 pos->start -= map__start(curr_map) - map__pgoff(curr_map); 820 if (pos->end > map__end(curr_map)) 821 pos->end = map__end(curr_map); 822 if (pos->end) 823 pos->end -= map__start(curr_map) - map__pgoff(curr_map); 824 symbols__insert(&curr_map_dso->symbols, pos); 825 ++count; 826 map__put(curr_map); 827 } 828 829 /* Symbols have been adjusted */ 830 dso->adjust_symbols = 1; 831 832 return count; 833} 834 835/* 836 * Split the symbols into maps, making sure there are no overlaps, i.e. the 837 * kernel range is broken in several maps, named [kernel].N, as we don't have 838 * the original ELF section names vmlinux have. 839 */ 840static int maps__split_kallsyms(struct maps *kmaps, struct dso *dso, u64 delta, 841 struct map *initial_map) 842{ 843 struct machine *machine; 844 struct map *curr_map = map__get(initial_map); 845 struct symbol *pos; 846 int count = 0, moved = 0; 847 struct rb_root_cached *root = &dso->symbols; 848 struct rb_node *next = rb_first_cached(root); 849 int kernel_range = 0; 850 bool x86_64; 851 852 if (!kmaps) 853 return -1; 854 855 machine = maps__machine(kmaps); 856 857 x86_64 = machine__is(machine, "x86_64"); 858 859 while (next) { 860 char *module; 861 862 pos = rb_entry(next, struct symbol, rb_node); 863 next = rb_next(&pos->rb_node); 864 865 module = strchr(pos->name, '\t'); 866 if (module) { 867 struct dso *curr_map_dso; 868 869 if (!symbol_conf.use_modules) 870 goto discard_symbol; 871 872 *module++ = '\0'; 873 curr_map_dso = map__dso(curr_map); 874 if (strcmp(curr_map_dso->short_name, module)) { 875 if (!RC_CHK_EQUAL(curr_map, initial_map) && 876 dso->kernel == DSO_SPACE__KERNEL_GUEST && 877 machine__is_default_guest(machine)) { 878 /* 879 * We assume all symbols of a module are 880 * continuous in * kallsyms, so curr_map 881 * points to a module and all its 882 * symbols are in its kmap. Mark it as 883 * loaded. 884 */ 885 dso__set_loaded(curr_map_dso); 886 } 887 888 map__zput(curr_map); 889 curr_map = maps__find_by_name(kmaps, module); 890 if (curr_map == NULL) { 891 pr_debug("%s/proc/{kallsyms,modules} " 892 "inconsistency while looking " 893 "for \"%s\" module!\n", 894 machine->root_dir, module); 895 curr_map = map__get(initial_map); 896 goto discard_symbol; 897 } 898 curr_map_dso = map__dso(curr_map); 899 if (curr_map_dso->loaded && 900 !machine__is_default_guest(machine)) 901 goto discard_symbol; 902 } 903 /* 904 * So that we look just like we get from .ko files, 905 * i.e. not prelinked, relative to initial_map->start. 906 */ 907 pos->start = map__map_ip(curr_map, pos->start); 908 pos->end = map__map_ip(curr_map, pos->end); 909 } else if (x86_64 && is_entry_trampoline(pos->name)) { 910 /* 911 * These symbols are not needed anymore since the 912 * trampoline maps refer to the text section and it's 913 * symbols instead. Avoid having to deal with 914 * relocations, and the assumption that the first symbol 915 * is the start of kernel text, by simply removing the 916 * symbols at this point. 917 */ 918 goto discard_symbol; 919 } else if (!RC_CHK_EQUAL(curr_map, initial_map)) { 920 char dso_name[PATH_MAX]; 921 struct dso *ndso; 922 923 if (delta) { 924 /* Kernel was relocated at boot time */ 925 pos->start -= delta; 926 pos->end -= delta; 927 } 928 929 if (count == 0) { 930 map__zput(curr_map); 931 curr_map = map__get(initial_map); 932 goto add_symbol; 933 } 934 935 if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 936 snprintf(dso_name, sizeof(dso_name), 937 "[guest.kernel].%d", 938 kernel_range++); 939 else 940 snprintf(dso_name, sizeof(dso_name), 941 "[kernel].%d", 942 kernel_range++); 943 944 ndso = dso__new(dso_name); 945 map__zput(curr_map); 946 if (ndso == NULL) 947 return -1; 948 949 ndso->kernel = dso->kernel; 950 951 curr_map = map__new2(pos->start, ndso); 952 if (curr_map == NULL) { 953 dso__put(ndso); 954 return -1; 955 } 956 957 map__set_mapping_type(curr_map, MAPPING_TYPE__IDENTITY); 958 if (maps__insert(kmaps, curr_map)) { 959 map__zput(curr_map); 960 dso__put(ndso); 961 return -1; 962 } 963 ++kernel_range; 964 } else if (delta) { 965 /* Kernel was relocated at boot time */ 966 pos->start -= delta; 967 pos->end -= delta; 968 } 969add_symbol: 970 if (!RC_CHK_EQUAL(curr_map, initial_map)) { 971 struct dso *curr_map_dso = map__dso(curr_map); 972 973 rb_erase_cached(&pos->rb_node, root); 974 symbols__insert(&curr_map_dso->symbols, pos); 975 ++moved; 976 } else 977 ++count; 978 979 continue; 980discard_symbol: 981 rb_erase_cached(&pos->rb_node, root); 982 symbol__delete(pos); 983 } 984 985 if (!RC_CHK_EQUAL(curr_map, initial_map) && 986 dso->kernel == DSO_SPACE__KERNEL_GUEST && 987 machine__is_default_guest(maps__machine(kmaps))) { 988 dso__set_loaded(map__dso(curr_map)); 989 } 990 map__put(curr_map); 991 return count + moved; 992} 993 994bool symbol__restricted_filename(const char *filename, 995 const char *restricted_filename) 996{ 997 bool restricted = false; 998 999 if (symbol_conf.kptr_restrict) { 1000 char *r = realpath(filename, NULL); 1001 1002 if (r != NULL) { 1003 restricted = strcmp(r, restricted_filename) == 0; 1004 free(r); 1005 return restricted; 1006 } 1007 } 1008 1009 return restricted; 1010} 1011 1012struct module_info { 1013 struct rb_node rb_node; 1014 char *name; 1015 u64 start; 1016}; 1017 1018static void add_module(struct module_info *mi, struct rb_root *modules) 1019{ 1020 struct rb_node **p = &modules->rb_node; 1021 struct rb_node *parent = NULL; 1022 struct module_info *m; 1023 1024 while (*p != NULL) { 1025 parent = *p; 1026 m = rb_entry(parent, struct module_info, rb_node); 1027 if (strcmp(mi->name, m->name) < 0) 1028 p = &(*p)->rb_left; 1029 else 1030 p = &(*p)->rb_right; 1031 } 1032 rb_link_node(&mi->rb_node, parent, p); 1033 rb_insert_color(&mi->rb_node, modules); 1034} 1035 1036static void delete_modules(struct rb_root *modules) 1037{ 1038 struct module_info *mi; 1039 struct rb_node *next = rb_first(modules); 1040 1041 while (next) { 1042 mi = rb_entry(next, struct module_info, rb_node); 1043 next = rb_next(&mi->rb_node); 1044 rb_erase(&mi->rb_node, modules); 1045 zfree(&mi->name); 1046 free(mi); 1047 } 1048} 1049 1050static struct module_info *find_module(const char *name, 1051 struct rb_root *modules) 1052{ 1053 struct rb_node *n = modules->rb_node; 1054 1055 while (n) { 1056 struct module_info *m; 1057 int cmp; 1058 1059 m = rb_entry(n, struct module_info, rb_node); 1060 cmp = strcmp(name, m->name); 1061 if (cmp < 0) 1062 n = n->rb_left; 1063 else if (cmp > 0) 1064 n = n->rb_right; 1065 else 1066 return m; 1067 } 1068 1069 return NULL; 1070} 1071 1072static int __read_proc_modules(void *arg, const char *name, u64 start, 1073 u64 size __maybe_unused) 1074{ 1075 struct rb_root *modules = arg; 1076 struct module_info *mi; 1077 1078 mi = zalloc(sizeof(struct module_info)); 1079 if (!mi) 1080 return -ENOMEM; 1081 1082 mi->name = strdup(name); 1083 mi->start = start; 1084 1085 if (!mi->name) { 1086 free(mi); 1087 return -ENOMEM; 1088 } 1089 1090 add_module(mi, modules); 1091 1092 return 0; 1093} 1094 1095static int read_proc_modules(const char *filename, struct rb_root *modules) 1096{ 1097 if (symbol__restricted_filename(filename, "/proc/modules")) 1098 return -1; 1099 1100 if (modules__parse(filename, modules, __read_proc_modules)) { 1101 delete_modules(modules); 1102 return -1; 1103 } 1104 1105 return 0; 1106} 1107 1108int compare_proc_modules(const char *from, const char *to) 1109{ 1110 struct rb_root from_modules = RB_ROOT; 1111 struct rb_root to_modules = RB_ROOT; 1112 struct rb_node *from_node, *to_node; 1113 struct module_info *from_m, *to_m; 1114 int ret = -1; 1115 1116 if (read_proc_modules(from, &from_modules)) 1117 return -1; 1118 1119 if (read_proc_modules(to, &to_modules)) 1120 goto out_delete_from; 1121 1122 from_node = rb_first(&from_modules); 1123 to_node = rb_first(&to_modules); 1124 while (from_node) { 1125 if (!to_node) 1126 break; 1127 1128 from_m = rb_entry(from_node, struct module_info, rb_node); 1129 to_m = rb_entry(to_node, struct module_info, rb_node); 1130 1131 if (from_m->start != to_m->start || 1132 strcmp(from_m->name, to_m->name)) 1133 break; 1134 1135 from_node = rb_next(from_node); 1136 to_node = rb_next(to_node); 1137 } 1138 1139 if (!from_node && !to_node) 1140 ret = 0; 1141 1142 delete_modules(&to_modules); 1143out_delete_from: 1144 delete_modules(&from_modules); 1145 1146 return ret; 1147} 1148 1149static int do_validate_kcore_modules_cb(struct map *old_map, void *data) 1150{ 1151 struct rb_root *modules = data; 1152 struct module_info *mi; 1153 struct dso *dso; 1154 1155 if (!__map__is_kmodule(old_map)) 1156 return 0; 1157 1158 dso = map__dso(old_map); 1159 /* Module must be in memory at the same address */ 1160 mi = find_module(dso->short_name, modules); 1161 if (!mi || mi->start != map__start(old_map)) 1162 return -EINVAL; 1163 1164 return 0; 1165} 1166 1167static int do_validate_kcore_modules(const char *filename, struct maps *kmaps) 1168{ 1169 struct rb_root modules = RB_ROOT; 1170 int err; 1171 1172 err = read_proc_modules(filename, &modules); 1173 if (err) 1174 return err; 1175 1176 err = maps__for_each_map(kmaps, do_validate_kcore_modules_cb, &modules); 1177 1178 delete_modules(&modules); 1179 return err; 1180} 1181 1182/* 1183 * If kallsyms is referenced by name then we look for filename in the same 1184 * directory. 1185 */ 1186static bool filename_from_kallsyms_filename(char *filename, 1187 const char *base_name, 1188 const char *kallsyms_filename) 1189{ 1190 char *name; 1191 1192 strcpy(filename, kallsyms_filename); 1193 name = strrchr(filename, '/'); 1194 if (!name) 1195 return false; 1196 1197 name += 1; 1198 1199 if (!strcmp(name, "kallsyms")) { 1200 strcpy(name, base_name); 1201 return true; 1202 } 1203 1204 return false; 1205} 1206 1207static int validate_kcore_modules(const char *kallsyms_filename, 1208 struct map *map) 1209{ 1210 struct maps *kmaps = map__kmaps(map); 1211 char modules_filename[PATH_MAX]; 1212 1213 if (!kmaps) 1214 return -EINVAL; 1215 1216 if (!filename_from_kallsyms_filename(modules_filename, "modules", 1217 kallsyms_filename)) 1218 return -EINVAL; 1219 1220 if (do_validate_kcore_modules(modules_filename, kmaps)) 1221 return -EINVAL; 1222 1223 return 0; 1224} 1225 1226static int validate_kcore_addresses(const char *kallsyms_filename, 1227 struct map *map) 1228{ 1229 struct kmap *kmap = map__kmap(map); 1230 1231 if (!kmap) 1232 return -EINVAL; 1233 1234 if (kmap->ref_reloc_sym && kmap->ref_reloc_sym->name) { 1235 u64 start; 1236 1237 if (kallsyms__get_function_start(kallsyms_filename, 1238 kmap->ref_reloc_sym->name, &start)) 1239 return -ENOENT; 1240 if (start != kmap->ref_reloc_sym->addr) 1241 return -EINVAL; 1242 } 1243 1244 return validate_kcore_modules(kallsyms_filename, map); 1245} 1246 1247struct kcore_mapfn_data { 1248 struct dso *dso; 1249 struct list_head maps; 1250}; 1251 1252static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data) 1253{ 1254 struct kcore_mapfn_data *md = data; 1255 struct map_list_node *list_node = map_list_node__new(); 1256 1257 if (!list_node) 1258 return -ENOMEM; 1259 1260 list_node->map = map__new2(start, md->dso); 1261 if (!list_node->map) { 1262 free(list_node); 1263 return -ENOMEM; 1264 } 1265 1266 map__set_end(list_node->map, map__start(list_node->map) + len); 1267 map__set_pgoff(list_node->map, pgoff); 1268 1269 list_add(&list_node->node, &md->maps); 1270 1271 return 0; 1272} 1273 1274static bool remove_old_maps(struct map *map, void *data) 1275{ 1276 const struct map *map_to_save = data; 1277 1278 /* 1279 * We need to preserve eBPF maps even if they are covered by kcore, 1280 * because we need to access eBPF dso for source data. 1281 */ 1282 return !RC_CHK_EQUAL(map, map_to_save) && !__map__is_bpf_prog(map); 1283} 1284 1285static int dso__load_kcore(struct dso *dso, struct map *map, 1286 const char *kallsyms_filename) 1287{ 1288 struct maps *kmaps = map__kmaps(map); 1289 struct kcore_mapfn_data md; 1290 struct map *replacement_map = NULL; 1291 struct machine *machine; 1292 bool is_64_bit; 1293 int err, fd; 1294 char kcore_filename[PATH_MAX]; 1295 u64 stext; 1296 1297 if (!kmaps) 1298 return -EINVAL; 1299 1300 machine = maps__machine(kmaps); 1301 1302 /* This function requires that the map is the kernel map */ 1303 if (!__map__is_kernel(map)) 1304 return -EINVAL; 1305 1306 if (!filename_from_kallsyms_filename(kcore_filename, "kcore", 1307 kallsyms_filename)) 1308 return -EINVAL; 1309 1310 /* Modules and kernel must be present at their original addresses */ 1311 if (validate_kcore_addresses(kallsyms_filename, map)) 1312 return -EINVAL; 1313 1314 md.dso = dso; 1315 INIT_LIST_HEAD(&md.maps); 1316 1317 fd = open(kcore_filename, O_RDONLY); 1318 if (fd < 0) { 1319 pr_debug("Failed to open %s. Note /proc/kcore requires CAP_SYS_RAWIO capability to access.\n", 1320 kcore_filename); 1321 return -EINVAL; 1322 } 1323 1324 /* Read new maps into temporary lists */ 1325 err = file__read_maps(fd, map__prot(map) & PROT_EXEC, kcore_mapfn, &md, 1326 &is_64_bit); 1327 if (err) 1328 goto out_err; 1329 dso->is_64_bit = is_64_bit; 1330 1331 if (list_empty(&md.maps)) { 1332 err = -EINVAL; 1333 goto out_err; 1334 } 1335 1336 /* Remove old maps */ 1337 maps__remove_maps(kmaps, remove_old_maps, map); 1338 machine->trampolines_mapped = false; 1339 1340 /* Find the kernel map using the '_stext' symbol */ 1341 if (!kallsyms__get_function_start(kallsyms_filename, "_stext", &stext)) { 1342 u64 replacement_size = 0; 1343 struct map_list_node *new_node; 1344 1345 list_for_each_entry(new_node, &md.maps, node) { 1346 struct map *new_map = new_node->map; 1347 u64 new_size = map__size(new_map); 1348 1349 if (!(stext >= map__start(new_map) && stext < map__end(new_map))) 1350 continue; 1351 1352 /* 1353 * On some architectures, ARM64 for example, the kernel 1354 * text can get allocated inside of the vmalloc segment. 1355 * Select the smallest matching segment, in case stext 1356 * falls within more than one in the list. 1357 */ 1358 if (!replacement_map || new_size < replacement_size) { 1359 replacement_map = new_map; 1360 replacement_size = new_size; 1361 } 1362 } 1363 } 1364 1365 if (!replacement_map) 1366 replacement_map = list_entry(md.maps.next, struct map_list_node, node)->map; 1367 1368 /* Add new maps */ 1369 while (!list_empty(&md.maps)) { 1370 struct map_list_node *new_node = list_entry(md.maps.next, struct map_list_node, node); 1371 struct map *new_map = new_node->map; 1372 1373 list_del_init(&new_node->node); 1374 1375 if (RC_CHK_EQUAL(new_map, replacement_map)) { 1376 struct map *map_ref; 1377 1378 map__set_start(map, map__start(new_map)); 1379 map__set_end(map, map__end(new_map)); 1380 map__set_pgoff(map, map__pgoff(new_map)); 1381 map__set_mapping_type(map, map__mapping_type(new_map)); 1382 /* Ensure maps are correctly ordered */ 1383 map_ref = map__get(map); 1384 maps__remove(kmaps, map_ref); 1385 err = maps__insert(kmaps, map_ref); 1386 map__put(map_ref); 1387 map__put(new_map); 1388 if (err) 1389 goto out_err; 1390 } else { 1391 /* 1392 * Merge kcore map into existing maps, 1393 * and ensure that current maps (eBPF) 1394 * stay intact. 1395 */ 1396 if (maps__merge_in(kmaps, new_map)) { 1397 err = -EINVAL; 1398 goto out_err; 1399 } 1400 } 1401 free(new_node); 1402 } 1403 1404 if (machine__is(machine, "x86_64")) { 1405 u64 addr; 1406 1407 /* 1408 * If one of the corresponding symbols is there, assume the 1409 * entry trampoline maps are too. 1410 */ 1411 if (!kallsyms__get_function_start(kallsyms_filename, 1412 ENTRY_TRAMPOLINE_NAME, 1413 &addr)) 1414 machine->trampolines_mapped = true; 1415 } 1416 1417 /* 1418 * Set the data type and long name so that kcore can be read via 1419 * dso__data_read_addr(). 1420 */ 1421 if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1422 dso->binary_type = DSO_BINARY_TYPE__GUEST_KCORE; 1423 else 1424 dso->binary_type = DSO_BINARY_TYPE__KCORE; 1425 dso__set_long_name(dso, strdup(kcore_filename), true); 1426 1427 close(fd); 1428 1429 if (map__prot(map) & PROT_EXEC) 1430 pr_debug("Using %s for kernel object code\n", kcore_filename); 1431 else 1432 pr_debug("Using %s for kernel data\n", kcore_filename); 1433 1434 return 0; 1435 1436out_err: 1437 while (!list_empty(&md.maps)) { 1438 struct map_list_node *list_node; 1439 1440 list_node = list_entry(md.maps.next, struct map_list_node, node); 1441 list_del_init(&list_node->node); 1442 map__zput(list_node->map); 1443 free(list_node); 1444 } 1445 close(fd); 1446 return err; 1447} 1448 1449/* 1450 * If the kernel is relocated at boot time, kallsyms won't match. Compute the 1451 * delta based on the relocation reference symbol. 1452 */ 1453static int kallsyms__delta(struct kmap *kmap, const char *filename, u64 *delta) 1454{ 1455 u64 addr; 1456 1457 if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->name) 1458 return 0; 1459 1460 if (kallsyms__get_function_start(filename, kmap->ref_reloc_sym->name, &addr)) 1461 return -1; 1462 1463 *delta = addr - kmap->ref_reloc_sym->addr; 1464 return 0; 1465} 1466 1467int __dso__load_kallsyms(struct dso *dso, const char *filename, 1468 struct map *map, bool no_kcore) 1469{ 1470 struct kmap *kmap = map__kmap(map); 1471 u64 delta = 0; 1472 1473 if (symbol__restricted_filename(filename, "/proc/kallsyms")) 1474 return -1; 1475 1476 if (!kmap || !kmap->kmaps) 1477 return -1; 1478 1479 if (dso__load_all_kallsyms(dso, filename) < 0) 1480 return -1; 1481 1482 if (kallsyms__delta(kmap, filename, &delta)) 1483 return -1; 1484 1485 symbols__fixup_end(&dso->symbols, true); 1486 symbols__fixup_duplicate(&dso->symbols); 1487 1488 if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1489 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 1490 else 1491 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS; 1492 1493 if (!no_kcore && !dso__load_kcore(dso, map, filename)) 1494 return maps__split_kallsyms_for_kcore(kmap->kmaps, dso); 1495 else 1496 return maps__split_kallsyms(kmap->kmaps, dso, delta, map); 1497} 1498 1499int dso__load_kallsyms(struct dso *dso, const char *filename, 1500 struct map *map) 1501{ 1502 return __dso__load_kallsyms(dso, filename, map, false); 1503} 1504 1505static int dso__load_perf_map(const char *map_path, struct dso *dso) 1506{ 1507 char *line = NULL; 1508 size_t n; 1509 FILE *file; 1510 int nr_syms = 0; 1511 1512 file = fopen(map_path, "r"); 1513 if (file == NULL) 1514 goto out_failure; 1515 1516 while (!feof(file)) { 1517 u64 start, size; 1518 struct symbol *sym; 1519 int line_len, len; 1520 1521 line_len = getline(&line, &n, file); 1522 if (line_len < 0) 1523 break; 1524 1525 if (!line) 1526 goto out_failure; 1527 1528 line[--line_len] = '\0'; /* \n */ 1529 1530 len = hex2u64(line, &start); 1531 1532 len++; 1533 if (len + 2 >= line_len) 1534 continue; 1535 1536 len += hex2u64(line + len, &size); 1537 1538 len++; 1539 if (len + 2 >= line_len) 1540 continue; 1541 1542 sym = symbol__new(start, size, STB_GLOBAL, STT_FUNC, line + len); 1543 1544 if (sym == NULL) 1545 goto out_delete_line; 1546 1547 symbols__insert(&dso->symbols, sym); 1548 nr_syms++; 1549 } 1550 1551 free(line); 1552 fclose(file); 1553 1554 return nr_syms; 1555 1556out_delete_line: 1557 free(line); 1558out_failure: 1559 return -1; 1560} 1561 1562#ifdef HAVE_LIBBFD_SUPPORT 1563#define PACKAGE 'perf' 1564#include <bfd.h> 1565 1566static int bfd_symbols__cmpvalue(const void *a, const void *b) 1567{ 1568 const asymbol *as = *(const asymbol **)a, *bs = *(const asymbol **)b; 1569 1570 if (bfd_asymbol_value(as) != bfd_asymbol_value(bs)) 1571 return bfd_asymbol_value(as) - bfd_asymbol_value(bs); 1572 1573 return bfd_asymbol_name(as)[0] - bfd_asymbol_name(bs)[0]; 1574} 1575 1576static int bfd2elf_binding(asymbol *symbol) 1577{ 1578 if (symbol->flags & BSF_WEAK) 1579 return STB_WEAK; 1580 if (symbol->flags & BSF_GLOBAL) 1581 return STB_GLOBAL; 1582 if (symbol->flags & BSF_LOCAL) 1583 return STB_LOCAL; 1584 return -1; 1585} 1586 1587int dso__load_bfd_symbols(struct dso *dso, const char *debugfile) 1588{ 1589 int err = -1; 1590 long symbols_size, symbols_count, i; 1591 asection *section; 1592 asymbol **symbols, *sym; 1593 struct symbol *symbol; 1594 bfd *abfd; 1595 u64 start, len; 1596 1597 abfd = bfd_openr(debugfile, NULL); 1598 if (!abfd) 1599 return -1; 1600 1601 if (!bfd_check_format(abfd, bfd_object)) { 1602 pr_debug2("%s: cannot read %s bfd file.\n", __func__, 1603 dso->long_name); 1604 goto out_close; 1605 } 1606 1607 if (bfd_get_flavour(abfd) == bfd_target_elf_flavour) 1608 goto out_close; 1609 1610 symbols_size = bfd_get_symtab_upper_bound(abfd); 1611 if (symbols_size == 0) { 1612 bfd_close(abfd); 1613 return 0; 1614 } 1615 1616 if (symbols_size < 0) 1617 goto out_close; 1618 1619 symbols = malloc(symbols_size); 1620 if (!symbols) 1621 goto out_close; 1622 1623 symbols_count = bfd_canonicalize_symtab(abfd, symbols); 1624 if (symbols_count < 0) 1625 goto out_free; 1626 1627 section = bfd_get_section_by_name(abfd, ".text"); 1628 if (section) { 1629 for (i = 0; i < symbols_count; ++i) { 1630 if (!strcmp(bfd_asymbol_name(symbols[i]), "__ImageBase") || 1631 !strcmp(bfd_asymbol_name(symbols[i]), "__image_base__")) 1632 break; 1633 } 1634 if (i < symbols_count) { 1635 /* PE symbols can only have 4 bytes, so use .text high bits */ 1636 dso->text_offset = section->vma - (u32)section->vma; 1637 dso->text_offset += (u32)bfd_asymbol_value(symbols[i]); 1638 dso->text_end = (section->vma - dso->text_offset) + section->size; 1639 } else { 1640 dso->text_offset = section->vma - section->filepos; 1641 dso->text_end = section->filepos + section->size; 1642 } 1643 } 1644 1645 qsort(symbols, symbols_count, sizeof(asymbol *), bfd_symbols__cmpvalue); 1646 1647#ifdef bfd_get_section 1648#define bfd_asymbol_section bfd_get_section 1649#endif 1650 for (i = 0; i < symbols_count; ++i) { 1651 sym = symbols[i]; 1652 section = bfd_asymbol_section(sym); 1653 if (bfd2elf_binding(sym) < 0) 1654 continue; 1655 1656 while (i + 1 < symbols_count && 1657 bfd_asymbol_section(symbols[i + 1]) == section && 1658 bfd2elf_binding(symbols[i + 1]) < 0) 1659 i++; 1660 1661 if (i + 1 < symbols_count && 1662 bfd_asymbol_section(symbols[i + 1]) == section) 1663 len = symbols[i + 1]->value - sym->value; 1664 else 1665 len = section->size - sym->value; 1666 1667 start = bfd_asymbol_value(sym) - dso->text_offset; 1668 symbol = symbol__new(start, len, bfd2elf_binding(sym), STT_FUNC, 1669 bfd_asymbol_name(sym)); 1670 if (!symbol) 1671 goto out_free; 1672 1673 symbols__insert(&dso->symbols, symbol); 1674 } 1675#ifdef bfd_get_section 1676#undef bfd_asymbol_section 1677#endif 1678 1679 symbols__fixup_end(&dso->symbols, false); 1680 symbols__fixup_duplicate(&dso->symbols); 1681 dso->adjust_symbols = 1; 1682 1683 err = 0; 1684out_free: 1685 free(symbols); 1686out_close: 1687 bfd_close(abfd); 1688 return err; 1689} 1690#endif 1691 1692static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod, 1693 enum dso_binary_type type) 1694{ 1695 switch (type) { 1696 case DSO_BINARY_TYPE__JAVA_JIT: 1697 case DSO_BINARY_TYPE__DEBUGLINK: 1698 case DSO_BINARY_TYPE__SYSTEM_PATH_DSO: 1699 case DSO_BINARY_TYPE__FEDORA_DEBUGINFO: 1700 case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO: 1701 case DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO: 1702 case DSO_BINARY_TYPE__BUILDID_DEBUGINFO: 1703 case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO: 1704 return !kmod && dso->kernel == DSO_SPACE__USER; 1705 1706 case DSO_BINARY_TYPE__KALLSYMS: 1707 case DSO_BINARY_TYPE__VMLINUX: 1708 case DSO_BINARY_TYPE__KCORE: 1709 return dso->kernel == DSO_SPACE__KERNEL; 1710 1711 case DSO_BINARY_TYPE__GUEST_KALLSYMS: 1712 case DSO_BINARY_TYPE__GUEST_VMLINUX: 1713 case DSO_BINARY_TYPE__GUEST_KCORE: 1714 return dso->kernel == DSO_SPACE__KERNEL_GUEST; 1715 1716 case DSO_BINARY_TYPE__GUEST_KMODULE: 1717 case DSO_BINARY_TYPE__GUEST_KMODULE_COMP: 1718 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE: 1719 case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP: 1720 /* 1721 * kernel modules know their symtab type - it's set when 1722 * creating a module dso in machine__addnew_module_map(). 1723 */ 1724 return kmod && dso->symtab_type == type; 1725 1726 case DSO_BINARY_TYPE__BUILD_ID_CACHE: 1727 case DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO: 1728 return true; 1729 1730 case DSO_BINARY_TYPE__BPF_PROG_INFO: 1731 case DSO_BINARY_TYPE__BPF_IMAGE: 1732 case DSO_BINARY_TYPE__OOL: 1733 case DSO_BINARY_TYPE__NOT_FOUND: 1734 default: 1735 return false; 1736 } 1737} 1738 1739/* Checks for the existence of the perf-<pid>.map file in two different 1740 * locations. First, if the process is a separate mount namespace, check in 1741 * that namespace using the pid of the innermost pid namespace. If's not in a 1742 * namespace, or the file can't be found there, try in the mount namespace of 1743 * the tracing process using our view of its pid. 1744 */ 1745static int dso__find_perf_map(char *filebuf, size_t bufsz, 1746 struct nsinfo **nsip) 1747{ 1748 struct nscookie nsc; 1749 struct nsinfo *nsi; 1750 struct nsinfo *nnsi; 1751 int rc = -1; 1752 1753 nsi = *nsip; 1754 1755 if (nsinfo__need_setns(nsi)) { 1756 snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsinfo__nstgid(nsi)); 1757 nsinfo__mountns_enter(nsi, &nsc); 1758 rc = access(filebuf, R_OK); 1759 nsinfo__mountns_exit(&nsc); 1760 if (rc == 0) 1761 return rc; 1762 } 1763 1764 nnsi = nsinfo__copy(nsi); 1765 if (nnsi) { 1766 nsinfo__put(nsi); 1767 1768 nsinfo__clear_need_setns(nnsi); 1769 snprintf(filebuf, bufsz, "/tmp/perf-%d.map", nsinfo__tgid(nnsi)); 1770 *nsip = nnsi; 1771 rc = 0; 1772 } 1773 1774 return rc; 1775} 1776 1777int dso__load(struct dso *dso, struct map *map) 1778{ 1779 char *name; 1780 int ret = -1; 1781 u_int i; 1782 struct machine *machine = NULL; 1783 char *root_dir = (char *) ""; 1784 int ss_pos = 0; 1785 struct symsrc ss_[2]; 1786 struct symsrc *syms_ss = NULL, *runtime_ss = NULL; 1787 bool kmod; 1788 bool perfmap; 1789 struct build_id bid; 1790 struct nscookie nsc; 1791 char newmapname[PATH_MAX]; 1792 const char *map_path = dso->long_name; 1793 1794 mutex_lock(&dso->lock); 1795 perfmap = strncmp(dso->name, "/tmp/perf-", 10) == 0; 1796 if (perfmap) { 1797 if (dso->nsinfo && (dso__find_perf_map(newmapname, 1798 sizeof(newmapname), &dso->nsinfo) == 0)) { 1799 map_path = newmapname; 1800 } 1801 } 1802 1803 nsinfo__mountns_enter(dso->nsinfo, &nsc); 1804 1805 /* check again under the dso->lock */ 1806 if (dso__loaded(dso)) { 1807 ret = 1; 1808 goto out; 1809 } 1810 1811 kmod = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE || 1812 dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP || 1813 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE || 1814 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP; 1815 1816 if (dso->kernel && !kmod) { 1817 if (dso->kernel == DSO_SPACE__KERNEL) 1818 ret = dso__load_kernel_sym(dso, map); 1819 else if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1820 ret = dso__load_guest_kernel_sym(dso, map); 1821 1822 machine = maps__machine(map__kmaps(map)); 1823 if (machine__is(machine, "x86_64")) 1824 machine__map_x86_64_entry_trampolines(machine, dso); 1825 goto out; 1826 } 1827 1828 dso->adjust_symbols = 0; 1829 1830 if (perfmap) { 1831 ret = dso__load_perf_map(map_path, dso); 1832 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT : 1833 DSO_BINARY_TYPE__NOT_FOUND; 1834 goto out; 1835 } 1836 1837 if (machine) 1838 root_dir = machine->root_dir; 1839 1840 name = malloc(PATH_MAX); 1841 if (!name) 1842 goto out; 1843 1844 /* 1845 * Read the build id if possible. This is required for 1846 * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work 1847 */ 1848 if (!dso->has_build_id && 1849 is_regular_file(dso->long_name)) { 1850 __symbol__join_symfs(name, PATH_MAX, dso->long_name); 1851 if (filename__read_build_id(name, &bid) > 0) 1852 dso__set_build_id(dso, &bid); 1853 } 1854 1855 /* 1856 * Iterate over candidate debug images. 1857 * Keep track of "interesting" ones (those which have a symtab, dynsym, 1858 * and/or opd section) for processing. 1859 */ 1860 for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) { 1861 struct symsrc *ss = &ss_[ss_pos]; 1862 bool next_slot = false; 1863 bool is_reg; 1864 bool nsexit; 1865 int bfdrc = -1; 1866 int sirc = -1; 1867 1868 enum dso_binary_type symtab_type = binary_type_symtab[i]; 1869 1870 nsexit = (symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE || 1871 symtab_type == DSO_BINARY_TYPE__BUILD_ID_CACHE_DEBUGINFO); 1872 1873 if (!dso__is_compatible_symtab_type(dso, kmod, symtab_type)) 1874 continue; 1875 1876 if (dso__read_binary_type_filename(dso, symtab_type, 1877 root_dir, name, PATH_MAX)) 1878 continue; 1879 1880 if (nsexit) 1881 nsinfo__mountns_exit(&nsc); 1882 1883 is_reg = is_regular_file(name); 1884 if (!is_reg && errno == ENOENT && dso->nsinfo) { 1885 char *new_name = dso__filename_with_chroot(dso, name); 1886 if (new_name) { 1887 is_reg = is_regular_file(new_name); 1888 strlcpy(name, new_name, PATH_MAX); 1889 free(new_name); 1890 } 1891 } 1892 1893#ifdef HAVE_LIBBFD_SUPPORT 1894 if (is_reg) 1895 bfdrc = dso__load_bfd_symbols(dso, name); 1896#endif 1897 if (is_reg && bfdrc < 0) 1898 sirc = symsrc__init(ss, dso, name, symtab_type); 1899 1900 if (nsexit) 1901 nsinfo__mountns_enter(dso->nsinfo, &nsc); 1902 1903 if (bfdrc == 0) { 1904 ret = 0; 1905 break; 1906 } 1907 1908 if (!is_reg || sirc < 0) 1909 continue; 1910 1911 if (!syms_ss && symsrc__has_symtab(ss)) { 1912 syms_ss = ss; 1913 next_slot = true; 1914 if (!dso->symsrc_filename) 1915 dso->symsrc_filename = strdup(name); 1916 } 1917 1918 if (!runtime_ss && symsrc__possibly_runtime(ss)) { 1919 runtime_ss = ss; 1920 next_slot = true; 1921 } 1922 1923 if (next_slot) { 1924 ss_pos++; 1925 1926 if (syms_ss && runtime_ss) 1927 break; 1928 } else { 1929 symsrc__destroy(ss); 1930 } 1931 1932 } 1933 1934 if (!runtime_ss && !syms_ss) 1935 goto out_free; 1936 1937 if (runtime_ss && !syms_ss) { 1938 syms_ss = runtime_ss; 1939 } 1940 1941 /* We'll have to hope for the best */ 1942 if (!runtime_ss && syms_ss) 1943 runtime_ss = syms_ss; 1944 1945 if (syms_ss) 1946 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod); 1947 else 1948 ret = -1; 1949 1950 if (ret > 0) { 1951 int nr_plt; 1952 1953 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss); 1954 if (nr_plt > 0) 1955 ret += nr_plt; 1956 } 1957 1958 for (; ss_pos > 0; ss_pos--) 1959 symsrc__destroy(&ss_[ss_pos - 1]); 1960out_free: 1961 free(name); 1962 if (ret < 0 && strstr(dso->name, " (deleted)") != NULL) 1963 ret = 0; 1964out: 1965 dso__set_loaded(dso); 1966 mutex_unlock(&dso->lock); 1967 nsinfo__mountns_exit(&nsc); 1968 1969 return ret; 1970} 1971 1972int dso__load_vmlinux(struct dso *dso, struct map *map, 1973 const char *vmlinux, bool vmlinux_allocated) 1974{ 1975 int err = -1; 1976 struct symsrc ss; 1977 char symfs_vmlinux[PATH_MAX]; 1978 enum dso_binary_type symtab_type; 1979 1980 if (vmlinux[0] == '/') 1981 snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux); 1982 else 1983 symbol__join_symfs(symfs_vmlinux, vmlinux); 1984 1985 if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1986 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 1987 else 1988 symtab_type = DSO_BINARY_TYPE__VMLINUX; 1989 1990 if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type)) 1991 return -1; 1992 1993 /* 1994 * dso__load_sym() may copy 'dso' which will result in the copies having 1995 * an incorrect long name unless we set it here first. 1996 */ 1997 dso__set_long_name(dso, vmlinux, vmlinux_allocated); 1998 if (dso->kernel == DSO_SPACE__KERNEL_GUEST) 1999 dso->binary_type = DSO_BINARY_TYPE__GUEST_VMLINUX; 2000 else 2001 dso->binary_type = DSO_BINARY_TYPE__VMLINUX; 2002 2003 err = dso__load_sym(dso, map, &ss, &ss, 0); 2004 symsrc__destroy(&ss); 2005 2006 if (err > 0) { 2007 dso__set_loaded(dso); 2008 pr_debug("Using %s for symbols\n", symfs_vmlinux); 2009 } 2010 2011 return err; 2012} 2013 2014int dso__load_vmlinux_path(struct dso *dso, struct map *map) 2015{ 2016 int i, err = 0; 2017 char *filename = NULL; 2018 2019 pr_debug("Looking at the vmlinux_path (%d entries long)\n", 2020 vmlinux_path__nr_entries + 1); 2021 2022 for (i = 0; i < vmlinux_path__nr_entries; ++i) { 2023 err = dso__load_vmlinux(dso, map, vmlinux_path[i], false); 2024 if (err > 0) 2025 goto out; 2026 } 2027 2028 if (!symbol_conf.ignore_vmlinux_buildid) 2029 filename = dso__build_id_filename(dso, NULL, 0, false); 2030 if (filename != NULL) { 2031 err = dso__load_vmlinux(dso, map, filename, true); 2032 if (err > 0) 2033 goto out; 2034 free(filename); 2035 } 2036out: 2037 return err; 2038} 2039 2040static bool visible_dir_filter(const char *name, struct dirent *d) 2041{ 2042 if (d->d_type != DT_DIR) 2043 return false; 2044 return lsdir_no_dot_filter(name, d); 2045} 2046 2047static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz) 2048{ 2049 char kallsyms_filename[PATH_MAX]; 2050 int ret = -1; 2051 struct strlist *dirs; 2052 struct str_node *nd; 2053 2054 dirs = lsdir(dir, visible_dir_filter); 2055 if (!dirs) 2056 return -1; 2057 2058 strlist__for_each_entry(nd, dirs) { 2059 scnprintf(kallsyms_filename, sizeof(kallsyms_filename), 2060 "%s/%s/kallsyms", dir, nd->s); 2061 if (!validate_kcore_addresses(kallsyms_filename, map)) { 2062 strlcpy(dir, kallsyms_filename, dir_sz); 2063 ret = 0; 2064 break; 2065 } 2066 } 2067 2068 strlist__delete(dirs); 2069 2070 return ret; 2071} 2072 2073/* 2074 * Use open(O_RDONLY) to check readability directly instead of access(R_OK) 2075 * since access(R_OK) only checks with real UID/GID but open() use effective 2076 * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO). 2077 */ 2078static bool filename__readable(const char *file) 2079{ 2080 int fd = open(file, O_RDONLY); 2081 if (fd < 0) 2082 return false; 2083 close(fd); 2084 return true; 2085} 2086 2087static char *dso__find_kallsyms(struct dso *dso, struct map *map) 2088{ 2089 struct build_id bid; 2090 char sbuild_id[SBUILD_ID_SIZE]; 2091 bool is_host = false; 2092 char path[PATH_MAX]; 2093 2094 if (!dso->has_build_id) { 2095 /* 2096 * Last resort, if we don't have a build-id and couldn't find 2097 * any vmlinux file, try the running kernel kallsyms table. 2098 */ 2099 goto proc_kallsyms; 2100 } 2101 2102 if (sysfs__read_build_id("/sys/kernel/notes", &bid) == 0) 2103 is_host = dso__build_id_equal(dso, &bid); 2104 2105 /* Try a fast path for /proc/kallsyms if possible */ 2106 if (is_host) { 2107 /* 2108 * Do not check the build-id cache, unless we know we cannot use 2109 * /proc/kcore or module maps don't match to /proc/kallsyms. 2110 * To check readability of /proc/kcore, do not use access(R_OK) 2111 * since /proc/kcore requires CAP_SYS_RAWIO to read and access 2112 * can't check it. 2113 */ 2114 if (filename__readable("/proc/kcore") && 2115 !validate_kcore_addresses("/proc/kallsyms", map)) 2116 goto proc_kallsyms; 2117 } 2118 2119 build_id__sprintf(&dso->bid, sbuild_id); 2120 2121 /* Find kallsyms in build-id cache with kcore */ 2122 scnprintf(path, sizeof(path), "%s/%s/%s", 2123 buildid_dir, DSO__NAME_KCORE, sbuild_id); 2124 2125 if (!find_matching_kcore(map, path, sizeof(path))) 2126 return strdup(path); 2127 2128 /* Use current /proc/kallsyms if possible */ 2129 if (is_host) { 2130proc_kallsyms: 2131 return strdup("/proc/kallsyms"); 2132 } 2133 2134 /* Finally, find a cache of kallsyms */ 2135 if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) { 2136 pr_err("No kallsyms or vmlinux with build-id %s was found\n", 2137 sbuild_id); 2138 return NULL; 2139 } 2140 2141 return strdup(path); 2142} 2143 2144static int dso__load_kernel_sym(struct dso *dso, struct map *map) 2145{ 2146 int err; 2147 const char *kallsyms_filename = NULL; 2148 char *kallsyms_allocated_filename = NULL; 2149 char *filename = NULL; 2150 2151 /* 2152 * Step 1: if the user specified a kallsyms or vmlinux filename, use 2153 * it and only it, reporting errors to the user if it cannot be used. 2154 * 2155 * For instance, try to analyse an ARM perf.data file _without_ a 2156 * build-id, or if the user specifies the wrong path to the right 2157 * vmlinux file, obviously we can't fallback to another vmlinux (a 2158 * x86_86 one, on the machine where analysis is being performed, say), 2159 * or worse, /proc/kallsyms. 2160 * 2161 * If the specified file _has_ a build-id and there is a build-id 2162 * section in the perf.data file, we will still do the expected 2163 * validation in dso__load_vmlinux and will bail out if they don't 2164 * match. 2165 */ 2166 if (symbol_conf.kallsyms_name != NULL) { 2167 kallsyms_filename = symbol_conf.kallsyms_name; 2168 goto do_kallsyms; 2169 } 2170 2171 if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) { 2172 return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false); 2173 } 2174 2175 /* 2176 * Before checking on common vmlinux locations, check if it's 2177 * stored as standard build id binary (not kallsyms) under 2178 * .debug cache. 2179 */ 2180 if (!symbol_conf.ignore_vmlinux_buildid) 2181 filename = __dso__build_id_filename(dso, NULL, 0, false, false); 2182 if (filename != NULL) { 2183 err = dso__load_vmlinux(dso, map, filename, true); 2184 if (err > 0) 2185 return err; 2186 free(filename); 2187 } 2188 2189 if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) { 2190 err = dso__load_vmlinux_path(dso, map); 2191 if (err > 0) 2192 return err; 2193 } 2194 2195 /* do not try local files if a symfs was given */ 2196 if (symbol_conf.symfs[0] != 0) 2197 return -1; 2198 2199 kallsyms_allocated_filename = dso__find_kallsyms(dso, map); 2200 if (!kallsyms_allocated_filename) 2201 return -1; 2202 2203 kallsyms_filename = kallsyms_allocated_filename; 2204 2205do_kallsyms: 2206 err = dso__load_kallsyms(dso, kallsyms_filename, map); 2207 if (err > 0) 2208 pr_debug("Using %s for symbols\n", kallsyms_filename); 2209 free(kallsyms_allocated_filename); 2210 2211 if (err > 0 && !dso__is_kcore(dso)) { 2212 dso->binary_type = DSO_BINARY_TYPE__KALLSYMS; 2213 dso__set_long_name(dso, DSO__NAME_KALLSYMS, false); 2214 map__fixup_start(map); 2215 map__fixup_end(map); 2216 } 2217 2218 return err; 2219} 2220 2221static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map) 2222{ 2223 int err; 2224 const char *kallsyms_filename; 2225 struct machine *machine = maps__machine(map__kmaps(map)); 2226 char path[PATH_MAX]; 2227 2228 if (machine->kallsyms_filename) { 2229 kallsyms_filename = machine->kallsyms_filename; 2230 } else if (machine__is_default_guest(machine)) { 2231 /* 2232 * if the user specified a vmlinux filename, use it and only 2233 * it, reporting errors to the user if it cannot be used. 2234 * Or use file guest_kallsyms inputted by user on commandline 2235 */ 2236 if (symbol_conf.default_guest_vmlinux_name != NULL) { 2237 err = dso__load_vmlinux(dso, map, 2238 symbol_conf.default_guest_vmlinux_name, 2239 false); 2240 return err; 2241 } 2242 2243 kallsyms_filename = symbol_conf.default_guest_kallsyms; 2244 if (!kallsyms_filename) 2245 return -1; 2246 } else { 2247 sprintf(path, "%s/proc/kallsyms", machine->root_dir); 2248 kallsyms_filename = path; 2249 } 2250 2251 err = dso__load_kallsyms(dso, kallsyms_filename, map); 2252 if (err > 0) 2253 pr_debug("Using %s for symbols\n", kallsyms_filename); 2254 if (err > 0 && !dso__is_kcore(dso)) { 2255 dso->binary_type = DSO_BINARY_TYPE__GUEST_KALLSYMS; 2256 dso__set_long_name(dso, machine->mmap_name, false); 2257 map__fixup_start(map); 2258 map__fixup_end(map); 2259 } 2260 2261 return err; 2262} 2263 2264static void vmlinux_path__exit(void) 2265{ 2266 while (--vmlinux_path__nr_entries >= 0) 2267 zfree(&vmlinux_path[vmlinux_path__nr_entries]); 2268 vmlinux_path__nr_entries = 0; 2269 2270 zfree(&vmlinux_path); 2271} 2272 2273static const char * const vmlinux_paths[] = { 2274 "vmlinux", 2275 "/boot/vmlinux" 2276}; 2277 2278static const char * const vmlinux_paths_upd[] = { 2279 "/boot/vmlinux-%s", 2280 "/usr/lib/debug/boot/vmlinux-%s", 2281 "/lib/modules/%s/build/vmlinux", 2282 "/usr/lib/debug/lib/modules/%s/vmlinux", 2283 "/usr/lib/debug/boot/vmlinux-%s.debug" 2284}; 2285 2286static int vmlinux_path__add(const char *new_entry) 2287{ 2288 vmlinux_path[vmlinux_path__nr_entries] = strdup(new_entry); 2289 if (vmlinux_path[vmlinux_path__nr_entries] == NULL) 2290 return -1; 2291 ++vmlinux_path__nr_entries; 2292 2293 return 0; 2294} 2295 2296static int vmlinux_path__init(struct perf_env *env) 2297{ 2298 struct utsname uts; 2299 char bf[PATH_MAX]; 2300 char *kernel_version; 2301 unsigned int i; 2302 2303 vmlinux_path = malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) + 2304 ARRAY_SIZE(vmlinux_paths_upd))); 2305 if (vmlinux_path == NULL) 2306 return -1; 2307 2308 for (i = 0; i < ARRAY_SIZE(vmlinux_paths); i++) 2309 if (vmlinux_path__add(vmlinux_paths[i]) < 0) 2310 goto out_fail; 2311 2312 /* only try kernel version if no symfs was given */ 2313 if (symbol_conf.symfs[0] != 0) 2314 return 0; 2315 2316 if (env) { 2317 kernel_version = env->os_release; 2318 } else { 2319 if (uname(&uts) < 0) 2320 goto out_fail; 2321 2322 kernel_version = uts.release; 2323 } 2324 2325 for (i = 0; i < ARRAY_SIZE(vmlinux_paths_upd); i++) { 2326 snprintf(bf, sizeof(bf), vmlinux_paths_upd[i], kernel_version); 2327 if (vmlinux_path__add(bf) < 0) 2328 goto out_fail; 2329 } 2330 2331 return 0; 2332 2333out_fail: 2334 vmlinux_path__exit(); 2335 return -1; 2336} 2337 2338int setup_list(struct strlist **list, const char *list_str, 2339 const char *list_name) 2340{ 2341 if (list_str == NULL) 2342 return 0; 2343 2344 *list = strlist__new(list_str, NULL); 2345 if (!*list) { 2346 pr_err("problems parsing %s list\n", list_name); 2347 return -1; 2348 } 2349 2350 symbol_conf.has_filter = true; 2351 return 0; 2352} 2353 2354int setup_intlist(struct intlist **list, const char *list_str, 2355 const char *list_name) 2356{ 2357 if (list_str == NULL) 2358 return 0; 2359 2360 *list = intlist__new(list_str); 2361 if (!*list) { 2362 pr_err("problems parsing %s list\n", list_name); 2363 return -1; 2364 } 2365 return 0; 2366} 2367 2368static int setup_addrlist(struct intlist **addr_list, struct strlist *sym_list) 2369{ 2370 struct str_node *pos, *tmp; 2371 unsigned long val; 2372 char *sep; 2373 const char *end; 2374 int i = 0, err; 2375 2376 *addr_list = intlist__new(NULL); 2377 if (!*addr_list) 2378 return -1; 2379 2380 strlist__for_each_entry_safe(pos, tmp, sym_list) { 2381 errno = 0; 2382 val = strtoul(pos->s, &sep, 16); 2383 if (errno || (sep == pos->s)) 2384 continue; 2385 2386 if (*sep != '\0') { 2387 end = pos->s + strlen(pos->s) - 1; 2388 while (end >= sep && isspace(*end)) 2389 end--; 2390 2391 if (end >= sep) 2392 continue; 2393 } 2394 2395 err = intlist__add(*addr_list, val); 2396 if (err) 2397 break; 2398 2399 strlist__remove(sym_list, pos); 2400 i++; 2401 } 2402 2403 if (i == 0) { 2404 intlist__delete(*addr_list); 2405 *addr_list = NULL; 2406 } 2407 2408 return 0; 2409} 2410 2411static bool symbol__read_kptr_restrict(void) 2412{ 2413 bool value = false; 2414 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r"); 2415 2416 if (fp != NULL) { 2417 char line[8]; 2418 2419 if (fgets(line, sizeof(line), fp) != NULL) 2420 value = perf_cap__capable(CAP_SYSLOG) ? 2421 (atoi(line) >= 2) : 2422 (atoi(line) != 0); 2423 2424 fclose(fp); 2425 } 2426 2427 /* Per kernel/kallsyms.c: 2428 * we also restrict when perf_event_paranoid > 1 w/o CAP_SYSLOG 2429 */ 2430 if (perf_event_paranoid() > 1 && !perf_cap__capable(CAP_SYSLOG)) 2431 value = true; 2432 2433 return value; 2434} 2435 2436int symbol__annotation_init(void) 2437{ 2438 if (symbol_conf.init_annotation) 2439 return 0; 2440 2441 if (symbol_conf.initialized) { 2442 pr_err("Annotation needs to be init before symbol__init()\n"); 2443 return -1; 2444 } 2445 2446 symbol_conf.priv_size += sizeof(struct annotation); 2447 symbol_conf.init_annotation = true; 2448 return 0; 2449} 2450 2451int symbol__init(struct perf_env *env) 2452{ 2453 const char *symfs; 2454 2455 if (symbol_conf.initialized) 2456 return 0; 2457 2458 symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64)); 2459 2460 symbol__elf_init(); 2461 2462 if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0) 2463 return -1; 2464 2465 if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') { 2466 pr_err("'.' is the only non valid --field-separator argument\n"); 2467 return -1; 2468 } 2469 2470 if (setup_list(&symbol_conf.dso_list, 2471 symbol_conf.dso_list_str, "dso") < 0) 2472 return -1; 2473 2474 if (setup_list(&symbol_conf.comm_list, 2475 symbol_conf.comm_list_str, "comm") < 0) 2476 goto out_free_dso_list; 2477 2478 if (setup_intlist(&symbol_conf.pid_list, 2479 symbol_conf.pid_list_str, "pid") < 0) 2480 goto out_free_comm_list; 2481 2482 if (setup_intlist(&symbol_conf.tid_list, 2483 symbol_conf.tid_list_str, "tid") < 0) 2484 goto out_free_pid_list; 2485 2486 if (setup_list(&symbol_conf.sym_list, 2487 symbol_conf.sym_list_str, "symbol") < 0) 2488 goto out_free_tid_list; 2489 2490 if (symbol_conf.sym_list && 2491 setup_addrlist(&symbol_conf.addr_list, symbol_conf.sym_list) < 0) 2492 goto out_free_sym_list; 2493 2494 if (setup_list(&symbol_conf.bt_stop_list, 2495 symbol_conf.bt_stop_list_str, "symbol") < 0) 2496 goto out_free_sym_list; 2497 2498 /* 2499 * A path to symbols of "/" is identical to "" 2500 * reset here for simplicity. 2501 */ 2502 symfs = realpath(symbol_conf.symfs, NULL); 2503 if (symfs == NULL) 2504 symfs = symbol_conf.symfs; 2505 if (strcmp(symfs, "/") == 0) 2506 symbol_conf.symfs = ""; 2507 if (symfs != symbol_conf.symfs) 2508 free((void *)symfs); 2509 2510 symbol_conf.kptr_restrict = symbol__read_kptr_restrict(); 2511 2512 symbol_conf.initialized = true; 2513 return 0; 2514 2515out_free_sym_list: 2516 strlist__delete(symbol_conf.sym_list); 2517 intlist__delete(symbol_conf.addr_list); 2518out_free_tid_list: 2519 intlist__delete(symbol_conf.tid_list); 2520out_free_pid_list: 2521 intlist__delete(symbol_conf.pid_list); 2522out_free_comm_list: 2523 strlist__delete(symbol_conf.comm_list); 2524out_free_dso_list: 2525 strlist__delete(symbol_conf.dso_list); 2526 return -1; 2527} 2528 2529void symbol__exit(void) 2530{ 2531 if (!symbol_conf.initialized) 2532 return; 2533 strlist__delete(symbol_conf.bt_stop_list); 2534 strlist__delete(symbol_conf.sym_list); 2535 strlist__delete(symbol_conf.dso_list); 2536 strlist__delete(symbol_conf.comm_list); 2537 intlist__delete(symbol_conf.tid_list); 2538 intlist__delete(symbol_conf.pid_list); 2539 intlist__delete(symbol_conf.addr_list); 2540 vmlinux_path__exit(); 2541 symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL; 2542 symbol_conf.bt_stop_list = NULL; 2543 symbol_conf.initialized = false; 2544} 2545 2546int symbol__config_symfs(const struct option *opt __maybe_unused, 2547 const char *dir, int unset __maybe_unused) 2548{ 2549 char *bf = NULL; 2550 int ret; 2551 2552 symbol_conf.symfs = strdup(dir); 2553 if (symbol_conf.symfs == NULL) 2554 return -ENOMEM; 2555 2556 /* skip the locally configured cache if a symfs is given, and 2557 * config buildid dir to symfs/.debug 2558 */ 2559 ret = asprintf(&bf, "%s/%s", dir, ".debug"); 2560 if (ret < 0) 2561 return -ENOMEM; 2562 2563 set_buildid_dir(bf); 2564 2565 free(bf); 2566 return 0; 2567} 2568 2569struct mem_info *mem_info__get(struct mem_info *mi) 2570{ 2571 if (mi) 2572 refcount_inc(&mi->refcnt); 2573 return mi; 2574} 2575 2576void mem_info__put(struct mem_info *mi) 2577{ 2578 if (mi && refcount_dec_and_test(&mi->refcnt)) { 2579 addr_map_symbol__exit(&mi->iaddr); 2580 addr_map_symbol__exit(&mi->daddr); 2581 free(mi); 2582 } 2583} 2584 2585struct mem_info *mem_info__new(void) 2586{ 2587 struct mem_info *mi = zalloc(sizeof(*mi)); 2588 2589 if (mi) 2590 refcount_set(&mi->refcnt, 1); 2591 return mi; 2592} 2593 2594/* 2595 * Checks that user supplied symbol kernel files are accessible because 2596 * the default mechanism for accessing elf files fails silently. i.e. if 2597 * debug syms for a build ID aren't found perf carries on normally. When 2598 * they are user supplied we should assume that the user doesn't want to 2599 * silently fail. 2600 */ 2601int symbol__validate_sym_arguments(void) 2602{ 2603 if (symbol_conf.vmlinux_name && 2604 access(symbol_conf.vmlinux_name, R_OK)) { 2605 pr_err("Invalid file: %s\n", symbol_conf.vmlinux_name); 2606 return -EINVAL; 2607 } 2608 if (symbol_conf.kallsyms_name && 2609 access(symbol_conf.kallsyms_name, R_OK)) { 2610 pr_err("Invalid file: %s\n", symbol_conf.kallsyms_name); 2611 return -EINVAL; 2612 } 2613 return 0; 2614} 2615