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