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