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

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