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
 981 dso__synthesize_plt_symbols(struct dso *dso, char *name, struct map *map,
 982                             symbol_filter_t filter)
 983 {
 984         uint32_t nr_rel_entries, idx;
 985         GElf_Sym sym;
 986         u64 plt_offset;
 987         GElf_Shdr shdr_plt;
 988         struct symbol *f;
 989         GElf_Shdr shdr_rel_plt, shdr_dynsym;
 990         Elf_Data *reldata, *syms, *symstrs;
 991         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 992         size_t dynsym_idx;
 993         GElf_Ehdr ehdr;
 994         char sympltname[1024];
 995         Elf *elf;
 996         int nr = 0, symidx, fd, err = 0;
 997
 998         fd = open(name, O_RDONLY);
 999         if (fd < 0)
1000                 goto out;
1001
1002         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1003         if (elf == NULL)
1004                 goto out_close;
1005
1006         if (gelf_getehdr(elf, &ehdr) == NULL)
1007                 goto out_elf_end;
1008
1009         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
1010                                          ".dynsym", &dynsym_idx);
1011         if (scn_dynsym == NULL)
1012                 goto out_elf_end;
1013
1014         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
1015                                           ".rela.plt", NULL);
1016         if (scn_plt_rel == NULL) {
1017                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
1018                                                   ".rel.plt", NULL);
1019                 if (scn_plt_rel == NULL)
1020                         goto out_elf_end;
1021         }
1022
1023         err = -1;
1024
1025         if (shdr_rel_plt.sh_link != dynsym_idx)
1026                 goto out_elf_end;
1027
1028         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
1029                 goto out_elf_end;
1030
1031         /*
1032          * Fetch the relocation section to find the idxes to the GOT
1033          * and the symbols in the .dynsym they refer to.
1034          */
1035         reldata = elf_getdata(scn_plt_rel, NULL);
1036         if (reldata == NULL)
1037                 goto out_elf_end;
1038
1039         syms = elf_getdata(scn_dynsym, NULL);
1040         if (syms == NULL)
1041                 goto out_elf_end;
1042
1043         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
1044         if (scn_symstrs == NULL)
1045                 goto out_elf_end;
1046
1047         symstrs = elf_getdata(scn_symstrs, NULL);
1048         if (symstrs == NULL)
1049                 goto out_elf_end;
1050
1051         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
1052         plt_offset = shdr_plt.sh_offset;
1053
1054         if (shdr_rel_plt.sh_type == SHT_RELA) {
1055                 GElf_Rela pos_mem, *pos;
1056
1057                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
1058                                            nr_rel_entries) {
1059                         symidx = GELF_R_SYM(pos->r_info);
1060                         plt_offset += shdr_plt.sh_entsize;
1061                         gelf_getsym(syms, symidx, &sym);
1062                         snprintf(sympltname, sizeof(sympltname),
1063                                  "%s@plt", elf_sym__name(&sym, symstrs));
1064
1065                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1066                                         STB_GLOBAL, sympltname);
1067                         if (!f)
1068                                 goto out_elf_end;
1069
1070                         if (filter && filter(map, f))
1071                                 symbol__delete(f);
1072                         else {
1073                                 symbols__insert(&dso->symbols[map->type], f);
1074                                 ++nr;
1075                         }
1076                 }
1077         } else if (shdr_rel_plt.sh_type == SHT_REL) {
1078                 GElf_Rel pos_mem, *pos;
1079                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
1080                                           nr_rel_entries) {
1081                         symidx = GELF_R_SYM(pos->r_info);
1082                         plt_offset += shdr_plt.sh_entsize;
1083                         gelf_getsym(syms, symidx, &sym);
1084                         snprintf(sympltname, sizeof(sympltname),
1085                                  "%s@plt", elf_sym__name(&sym, symstrs));
1086
1087                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
1088                                         STB_GLOBAL, sympltname);
1089                         if (!f)
1090                                 goto out_elf_end;
1091
1092                         if (filter && filter(map, f))
1093                                 symbol__delete(f);
1094                         else {
1095                                 symbols__insert(&dso->symbols[map->type], f);
1096                                 ++nr;
1097                         }
1098                 }
1099         }
1100
1101         err = 0;
1102 out_elf_end:
1103         elf_end(elf);
1104 out_close:
1105         close(fd);
1106
1107         if (err == 0)
1108                 return nr;
1109 out:
1110         pr_debug("%s: problems reading %s PLT info.\n",
1111                  __func__, dso->long_name);
1112         return 0;
1113 }
1114
1115 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
1116 {
1117         switch (type) {
1118         case MAP__FUNCTION:
1119                 return elf_sym__is_function(sym);
1120         case MAP__VARIABLE:
1121                 return elf_sym__is_object(sym);
1122         default:
1123                 return false;
1124         }
1125 }
1126
1127 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
1128                           enum map_type type)
1129 {
1130         switch (type) {
1131         case MAP__FUNCTION:
1132                 return elf_sec__is_text(shdr, secstrs);
1133         case MAP__VARIABLE:
1134                 return elf_sec__is_data(shdr, secstrs);
1135         default:
1136                 return false;
1137         }
1138 }
1139
1140 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
1141 {
1142         Elf_Scn *sec = NULL;
1143         GElf_Shdr shdr;
1144         size_t cnt = 1;
1145
1146         while ((sec = elf_nextscn(elf, sec)) != NULL) {
1147                 gelf_getshdr(sec, &shdr);
1148
1149                 if ((addr >= shdr.sh_addr) &&
1150                     (addr < (shdr.sh_addr + shdr.sh_size)))
1151                         return cnt;
1152
1153                 ++cnt;
1154         }
1155
1156         return -1;
1157 }
1158
1159 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
1160                          int fd, symbol_filter_t filter, int kmodule,
1161                          int want_symtab)
1162 {
1163         struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
1164         struct map *curr_map = map;
1165         struct dso *curr_dso = dso;
1166         Elf_Data *symstrs, *secstrs;
1167         uint32_t nr_syms;
1168         int err = -1;
1169         uint32_t idx;
1170         GElf_Ehdr ehdr;
1171         GElf_Shdr shdr, opdshdr;
1172         Elf_Data *syms, *opddata = NULL;
1173         GElf_Sym sym;
1174         Elf_Scn *sec, *sec_strndx, *opdsec;
1175         Elf *elf;
1176         int nr = 0;
1177         size_t opdidx = 0;
1178
1179         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1180         if (elf == NULL) {
1181                 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1182                 goto out_close;
1183         }
1184
1185         if (gelf_getehdr(elf, &ehdr) == NULL) {
1186                 pr_debug("%s: cannot get elf header.\n", __func__);
1187                 goto out_elf_end;
1188         }
1189
1190         /* Always reject images with a mismatched build-id: */
1191         if (dso->has_build_id) {
1192                 u8 build_id[BUILD_ID_SIZE];
1193
1194                 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
1195                         goto out_elf_end;
1196
1197                 if (!dso__build_id_equal(dso, build_id))
1198                         goto out_elf_end;
1199         }
1200
1201         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1202         if (sec == NULL) {
1203                 if (want_symtab)
1204                         goto out_elf_end;
1205
1206                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1207                 if (sec == NULL)
1208                         goto out_elf_end;
1209         }
1210
1211         opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1212         if (opdshdr.sh_type != SHT_PROGBITS)
1213                 opdsec = NULL;
1214         if (opdsec)
1215                 opddata = elf_rawdata(opdsec, NULL);
1216
1217         syms = elf_getdata(sec, NULL);
1218         if (syms == NULL)
1219                 goto out_elf_end;
1220
1221         sec = elf_getscn(elf, shdr.sh_link);
1222         if (sec == NULL)
1223                 goto out_elf_end;
1224
1225         symstrs = elf_getdata(sec, NULL);
1226         if (symstrs == NULL)
1227                 goto out_elf_end;
1228
1229         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1230         if (sec_strndx == NULL)
1231                 goto out_elf_end;
1232
1233         secstrs = elf_getdata(sec_strndx, NULL);
1234         if (secstrs == NULL)
1235                 goto out_elf_end;
1236
1237         nr_syms = shdr.sh_size / shdr.sh_entsize;
1238
1239         memset(&sym, 0, sizeof(sym));
1240         if (dso->kernel == DSO_TYPE_USER) {
1241                 dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1242                                 elf_section_by_name(elf, &ehdr, &shdr,
1243                                                      ".gnu.prelink_undo",
1244                                                      NULL) != NULL);
1245         } else {
1246                 dso->adjust_symbols = 0;
1247         }
1248         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1249                 struct symbol *f;
1250                 const char *elf_name = elf_sym__name(&sym, symstrs);
1251                 char *demangled = NULL;
1252                 int is_label = elf_sym__is_label(&sym);
1253                 const char *section_name;
1254
1255                 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1256                     strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1257                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1258
1259                 if (!is_label && !elf_sym__is_a(&sym, map->type))
1260                         continue;
1261
1262                 /* Reject ARM ELF "mapping symbols": these aren't unique and
1263                  * don't identify functions, so will confuse the profile
1264                  * output: */
1265                 if (ehdr.e_machine == EM_ARM) {
1266                         if (!strcmp(elf_name, "$a") ||
1267                             !strcmp(elf_name, "$d") ||
1268                             !strcmp(elf_name, "$t"))
1269                                 continue;
1270                 }
1271
1272                 if (opdsec && sym.st_shndx == opdidx) {
1273                         u32 offset = sym.st_value - opdshdr.sh_addr;
1274                         u64 *opd = opddata->d_buf + offset;
1275                         sym.st_value = *opd;
1276                         sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1277                 }
1278
1279                 sec = elf_getscn(elf, sym.st_shndx);
1280                 if (!sec)
1281                         goto out_elf_end;
1282
1283                 gelf_getshdr(sec, &shdr);
1284
1285                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1286                         continue;
1287
1288                 section_name = elf_sec__name(&shdr, secstrs);
1289
1290                 /* On ARM, symbols for thumb functions have 1 added to
1291                  * the symbol address as a flag - remove it */
1292                 if ((ehdr.e_machine == EM_ARM) &&
1293                     (map->type == MAP__FUNCTION) &&
1294                     (sym.st_value & 1))
1295                         --sym.st_value;
1296
1297                 if (dso->kernel != DSO_TYPE_USER || kmodule) {
1298                         char dso_name[PATH_MAX];
1299
1300                         if (strcmp(section_name,
1301                                    (curr_dso->short_name +
1302                                     dso->short_name_len)) == 0)
1303                                 goto new_symbol;
1304
1305                         if (strcmp(section_name, ".text") == 0) {
1306                                 curr_map = map;
1307                                 curr_dso = dso;
1308                                 goto new_symbol;
1309                         }
1310
1311                         snprintf(dso_name, sizeof(dso_name),
1312                                  "%s%s", dso->short_name, section_name);
1313
1314                         curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1315                         if (curr_map == NULL) {
1316                                 u64 start = sym.st_value;
1317
1318                                 if (kmodule)
1319                                         start += map->start + shdr.sh_offset;
1320
1321                                 curr_dso = dso__new(dso_name);
1322                                 if (curr_dso == NULL)
1323                                         goto out_elf_end;
1324                                 curr_dso->kernel = dso->kernel;
1325                                 curr_dso->long_name = dso->long_name;
1326                                 curr_dso->long_name_len = dso->long_name_len;
1327                                 curr_map = map__new2(start, curr_dso,
1328                                                      map->type);
1329                                 if (curr_map == NULL) {
1330                                         dso__delete(curr_dso);
1331                                         goto out_elf_end;
1332                                 }
1333                                 curr_map->map_ip = identity__map_ip;
1334                                 curr_map->unmap_ip = identity__map_ip;
1335                                 curr_dso->symtab_type = dso->symtab_type;
1336                                 map_groups__insert(kmap->kmaps, curr_map);
1337                                 dsos__add(&dso->node, curr_dso);
1338                                 dso__set_loaded(curr_dso, map->type);
1339                         } else
1340                                 curr_dso = curr_map->dso;
1341
1342                         goto new_symbol;
1343                 }
1344
1345                 if (curr_dso->adjust_symbols) {
1346                         pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
1347                                   "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
1348                                   (u64)sym.st_value, (u64)shdr.sh_addr,
1349                                   (u64)shdr.sh_offset);
1350                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1351                 }
1352                 /*
1353                  * We need to figure out if the object was created from C++ sources
1354                  * DWARF DW_compile_unit has this, but we don't always have access
1355                  * to it...
1356                  */
1357                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1358                 if (demangled != NULL)
1359                         elf_name = demangled;
1360 new_symbol:
1361                 f = symbol__new(sym.st_value, sym.st_size,
1362                                 GELF_ST_BIND(sym.st_info), elf_name);
1363                 free(demangled);
1364                 if (!f)
1365                         goto out_elf_end;
1366
1367                 if (filter && filter(curr_map, f))
1368                         symbol__delete(f);
1369                 else {
1370                         symbols__insert(&curr_dso->symbols[curr_map->type], f);
1371                         nr++;
1372                 }
1373         }
1374
1375         /*
1376          * For misannotated, zeroed, ASM function sizes.
1377          */
1378         if (nr > 0) {
1379                 symbols__fixup_duplicate(&dso->symbols[map->type]);
1380                 symbols__fixup_end(&dso->symbols[map->type]);
1381                 if (kmap) {
1382                         /*
1383                          * We need to fixup this here too because we create new
1384                          * maps here, for things like vsyscall sections.
1385                          */
1386                         __map_groups__fixup_end(kmap->kmaps, map->type);
1387                 }
1388         }
1389         err = nr;
1390 out_elf_end:
1391         elf_end(elf);
1392 out_close:
1393         return err;
1394 }
1395
1396 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
1397 {
1398         return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
1399 }
1400
1401 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1402 {
1403         bool have_build_id = false;
1404         struct dso *pos;
1405
1406         list_for_each_entry(pos, head, node) {
1407                 if (with_hits && !pos->hit)
1408                         continue;
1409                 if (pos->has_build_id) {
1410                         have_build_id = true;
1411                         continue;
1412                 }
1413                 if (filename__read_build_id(pos->long_name, pos->build_id,
1414                                             sizeof(pos->build_id)) > 0) {
1415                         have_build_id     = true;
1416                         pos->has_build_id = true;
1417                 }
1418         }
1419
1420         return have_build_id;
1421 }
1422
1423 /*
1424  * Align offset to 4 bytes as needed for note name and descriptor data.
1425  */
1426 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1427
1428 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1429 {
1430         int err = -1;
1431         GElf_Ehdr ehdr;
1432         GElf_Shdr shdr;
1433         Elf_Data *data;
1434         Elf_Scn *sec;
1435         Elf_Kind ek;
1436         void *ptr;
1437
1438         if (size < BUILD_ID_SIZE)
1439                 goto out;
1440
1441         ek = elf_kind(elf);
1442         if (ek != ELF_K_ELF)
1443                 goto out;
1444
1445         if (gelf_getehdr(elf, &ehdr) == NULL) {
1446                 pr_err("%s: cannot get elf header.\n", __func__);
1447                 goto out;
1448         }
1449
1450         sec = elf_section_by_name(elf, &ehdr, &shdr,
1451                                   ".note.gnu.build-id", NULL);
1452         if (sec == NULL) {
1453                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1454                                           ".notes", NULL);
1455                 if (sec == NULL)
1456                         goto out;
1457         }
1458
1459         data = elf_getdata(sec, NULL);
1460         if (data == NULL)
1461                 goto out;
1462
1463         ptr = data->d_buf;
1464         while (ptr < (data->d_buf + data->d_size)) {
1465                 GElf_Nhdr *nhdr = ptr;
1466                 size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
1467                        descsz = NOTE_ALIGN(nhdr->n_descsz);
1468                 const char *name;
1469
1470                 ptr += sizeof(*nhdr);
1471                 name = ptr;
1472                 ptr += namesz;
1473                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1474                     nhdr->n_namesz == sizeof("GNU")) {
1475                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1476                                 size_t sz = min(size, descsz);
1477                                 memcpy(bf, ptr, sz);
1478                                 memset(bf + sz, 0, size - sz);
1479                                 err = descsz;
1480                                 break;
1481                         }
1482                 }
1483                 ptr += descsz;
1484         }
1485
1486 out:
1487         return err;
1488 }
1489
1490 int filename__read_build_id(const char *filename, void *bf, size_t size)
1491 {
1492         int fd, err = -1;
1493         Elf *elf;
1494
1495         if (size < BUILD_ID_SIZE)
1496                 goto out;
1497
1498         fd = open(filename, O_RDONLY);
1499         if (fd < 0)
1500                 goto out;
1501
1502         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1503         if (elf == NULL) {
1504                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1505                 goto out_close;
1506         }
1507
1508         err = elf_read_build_id(elf, bf, size);
1509
1510         elf_end(elf);
1511 out_close:
1512         close(fd);
1513 out:
1514         return err;
1515 }
1516
1517 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1518 {
1519         int fd, err = -1;
1520
1521         if (size < BUILD_ID_SIZE)
1522                 goto out;
1523
1524         fd = open(filename, O_RDONLY);
1525         if (fd < 0)
1526                 goto out;
1527
1528         while (1) {
1529                 char bf[BUFSIZ];
1530                 GElf_Nhdr nhdr;
1531                 size_t namesz, descsz;
1532
1533                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1534                         break;
1535
1536                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1537                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1538                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1539                     nhdr.n_namesz == sizeof("GNU")) {
1540                         if (read(fd, bf, namesz) != (ssize_t)namesz)
1541                                 break;
1542                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1543                                 size_t sz = min(descsz, size);
1544                                 if (read(fd, build_id, sz) == (ssize_t)sz) {
1545                                         memset(build_id + sz, 0, size - sz);
1546                                         err = 0;
1547                                         break;
1548                                 }
1549                         } else if (read(fd, bf, descsz) != (ssize_t)descsz)
1550                                 break;
1551                 } else {
1552                         int n = namesz + descsz;
1553                         if (read(fd, bf, n) != n)
1554                                 break;
1555                 }
1556         }
1557         close(fd);
1558 out:
1559         return err;
1560 }
1561
1562 char dso__symtab_origin(const struct dso *dso)
1563 {
1564         static const char origin[] = {
1565                 [SYMTAB__KALLSYMS]            = 'k',
1566                 [SYMTAB__JAVA_JIT]            = 'j',
1567                 [SYMTAB__BUILD_ID_CACHE]      = 'B',
1568                 [SYMTAB__FEDORA_DEBUGINFO]    = 'f',
1569                 [SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
1570                 [SYMTAB__BUILDID_DEBUGINFO]   = 'b',
1571                 [SYMTAB__SYSTEM_PATH_DSO]     = 'd',
1572                 [SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
1573                 [SYMTAB__GUEST_KALLSYMS]      =  'g',
1574                 [SYMTAB__GUEST_KMODULE]       =  'G',
1575         };
1576
1577         if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
1578                 return '!';
1579         return origin[dso->symtab_type];
1580 }
1581
1582 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
1583 {
1584         int size = PATH_MAX;
1585         char *name;
1586         int ret = -1;
1587         int fd;
1588         struct machine *machine;
1589         const char *root_dir;
1590         int want_symtab;
1591
1592         dso__set_loaded(dso, map->type);
1593
1594         if (dso->kernel == DSO_TYPE_KERNEL)
1595                 return dso__load_kernel_sym(dso, map, filter);
1596         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
1597                 return dso__load_guest_kernel_sym(dso, map, filter);
1598
1599         if (map->groups && map->groups->machine)
1600                 machine = map->groups->machine;
1601         else
1602                 machine = NULL;
1603
1604         name = malloc(size);
1605         if (!name)
1606                 return -1;
1607
1608         dso->adjust_symbols = 0;
1609
1610         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
1611                 struct stat st;
1612
1613                 if (lstat(dso->name, &st) < 0)
1614                         return -1;
1615
1616                 if (st.st_uid && (st.st_uid != geteuid())) {
1617                         pr_warning("File %s not owned by current user or root, "
1618                                 "ignoring it.\n", dso->name);
1619                         return -1;
1620                 }
1621
1622                 ret = dso__load_perf_map(dso, map, filter);
1623                 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
1624                                               SYMTAB__NOT_FOUND;
1625                 return ret;
1626         }
1627
1628         /* Iterate over candidate debug images.
1629          * On the first pass, only load images if they have a full symtab.
1630          * Failing that, do a second pass where we accept .dynsym also
1631          */
1632         want_symtab = 1;
1633 restart:
1634         for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
1635              dso->symtab_type != SYMTAB__NOT_FOUND;
1636              dso->symtab_type++) {
1637                 switch (dso->symtab_type) {
1638                 case SYMTAB__BUILD_ID_CACHE:
1639                         /* skip the locally configured cache if a symfs is given */
1640                         if (symbol_conf.symfs[0] ||
1641                             (dso__build_id_filename(dso, name, size) == NULL)) {
1642                                 continue;
1643                         }
1644                         break;
1645                 case SYMTAB__FEDORA_DEBUGINFO:
1646                         snprintf(name, size, "%s/usr/lib/debug%s.debug",
1647                                  symbol_conf.symfs, dso->long_name);
1648                         break;
1649                 case SYMTAB__UBUNTU_DEBUGINFO:
1650                         snprintf(name, size, "%s/usr/lib/debug%s",
1651                                  symbol_conf.symfs, dso->long_name);
1652                         break;
1653                 case SYMTAB__BUILDID_DEBUGINFO: {
1654                         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1655
1656                         if (!dso->has_build_id)
1657                                 continue;
1658
1659                         build_id__sprintf(dso->build_id,
1660                                           sizeof(dso->build_id),
1661                                           build_id_hex);
1662                         snprintf(name, size,
1663                                  "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
1664                                  symbol_conf.symfs, build_id_hex, build_id_hex + 2);
1665                         }
1666                         break;
1667                 case SYMTAB__SYSTEM_PATH_DSO:
1668                         snprintf(name, size, "%s%s",
1669                              symbol_conf.symfs, dso->long_name);
1670                         break;
1671                 case SYMTAB__GUEST_KMODULE:
1672                         if (map->groups && machine)
1673                                 root_dir = machine->root_dir;
1674                         else
1675                                 root_dir = "";
1676                         snprintf(name, size, "%s%s%s", symbol_conf.symfs,
1677                                  root_dir, dso->long_name);
1678                         break;
1679
1680                 case SYMTAB__SYSTEM_PATH_KMODULE:
1681                         snprintf(name, size, "%s%s", symbol_conf.symfs,
1682                                  dso->long_name);
1683                         break;
1684                 default:;
1685                 }
1686
1687                 /* Name is now the name of the next image to try */
1688                 fd = open(name, O_RDONLY);
1689                 if (fd < 0)
1690                         continue;
1691
1692                 ret = dso__load_sym(dso, map, name, fd, filter, 0,
1693                                     want_symtab);
1694                 close(fd);
1695
1696                 /*
1697                  * Some people seem to have debuginfo files _WITHOUT_ debug
1698                  * info!?!?
1699                  */
1700                 if (!ret)
1701                         continue;
1702
1703                 if (ret > 0) {
1704                         int nr_plt;
1705
1706                         nr_plt = dso__synthesize_plt_symbols(dso, name, map, filter);
1707                         if (nr_plt > 0)
1708                                 ret += nr_plt;
1709                         break;
1710                 }
1711         }
1712
1713         /*
1714          * If we wanted a full symtab but no image had one,
1715          * relax our requirements and repeat the search.
1716          */
1717         if (ret <= 0 && want_symtab) {
1718                 want_symtab = 0;
1719                 goto restart;
1720         }
1721
1722         free(name);
1723         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
1724                 return 0;
1725         return ret;
1726 }
1727
1728 struct map *map_groups__find_by_name(struct map_groups *mg,
1729                                      enum map_type type, const char *name)
1730 {
1731         struct rb_node *nd;
1732
1733         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
1734                 struct map *map = rb_entry(nd, struct map, rb_node);
1735
1736                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1737                         return map;
1738         }
1739
1740         return NULL;
1741 }
1742
1743 static int dso__kernel_module_get_build_id(struct dso *dso,
1744                                            const char *root_dir)
1745 {
1746         char filename[PATH_MAX];
1747         /*
1748          * kernel module short names are of the form "[module]" and
1749          * we need just "module" here.
1750          */
1751         const char *name = dso->short_name + 1;
1752
1753         snprintf(filename, sizeof(filename),
1754                  "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1755                  root_dir, (int)strlen(name) - 1, name);
1756
1757         if (sysfs__read_build_id(filename, dso->build_id,
1758                                  sizeof(dso->build_id)) == 0)
1759                 dso->has_build_id = true;
1760
1761         return 0;
1762 }
1763
1764 static int map_groups__set_modules_path_dir(struct map_groups *mg,
1765                                 const char *dir_name)
1766 {
1767         struct dirent *dent;
1768         DIR *dir = opendir(dir_name);
1769         int ret = 0;
1770
1771         if (!dir) {
1772                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1773                 return -1;
1774         }
1775
1776         while ((dent = readdir(dir)) != NULL) {
1777                 char path[PATH_MAX];
1778                 struct stat st;
1779
1780                 /*sshfs might return bad dent->d_type, so we have to stat*/
1781                 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
1782                 if (stat(path, &st))
1783                         continue;
1784
1785                 if (S_ISDIR(st.st_mode)) {
1786                         if (!strcmp(dent->d_name, ".") ||
1787                             !strcmp(dent->d_name, ".."))
1788                                 continue;
1789
1790                         ret = map_groups__set_modules_path_dir(mg, path);
1791                         if (ret < 0)
1792                                 goto out;
1793                 } else {
1794                         char *dot = strrchr(dent->d_name, '.'),
1795                              dso_name[PATH_MAX];
1796                         struct map *map;
1797                         char *long_name;
1798
1799                         if (dot == NULL || strcmp(dot, ".ko"))
1800                                 continue;
1801                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1802                                  (int)(dot - dent->d_name), dent->d_name);
1803
1804                         strxfrchar(dso_name, '-', '_');
1805                         map = map_groups__find_by_name(mg, MAP__FUNCTION,
1806                                                        dso_name);
1807                         if (map == NULL)
1808                                 continue;
1809
1810                         long_name = strdup(path);
1811                         if (long_name == NULL) {
1812                                 ret = -1;
1813                                 goto out;
1814                         }
1815                         dso__set_long_name(map->dso, long_name);
1816                         map->dso->lname_alloc = 1;
1817                         dso__kernel_module_get_build_id(map->dso, "");
1818                 }
1819         }
1820
1821 out:
1822         closedir(dir);
1823         return ret;
1824 }
1825
1826 static char *get_kernel_version(const char *root_dir)
1827 {
1828         char version[PATH_MAX];
1829         FILE *file;
1830         char *name, *tmp;
1831         const char *prefix = "Linux version ";
1832
1833         sprintf(version, "%s/proc/version", root_dir);
1834         file = fopen(version, "r");
1835         if (!file)
1836                 return NULL;
1837
1838         version[0] = '\0';
1839         tmp = fgets(version, sizeof(version), file);
1840         fclose(file);
1841
1842         name = strstr(version, prefix);
1843         if (!name)
1844                 return NULL;
1845         name += strlen(prefix);
1846         tmp = strchr(name, ' ');
1847         if (tmp)
1848                 *tmp = '\0';
1849
1850         return strdup(name);
1851 }
1852
1853 static int machine__set_modules_path(struct machine *machine)
1854 {
1855         char *version;
1856         char modules_path[PATH_MAX];
1857
1858         version = get_kernel_version(machine->root_dir);
1859         if (!version)
1860                 return -1;
1861
1862         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1863                  machine->root_dir, version);
1864         free(version);
1865
1866         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
1867 }
1868
1869 /*
1870  * Constructor variant for modules (where we know from /proc/modules where
1871  * they are loaded) and for vmlinux, where only after we load all the
1872  * symbols we'll know where it starts and ends.
1873  */
1874 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1875 {
1876         struct map *map = calloc(1, (sizeof(*map) +
1877                                      (dso->kernel ? sizeof(struct kmap) : 0)));
1878         if (map != NULL) {
1879                 /*
1880                  * ->end will be filled after we load all the symbols
1881                  */
1882                 map__init(map, type, start, 0, 0, dso);
1883         }
1884
1885         return map;
1886 }
1887
1888 struct map *machine__new_module(struct machine *machine, u64 start,
1889                                 const char *filename)
1890 {
1891         struct map *map;
1892         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
1893
1894         if (dso == NULL)
1895                 return NULL;
1896
1897         map = map__new2(start, dso, MAP__FUNCTION);
1898         if (map == NULL)
1899                 return NULL;
1900
1901         if (machine__is_host(machine))
1902                 dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
1903         else
1904                 dso->symtab_type = SYMTAB__GUEST_KMODULE;
1905         map_groups__insert(&machine->kmaps, map);
1906         return map;
1907 }
1908
1909 static int machine__create_modules(struct machine *machine)
1910 {
1911         char *line = NULL;
1912         size_t n;
1913         FILE *file;
1914         struct map *map;
1915         const char *modules;
1916         char path[PATH_MAX];
1917
1918         if (machine__is_default_guest(machine))
1919                 modules = symbol_conf.default_guest_modules;
1920         else {
1921                 sprintf(path, "%s/proc/modules", machine->root_dir);
1922                 modules = path;
1923         }
1924
1925         if (symbol__restricted_filename(path, "/proc/modules"))
1926                 return -1;
1927
1928         file = fopen(modules, "r");
1929         if (file == NULL)
1930                 return -1;
1931
1932         while (!feof(file)) {
1933                 char name[PATH_MAX];
1934                 u64 start;
1935                 char *sep;
1936                 int line_len;
1937
1938                 line_len = getline(&line, &n, file);
1939                 if (line_len < 0)
1940                         break;
1941
1942                 if (!line)
1943                         goto out_failure;
1944
1945                 line[--line_len] = '\0'; /* \n */
1946
1947                 sep = strrchr(line, 'x');
1948                 if (sep == NULL)
1949                         continue;
1950
1951                 hex2u64(sep + 1, &start);
1952
1953                 sep = strchr(line, ' ');
1954                 if (sep == NULL)
1955                         continue;
1956
1957                 *sep = '\0';
1958
1959                 snprintf(name, sizeof(name), "[%s]", line);
1960                 map = machine__new_module(machine, start, name);
1961                 if (map == NULL)
1962                         goto out_delete_line;
1963                 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1964         }
1965
1966         free(line);
1967         fclose(file);
1968
1969         return machine__set_modules_path(machine);
1970
1971 out_delete_line:
1972         free(line);
1973 out_failure:
1974         return -1;
1975 }
1976
1977 int dso__load_vmlinux(struct dso *dso, struct map *map,
1978                       const char *vmlinux, symbol_filter_t filter)
1979 {
1980         int err = -1, fd;
1981         char symfs_vmlinux[PATH_MAX];
1982
1983         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
1984                  symbol_conf.symfs, vmlinux);
1985         fd = open(symfs_vmlinux, O_RDONLY);
1986         if (fd < 0)
1987                 return -1;
1988
1989         dso__set_long_name(dso, (char *)vmlinux);
1990         dso__set_loaded(dso, map->type);
1991         err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
1992         close(fd);
1993
1994         if (err > 0)
1995                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
1996
1997         return err;
1998 }
1999
2000 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
2001                            symbol_filter_t filter)
2002 {
2003         int i, err = 0;
2004         char *filename;
2005
2006         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
2007                  vmlinux_path__nr_entries + 1);
2008
2009         filename = dso__build_id_filename(dso, NULL, 0);
2010         if (filename != NULL) {
2011                 err = dso__load_vmlinux(dso, map, filename, filter);
2012                 if (err > 0) {
2013                         dso__set_long_name(dso, filename);
2014                         goto out;
2015                 }
2016                 free(filename);
2017         }
2018
2019         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
2020                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
2021                 if (err > 0) {
2022                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
2023                         break;
2024                 }
2025         }
2026 out:
2027         return err;
2028 }
2029
2030 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
2031                                 symbol_filter_t filter)
2032 {
2033         int err;
2034         const char *kallsyms_filename = NULL;
2035         char *kallsyms_allocated_filename = NULL;
2036         /*
2037          * Step 1: if the user specified a kallsyms or vmlinux filename, use
2038          * it and only it, reporting errors to the user if it cannot be used.
2039          *
2040          * For instance, try to analyse an ARM perf.data file _without_ a
2041          * build-id, or if the user specifies the wrong path to the right
2042          * vmlinux file, obviously we can't fallback to another vmlinux (a
2043          * x86_86 one, on the machine where analysis is being performed, say),
2044          * or worse, /proc/kallsyms.
2045          *
2046          * If the specified file _has_ a build-id and there is a build-id
2047          * section in the perf.data file, we will still do the expected
2048          * validation in dso__load_vmlinux and will bail out if they don't
2049          * match.
2050          */
2051         if (symbol_conf.kallsyms_name != NULL) {
2052                 kallsyms_filename = symbol_conf.kallsyms_name;
2053                 goto do_kallsyms;
2054         }
2055
2056         if (symbol_conf.vmlinux_name != NULL) {
2057                 err = dso__load_vmlinux(dso, map,
2058                                         symbol_conf.vmlinux_name, filter);
2059                 if (err > 0) {
2060                         dso__set_long_name(dso,
2061                                            strdup(symbol_conf.vmlinux_name));
2062                         goto out_fixup;
2063                 }
2064                 return err;
2065         }
2066
2067         if (vmlinux_path != NULL) {
2068                 err = dso__load_vmlinux_path(dso, map, filter);
2069                 if (err > 0)
2070                         goto out_fixup;
2071         }
2072
2073         /* do not try local files if a symfs was given */
2074         if (symbol_conf.symfs[0] != 0)
2075                 return -1;
2076
2077         /*
2078          * Say the kernel DSO was created when processing the build-id header table,
2079          * we have a build-id, so check if it is the same as the running kernel,
2080          * using it if it is.
2081          */
2082         if (dso->has_build_id) {
2083                 u8 kallsyms_build_id[BUILD_ID_SIZE];
2084                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
2085
2086                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
2087                                          sizeof(kallsyms_build_id)) == 0) {
2088                         if (dso__build_id_equal(dso, kallsyms_build_id)) {
2089                                 kallsyms_filename = "/proc/kallsyms";
2090                                 goto do_kallsyms;
2091                         }
2092                 }
2093                 /*
2094                  * Now look if we have it on the build-id cache in
2095                  * $HOME/.debug/[kernel.kallsyms].
2096                  */
2097                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
2098                                   sbuild_id);
2099
2100                 if (asprintf(&kallsyms_allocated_filename,
2101                              "%s/.debug/[kernel.kallsyms]/%s",
2102                              getenv("HOME"), sbuild_id) == -1) {
2103                         pr_err("Not enough memory for kallsyms file lookup\n");
2104                         return -1;
2105                 }
2106
2107                 kallsyms_filename = kallsyms_allocated_filename;
2108
2109                 if (access(kallsyms_filename, F_OK)) {
2110                         pr_err("No kallsyms or vmlinux with build-id %s "
2111                                "was found\n", sbuild_id);
2112                         free(kallsyms_allocated_filename);
2113                         return -1;
2114                 }
2115         } else {
2116                 /*
2117                  * Last resort, if we don't have a build-id and couldn't find
2118                  * any vmlinux file, try the running kernel kallsyms table.
2119                  */
2120                 kallsyms_filename = "/proc/kallsyms";
2121         }
2122
2123 do_kallsyms:
2124         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2125         if (err > 0)
2126                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2127         free(kallsyms_allocated_filename);
2128
2129         if (err > 0) {
2130 out_fixup:
2131                 if (kallsyms_filename != NULL)
2132                         dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
2133                 map__fixup_start(map);
2134                 map__fixup_end(map);
2135         }
2136
2137         return err;
2138 }
2139
2140 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
2141                                       symbol_filter_t filter)
2142 {
2143         int err;
2144         const char *kallsyms_filename = NULL;
2145         struct machine *machine;
2146         char path[PATH_MAX];
2147
2148         if (!map->groups) {
2149                 pr_debug("Guest kernel map hasn't the point to groups\n");
2150                 return -1;
2151         }
2152         machine = map->groups->machine;
2153
2154         if (machine__is_default_guest(machine)) {
2155                 /*
2156                  * if the user specified a vmlinux filename, use it and only
2157                  * it, reporting errors to the user if it cannot be used.
2158                  * Or use file guest_kallsyms inputted by user on commandline
2159                  */
2160                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
2161                         err = dso__load_vmlinux(dso, map,
2162                                 symbol_conf.default_guest_vmlinux_name, filter);
2163                         goto out_try_fixup;
2164                 }
2165
2166                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
2167                 if (!kallsyms_filename)
2168                         return -1;
2169         } else {
2170                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2171                 kallsyms_filename = path;
2172         }
2173
2174         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
2175         if (err > 0)
2176                 pr_debug("Using %s for symbols\n", kallsyms_filename);
2177
2178 out_try_fixup:
2179         if (err > 0) {
2180                 if (kallsyms_filename != NULL) {
2181                         machine__mmap_name(machine, path, sizeof(path));
2182                         dso__set_long_name(dso, strdup(path));
2183                 }
2184                 map__fixup_start(map);
2185                 map__fixup_end(map);
2186         }
2187
2188         return err;
2189 }
2190
2191 static void dsos__add(struct list_head *head, struct dso *dso)
2192 {
2193         list_add_tail(&dso->node, head);
2194 }
2195
2196 static struct dso *dsos__find(struct list_head *head, const char *name)
2197 {
2198         struct dso *pos;
2199
2200         list_for_each_entry(pos, head, node)
2201                 if (strcmp(pos->long_name, name) == 0)
2202                         return pos;
2203         return NULL;
2204 }
2205
2206 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2207 {
2208         struct dso *dso = dsos__find(head, name);
2209
2210         if (!dso) {
2211                 dso = dso__new(name);
2212                 if (dso != NULL) {
2213                         dsos__add(head, dso);
2214                         dso__set_basename(dso);
2215                 }
2216         }
2217
2218         return dso;
2219 }
2220
2221 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2222 {
2223         struct dso *pos;
2224         size_t ret = 0;
2225
2226         list_for_each_entry(pos, head, node) {
2227                 int i;
2228                 for (i = 0; i < MAP__NR_TYPES; ++i)
2229                         ret += dso__fprintf(pos, i, fp);
2230         }
2231
2232         return ret;
2233 }
2234
2235 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
2236 {
2237         struct rb_node *nd;
2238         size_t ret = 0;
2239
2240         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2241                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2242                 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2243                 ret += __dsos__fprintf(&pos->user_dsos, fp);
2244         }
2245
2246         return ret;
2247 }
2248
2249 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2250                                       bool with_hits)
2251 {
2252         struct dso *pos;
2253         size_t ret = 0;
2254
2255         list_for_each_entry(pos, head, node) {
2256                 if (with_hits && !pos->hit)
2257                         continue;
2258                 ret += dso__fprintf_buildid(pos, fp);
2259                 ret += fprintf(fp, " %s\n", pos->long_name);
2260         }
2261         return ret;
2262 }
2263
2264 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
2265                                      bool with_hits)
2266 {
2267         return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
2268                __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
2269 }
2270
2271 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
2272                                       FILE *fp, bool with_hits)
2273 {
2274         struct rb_node *nd;
2275         size_t ret = 0;
2276
2277         for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
2278                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2279                 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2280         }
2281         return ret;
2282 }
2283
2284 static struct dso*
2285 dso__kernel_findnew(struct machine *machine, const char *name,
2286                     const char *short_name, int dso_type)
2287 {
2288         /*
2289          * The kernel dso could be created by build_id processing.
2290          */
2291         struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
2292
2293         /*
2294          * We need to run this in all cases, since during the build_id
2295          * processing we had no idea this was the kernel dso.
2296          */
2297         if (dso != NULL) {
2298                 dso__set_short_name(dso, short_name);
2299                 dso->kernel = dso_type;
2300         }
2301
2302         return dso;
2303 }
2304
2305 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
2306 {
2307         char path[PATH_MAX];
2308
2309         if (machine__is_default_guest(machine))
2310                 return;
2311         sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2312         if (sysfs__read_build_id(path, dso->build_id,
2313                                  sizeof(dso->build_id)) == 0)
2314                 dso->has_build_id = true;
2315 }
2316
2317 static struct dso *machine__get_kernel(struct machine *machine)
2318 {
2319         const char *vmlinux_name = NULL;
2320         struct dso *kernel;
2321
2322         if (machine__is_host(machine)) {
2323                 vmlinux_name = symbol_conf.vmlinux_name;
2324                 if (!vmlinux_name)
2325                         vmlinux_name = "[kernel.kallsyms]";
2326
2327                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2328                                              "[kernel]",
2329                                              DSO_TYPE_KERNEL);
2330         } else {
2331                 char bf[PATH_MAX];
2332
2333                 if (machine__is_default_guest(machine))
2334                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2335                 if (!vmlinux_name)
2336                         vmlinux_name = machine__mmap_name(machine, bf,
2337                                                           sizeof(bf));
2338
2339                 kernel = dso__kernel_findnew(machine, vmlinux_name,
2340                                              "[guest.kernel]",
2341                                              DSO_TYPE_GUEST_KERNEL);
2342         }
2343
2344         if (kernel != NULL && (!kernel->has_build_id))
2345                 dso__read_running_kernel_build_id(kernel, machine);
2346
2347         return kernel;
2348 }
2349
2350 struct process_args {
2351         u64 start;
2352 };
2353
2354 static int symbol__in_kernel(void *arg, const char *name,
2355                              char type __used, u64 start, u64 end __used)
2356 {
2357         struct process_args *args = arg;
2358
2359         if (strchr(name, '['))
2360                 return 0;
2361
2362         args->start = start;
2363         return 1;
2364 }
2365
2366 /* Figure out the start address of kernel map from /proc/kallsyms */
2367 static u64 machine__get_kernel_start_addr(struct machine *machine)
2368 {
2369         const char *filename;
2370         char path[PATH_MAX];
2371         struct process_args args;
2372
2373         if (machine__is_host(machine)) {
2374                 filename = "/proc/kallsyms";
2375         } else {
2376                 if (machine__is_default_guest(machine))
2377                         filename = (char *)symbol_conf.default_guest_kallsyms;
2378                 else {
2379                         sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2380                         filename = path;
2381                 }
2382         }
2383
2384         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
2385                 return 0;
2386
2387         if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2388                 return 0;
2389
2390         return args.start;
2391 }
2392
2393 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
2394 {
2395         enum map_type type;
2396         u64 start = machine__get_kernel_start_addr(machine);
2397
2398         for (type = 0; type < MAP__NR_TYPES; ++type) {
2399                 struct kmap *kmap;
2400
2401                 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
2402                 if (machine->vmlinux_maps[type] == NULL)
2403                         return -1;
2404
2405                 machine->vmlinux_maps[type]->map_ip =
2406                         machine->vmlinux_maps[type]->unmap_ip =
2407                                 identity__map_ip;
2408                 kmap = map__kmap(machine->vmlinux_maps[type]);
2409                 kmap->kmaps = &machine->kmaps;
2410                 map_groups__insert(&machine->kmaps,
2411                                    machine->vmlinux_maps[type]);
2412         }
2413
2414         return 0;
2415 }
2416
2417 void machine__destroy_kernel_maps(struct machine *machine)
2418 {
2419         enum map_type type;
2420
2421         for (type = 0; type < MAP__NR_TYPES; ++type) {
2422                 struct kmap *kmap;
2423
2424                 if (machine->vmlinux_maps[type] == NULL)
2425                         continue;
2426
2427                 kmap = map__kmap(machine->vmlinux_maps[type]);
2428                 map_groups__remove(&machine->kmaps,
2429                                    machine->vmlinux_maps[type]);
2430                 if (kmap->ref_reloc_sym) {
2431                         /*
2432                          * ref_reloc_sym is shared among all maps, so free just
2433                          * on one of them.
2434                          */
2435                         if (type == MAP__FUNCTION) {
2436                                 free((char *)kmap->ref_reloc_sym->name);
2437                                 kmap->ref_reloc_sym->name = NULL;
2438                                 free(kmap->ref_reloc_sym);
2439                         }
2440                         kmap->ref_reloc_sym = NULL;
2441                 }
2442
2443                 map__delete(machine->vmlinux_maps[type]);
2444                 machine->vmlinux_maps[type] = NULL;
2445         }
2446 }
2447
2448 int machine__create_kernel_maps(struct machine *machine)
2449 {
2450         struct dso *kernel = machine__get_kernel(machine);
2451
2452         if (kernel == NULL ||
2453             __machine__create_kernel_maps(machine, kernel) < 0)
2454                 return -1;
2455
2456         if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
2457                 pr_debug("Problems creating module maps, continuing anyway...\n");
2458         /*
2459          * Now that we have all the maps created, just set the ->end of them:
2460          */
2461         map_groups__fixup_end(&machine->kmaps);
2462         return 0;
2463 }
2464
2465 static void vmlinux_path__exit(void)
2466 {
2467         while (--vmlinux_path__nr_entries >= 0) {
2468                 free(vmlinux_path[vmlinux_path__nr_entries]);
2469                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2470         }
2471
2472         free(vmlinux_path);
2473         vmlinux_path = NULL;
2474 }
2475
2476 static int vmlinux_path__init(void)
2477 {
2478         struct utsname uts;
2479         char bf[PATH_MAX];
2480
2481         vmlinux_path = malloc(sizeof(char *) * 5);
2482         if (vmlinux_path == NULL)
2483                 return -1;
2484
2485         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2486         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2487                 goto out_fail;
2488         ++vmlinux_path__nr_entries;
2489         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2490         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2491                 goto out_fail;
2492         ++vmlinux_path__nr_entries;
2493
2494         /* only try running kernel version if no symfs was given */
2495         if (symbol_conf.symfs[0] != 0)
2496                 return 0;
2497
2498         if (uname(&uts) < 0)
2499                 return -1;
2500
2501         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2502         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2503         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2504                 goto out_fail;
2505         ++vmlinux_path__nr_entries;
2506         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2507         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2508         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2509                 goto out_fail;
2510         ++vmlinux_path__nr_entries;
2511         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2512                  uts.release);
2513         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2514         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2515                 goto out_fail;
2516         ++vmlinux_path__nr_entries;
2517
2518         return 0;
2519
2520 out_fail:
2521         vmlinux_path__exit();
2522         return -1;
2523 }
2524
2525 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
2526 {
2527         int i;
2528         size_t printed = 0;
2529         struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
2530
2531         if (kdso->has_build_id) {
2532                 char filename[PATH_MAX];
2533                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2534                         printed += fprintf(fp, "[0] %s\n", filename);
2535         }
2536
2537         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2538                 printed += fprintf(fp, "[%d] %s\n",
2539                                    i + kdso->has_build_id, vmlinux_path[i]);
2540
2541         return printed;
2542 }
2543
2544 static int setup_list(struct strlist **list, const char *list_str,
2545                       const char *list_name)
2546 {
2547         if (list_str == NULL)
2548                 return 0;
2549
2550         *list = strlist__new(true, list_str);
2551         if (!*list) {
2552                 pr_err("problems parsing %s list\n", list_name);
2553                 return -1;
2554         }
2555         return 0;
2556 }
2557
2558 static bool symbol__read_kptr_restrict(void)
2559 {
2560         bool value = false;
2561
2562         if (geteuid() != 0) {
2563                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
2564                 if (fp != NULL) {
2565                         char line[8];
2566
2567                         if (fgets(line, sizeof(line), fp) != NULL)
2568                                 value = atoi(line) != 0;
2569
2570                         fclose(fp);
2571                 }
2572         }
2573
2574         return value;
2575 }
2576
2577 int symbol__init(void)
2578 {
2579         const char *symfs;
2580
2581         if (symbol_conf.initialized)
2582                 return 0;
2583
2584         symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
2585
2586         elf_version(EV_CURRENT);
2587         if (symbol_conf.sort_by_name)
2588                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2589                                           sizeof(struct symbol));
2590
2591         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2592                 return -1;
2593
2594         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2595                 pr_err("'.' is the only non valid --field-separator argument\n");
2596                 return -1;
2597         }
2598
2599         if (setup_list(&symbol_conf.dso_list,
2600                        symbol_conf.dso_list_str, "dso") < 0)
2601                 return -1;
2602
2603         if (setup_list(&symbol_conf.comm_list,
2604                        symbol_conf.comm_list_str, "comm") < 0)
2605                 goto out_free_dso_list;
2606
2607         if (setup_list(&symbol_conf.sym_list,
2608                        symbol_conf.sym_list_str, "symbol") < 0)
2609                 goto out_free_comm_list;
2610
2611         /*
2612          * A path to symbols of "/" is identical to ""
2613          * reset here for simplicity.
2614          */
2615         symfs = realpath(symbol_conf.symfs, NULL);
2616         if (symfs == NULL)
2617                 symfs = symbol_conf.symfs;
2618         if (strcmp(symfs, "/") == 0)
2619                 symbol_conf.symfs = "";
2620         if (symfs != symbol_conf.symfs)
2621                 free((void *)symfs);
2622
2623         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
2624
2625         symbol_conf.initialized = true;
2626         return 0;
2627
2628 out_free_comm_list:
2629         strlist__delete(symbol_conf.comm_list);
2630 out_free_dso_list:
2631         strlist__delete(symbol_conf.dso_list);
2632         return -1;
2633 }
2634
2635 void symbol__exit(void)
2636 {
2637         if (!symbol_conf.initialized)
2638                 return;
2639         strlist__delete(symbol_conf.sym_list);
2640         strlist__delete(symbol_conf.dso_list);
2641         strlist__delete(symbol_conf.comm_list);
2642         vmlinux_path__exit();
2643         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2644         symbol_conf.initialized = false;
2645 }
2646
2647 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
2648 {
2649         struct machine *machine = machines__findnew(machines, pid);
2650
2651         if (machine == NULL)
2652                 return -1;
2653
2654         return machine__create_kernel_maps(machine);
2655 }
2656
2657 static int hex(char ch)
2658 {
2659         if ((ch >= '0') && (ch <= '9'))
2660                 return ch - '0';
2661         if ((ch >= 'a') && (ch <= 'f'))
2662                 return ch - 'a' + 10;
2663         if ((ch >= 'A') && (ch <= 'F'))
2664                 return ch - 'A' + 10;
2665         return -1;
2666 }
2667
2668 /*
2669  * While we find nice hex chars, build a long_val.
2670  * Return number of chars processed.
2671  */
2672 int hex2u64(const char *ptr, u64 *long_val)
2673 {
2674         const char *p = ptr;
2675         *long_val = 0;
2676
2677         while (*p) {
2678                 const int hex_val = hex(*p);
2679
2680                 if (hex_val < 0)
2681                         break;
2682
2683                 *long_val = (*long_val << 4) | hex_val;
2684                 p++;
2685         }
2686
2687         return p - ptr;
2688 }
2689
2690 char *strxfrchar(char *s, char from, char to)
2691 {
2692         char *p = s;
2693
2694         while ((p = strchr(p, from)) != NULL)
2695                 *p++ = to;
2696
2697         return s;
2698 }
2699
2700 int machines__create_guest_kernel_maps(struct rb_root *machines)
2701 {
2702         int ret = 0;
2703         struct dirent **namelist = NULL;
2704         int i, items = 0;
2705         char path[PATH_MAX];
2706         pid_t pid;
2707
2708         if (symbol_conf.default_guest_vmlinux_name ||
2709             symbol_conf.default_guest_modules ||
2710             symbol_conf.default_guest_kallsyms) {
2711                 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
2712         }
2713
2714         if (symbol_conf.guestmount) {
2715                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2716                 if (items <= 0)
2717                         return -ENOENT;
2718                 for (i = 0; i < items; i++) {
2719                         if (!isdigit(namelist[i]->d_name[0])) {
2720                                 /* Filter out . and .. */
2721                                 continue;
2722                         }
2723                         pid = atoi(namelist[i]->d_name);
2724                         sprintf(path, "%s/%s/proc/kallsyms",
2725                                 symbol_conf.guestmount,
2726                                 namelist[i]->d_name);
2727                         ret = access(path, R_OK);
2728                         if (ret) {
2729                                 pr_debug("Can't access file %s\n", path);
2730                                 goto failure;
2731                         }
2732                         machines__create_kernel_maps(machines, pid);
2733                 }
2734 failure:
2735                 free(namelist);
2736         }
2737
2738         return ret;
2739 }
2740
2741 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
2742 {
2743         struct rb_node *next = rb_first(machines);
2744
2745         while (next) {
2746                 struct machine *pos = rb_entry(next, struct machine, rb_node);
2747
2748                 next = rb_next(&pos->rb_node);
2749                 rb_erase(&pos->rb_node, machines);
2750                 machine__delete(pos);
2751         }
2752 }
2753
2754 int machine__load_kallsyms(struct machine *machine, const char *filename,
2755                            enum map_type type, symbol_filter_t filter)
2756 {
2757         struct map *map = machine->vmlinux_maps[type];
2758         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2759
2760         if (ret > 0) {
2761                 dso__set_loaded(map->dso, type);
2762                 /*
2763                  * Since /proc/kallsyms will have multiple sessions for the
2764                  * kernel, with modules between them, fixup the end of all
2765                  * sections.
2766                  */
2767                 __map_groups__fixup_end(&machine->kmaps, type);
2768         }
2769
2770         return ret;
2771 }
2772
2773 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
2774                                symbol_filter_t filter)
2775 {
2776         struct map *map = machine->vmlinux_maps[type];
2777         int ret = dso__load_vmlinux_path(map->dso, map, filter);
2778
2779         if (ret > 0) {
2780                 dso__set_loaded(map->dso, type);
2781                 map__reloc_vmlinux(map);
2782         }
2783
2784         return ret;
2785 }