SAFE public projects git trees. - safe/jmp/linux-2.6/blob - tools/perf/util/symbol.c

   1 #include "util.h"
   2 #include "../perf.h"
   3 #include "sort.h"
   4 #include "string.h"
   5 #include "symbol.h"
   6 #include "thread.h"
   7
   8 #include "debug.h"
   9
  10 #include <asm/bug.h>
  11 #include <libelf.h>
  12 #include <gelf.h>
  13 #include <elf.h>
  14 #include <limits.h>
  15 #include <sys/utsname.h>
  16
  17 #ifndef NT_GNU_BUILD_ID
  18 #define NT_GNU_BUILD_ID 3
  19 #endif
  20
  21 enum dso_origin {
  22         DSO__ORIG_KERNEL = 0,
  23         DSO__ORIG_JAVA_JIT,
  24         DSO__ORIG_BUILD_ID_CACHE,
  25         DSO__ORIG_FEDORA,
  26         DSO__ORIG_UBUNTU,
  27         DSO__ORIG_BUILDID,
  28         DSO__ORIG_DSO,
  29         DSO__ORIG_KMODULE,
  30         DSO__ORIG_NOT_FOUND,
  31 };
  32
  33 static void dsos__add(struct list_head *head, struct dso *dso);
  34 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
  35 static int dso__load_kernel_sym(struct dso *self, struct map *map,
  36                                 symbol_filter_t filter);
  37 static int vmlinux_path__nr_entries;
  38 static char **vmlinux_path;
  39
  40 struct symbol_conf symbol_conf = {
  41         .exclude_other    = true,
  42         .use_modules      = true,
  43         .try_vmlinux_path = true,
  44 };
  45
  46 bool dso__loaded(const struct dso *self, enum map_type type)
  47 {
  48         return self->loaded & (1 << type);
  49 }
  50
  51 bool dso__sorted_by_name(const struct dso *self, enum map_type type)
  52 {
  53         return self->sorted_by_name & (1 << type);
  54 }
  55
  56 static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
  57 {
  58         self->sorted_by_name |= (1 << type);
  59 }
  60
  61 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
  62 {
  63         switch (map_type) {
  64         case MAP__FUNCTION:
  65                 return symbol_type == 'T' || symbol_type == 'W';
  66         case MAP__VARIABLE:
  67                 return symbol_type == 'D' || symbol_type == 'd';
  68         default:
  69                 return false;
  70         }
  71 }
  72
  73 static void symbols__fixup_end(struct rb_root *self)
  74 {
  75         struct rb_node *nd, *prevnd = rb_first(self);
  76         struct symbol *curr, *prev;
  77
  78         if (prevnd == NULL)
  79                 return;
  80
  81         curr = rb_entry(prevnd, struct symbol, rb_node);
  82
  83         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
  84                 prev = curr;
  85                 curr = rb_entry(nd, struct symbol, rb_node);
  86
  87                 if (prev->end == prev->start)
  88                         prev->end = curr->start - 1;
  89         }
  90
  91         /* Last entry */
  92         if (curr->end == curr->start)
  93                 curr->end = roundup(curr->start, 4096);
  94 }
  95
  96 static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
  97 {
  98         struct map *prev, *curr;
  99         struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
 100
 101         if (prevnd == NULL)
 102                 return;
 103
 104         curr = rb_entry(prevnd, struct map, rb_node);
 105
 106         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 107                 prev = curr;
 108                 curr = rb_entry(nd, struct map, rb_node);
 109                 prev->end = curr->start - 1;
 110         }
 111
 112         /*
 113          * We still haven't the actual symbols, so guess the
 114          * last map final address.
 115          */
 116         curr->end = ~0UL;
 117 }
 118
 119 static void map_groups__fixup_end(struct map_groups *self)
 120 {
 121         int i;
 122         for (i = 0; i < MAP__NR_TYPES; ++i)
 123                 __map_groups__fixup_end(self, i);
 124 }
 125
 126 static struct symbol *symbol__new(u64 start, u64 len, const char *name)
 127 {
 128         size_t namelen = strlen(name) + 1;
 129         struct symbol *self = zalloc(symbol_conf.priv_size +
 130                                      sizeof(*self) + namelen);
 131         if (self == NULL)
 132                 return NULL;
 133
 134         if (symbol_conf.priv_size)
 135                 self = ((void *)self) + symbol_conf.priv_size;
 136
 137         self->start = start;
 138         self->end   = len ? start + len - 1 : start;
 139
 140         pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
 141
 142         memcpy(self->name, name, namelen);
 143
 144         return self;
 145 }
 146
 147 void symbol__delete(struct symbol *self)
 148 {
 149         free(((void *)self) - symbol_conf.priv_size);
 150 }
 151
 152 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 153 {
 154         return fprintf(fp, " %llx-%llx %s\n",
 155                        self->start, self->end, self->name);
 156 }
 157
 158 void dso__set_long_name(struct dso *self, char *name)
 159 {
 160         if (name == NULL)
 161                 return;
 162         self->long_name = name;
 163         self->long_name_len = strlen(name);
 164 }
 165
 166 static void dso__set_short_name(struct dso *self, const char *name)
 167 {
 168         if (name == NULL)
 169                 return;
 170         self->short_name = name;
 171         self->short_name_len = strlen(name);
 172 }
 173
 174 static void dso__set_basename(struct dso *self)
 175 {
 176         dso__set_short_name(self, basename(self->long_name));
 177 }
 178
 179 struct dso *dso__new(const char *name)
 180 {
 181         struct dso *self = zalloc(sizeof(*self) + strlen(name) + 1);
 182
 183         if (self != NULL) {
 184                 int i;
 185                 strcpy(self->name, name);
 186                 dso__set_long_name(self, self->name);
 187                 dso__set_short_name(self, self->name);
 188                 for (i = 0; i < MAP__NR_TYPES; ++i)
 189                         self->symbols[i] = self->symbol_names[i] = RB_ROOT;
 190                 self->slen_calculated = 0;
 191                 self->origin = DSO__ORIG_NOT_FOUND;
 192                 self->loaded = 0;
 193                 self->sorted_by_name = 0;
 194                 self->has_build_id = 0;
 195         }
 196
 197         return self;
 198 }
 199
 200 static void symbols__delete(struct rb_root *self)
 201 {
 202         struct symbol *pos;
 203         struct rb_node *next = rb_first(self);
 204
 205         while (next) {
 206                 pos = rb_entry(next, struct symbol, rb_node);
 207                 next = rb_next(&pos->rb_node);
 208                 rb_erase(&pos->rb_node, self);
 209                 symbol__delete(pos);
 210         }
 211 }
 212
 213 void dso__delete(struct dso *self)
 214 {
 215         int i;
 216         for (i = 0; i < MAP__NR_TYPES; ++i)
 217                 symbols__delete(&self->symbols[i]);
 218         if (self->long_name != self->name)
 219                 free(self->long_name);
 220         free(self);
 221 }
 222
 223 void dso__set_build_id(struct dso *self, void *build_id)
 224 {
 225         memcpy(self->build_id, build_id, sizeof(self->build_id));
 226         self->has_build_id = 1;
 227 }
 228
 229 static void symbols__insert(struct rb_root *self, struct symbol *sym)
 230 {
 231         struct rb_node **p = &self->rb_node;
 232         struct rb_node *parent = NULL;
 233         const u64 ip = sym->start;
 234         struct symbol *s;
 235
 236         while (*p != NULL) {
 237                 parent = *p;
 238                 s = rb_entry(parent, struct symbol, rb_node);
 239                 if (ip < s->start)
 240                         p = &(*p)->rb_left;
 241                 else
 242                         p = &(*p)->rb_right;
 243         }
 244         rb_link_node(&sym->rb_node, parent, p);
 245         rb_insert_color(&sym->rb_node, self);
 246 }
 247
 248 static struct symbol *symbols__find(struct rb_root *self, u64 ip)
 249 {
 250         struct rb_node *n;
 251
 252         if (self == NULL)
 253                 return NULL;
 254
 255         n = self->rb_node;
 256
 257         while (n) {
 258                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 259
 260                 if (ip < s->start)
 261                         n = n->rb_left;
 262                 else if (ip > s->end)
 263                         n = n->rb_right;
 264                 else
 265                         return s;
 266         }
 267
 268         return NULL;
 269 }
 270
 271 struct symbol_name_rb_node {
 272         struct rb_node  rb_node;
 273         struct symbol   sym;
 274 };
 275
 276 static void symbols__insert_by_name(struct rb_root *self, struct symbol *sym)
 277 {
 278         struct rb_node **p = &self->rb_node;
 279         struct rb_node *parent = NULL;
 280         struct symbol_name_rb_node *symn = ((void *)sym) - sizeof(*parent), *s;
 281
 282         while (*p != NULL) {
 283                 parent = *p;
 284                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 285                 if (strcmp(sym->name, s->sym.name) < 0)
 286                         p = &(*p)->rb_left;
 287                 else
 288                         p = &(*p)->rb_right;
 289         }
 290         rb_link_node(&symn->rb_node, parent, p);
 291         rb_insert_color(&symn->rb_node, self);
 292 }
 293
 294 static void symbols__sort_by_name(struct rb_root *self, struct rb_root *source)
 295 {
 296         struct rb_node *nd;
 297
 298         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 299                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 300                 symbols__insert_by_name(self, pos);
 301         }
 302 }
 303
 304 static struct symbol *symbols__find_by_name(struct rb_root *self, const char *name)
 305 {
 306         struct rb_node *n;
 307
 308         if (self == NULL)
 309                 return NULL;
 310
 311         n = self->rb_node;
 312
 313         while (n) {
 314                 struct symbol_name_rb_node *s;
 315                 int cmp;
 316
 317                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 318                 cmp = strcmp(name, s->sym.name);
 319
 320                 if (cmp < 0)
 321                         n = n->rb_left;
 322                 else if (cmp > 0)
 323                         n = n->rb_right;
 324                 else
 325                         return &s->sym;
 326         }
 327
 328         return NULL;
 329 }
 330
 331 struct symbol *dso__find_symbol(struct dso *self,
 332                                 enum map_type type, u64 addr)
 333 {
 334         return symbols__find(&self->symbols[type], addr);
 335 }
 336
 337 struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
 338                                         const char *name)
 339 {
 340         return symbols__find_by_name(&self->symbol_names[type], name);
 341 }
 342
 343 void dso__sort_by_name(struct dso *self, enum map_type type)
 344 {
 345         dso__set_sorted_by_name(self, type);
 346         return symbols__sort_by_name(&self->symbol_names[type],
 347                                      &self->symbols[type]);
 348 }
 349
 350 int build_id__sprintf(const u8 *self, int len, char *bf)
 351 {
 352         char *bid = bf;
 353         const u8 *raw = self;
 354         int i;
 355
 356         for (i = 0; i < len; ++i) {
 357                 sprintf(bid, "%02x", *raw);
 358                 ++raw;
 359                 bid += 2;
 360         }
 361
 362         return raw - self;
 363 }
 364
 365 size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
 366 {
 367         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 368
 369         build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
 370         return fprintf(fp, "%s", sbuild_id);
 371 }
 372
 373 size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
 374 {
 375         struct rb_node *nd;
 376         size_t ret = fprintf(fp, "dso: %s (", self->short_name);
 377
 378         if (self->short_name != self->long_name)
 379                 ret += fprintf(fp, "%s, ", self->long_name);
 380         ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
 381                        self->loaded ? "" : "NOT ");
 382         ret += dso__fprintf_buildid(self, fp);
 383         ret += fprintf(fp, ")\n");
 384         for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
 385                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 386                 ret += symbol__fprintf(pos, fp);
 387         }
 388
 389         return ret;
 390 }
 391
 392 int kallsyms__parse(const char *filename, void *arg,
 393                     int (*process_symbol)(void *arg, const char *name,
 394                                                      char type, u64 start))
 395 {
 396         char *line = NULL;
 397         size_t n;
 398         int err = 0;
 399         FILE *file = fopen(filename, "r");
 400
 401         if (file == NULL)
 402                 goto out_failure;
 403
 404         while (!feof(file)) {
 405                 u64 start;
 406                 int line_len, len;
 407                 char symbol_type;
 408                 char *symbol_name;
 409
 410                 line_len = getline(&line, &n, file);
 411                 if (line_len < 0)
 412                         break;
 413
 414                 if (!line)
 415                         goto out_failure;
 416
 417                 line[--line_len] = '\0'; /* \n */
 418
 419                 len = hex2u64(line, &start);
 420
 421                 len++;
 422                 if (len + 2 >= line_len)
 423                         continue;
 424
 425                 symbol_type = toupper(line[len]);
 426                 symbol_name = line + len + 2;
 427
 428                 err = process_symbol(arg, symbol_name, symbol_type, start);
 429                 if (err)
 430                         break;
 431         }
 432
 433         free(line);
 434         fclose(file);
 435         return err;
 436
 437 out_failure:
 438         return -1;
 439 }
 440
 441 struct process_kallsyms_args {
 442         struct map *map;
 443         struct dso *dso;
 444 };
 445
 446 static int map__process_kallsym_symbol(void *arg, const char *name,
 447                                        char type, u64 start)
 448 {
 449         struct symbol *sym;
 450         struct process_kallsyms_args *a = arg;
 451         struct rb_root *root = &a->dso->symbols[a->map->type];
 452
 453         if (!symbol_type__is_a(type, a->map->type))
 454                 return 0;
 455
 456         /*
 457          * Will fix up the end later, when we have all symbols sorted.
 458          */
 459         sym = symbol__new(start, 0, name);
 460
 461         if (sym == NULL)
 462                 return -ENOMEM;
 463         /*
 464          * We will pass the symbols to the filter later, in
 465          * map__split_kallsyms, when we have split the maps per module
 466          */
 467         symbols__insert(root, sym);
 468         return 0;
 469 }
 470
 471 /*
 472  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 473  * so that we can in the next step set the symbol ->end address and then
 474  * call kernel_maps__split_kallsyms.
 475  */
 476 static int dso__load_all_kallsyms(struct dso *self, const char *filename,
 477                                   struct map *map)
 478 {
 479         struct process_kallsyms_args args = { .map = map, .dso = self, };
 480         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 481 }
 482
 483 /*
 484  * Split the symbols into maps, making sure there are no overlaps, i.e. the
 485  * kernel range is broken in several maps, named [kernel].N, as we don't have
 486  * the original ELF section names vmlinux have.
 487  */
 488 static int dso__split_kallsyms(struct dso *self, struct map *map,
 489                                symbol_filter_t filter)
 490 {
 491         struct map_groups *kmaps = map__kmap(map)->kmaps;
 492         struct map *curr_map = map;
 493         struct symbol *pos;
 494         int count = 0;
 495         struct rb_root *root = &self->symbols[map->type];
 496         struct rb_node *next = rb_first(root);
 497         int kernel_range = 0;
 498
 499         while (next) {
 500                 char *module;
 501
 502                 pos = rb_entry(next, struct symbol, rb_node);
 503                 next = rb_next(&pos->rb_node);
 504
 505                 module = strchr(pos->name, '\t');
 506                 if (module) {
 507                         if (!symbol_conf.use_modules)
 508                                 goto discard_symbol;
 509
 510                         *module++ = '\0';
 511
 512                         if (strcmp(curr_map->dso->short_name, module)) {
 513                                 curr_map = map_groups__find_by_name(kmaps, map->type, module);
 514                                 if (curr_map == NULL) {
 515                                         pr_debug("/proc/{kallsyms,modules} "
 516                                                  "inconsistency while looking "
 517                                                  "for \"%s\" module!\n", module);
 518                                         return -1;
 519                                 }
 520
 521                                 if (curr_map->dso->loaded)
 522                                         goto discard_symbol;
 523                         }
 524                         /*
 525                          * So that we look just like we get from .ko files,
 526                          * i.e. not prelinked, relative to map->start.
 527                          */
 528                         pos->start = curr_map->map_ip(curr_map, pos->start);
 529                         pos->end   = curr_map->map_ip(curr_map, pos->end);
 530                 } else if (curr_map != map) {
 531                         char dso_name[PATH_MAX];
 532                         struct dso *dso;
 533
 534                         snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
 535                                  kernel_range++);
 536
 537                         dso = dso__new(dso_name);
 538                         if (dso == NULL)
 539                                 return -1;
 540
 541                         curr_map = map__new2(pos->start, dso, map->type);
 542                         if (curr_map == NULL) {
 543                                 dso__delete(dso);
 544                                 return -1;
 545                         }
 546
 547                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 548                         map_groups__insert(kmaps, curr_map);
 549                         ++kernel_range;
 550                 }
 551
 552                 if (filter && filter(curr_map, pos)) {
 553 discard_symbol:         rb_erase(&pos->rb_node, root);
 554                         symbol__delete(pos);
 555                 } else {
 556                         if (curr_map != map) {
 557                                 rb_erase(&pos->rb_node, root);
 558                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 559                         }
 560                         count++;
 561                 }
 562         }
 563
 564         return count;
 565 }
 566
 567 int dso__load_kallsyms(struct dso *self, const char *filename,
 568                        struct map *map, symbol_filter_t filter)
 569 {
 570         if (dso__load_all_kallsyms(self, filename, map) < 0)
 571                 return -1;
 572
 573         symbols__fixup_end(&self->symbols[map->type]);
 574         self->origin = DSO__ORIG_KERNEL;
 575
 576         return dso__split_kallsyms(self, map, filter);
 577 }
 578
 579 static int dso__load_perf_map(struct dso *self, struct map *map,
 580                               symbol_filter_t filter)
 581 {
 582         char *line = NULL;
 583         size_t n;
 584         FILE *file;
 585         int nr_syms = 0;
 586
 587         file = fopen(self->long_name, "r");
 588         if (file == NULL)
 589                 goto out_failure;
 590
 591         while (!feof(file)) {
 592                 u64 start, size;
 593                 struct symbol *sym;
 594                 int line_len, len;
 595
 596                 line_len = getline(&line, &n, file);
 597                 if (line_len < 0)
 598                         break;
 599
 600                 if (!line)
 601                         goto out_failure;
 602
 603                 line[--line_len] = '\0'; /* \n */
 604
 605                 len = hex2u64(line, &start);
 606
 607                 len++;
 608                 if (len + 2 >= line_len)
 609                         continue;
 610
 611                 len += hex2u64(line + len, &size);
 612
 613                 len++;
 614                 if (len + 2 >= line_len)
 615                         continue;
 616
 617                 sym = symbol__new(start, size, line + len);
 618
 619                 if (sym == NULL)
 620                         goto out_delete_line;
 621
 622                 if (filter && filter(map, sym))
 623                         symbol__delete(sym);
 624                 else {
 625                         symbols__insert(&self->symbols[map->type], sym);
 626                         nr_syms++;
 627                 }
 628         }
 629
 630         free(line);
 631         fclose(file);
 632
 633         return nr_syms;
 634
 635 out_delete_line:
 636         free(line);
 637 out_failure:
 638         return -1;
 639 }
 640
 641 /**
 642  * elf_symtab__for_each_symbol - iterate thru all the symbols
 643  *
 644  * @self: struct elf_symtab instance to iterate
 645  * @idx: uint32_t idx
 646  * @sym: GElf_Sym iterator
 647  */
 648 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 649         for (idx = 0, gelf_getsym(syms, idx, &sym);\
 650              idx < nr_syms; \
 651              idx++, gelf_getsym(syms, idx, &sym))
 652
 653 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 654 {
 655         return GELF_ST_TYPE(sym->st_info);
 656 }
 657
 658 static inline int elf_sym__is_function(const GElf_Sym *sym)
 659 {
 660         return elf_sym__type(sym) == STT_FUNC &&
 661                sym->st_name != 0 &&
 662                sym->st_shndx != SHN_UNDEF;
 663 }
 664
 665 static inline bool elf_sym__is_object(const GElf_Sym *sym)
 666 {
 667         return elf_sym__type(sym) == STT_OBJECT &&
 668                 sym->st_name != 0 &&
 669                 sym->st_shndx != SHN_UNDEF;
 670 }
 671
 672 static inline int elf_sym__is_label(const GElf_Sym *sym)
 673 {
 674         return elf_sym__type(sym) == STT_NOTYPE &&
 675                 sym->st_name != 0 &&
 676                 sym->st_shndx != SHN_UNDEF &&
 677                 sym->st_shndx != SHN_ABS;
 678 }
 679
 680 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 681                                         const Elf_Data *secstrs)
 682 {
 683         return secstrs->d_buf + shdr->sh_name;
 684 }
 685
 686 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 687                                         const Elf_Data *secstrs)
 688 {
 689         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 690 }
 691
 692 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 693                                     const Elf_Data *secstrs)
 694 {
 695         return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 696 }
 697
 698 static inline const char *elf_sym__name(const GElf_Sym *sym,
 699                                         const Elf_Data *symstrs)
 700 {
 701         return symstrs->d_buf + sym->st_name;
 702 }
 703
 704 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 705                                     GElf_Shdr *shp, const char *name,
 706                                     size_t *idx)
 707 {
 708         Elf_Scn *sec = NULL;
 709         size_t cnt = 1;
 710
 711         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 712                 char *str;
 713
 714                 gelf_getshdr(sec, shp);
 715                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 716                 if (!strcmp(name, str)) {
 717                         if (idx)
 718                                 *idx = cnt;
 719                         break;
 720                 }
 721                 ++cnt;
 722         }
 723
 724         return sec;
 725 }
 726
 727 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 728         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 729              idx < nr_entries; \
 730              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 731
 732 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 733         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 734              idx < nr_entries; \
 735              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 736
 737 /*
 738  * We need to check if we have a .dynsym, so that we can handle the
 739  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 740  * .dynsym or .symtab).
 741  * And always look at the original dso, not at debuginfo packages, that
 742  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 743  */
 744 static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
 745                                        symbol_filter_t filter)
 746 {
 747         uint32_t nr_rel_entries, idx;
 748         GElf_Sym sym;
 749         u64 plt_offset;
 750         GElf_Shdr shdr_plt;
 751         struct symbol *f;
 752         GElf_Shdr shdr_rel_plt, shdr_dynsym;
 753         Elf_Data *reldata, *syms, *symstrs;
 754         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 755         size_t dynsym_idx;
 756         GElf_Ehdr ehdr;
 757         char sympltname[1024];
 758         Elf *elf;
 759         int nr = 0, symidx, fd, err = 0;
 760
 761         fd = open(self->long_name, O_RDONLY);
 762         if (fd < 0)
 763                 goto out;
 764
 765         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 766         if (elf == NULL)
 767                 goto out_close;
 768
 769         if (gelf_getehdr(elf, &ehdr) == NULL)
 770                 goto out_elf_end;
 771
 772         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 773                                          ".dynsym", &dynsym_idx);
 774         if (scn_dynsym == NULL)
 775                 goto out_elf_end;
 776
 777         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 778                                           ".rela.plt", NULL);
 779         if (scn_plt_rel == NULL) {
 780                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 781                                                   ".rel.plt", NULL);
 782                 if (scn_plt_rel == NULL)
 783                         goto out_elf_end;
 784         }
 785
 786         err = -1;
 787
 788         if (shdr_rel_plt.sh_link != dynsym_idx)
 789                 goto out_elf_end;
 790
 791         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
 792                 goto out_elf_end;
 793
 794         /*
 795          * Fetch the relocation section to find the idxes to the GOT
 796          * and the symbols in the .dynsym they refer to.
 797          */
 798         reldata = elf_getdata(scn_plt_rel, NULL);
 799         if (reldata == NULL)
 800                 goto out_elf_end;
 801
 802         syms = elf_getdata(scn_dynsym, NULL);
 803         if (syms == NULL)
 804                 goto out_elf_end;
 805
 806         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
 807         if (scn_symstrs == NULL)
 808                 goto out_elf_end;
 809
 810         symstrs = elf_getdata(scn_symstrs, NULL);
 811         if (symstrs == NULL)
 812                 goto out_elf_end;
 813
 814         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
 815         plt_offset = shdr_plt.sh_offset;
 816
 817         if (shdr_rel_plt.sh_type == SHT_RELA) {
 818                 GElf_Rela pos_mem, *pos;
 819
 820                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
 821                                            nr_rel_entries) {
 822                         symidx = GELF_R_SYM(pos->r_info);
 823                         plt_offset += shdr_plt.sh_entsize;
 824                         gelf_getsym(syms, symidx, &sym);
 825                         snprintf(sympltname, sizeof(sympltname),
 826                                  "%s@plt", elf_sym__name(&sym, symstrs));
 827
 828                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 829                                         sympltname);
 830                         if (!f)
 831                                 goto out_elf_end;
 832
 833                         if (filter && filter(map, f))
 834                                 symbol__delete(f);
 835                         else {
 836                                 symbols__insert(&self->symbols[map->type], f);
 837                                 ++nr;
 838                         }
 839                 }
 840         } else if (shdr_rel_plt.sh_type == SHT_REL) {
 841                 GElf_Rel pos_mem, *pos;
 842                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
 843                                           nr_rel_entries) {
 844                         symidx = GELF_R_SYM(pos->r_info);
 845                         plt_offset += shdr_plt.sh_entsize;
 846                         gelf_getsym(syms, symidx, &sym);
 847                         snprintf(sympltname, sizeof(sympltname),
 848                                  "%s@plt", elf_sym__name(&sym, symstrs));
 849
 850                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 851                                         sympltname);
 852                         if (!f)
 853                                 goto out_elf_end;
 854
 855                         if (filter && filter(map, f))
 856                                 symbol__delete(f);
 857                         else {
 858                                 symbols__insert(&self->symbols[map->type], f);
 859                                 ++nr;
 860                         }
 861                 }
 862         }
 863
 864         err = 0;
 865 out_elf_end:
 866         elf_end(elf);
 867 out_close:
 868         close(fd);
 869
 870         if (err == 0)
 871                 return nr;
 872 out:
 873         pr_warning("%s: problems reading %s PLT info.\n",
 874                    __func__, self->long_name);
 875         return 0;
 876 }
 877
 878 static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
 879 {
 880         switch (type) {
 881         case MAP__FUNCTION:
 882                 return elf_sym__is_function(self);
 883         case MAP__VARIABLE:
 884                 return elf_sym__is_object(self);
 885         default:
 886                 return false;
 887         }
 888 }
 889
 890 static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
 891 {
 892         switch (type) {
 893         case MAP__FUNCTION:
 894                 return elf_sec__is_text(self, secstrs);
 895         case MAP__VARIABLE:
 896                 return elf_sec__is_data(self, secstrs);
 897         default:
 898                 return false;
 899         }
 900 }
 901
 902 static int dso__load_sym(struct dso *self, struct map *map, const char *name,
 903                          int fd, symbol_filter_t filter, int kmodule)
 904 {
 905         struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
 906         struct map *curr_map = map;
 907         struct dso *curr_dso = self;
 908         Elf_Data *symstrs, *secstrs;
 909         uint32_t nr_syms;
 910         int err = -1;
 911         uint32_t idx;
 912         GElf_Ehdr ehdr;
 913         GElf_Shdr shdr;
 914         Elf_Data *syms;
 915         GElf_Sym sym;
 916         Elf_Scn *sec, *sec_strndx;
 917         Elf *elf;
 918         int nr = 0;
 919
 920         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 921         if (elf == NULL) {
 922                 pr_err("%s: cannot read %s ELF file.\n", __func__, name);
 923                 goto out_close;
 924         }
 925
 926         if (gelf_getehdr(elf, &ehdr) == NULL) {
 927                 pr_err("%s: cannot get elf header.\n", __func__);
 928                 goto out_elf_end;
 929         }
 930
 931         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
 932         if (sec == NULL) {
 933                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
 934                 if (sec == NULL)
 935                         goto out_elf_end;
 936         }
 937
 938         syms = elf_getdata(sec, NULL);
 939         if (syms == NULL)
 940                 goto out_elf_end;
 941
 942         sec = elf_getscn(elf, shdr.sh_link);
 943         if (sec == NULL)
 944                 goto out_elf_end;
 945
 946         symstrs = elf_getdata(sec, NULL);
 947         if (symstrs == NULL)
 948                 goto out_elf_end;
 949
 950         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
 951         if (sec_strndx == NULL)
 952                 goto out_elf_end;
 953
 954         secstrs = elf_getdata(sec_strndx, NULL);
 955         if (secstrs == NULL)
 956                 goto out_elf_end;
 957
 958         nr_syms = shdr.sh_size / shdr.sh_entsize;
 959
 960         memset(&sym, 0, sizeof(sym));
 961         if (!self->kernel) {
 962                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
 963                                 elf_section_by_name(elf, &ehdr, &shdr,
 964                                                      ".gnu.prelink_undo",
 965                                                      NULL) != NULL);
 966         } else self->adjust_symbols = 0;
 967
 968         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
 969                 struct symbol *f;
 970                 const char *elf_name = elf_sym__name(&sym, symstrs);
 971                 char *demangled = NULL;
 972                 int is_label = elf_sym__is_label(&sym);
 973                 const char *section_name;
 974
 975                 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
 976                     strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
 977                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
 978
 979                 if (!is_label && !elf_sym__is_a(&sym, map->type))
 980                         continue;
 981
 982                 sec = elf_getscn(elf, sym.st_shndx);
 983                 if (!sec)
 984                         goto out_elf_end;
 985
 986                 gelf_getshdr(sec, &shdr);
 987
 988                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
 989                         continue;
 990
 991                 section_name = elf_sec__name(&shdr, secstrs);
 992
 993                 if (self->kernel || kmodule) {
 994                         char dso_name[PATH_MAX];
 995
 996                         if (strcmp(section_name,
 997                                    (curr_dso->short_name +
 998                                     self->short_name_len)) == 0)
 999                                 goto new_symbol;
1000
1001                         if (strcmp(section_name, ".text") == 0) {
1002                                 curr_map = map;
1003                                 curr_dso = self;
1004                                 goto new_symbol;
1005                         }
1006
1007                         snprintf(dso_name, sizeof(dso_name),
1008                                  "%s%s", self->short_name, section_name);
1009
1010                         curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1011                         if (curr_map == NULL) {
1012                                 u64 start = sym.st_value;
1013
1014                                 if (kmodule)
1015                                         start += map->start + shdr.sh_offset;
1016
1017                                 curr_dso = dso__new(dso_name);
1018                                 if (curr_dso == NULL)
1019                                         goto out_elf_end;
1020                                 curr_map = map__new2(start, curr_dso,
1021                                                      map->type);
1022                                 if (curr_map == NULL) {
1023                                         dso__delete(curr_dso);
1024                                         goto out_elf_end;
1025                                 }
1026                                 curr_map->map_ip = identity__map_ip;
1027                                 curr_map->unmap_ip = identity__map_ip;
1028                                 curr_dso->origin = DSO__ORIG_KERNEL;
1029                                 map_groups__insert(kmap->kmaps, curr_map);
1030                                 dsos__add(&dsos__kernel, curr_dso);
1031                                 dso__set_loaded(curr_dso, map->type);
1032                         } else
1033                                 curr_dso = curr_map->dso;
1034
1035                         goto new_symbol;
1036                 }
1037
1038                 if (curr_dso->adjust_symbols) {
1039                         pr_debug4("%s: adjusting symbol: st_value: %#Lx "
1040                                   "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
1041                                   (u64)sym.st_value, (u64)shdr.sh_addr,
1042                                   (u64)shdr.sh_offset);
1043                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1044                 }
1045                 /*
1046                  * We need to figure out if the object was created from C++ sources
1047                  * DWARF DW_compile_unit has this, but we don't always have access
1048                  * to it...
1049                  */
1050                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1051                 if (demangled != NULL)
1052                         elf_name = demangled;
1053 new_symbol:
1054                 f = symbol__new(sym.st_value, sym.st_size, elf_name);
1055                 free(demangled);
1056                 if (!f)
1057                         goto out_elf_end;
1058
1059                 if (filter && filter(curr_map, f))
1060                         symbol__delete(f);
1061                 else {
1062                         symbols__insert(&curr_dso->symbols[curr_map->type], f);
1063                         nr++;
1064                 }
1065         }
1066
1067         /*
1068          * For misannotated, zeroed, ASM function sizes.
1069          */
1070         if (nr > 0) {
1071                 symbols__fixup_end(&self->symbols[map->type]);
1072                 if (kmap) {
1073                         /*
1074                          * We need to fixup this here too because we create new
1075                          * maps here, for things like vsyscall sections.
1076                          */
1077                         __map_groups__fixup_end(kmap->kmaps, map->type);
1078                 }
1079         }
1080         err = nr;
1081 out_elf_end:
1082         elf_end(elf);
1083 out_close:
1084         return err;
1085 }
1086
1087 static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
1088 {
1089         return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
1090 }
1091
1092 static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1093 {
1094         bool have_build_id = false;
1095         struct dso *pos;
1096
1097         list_for_each_entry(pos, head, node) {
1098                 if (with_hits && !pos->hit)
1099                         continue;
1100                 if (filename__read_build_id(pos->long_name, pos->build_id,
1101                                             sizeof(pos->build_id)) > 0) {
1102                         have_build_id     = true;
1103                         pos->has_build_id = true;
1104                 }
1105         }
1106
1107         return have_build_id;
1108 }
1109
1110 bool dsos__read_build_ids(bool with_hits)
1111 {
1112         bool kbuildids = __dsos__read_build_ids(&dsos__kernel, with_hits),
1113              ubuildids = __dsos__read_build_ids(&dsos__user, with_hits);
1114         return kbuildids || ubuildids;
1115 }
1116
1117 /*
1118  * Align offset to 4 bytes as needed for note name and descriptor data.
1119  */
1120 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1121
1122 int filename__read_build_id(const char *filename, void *bf, size_t size)
1123 {
1124         int fd, err = -1;
1125         GElf_Ehdr ehdr;
1126         GElf_Shdr shdr;
1127         Elf_Data *data;
1128         Elf_Scn *sec;
1129         Elf_Kind ek;
1130         void *ptr;
1131         Elf *elf;
1132
1133         if (size < BUILD_ID_SIZE)
1134                 goto out;
1135
1136         fd = open(filename, O_RDONLY);
1137         if (fd < 0)
1138                 goto out;
1139
1140         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1141         if (elf == NULL) {
1142                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1143                 goto out_close;
1144         }
1145
1146         ek = elf_kind(elf);
1147         if (ek != ELF_K_ELF)
1148                 goto out_elf_end;
1149
1150         if (gelf_getehdr(elf, &ehdr) == NULL) {
1151                 pr_err("%s: cannot get elf header.\n", __func__);
1152                 goto out_elf_end;
1153         }
1154
1155         sec = elf_section_by_name(elf, &ehdr, &shdr,
1156                                   ".note.gnu.build-id", NULL);
1157         if (sec == NULL) {
1158                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1159                                           ".notes", NULL);
1160                 if (sec == NULL)
1161                         goto out_elf_end;
1162         }
1163
1164         data = elf_getdata(sec, NULL);
1165         if (data == NULL)
1166                 goto out_elf_end;
1167
1168         ptr = data->d_buf;
1169         while (ptr < (data->d_buf + data->d_size)) {
1170                 GElf_Nhdr *nhdr = ptr;
1171                 int namesz = NOTE_ALIGN(nhdr->n_namesz),
1172                     descsz = NOTE_ALIGN(nhdr->n_descsz);
1173                 const char *name;
1174
1175                 ptr += sizeof(*nhdr);
1176                 name = ptr;
1177                 ptr += namesz;
1178                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1179                     nhdr->n_namesz == sizeof("GNU")) {
1180                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1181                                 memcpy(bf, ptr, BUILD_ID_SIZE);
1182                                 err = BUILD_ID_SIZE;
1183                                 break;
1184                         }
1185                 }
1186                 ptr += descsz;
1187         }
1188 out_elf_end:
1189         elf_end(elf);
1190 out_close:
1191         close(fd);
1192 out:
1193         return err;
1194 }
1195
1196 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1197 {
1198         int fd, err = -1;
1199
1200         if (size < BUILD_ID_SIZE)
1201                 goto out;
1202
1203         fd = open(filename, O_RDONLY);
1204         if (fd < 0)
1205                 goto out;
1206
1207         while (1) {
1208                 char bf[BUFSIZ];
1209                 GElf_Nhdr nhdr;
1210                 int namesz, descsz;
1211
1212                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1213                         break;
1214
1215                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1216                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1217                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1218                     nhdr.n_namesz == sizeof("GNU")) {
1219                         if (read(fd, bf, namesz) != namesz)
1220                                 break;
1221                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1222                                 if (read(fd, build_id,
1223                                     BUILD_ID_SIZE) == BUILD_ID_SIZE) {
1224                                         err = 0;
1225                                         break;
1226                                 }
1227                         } else if (read(fd, bf, descsz) != descsz)
1228                                 break;
1229                 } else {
1230                         int n = namesz + descsz;
1231                         if (read(fd, bf, n) != n)
1232                                 break;
1233                 }
1234         }
1235         close(fd);
1236 out:
1237         return err;
1238 }
1239
1240 char dso__symtab_origin(const struct dso *self)
1241 {
1242         static const char origin[] = {
1243                 [DSO__ORIG_KERNEL] =   'k',
1244                 [DSO__ORIG_JAVA_JIT] = 'j',
1245                 [DSO__ORIG_BUILD_ID_CACHE] = 'B',
1246                 [DSO__ORIG_FEDORA] =   'f',
1247                 [DSO__ORIG_UBUNTU] =   'u',
1248                 [DSO__ORIG_BUILDID] =  'b',
1249                 [DSO__ORIG_DSO] =      'd',
1250                 [DSO__ORIG_KMODULE] =  'K',
1251         };
1252
1253         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
1254                 return '!';
1255         return origin[self->origin];
1256 }
1257
1258 int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1259 {
1260         int size = PATH_MAX;
1261         char *name;
1262         u8 build_id[BUILD_ID_SIZE];
1263         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1264         int ret = -1;
1265         int fd;
1266
1267         dso__set_loaded(self, map->type);
1268
1269         if (self->kernel)
1270                 return dso__load_kernel_sym(self, map, filter);
1271
1272         name = malloc(size);
1273         if (!name)
1274                 return -1;
1275
1276         self->adjust_symbols = 0;
1277
1278         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
1279                 ret = dso__load_perf_map(self, map, filter);
1280                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
1281                                          DSO__ORIG_NOT_FOUND;
1282                 return ret;
1283         }
1284
1285         self->origin = DSO__ORIG_BUILD_ID_CACHE;
1286
1287         if (self->has_build_id) {
1288                 build_id__sprintf(self->build_id, sizeof(self->build_id),
1289                                   build_id_hex);
1290                 snprintf(name, size, "%s/%s/.build-id/%.2s/%s",
1291                          getenv("HOME"), DEBUG_CACHE_DIR,
1292                          build_id_hex, build_id_hex + 2);
1293                 goto open_file;
1294         }
1295 more:
1296         do {
1297                 self->origin++;
1298                 switch (self->origin) {
1299                 case DSO__ORIG_FEDORA:
1300                         snprintf(name, size, "/usr/lib/debug%s.debug",
1301                                  self->long_name);
1302                         break;
1303                 case DSO__ORIG_UBUNTU:
1304                         snprintf(name, size, "/usr/lib/debug%s",
1305                                  self->long_name);
1306                         break;
1307                 case DSO__ORIG_BUILDID:
1308                         if (filename__read_build_id(self->long_name, build_id,
1309                                                     sizeof(build_id))) {
1310                                 build_id__sprintf(build_id, sizeof(build_id),
1311                                                   build_id_hex);
1312                                 snprintf(name, size,
1313                                          "/usr/lib/debug/.build-id/%.2s/%s.debug",
1314                                         build_id_hex, build_id_hex + 2);
1315                                 if (self->has_build_id)
1316                                         goto compare_build_id;
1317                                 break;
1318                         }
1319                         self->origin++;
1320                         /* Fall thru */
1321                 case DSO__ORIG_DSO:
1322                         snprintf(name, size, "%s", self->long_name);
1323                         break;
1324
1325                 default:
1326                         goto out;
1327                 }
1328
1329                 if (self->has_build_id) {
1330                         if (filename__read_build_id(name, build_id,
1331                                                     sizeof(build_id)) < 0)
1332                                 goto more;
1333 compare_build_id:
1334                         if (!dso__build_id_equal(self, build_id))
1335                                 goto more;
1336                 }
1337 open_file:
1338                 fd = open(name, O_RDONLY);
1339         } while (fd < 0);
1340
1341         ret = dso__load_sym(self, map, name, fd, filter, 0);
1342         close(fd);
1343
1344         /*
1345          * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
1346          */
1347         if (!ret)
1348                 goto more;
1349
1350         if (ret > 0) {
1351                 int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
1352                 if (nr_plt > 0)
1353                         ret += nr_plt;
1354         }
1355 out:
1356         free(name);
1357         if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
1358                 return 0;
1359         return ret;
1360 }
1361
1362 struct map *map_groups__find_by_name(struct map_groups *self,
1363                                      enum map_type type, const char *name)
1364 {
1365         struct rb_node *nd;
1366
1367         for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
1368                 struct map *map = rb_entry(nd, struct map, rb_node);
1369
1370                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1371                         return map;
1372         }
1373
1374         return NULL;
1375 }
1376
1377 static int dso__kernel_module_get_build_id(struct dso *self)
1378 {
1379         char filename[PATH_MAX];
1380         /*
1381          * kernel module short names are of the form "[module]" and
1382          * we need just "module" here.
1383          */
1384         const char *name = self->short_name + 1;
1385
1386         snprintf(filename, sizeof(filename),
1387                  "/sys/module/%.*s/notes/.note.gnu.build-id",
1388                  (int)strlen(name - 1), name);
1389
1390         if (sysfs__read_build_id(filename, self->build_id,
1391                                  sizeof(self->build_id)) == 0)
1392                 self->has_build_id = true;
1393
1394         return 0;
1395 }
1396
1397 static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirname)
1398 {
1399         struct dirent *dent;
1400         DIR *dir = opendir(dirname);
1401
1402         if (!dir) {
1403                 pr_debug("%s: cannot open %s dir\n", __func__, dirname);
1404                 return -1;
1405         }
1406
1407         while ((dent = readdir(dir)) != NULL) {
1408                 char path[PATH_MAX];
1409
1410                 if (dent->d_type == DT_DIR) {
1411                         if (!strcmp(dent->d_name, ".") ||
1412                             !strcmp(dent->d_name, ".."))
1413                                 continue;
1414
1415                         snprintf(path, sizeof(path), "%s/%s",
1416                                  dirname, dent->d_name);
1417                         if (map_groups__set_modules_path_dir(self, path) < 0)
1418                                 goto failure;
1419                 } else {
1420                         char *dot = strrchr(dent->d_name, '.'),
1421                              dso_name[PATH_MAX];
1422                         struct map *map;
1423                         char *long_name;
1424
1425                         if (dot == NULL || strcmp(dot, ".ko"))
1426                                 continue;
1427                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1428                                  (int)(dot - dent->d_name), dent->d_name);
1429
1430                         strxfrchar(dso_name, '-', '_');
1431                         map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
1432                         if (map == NULL)
1433                                 continue;
1434
1435                         snprintf(path, sizeof(path), "%s/%s",
1436                                  dirname, dent->d_name);
1437
1438                         long_name = strdup(path);
1439                         if (long_name == NULL)
1440                                 goto failure;
1441                         dso__set_long_name(map->dso, long_name);
1442                         dso__kernel_module_get_build_id(map->dso);
1443                 }
1444         }
1445
1446         return 0;
1447 failure:
1448         closedir(dir);
1449         return -1;
1450 }
1451
1452 static int map_groups__set_modules_path(struct map_groups *self)
1453 {
1454         struct utsname uts;
1455         char modules_path[PATH_MAX];
1456
1457         if (uname(&uts) < 0)
1458                 return -1;
1459
1460         snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
1461                  uts.release);
1462
1463         return map_groups__set_modules_path_dir(self, modules_path);
1464 }
1465
1466 /*
1467  * Constructor variant for modules (where we know from /proc/modules where
1468  * they are loaded) and for vmlinux, where only after we load all the
1469  * symbols we'll know where it starts and ends.
1470  */
1471 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1472 {
1473         struct map *self = zalloc(sizeof(*self) +
1474                                   (dso->kernel ? sizeof(struct kmap) : 0));
1475         if (self != NULL) {
1476                 /*
1477                  * ->end will be filled after we load all the symbols
1478                  */
1479                 map__init(self, type, start, 0, 0, dso);
1480         }
1481
1482         return self;
1483 }
1484
1485 struct map *map_groups__new_module(struct map_groups *self, u64 start,
1486                                    const char *filename)
1487 {
1488         struct map *map;
1489         struct dso *dso = __dsos__findnew(&dsos__kernel, filename);
1490
1491         if (dso == NULL)
1492                 return NULL;
1493
1494         map = map__new2(start, dso, MAP__FUNCTION);
1495         if (map == NULL)
1496                 return NULL;
1497
1498         dso->origin = DSO__ORIG_KMODULE;
1499         map_groups__insert(self, map);
1500         return map;
1501 }
1502
1503 static int map_groups__create_modules(struct map_groups *self)
1504 {
1505         char *line = NULL;
1506         size_t n;
1507         FILE *file = fopen("/proc/modules", "r");
1508         struct map *map;
1509
1510         if (file == NULL)
1511                 return -1;
1512
1513         while (!feof(file)) {
1514                 char name[PATH_MAX];
1515                 u64 start;
1516                 char *sep;
1517                 int line_len;
1518
1519                 line_len = getline(&line, &n, file);
1520                 if (line_len < 0)
1521                         break;
1522
1523                 if (!line)
1524                         goto out_failure;
1525
1526                 line[--line_len] = '\0'; /* \n */
1527
1528                 sep = strrchr(line, 'x');
1529                 if (sep == NULL)
1530                         continue;
1531
1532                 hex2u64(sep + 1, &start);
1533
1534                 sep = strchr(line, ' ');
1535                 if (sep == NULL)
1536                         continue;
1537
1538                 *sep = '\0';
1539
1540                 snprintf(name, sizeof(name), "[%s]", line);
1541                 map = map_groups__new_module(self, start, name);
1542                 if (map == NULL)
1543                         goto out_delete_line;
1544                 dso__kernel_module_get_build_id(map->dso);
1545         }
1546
1547         free(line);
1548         fclose(file);
1549
1550         return map_groups__set_modules_path(self);
1551
1552 out_delete_line:
1553         free(line);
1554 out_failure:
1555         return -1;
1556 }
1557
1558 static int dso__load_vmlinux(struct dso *self, struct map *map,
1559                              const char *vmlinux, symbol_filter_t filter)
1560 {
1561         int err = -1, fd;
1562
1563         if (self->has_build_id) {
1564                 u8 build_id[BUILD_ID_SIZE];
1565
1566                 if (filename__read_build_id(vmlinux, build_id,
1567                                             sizeof(build_id)) < 0) {
1568                         pr_debug("No build_id in %s, ignoring it\n", vmlinux);
1569                         return -1;
1570                 }
1571                 if (!dso__build_id_equal(self, build_id)) {
1572                         char expected_build_id[BUILD_ID_SIZE * 2 + 1],
1573                              vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
1574
1575                         build_id__sprintf(self->build_id,
1576                                           sizeof(self->build_id),
1577                                           expected_build_id);
1578                         build_id__sprintf(build_id, sizeof(build_id),
1579                                           vmlinux_build_id);
1580                         pr_debug("build_id in %s is %s while expected is %s, "
1581                                  "ignoring it\n", vmlinux, vmlinux_build_id,
1582                                  expected_build_id);
1583                         return -1;
1584                 }
1585         }
1586
1587         fd = open(vmlinux, O_RDONLY);
1588         if (fd < 0)
1589                 return -1;
1590
1591         dso__set_loaded(self, map->type);
1592         err = dso__load_sym(self, map, vmlinux, fd, filter, 0);
1593         close(fd);
1594
1595         if (err > 0)
1596                 pr_debug("Using %s for symbols\n", vmlinux);
1597
1598         return err;
1599 }
1600
1601 int dso__load_vmlinux_path(struct dso *self, struct map *map,
1602                            symbol_filter_t filter)
1603 {
1604         int i, err = 0;
1605
1606         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1607                  vmlinux_path__nr_entries);
1608
1609         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1610                 err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
1611                 if (err > 0) {
1612                         dso__set_long_name(self, strdup(vmlinux_path[i]));
1613                         break;
1614                 }
1615         }
1616
1617         return err;
1618 }
1619
1620 static int dso__load_kernel_sym(struct dso *self, struct map *map,
1621                                 symbol_filter_t filter)
1622 {
1623         int err;
1624         const char *kallsyms_filename = NULL;
1625         char *kallsyms_allocated_filename = NULL;
1626         /*
1627          * Step 1: if the user specified a vmlinux filename, use it and only
1628          * it, reporting errors to the user if it cannot be used.
1629          *
1630          * For instance, try to analyse an ARM perf.data file _without_ a
1631          * build-id, or if the user specifies the wrong path to the right
1632          * vmlinux file, obviously we can't fallback to another vmlinux (a
1633          * x86_86 one, on the machine where analysis is being performed, say),
1634          * or worse, /proc/kallsyms.
1635          *
1636          * If the specified file _has_ a build-id and there is a build-id
1637          * section in the perf.data file, we will still do the expected
1638          * validation in dso__load_vmlinux and will bail out if they don't
1639          * match.
1640          */
1641         if (symbol_conf.vmlinux_name != NULL) {
1642                 err = dso__load_vmlinux(self, map,
1643                                         symbol_conf.vmlinux_name, filter);
1644                 goto out_try_fixup;
1645         }
1646
1647         if (vmlinux_path != NULL) {
1648                 err = dso__load_vmlinux_path(self, map, filter);
1649                 if (err > 0)
1650                         goto out_fixup;
1651         }
1652
1653         /*
1654          * Say the kernel DSO was created when processing the build-id header table,
1655          * we have a build-id, so check if it is the same as the running kernel,
1656          * using it if it is.
1657          */
1658         if (self->has_build_id) {
1659                 u8 kallsyms_build_id[BUILD_ID_SIZE];
1660                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1661
1662                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1663                                          sizeof(kallsyms_build_id)) == 0) {
1664                         if (dso__build_id_equal(self, kallsyms_build_id)) {
1665                                 kallsyms_filename = "/proc/kallsyms";
1666                                 goto do_kallsyms;
1667                         }
1668                 }
1669                 /*
1670                  * Now look if we have it on the build-id cache in
1671                  * $HOME/.debug/[kernel.kallsyms].
1672                  */
1673                 build_id__sprintf(self->build_id, sizeof(self->build_id),
1674                                   sbuild_id);
1675
1676                 if (asprintf(&kallsyms_allocated_filename,
1677                              "%s/.debug/[kernel.kallsyms]/%s",
1678                              getenv("HOME"), sbuild_id) == -1) {
1679                         pr_err("Not enough memory for kallsyms file lookup\n");
1680                         return -1;
1681                 }
1682
1683                 kallsyms_filename = kallsyms_allocated_filename;
1684
1685                 if (access(kallsyms_filename, F_OK)) {
1686                         pr_err("No kallsyms or vmlinux with build-id %s "
1687                                "was found\n", sbuild_id);
1688                         free(kallsyms_allocated_filename);
1689                         return -1;
1690                 }
1691         } else {
1692                 /*
1693                  * Last resort, if we don't have a build-id and couldn't find
1694                  * any vmlinux file, try the running kernel kallsyms table.
1695                  */
1696                 kallsyms_filename = "/proc/kallsyms";
1697         }
1698
1699 do_kallsyms:
1700         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1701         if (err > 0)
1702                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1703         free(kallsyms_allocated_filename);
1704
1705 out_try_fixup:
1706         if (err > 0) {
1707 out_fixup:
1708                 if (kallsyms_filename != NULL)
1709                         dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1710                 map__fixup_start(map);
1711                 map__fixup_end(map);
1712         }
1713
1714         return err;
1715 }
1716
1717 LIST_HEAD(dsos__user);
1718 LIST_HEAD(dsos__kernel);
1719
1720 static void dsos__add(struct list_head *head, struct dso *dso)
1721 {
1722         list_add_tail(&dso->node, head);
1723 }
1724
1725 static struct dso *dsos__find(struct list_head *head, const char *name)
1726 {
1727         struct dso *pos;
1728
1729         list_for_each_entry(pos, head, node)
1730                 if (strcmp(pos->long_name, name) == 0)
1731                         return pos;
1732         return NULL;
1733 }
1734
1735 struct dso *__dsos__findnew(struct list_head *head, const char *name)
1736 {
1737         struct dso *dso = dsos__find(head, name);
1738
1739         if (!dso) {
1740                 dso = dso__new(name);
1741                 if (dso != NULL) {
1742                         dsos__add(head, dso);
1743                         dso__set_basename(dso);
1744                 }
1745         }
1746
1747         return dso;
1748 }
1749
1750 static void __dsos__fprintf(struct list_head *head, FILE *fp)
1751 {
1752         struct dso *pos;
1753
1754         list_for_each_entry(pos, head, node) {
1755                 int i;
1756                 for (i = 0; i < MAP__NR_TYPES; ++i)
1757                         dso__fprintf(pos, i, fp);
1758         }
1759 }
1760
1761 void dsos__fprintf(FILE *fp)
1762 {
1763         __dsos__fprintf(&dsos__kernel, fp);
1764         __dsos__fprintf(&dsos__user, fp);
1765 }
1766
1767 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
1768                                       bool with_hits)
1769 {
1770         struct dso *pos;
1771         size_t ret = 0;
1772
1773         list_for_each_entry(pos, head, node) {
1774                 if (with_hits && !pos->hit)
1775                         continue;
1776                 ret += dso__fprintf_buildid(pos, fp);
1777                 ret += fprintf(fp, " %s\n", pos->long_name);
1778         }
1779         return ret;
1780 }
1781
1782 size_t dsos__fprintf_buildid(FILE *fp, bool with_hits)
1783 {
1784         return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) +
1785                 __dsos__fprintf_buildid(&dsos__user, fp, with_hits));
1786 }
1787
1788 struct dso *dso__new_kernel(const char *name)
1789 {
1790         struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
1791
1792         if (self != NULL) {
1793                 dso__set_short_name(self, "[kernel]");
1794                 self->kernel     = 1;
1795         }
1796
1797         return self;
1798 }
1799
1800 void dso__read_running_kernel_build_id(struct dso *self)
1801 {
1802         if (sysfs__read_build_id("/sys/kernel/notes", self->build_id,
1803                                  sizeof(self->build_id)) == 0)
1804                 self->has_build_id = true;
1805 }
1806
1807 static struct dso *dsos__create_kernel(const char *vmlinux)
1808 {
1809         struct dso *kernel = dso__new_kernel(vmlinux);
1810
1811         if (kernel != NULL) {
1812                 dso__read_running_kernel_build_id(kernel);
1813                 dsos__add(&dsos__kernel, kernel);
1814         }
1815
1816         return kernel;
1817 }
1818
1819 int __map_groups__create_kernel_maps(struct map_groups *self,
1820                                      struct map *vmlinux_maps[MAP__NR_TYPES],
1821                                      struct dso *kernel)
1822 {
1823         enum map_type type;
1824
1825         for (type = 0; type < MAP__NR_TYPES; ++type) {
1826                 struct kmap *kmap;
1827
1828                 vmlinux_maps[type] = map__new2(0, kernel, type);
1829                 if (vmlinux_maps[type] == NULL)
1830                         return -1;
1831
1832                 vmlinux_maps[type]->map_ip =
1833                         vmlinux_maps[type]->unmap_ip = identity__map_ip;
1834
1835                 kmap = map__kmap(vmlinux_maps[type]);
1836                 kmap->kmaps = self;
1837                 map_groups__insert(self, vmlinux_maps[type]);
1838         }
1839
1840         return 0;
1841 }
1842
1843 static void vmlinux_path__exit(void)
1844 {
1845         while (--vmlinux_path__nr_entries >= 0) {
1846                 free(vmlinux_path[vmlinux_path__nr_entries]);
1847                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
1848         }
1849
1850         free(vmlinux_path);
1851         vmlinux_path = NULL;
1852 }
1853
1854 static int vmlinux_path__init(void)
1855 {
1856         struct utsname uts;
1857         char bf[PATH_MAX];
1858
1859         if (uname(&uts) < 0)
1860                 return -1;
1861
1862         vmlinux_path = malloc(sizeof(char *) * 5);
1863         if (vmlinux_path == NULL)
1864                 return -1;
1865
1866         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
1867         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1868                 goto out_fail;
1869         ++vmlinux_path__nr_entries;
1870         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
1871         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1872                 goto out_fail;
1873         ++vmlinux_path__nr_entries;
1874         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
1875         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1876         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1877                 goto out_fail;
1878         ++vmlinux_path__nr_entries;
1879         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
1880         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1881         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1882                 goto out_fail;
1883         ++vmlinux_path__nr_entries;
1884         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
1885                  uts.release);
1886         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1887         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1888                 goto out_fail;
1889         ++vmlinux_path__nr_entries;
1890
1891         return 0;
1892
1893 out_fail:
1894         vmlinux_path__exit();
1895         return -1;
1896 }
1897
1898 static int setup_list(struct strlist **list, const char *list_str,
1899                       const char *list_name)
1900 {
1901         if (list_str == NULL)
1902                 return 0;
1903
1904         *list = strlist__new(true, list_str);
1905         if (!*list) {
1906                 pr_err("problems parsing %s list\n", list_name);
1907                 return -1;
1908         }
1909         return 0;
1910 }
1911
1912 int symbol__init(void)
1913 {
1914         elf_version(EV_CURRENT);
1915         if (symbol_conf.sort_by_name)
1916                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
1917                                           sizeof(struct symbol));
1918
1919         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
1920                 return -1;
1921
1922         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
1923                 pr_err("'.' is the only non valid --field-separator argument\n");
1924                 return -1;
1925         }
1926
1927         if (setup_list(&symbol_conf.dso_list,
1928                        symbol_conf.dso_list_str, "dso") < 0)
1929                 return -1;
1930
1931         if (setup_list(&symbol_conf.comm_list,
1932                        symbol_conf.comm_list_str, "comm") < 0)
1933                 goto out_free_dso_list;
1934
1935         if (setup_list(&symbol_conf.sym_list,
1936                        symbol_conf.sym_list_str, "symbol") < 0)
1937                 goto out_free_comm_list;
1938
1939         return 0;
1940
1941 out_free_dso_list:
1942         strlist__delete(symbol_conf.dso_list);
1943 out_free_comm_list:
1944         strlist__delete(symbol_conf.comm_list);
1945         return -1;
1946 }
1947
1948 int map_groups__create_kernel_maps(struct map_groups *self,
1949                                    struct map *vmlinux_maps[MAP__NR_TYPES])
1950 {
1951         struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name);
1952
1953         if (kernel == NULL)
1954                 return -1;
1955
1956         if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0)
1957                 return -1;
1958
1959         if (symbol_conf.use_modules && map_groups__create_modules(self) < 0)
1960                 pr_debug("Problems creating module maps, continuing anyway...\n");
1961         /*
1962          * Now that we have all the maps created, just set the ->end of them:
1963          */
1964         map_groups__fixup_end(self);
1965         return 0;
1966 }