tools/perf/util/symbol.c

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