tools/perf/util/symbol.c

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