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