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