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;
 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 (self->kernel == DSO_TYPE_GUEST_KERNEL)
 594                                 snprintf(dso_name, sizeof(dso_name),
 595                                         "[guest.kernel].%d",
 596                                         kernel_range++);
 597                         else
 598                                 snprintf(dso_name, sizeof(dso_name),
 599                                         "[kernel].%d",
 600                                         kernel_range++);
 601
 602                         dso = dso__new(dso_name);
 603                         if (dso == NULL)
 604                                 return -1;
 605
 606                         dso->kernel = self->kernel;
 607
 608                         curr_map = map__new2(pos->start, dso, map->type);
 609                         if (curr_map == NULL) {
 610                                 dso__delete(dso);
 611                                 return -1;
 612                         }
 613
 614                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 615                         map_groups__insert(kmaps, curr_map);
 616                         ++kernel_range;
 617                 }
 618
 619                 if (filter && filter(curr_map, pos)) {
 620 discard_symbol:         rb_erase(&pos->rb_node, root);
 621                         symbol__delete(pos);
 622                 } else {
 623                         if (curr_map != map) {
 624                                 rb_erase(&pos->rb_node, root);
 625                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 626                         }
 627                         count++;
 628                 }
 629         }
 630
 631         if (curr_map != map &&
 632             self->kernel == DSO_TYPE_GUEST_KERNEL &&
 633             machine__is_default_guest(kmaps->machine)) {
 634                 dso__set_loaded(curr_map->dso, curr_map->type);
 635         }
 636
 637         return count;
 638 }
 639
 640 int dso__load_kallsyms(struct dso *self, const char *filename,
 641                        struct map *map, symbol_filter_t filter)
 642 {
 643         if (dso__load_all_kallsyms(self, filename, map) < 0)
 644                 return -1;
 645
 646         symbols__fixup_end(&self->symbols[map->type]);
 647         if (self->kernel == DSO_TYPE_GUEST_KERNEL)
 648                 self->origin = DSO__ORIG_GUEST_KERNEL;
 649         else
 650                 self->origin = DSO__ORIG_KERNEL;
 651
 652         return dso__split_kallsyms(self, map, filter);
 653 }
 654
 655 static int dso__load_perf_map(struct dso *self, struct map *map,
 656                               symbol_filter_t filter)
 657 {
 658         char *line = NULL;
 659         size_t n;
 660         FILE *file;
 661         int nr_syms = 0;
 662
 663         file = fopen(self->long_name, "r");
 664         if (file == NULL)
 665                 goto out_failure;
 666
 667         while (!feof(file)) {
 668                 u64 start, size;
 669                 struct symbol *sym;
 670                 int line_len, len;
 671
 672                 line_len = getline(&line, &n, file);
 673                 if (line_len < 0)
 674                         break;
 675
 676                 if (!line)
 677                         goto out_failure;
 678
 679                 line[--line_len] = '\0'; /* \n */
 680
 681                 len = hex2u64(line, &start);
 682
 683                 len++;
 684                 if (len + 2 >= line_len)
 685                         continue;
 686
 687                 len += hex2u64(line + len, &size);
 688
 689                 len++;
 690                 if (len + 2 >= line_len)
 691                         continue;
 692
 693                 sym = symbol__new(start, size, STB_GLOBAL, line + len);
 694
 695                 if (sym == NULL)
 696                         goto out_delete_line;
 697
 698                 if (filter && filter(map, sym))
 699                         symbol__delete(sym);
 700                 else {
 701                         symbols__insert(&self->symbols[map->type], sym);
 702                         nr_syms++;
 703                 }
 704         }
 705
 706         free(line);
 707         fclose(file);
 708
 709         return nr_syms;
 710
 711 out_delete_line:
 712         free(line);
 713 out_failure:
 714         return -1;
 715 }
 716
 717 /**
 718  * elf_symtab__for_each_symbol - iterate thru all the symbols
 719  *
 720  * @self: struct elf_symtab instance to iterate
 721  * @idx: uint32_t idx
 722  * @sym: GElf_Sym iterator
 723  */
 724 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 725         for (idx = 0, gelf_getsym(syms, idx, &sym);\
 726              idx < nr_syms; \
 727              idx++, gelf_getsym(syms, idx, &sym))
 728
 729 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 730 {
 731         return GELF_ST_TYPE(sym->st_info);
 732 }
 733
 734 static inline int elf_sym__is_function(const GElf_Sym *sym)
 735 {
 736         return elf_sym__type(sym) == STT_FUNC &&
 737                sym->st_name != 0 &&
 738                sym->st_shndx != SHN_UNDEF;
 739 }
 740
 741 static inline bool elf_sym__is_object(const GElf_Sym *sym)
 742 {
 743         return elf_sym__type(sym) == STT_OBJECT &&
 744                 sym->st_name != 0 &&
 745                 sym->st_shndx != SHN_UNDEF;
 746 }
 747
 748 static inline int elf_sym__is_label(const GElf_Sym *sym)
 749 {
 750         return elf_sym__type(sym) == STT_NOTYPE &&
 751                 sym->st_name != 0 &&
 752                 sym->st_shndx != SHN_UNDEF &&
 753                 sym->st_shndx != SHN_ABS;
 754 }
 755
 756 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 757                                         const Elf_Data *secstrs)
 758 {
 759         return secstrs->d_buf + shdr->sh_name;
 760 }
 761
 762 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 763                                         const Elf_Data *secstrs)
 764 {
 765         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 766 }
 767
 768 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 769                                     const Elf_Data *secstrs)
 770 {
 771         return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 772 }
 773
 774 static inline const char *elf_sym__name(const GElf_Sym *sym,
 775                                         const Elf_Data *symstrs)
 776 {
 777         return symstrs->d_buf + sym->st_name;
 778 }
 779
 780 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 781                                     GElf_Shdr *shp, const char *name,
 782                                     size_t *idx)
 783 {
 784         Elf_Scn *sec = NULL;
 785         size_t cnt = 1;
 786
 787         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 788                 char *str;
 789
 790                 gelf_getshdr(sec, shp);
 791                 str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 792                 if (!strcmp(name, str)) {
 793                         if (idx)
 794                                 *idx = cnt;
 795                         break;
 796                 }
 797                 ++cnt;
 798         }
 799
 800         return sec;
 801 }
 802
 803 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 804         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 805              idx < nr_entries; \
 806              ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 807
 808 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 809         for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 810              idx < nr_entries; \
 811              ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 812
 813 /*
 814  * We need to check if we have a .dynsym, so that we can handle the
 815  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
 816  * .dynsym or .symtab).
 817  * And always look at the original dso, not at debuginfo packages, that
 818  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
 819  */
 820 static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
 821                                        symbol_filter_t filter)
 822 {
 823         uint32_t nr_rel_entries, idx;
 824         GElf_Sym sym;
 825         u64 plt_offset;
 826         GElf_Shdr shdr_plt;
 827         struct symbol *f;
 828         GElf_Shdr shdr_rel_plt, shdr_dynsym;
 829         Elf_Data *reldata, *syms, *symstrs;
 830         Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 831         size_t dynsym_idx;
 832         GElf_Ehdr ehdr;
 833         char sympltname[1024];
 834         Elf *elf;
 835         int nr = 0, symidx, fd, err = 0;
 836
 837         fd = open(self->long_name, O_RDONLY);
 838         if (fd < 0)
 839                 goto out;
 840
 841         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 842         if (elf == NULL)
 843                 goto out_close;
 844
 845         if (gelf_getehdr(elf, &ehdr) == NULL)
 846                 goto out_elf_end;
 847
 848         scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 849                                          ".dynsym", &dynsym_idx);
 850         if (scn_dynsym == NULL)
 851                 goto out_elf_end;
 852
 853         scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 854                                           ".rela.plt", NULL);
 855         if (scn_plt_rel == NULL) {
 856                 scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 857                                                   ".rel.plt", NULL);
 858                 if (scn_plt_rel == NULL)
 859                         goto out_elf_end;
 860         }
 861
 862         err = -1;
 863
 864         if (shdr_rel_plt.sh_link != dynsym_idx)
 865                 goto out_elf_end;
 866
 867         if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
 868                 goto out_elf_end;
 869
 870         /*
 871          * Fetch the relocation section to find the idxes to the GOT
 872          * and the symbols in the .dynsym they refer to.
 873          */
 874         reldata = elf_getdata(scn_plt_rel, NULL);
 875         if (reldata == NULL)
 876                 goto out_elf_end;
 877
 878         syms = elf_getdata(scn_dynsym, NULL);
 879         if (syms == NULL)
 880                 goto out_elf_end;
 881
 882         scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
 883         if (scn_symstrs == NULL)
 884                 goto out_elf_end;
 885
 886         symstrs = elf_getdata(scn_symstrs, NULL);
 887         if (symstrs == NULL)
 888                 goto out_elf_end;
 889
 890         nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
 891         plt_offset = shdr_plt.sh_offset;
 892
 893         if (shdr_rel_plt.sh_type == SHT_RELA) {
 894                 GElf_Rela pos_mem, *pos;
 895
 896                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
 897                                            nr_rel_entries) {
 898                         symidx = GELF_R_SYM(pos->r_info);
 899                         plt_offset += shdr_plt.sh_entsize;
 900                         gelf_getsym(syms, symidx, &sym);
 901                         snprintf(sympltname, sizeof(sympltname),
 902                                  "%s@plt", elf_sym__name(&sym, symstrs));
 903
 904                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 905                                         STB_GLOBAL, sympltname);
 906                         if (!f)
 907                                 goto out_elf_end;
 908
 909                         if (filter && filter(map, f))
 910                                 symbol__delete(f);
 911                         else {
 912                                 symbols__insert(&self->symbols[map->type], f);
 913                                 ++nr;
 914                         }
 915                 }
 916         } else if (shdr_rel_plt.sh_type == SHT_REL) {
 917                 GElf_Rel pos_mem, *pos;
 918                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
 919                                           nr_rel_entries) {
 920                         symidx = GELF_R_SYM(pos->r_info);
 921                         plt_offset += shdr_plt.sh_entsize;
 922                         gelf_getsym(syms, symidx, &sym);
 923                         snprintf(sympltname, sizeof(sympltname),
 924                                  "%s@plt", elf_sym__name(&sym, symstrs));
 925
 926                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 927                                         STB_GLOBAL, sympltname);
 928                         if (!f)
 929                                 goto out_elf_end;
 930
 931                         if (filter && filter(map, f))
 932                                 symbol__delete(f);
 933                         else {
 934                                 symbols__insert(&self->symbols[map->type], f);
 935                                 ++nr;
 936                         }
 937                 }
 938         }
 939
 940         err = 0;
 941 out_elf_end:
 942         elf_end(elf);
 943 out_close:
 944         close(fd);
 945
 946         if (err == 0)
 947                 return nr;
 948 out:
 949         pr_debug("%s: problems reading %s PLT info.\n",
 950                  __func__, self->long_name);
 951         return 0;
 952 }
 953
 954 static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
 955 {
 956         switch (type) {
 957         case MAP__FUNCTION:
 958                 return elf_sym__is_function(self);
 959         case MAP__VARIABLE:
 960                 return elf_sym__is_object(self);
 961         default:
 962                 return false;
 963         }
 964 }
 965
 966 static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
 967 {
 968         switch (type) {
 969         case MAP__FUNCTION:
 970                 return elf_sec__is_text(self, secstrs);
 971         case MAP__VARIABLE:
 972                 return elf_sec__is_data(self, secstrs);
 973         default:
 974                 return false;
 975         }
 976 }
 977
 978 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
 979 {
 980         Elf_Scn *sec = NULL;
 981         GElf_Shdr shdr;
 982         size_t cnt = 1;
 983
 984         while ((sec = elf_nextscn(elf, sec)) != NULL) {
 985                 gelf_getshdr(sec, &shdr);
 986
 987                 if ((addr >= shdr.sh_addr) &&
 988                     (addr < (shdr.sh_addr + shdr.sh_size)))
 989                         return cnt;
 990
 991                 ++cnt;
 992         }
 993
 994         return -1;
 995 }
 996
 997 static int dso__load_sym(struct dso *self, struct map *map, const char *name,
 998                          int fd, symbol_filter_t filter, int kmodule,
 999                          int want_symtab)
1000 {
1001         struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
1002         struct map *curr_map = map;
1003         struct dso *curr_dso = self;
1004         Elf_Data *symstrs, *secstrs;
1005         uint32_t nr_syms;
1006         int err = -1;
1007         uint32_t idx;
1008         GElf_Ehdr ehdr;
1009         GElf_Shdr shdr, opdshdr;
1010         Elf_Data *syms, *opddata = NULL;
1011         GElf_Sym sym;
1012         Elf_Scn *sec, *sec_strndx, *opdsec;
1013         Elf *elf;
1014         int nr = 0;
1015         size_t opdidx = 0;
1016
1017         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1018         if (elf == NULL) {
1019                 pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
1020                 goto out_close;
1021         }
1022
1023         if (gelf_getehdr(elf, &ehdr) == NULL) {
1024                 pr_debug("%s: cannot get elf header.\n", __func__);
1025                 goto out_elf_end;
1026         }
1027
1028         /* Always reject images with a mismatched build-id: */
1029         if (self->has_build_id) {
1030                 u8 build_id[BUILD_ID_SIZE];
1031
1032                 if (elf_read_build_id(elf, build_id,
1033                                       BUILD_ID_SIZE) != BUILD_ID_SIZE)
1034                         goto out_elf_end;
1035
1036                 if (!dso__build_id_equal(self, build_id))
1037                         goto out_elf_end;
1038         }
1039
1040         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
1041         if (sec == NULL) {
1042                 if (want_symtab)
1043                         goto out_elf_end;
1044
1045                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
1046                 if (sec == NULL)
1047                         goto out_elf_end;
1048         }
1049
1050         opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
1051         if (opdsec)
1052                 opddata = elf_rawdata(opdsec, NULL);
1053
1054         syms = elf_getdata(sec, NULL);
1055         if (syms == NULL)
1056                 goto out_elf_end;
1057
1058         sec = elf_getscn(elf, shdr.sh_link);
1059         if (sec == NULL)
1060                 goto out_elf_end;
1061
1062         symstrs = elf_getdata(sec, NULL);
1063         if (symstrs == NULL)
1064                 goto out_elf_end;
1065
1066         sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
1067         if (sec_strndx == NULL)
1068                 goto out_elf_end;
1069
1070         secstrs = elf_getdata(sec_strndx, NULL);
1071         if (secstrs == NULL)
1072                 goto out_elf_end;
1073
1074         nr_syms = shdr.sh_size / shdr.sh_entsize;
1075
1076         memset(&sym, 0, sizeof(sym));
1077         if (self->kernel == DSO_TYPE_USER) {
1078                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
1079                                 elf_section_by_name(elf, &ehdr, &shdr,
1080                                                      ".gnu.prelink_undo",
1081                                                      NULL) != NULL);
1082         } else self->adjust_symbols = 0;
1083
1084         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
1085                 struct symbol *f;
1086                 const char *elf_name = elf_sym__name(&sym, symstrs);
1087                 char *demangled = NULL;
1088                 int is_label = elf_sym__is_label(&sym);
1089                 const char *section_name;
1090
1091                 if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
1092                     strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
1093                         kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
1094
1095                 if (!is_label && !elf_sym__is_a(&sym, map->type))
1096                         continue;
1097
1098                 /* Reject ARM ELF "mapping symbols": these aren't unique and
1099                  * don't identify functions, so will confuse the profile
1100                  * output: */
1101                 if (ehdr.e_machine == EM_ARM) {
1102                         if (!strcmp(elf_name, "$a") ||
1103                             !strcmp(elf_name, "$d") ||
1104                             !strcmp(elf_name, "$t"))
1105                                 continue;
1106                 }
1107
1108                 if (opdsec && sym.st_shndx == opdidx) {
1109                         u32 offset = sym.st_value - opdshdr.sh_addr;
1110                         u64 *opd = opddata->d_buf + offset;
1111                         sym.st_value = *opd;
1112                         sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
1113                 }
1114
1115                 sec = elf_getscn(elf, sym.st_shndx);
1116                 if (!sec)
1117                         goto out_elf_end;
1118
1119                 gelf_getshdr(sec, &shdr);
1120
1121                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
1122                         continue;
1123
1124                 section_name = elf_sec__name(&shdr, secstrs);
1125
1126                 if (self->kernel != DSO_TYPE_USER || kmodule) {
1127                         char dso_name[PATH_MAX];
1128
1129                         if (strcmp(section_name,
1130                                    (curr_dso->short_name +
1131                                     self->short_name_len)) == 0)
1132                                 goto new_symbol;
1133
1134                         if (strcmp(section_name, ".text") == 0) {
1135                                 curr_map = map;
1136                                 curr_dso = self;
1137                                 goto new_symbol;
1138                         }
1139
1140                         snprintf(dso_name, sizeof(dso_name),
1141                                  "%s%s", self->short_name, section_name);
1142
1143                         curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
1144                         if (curr_map == NULL) {
1145                                 u64 start = sym.st_value;
1146
1147                                 if (kmodule)
1148                                         start += map->start + shdr.sh_offset;
1149
1150                                 curr_dso = dso__new(dso_name);
1151                                 if (curr_dso == NULL)
1152                                         goto out_elf_end;
1153                                 curr_dso->kernel = self->kernel;
1154                                 curr_map = map__new2(start, curr_dso,
1155                                                      map->type);
1156                                 if (curr_map == NULL) {
1157                                         dso__delete(curr_dso);
1158                                         goto out_elf_end;
1159                                 }
1160                                 curr_map->map_ip = identity__map_ip;
1161                                 curr_map->unmap_ip = identity__map_ip;
1162                                 curr_dso->origin = self->origin;
1163                                 map_groups__insert(kmap->kmaps, curr_map);
1164                                 dsos__add(&self->node, curr_dso);
1165                                 dso__set_loaded(curr_dso, map->type);
1166                         } else
1167                                 curr_dso = curr_map->dso;
1168
1169                         goto new_symbol;
1170                 }
1171
1172                 if (curr_dso->adjust_symbols) {
1173                         pr_debug4("%s: adjusting symbol: st_value: %#Lx "
1174                                   "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
1175                                   (u64)sym.st_value, (u64)shdr.sh_addr,
1176                                   (u64)shdr.sh_offset);
1177                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
1178                 }
1179                 /*
1180                  * We need to figure out if the object was created from C++ sources
1181                  * DWARF DW_compile_unit has this, but we don't always have access
1182                  * to it...
1183                  */
1184                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
1185                 if (demangled != NULL)
1186                         elf_name = demangled;
1187 new_symbol:
1188                 f = symbol__new(sym.st_value, sym.st_size,
1189                                 GELF_ST_BIND(sym.st_info), elf_name);
1190                 free(demangled);
1191                 if (!f)
1192                         goto out_elf_end;
1193
1194                 if (filter && filter(curr_map, f))
1195                         symbol__delete(f);
1196                 else {
1197                         symbols__insert(&curr_dso->symbols[curr_map->type], f);
1198                         nr++;
1199                 }
1200         }
1201
1202         /*
1203          * For misannotated, zeroed, ASM function sizes.
1204          */
1205         if (nr > 0) {
1206                 symbols__fixup_end(&self->symbols[map->type]);
1207                 if (kmap) {
1208                         /*
1209                          * We need to fixup this here too because we create new
1210                          * maps here, for things like vsyscall sections.
1211                          */
1212                         __map_groups__fixup_end(kmap->kmaps, map->type);
1213                 }
1214         }
1215         err = nr;
1216 out_elf_end:
1217         elf_end(elf);
1218 out_close:
1219         return err;
1220 }
1221
1222 static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
1223 {
1224         return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
1225 }
1226
1227 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
1228 {
1229         bool have_build_id = false;
1230         struct dso *pos;
1231
1232         list_for_each_entry(pos, head, node) {
1233                 if (with_hits && !pos->hit)
1234                         continue;
1235                 if (pos->has_build_id) {
1236                         have_build_id = true;
1237                         continue;
1238                 }
1239                 if (filename__read_build_id(pos->long_name, pos->build_id,
1240                                             sizeof(pos->build_id)) > 0) {
1241                         have_build_id     = true;
1242                         pos->has_build_id = true;
1243                 }
1244         }
1245
1246         return have_build_id;
1247 }
1248
1249 /*
1250  * Align offset to 4 bytes as needed for note name and descriptor data.
1251  */
1252 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
1253
1254 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
1255 {
1256         int err = -1;
1257         GElf_Ehdr ehdr;
1258         GElf_Shdr shdr;
1259         Elf_Data *data;
1260         Elf_Scn *sec;
1261         Elf_Kind ek;
1262         void *ptr;
1263
1264         if (size < BUILD_ID_SIZE)
1265                 goto out;
1266
1267         ek = elf_kind(elf);
1268         if (ek != ELF_K_ELF)
1269                 goto out;
1270
1271         if (gelf_getehdr(elf, &ehdr) == NULL) {
1272                 pr_err("%s: cannot get elf header.\n", __func__);
1273                 goto out;
1274         }
1275
1276         sec = elf_section_by_name(elf, &ehdr, &shdr,
1277                                   ".note.gnu.build-id", NULL);
1278         if (sec == NULL) {
1279                 sec = elf_section_by_name(elf, &ehdr, &shdr,
1280                                           ".notes", NULL);
1281                 if (sec == NULL)
1282                         goto out;
1283         }
1284
1285         data = elf_getdata(sec, NULL);
1286         if (data == NULL)
1287                 goto out;
1288
1289         ptr = data->d_buf;
1290         while (ptr < (data->d_buf + data->d_size)) {
1291                 GElf_Nhdr *nhdr = ptr;
1292                 int namesz = NOTE_ALIGN(nhdr->n_namesz),
1293                     descsz = NOTE_ALIGN(nhdr->n_descsz);
1294                 const char *name;
1295
1296                 ptr += sizeof(*nhdr);
1297                 name = ptr;
1298                 ptr += namesz;
1299                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
1300                     nhdr->n_namesz == sizeof("GNU")) {
1301                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
1302                                 memcpy(bf, ptr, BUILD_ID_SIZE);
1303                                 err = BUILD_ID_SIZE;
1304                                 break;
1305                         }
1306                 }
1307                 ptr += descsz;
1308         }
1309
1310 out:
1311         return err;
1312 }
1313
1314 int filename__read_build_id(const char *filename, void *bf, size_t size)
1315 {
1316         int fd, err = -1;
1317         Elf *elf;
1318
1319         if (size < BUILD_ID_SIZE)
1320                 goto out;
1321
1322         fd = open(filename, O_RDONLY);
1323         if (fd < 0)
1324                 goto out;
1325
1326         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
1327         if (elf == NULL) {
1328                 pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
1329                 goto out_close;
1330         }
1331
1332         err = elf_read_build_id(elf, bf, size);
1333
1334         elf_end(elf);
1335 out_close:
1336         close(fd);
1337 out:
1338         return err;
1339 }
1340
1341 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
1342 {
1343         int fd, err = -1;
1344
1345         if (size < BUILD_ID_SIZE)
1346                 goto out;
1347
1348         fd = open(filename, O_RDONLY);
1349         if (fd < 0)
1350                 goto out;
1351
1352         while (1) {
1353                 char bf[BUFSIZ];
1354                 GElf_Nhdr nhdr;
1355                 int namesz, descsz;
1356
1357                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
1358                         break;
1359
1360                 namesz = NOTE_ALIGN(nhdr.n_namesz);
1361                 descsz = NOTE_ALIGN(nhdr.n_descsz);
1362                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
1363                     nhdr.n_namesz == sizeof("GNU")) {
1364                         if (read(fd, bf, namesz) != namesz)
1365                                 break;
1366                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
1367                                 if (read(fd, build_id,
1368                                     BUILD_ID_SIZE) == BUILD_ID_SIZE) {
1369                                         err = 0;
1370                                         break;
1371                                 }
1372                         } else if (read(fd, bf, descsz) != descsz)
1373                                 break;
1374                 } else {
1375                         int n = namesz + descsz;
1376                         if (read(fd, bf, n) != n)
1377                                 break;
1378                 }
1379         }
1380         close(fd);
1381 out:
1382         return err;
1383 }
1384
1385 char dso__symtab_origin(const struct dso *self)
1386 {
1387         static const char origin[] = {
1388                 [DSO__ORIG_KERNEL] =   'k',
1389                 [DSO__ORIG_JAVA_JIT] = 'j',
1390                 [DSO__ORIG_BUILD_ID_CACHE] = 'B',
1391                 [DSO__ORIG_FEDORA] =   'f',
1392                 [DSO__ORIG_UBUNTU] =   'u',
1393                 [DSO__ORIG_BUILDID] =  'b',
1394                 [DSO__ORIG_DSO] =      'd',
1395                 [DSO__ORIG_KMODULE] =  'K',
1396                 [DSO__ORIG_GUEST_KERNEL] =  'g',
1397                 [DSO__ORIG_GUEST_KMODULE] =  'G',
1398         };
1399
1400         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
1401                 return '!';
1402         return origin[self->origin];
1403 }
1404
1405 int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
1406 {
1407         int size = PATH_MAX;
1408         char *name;
1409         int ret = -1;
1410         int fd;
1411         struct machine *machine;
1412         const char *root_dir;
1413         int want_symtab;
1414
1415         dso__set_loaded(self, map->type);
1416
1417         if (self->kernel == DSO_TYPE_KERNEL)
1418                 return dso__load_kernel_sym(self, map, filter);
1419         else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
1420                 return dso__load_guest_kernel_sym(self, map, filter);
1421
1422         if (map->groups && map->groups->machine)
1423                 machine = map->groups->machine;
1424         else
1425                 machine = NULL;
1426
1427         name = malloc(size);
1428         if (!name)
1429                 return -1;
1430
1431         self->adjust_symbols = 0;
1432
1433         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
1434                 ret = dso__load_perf_map(self, map, filter);
1435                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
1436                                          DSO__ORIG_NOT_FOUND;
1437                 return ret;
1438         }
1439
1440         /* Iterate over candidate debug images.
1441          * On the first pass, only load images if they have a full symtab.
1442          * Failing that, do a second pass where we accept .dynsym also
1443          */
1444         for (self->origin = DSO__ORIG_BUILD_ID_CACHE, want_symtab = 1;
1445              self->origin != DSO__ORIG_NOT_FOUND;
1446              self->origin++) {
1447                 switch (self->origin) {
1448                 case DSO__ORIG_BUILD_ID_CACHE:
1449                         if (dso__build_id_filename(self, name, size) == NULL)
1450                                 continue;
1451                         break;
1452                 case DSO__ORIG_FEDORA:
1453                         snprintf(name, size, "/usr/lib/debug%s.debug",
1454                                  self->long_name);
1455                         break;
1456                 case DSO__ORIG_UBUNTU:
1457                         snprintf(name, size, "/usr/lib/debug%s",
1458                                  self->long_name);
1459                         break;
1460                 case DSO__ORIG_BUILDID: {
1461                         char build_id_hex[BUILD_ID_SIZE * 2 + 1];
1462
1463                         if (!self->has_build_id)
1464                                 continue;
1465
1466                         build_id__sprintf(self->build_id,
1467                                           sizeof(self->build_id),
1468                                           build_id_hex);
1469                         snprintf(name, size,
1470                                  "/usr/lib/debug/.build-id/%.2s/%s.debug",
1471                                  build_id_hex, build_id_hex + 2);
1472                         }
1473                         break;
1474                 case DSO__ORIG_DSO:
1475                         snprintf(name, size, "%s", self->long_name);
1476                         break;
1477                 case DSO__ORIG_GUEST_KMODULE:
1478                         if (map->groups && map->groups->machine)
1479                                 root_dir = map->groups->machine->root_dir;
1480                         else
1481                                 root_dir = "";
1482                         snprintf(name, size, "%s%s", root_dir, self->long_name);
1483                         break;
1484
1485                 default:
1486                         /*
1487                          * If we wanted a full symtab but no image had one,
1488                          * relax our requirements and repeat the search.
1489                          */
1490                         if (want_symtab) {
1491                                 want_symtab = 0;
1492                                 self->origin = DSO__ORIG_BUILD_ID_CACHE;
1493                         } else
1494                                 continue;
1495                 }
1496
1497                 /* Name is now the name of the next image to try */
1498                 fd = open(name, O_RDONLY);
1499                 if (fd < 0)
1500                         continue;
1501
1502                 ret = dso__load_sym(self, map, name, fd, filter, 0,
1503                                     want_symtab);
1504                 close(fd);
1505
1506                 /*
1507                  * Some people seem to have debuginfo files _WITHOUT_ debug
1508                  * info!?!?
1509                  */
1510                 if (!ret)
1511                         continue;
1512
1513                 if (ret > 0) {
1514                         int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
1515                         if (nr_plt > 0)
1516                                 ret += nr_plt;
1517                         break;
1518                 }
1519         }
1520
1521         free(name);
1522         if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
1523                 return 0;
1524         return ret;
1525 }
1526
1527 struct map *map_groups__find_by_name(struct map_groups *self,
1528                                      enum map_type type, const char *name)
1529 {
1530         struct rb_node *nd;
1531
1532         for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
1533                 struct map *map = rb_entry(nd, struct map, rb_node);
1534
1535                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
1536                         return map;
1537         }
1538
1539         return NULL;
1540 }
1541
1542 static int dso__kernel_module_get_build_id(struct dso *self,
1543                                 const char *root_dir)
1544 {
1545         char filename[PATH_MAX];
1546         /*
1547          * kernel module short names are of the form "[module]" and
1548          * we need just "module" here.
1549          */
1550         const char *name = self->short_name + 1;
1551
1552         snprintf(filename, sizeof(filename),
1553                  "%s/sys/module/%.*s/notes/.note.gnu.build-id",
1554                  root_dir, (int)strlen(name) - 1, name);
1555
1556         if (sysfs__read_build_id(filename, self->build_id,
1557                                  sizeof(self->build_id)) == 0)
1558                 self->has_build_id = true;
1559
1560         return 0;
1561 }
1562
1563 static int map_groups__set_modules_path_dir(struct map_groups *self,
1564                                 const char *dir_name)
1565 {
1566         struct dirent *dent;
1567         DIR *dir = opendir(dir_name);
1568         int ret = 0;
1569
1570         if (!dir) {
1571                 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
1572                 return -1;
1573         }
1574
1575         while ((dent = readdir(dir)) != NULL) {
1576                 char path[PATH_MAX];
1577                 struct stat st;
1578
1579                 /*sshfs might return bad dent->d_type, so we have to stat*/
1580                 sprintf(path, "%s/%s", dir_name, dent->d_name);
1581                 if (stat(path, &st))
1582                         continue;
1583
1584                 if (S_ISDIR(st.st_mode)) {
1585                         if (!strcmp(dent->d_name, ".") ||
1586                             !strcmp(dent->d_name, ".."))
1587                                 continue;
1588
1589                         snprintf(path, sizeof(path), "%s/%s",
1590                                  dir_name, dent->d_name);
1591                         ret = map_groups__set_modules_path_dir(self, path);
1592                         if (ret < 0)
1593                                 goto out;
1594                 } else {
1595                         char *dot = strrchr(dent->d_name, '.'),
1596                              dso_name[PATH_MAX];
1597                         struct map *map;
1598                         char *long_name;
1599
1600                         if (dot == NULL || strcmp(dot, ".ko"))
1601                                 continue;
1602                         snprintf(dso_name, sizeof(dso_name), "[%.*s]",
1603                                  (int)(dot - dent->d_name), dent->d_name);
1604
1605                         strxfrchar(dso_name, '-', '_');
1606                         map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
1607                         if (map == NULL)
1608                                 continue;
1609
1610                         snprintf(path, sizeof(path), "%s/%s",
1611                                  dir_name, dent->d_name);
1612
1613                         long_name = strdup(path);
1614                         if (long_name == NULL) {
1615                                 ret = -1;
1616                                 goto out;
1617                         }
1618                         dso__set_long_name(map->dso, long_name);
1619                         map->dso->lname_alloc = 1;
1620                         dso__kernel_module_get_build_id(map->dso, "");
1621                 }
1622         }
1623
1624 out:
1625         closedir(dir);
1626         return ret;
1627 }
1628
1629 static char *get_kernel_version(const char *root_dir)
1630 {
1631         char version[PATH_MAX];
1632         FILE *file;
1633         char *name, *tmp;
1634         const char *prefix = "Linux version ";
1635
1636         sprintf(version, "%s/proc/version", root_dir);
1637         file = fopen(version, "r");
1638         if (!file)
1639                 return NULL;
1640
1641         version[0] = '\0';
1642         tmp = fgets(version, sizeof(version), file);
1643         fclose(file);
1644
1645         name = strstr(version, prefix);
1646         if (!name)
1647                 return NULL;
1648         name += strlen(prefix);
1649         tmp = strchr(name, ' ');
1650         if (tmp)
1651                 *tmp = '\0';
1652
1653         return strdup(name);
1654 }
1655
1656 static int machine__set_modules_path(struct machine *self)
1657 {
1658         char *version;
1659         char modules_path[PATH_MAX];
1660
1661         version = get_kernel_version(self->root_dir);
1662         if (!version)
1663                 return -1;
1664
1665         snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
1666                  self->root_dir, version);
1667         free(version);
1668
1669         return map_groups__set_modules_path_dir(&self->kmaps, modules_path);
1670 }
1671
1672 /*
1673  * Constructor variant for modules (where we know from /proc/modules where
1674  * they are loaded) and for vmlinux, where only after we load all the
1675  * symbols we'll know where it starts and ends.
1676  */
1677 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
1678 {
1679         struct map *self = calloc(1, (sizeof(*self) +
1680                                       (dso->kernel ? sizeof(struct kmap) : 0)));
1681         if (self != NULL) {
1682                 /*
1683                  * ->end will be filled after we load all the symbols
1684                  */
1685                 map__init(self, type, start, 0, 0, dso);
1686         }
1687
1688         return self;
1689 }
1690
1691 struct map *machine__new_module(struct machine *self, u64 start,
1692                                 const char *filename)
1693 {
1694         struct map *map;
1695         struct dso *dso = __dsos__findnew(&self->kernel_dsos, filename);
1696
1697         if (dso == NULL)
1698                 return NULL;
1699
1700         map = map__new2(start, dso, MAP__FUNCTION);
1701         if (map == NULL)
1702                 return NULL;
1703
1704         if (machine__is_host(self))
1705                 dso->origin = DSO__ORIG_KMODULE;
1706         else
1707                 dso->origin = DSO__ORIG_GUEST_KMODULE;
1708         map_groups__insert(&self->kmaps, map);
1709         return map;
1710 }
1711
1712 static int machine__create_modules(struct machine *self)
1713 {
1714         char *line = NULL;
1715         size_t n;
1716         FILE *file;
1717         struct map *map;
1718         const char *modules;
1719         char path[PATH_MAX];
1720
1721         if (machine__is_default_guest(self))
1722                 modules = symbol_conf.default_guest_modules;
1723         else {
1724                 sprintf(path, "%s/proc/modules", self->root_dir);
1725                 modules = path;
1726         }
1727
1728         file = fopen(modules, "r");
1729         if (file == NULL)
1730                 return -1;
1731
1732         while (!feof(file)) {
1733                 char name[PATH_MAX];
1734                 u64 start;
1735                 char *sep;
1736                 int line_len;
1737
1738                 line_len = getline(&line, &n, file);
1739                 if (line_len < 0)
1740                         break;
1741
1742                 if (!line)
1743                         goto out_failure;
1744
1745                 line[--line_len] = '\0'; /* \n */
1746
1747                 sep = strrchr(line, 'x');
1748                 if (sep == NULL)
1749                         continue;
1750
1751                 hex2u64(sep + 1, &start);
1752
1753                 sep = strchr(line, ' ');
1754                 if (sep == NULL)
1755                         continue;
1756
1757                 *sep = '\0';
1758
1759                 snprintf(name, sizeof(name), "[%s]", line);
1760                 map = machine__new_module(self, start, name);
1761                 if (map == NULL)
1762                         goto out_delete_line;
1763                 dso__kernel_module_get_build_id(map->dso, self->root_dir);
1764         }
1765
1766         free(line);
1767         fclose(file);
1768
1769         return machine__set_modules_path(self);
1770
1771 out_delete_line:
1772         free(line);
1773 out_failure:
1774         return -1;
1775 }
1776
1777 static int dso__load_vmlinux(struct dso *self, struct map *map,
1778                              const char *vmlinux, symbol_filter_t filter)
1779 {
1780         int err = -1, fd;
1781
1782         fd = open(vmlinux, O_RDONLY);
1783         if (fd < 0)
1784                 return -1;
1785
1786         dso__set_loaded(self, map->type);
1787         err = dso__load_sym(self, map, vmlinux, fd, filter, 0, 0);
1788         close(fd);
1789
1790         if (err > 0)
1791                 pr_debug("Using %s for symbols\n", vmlinux);
1792
1793         return err;
1794 }
1795
1796 int dso__load_vmlinux_path(struct dso *self, struct map *map,
1797                            symbol_filter_t filter)
1798 {
1799         int i, err = 0;
1800         char *filename;
1801
1802         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
1803                  vmlinux_path__nr_entries + 1);
1804
1805         filename = dso__build_id_filename(self, NULL, 0);
1806         if (filename != NULL) {
1807                 err = dso__load_vmlinux(self, map, filename, filter);
1808                 if (err > 0) {
1809                         dso__set_long_name(self, filename);
1810                         goto out;
1811                 }
1812                 free(filename);
1813         }
1814
1815         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
1816                 err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
1817                 if (err > 0) {
1818                         dso__set_long_name(self, strdup(vmlinux_path[i]));
1819                         break;
1820                 }
1821         }
1822 out:
1823         return err;
1824 }
1825
1826 static int dso__load_kernel_sym(struct dso *self, struct map *map,
1827                                 symbol_filter_t filter)
1828 {
1829         int err;
1830         const char *kallsyms_filename = NULL;
1831         char *kallsyms_allocated_filename = NULL;
1832         /*
1833          * Step 1: if the user specified a vmlinux filename, use it and only
1834          * it, reporting errors to the user if it cannot be used.
1835          *
1836          * For instance, try to analyse an ARM perf.data file _without_ a
1837          * build-id, or if the user specifies the wrong path to the right
1838          * vmlinux file, obviously we can't fallback to another vmlinux (a
1839          * x86_86 one, on the machine where analysis is being performed, say),
1840          * or worse, /proc/kallsyms.
1841          *
1842          * If the specified file _has_ a build-id and there is a build-id
1843          * section in the perf.data file, we will still do the expected
1844          * validation in dso__load_vmlinux and will bail out if they don't
1845          * match.
1846          */
1847         if (symbol_conf.vmlinux_name != NULL) {
1848                 err = dso__load_vmlinux(self, map,
1849                                         symbol_conf.vmlinux_name, filter);
1850                 if (err > 0) {
1851                         dso__set_long_name(self,
1852                                            strdup(symbol_conf.vmlinux_name));
1853                         goto out_fixup;
1854                 }
1855                 return err;
1856         }
1857
1858         if (vmlinux_path != NULL) {
1859                 err = dso__load_vmlinux_path(self, map, filter);
1860                 if (err > 0)
1861                         goto out_fixup;
1862         }
1863
1864         /*
1865          * Say the kernel DSO was created when processing the build-id header table,
1866          * we have a build-id, so check if it is the same as the running kernel,
1867          * using it if it is.
1868          */
1869         if (self->has_build_id) {
1870                 u8 kallsyms_build_id[BUILD_ID_SIZE];
1871                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1872
1873                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1874                                          sizeof(kallsyms_build_id)) == 0) {
1875                         if (dso__build_id_equal(self, kallsyms_build_id)) {
1876                                 kallsyms_filename = "/proc/kallsyms";
1877                                 goto do_kallsyms;
1878                         }
1879                 }
1880                 /*
1881                  * Now look if we have it on the build-id cache in
1882                  * $HOME/.debug/[kernel.kallsyms].
1883                  */
1884                 build_id__sprintf(self->build_id, sizeof(self->build_id),
1885                                   sbuild_id);
1886
1887                 if (asprintf(&kallsyms_allocated_filename,
1888                              "%s/.debug/[kernel.kallsyms]/%s",
1889                              getenv("HOME"), sbuild_id) == -1) {
1890                         pr_err("Not enough memory for kallsyms file lookup\n");
1891                         return -1;
1892                 }
1893
1894                 kallsyms_filename = kallsyms_allocated_filename;
1895
1896                 if (access(kallsyms_filename, F_OK)) {
1897                         pr_err("No kallsyms or vmlinux with build-id %s "
1898                                "was found\n", sbuild_id);
1899                         free(kallsyms_allocated_filename);
1900                         return -1;
1901                 }
1902         } else {
1903                 /*
1904                  * Last resort, if we don't have a build-id and couldn't find
1905                  * any vmlinux file, try the running kernel kallsyms table.
1906                  */
1907                 kallsyms_filename = "/proc/kallsyms";
1908         }
1909
1910 do_kallsyms:
1911         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1912         if (err > 0)
1913                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1914         free(kallsyms_allocated_filename);
1915
1916         if (err > 0) {
1917 out_fixup:
1918                 if (kallsyms_filename != NULL)
1919                         dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1920                 map__fixup_start(map);
1921                 map__fixup_end(map);
1922         }
1923
1924         return err;
1925 }
1926
1927 static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1928                                 symbol_filter_t filter)
1929 {
1930         int err;
1931         const char *kallsyms_filename = NULL;
1932         struct machine *machine;
1933         char path[PATH_MAX];
1934
1935         if (!map->groups) {
1936                 pr_debug("Guest kernel map hasn't the point to groups\n");
1937                 return -1;
1938         }
1939         machine = map->groups->machine;
1940
1941         if (machine__is_default_guest(machine)) {
1942                 /*
1943                  * if the user specified a vmlinux filename, use it and only
1944                  * it, reporting errors to the user if it cannot be used.
1945                  * Or use file guest_kallsyms inputted by user on commandline
1946                  */
1947                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1948                         err = dso__load_vmlinux(self, map,
1949                                 symbol_conf.default_guest_vmlinux_name, filter);
1950                         goto out_try_fixup;
1951                 }
1952
1953                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1954                 if (!kallsyms_filename)
1955                         return -1;
1956         } else {
1957                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1958                 kallsyms_filename = path;
1959         }
1960
1961         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1962         if (err > 0)
1963                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1964
1965 out_try_fixup:
1966         if (err > 0) {
1967                 if (kallsyms_filename != NULL) {
1968                         machine__mmap_name(machine, path, sizeof(path));
1969                         dso__set_long_name(self, strdup(path));
1970                 }
1971                 map__fixup_start(map);
1972                 map__fixup_end(map);
1973         }
1974
1975         return err;
1976 }
1977
1978 static void dsos__add(struct list_head *head, struct dso *dso)
1979 {
1980         list_add_tail(&dso->node, head);
1981 }
1982
1983 static struct dso *dsos__find(struct list_head *head, const char *name)
1984 {
1985         struct dso *pos;
1986
1987         list_for_each_entry(pos, head, node)
1988                 if (strcmp(pos->long_name, name) == 0)
1989                         return pos;
1990         return NULL;
1991 }
1992
1993 struct dso *__dsos__findnew(struct list_head *head, const char *name)
1994 {
1995         struct dso *dso = dsos__find(head, name);
1996
1997         if (!dso) {
1998                 dso = dso__new(name);
1999                 if (dso != NULL) {
2000                         dsos__add(head, dso);
2001                         dso__set_basename(dso);
2002                 }
2003         }
2004
2005         return dso;
2006 }
2007
2008 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2009 {
2010         struct dso *pos;
2011         size_t ret = 0;
2012
2013         list_for_each_entry(pos, head, node) {
2014                 int i;
2015                 for (i = 0; i < MAP__NR_TYPES; ++i)
2016                         ret += dso__fprintf(pos, i, fp);
2017         }
2018
2019         return ret;
2020 }
2021
2022 size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
2023 {
2024         struct rb_node *nd;
2025         size_t ret = 0;
2026
2027         for (nd = rb_first(self); nd; nd = rb_next(nd)) {
2028                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2029                 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2030                 ret += __dsos__fprintf(&pos->user_dsos, fp);
2031         }
2032
2033         return ret;
2034 }
2035
2036 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2037                                       bool with_hits)
2038 {
2039         struct dso *pos;
2040         size_t ret = 0;
2041
2042         list_for_each_entry(pos, head, node) {
2043                 if (with_hits && !pos->hit)
2044                         continue;
2045                 ret += dso__fprintf_buildid(pos, fp);
2046                 ret += fprintf(fp, " %s\n", pos->long_name);
2047         }
2048         return ret;
2049 }
2050
2051 size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits)
2052 {
2053         return __dsos__fprintf_buildid(&self->kernel_dsos, fp, with_hits) +
2054                __dsos__fprintf_buildid(&self->user_dsos, fp, with_hits);
2055 }
2056
2057 size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
2058 {
2059         struct rb_node *nd;
2060         size_t ret = 0;
2061
2062         for (nd = rb_first(self); nd; nd = rb_next(nd)) {
2063                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2064                 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2065         }
2066         return ret;
2067 }
2068
2069 struct dso *dso__new_kernel(const char *name)
2070 {
2071         struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
2072
2073         if (self != NULL) {
2074                 dso__set_short_name(self, "[kernel]");
2075                 self->kernel = DSO_TYPE_KERNEL;
2076         }
2077
2078         return self;
2079 }
2080
2081 static struct dso *dso__new_guest_kernel(struct machine *machine,
2082                                         const char *name)
2083 {
2084         char bf[PATH_MAX];
2085         struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
2086
2087         if (self != NULL) {
2088                 dso__set_short_name(self, "[guest.kernel]");
2089                 self->kernel = DSO_TYPE_GUEST_KERNEL;
2090         }
2091
2092         return self;
2093 }
2094
2095 void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
2096 {
2097         char path[PATH_MAX];
2098
2099         if (machine__is_default_guest(machine))
2100                 return;
2101         sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2102         if (sysfs__read_build_id(path, self->build_id,
2103                                  sizeof(self->build_id)) == 0)
2104                 self->has_build_id = true;
2105 }
2106
2107 static struct dso *machine__create_kernel(struct machine *self)
2108 {
2109         const char *vmlinux_name = NULL;
2110         struct dso *kernel;
2111
2112         if (machine__is_host(self)) {
2113                 vmlinux_name = symbol_conf.vmlinux_name;
2114                 kernel = dso__new_kernel(vmlinux_name);
2115         } else {
2116                 if (machine__is_default_guest(self))
2117                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2118                 kernel = dso__new_guest_kernel(self, vmlinux_name);
2119         }
2120
2121         if (kernel != NULL) {
2122                 dso__read_running_kernel_build_id(kernel, self);
2123                 dsos__add(&self->kernel_dsos, kernel);
2124         }
2125         return kernel;
2126 }
2127
2128 int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
2129 {
2130         enum map_type type;
2131
2132         for (type = 0; type < MAP__NR_TYPES; ++type) {
2133                 struct kmap *kmap;
2134
2135                 self->vmlinux_maps[type] = map__new2(0, kernel, type);
2136                 if (self->vmlinux_maps[type] == NULL)
2137                         return -1;
2138
2139                 self->vmlinux_maps[type]->map_ip =
2140                         self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
2141
2142                 kmap = map__kmap(self->vmlinux_maps[type]);
2143                 kmap->kmaps = &self->kmaps;
2144                 map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
2145         }
2146
2147         return 0;
2148 }
2149
2150 void machine__destroy_kernel_maps(struct machine *self)
2151 {
2152         enum map_type type;
2153
2154         for (type = 0; type < MAP__NR_TYPES; ++type) {
2155                 struct kmap *kmap;
2156
2157                 if (self->vmlinux_maps[type] == NULL)
2158                         continue;
2159
2160                 kmap = map__kmap(self->vmlinux_maps[type]);
2161                 map_groups__remove(&self->kmaps, self->vmlinux_maps[type]);
2162                 if (kmap->ref_reloc_sym) {
2163                         /*
2164                          * ref_reloc_sym is shared among all maps, so free just
2165                          * on one of them.
2166                          */
2167                         if (type == MAP__FUNCTION) {
2168                                 free((char *)kmap->ref_reloc_sym->name);
2169                                 kmap->ref_reloc_sym->name = NULL;
2170                                 free(kmap->ref_reloc_sym);
2171                         }
2172                         kmap->ref_reloc_sym = NULL;
2173                 }
2174
2175                 map__delete(self->vmlinux_maps[type]);
2176                 self->vmlinux_maps[type] = NULL;
2177         }
2178 }
2179
2180 int machine__create_kernel_maps(struct machine *self)
2181 {
2182         struct dso *kernel = machine__create_kernel(self);
2183
2184         if (kernel == NULL ||
2185             __machine__create_kernel_maps(self, kernel) < 0)
2186                 return -1;
2187
2188         if (symbol_conf.use_modules && machine__create_modules(self) < 0)
2189                 pr_debug("Problems creating module maps, continuing anyway...\n");
2190         /*
2191          * Now that we have all the maps created, just set the ->end of them:
2192          */
2193         map_groups__fixup_end(&self->kmaps);
2194         return 0;
2195 }
2196
2197 static void vmlinux_path__exit(void)
2198 {
2199         while (--vmlinux_path__nr_entries >= 0) {
2200                 free(vmlinux_path[vmlinux_path__nr_entries]);
2201                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2202         }
2203
2204         free(vmlinux_path);
2205         vmlinux_path = NULL;
2206 }
2207
2208 static int vmlinux_path__init(void)
2209 {
2210         struct utsname uts;
2211         char bf[PATH_MAX];
2212
2213         if (uname(&uts) < 0)
2214                 return -1;
2215
2216         vmlinux_path = malloc(sizeof(char *) * 5);
2217         if (vmlinux_path == NULL)
2218                 return -1;
2219
2220         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2221         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2222                 goto out_fail;
2223         ++vmlinux_path__nr_entries;
2224         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2225         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2226                 goto out_fail;
2227         ++vmlinux_path__nr_entries;
2228         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
2229         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2230         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2231                 goto out_fail;
2232         ++vmlinux_path__nr_entries;
2233         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
2234         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2235         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2236                 goto out_fail;
2237         ++vmlinux_path__nr_entries;
2238         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2239                  uts.release);
2240         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2241         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2242                 goto out_fail;
2243         ++vmlinux_path__nr_entries;
2244
2245         return 0;
2246
2247 out_fail:
2248         vmlinux_path__exit();
2249         return -1;
2250 }
2251
2252 size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp)
2253 {
2254         int i;
2255         size_t printed = 0;
2256         struct dso *kdso = self->vmlinux_maps[MAP__FUNCTION]->dso;
2257
2258         if (kdso->has_build_id) {
2259                 char filename[PATH_MAX];
2260                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2261                         printed += fprintf(fp, "[0] %s\n", filename);
2262         }
2263
2264         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2265                 printed += fprintf(fp, "[%d] %s\n",
2266                                    i + kdso->has_build_id, vmlinux_path[i]);
2267
2268         return printed;
2269 }
2270
2271 static int setup_list(struct strlist **list, const char *list_str,
2272                       const char *list_name)
2273 {
2274         if (list_str == NULL)
2275                 return 0;
2276
2277         *list = strlist__new(true, list_str);
2278         if (!*list) {
2279                 pr_err("problems parsing %s list\n", list_name);
2280                 return -1;
2281         }
2282         return 0;
2283 }
2284
2285 int symbol__init(void)
2286 {
2287         if (symbol_conf.initialized)
2288                 return 0;
2289
2290         elf_version(EV_CURRENT);
2291         if (symbol_conf.sort_by_name)
2292                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2293                                           sizeof(struct symbol));
2294
2295         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2296                 return -1;
2297
2298         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2299                 pr_err("'.' is the only non valid --field-separator argument\n");
2300                 return -1;
2301         }
2302
2303         if (setup_list(&symbol_conf.dso_list,
2304                        symbol_conf.dso_list_str, "dso") < 0)
2305                 return -1;
2306
2307         if (setup_list(&symbol_conf.comm_list,
2308                        symbol_conf.comm_list_str, "comm") < 0)
2309                 goto out_free_dso_list;
2310
2311         if (setup_list(&symbol_conf.sym_list,
2312                        symbol_conf.sym_list_str, "symbol") < 0)
2313                 goto out_free_comm_list;
2314
2315         symbol_conf.initialized = true;
2316         return 0;
2317
2318 out_free_dso_list:
2319         strlist__delete(symbol_conf.dso_list);
2320 out_free_comm_list:
2321         strlist__delete(symbol_conf.comm_list);
2322         return -1;
2323 }
2324
2325 void symbol__exit(void)
2326 {
2327         if (!symbol_conf.initialized)
2328                 return;
2329         strlist__delete(symbol_conf.sym_list);
2330         strlist__delete(symbol_conf.dso_list);
2331         strlist__delete(symbol_conf.comm_list);
2332         vmlinux_path__exit();
2333         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2334         symbol_conf.initialized = false;
2335 }
2336
2337 int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
2338 {
2339         struct machine *machine = machines__findnew(self, pid);
2340
2341         if (machine == NULL)
2342                 return -1;
2343
2344         return machine__create_kernel_maps(machine);
2345 }
2346
2347 static int hex(char ch)
2348 {
2349         if ((ch >= '0') && (ch <= '9'))
2350                 return ch - '0';
2351         if ((ch >= 'a') && (ch <= 'f'))
2352                 return ch - 'a' + 10;
2353         if ((ch >= 'A') && (ch <= 'F'))
2354                 return ch - 'A' + 10;
2355         return -1;
2356 }
2357
2358 /*
2359  * While we find nice hex chars, build a long_val.
2360  * Return number of chars processed.
2361  */
2362 int hex2u64(const char *ptr, u64 *long_val)
2363 {
2364         const char *p = ptr;
2365         *long_val = 0;
2366
2367         while (*p) {
2368                 const int hex_val = hex(*p);
2369
2370                 if (hex_val < 0)
2371                         break;
2372
2373                 *long_val = (*long_val << 4) | hex_val;
2374                 p++;
2375         }
2376
2377         return p - ptr;
2378 }
2379
2380 char *strxfrchar(char *s, char from, char to)
2381 {
2382         char *p = s;
2383
2384         while ((p = strchr(p, from)) != NULL)
2385                 *p++ = to;
2386
2387         return s;
2388 }
2389
2390 int machines__create_guest_kernel_maps(struct rb_root *self)
2391 {
2392         int ret = 0;
2393         struct dirent **namelist = NULL;
2394         int i, items = 0;
2395         char path[PATH_MAX];
2396         pid_t pid;
2397
2398         if (symbol_conf.default_guest_vmlinux_name ||
2399             symbol_conf.default_guest_modules ||
2400             symbol_conf.default_guest_kallsyms) {
2401                 machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
2402         }
2403
2404         if (symbol_conf.guestmount) {
2405                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2406                 if (items <= 0)
2407                         return -ENOENT;
2408                 for (i = 0; i < items; i++) {
2409                         if (!isdigit(namelist[i]->d_name[0])) {
2410                                 /* Filter out . and .. */
2411                                 continue;
2412                         }
2413                         pid = atoi(namelist[i]->d_name);
2414                         sprintf(path, "%s/%s/proc/kallsyms",
2415                                 symbol_conf.guestmount,
2416                                 namelist[i]->d_name);
2417                         ret = access(path, R_OK);
2418                         if (ret) {
2419                                 pr_debug("Can't access file %s\n", path);
2420                                 goto failure;
2421                         }
2422                         machines__create_kernel_maps(self, pid);
2423                 }
2424 failure:
2425                 free(namelist);
2426         }
2427
2428         return ret;
2429 }
2430
2431 void machines__destroy_guest_kernel_maps(struct rb_root *self)
2432 {
2433         struct rb_node *next = rb_first(self);
2434
2435         while (next) {
2436                 struct machine *pos = rb_entry(next, struct machine, rb_node);
2437
2438                 next = rb_next(&pos->rb_node);
2439                 rb_erase(&pos->rb_node, self);
2440                 machine__delete(pos);
2441         }
2442 }
2443
2444 int machine__load_kallsyms(struct machine *self, const char *filename,
2445                            enum map_type type, symbol_filter_t filter)
2446 {
2447         struct map *map = self->vmlinux_maps[type];
2448         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2449
2450         if (ret > 0) {
2451                 dso__set_loaded(map->dso, type);
2452                 /*
2453                  * Since /proc/kallsyms will have multiple sessions for the
2454                  * kernel, with modules between them, fixup the end of all
2455                  * sections.
2456                  */
2457                 __map_groups__fixup_end(&self->kmaps, type);
2458         }
2459
2460         return ret;
2461 }
2462
2463 int machine__load_vmlinux_path(struct machine *self, enum map_type type,
2464                                symbol_filter_t filter)
2465 {
2466         struct map *map = self->vmlinux_maps[type];
2467         int ret = dso__load_vmlinux_path(map->dso, map, filter);
2468
2469         if (ret > 0) {
2470                 dso__set_loaded(map->dso, type);
2471                 map__reloc_vmlinux(map);
2472         }
2473
2474         return ret;
2475 }