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