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         sec = elf_section_by_name(elf, &ehdr, &shdr,
1482                                   ".note.gnu.build-id", NULL);
1483         if (sec == NULL) {
1484                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1485                                           ".notes", NULL);
1486                 if (sec == NULL)
1487                         goto out;
1488         }
1489
1490         data = elf_getdata(sec, NULL);
1491         if (data == NULL)
1492                 goto out;
1493
1494         ptr = data->d_buf;
1495         while (ptr < (data->d_buf + data->d_size)) {
1496                 GElf_Nhdr *nhdr = ptr;
1497                 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1498                        descsz = NOTE_ALIGN(nhdr->n_descsz);
1499                 const char *name;
1500
1501                 ptr += sizeof(*nhdr);
1502                 name = ptr;
1503                 ptr += namesz;
1504                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1505                     nhdr->n_namesz == sizeof("GNU")) {
1506                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1507                                 size_t sz = min(size, descsz);
1508                                 memcpy(bf, ptr, sz);
1509                                 memset(bf + sz, 0, size - sz);
1510                                 err = descsz;
1511                                 break;
1512                         }
1513                 }
1514                 ptr += descsz;
1515         }
1516
1517 out:
1518         return err;
1519 }
1520
1521 int filename__read_build_id(const char *filename, void *bf, size_t size)
1522 {
1523         int fd, err = -1;
1524         Elf *elf;
1525
1526         if (size < BUILD_ID_SIZE)
1527                 goto out;
1528
1529         fd = open(filename, O_RDONLY);
1530         if (fd < 0)
1531                 goto out;
1532
1533         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1534         if (elf == NULL) {
1535                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1536                 goto out_close;
1537         }
1538
1539         err = elf_read_build_id(elf, bf, size);
1540
1541         elf_end(elf);
1542 out_close:
1543         close(fd);
1544 out:
1545         return err;
1546 }
1547
1548 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1549 {
1550         int fd, err = -1;
1551
1552         if (size < BUILD_ID_SIZE)
1553                 goto out;
1554
1555         fd = open(filename, O_RDONLY);
1556         if (fd < 0)
1557                 goto out;
1558
1559         while (1) {
1560                 char bf[BUFSIZ];
1561                 GElf_Nhdr nhdr;
1562                 size_t namesz, descsz;
1563
1564                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1565                         break;
1566
1567                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1568                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1569                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1570                     nhdr.n_namesz == sizeof("GNU")) {
1571                         if (read(fd, bf, namesz) != (ssize_t)namesz)
1572                                 break;
1573                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1574                                 size_t sz = min(descsz, size);
1575                                 if (read(fd, build_id, sz) == (ssize_t)sz) {
1576                                         memset(build_id + sz, 0, size - sz);
1577                                         err = 0;
1578                                         break;
1579                                 }
1580                         } else if (read(fd, bf, descsz) != (ssize_t)descsz)
1581                                 break;
1582                 } else {
1583                         int n = namesz + descsz;
1584                         if (read(fd, bf, n) != n)
1585                                 break;
1586                 }
1587         }
1588         close(fd);
1589 out:
1590         return err;
1591 }
1592
1593 char dso__symtab_origin(const struct dso *dso)
1594 {
1595         static const char origin[] = {
1596                 [SYMTAB__KALLSYMS]            = 'k',
1597                 [SYMTAB__JAVA_JIT]            = 'j',
1598                 [SYMTAB__BUILD_ID_CACHE]      = 'B',
1599                 [SYMTAB__FEDORA_DEBUGINFO]    = 'f',
1600                 [SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
1601                 [SYMTAB__BUILDID_DEBUGINFO]   = 'b',
1602                 [SYMTAB__SYSTEM_PATH_DSO]     = 'd',
1603                 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
1604                 [SYMTAB__GUEST_KALLSYMS]      =  'g',
1605                 [SYMTAB__GUEST_KMODULE]       =  'G',
1606         };
1607
1608         if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
1609                 return '!';
1610         return origin[dso->symtab_type];
1611 }
1612
1613 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1614 {
1615         int size = PATH_MAX;
1616         char *name;
1617         int ret = -1;
1618         int fd;
1619         struct machine *machine;
1620         const char *root_dir;
1621         int want_symtab;
1622
1623         dso__set_loaded(dso, map->type);
1624
1625         if (dso->kernel == DSO_TYPE_KERNEL)
1626                 return dso__load_kernel_sym(dso, map, filter);
1627         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1628                 return dso__load_guest_kernel_sym(dso, map, filter);
1629
1630         if (map->groups && map->groups->machine)
1631                 machine = map->groups->machine;
1632         else
1633                 machine = NULL;
1634
1635         name = malloc(size);
1636         if (!name)
1637                 return -1;
1638
1639         dso->adjust_symbols = 0;
1640
1641         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1642                 struct stat st;
1643
1644                 if (lstat(dso->name, &st) < 0)
1645                         return -1;
1646
1647                 if (st.st_uid && (st.st_uid != geteuid())) {
1648                         pr_warning("File %s not owned by current user or root, "
1649                                 "ignoring it.\n", dso->name);
1650                         return -1;
1651                 }
1652
1653                 ret = dso__load_perf_map(dso, map, filter);
1654                 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
1655                                               SYMTAB__NOT_FOUND;
1656                 return ret;
1657         }
1658
1659         /* Iterate over candidate debug images.
1660          * On the first pass, only load images if they have a full symtab.
1661          * Failing that, do a second pass where we accept .dynsym also
1662          */
1663         want_symtab = 1;
1664 restart:
1665         for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
1666              dso->symtab_type != SYMTAB__NOT_FOUND;
1667              dso->symtab_type++) {
1668                 switch (dso->symtab_type) {
1669                 case SYMTAB__BUILD_ID_CACHE:
1670                         /* skip the locally configured cache if a symfs is given */
1671                         if (symbol_conf.symfs[0] ||
1672                             (dso__build_id_filename(dso, name, size) == NULL)) {
1673                                 continue;
1674                         }
1675                         break;
1676                 case SYMTAB__FEDORA_DEBUGINFO:
1677                         snprintf(name, size, "%s/usr/lib/debug%s.debug",
1678                                  symbol_conf.symfs, dso->long_name);
1679                         break;
1680                 case SYMTAB__UBUNTU_DEBUGINFO:
1681                         snprintf(name, size, "%s/usr/lib/debug%s",
1682                                  symbol_conf.symfs, dso->long_name);
1683                         break;
1684                 case SYMTAB__BUILDID_DEBUGINFO: {
1685                         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1686
1687                         if (!dso->has_build_id)
1688                                 continue;
1689
1690                         build_id__sprintf(dso->build_id,
1691                                           sizeof(dso->build_id),
1692                                           build_id_hex);
1693                         snprintf(name, size,
1694                                  "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1695                                  symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1696                         }
1697                         break;
1698                 case SYMTAB__SYSTEM_PATH_DSO:
1699                         snprintf(name, size, "%s%s",
1700                              symbol_conf.symfs, dso->long_name);
1701                         break;
1702                 case SYMTAB__GUEST_KMODULE:
1703                         if (map->groups && machine)
1704                                 root_dir = machine->root_dir;
1705                         else
1706                                 root_dir = "";
1707                         snprintf(name, size, "%s%s%s", symbol_conf.symfs,
1708                                  root_dir, dso->long_name);
1709                         break;
1710
1711                 case SYMTAB__SYSTEM_PATH_KMODULE:
1712                         snprintf(name, size, "%s%s", symbol_conf.symfs,
1713                                  dso->long_name);
1714                         break;
1715                 default:;
1716                 }
1717
1718                 /* Name is now the name of the next image to try */
1719                 fd = open(name, O_RDONLY);
1720                 if (fd < 0)
1721                         continue;
1722
1723                 ret = dso__load_sym(dso, map, name, fd, filter, 0,
1724                                     want_symtab);
1725                 close(fd);
1726
1727                 /*
1728                  * Some people seem to have debuginfo files _WITHOUT_ debug
1729                  * info!?!?
1730                  */
1731                 if (!ret)
1732                         continue;
1733
1734                 if (ret > 0) {
1735                         int nr_plt;
1736
1737                         nr_plt = dso__synthesize_plt_symbols(dso, name, map, filter);
1738                         if (nr_plt > 0)
1739                                 ret += nr_plt;
1740                         break;
1741                 }
1742         }
1743
1744         /*
1745          * If we wanted a full symtab but no image had one,
1746          * relax our requirements and repeat the search.
1747          */
1748         if (ret <= 0 && want_symtab) {
1749                 want_symtab = 0;
1750                 goto restart;
1751         }
1752
1753         free(name);
1754         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1755                 return 0;
1756         return ret;
1757 }
1758
1759 struct map *map_groups__find_by_name(struct map_groups *mg,
1760                                      enum map_type type, const char *name)
1761 {
1762         struct rb_node *nd;
1763
1764         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1765                 struct map *map = rb_entry(nd, struct map, rb_node);
1766
1767                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1768                         return map;
1769         }
1770
1771         return NULL;
1772 }
1773
1774 static int dso__kernel_module_get_build_id(struct dso *dso,
1775                                            const char *root_dir)
1776 {
1777         char filename[PATH_MAX];
1778         /*
1779          * kernel module short names are of the form "[module]" and
1780          * we need just "module" here.
1781          */
1782         const char *name = dso->short_name + 1;
1783
1784         snprintf(filename, sizeof(filename),
1785                  "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1786                  root_dir, (int)strlen(name) - 1, name);
1787
1788         if (sysfs__read_build_id(filename, dso->build_id,
1789                                  sizeof(dso->build_id)) == 0)
1790                 dso->has_build_id = true;
1791
1792         return 0;
1793 }
1794
1795 static int map_groups__set_modules_path_dir(struct map_groups *mg,
1796                                 const char *dir_name)
1797 {
1798         struct dirent *dent;
1799         DIR *dir = opendir(dir_name);
1800         int ret = 0;
1801
1802         if (!dir) {
1803                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1804                 return -1;
1805         }
1806
1807         while ((dent = readdir(dir)) != NULL) {
1808                 char path[PATH_MAX];
1809                 struct stat st;
1810
1811                 /*sshfs might return bad dent->d_type, so we have to stat*/
1812                 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
1813                 if (stat(path, &st))
1814                         continue;
1815
1816                 if (S_ISDIR(st.st_mode)) {
1817                         if (!strcmp(dent->d_name, ".") ||
1818                             !strcmp(dent->d_name, ".."))
1819                                 continue;
1820
1821                         ret = map_groups__set_modules_path_dir(mg, path);
1822                         if (ret < 0)
1823                                 goto out;
1824                 } else {
1825                         char *dot = strrchr(dent->d_name, '.'),
1826                              dso_name[PATH_MAX];
1827                         struct map *map;
1828                         char *long_name;
1829
1830                         if (dot == NULL || strcmp(dot, ".ko"))
1831                                 continue;
1832                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1833                                  (int)(dot - dent->d_name), dent->d_name);
1834
1835                         strxfrchar(dso_name, '-', '_');
1836                         map = map_groups__find_by_name(mg, MAP__FUNCTION,
1837                                                        dso_name);
1838                         if (map == NULL)
1839                                 continue;
1840
1841                         long_name = strdup(path);
1842                         if (long_name == NULL) {
1843                                 ret = -1;
1844                                 goto out;
1845                         }
1846                         dso__set_long_name(map->dso, long_name);
1847                         map->dso->lname_alloc = 1;
1848                         dso__kernel_module_get_build_id(map->dso, "");
1849                 }
1850         }
1851
1852 out:
1853         closedir(dir);
1854         return ret;
1855 }
1856
1857 static char *get_kernel_version(const char *root_dir)
1858 {
1859         char version[PATH_MAX];
1860         FILE *file;
1861         char *name, *tmp;
1862         const char *prefix = "Linux version ";
1863
1864         sprintf(version, "%s/proc/version", root_dir);
1865         file = fopen(version, "r");
1866         if (!file)
1867                 return NULL;
1868
1869         version[0] = '\0';
1870         tmp = fgets(version, sizeof(version), file);
1871         fclose(file);
1872
1873         name = strstr(version, prefix);
1874         if (!name)
1875                 return NULL;
1876         name += strlen(prefix);
1877         tmp = strchr(name, ' ');
1878         if (tmp)
1879                 *tmp = '\0';
1880
1881         return strdup(name);
1882 }
1883
1884 static int machine__set_modules_path(struct machine *machine)
1885 {
1886         char *version;
1887         char modules_path[PATH_MAX];
1888
1889         version = get_kernel_version(machine->root_dir);
1890         if (!version)
1891                 return -1;
1892
1893         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1894                  machine->root_dir, version);
1895         free(version);
1896
1897         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
1898 }
1899
1900 /*
1901  * Constructor variant for modules (where we know from /proc/modules where
1902  * they are loaded) and for vmlinux, where only after we load all the
1903  * symbols we'll know where it starts and ends.
1904  */
1905 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1906 {
1907         struct map *map = calloc(1, (sizeof(*map) +
1908                                      (dso->kernel ? sizeof(struct kmap) : 0)));
1909         if (map != NULL) {
1910                 /*
1911                  * ->end will be filled after we load all the symbols
1912                  */
1913                 map__init(map, type, start, 0, 0, dso);
1914         }
1915
1916         return map;
1917 }
1918
1919 struct map *machine__new_module(struct machine *machine, u64 start,
1920                                 const char *filename)
1921 {
1922         struct map *map;
1923         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
1924
1925         if (dso == NULL)
1926                 return NULL;
1927
1928         map = map__new2(start, dso, MAP__FUNCTION);
1929         if (map == NULL)
1930                 return NULL;
1931
1932         if (machine__is_host(machine))
1933                 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
1934         else
1935                 dso->symtab_type = SYMTAB__GUEST_KMODULE;
1936         map_groups__insert(&machine->kmaps, map);
1937         return map;
1938 }
1939
1940 static int machine__create_modules(struct machine *machine)
1941 {
1942         char *line = NULL;
1943         size_t n;
1944         FILE *file;
1945         struct map *map;
1946         const char *modules;
1947         char path[PATH_MAX];
1948
1949         if (machine__is_default_guest(machine))
1950                 modules = symbol_conf.default_guest_modules;
1951         else {
1952                 sprintf(path, "%s/proc/modules", machine->root_dir);
1953                 modules = path;
1954         }
1955
1956         if (symbol__restricted_filename(path, "/proc/modules"))
1957                 return -1;
1958
1959         file = fopen(modules, "r");
1960         if (file == NULL)
1961                 return -1;
1962
1963         while (!feof(file)) {
1964                 char name[PATH_MAX];
1965                 u64 start;
1966                 char *sep;
1967                 int line_len;
1968
1969                 line_len = getline(&line, &n, file);
1970                 if (line_len < 0)
1971                         break;
1972
1973                 if (!line)
1974                         goto out_failure;
1975
1976                 line[--line_len] = '\0'; /* \n */
1977
1978                 sep = strrchr(line, 'x');
1979                 if (sep == NULL)
1980                         continue;
1981
1982                 hex2u64(sep + 1, &start);
1983
1984                 sep = strchr(line, ' ');
1985                 if (sep == NULL)
1986                         continue;
1987
1988                 *sep = '\0';
1989
1990                 snprintf(name, sizeof(name), "[%s]", line);
1991                 map = machine__new_module(machine, start, name);
1992                 if (map == NULL)
1993                         goto out_delete_line;
1994                 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1995         }
1996
1997         free(line);
1998         fclose(file);
1999
2000         return machine__set_modules_path(machine);
2001
2002 out_delete_line:
2003         free(line);
2004 out_failure:
2005         return -1;
2006 }
2007
2008 int dso__load_vmlinux(struct dso *dso, struct map *map,
2009                       const char *vmlinux, symbol_filter_t filter)
2010 {
2011         int err = -1, fd;
2012         char symfs_vmlinux[PATH_MAX];
2013
2014         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
2015                  symbol_conf.symfs, vmlinux);
2016         fd = open(symfs_vmlinux, O_RDONLY);
2017         if (fd < 0)
2018                 return -1;
2019
2020         dso__set_long_name(dso, (char *)vmlinux);
2021         dso__set_loaded(dso, map->type);
2022         err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
2023         close(fd);
2024
2025         if (err > 0)
2026                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
2027
2028         return err;
2029 }
2030
2031 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
2032                            symbol_filter_t filter)
2033 {
2034         int i, err = 0;
2035         char *filename;
2036
2037         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
2038                  vmlinux_path__nr_entries + 1);
2039
2040         filename = dso__build_id_filename(dso, NULL, 0);
2041         if (filename != NULL) {
2042                 err = dso__load_vmlinux(dso, map, filename, filter);
2043                 if (err > 0) {
2044                         dso__set_long_name(dso, filename);
2045                         goto out;
2046                 }
2047                 free(filename);
2048         }
2049
2050         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2051                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2052                 if (err > 0) {
2053                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
2054                         break;
2055                 }
2056         }
2057 out:
2058         return err;
2059 }
2060
2061 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2062                                 symbol_filter_t filter)
2063 {
2064         int err;
2065         const char *kallsyms_filename = NULL;
2066         char *kallsyms_allocated_filename = NULL;
2067         /*
2068          * Step 1: if the user specified a kallsyms or vmlinux filename, use
2069          * it and only it, reporting errors to the user if it cannot be used.
2070          *
2071          * For instance, try to analyse an ARM perf.data file _without_ a
2072          * build-id, or if the user specifies the wrong path to the right
2073          * vmlinux file, obviously we can't fallback to another vmlinux (a
2074          * x86_86 one, on the machine where analysis is being performed, say),
2075          * or worse, /proc/kallsyms.
2076          *
2077          * If the specified file _has_ a build-id and there is a build-id
2078          * section in the perf.data file, we will still do the expected
2079          * validation in dso__load_vmlinux and will bail out if they don't
2080          * match.
2081          */
2082         if (symbol_conf.kallsyms_name != NULL) {
2083                 kallsyms_filename = symbol_conf.kallsyms_name;
2084                 goto do_kallsyms;
2085         }
2086
2087         if (symbol_conf.vmlinux_name != NULL) {
2088                 err = dso__load_vmlinux(dso, map,
2089                                         symbol_conf.vmlinux_name, filter);
2090                 if (err > 0) {
2091                         dso__set_long_name(dso,
2092                                            strdup(symbol_conf.vmlinux_name));
2093                         goto out_fixup;
2094                 }
2095                 return err;
2096         }
2097
2098         if (vmlinux_path != NULL) {
2099                 err = dso__load_vmlinux_path(dso, map, filter);
2100                 if (err > 0)
2101                         goto out_fixup;
2102         }
2103
2104         /* do not try local files if a symfs was given */
2105         if (symbol_conf.symfs[0] != 0)
2106                 return -1;
2107
2108         /*
2109          * Say the kernel DSO was created when processing the build-id header table,
2110          * we have a build-id, so check if it is the same as the running kernel,
2111          * using it if it is.
2112          */
2113         if (dso->has_build_id) {
2114                 u8 kallsyms_build_id[BUILD_ID_SIZE];
2115                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2116
2117                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2118                                          sizeof(kallsyms_build_id)) == 0) {
2119                         if (dso__build_id_equal(dso, kallsyms_build_id)) {
2120                                 kallsyms_filename = "/proc/kallsyms";
2121                                 goto do_kallsyms;
2122                         }
2123                 }
2124                 /*
2125                  * Now look if we have it on the build-id cache in
2126                  * $HOME/.debug/[kernel.kallsyms].
2127                  */
2128                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2129                                   sbuild_id);
2130
2131                 if (asprintf(&kallsyms_allocated_filename,
2132                              "%s/.debug/[kernel.kallsyms]/%s",
2133                              getenv("HOME"), sbuild_id) == -1) {
2134                         pr_err("Not enough memory for kallsyms file lookup\n");
2135                         return -1;
2136                 }
2137
2138                 kallsyms_filename = kallsyms_allocated_filename;
2139
2140                 if (access(kallsyms_filename, F_OK)) {
2141                         pr_err("No kallsyms or vmlinux with build-id %s "
2142                                "was found\n", sbuild_id);
2143                         free(kallsyms_allocated_filename);
2144                         return -1;
2145                 }
2146         } else {
2147                 /*
2148                  * Last resort, if we don't have a build-id and couldn't find
2149                  * any vmlinux file, try the running kernel kallsyms table.
2150                  */
2151                 kallsyms_filename = "/proc/kallsyms";
2152         }
2153
2154 do_kallsyms:
2155         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2156         if (err > 0)
2157                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2158         free(kallsyms_allocated_filename);
2159
2160         if (err > 0) {
2161 out_fixup:
2162                 if (kallsyms_filename != NULL)
2163                         dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2164                 map__fixup_start(map);
2165                 map__fixup_end(map);
2166         }
2167
2168         return err;
2169 }
2170
2171 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2172                                       symbol_filter_t filter)
2173 {
2174         int err;
2175         const char *kallsyms_filename = NULL;
2176         struct machine *machine;
2177         char path[PATH_MAX];
2178
2179         if (!map->groups) {
2180                 pr_debug("Guest kernel map hasn't the point to groups\n");
2181                 return -1;
2182         }
2183         machine = map->groups->machine;
2184
2185         if (machine__is_default_guest(machine)) {
2186                 /*
2187                  * if the user specified a vmlinux filename, use it and only
2188                  * it, reporting errors to the user if it cannot be used.
2189                  * Or use file guest_kallsyms inputted by user on commandline
2190                  */
2191                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2192                         err = dso__load_vmlinux(dso, map,
2193                                 symbol_conf.default_guest_vmlinux_name, filter);
2194                         goto out_try_fixup;
2195                 }
2196
2197                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2198                 if (!kallsyms_filename)
2199                         return -1;
2200         } else {
2201                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2202                 kallsyms_filename = path;
2203         }
2204
2205         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2206         if (err > 0)
2207                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2208
2209 out_try_fixup:
2210         if (err > 0) {
2211                 if (kallsyms_filename != NULL) {
2212                         machine__mmap_name(machine, path, sizeof(path));
2213                         dso__set_long_name(dso, strdup(path));
2214                 }
2215                 map__fixup_start(map);
2216                 map__fixup_end(map);
2217         }
2218
2219         return err;
2220 }
2221
2222 static void dsos__add(struct list_head *head, struct dso *dso)
2223 {
2224         list_add_tail(&dso->node, head);
2225 }
2226
2227 static struct dso *dsos__find(struct list_head *head, const char *name)
2228 {
2229         struct dso *pos;
2230
2231         list_for_each_entry(pos, head, node)
2232                 if (strcmp(pos->long_name, name) == 0)
2233                         return pos;
2234         return NULL;
2235 }
2236
2237 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2238 {
2239         struct dso *dso = dsos__find(head, name);
2240
2241         if (!dso) {
2242                 dso = dso__new(name);
2243                 if (dso != NULL) {
2244                         dsos__add(head, dso);
2245                         dso__set_basename(dso);
2246                 }
2247         }
2248
2249         return dso;
2250 }
2251
2252 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2253 {
2254         struct dso *pos;
2255         size_t ret = 0;
2256
2257         list_for_each_entry(pos, head, node) {
2258                 int i;
2259                 for (i = 0; i < MAP__NR_TYPES; ++i)
2260                         ret += dso__fprintf(pos, i, fp);
2261         }
2262
2263         return ret;
2264 }
2265
2266 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2267 {
2268         struct rb_node *nd;
2269         size_t ret = 0;
2270
2271         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2272                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2273                 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2274                 ret += __dsos__fprintf(&pos->user_dsos, fp);
2275         }
2276
2277         return ret;
2278 }
2279
2280 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2281                                       bool with_hits)
2282 {
2283         struct dso *pos;
2284         size_t ret = 0;
2285
2286         list_for_each_entry(pos, head, node) {
2287                 if (with_hits && !pos->hit)
2288                         continue;
2289                 ret += dso__fprintf_buildid(pos, fp);
2290                 ret += fprintf(fp, " %s\n", pos->long_name);
2291         }
2292         return ret;
2293 }
2294
2295 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2296                                      bool with_hits)
2297 {
2298         return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2299                __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2300 }
2301
2302 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2303                                       FILE *fp, bool with_hits)
2304 {
2305         struct rb_node *nd;
2306         size_t ret = 0;
2307
2308         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2309                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2310                 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2311         }
2312         return ret;
2313 }
2314
2315 static struct dso*
2316 dso__kernel_findnew(struct machine *machine, const char *name,
2317                     const char *short_name, int dso_type)
2318 {
2319         /*
2320          * The kernel dso could be created by build_id processing.
2321          */
2322         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2323
2324         /*
2325          * We need to run this in all cases, since during the build_id
2326          * processing we had no idea this was the kernel dso.
2327          */
2328         if (dso != NULL) {
2329                 dso__set_short_name(dso, short_name);
2330                 dso->kernel = dso_type;
2331         }
2332
2333         return dso;
2334 }
2335
2336 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2337 {
2338         char path[PATH_MAX];
2339
2340         if (machine__is_default_guest(machine))
2341                 return;
2342         sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2343         if (sysfs__read_build_id(path, dso->build_id,
2344                                  sizeof(dso->build_id)) == 0)
2345                 dso->has_build_id = true;
2346 }
2347
2348 static struct dso *machine__get_kernel(struct machine *machine)
2349 {
2350         const char *vmlinux_name = NULL;
2351         struct dso *kernel;
2352
2353         if (machine__is_host(machine)) {
2354                 vmlinux_name = symbol_conf.vmlinux_name;
2355                 if (!vmlinux_name)
2356                         vmlinux_name = "[kernel.kallsyms]";
2357
2358                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2359                                              "[kernel]",
2360                                              DSO_TYPE_KERNEL);
2361         } else {
2362                 char bf[PATH_MAX];
2363
2364                 if (machine__is_default_guest(machine))
2365                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2366                 if (!vmlinux_name)
2367                         vmlinux_name = machine__mmap_name(machine, bf,
2368                                                           sizeof(bf));
2369
2370                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2371                                              "[guest.kernel]",
2372                                              DSO_TYPE_GUEST_KERNEL);
2373         }
2374
2375         if (kernel != NULL && (!kernel->has_build_id))
2376                 dso__read_running_kernel_build_id(kernel, machine);
2377
2378         return kernel;
2379 }
2380
2381 struct process_args {
2382         u64 start;
2383 };
2384
2385 static int symbol__in_kernel(void *arg, const char *name,
2386                              char type __used, u64 start, u64 end __used)
2387 {
2388         struct process_args *args = arg;
2389
2390         if (strchr(name, '['))
2391                 return 0;
2392
2393         args->start = start;
2394         return 1;
2395 }
2396
2397 /* Figure out the start address of kernel map from /proc/kallsyms */
2398 static u64 machine__get_kernel_start_addr(struct machine *machine)
2399 {
2400         const char *filename;
2401         char path[PATH_MAX];
2402         struct process_args args;
2403
2404         if (machine__is_host(machine)) {
2405                 filename = "/proc/kallsyms";
2406         } else {
2407                 if (machine__is_default_guest(machine))
2408                         filename = (char *)symbol_conf.default_guest_kallsyms;
2409                 else {
2410                         sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2411                         filename = path;
2412                 }
2413         }
2414
2415         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2416                 return 0;
2417
2418         if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2419                 return 0;
2420
2421         return args.start;
2422 }
2423
2424 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
2425 {
2426         enum map_type type;
2427         u64 start = machine__get_kernel_start_addr(machine);
2428
2429         for (type = 0; type < MAP__NR_TYPES; ++type) {
2430                 struct kmap *kmap;
2431
2432                 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2433                 if (machine->vmlinux_maps[type] == NULL)
2434                         return -1;
2435
2436                 machine->vmlinux_maps[type]->map_ip =
2437                         machine->vmlinux_maps[type]->unmap_ip =
2438                                 identity__map_ip;
2439                 kmap = map__kmap(machine->vmlinux_maps[type]);
2440                 kmap->kmaps = &machine->kmaps;
2441                 map_groups__insert(&machine->kmaps,
2442                                    machine->vmlinux_maps[type]);
2443         }
2444
2445         return 0;
2446 }
2447
2448 void machine__destroy_kernel_maps(struct machine *machine)
2449 {
2450         enum map_type type;
2451
2452         for (type = 0; type < MAP__NR_TYPES; ++type) {
2453                 struct kmap *kmap;
2454
2455                 if (machine->vmlinux_maps[type] == NULL)
2456                         continue;
2457
2458                 kmap = map__kmap(machine->vmlinux_maps[type]);
2459                 map_groups__remove(&machine->kmaps,
2460                                    machine->vmlinux_maps[type]);
2461                 if (kmap->ref_reloc_sym) {
2462                         /*
2463                          * ref_reloc_sym is shared among all maps, so free just
2464                          * on one of them.
2465                          */
2466                         if (type == MAP__FUNCTION) {
2467                                 free((char *)kmap->ref_reloc_sym->name);
2468                                 kmap->ref_reloc_sym->name = NULL;
2469                                 free(kmap->ref_reloc_sym);
2470                         }
2471                         kmap->ref_reloc_sym = NULL;
2472                 }
2473
2474                 map__delete(machine->vmlinux_maps[type]);
2475                 machine->vmlinux_maps[type] = NULL;
2476         }
2477 }
2478
2479 int machine__create_kernel_maps(struct machine *machine)
2480 {
2481         struct dso *kernel = machine__get_kernel(machine);
2482
2483         if (kernel == NULL ||
2484             __machine__create_kernel_maps(machine, kernel) < 0)
2485                 return -1;
2486
2487         if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
2488                 pr_debug("Problems creating module maps, continuing anyway...\n");
2489         /*
2490          * Now that we have all the maps created, just set the ->end of them:
2491          */
2492         map_groups__fixup_end(&machine->kmaps);
2493         return 0;
2494 }
2495
2496 static void vmlinux_path__exit(void)
2497 {
2498         while (--vmlinux_path__nr_entries >= 0) {
2499                 free(vmlinux_path[vmlinux_path__nr_entries]);
2500                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2501         }
2502
2503         free(vmlinux_path);
2504         vmlinux_path = NULL;
2505 }
2506
2507 static int vmlinux_path__init(void)
2508 {
2509         struct utsname uts;
2510         char bf[PATH_MAX];
2511
2512         vmlinux_path = malloc(sizeof(char *) * 5);
2513         if (vmlinux_path == NULL)
2514                 return -1;
2515
2516         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2517         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2518                 goto out_fail;
2519         ++vmlinux_path__nr_entries;
2520         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2521         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2522                 goto out_fail;
2523         ++vmlinux_path__nr_entries;
2524
2525         /* only try running kernel version if no symfs was given */
2526         if (symbol_conf.symfs[0] != 0)
2527                 return 0;
2528
2529         if (uname(&uts) < 0)
2530                 return -1;
2531
2532         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2533         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2534         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2535                 goto out_fail;
2536         ++vmlinux_path__nr_entries;
2537         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2538         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2539         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2540                 goto out_fail;
2541         ++vmlinux_path__nr_entries;
2542         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2543                  uts.release);
2544         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2545         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2546                 goto out_fail;
2547         ++vmlinux_path__nr_entries;
2548
2549         return 0;
2550
2551 out_fail:
2552         vmlinux_path__exit();
2553         return -1;
2554 }
2555
2556 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2557 {
2558         int i;
2559         size_t printed = 0;
2560         struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2561
2562         if (kdso->has_build_id) {
2563                 char filename[PATH_MAX];
2564                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2565                         printed += fprintf(fp, "[0] %s\n", filename);
2566         }
2567
2568         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2569                 printed += fprintf(fp, "[%d] %s\n",
2570                                    i + kdso->has_build_id, vmlinux_path[i]);
2571
2572         return printed;
2573 }
2574
2575 static int setup_list(struct strlist **list, const char *list_str,
2576                       const char *list_name)
2577 {
2578         if (list_str == NULL)
2579                 return 0;
2580
2581         *list = strlist__new(true, list_str);
2582         if (!*list) {
2583                 pr_err("problems parsing %s list\n", list_name);
2584                 return -1;
2585         }
2586         return 0;
2587 }
2588
2589 static bool symbol__read_kptr_restrict(void)
2590 {
2591         bool value = false;
2592
2593         if (geteuid() != 0) {
2594                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2595                 if (fp != NULL) {
2596                         char line[8];
2597
2598                         if (fgets(line, sizeof(line), fp) != NULL)
2599                                 value = atoi(line) != 0;
2600
2601                         fclose(fp);
2602                 }
2603         }
2604
2605         return value;
2606 }
2607
2608 int symbol__init(void)
2609 {
2610         const char *symfs;
2611
2612         if (symbol_conf.initialized)
2613                 return 0;
2614
2615         symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2616
2617         elf_version(EV_CURRENT);
2618         if (symbol_conf.sort_by_name)
2619                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2620                                           sizeof(struct symbol));
2621
2622         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2623                 return -1;
2624
2625         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2626                 pr_err("'.' is the only non valid --field-separator argument\n");
2627                 return -1;
2628         }
2629
2630         if (setup_list(&symbol_conf.dso_list,
2631                        symbol_conf.dso_list_str, "dso") < 0)
2632                 return -1;
2633
2634         if (setup_list(&symbol_conf.comm_list,
2635                        symbol_conf.comm_list_str, "comm") < 0)
2636                 goto out_free_dso_list;
2637
2638         if (setup_list(&symbol_conf.sym_list,
2639                        symbol_conf.sym_list_str, "symbol") < 0)
2640                 goto out_free_comm_list;
2641
2642         /*
2643          * A path to symbols of "/" is identical to ""
2644          * reset here for simplicity.
2645          */
2646         symfs = realpath(symbol_conf.symfs, NULL);
2647         if (symfs == NULL)
2648                 symfs = symbol_conf.symfs;
2649         if (strcmp(symfs, "/") == 0)
2650                 symbol_conf.symfs = "";
2651         if (symfs != symbol_conf.symfs)
2652                 free((void *)symfs);
2653
2654         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2655
2656         symbol_conf.initialized = true;
2657         return 0;
2658
2659 out_free_comm_list:
2660         strlist__delete(symbol_conf.comm_list);
2661 out_free_dso_list:
2662         strlist__delete(symbol_conf.dso_list);
2663         return -1;
2664 }
2665
2666 void symbol__exit(void)
2667 {
2668         if (!symbol_conf.initialized)
2669                 return;
2670         strlist__delete(symbol_conf.sym_list);
2671         strlist__delete(symbol_conf.dso_list);
2672         strlist__delete(symbol_conf.comm_list);
2673         vmlinux_path__exit();
2674         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2675         symbol_conf.initialized = false;
2676 }
2677
2678 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2679 {
2680         struct machine *machine = machines__findnew(machines, pid);
2681
2682         if (machine == NULL)
2683                 return -1;
2684
2685         return machine__create_kernel_maps(machine);
2686 }
2687
2688 static int hex(char ch)
2689 {
2690         if ((ch >= '0') && (ch <= '9'))
2691                 return ch - '0';
2692         if ((ch >= 'a') && (ch <= 'f'))
2693                 return ch - 'a' + 10;
2694         if ((ch >= 'A') && (ch <= 'F'))
2695                 return ch - 'A' + 10;
2696         return -1;
2697 }
2698
2699 /*
2700  * While we find nice hex chars, build a long_val.
2701  * Return number of chars processed.
2702  */
2703 int hex2u64(const char *ptr, u64 *long_val)
2704 {
2705         const char *p = ptr;
2706         *long_val = 0;
2707
2708         while (*p) {
2709                 const int hex_val = hex(*p);
2710
2711                 if (hex_val < 0)
2712                         break;
2713
2714                 *long_val = (*long_val << 4) | hex_val;
2715                 p++;
2716         }
2717
2718         return p - ptr;
2719 }
2720
2721 char *strxfrchar(char *s, char from, char to)
2722 {
2723         char *p = s;
2724
2725         while ((p = strchr(p, from)) != NULL)
2726                 *p++ = to;
2727
2728         return s;
2729 }
2730
2731 int machines__create_guest_kernel_maps(struct rb_root *machines)
2732 {
2733         int ret = 0;
2734         struct dirent **namelist = NULL;
2735         int i, items = 0;
2736         char path[PATH_MAX];
2737         pid_t pid;
2738
2739         if (symbol_conf.default_guest_vmlinux_name ||
2740             symbol_conf.default_guest_modules ||
2741             symbol_conf.default_guest_kallsyms) {
2742                 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2743         }
2744
2745         if (symbol_conf.guestmount) {
2746                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2747                 if (items <= 0)
2748                         return -ENOENT;
2749                 for (i = 0; i < items; i++) {
2750                         if (!isdigit(namelist[i]->d_name[0])) {
2751                                 /* Filter out . and .. */
2752                                 continue;
2753                         }
2754                         pid = atoi(namelist[i]->d_name);
2755                         sprintf(path, "%s/%s/proc/kallsyms",
2756                                 symbol_conf.guestmount,
2757                                 namelist[i]->d_name);
2758                         ret = access(path, R_OK);
2759                         if (ret) {
2760                                 pr_debug("Can't access file %s\n", path);
2761                                 goto failure;
2762                         }
2763                         machines__create_kernel_maps(machines, pid);
2764                 }
2765 failure:
2766                 free(namelist);
2767         }
2768
2769         return ret;
2770 }
2771
2772 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2773 {
2774         struct rb_node *next = rb_first(machines);
2775
2776         while (next) {
2777                 struct machine *pos = rb_entry(next, struct machine, rb_node);
2778
2779                 next = rb_next(&pos->rb_node);
2780                 rb_erase(&pos->rb_node, machines);
2781                 machine__delete(pos);
2782         }
2783 }
2784
2785 int machine__load_kallsyms(struct machine *machine, const char *filename,
2786                            enum map_type type, symbol_filter_t filter)
2787 {
2788         struct map *map = machine->vmlinux_maps[type];
2789         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2790
2791         if (ret > 0) {
2792                 dso__set_loaded(map->dso, type);
2793                 /*
2794                  * Since /proc/kallsyms will have multiple sessions for the
2795                  * kernel, with modules between them, fixup the end of all
2796                  * sections.
2797                  */
2798                 __map_groups__fixup_end(&machine->kmaps, type);
2799         }
2800
2801         return ret;
2802 }
2803
2804 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2805                                symbol_filter_t filter)
2806 {
2807         struct map *map = machine->vmlinux_maps[type];
2808         int ret = dso__load_vmlinux_path(map->dso, map, filter);
2809
2810         if (ret > 0) {
2811                 dso__set_loaded(map->dso, type);
2812                 map__reloc_vmlinux(map);
2813         }
2814
2815         return ret;
2816 }
2817
2818 struct map *dso__new_map(const char *name)
2819 {
2820         struct map *map = NULL;
2821         struct dso *dso = dso__new(name);
2822
2823         if (dso)
2824                 map = map__new2(0, dso, MAP__FUNCTION);
2825
2826         return map;
2827 }