tools/perf/util/symbol.c

   1 #define _GNU_SOURCE
   2 #include <ctype.h>
   3 #include <dirent.h>
   4 #include <errno.h>
   5 #include <libgen.h>
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <sys/param.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14 #include <inttypes.h>
  15 #include "build-id.h"
  16 #include "debug.h"
  17 #include "symbol.h"
  18 #include "strlist.h"
  19
  20 #include <libelf.h>
  21 #include <gelf.h>
  22 #include <elf.h>
  23 #include <limits.h>
  24 #include <sys/utsname.h>
  25
  26 #ifndef KSYM_NAME_LEN
  27 #define KSYM_NAME_LEN 256
  28 #endif
  29
  30 #ifndef NT_GNU_BUILD_ID
  31 #define NT_GNU_BUILD_ID 3
  32 #endif
  33
  34 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
  35 static int elf_read_build_id(Elf *elf, void *bf, size_t size);
  36 static void dsos__add(struct list_head *head, struct dso *dso);
  37 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
  38 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
  39                                 symbol_filter_t filter);
  40 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
  41                         symbol_filter_t filter);
  42 static int vmlinux_path__nr_entries;
  43 static char **vmlinux_path;
  44
  45 struct symbol_conf symbol_conf = {
  46         .exclude_other    = true,
  47         .use_modules      = true,
  48         .try_vmlinux_path = true,
  49         .annotate_src     = true,
  50         .symfs            = "",
  51 };
  52
  53 int dso__name_len(const struct dso *dso)
  54 {
  55         if (verbose)
  56                 return dso->long_name_len;
  57
  58         return dso->short_name_len;
  59 }
  60
  61 bool dso__loaded(const struct dso *dso, enum map_type type)
  62 {
  63         return dso->loaded & (1 << type);
  64 }
  65
  66 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
  67 {
  68         return dso->sorted_by_name & (1 << type);
  69 }
  70
  71 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
  72 {
  73         dso->sorted_by_name |= (1 << type);
  74 }
  75
  76 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
  77 {
  78         symbol_type = toupper(symbol_type);
  79
  80         switch (map_type) {
  81         case MAP__FUNCTION:
  82                 return symbol_type == 'T' || symbol_type == 'W';
  83         case MAP__VARIABLE:
  84                 return symbol_type == 'D';
  85         default:
  86                 return false;
  87         }
  88 }
  89
  90 static int prefix_underscores_count(const char *str)
  91 {
  92         const char *tail = str;
  93
  94         while (*tail == '_')
  95                 tail++;
  96
  97         return tail - str;
  98 }
  99
 100 #define SYMBOL_A 0
 101 #define SYMBOL_B 1
 102
 103 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 104 {
 105         s64 a;
 106         s64 b;
 107
 108         /* Prefer a symbol with non zero length */
 109         a = syma->end - syma->start;
 110         b = symb->end - symb->start;
 111         if ((b == 0) && (a > 0))
 112                 return SYMBOL_A;
 113         else if ((a == 0) && (b > 0))
 114                 return SYMBOL_B;
 115
 116         /* Prefer a non weak symbol over a weak one */
 117         a = syma->binding == STB_WEAK;
 118         b = symb->binding == STB_WEAK;
 119         if (b && !a)
 120                 return SYMBOL_A;
 121         if (a && !b)
 122                 return SYMBOL_B;
 123
 124         /* Prefer a global symbol over a non global one */
 125         a = syma->binding == STB_GLOBAL;
 126         b = symb->binding == STB_GLOBAL;
 127         if (a && !b)
 128                 return SYMBOL_A;
 129         if (b && !a)
 130                 return SYMBOL_B;
 131
 132         /* Prefer a symbol with less underscores */
 133         a = prefix_underscores_count(syma->name);
 134         b = prefix_underscores_count(symb->name);
 135         if (b > a)
 136                 return SYMBOL_A;
 137         else if (a > b)
 138                 return SYMBOL_B;
 139
 140         /* If all else fails, choose the symbol with the longest name */
 141         if (strlen(syma->name) >= strlen(symb->name))
 142                 return SYMBOL_A;
 143         else
 144                 return SYMBOL_B;
 145 }
 146
 147 static void symbols__fixup_duplicate(struct rb_root *symbols)
 148 {
 149         struct rb_node *nd;
 150         struct symbol *curr, *next;
 151
 152         nd = rb_first(symbols);
 153
 154         while (nd) {
 155                 curr = rb_entry(nd, struct symbol, rb_node);
 156 again:
 157                 nd = rb_next(&curr->rb_node);
 158                 next = rb_entry(nd, struct symbol, rb_node);
 159
 160                 if (!nd)
 161                         break;
 162
 163                 if (curr->start != next->start)
 164                         continue;
 165
 166                 if (choose_best_symbol(curr, next) == SYMBOL_A) {
 167                         rb_erase(&next->rb_node, symbols);
 168                         goto again;
 169                 } else {
 170                         nd = rb_next(&curr->rb_node);
 171                         rb_erase(&curr->rb_node, symbols);
 172                 }
 173         }
 174 }
 175
 176 static void symbols__fixup_end(struct rb_root *symbols)
 177 {
 178         struct rb_node *nd, *prevnd = rb_first(symbols);
 179         struct symbol *curr, *prev;
 180
 181         if (prevnd == NULL)
 182                 return;
 183
 184         curr = rb_entry(prevnd, struct symbol, rb_node);
 185
 186         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 187                 prev = curr;
 188                 curr = rb_entry(nd, struct symbol, rb_node);
 189
 190                 if (prev->end == prev->start && prev->end != curr->start)
 191                         prev->end = curr->start - 1;
 192         }
 193
 194         /* Last entry */
 195         if (curr->end == curr->start)
 196                 curr->end = roundup(curr->start, 4096);
 197 }
 198
 199 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 200 {
 201         struct map *prev, *curr;
 202         struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 203
 204         if (prevnd == NULL)
 205                 return;
 206
 207         curr = rb_entry(prevnd, struct map, rb_node);
 208
 209         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 210                 prev = curr;
 211                 curr = rb_entry(nd, struct map, rb_node);
 212                 prev->end = curr->start - 1;
 213         }
 214
 215         /*
 216          * We still haven't the actual symbols, so guess the
 217          * last map final address.
 218          */
 219         curr->end = ~0ULL;
 220 }
 221
 222 static void map_groups__fixup_end(struct map_groups *mg)
 223 {
 224         int i;
 225         for (i = 0; i < MAP__NR_TYPES; ++i)
 226                 __map_groups__fixup_end(mg, i);
 227 }
 228
 229 static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
 230                                   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 - 1 : 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 static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 259 {
 260         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 261                        sym->start, sym->end,
 262                        sym->binding == STB_GLOBAL ? 'g' :
 263                        sym->binding == STB_LOCAL  ? 'l' : 'w',
 264                        sym->name);
 265 }
 266
 267 void dso__set_long_name(struct dso *dso, char *name)
 268 {
 269         if (name == NULL)
 270                 return;
 271         dso->long_name = name;
 272         dso->long_name_len = strlen(name);
 273 }
 274
 275 static void dso__set_short_name(struct dso *dso, const char *name)
 276 {
 277         if (name == NULL)
 278                 return;
 279         dso->short_name = name;
 280         dso->short_name_len = strlen(name);
 281 }
 282
 283 static void dso__set_basename(struct dso *dso)
 284 {
 285         dso__set_short_name(dso, basename(dso->long_name));
 286 }
 287
 288 struct dso *dso__new(const char *name)
 289 {
 290         struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
 291
 292         if (dso != NULL) {
 293                 int i;
 294                 strcpy(dso->name, name);
 295                 dso__set_long_name(dso, dso->name);
 296                 dso__set_short_name(dso, dso->name);
 297                 for (i = 0; i < MAP__NR_TYPES; ++i)
 298                         dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
 299                 dso->symtab_type = SYMTAB__NOT_FOUND;
 300                 dso->loaded = 0;
 301                 dso->sorted_by_name = 0;
 302                 dso->has_build_id = 0;
 303                 dso->kernel = DSO_TYPE_USER;
 304                 INIT_LIST_HEAD(&dso->node);
 305         }
 306
 307         return dso;
 308 }
 309
 310 static void symbols__delete(struct rb_root *symbols)
 311 {
 312         struct symbol *pos;
 313         struct rb_node *next = rb_first(symbols);
 314
 315         while (next) {
 316                 pos = rb_entry(next, struct symbol, rb_node);
 317                 next = rb_next(&pos->rb_node);
 318                 rb_erase(&pos->rb_node, symbols);
 319                 symbol__delete(pos);
 320         }
 321 }
 322
 323 void dso__delete(struct dso *dso)
 324 {
 325         int i;
 326         for (i = 0; i < MAP__NR_TYPES; ++i)
 327                 symbols__delete(&dso->symbols[i]);
 328         if (dso->sname_alloc)
 329                 free((char *)dso->short_name);
 330         if (dso->lname_alloc)
 331                 free(dso->long_name);
 332         free(dso);
 333 }
 334
 335 void dso__set_build_id(struct dso *dso, void *build_id)
 336 {
 337         memcpy(dso->build_id, build_id, sizeof(dso->build_id));
 338         dso->has_build_id = 1;
 339 }
 340
 341 static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 342 {
 343         struct rb_node **p = &symbols->rb_node;
 344         struct rb_node *parent = NULL;
 345         const u64 ip = sym->start;
 346         struct symbol *s;
 347
 348         while (*p != NULL) {
 349                 parent = *p;
 350                 s = rb_entry(parent, struct symbol, rb_node);
 351                 if (ip < s->start)
 352                         p = &(*p)->rb_left;
 353                 else
 354                         p = &(*p)->rb_right;
 355         }
 356         rb_link_node(&sym->rb_node, parent, p);
 357         rb_insert_color(&sym->rb_node, symbols);
 358 }
 359
 360 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 361 {
 362         struct rb_node *n;
 363
 364         if (symbols == NULL)
 365                 return NULL;
 366
 367         n = symbols->rb_node;
 368
 369         while (n) {
 370                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 371
 372                 if (ip < s->start)
 373                         n = n->rb_left;
 374                 else if (ip > s->end)
 375                         n = n->rb_right;
 376                 else
 377                         return s;
 378         }
 379
 380         return NULL;
 381 }
 382
 383 struct symbol_name_rb_node {
 384         struct rb_node  rb_node;
 385         struct symbol   sym;
 386 };
 387
 388 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 389 {
 390         struct rb_node **p = &symbols->rb_node;
 391         struct rb_node *parent = NULL;
 392         struct symbol_name_rb_node *symn, *s;
 393
 394         symn = container_of(sym, struct symbol_name_rb_node, sym);
 395
 396         while (*p != NULL) {
 397                 parent = *p;
 398                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 399                 if (strcmp(sym->name, s->sym.name) < 0)
 400                         p = &(*p)->rb_left;
 401                 else
 402                         p = &(*p)->rb_right;
 403         }
 404         rb_link_node(&symn->rb_node, parent, p);
 405         rb_insert_color(&symn->rb_node, symbols);
 406 }
 407
 408 static void symbols__sort_by_name(struct rb_root *symbols,
 409                                   struct rb_root *source)
 410 {
 411         struct rb_node *nd;
 412
 413         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 414                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 415                 symbols__insert_by_name(symbols, pos);
 416         }
 417 }
 418
 419 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 420                                             const char *name)
 421 {
 422         struct rb_node *n;
 423
 424         if (symbols == NULL)
 425                 return NULL;
 426
 427         n = symbols->rb_node;
 428
 429         while (n) {
 430                 struct symbol_name_rb_node *s;
 431                 int cmp;
 432
 433                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 434                 cmp = strcmp(name, s->sym.name);
 435
 436                 if (cmp < 0)
 437                         n = n->rb_left;
 438                 else if (cmp > 0)
 439                         n = n->rb_right;
 440                 else
 441                         return &s->sym;
 442         }
 443
 444         return NULL;
 445 }
 446
 447 struct symbol *dso__find_symbol(struct dso *dso,
 448                                 enum map_type type, u64 addr)
 449 {
 450         return symbols__find(&dso->symbols[type], addr);
 451 }
 452
 453 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 454                                         const char *name)
 455 {
 456         return symbols__find_by_name(&dso->symbol_names[type], name);
 457 }
 458
 459 void dso__sort_by_name(struct dso *dso, enum map_type type)
 460 {
 461         dso__set_sorted_by_name(dso, type);
 462         return symbols__sort_by_name(&dso->symbol_names[type],
 463                                      &dso->symbols[type]);
 464 }
 465
 466 int build_id__sprintf(const u8 *build_id, int len, char *bf)
 467 {
 468         char *bid = bf;
 469         const u8 *raw = build_id;
 470         int i;
 471
 472         for (i = 0; i < len; ++i) {
 473                 sprintf(bid, "%02x", *raw);
 474                 ++raw;
 475                 bid += 2;
 476         }
 477
 478         return raw - build_id;
 479 }
 480
 481 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
 482 {
 483         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 484
 485         build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
 486         return fprintf(fp, "%s", sbuild_id);
 487 }
 488
 489 size_t dso__fprintf_symbols_by_name(struct dso *dso,
 490                                     enum map_type type, FILE *fp)
 491 {
 492         size_t ret = 0;
 493         struct rb_node *nd;
 494         struct symbol_name_rb_node *pos;
 495
 496         for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 497                 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 498                 fprintf(fp, "%s\n", pos->sym.name);
 499         }
 500
 501         return ret;
 502 }
 503
 504 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
 505 {
 506         struct rb_node *nd;
 507         size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
 508
 509         if (dso->short_name != dso->long_name)
 510                 ret += fprintf(fp, "%s, ", dso->long_name);
 511         ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
 512                        dso->loaded ? "" : "NOT ");
 513         ret += dso__fprintf_buildid(dso, fp);
 514         ret += fprintf(fp, ")\n");
 515         for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
 516                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 517                 ret += symbol__fprintf(pos, fp);
 518         }
 519
 520         return ret;
 521 }
 522
 523 int kallsyms__parse(const char *filename, void *arg,
 524                     int (*process_symbol)(void *arg, const char *name,
 525                                           char type, u64 start, u64 end))
 526 {
 527         char *line = NULL;
 528         size_t n;
 529         int err = -1;
 530         FILE *file = fopen(filename, "r");
 531
 532         if (file == NULL)
 533                 goto out_failure;
 534
 535         err = 0;
 536
 537         while (!feof(file)) {
 538                 u64 start;
 539                 int line_len, len;
 540                 char symbol_type;
 541                 char *symbol_name;
 542
 543                 line_len = getline(&line, &n, file);
 544                 if (line_len < 0 || !line)
 545                         break;
 546
 547                 line[--line_len] = '\0'; /* \n */
 548
 549                 len = hex2u64(line, &start);
 550
 551                 len++;
 552                 if (len + 2 >= line_len)
 553                         continue;
 554
 555                 symbol_type = line[len];
 556                 len += 2;
 557                 symbol_name = line + len;
 558                 len = line_len - len;
 559
 560                 if (len >= KSYM_NAME_LEN) {
 561                         err = -1;
 562                         break;
 563                 }
 564
 565                 /*
 566                  * module symbols are not sorted so we add all
 567                  * symbols with zero length and rely on
 568                  * symbols__fixup_end() to fix it up.
 569                  */
 570                 err = process_symbol(arg, symbol_name,
 571                                      symbol_type, start, start);
 572                 if (err)
 573                         break;
 574         }
 575
 576         free(line);
 577         fclose(file);
 578         return err;
 579
 580 out_failure:
 581         return -1;
 582 }
 583
 584 struct process_kallsyms_args {
 585         struct map *map;
 586         struct dso *dso;
 587 };
 588
 589 static u8 kallsyms2elf_type(char type)
 590 {
 591         if (type == 'W')
 592                 return STB_WEAK;
 593
 594         return isupper(type) ? STB_GLOBAL : STB_LOCAL;
 595 }
 596
 597 static int map__process_kallsym_symbol(void *arg, const char *name,
 598                                        char type, u64 start, u64 end)
 599 {
 600         struct symbol *sym;
 601         struct process_kallsyms_args *a = arg;
 602         struct rb_root *root = &a->dso->symbols[a->map->type];
 603
 604         if (!symbol_type__is_a(type, a->map->type))
 605                 return 0;
 606
 607         sym = symbol__new(start, end - start + 1,
 608                           kallsyms2elf_type(type), name);
 609         if (sym == NULL)
 610                 return -ENOMEM;
 611         /*
 612          * We will pass the symbols to the filter later, in
 613          * map__split_kallsyms, when we have split the maps per module
 614          */
 615         symbols__insert(root, sym);
 616
 617         return 0;
 618 }
 619
 620 /*
 621  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 622  * so that we can in the next step set the symbol ->end address and then
 623  * call kernel_maps__split_kallsyms.
 624  */
 625 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 626                                   struct map *map)
 627 {
 628         struct process_kallsyms_args args = { .map = map, .dso = dso, };
 629         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 630 }
 631
 632 /*
 633  * Split the symbols into maps, making sure there are no overlaps, i.e. the
 634  * kernel range is broken in several maps, named [kernel].N, as we don't have
 635  * the original ELF section names vmlinux have.
 636  */
 637 static int dso__split_kallsyms(struct dso *dso, struct map *map,
 638                                symbol_filter_t filter)
 639 {
 640         struct map_groups *kmaps = map__kmap(map)->kmaps;
 641         struct machine *machine = kmaps->machine;
 642         struct map *curr_map = map;
 643         struct symbol *pos;
 644         int count = 0, moved = 0;
 645         struct rb_root *root = &dso->symbols[map->type];
 646         struct rb_node *next = rb_first(root);
 647         int kernel_range = 0;
 648
 649         while (next) {
 650                 char *module;
 651
 652                 pos = rb_entry(next, struct symbol, rb_node);
 653                 next = rb_next(&pos->rb_node);
 654
 655                 module = strchr(pos->name, '\t');
 656                 if (module) {
 657                         if (!symbol_conf.use_modules)
 658                                 goto discard_symbol;
 659
 660                         *module++ = '\0';
 661
 662                         if (strcmp(curr_map->dso->short_name, module)) {
 663                                 if (curr_map != map &&
 664                                     dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 665                                     machine__is_default_guest(machine)) {
 666                                         /*
 667                                          * We assume all symbols of a module are
 668                                          * continuous in * kallsyms, so curr_map
 669                                          * points to a module and all its
 670                                          * symbols are in its kmap. Mark it as
 671                                          * loaded.
 672                                          */
 673                                         dso__set_loaded(curr_map->dso,
 674                                                         curr_map->type);
 675                                 }
 676
 677                                 curr_map = map_groups__find_by_name(kmaps,
 678                                                         map->type, module);
 679                                 if (curr_map == NULL) {
 680                                         pr_debug("%s/proc/{kallsyms,modules} "
 681                                                  "inconsistency while looking "
 682                                                  "for \"%s\" module!\n",
 683                                                  machine->root_dir, module);
 684                                         curr_map = map;
 685                                         goto discard_symbol;
 686                                 }
 687
 688                                 if (curr_map->dso->loaded &&
 689                                     !machine__is_default_guest(machine))
 690                                         goto discard_symbol;
 691                         }
 692                         /*
 693                          * So that we look just like we get from .ko files,
 694                          * i.e. not prelinked, relative to map->start.
 695                          */
 696                         pos->start = curr_map->map_ip(curr_map, pos->start);
 697                         pos->end   = curr_map->map_ip(curr_map, pos->end);
 698                 } else if (curr_map != map) {
 699                         char dso_name[PATH_MAX];
 700                         struct dso *ndso;
 701
 702                         if (count == 0) {
 703                                 curr_map = map;
 704                                 goto filter_symbol;
 705                         }
 706
 707                         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 708                                 snprintf(dso_name, sizeof(dso_name),
 709                                         "[guest.kernel].%d",
 710                                         kernel_range++);
 711                         else
 712                                 snprintf(dso_name, sizeof(dso_name),
 713                                         "[kernel].%d",
 714                                         kernel_range++);
 715
 716                         ndso = dso__new(dso_name);
 717                         if (ndso == NULL)
 718                                 return -1;
 719
 720                         ndso->kernel = dso->kernel;
 721
 722                         curr_map = map__new2(pos->start, ndso, map->type);
 723                         if (curr_map == NULL) {
 724                                 dso__delete(ndso);
 725                                 return -1;
 726                         }
 727
 728                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 729                         map_groups__insert(kmaps, curr_map);
 730                         ++kernel_range;
 731                 }
 732 filter_symbol:
 733                 if (filter && filter(curr_map, pos)) {
 734 discard_symbol:         rb_erase(&pos->rb_node, root);
 735                         symbol__delete(pos);
 736                 } else {
 737                         if (curr_map != map) {
 738                                 rb_erase(&pos->rb_node, root);
 739                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 740                                 ++moved;
 741                         } else
 742                                 ++count;
 743                 }
 744         }
 745
 746         if (curr_map != map &&
 747             dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 748             machine__is_default_guest(kmaps->machine)) {
 749                 dso__set_loaded(curr_map->dso, curr_map->type);
 750         }
 751
 752         return count + moved;
 753 }
 754
 755 static bool symbol__restricted_filename(const char *filename,
 756                                         const char *restricted_filename)
 757 {
 758         bool restricted = false;
 759
 760         if (symbol_conf.kptr_restrict) {
 761                 char *r = realpath(filename, NULL);
 762
 763                 if (r != NULL) {
 764                         restricted = strcmp(r, restricted_filename) == 0;
 765                         free(r);
 766                         return restricted;
 767                 }
 768         }
 769
 770         return restricted;
 771 }
 772
 773 int dso__load_kallsyms(struct dso *dso, const char *filename,
 774                        struct map *map, symbol_filter_t filter)
 775 {
 776         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 777                 return -1;
 778
 779         if (dso__load_all_kallsyms(dso, filename, map) < 0)
 780                 return -1;
 781
 782         symbols__fixup_duplicate(&dso->symbols[map->type]);
 783         symbols__fixup_end(&dso->symbols[map->type]);
 784
 785         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 786                 dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
 787         else
 788                 dso->symtab_type = SYMTAB__KALLSYMS;
 789
 790         return dso__split_kallsyms(dso, map, filter);
 791 }
 792
 793 static int dso__load_perf_map(struct dso *dso, struct map *map,
 794                               symbol_filter_t filter)
 795 {
 796         char *line = NULL;
 797         size_t n;
 798         FILE *file;
 799         int nr_syms = 0;
 800
 801         file = fopen(dso->long_name, "r");
 802         if (file == NULL)
 803                 goto out_failure;
 804
 805         while (!feof(file)) {
 806                 u64 start, size;
 807                 struct symbol *sym;
 808                 int line_len, len;
 809
 810                 line_len = getline(&line, &n, file);
 811                 if (line_len < 0)
 812                         break;
 813
 814                 if (!line)
 815                         goto out_failure;
 816
 817                 line[--line_len] = '\0'; /* \n */
 818
 819                 len = hex2u64(line, &start);
 820
 821                 len++;
 822                 if (len + 2 >= line_len)
 823                         continue;
 824
 825                 len += hex2u64(line + len, &size);
 826
 827                 len++;
 828                 if (len + 2 >= line_len)
 829                         continue;
 830
 831                 sym = symbol__new(start, size, STB_GLOBAL, line + len);
 832
 833                 if (sym == NULL)
 834                         goto out_delete_line;
 835
 836                 if (filter && filter(map, sym))
 837                         symbol__delete(sym);
 838                 else {
 839                         symbols__insert(&dso->symbols[map->type], sym);
 840                         nr_syms++;
 841                 }
 842         }
 843
 844         free(line);
 845         fclose(file);
 846
 847         return nr_syms;
 848
 849 out_delete_line:
 850         free(line);
 851 out_failure:
 852         return -1;
 853 }
 854
 855 /**
 856  * elf_symtab__for_each_symbol - iterate thru all the symbols
 857  *
 858  * @syms: struct elf_symtab instance to iterate
 859  * @idx: uint32_t idx
 860  * @sym: GElf_Sym iterator
 861  */
 862 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 863         for (idx = 0, gelf_getsym(syms, idx, &sym);\
 864              idx < nr_syms; \
 865              idx++, gelf_getsym(syms, idx, &sym))
 866
 867 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 868 {
 869         return GELF_ST_TYPE(sym->st_info);
 870 }
 871
 872 static inline int elf_sym__is_function(const GElf_Sym *sym)
 873 {
 874         return elf_sym__type(sym) == STT_FUNC &&
 875                sym->st_name != 0 &&
 876                sym->st_shndx != SHN_UNDEF;
 877 }
 878
 879 static inline bool elf_sym__is_object(const GElf_Sym *sym)
 880 {
 881         return elf_sym__type(sym) == STT_OBJECT &&
 882                 sym->st_name != 0 &&
 883                 sym->st_shndx != SHN_UNDEF;
 884 }
 885
 886 static inline int elf_sym__is_label(const GElf_Sym *sym)
 887 {
 888         return elf_sym__type(sym) == STT_NOTYPE &&
 889                 sym->st_name != 0 &&
 890                 sym->st_shndx != SHN_UNDEF &&
 891                 sym->st_shndx != SHN_ABS;
 892 }
 893
 894 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 895                                         const Elf_Data *secstrs)
 896 {
 897         return secstrs->d_buf + shdr->sh_name;
 898 }
 899
 900 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 901                                         const Elf_Data *secstrs)
 902 {
 903         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 904 }
 905
 906 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 907                                     const Elf_Data *secstrs)
 908 {
 909         return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 910 }
 911
 912 static inline const char *elf_sym__name(const GElf_Sym *sym,
 913                                         const Elf_Data *symstrs)
 914 {
 915         return symstrs->d_buf + sym->st_name;
 916 }
 917
 918 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 919                                     GElf_Shdr *shp, const char *name,
 920                                     size_t *idx)
 921 {
 922         Elf_Scn *sec = NULL;
 923         size_t cnt = 1;
 924
 925         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 926                 char *str;
 927
 928                 gelf_getshdr(sec, shp);
 929                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 930                 if (!strcmp(name, str)) {
 931                         if (idx)
 932                                 *idx = cnt;
 933                         break;
 934                 }
 935                 ++cnt;
 936         }
 937
 938         return sec;
 939 }
 940
 941 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 942         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 943              idx < nr_entries; \
 944              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 945
 946 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 947         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 948              idx < nr_entries; \
 949              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 950
 951 /*
 952  * We need to check if we have a .dynsym, so that we can handle the
 953  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 954  * .dynsym or .symtab).
 955  * And always look at the original dso, not at debuginfo packages, that
 956  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 957  */
 958 static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
 959                                        symbol_filter_t filter)
 960 {
 961         uint32_t nr_rel_entries, idx;
 962         GElf_Sym sym;
 963         u64 plt_offset;
 964         GElf_Shdr shdr_plt;
 965         struct symbol *f;
 966         GElf_Shdr shdr_rel_plt, shdr_dynsym;
 967         Elf_Data *reldata, *syms, *symstrs;
 968         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 969         size_t dynsym_idx;
 970         GElf_Ehdr ehdr;
 971         char sympltname[1024];
 972         Elf *elf;
 973         int nr = 0, symidx, fd, err = 0;
 974         char name[PATH_MAX];
 975
 976         snprintf(name, sizeof(name), "%s%s",
 977                  symbol_conf.symfs, dso->long_name);
 978         fd = open(name, O_RDONLY);
 979         if (fd < 0)
 980                 goto out;
 981
 982         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 983         if (elf == NULL)
 984                 goto out_close;
 985
 986         if (gelf_getehdr(elf, &ehdr) == NULL)
 987                 goto out_elf_end;
 988
 989         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 990                                          ".dynsym", &dynsym_idx);
 991         if (scn_dynsym == NULL)
 992                 goto out_elf_end;
 993
 994         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 995                                           ".rela.plt", NULL);
 996         if (scn_plt_rel == NULL) {
 997                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 998                                                   ".rel.plt", NULL);
 999                 if (scn_plt_rel == NULL)
1000                         goto out_elf_end;
1001         }
1002
1003         err = -1;
1004
1005         if (shdr_rel_plt.sh_link != dynsym_idx)
1006                 goto out_elf_end;
1007
1008         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
1009                 goto out_elf_end;
1010
1011         /*
1012          * Fetch the relocation section to find the idxes to the GOT
1013          * and the symbols in the .dynsym they refer to.
1014          */
1015         reldata = elf_getdata(scn_plt_rel, NULL);
1016         if (reldata == NULL)
1017                 goto out_elf_end;
1018
1019         syms = elf_getdata(scn_dynsym, NULL);
1020         if (syms == NULL)
1021                 goto out_elf_end;
1022
1023         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
1024         if (scn_symstrs == NULL)
1025                 goto out_elf_end;
1026
1027         symstrs = elf_getdata(scn_symstrs, NULL);
1028         if (symstrs == NULL)
1029                 goto out_elf_end;
1030
1031         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
1032         plt_offset = shdr_plt.sh_offset;
1033
1034         if (shdr_rel_plt.sh_type == SHT_RELA) {
1035                 GElf_Rela pos_mem, *pos;
1036
1037                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
1038                                            nr_rel_entries) {
1039                         symidx = GELF_R_SYM(pos->r_info);
1040                         plt_offset += shdr_plt.sh_entsize;
1041                         gelf_getsym(syms, symidx, &sym);
1042                         snprintf(sympltname, sizeof(sympltname),
1043                                  "%s@plt", elf_sym__name(&sym, symstrs));
1044
1045                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1046                                         STB_GLOBAL, sympltname);
1047                         if (!f)
1048                                 goto out_elf_end;
1049
1050                         if (filter && filter(map, f))
1051                                 symbol__delete(f);
1052                         else {
1053                                 symbols__insert(&dso->symbols[map->type], f);
1054                                 ++nr;
1055                         }
1056                 }
1057         } else if (shdr_rel_plt.sh_type == SHT_REL) {
1058                 GElf_Rel pos_mem, *pos;
1059                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
1060                                           nr_rel_entries) {
1061                         symidx = GELF_R_SYM(pos->r_info);
1062                         plt_offset += shdr_plt.sh_entsize;
1063                         gelf_getsym(syms, symidx, &sym);
1064                         snprintf(sympltname, sizeof(sympltname),
1065                                  "%s@plt", elf_sym__name(&sym, symstrs));
1066
1067                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1068                                         STB_GLOBAL, sympltname);
1069                         if (!f)
1070                                 goto out_elf_end;
1071
1072                         if (filter && filter(map, f))
1073                                 symbol__delete(f);
1074                         else {
1075                                 symbols__insert(&dso->symbols[map->type], f);
1076                                 ++nr;
1077                         }
1078                 }
1079         }
1080
1081         err = 0;
1082 out_elf_end:
1083         elf_end(elf);
1084 out_close:
1085         close(fd);
1086
1087         if (err == 0)
1088                 return nr;
1089 out:
1090         pr_debug("%s: problems reading %s PLT info.\n",
1091                  __func__, dso->long_name);
1092         return 0;
1093 }
1094
1095 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
1096 {
1097         switch (type) {
1098         case MAP__FUNCTION:
1099                 return elf_sym__is_function(sym);
1100         case MAP__VARIABLE:
1101                 return elf_sym__is_object(sym);
1102         default:
1103                 return false;
1104         }
1105 }
1106
1107 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
1108                           enum map_type type)
1109 {
1110         switch (type) {
1111         case MAP__FUNCTION:
1112                 return elf_sec__is_text(shdr, secstrs);
1113         case MAP__VARIABLE:
1114                 return elf_sec__is_data(shdr, secstrs);
1115         default:
1116                 return false;
1117         }
1118 }
1119
1120 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
1121 {
1122         Elf_Scn *sec = NULL;
1123         GElf_Shdr shdr;
1124         size_t cnt = 1;
1125
1126         while ((sec = elf_nextscn(elf, sec)) != NULL) {
1127                 gelf_getshdr(sec, &shdr);
1128
1129                 if ((addr >= shdr.sh_addr) &&
1130                     (addr < (shdr.sh_addr + shdr.sh_size)))
1131                         return cnt;
1132
1133                 ++cnt;
1134         }
1135
1136         return -1;
1137 }
1138
1139 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
1140                          int fd, symbol_filter_t filter, int kmodule,
1141                          int want_symtab)
1142 {
1143         struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1144         struct map *curr_map = map;
1145         struct dso *curr_dso = dso;
1146         Elf_Data *symstrs, *secstrs;
1147         uint32_t nr_syms;
1148         int err = -1;
1149         uint32_t idx;
1150         GElf_Ehdr ehdr;
1151         GElf_Shdr shdr, opdshdr;
1152         Elf_Data *syms, *opddata = NULL;
1153         GElf_Sym sym;
1154         Elf_Scn *sec, *sec_strndx, *opdsec;
1155         Elf *elf;
1156         int nr = 0;
1157         size_t opdidx = 0;
1158
1159         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1160         if (elf == NULL) {
1161                 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1162                 goto out_close;
1163         }
1164
1165         if (gelf_getehdr(elf, &ehdr) == NULL) {
1166                 pr_debug("%s: cannot get elf header.\n", __func__);
1167                 goto out_elf_end;
1168         }
1169
1170         /* Always reject images with a mismatched build-id: */
1171         if (dso->has_build_id) {
1172                 u8 build_id[BUILD_ID_SIZE];
1173
1174                 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
1175                         goto out_elf_end;
1176
1177                 if (!dso__build_id_equal(dso, build_id))
1178                         goto out_elf_end;
1179         }
1180
1181         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1182         if (sec == NULL) {
1183                 if (want_symtab)
1184                         goto out_elf_end;
1185
1186                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1187                 if (sec == NULL)
1188                         goto out_elf_end;
1189         }
1190
1191         opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1192         if (opdshdr.sh_type != SHT_PROGBITS)
1193                 opdsec = NULL;
1194         if (opdsec)
1195                 opddata = elf_rawdata(opdsec, NULL);
1196
1197         syms = elf_getdata(sec, NULL);
1198         if (syms == NULL)
1199                 goto out_elf_end;
1200
1201         sec = elf_getscn(elf, shdr.sh_link);
1202         if (sec == NULL)
1203                 goto out_elf_end;
1204
1205         symstrs = elf_getdata(sec, NULL);
1206         if (symstrs == NULL)
1207                 goto out_elf_end;
1208
1209         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1210         if (sec_strndx == NULL)
1211                 goto out_elf_end;
1212
1213         secstrs = elf_getdata(sec_strndx, NULL);
1214         if (secstrs == NULL)
1215                 goto out_elf_end;
1216
1217         nr_syms = shdr.sh_size / shdr.sh_entsize;
1218
1219         memset(&sym, 0, sizeof(sym));
1220         if (dso->kernel == DSO_TYPE_USER) {
1221                 dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1222                                 elf_section_by_name(elf, &ehdr, &shdr,
1223                                                      ".gnu.prelink_undo",
1224                                                      NULL) != NULL);
1225         } else {
1226                 dso->adjust_symbols = 0;
1227         }
1228         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1229                 struct symbol *f;
1230                 const char *elf_name = elf_sym__name(&sym, symstrs);
1231                 char *demangled = NULL;
1232                 int is_label = elf_sym__is_label(&sym);
1233                 const char *section_name;
1234
1235                 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1236                     strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1237                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1238
1239                 if (!is_label && !elf_sym__is_a(&sym, map->type))
1240                         continue;
1241
1242                 /* Reject ARM ELF "mapping symbols": these aren't unique and
1243                  * don't identify functions, so will confuse the profile
1244                  * output: */
1245                 if (ehdr.e_machine == EM_ARM) {
1246                         if (!strcmp(elf_name, "$a") ||
1247                             !strcmp(elf_name, "$d") ||
1248                             !strcmp(elf_name, "$t"))
1249                                 continue;
1250                 }
1251
1252                 if (opdsec && sym.st_shndx == opdidx) {
1253                         u32 offset = sym.st_value - opdshdr.sh_addr;
1254                         u64 *opd = opddata->d_buf + offset;
1255                         sym.st_value = *opd;
1256                         sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1257                 }
1258
1259                 sec = elf_getscn(elf, sym.st_shndx);
1260                 if (!sec)
1261                         goto out_elf_end;
1262
1263                 gelf_getshdr(sec, &shdr);
1264
1265                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1266                         continue;
1267
1268                 section_name = elf_sec__name(&shdr, secstrs);
1269
1270                 /* On ARM, symbols for thumb functions have 1 added to
1271                  * the symbol address as a flag - remove it */
1272                 if ((ehdr.e_machine == EM_ARM) &&
1273                     (map->type == MAP__FUNCTION) &&
1274                     (sym.st_value & 1))
1275                         --sym.st_value;
1276
1277                 if (dso->kernel != DSO_TYPE_USER || kmodule) {
1278                         char dso_name[PATH_MAX];
1279
1280                         if (strcmp(section_name,
1281                                    (curr_dso->short_name +
1282                                     dso->short_name_len)) == 0)
1283                                 goto new_symbol;
1284
1285                         if (strcmp(section_name, ".text") == 0) {
1286                                 curr_map = map;
1287                                 curr_dso = dso;
1288                                 goto new_symbol;
1289                         }
1290
1291                         snprintf(dso_name, sizeof(dso_name),
1292                                  "%s%s", dso->short_name, section_name);
1293
1294                         curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1295                         if (curr_map == NULL) {
1296                                 u64 start = sym.st_value;
1297
1298                                 if (kmodule)
1299                                         start += map->start + shdr.sh_offset;
1300
1301                                 curr_dso = dso__new(dso_name);
1302                                 if (curr_dso == NULL)
1303                                         goto out_elf_end;
1304                                 curr_dso->kernel = dso->kernel;
1305                                 curr_dso->long_name = dso->long_name;
1306                                 curr_dso->long_name_len = dso->long_name_len;
1307                                 curr_map = map__new2(start, curr_dso,
1308                                                      map->type);
1309                                 if (curr_map == NULL) {
1310                                         dso__delete(curr_dso);
1311                                         goto out_elf_end;
1312                                 }
1313                                 curr_map->map_ip = identity__map_ip;
1314                                 curr_map->unmap_ip = identity__map_ip;
1315                                 curr_dso->symtab_type = dso->symtab_type;
1316                                 map_groups__insert(kmap->kmaps, curr_map);
1317                                 dsos__add(&dso->node, curr_dso);
1318                                 dso__set_loaded(curr_dso, map->type);
1319                         } else
1320                                 curr_dso = curr_map->dso;
1321
1322                         goto new_symbol;
1323                 }
1324
1325                 if (curr_dso->adjust_symbols) {
1326                         pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1327                                   "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1328                                   (u64)sym.st_value, (u64)shdr.sh_addr,
1329                                   (u64)shdr.sh_offset);
1330                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1331                 }
1332                 /*
1333                  * We need to figure out if the object was created from C++ sources
1334                  * DWARF DW_compile_unit has this, but we don't always have access
1335                  * to it...
1336                  */
1337                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1338                 if (demangled != NULL)
1339                         elf_name = demangled;
1340 new_symbol:
1341                 f = symbol__new(sym.st_value, sym.st_size,
1342                                 GELF_ST_BIND(sym.st_info), elf_name);
1343                 free(demangled);
1344                 if (!f)
1345                         goto out_elf_end;
1346
1347                 if (filter && filter(curr_map, f))
1348                         symbol__delete(f);
1349                 else {
1350                         symbols__insert(&curr_dso->symbols[curr_map->type], f);
1351                         nr++;
1352                 }
1353         }
1354
1355         /*
1356          * For misannotated, zeroed, ASM function sizes.
1357          */
1358         if (nr > 0) {
1359                 symbols__fixup_duplicate(&dso->symbols[map->type]);
1360                 symbols__fixup_end(&dso->symbols[map->type]);
1361                 if (kmap) {
1362                         /*
1363                          * We need to fixup this here too because we create new
1364                          * maps here, for things like vsyscall sections.
1365                          */
1366                         __map_groups__fixup_end(kmap->kmaps, map->type);
1367                 }
1368         }
1369         err = nr;
1370 out_elf_end:
1371         elf_end(elf);
1372 out_close:
1373         return err;
1374 }
1375
1376 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
1377 {
1378         return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
1379 }
1380
1381 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1382 {
1383         bool have_build_id = false;
1384         struct dso *pos;
1385
1386         list_for_each_entry(pos, head, node) {
1387                 if (with_hits && !pos->hit)
1388                         continue;
1389                 if (pos->has_build_id) {
1390                         have_build_id = true;
1391                         continue;
1392                 }
1393                 if (filename__read_build_id(pos->long_name, pos->build_id,
1394                                             sizeof(pos->build_id)) > 0) {
1395                         have_build_id     = true;
1396                         pos->has_build_id = true;
1397                 }
1398         }
1399
1400         return have_build_id;
1401 }
1402
1403 /*
1404  * Align offset to 4 bytes as needed for note name and descriptor data.
1405  */
1406 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1407
1408 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1409 {
1410         int err = -1;
1411         GElf_Ehdr ehdr;
1412         GElf_Shdr shdr;
1413         Elf_Data *data;
1414         Elf_Scn *sec;
1415         Elf_Kind ek;
1416         void *ptr;
1417
1418         if (size < BUILD_ID_SIZE)
1419                 goto out;
1420
1421         ek = elf_kind(elf);
1422         if (ek != ELF_K_ELF)
1423                 goto out;
1424
1425         if (gelf_getehdr(elf, &ehdr) == NULL) {
1426                 pr_err("%s: cannot get elf header.\n", __func__);
1427                 goto out;
1428         }
1429
1430         sec = elf_section_by_name(elf, &ehdr, &shdr,
1431                                   ".note.gnu.build-id", NULL);
1432         if (sec == NULL) {
1433                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1434                                           ".notes", NULL);
1435                 if (sec == NULL)
1436                         goto out;
1437         }
1438
1439         data = elf_getdata(sec, NULL);
1440         if (data == NULL)
1441                 goto out;
1442
1443         ptr = data->d_buf;
1444         while (ptr < (data->d_buf + data->d_size)) {
1445                 GElf_Nhdr *nhdr = ptr;
1446                 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1447                        descsz = NOTE_ALIGN(nhdr->n_descsz);
1448                 const char *name;
1449
1450                 ptr += sizeof(*nhdr);
1451                 name = ptr;
1452                 ptr += namesz;
1453                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1454                     nhdr->n_namesz == sizeof("GNU")) {
1455                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1456                                 size_t sz = min(size, descsz);
1457                                 memcpy(bf, ptr, sz);
1458                                 memset(bf + sz, 0, size - sz);
1459                                 err = descsz;
1460                                 break;
1461                         }
1462                 }
1463                 ptr += descsz;
1464         }
1465
1466 out:
1467         return err;
1468 }
1469
1470 int filename__read_build_id(const char *filename, void *bf, size_t size)
1471 {
1472         int fd, err = -1;
1473         Elf *elf;
1474
1475         if (size < BUILD_ID_SIZE)
1476                 goto out;
1477
1478         fd = open(filename, O_RDONLY);
1479         if (fd < 0)
1480                 goto out;
1481
1482         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1483         if (elf == NULL) {
1484                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1485                 goto out_close;
1486         }
1487
1488         err = elf_read_build_id(elf, bf, size);
1489
1490         elf_end(elf);
1491 out_close:
1492         close(fd);
1493 out:
1494         return err;
1495 }
1496
1497 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1498 {
1499         int fd, err = -1;
1500
1501         if (size < BUILD_ID_SIZE)
1502                 goto out;
1503
1504         fd = open(filename, O_RDONLY);
1505         if (fd < 0)
1506                 goto out;
1507
1508         while (1) {
1509                 char bf[BUFSIZ];
1510                 GElf_Nhdr nhdr;
1511                 size_t namesz, descsz;
1512
1513                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1514                         break;
1515
1516                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1517                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1518                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1519                     nhdr.n_namesz == sizeof("GNU")) {
1520                         if (read(fd, bf, namesz) != (ssize_t)namesz)
1521                                 break;
1522                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1523                                 size_t sz = min(descsz, size);
1524                                 if (read(fd, build_id, sz) == (ssize_t)sz) {
1525                                         memset(build_id + sz, 0, size - sz);
1526                                         err = 0;
1527                                         break;
1528                                 }
1529                         } else if (read(fd, bf, descsz) != (ssize_t)descsz)
1530                                 break;
1531                 } else {
1532                         int n = namesz + descsz;
1533                         if (read(fd, bf, n) != n)
1534                                 break;
1535                 }
1536         }
1537         close(fd);
1538 out:
1539         return err;
1540 }
1541
1542 char dso__symtab_origin(const struct dso *dso)
1543 {
1544         static const char origin[] = {
1545                 [SYMTAB__KALLSYMS]            = 'k',
1546                 [SYMTAB__JAVA_JIT]            = 'j',
1547                 [SYMTAB__BUILD_ID_CACHE]      = 'B',
1548                 [SYMTAB__FEDORA_DEBUGINFO]    = 'f',
1549                 [SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
1550                 [SYMTAB__BUILDID_DEBUGINFO]   = 'b',
1551                 [SYMTAB__SYSTEM_PATH_DSO]     = 'd',
1552                 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
1553                 [SYMTAB__GUEST_KALLSYMS]      =  'g',
1554                 [SYMTAB__GUEST_KMODULE]       =  'G',
1555         };
1556
1557         if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
1558                 return '!';
1559         return origin[dso->symtab_type];
1560 }
1561
1562 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1563 {
1564         int size = PATH_MAX;
1565         char *name;
1566         int ret = -1;
1567         int fd;
1568         struct machine *machine;
1569         const char *root_dir;
1570         int want_symtab;
1571
1572         dso__set_loaded(dso, map->type);
1573
1574         if (dso->kernel == DSO_TYPE_KERNEL)
1575                 return dso__load_kernel_sym(dso, map, filter);
1576         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1577                 return dso__load_guest_kernel_sym(dso, map, filter);
1578
1579         if (map->groups && map->groups->machine)
1580                 machine = map->groups->machine;
1581         else
1582                 machine = NULL;
1583
1584         name = malloc(size);
1585         if (!name)
1586                 return -1;
1587
1588         dso->adjust_symbols = 0;
1589
1590         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1591                 struct stat st;
1592
1593                 if (lstat(dso->name, &st) < 0)
1594                         return -1;
1595
1596                 if (st.st_uid && (st.st_uid != geteuid())) {
1597                         pr_warning("File %s not owned by current user or root, "
1598                                 "ignoring it.\n", dso->name);
1599                         return -1;
1600                 }
1601
1602                 ret = dso__load_perf_map(dso, map, filter);
1603                 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
1604                                               SYMTAB__NOT_FOUND;
1605                 return ret;
1606         }
1607
1608         /* Iterate over candidate debug images.
1609          * On the first pass, only load images if they have a full symtab.
1610          * Failing that, do a second pass where we accept .dynsym also
1611          */
1612         want_symtab = 1;
1613 restart:
1614         for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
1615              dso->symtab_type != SYMTAB__NOT_FOUND;
1616              dso->symtab_type++) {
1617                 switch (dso->symtab_type) {
1618                 case SYMTAB__BUILD_ID_CACHE:
1619                         /* skip the locally configured cache if a symfs is given */
1620                         if (symbol_conf.symfs[0] ||
1621                             (dso__build_id_filename(dso, name, size) == NULL)) {
1622                                 continue;
1623                         }
1624                         break;
1625                 case SYMTAB__FEDORA_DEBUGINFO:
1626                         snprintf(name, size, "%s/usr/lib/debug%s.debug",
1627                                  symbol_conf.symfs, dso->long_name);
1628                         break;
1629                 case SYMTAB__UBUNTU_DEBUGINFO:
1630                         snprintf(name, size, "%s/usr/lib/debug%s",
1631                                  symbol_conf.symfs, dso->long_name);
1632                         break;
1633                 case SYMTAB__BUILDID_DEBUGINFO: {
1634                         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1635
1636                         if (!dso->has_build_id)
1637                                 continue;
1638
1639                         build_id__sprintf(dso->build_id,
1640                                           sizeof(dso->build_id),
1641                                           build_id_hex);
1642                         snprintf(name, size,
1643                                  "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1644                                  symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1645                         }
1646                         break;
1647                 case SYMTAB__SYSTEM_PATH_DSO:
1648                         snprintf(name, size, "%s%s",
1649                              symbol_conf.symfs, dso->long_name);
1650                         break;
1651                 case SYMTAB__GUEST_KMODULE:
1652                         if (map->groups && machine)
1653                                 root_dir = machine->root_dir;
1654                         else
1655                                 root_dir = "";
1656                         snprintf(name, size, "%s%s%s", symbol_conf.symfs,
1657                                  root_dir, dso->long_name);
1658                         break;
1659
1660                 case SYMTAB__SYSTEM_PATH_KMODULE:
1661                         snprintf(name, size, "%s%s", symbol_conf.symfs,
1662                                  dso->long_name);
1663                         break;
1664                 default:;
1665                 }
1666
1667                 /* Name is now the name of the next image to try */
1668                 fd = open(name, O_RDONLY);
1669                 if (fd < 0)
1670                         continue;
1671
1672                 ret = dso__load_sym(dso, map, name, fd, filter, 0,
1673                                     want_symtab);
1674                 close(fd);
1675
1676                 /*
1677                  * Some people seem to have debuginfo files _WITHOUT_ debug
1678                  * info!?!?
1679                  */
1680                 if (!ret)
1681                         continue;
1682
1683                 if (ret > 0) {
1684                         int nr_plt = dso__synthesize_plt_symbols(dso, map,
1685                                                                  filter);
1686                         if (nr_plt > 0)
1687                                 ret += nr_plt;
1688                         break;
1689                 }
1690         }
1691
1692         /*
1693          * If we wanted a full symtab but no image had one,
1694          * relax our requirements and repeat the search.
1695          */
1696         if (ret <= 0 && want_symtab) {
1697                 want_symtab = 0;
1698                 goto restart;
1699         }
1700
1701         free(name);
1702         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1703                 return 0;
1704         return ret;
1705 }
1706
1707 struct map *map_groups__find_by_name(struct map_groups *mg,
1708                                      enum map_type type, const char *name)
1709 {
1710         struct rb_node *nd;
1711
1712         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1713                 struct map *map = rb_entry(nd, struct map, rb_node);
1714
1715                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1716                         return map;
1717         }
1718
1719         return NULL;
1720 }
1721
1722 static int dso__kernel_module_get_build_id(struct dso *dso,
1723                                            const char *root_dir)
1724 {
1725         char filename[PATH_MAX];
1726         /*
1727          * kernel module short names are of the form "[module]" and
1728          * we need just "module" here.
1729          */
1730         const char *name = dso->short_name + 1;
1731
1732         snprintf(filename, sizeof(filename),
1733                  "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1734                  root_dir, (int)strlen(name) - 1, name);
1735
1736         if (sysfs__read_build_id(filename, dso->build_id,
1737                                  sizeof(dso->build_id)) == 0)
1738                 dso->has_build_id = true;
1739
1740         return 0;
1741 }
1742
1743 static int map_groups__set_modules_path_dir(struct map_groups *mg,
1744                                 const char *dir_name)
1745 {
1746         struct dirent *dent;
1747         DIR *dir = opendir(dir_name);
1748         int ret = 0;
1749
1750         if (!dir) {
1751                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1752                 return -1;
1753         }
1754
1755         while ((dent = readdir(dir)) != NULL) {
1756                 char path[PATH_MAX];
1757                 struct stat st;
1758
1759                 /*sshfs might return bad dent->d_type, so we have to stat*/
1760                 sprintf(path, "%s/%s", dir_name, dent->d_name);
1761                 if (stat(path, &st))
1762                         continue;
1763
1764                 if (S_ISDIR(st.st_mode)) {
1765                         if (!strcmp(dent->d_name, ".") ||
1766                             !strcmp(dent->d_name, ".."))
1767                                 continue;
1768
1769                         snprintf(path, sizeof(path), "%s/%s",
1770                                  dir_name, dent->d_name);
1771                         ret = map_groups__set_modules_path_dir(mg, path);
1772                         if (ret < 0)
1773                                 goto out;
1774                 } else {
1775                         char *dot = strrchr(dent->d_name, '.'),
1776                              dso_name[PATH_MAX];
1777                         struct map *map;
1778                         char *long_name;
1779
1780                         if (dot == NULL || strcmp(dot, ".ko"))
1781                                 continue;
1782                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1783                                  (int)(dot - dent->d_name), dent->d_name);
1784
1785                         strxfrchar(dso_name, '-', '_');
1786                         map = map_groups__find_by_name(mg, MAP__FUNCTION,
1787                                                        dso_name);
1788                         if (map == NULL)
1789                                 continue;
1790
1791                         snprintf(path, sizeof(path), "%s/%s",
1792                                  dir_name, dent->d_name);
1793
1794                         long_name = strdup(path);
1795                         if (long_name == NULL) {
1796                                 ret = -1;
1797                                 goto out;
1798                         }
1799                         dso__set_long_name(map->dso, long_name);
1800                         map->dso->lname_alloc = 1;
1801                         dso__kernel_module_get_build_id(map->dso, "");
1802                 }
1803         }
1804
1805 out:
1806         closedir(dir);
1807         return ret;
1808 }
1809
1810 static char *get_kernel_version(const char *root_dir)
1811 {
1812         char version[PATH_MAX];
1813         FILE *file;
1814         char *name, *tmp;
1815         const char *prefix = "Linux version ";
1816
1817         sprintf(version, "%s/proc/version", root_dir);
1818         file = fopen(version, "r");
1819         if (!file)
1820                 return NULL;
1821
1822         version[0] = '\0';
1823         tmp = fgets(version, sizeof(version), file);
1824         fclose(file);
1825
1826         name = strstr(version, prefix);
1827         if (!name)
1828                 return NULL;
1829         name += strlen(prefix);
1830         tmp = strchr(name, ' ');
1831         if (tmp)
1832                 *tmp = '\0';
1833
1834         return strdup(name);
1835 }
1836
1837 static int machine__set_modules_path(struct machine *machine)
1838 {
1839         char *version;
1840         char modules_path[PATH_MAX];
1841
1842         version = get_kernel_version(machine->root_dir);
1843         if (!version)
1844                 return -1;
1845
1846         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1847                  machine->root_dir, version);
1848         free(version);
1849
1850         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
1851 }
1852
1853 /*
1854  * Constructor variant for modules (where we know from /proc/modules where
1855  * they are loaded) and for vmlinux, where only after we load all the
1856  * symbols we'll know where it starts and ends.
1857  */
1858 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1859 {
1860         struct map *map = calloc(1, (sizeof(*map) +
1861                                      (dso->kernel ? sizeof(struct kmap) : 0)));
1862         if (map != NULL) {
1863                 /*
1864                  * ->end will be filled after we load all the symbols
1865                  */
1866                 map__init(map, type, start, 0, 0, dso);
1867         }
1868
1869         return map;
1870 }
1871
1872 struct map *machine__new_module(struct machine *machine, u64 start,
1873                                 const char *filename)
1874 {
1875         struct map *map;
1876         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
1877
1878         if (dso == NULL)
1879                 return NULL;
1880
1881         map = map__new2(start, dso, MAP__FUNCTION);
1882         if (map == NULL)
1883                 return NULL;
1884
1885         if (machine__is_host(machine))
1886                 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
1887         else
1888                 dso->symtab_type = SYMTAB__GUEST_KMODULE;
1889         map_groups__insert(&machine->kmaps, map);
1890         return map;
1891 }
1892
1893 static int machine__create_modules(struct machine *machine)
1894 {
1895         char *line = NULL;
1896         size_t n;
1897         FILE *file;
1898         struct map *map;
1899         const char *modules;
1900         char path[PATH_MAX];
1901
1902         if (machine__is_default_guest(machine))
1903                 modules = symbol_conf.default_guest_modules;
1904         else {
1905                 sprintf(path, "%s/proc/modules", machine->root_dir);
1906                 modules = path;
1907         }
1908
1909         if (symbol__restricted_filename(path, "/proc/modules"))
1910                 return -1;
1911
1912         file = fopen(modules, "r");
1913         if (file == NULL)
1914                 return -1;
1915
1916         while (!feof(file)) {
1917                 char name[PATH_MAX];
1918                 u64 start;
1919                 char *sep;
1920                 int line_len;
1921
1922                 line_len = getline(&line, &n, file);
1923                 if (line_len < 0)
1924                         break;
1925
1926                 if (!line)
1927                         goto out_failure;
1928
1929                 line[--line_len] = '\0'; /* \n */
1930
1931                 sep = strrchr(line, 'x');
1932                 if (sep == NULL)
1933                         continue;
1934
1935                 hex2u64(sep + 1, &start);
1936
1937                 sep = strchr(line, ' ');
1938                 if (sep == NULL)
1939                         continue;
1940
1941                 *sep = '\0';
1942
1943                 snprintf(name, sizeof(name), "[%s]", line);
1944                 map = machine__new_module(machine, start, name);
1945                 if (map == NULL)
1946                         goto out_delete_line;
1947                 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1948         }
1949
1950         free(line);
1951         fclose(file);
1952
1953         return machine__set_modules_path(machine);
1954
1955 out_delete_line:
1956         free(line);
1957 out_failure:
1958         return -1;
1959 }
1960
1961 int dso__load_vmlinux(struct dso *dso, struct map *map,
1962                       const char *vmlinux, symbol_filter_t filter)
1963 {
1964         int err = -1, fd;
1965         char symfs_vmlinux[PATH_MAX];
1966
1967         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
1968                  symbol_conf.symfs, vmlinux);
1969         fd = open(symfs_vmlinux, O_RDONLY);
1970         if (fd < 0)
1971                 return -1;
1972
1973         dso__set_long_name(dso, (char *)vmlinux);
1974         dso__set_loaded(dso, map->type);
1975         err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
1976         close(fd);
1977
1978         if (err > 0)
1979                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1980
1981         return err;
1982 }
1983
1984 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
1985                            symbol_filter_t filter)
1986 {
1987         int i, err = 0;
1988         char *filename;
1989
1990         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1991                  vmlinux_path__nr_entries + 1);
1992
1993         filename = dso__build_id_filename(dso, NULL, 0);
1994         if (filename != NULL) {
1995                 err = dso__load_vmlinux(dso, map, filename, filter);
1996                 if (err > 0) {
1997                         dso__set_long_name(dso, filename);
1998                         goto out;
1999                 }
2000                 free(filename);
2001         }
2002
2003         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2004                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2005                 if (err > 0) {
2006                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
2007                         break;
2008                 }
2009         }
2010 out:
2011         return err;
2012 }
2013
2014 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2015                                 symbol_filter_t filter)
2016 {
2017         int err;
2018         const char *kallsyms_filename = NULL;
2019         char *kallsyms_allocated_filename = NULL;
2020         /*
2021          * Step 1: if the user specified a kallsyms or vmlinux filename, use
2022          * it and only it, reporting errors to the user if it cannot be used.
2023          *
2024          * For instance, try to analyse an ARM perf.data file _without_ a
2025          * build-id, or if the user specifies the wrong path to the right
2026          * vmlinux file, obviously we can't fallback to another vmlinux (a
2027          * x86_86 one, on the machine where analysis is being performed, say),
2028          * or worse, /proc/kallsyms.
2029          *
2030          * If the specified file _has_ a build-id and there is a build-id
2031          * section in the perf.data file, we will still do the expected
2032          * validation in dso__load_vmlinux and will bail out if they don't
2033          * match.
2034          */
2035         if (symbol_conf.kallsyms_name != NULL) {
2036                 kallsyms_filename = symbol_conf.kallsyms_name;
2037                 goto do_kallsyms;
2038         }
2039
2040         if (symbol_conf.vmlinux_name != NULL) {
2041                 err = dso__load_vmlinux(dso, map,
2042                                         symbol_conf.vmlinux_name, filter);
2043                 if (err > 0) {
2044                         dso__set_long_name(dso,
2045                                            strdup(symbol_conf.vmlinux_name));
2046                         goto out_fixup;
2047                 }
2048                 return err;
2049         }
2050
2051         if (vmlinux_path != NULL) {
2052                 err = dso__load_vmlinux_path(dso, map, filter);
2053                 if (err > 0)
2054                         goto out_fixup;
2055         }
2056
2057         /* do not try local files if a symfs was given */
2058         if (symbol_conf.symfs[0] != 0)
2059                 return -1;
2060
2061         /*
2062          * Say the kernel DSO was created when processing the build-id header table,
2063          * we have a build-id, so check if it is the same as the running kernel,
2064          * using it if it is.
2065          */
2066         if (dso->has_build_id) {
2067                 u8 kallsyms_build_id[BUILD_ID_SIZE];
2068                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2069
2070                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2071                                          sizeof(kallsyms_build_id)) == 0) {
2072                         if (dso__build_id_equal(dso, kallsyms_build_id)) {
2073                                 kallsyms_filename = "/proc/kallsyms";
2074                                 goto do_kallsyms;
2075                         }
2076                 }
2077                 /*
2078                  * Now look if we have it on the build-id cache in
2079                  * $HOME/.debug/[kernel.kallsyms].
2080                  */
2081                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2082                                   sbuild_id);
2083
2084                 if (asprintf(&kallsyms_allocated_filename,
2085                              "%s/.debug/[kernel.kallsyms]/%s",
2086                              getenv("HOME"), sbuild_id) == -1) {
2087                         pr_err("Not enough memory for kallsyms file lookup\n");
2088                         return -1;
2089                 }
2090
2091                 kallsyms_filename = kallsyms_allocated_filename;
2092
2093                 if (access(kallsyms_filename, F_OK)) {
2094                         pr_err("No kallsyms or vmlinux with build-id %s "
2095                                "was found\n", sbuild_id);
2096                         free(kallsyms_allocated_filename);
2097                         return -1;
2098                 }
2099         } else {
2100                 /*
2101                  * Last resort, if we don't have a build-id and couldn't find
2102                  * any vmlinux file, try the running kernel kallsyms table.
2103                  */
2104                 kallsyms_filename = "/proc/kallsyms";
2105         }
2106
2107 do_kallsyms:
2108         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2109         if (err > 0)
2110                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2111         free(kallsyms_allocated_filename);
2112
2113         if (err > 0) {
2114 out_fixup:
2115                 if (kallsyms_filename != NULL)
2116                         dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2117                 map__fixup_start(map);
2118                 map__fixup_end(map);
2119         }
2120
2121         return err;
2122 }
2123
2124 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2125                                       symbol_filter_t filter)
2126 {
2127         int err;
2128         const char *kallsyms_filename = NULL;
2129         struct machine *machine;
2130         char path[PATH_MAX];
2131
2132         if (!map->groups) {
2133                 pr_debug("Guest kernel map hasn't the point to groups\n");
2134                 return -1;
2135         }
2136         machine = map->groups->machine;
2137
2138         if (machine__is_default_guest(machine)) {
2139                 /*
2140                  * if the user specified a vmlinux filename, use it and only
2141                  * it, reporting errors to the user if it cannot be used.
2142                  * Or use file guest_kallsyms inputted by user on commandline
2143                  */
2144                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2145                         err = dso__load_vmlinux(dso, map,
2146                                 symbol_conf.default_guest_vmlinux_name, filter);
2147                         goto out_try_fixup;
2148                 }
2149
2150                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2151                 if (!kallsyms_filename)
2152                         return -1;
2153         } else {
2154                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2155                 kallsyms_filename = path;
2156         }
2157
2158         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2159         if (err > 0)
2160                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2161
2162 out_try_fixup:
2163         if (err > 0) {
2164                 if (kallsyms_filename != NULL) {
2165                         machine__mmap_name(machine, path, sizeof(path));
2166                         dso__set_long_name(dso, strdup(path));
2167                 }
2168                 map__fixup_start(map);
2169                 map__fixup_end(map);
2170         }
2171
2172         return err;
2173 }
2174
2175 static void dsos__add(struct list_head *head, struct dso *dso)
2176 {
2177         list_add_tail(&dso->node, head);
2178 }
2179
2180 static struct dso *dsos__find(struct list_head *head, const char *name)
2181 {
2182         struct dso *pos;
2183
2184         list_for_each_entry(pos, head, node)
2185                 if (strcmp(pos->long_name, name) == 0)
2186                         return pos;
2187         return NULL;
2188 }
2189
2190 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2191 {
2192         struct dso *dso = dsos__find(head, name);
2193
2194         if (!dso) {
2195                 dso = dso__new(name);
2196                 if (dso != NULL) {
2197                         dsos__add(head, dso);
2198                         dso__set_basename(dso);
2199                 }
2200         }
2201
2202         return dso;
2203 }
2204
2205 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2206 {
2207         struct dso *pos;
2208         size_t ret = 0;
2209
2210         list_for_each_entry(pos, head, node) {
2211                 int i;
2212                 for (i = 0; i < MAP__NR_TYPES; ++i)
2213                         ret += dso__fprintf(pos, i, fp);
2214         }
2215
2216         return ret;
2217 }
2218
2219 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2220 {
2221         struct rb_node *nd;
2222         size_t ret = 0;
2223
2224         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2225                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2226                 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2227                 ret += __dsos__fprintf(&pos->user_dsos, fp);
2228         }
2229
2230         return ret;
2231 }
2232
2233 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2234                                       bool with_hits)
2235 {
2236         struct dso *pos;
2237         size_t ret = 0;
2238
2239         list_for_each_entry(pos, head, node) {
2240                 if (with_hits && !pos->hit)
2241                         continue;
2242                 ret += dso__fprintf_buildid(pos, fp);
2243                 ret += fprintf(fp, " %s\n", pos->long_name);
2244         }
2245         return ret;
2246 }
2247
2248 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2249                                      bool with_hits)
2250 {
2251         return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2252                __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2253 }
2254
2255 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2256                                       FILE *fp, bool with_hits)
2257 {
2258         struct rb_node *nd;
2259         size_t ret = 0;
2260
2261         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2262                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2263                 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2264         }
2265         return ret;
2266 }
2267
2268 static struct dso*
2269 dso__kernel_findnew(struct machine *machine, const char *name,
2270                     const char *short_name, int dso_type)
2271 {
2272         /*
2273          * The kernel dso could be created by build_id processing.
2274          */
2275         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2276
2277         /*
2278          * We need to run this in all cases, since during the build_id
2279          * processing we had no idea this was the kernel dso.
2280          */
2281         if (dso != NULL) {
2282                 dso__set_short_name(dso, short_name);
2283                 dso->kernel = dso_type;
2284         }
2285
2286         return dso;
2287 }
2288
2289 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2290 {
2291         char path[PATH_MAX];
2292
2293         if (machine__is_default_guest(machine))
2294                 return;
2295         sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2296         if (sysfs__read_build_id(path, dso->build_id,
2297                                  sizeof(dso->build_id)) == 0)
2298                 dso->has_build_id = true;
2299 }
2300
2301 static struct dso *machine__get_kernel(struct machine *machine)
2302 {
2303         const char *vmlinux_name = NULL;
2304         struct dso *kernel;
2305
2306         if (machine__is_host(machine)) {
2307                 vmlinux_name = symbol_conf.vmlinux_name;
2308                 if (!vmlinux_name)
2309                         vmlinux_name = "[kernel.kallsyms]";
2310
2311                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2312                                              "[kernel]",
2313                                              DSO_TYPE_KERNEL);
2314         } else {
2315                 char bf[PATH_MAX];
2316
2317                 if (machine__is_default_guest(machine))
2318                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2319                 if (!vmlinux_name)
2320                         vmlinux_name = machine__mmap_name(machine, bf,
2321                                                           sizeof(bf));
2322
2323                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2324                                              "[guest.kernel]",
2325                                              DSO_TYPE_GUEST_KERNEL);
2326         }
2327
2328         if (kernel != NULL && (!kernel->has_build_id))
2329                 dso__read_running_kernel_build_id(kernel, machine);
2330
2331         return kernel;
2332 }
2333
2334 struct process_args {
2335         u64 start;
2336 };
2337
2338 static int symbol__in_kernel(void *arg, const char *name,
2339                              char type __used, u64 start, u64 end __used)
2340 {
2341         struct process_args *args = arg;
2342
2343         if (strchr(name, '['))
2344                 return 0;
2345
2346         args->start = start;
2347         return 1;
2348 }
2349
2350 /* Figure out the start address of kernel map from /proc/kallsyms */
2351 static u64 machine__get_kernel_start_addr(struct machine *machine)
2352 {
2353         const char *filename;
2354         char path[PATH_MAX];
2355         struct process_args args;
2356
2357         if (machine__is_host(machine)) {
2358                 filename = "/proc/kallsyms";
2359         } else {
2360                 if (machine__is_default_guest(machine))
2361                         filename = (char *)symbol_conf.default_guest_kallsyms;
2362                 else {
2363                         sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2364                         filename = path;
2365                 }
2366         }
2367
2368         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2369                 return 0;
2370
2371         if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2372                 return 0;
2373
2374         return args.start;
2375 }
2376
2377 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
2378 {
2379         enum map_type type;
2380         u64 start = machine__get_kernel_start_addr(machine);
2381
2382         for (type = 0; type < MAP__NR_TYPES; ++type) {
2383                 struct kmap *kmap;
2384
2385                 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2386                 if (machine->vmlinux_maps[type] == NULL)
2387                         return -1;
2388
2389                 machine->vmlinux_maps[type]->map_ip =
2390                         machine->vmlinux_maps[type]->unmap_ip =
2391                                 identity__map_ip;
2392                 kmap = map__kmap(machine->vmlinux_maps[type]);
2393                 kmap->kmaps = &machine->kmaps;
2394                 map_groups__insert(&machine->kmaps,
2395                                    machine->vmlinux_maps[type]);
2396         }
2397
2398         return 0;
2399 }
2400
2401 void machine__destroy_kernel_maps(struct machine *machine)
2402 {
2403         enum map_type type;
2404
2405         for (type = 0; type < MAP__NR_TYPES; ++type) {
2406                 struct kmap *kmap;
2407
2408                 if (machine->vmlinux_maps[type] == NULL)
2409                         continue;
2410
2411                 kmap = map__kmap(machine->vmlinux_maps[type]);
2412                 map_groups__remove(&machine->kmaps,
2413                                    machine->vmlinux_maps[type]);
2414                 if (kmap->ref_reloc_sym) {
2415                         /*
2416                          * ref_reloc_sym is shared among all maps, so free just
2417                          * on one of them.
2418                          */
2419                         if (type == MAP__FUNCTION) {
2420                                 free((char *)kmap->ref_reloc_sym->name);
2421                                 kmap->ref_reloc_sym->name = NULL;
2422                                 free(kmap->ref_reloc_sym);
2423                         }
2424                         kmap->ref_reloc_sym = NULL;
2425                 }
2426
2427                 map__delete(machine->vmlinux_maps[type]);
2428                 machine->vmlinux_maps[type] = NULL;
2429         }
2430 }
2431
2432 int machine__create_kernel_maps(struct machine *machine)
2433 {
2434         struct dso *kernel = machine__get_kernel(machine);
2435
2436         if (kernel == NULL ||
2437             __machine__create_kernel_maps(machine, kernel) < 0)
2438                 return -1;
2439
2440         if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
2441                 pr_debug("Problems creating module maps, continuing anyway...\n");
2442         /*
2443          * Now that we have all the maps created, just set the ->end of them:
2444          */
2445         map_groups__fixup_end(&machine->kmaps);
2446         return 0;
2447 }
2448
2449 static void vmlinux_path__exit(void)
2450 {
2451         while (--vmlinux_path__nr_entries >= 0) {
2452                 free(vmlinux_path[vmlinux_path__nr_entries]);
2453                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2454         }
2455
2456         free(vmlinux_path);
2457         vmlinux_path = NULL;
2458 }
2459
2460 static int vmlinux_path__init(void)
2461 {
2462         struct utsname uts;
2463         char bf[PATH_MAX];
2464
2465         vmlinux_path = malloc(sizeof(char *) * 5);
2466         if (vmlinux_path == NULL)
2467                 return -1;
2468
2469         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2470         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2471                 goto out_fail;
2472         ++vmlinux_path__nr_entries;
2473         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2474         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2475                 goto out_fail;
2476         ++vmlinux_path__nr_entries;
2477
2478         /* only try running kernel version if no symfs was given */
2479         if (symbol_conf.symfs[0] != 0)
2480                 return 0;
2481
2482         if (uname(&uts) < 0)
2483                 return -1;
2484
2485         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2486         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2487         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2488                 goto out_fail;
2489         ++vmlinux_path__nr_entries;
2490         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2491         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2492         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2493                 goto out_fail;
2494         ++vmlinux_path__nr_entries;
2495         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2496                  uts.release);
2497         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2498         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2499                 goto out_fail;
2500         ++vmlinux_path__nr_entries;
2501
2502         return 0;
2503
2504 out_fail:
2505         vmlinux_path__exit();
2506         return -1;
2507 }
2508
2509 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2510 {
2511         int i;
2512         size_t printed = 0;
2513         struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2514
2515         if (kdso->has_build_id) {
2516                 char filename[PATH_MAX];
2517                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2518                         printed += fprintf(fp, "[0] %s\n", filename);
2519         }
2520
2521         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2522                 printed += fprintf(fp, "[%d] %s\n",
2523                                    i + kdso->has_build_id, vmlinux_path[i]);
2524
2525         return printed;
2526 }
2527
2528 static int setup_list(struct strlist **list, const char *list_str,
2529                       const char *list_name)
2530 {
2531         if (list_str == NULL)
2532                 return 0;
2533
2534         *list = strlist__new(true, list_str);
2535         if (!*list) {
2536                 pr_err("problems parsing %s list\n", list_name);
2537                 return -1;
2538         }
2539         return 0;
2540 }
2541
2542 static bool symbol__read_kptr_restrict(void)
2543 {
2544         bool value = false;
2545
2546         if (geteuid() != 0) {
2547                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2548                 if (fp != NULL) {
2549                         char line[8];
2550
2551                         if (fgets(line, sizeof(line), fp) != NULL)
2552                                 value = atoi(line) != 0;
2553
2554                         fclose(fp);
2555                 }
2556         }
2557
2558         return value;
2559 }
2560
2561 int symbol__init(void)
2562 {
2563         const char *symfs;
2564
2565         if (symbol_conf.initialized)
2566                 return 0;
2567
2568         symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2569
2570         elf_version(EV_CURRENT);
2571         if (symbol_conf.sort_by_name)
2572                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2573                                           sizeof(struct symbol));
2574
2575         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2576                 return -1;
2577
2578         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2579                 pr_err("'.' is the only non valid --field-separator argument\n");
2580                 return -1;
2581         }
2582
2583         if (setup_list(&symbol_conf.dso_list,
2584                        symbol_conf.dso_list_str, "dso") < 0)
2585                 return -1;
2586
2587         if (setup_list(&symbol_conf.comm_list,
2588                        symbol_conf.comm_list_str, "comm") < 0)
2589                 goto out_free_dso_list;
2590
2591         if (setup_list(&symbol_conf.sym_list,
2592                        symbol_conf.sym_list_str, "symbol") < 0)
2593                 goto out_free_comm_list;
2594
2595         /*
2596          * A path to symbols of "/" is identical to ""
2597          * reset here for simplicity.
2598          */
2599         symfs = realpath(symbol_conf.symfs, NULL);
2600         if (symfs == NULL)
2601                 symfs = symbol_conf.symfs;
2602         if (strcmp(symfs, "/") == 0)
2603                 symbol_conf.symfs = "";
2604         if (symfs != symbol_conf.symfs)
2605                 free((void *)symfs);
2606
2607         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2608
2609         symbol_conf.initialized = true;
2610         return 0;
2611
2612 out_free_dso_list:
2613         strlist__delete(symbol_conf.dso_list);
2614 out_free_comm_list:
2615         strlist__delete(symbol_conf.comm_list);
2616         return -1;
2617 }
2618
2619 void symbol__exit(void)
2620 {
2621         if (!symbol_conf.initialized)
2622                 return;
2623         strlist__delete(symbol_conf.sym_list);
2624         strlist__delete(symbol_conf.dso_list);
2625         strlist__delete(symbol_conf.comm_list);
2626         vmlinux_path__exit();
2627         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2628         symbol_conf.initialized = false;
2629 }
2630
2631 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2632 {
2633         struct machine *machine = machines__findnew(machines, pid);
2634
2635         if (machine == NULL)
2636                 return -1;
2637
2638         return machine__create_kernel_maps(machine);
2639 }
2640
2641 static int hex(char ch)
2642 {
2643         if ((ch >= '0') && (ch <= '9'))
2644                 return ch - '0';
2645         if ((ch >= 'a') && (ch <= 'f'))
2646                 return ch - 'a' + 10;
2647         if ((ch >= 'A') && (ch <= 'F'))
2648                 return ch - 'A' + 10;
2649         return -1;
2650 }
2651
2652 /*
2653  * While we find nice hex chars, build a long_val.
2654  * Return number of chars processed.
2655  */
2656 int hex2u64(const char *ptr, u64 *long_val)
2657 {
2658         const char *p = ptr;
2659         *long_val = 0;
2660
2661         while (*p) {
2662                 const int hex_val = hex(*p);
2663
2664                 if (hex_val < 0)
2665                         break;
2666
2667                 *long_val = (*long_val << 4) | hex_val;
2668                 p++;
2669         }
2670
2671         return p - ptr;
2672 }
2673
2674 char *strxfrchar(char *s, char from, char to)
2675 {
2676         char *p = s;
2677
2678         while ((p = strchr(p, from)) != NULL)
2679                 *p++ = to;
2680
2681         return s;
2682 }
2683
2684 int machines__create_guest_kernel_maps(struct rb_root *machines)
2685 {
2686         int ret = 0;
2687         struct dirent **namelist = NULL;
2688         int i, items = 0;
2689         char path[PATH_MAX];
2690         pid_t pid;
2691
2692         if (symbol_conf.default_guest_vmlinux_name ||
2693             symbol_conf.default_guest_modules ||
2694             symbol_conf.default_guest_kallsyms) {
2695                 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2696         }
2697
2698         if (symbol_conf.guestmount) {
2699                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2700                 if (items <= 0)
2701                         return -ENOENT;
2702                 for (i = 0; i < items; i++) {
2703                         if (!isdigit(namelist[i]->d_name[0])) {
2704                                 /* Filter out . and .. */
2705                                 continue;
2706                         }
2707                         pid = atoi(namelist[i]->d_name);
2708                         sprintf(path, "%s/%s/proc/kallsyms",
2709                                 symbol_conf.guestmount,
2710                                 namelist[i]->d_name);
2711                         ret = access(path, R_OK);
2712                         if (ret) {
2713                                 pr_debug("Can't access file %s\n", path);
2714                                 goto failure;
2715                         }
2716                         machines__create_kernel_maps(machines, pid);
2717                 }
2718 failure:
2719                 free(namelist);
2720         }
2721
2722         return ret;
2723 }
2724
2725 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2726 {
2727         struct rb_node *next = rb_first(machines);
2728
2729         while (next) {
2730                 struct machine *pos = rb_entry(next, struct machine, rb_node);
2731
2732                 next = rb_next(&pos->rb_node);
2733                 rb_erase(&pos->rb_node, machines);
2734                 machine__delete(pos);
2735         }
2736 }
2737
2738 int machine__load_kallsyms(struct machine *machine, const char *filename,
2739                            enum map_type type, symbol_filter_t filter)
2740 {
2741         struct map *map = machine->vmlinux_maps[type];
2742         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2743
2744         if (ret > 0) {
2745                 dso__set_loaded(map->dso, type);
2746                 /*
2747                  * Since /proc/kallsyms will have multiple sessions for the
2748                  * kernel, with modules between them, fixup the end of all
2749                  * sections.
2750                  */
2751                 __map_groups__fixup_end(&machine->kmaps, type);
2752         }
2753
2754         return ret;
2755 }
2756
2757 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2758                                symbol_filter_t filter)
2759 {
2760         struct map *map = machine->vmlinux_maps[type];
2761         int ret = dso__load_vmlinux_path(map->dso, map, filter);
2762
2763         if (ret > 0) {
2764                 dso__set_loaded(map->dso, type);
2765                 map__reloc_vmlinux(map);
2766         }
2767
2768         return ret;
2769 }