tools/perf/util/symbol.c

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