kernel/tools/perf/util/symbol.c

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