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 = ~0ULL;
 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 static 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 kallsyms or vmlinux filename, use
1840          * it and only 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.kallsyms_name != NULL) {
1854                 kallsyms_filename = symbol_conf.kallsyms_name;
1855                 goto do_kallsyms;
1856         }
1857
1858         if (symbol_conf.vmlinux_name != NULL) {
1859                 err = dso__load_vmlinux(self, map,
1860                                         symbol_conf.vmlinux_name, filter);
1861                 if (err > 0) {
1862                         dso__set_long_name(self,
1863                                            strdup(symbol_conf.vmlinux_name));
1864                         goto out_fixup;
1865                 }
1866                 return err;
1867         }
1868
1869         if (vmlinux_path != NULL) {
1870                 err = dso__load_vmlinux_path(self, map, filter);
1871                 if (err > 0)
1872                         goto out_fixup;
1873         }
1874
1875         /*
1876          * Say the kernel DSO was created when processing the build-id header table,
1877          * we have a build-id, so check if it is the same as the running kernel,
1878          * using it if it is.
1879          */
1880         if (self->has_build_id) {
1881                 u8 kallsyms_build_id[BUILD_ID_SIZE];
1882                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1883
1884                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1885                                          sizeof(kallsyms_build_id)) == 0) {
1886                         if (dso__build_id_equal(self, kallsyms_build_id)) {
1887                                 kallsyms_filename = "/proc/kallsyms";
1888                                 goto do_kallsyms;
1889                         }
1890                 }
1891                 /*
1892                  * Now look if we have it on the build-id cache in
1893                  * $HOME/.debug/[kernel.kallsyms].
1894                  */
1895                 build_id__sprintf(self->build_id, sizeof(self->build_id),
1896                                   sbuild_id);
1897
1898                 if (asprintf(&kallsyms_allocated_filename,
1899                              "%s/.debug/[kernel.kallsyms]/%s",
1900                              getenv("HOME"), sbuild_id) == -1) {
1901                         pr_err("Not enough memory for kallsyms file lookup\n");
1902                         return -1;
1903                 }
1904
1905                 kallsyms_filename = kallsyms_allocated_filename;
1906
1907                 if (access(kallsyms_filename, F_OK)) {
1908                         pr_err("No kallsyms or vmlinux with build-id %s "
1909                                "was found\n", sbuild_id);
1910                         free(kallsyms_allocated_filename);
1911                         return -1;
1912                 }
1913         } else {
1914                 /*
1915                  * Last resort, if we don't have a build-id and couldn't find
1916                  * any vmlinux file, try the running kernel kallsyms table.
1917                  */
1918                 kallsyms_filename = "/proc/kallsyms";
1919         }
1920
1921 do_kallsyms:
1922         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1923         if (err > 0)
1924                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1925         free(kallsyms_allocated_filename);
1926
1927         if (err > 0) {
1928 out_fixup:
1929                 if (kallsyms_filename != NULL)
1930                         dso__set_long_name(self, strdup("[kernel.kallsyms]"));
1931                 map__fixup_start(map);
1932                 map__fixup_end(map);
1933         }
1934
1935         return err;
1936 }
1937
1938 static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
1939                                 symbol_filter_t filter)
1940 {
1941         int err;
1942         const char *kallsyms_filename = NULL;
1943         struct machine *machine;
1944         char path[PATH_MAX];
1945
1946         if (!map->groups) {
1947                 pr_debug("Guest kernel map hasn't the point to groups\n");
1948                 return -1;
1949         }
1950         machine = map->groups->machine;
1951
1952         if (machine__is_default_guest(machine)) {
1953                 /*
1954                  * if the user specified a vmlinux filename, use it and only
1955                  * it, reporting errors to the user if it cannot be used.
1956                  * Or use file guest_kallsyms inputted by user on commandline
1957                  */
1958                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1959                         err = dso__load_vmlinux(self, map,
1960                                 symbol_conf.default_guest_vmlinux_name, filter);
1961                         goto out_try_fixup;
1962                 }
1963
1964                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1965                 if (!kallsyms_filename)
1966                         return -1;
1967         } else {
1968                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1969                 kallsyms_filename = path;
1970         }
1971
1972         err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
1973         if (err > 0)
1974                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1975
1976 out_try_fixup:
1977         if (err > 0) {
1978                 if (kallsyms_filename != NULL) {
1979                         machine__mmap_name(machine, path, sizeof(path));
1980                         dso__set_long_name(self, strdup(path));
1981                 }
1982                 map__fixup_start(map);
1983                 map__fixup_end(map);
1984         }
1985
1986         return err;
1987 }
1988
1989 static void dsos__add(struct list_head *head, struct dso *dso)
1990 {
1991         list_add_tail(&dso->node, head);
1992 }
1993
1994 static struct dso *dsos__find(struct list_head *head, const char *name)
1995 {
1996         struct dso *pos;
1997
1998         list_for_each_entry(pos, head, node)
1999                 if (strcmp(pos->long_name, name) == 0)
2000                         return pos;
2001         return NULL;
2002 }
2003
2004 struct dso *__dsos__findnew(struct list_head *head, const char *name)
2005 {
2006         struct dso *dso = dsos__find(head, name);
2007
2008         if (!dso) {
2009                 dso = dso__new(name);
2010                 if (dso != NULL) {
2011                         dsos__add(head, dso);
2012                         dso__set_basename(dso);
2013                 }
2014         }
2015
2016         return dso;
2017 }
2018
2019 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
2020 {
2021         struct dso *pos;
2022         size_t ret = 0;
2023
2024         list_for_each_entry(pos, head, node) {
2025                 int i;
2026                 for (i = 0; i < MAP__NR_TYPES; ++i)
2027                         ret += dso__fprintf(pos, i, fp);
2028         }
2029
2030         return ret;
2031 }
2032
2033 size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
2034 {
2035         struct rb_node *nd;
2036         size_t ret = 0;
2037
2038         for (nd = rb_first(self); nd; nd = rb_next(nd)) {
2039                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2040                 ret += __dsos__fprintf(&pos->kernel_dsos, fp);
2041                 ret += __dsos__fprintf(&pos->user_dsos, fp);
2042         }
2043
2044         return ret;
2045 }
2046
2047 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
2048                                       bool with_hits)
2049 {
2050         struct dso *pos;
2051         size_t ret = 0;
2052
2053         list_for_each_entry(pos, head, node) {
2054                 if (with_hits && !pos->hit)
2055                         continue;
2056                 ret += dso__fprintf_buildid(pos, fp);
2057                 ret += fprintf(fp, " %s\n", pos->long_name);
2058         }
2059         return ret;
2060 }
2061
2062 size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits)
2063 {
2064         return __dsos__fprintf_buildid(&self->kernel_dsos, fp, with_hits) +
2065                __dsos__fprintf_buildid(&self->user_dsos, fp, with_hits);
2066 }
2067
2068 size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
2069 {
2070         struct rb_node *nd;
2071         size_t ret = 0;
2072
2073         for (nd = rb_first(self); nd; nd = rb_next(nd)) {
2074                 struct machine *pos = rb_entry(nd, struct machine, rb_node);
2075                 ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
2076         }
2077         return ret;
2078 }
2079
2080 struct dso *dso__new_kernel(const char *name)
2081 {
2082         struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
2083
2084         if (self != NULL) {
2085                 dso__set_short_name(self, "[kernel]");
2086                 self->kernel = DSO_TYPE_KERNEL;
2087         }
2088
2089         return self;
2090 }
2091
2092 static struct dso *dso__new_guest_kernel(struct machine *machine,
2093                                         const char *name)
2094 {
2095         char bf[PATH_MAX];
2096         struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
2097
2098         if (self != NULL) {
2099                 dso__set_short_name(self, "[guest.kernel]");
2100                 self->kernel = DSO_TYPE_GUEST_KERNEL;
2101         }
2102
2103         return self;
2104 }
2105
2106 void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
2107 {
2108         char path[PATH_MAX];
2109
2110         if (machine__is_default_guest(machine))
2111                 return;
2112         sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
2113         if (sysfs__read_build_id(path, self->build_id,
2114                                  sizeof(self->build_id)) == 0)
2115                 self->has_build_id = true;
2116 }
2117
2118 static struct dso *machine__create_kernel(struct machine *self)
2119 {
2120         const char *vmlinux_name = NULL;
2121         struct dso *kernel;
2122
2123         if (machine__is_host(self)) {
2124                 vmlinux_name = symbol_conf.vmlinux_name;
2125                 kernel = dso__new_kernel(vmlinux_name);
2126         } else {
2127                 if (machine__is_default_guest(self))
2128                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
2129                 kernel = dso__new_guest_kernel(self, vmlinux_name);
2130         }
2131
2132         if (kernel != NULL) {
2133                 dso__read_running_kernel_build_id(kernel, self);
2134                 dsos__add(&self->kernel_dsos, kernel);
2135         }
2136         return kernel;
2137 }
2138
2139 struct process_args {
2140         u64 start;
2141 };
2142
2143 static int symbol__in_kernel(void *arg, const char *name,
2144                              char type __used, u64 start)
2145 {
2146         struct process_args *args = arg;
2147
2148         if (strchr(name, '['))
2149                 return 0;
2150
2151         args->start = start;
2152         return 1;
2153 }
2154
2155 /* Figure out the start address of kernel map from /proc/kallsyms */
2156 static u64 machine__get_kernel_start_addr(struct machine *machine)
2157 {
2158         const char *filename;
2159         char path[PATH_MAX];
2160         struct process_args args;
2161
2162         if (machine__is_host(machine)) {
2163                 filename = "/proc/kallsyms";
2164         } else {
2165                 if (machine__is_default_guest(machine))
2166                         filename = (char *)symbol_conf.default_guest_kallsyms;
2167                 else {
2168                         sprintf(path, "%s/proc/kallsyms", machine->root_dir);
2169                         filename = path;
2170                 }
2171         }
2172
2173         if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
2174                 return 0;
2175
2176         return args.start;
2177 }
2178
2179 int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
2180 {
2181         enum map_type type;
2182         u64 start = machine__get_kernel_start_addr(self);
2183
2184         for (type = 0; type < MAP__NR_TYPES; ++type) {
2185                 struct kmap *kmap;
2186
2187                 self->vmlinux_maps[type] = map__new2(start, kernel, type);
2188                 if (self->vmlinux_maps[type] == NULL)
2189                         return -1;
2190
2191                 self->vmlinux_maps[type]->map_ip =
2192                         self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
2193
2194                 kmap = map__kmap(self->vmlinux_maps[type]);
2195                 kmap->kmaps = &self->kmaps;
2196                 map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
2197         }
2198
2199         return 0;
2200 }
2201
2202 void machine__destroy_kernel_maps(struct machine *self)
2203 {
2204         enum map_type type;
2205
2206         for (type = 0; type < MAP__NR_TYPES; ++type) {
2207                 struct kmap *kmap;
2208
2209                 if (self->vmlinux_maps[type] == NULL)
2210                         continue;
2211
2212                 kmap = map__kmap(self->vmlinux_maps[type]);
2213                 map_groups__remove(&self->kmaps, self->vmlinux_maps[type]);
2214                 if (kmap->ref_reloc_sym) {
2215                         /*
2216                          * ref_reloc_sym is shared among all maps, so free just
2217                          * on one of them.
2218                          */
2219                         if (type == MAP__FUNCTION) {
2220                                 free((char *)kmap->ref_reloc_sym->name);
2221                                 kmap->ref_reloc_sym->name = NULL;
2222                                 free(kmap->ref_reloc_sym);
2223                         }
2224                         kmap->ref_reloc_sym = NULL;
2225                 }
2226
2227                 map__delete(self->vmlinux_maps[type]);
2228                 self->vmlinux_maps[type] = NULL;
2229         }
2230 }
2231
2232 int machine__create_kernel_maps(struct machine *self)
2233 {
2234         struct dso *kernel = machine__create_kernel(self);
2235
2236         if (kernel == NULL ||
2237             __machine__create_kernel_maps(self, kernel) < 0)
2238                 return -1;
2239
2240         if (symbol_conf.use_modules && machine__create_modules(self) < 0)
2241                 pr_debug("Problems creating module maps, continuing anyway...\n");
2242         /*
2243          * Now that we have all the maps created, just set the ->end of them:
2244          */
2245         map_groups__fixup_end(&self->kmaps);
2246         return 0;
2247 }
2248
2249 static void vmlinux_path__exit(void)
2250 {
2251         while (--vmlinux_path__nr_entries >= 0) {
2252                 free(vmlinux_path[vmlinux_path__nr_entries]);
2253                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
2254         }
2255
2256         free(vmlinux_path);
2257         vmlinux_path = NULL;
2258 }
2259
2260 static int vmlinux_path__init(void)
2261 {
2262         struct utsname uts;
2263         char bf[PATH_MAX];
2264
2265         if (uname(&uts) < 0)
2266                 return -1;
2267
2268         vmlinux_path = malloc(sizeof(char *) * 5);
2269         if (vmlinux_path == NULL)
2270                 return -1;
2271
2272         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
2273         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2274                 goto out_fail;
2275         ++vmlinux_path__nr_entries;
2276         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
2277         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2278                 goto out_fail;
2279         ++vmlinux_path__nr_entries;
2280         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", 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), "/lib/modules/%s/build/vmlinux", uts.release);
2286         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2287         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2288                 goto out_fail;
2289         ++vmlinux_path__nr_entries;
2290         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
2291                  uts.release);
2292         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
2293         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
2294                 goto out_fail;
2295         ++vmlinux_path__nr_entries;
2296
2297         return 0;
2298
2299 out_fail:
2300         vmlinux_path__exit();
2301         return -1;
2302 }
2303
2304 size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp)
2305 {
2306         int i;
2307         size_t printed = 0;
2308         struct dso *kdso = self->vmlinux_maps[MAP__FUNCTION]->dso;
2309
2310         if (kdso->has_build_id) {
2311                 char filename[PATH_MAX];
2312                 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
2313                         printed += fprintf(fp, "[0] %s\n", filename);
2314         }
2315
2316         for (i = 0; i < vmlinux_path__nr_entries; ++i)
2317                 printed += fprintf(fp, "[%d] %s\n",
2318                                    i + kdso->has_build_id, vmlinux_path[i]);
2319
2320         return printed;
2321 }
2322
2323 static int setup_list(struct strlist **list, const char *list_str,
2324                       const char *list_name)
2325 {
2326         if (list_str == NULL)
2327                 return 0;
2328
2329         *list = strlist__new(true, list_str);
2330         if (!*list) {
2331                 pr_err("problems parsing %s list\n", list_name);
2332                 return -1;
2333         }
2334         return 0;
2335 }
2336
2337 int symbol__init(void)
2338 {
2339         if (symbol_conf.initialized)
2340                 return 0;
2341
2342         elf_version(EV_CURRENT);
2343         if (symbol_conf.sort_by_name)
2344                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
2345                                           sizeof(struct symbol));
2346
2347         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
2348                 return -1;
2349
2350         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
2351                 pr_err("'.' is the only non valid --field-separator argument\n");
2352                 return -1;
2353         }
2354
2355         if (setup_list(&symbol_conf.dso_list,
2356                        symbol_conf.dso_list_str, "dso") < 0)
2357                 return -1;
2358
2359         if (setup_list(&symbol_conf.comm_list,
2360                        symbol_conf.comm_list_str, "comm") < 0)
2361                 goto out_free_dso_list;
2362
2363         if (setup_list(&symbol_conf.sym_list,
2364                        symbol_conf.sym_list_str, "symbol") < 0)
2365                 goto out_free_comm_list;
2366
2367         symbol_conf.initialized = true;
2368         return 0;
2369
2370 out_free_dso_list:
2371         strlist__delete(symbol_conf.dso_list);
2372 out_free_comm_list:
2373         strlist__delete(symbol_conf.comm_list);
2374         return -1;
2375 }
2376
2377 void symbol__exit(void)
2378 {
2379         if (!symbol_conf.initialized)
2380                 return;
2381         strlist__delete(symbol_conf.sym_list);
2382         strlist__delete(symbol_conf.dso_list);
2383         strlist__delete(symbol_conf.comm_list);
2384         vmlinux_path__exit();
2385         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
2386         symbol_conf.initialized = false;
2387 }
2388
2389 int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
2390 {
2391         struct machine *machine = machines__findnew(self, pid);
2392
2393         if (machine == NULL)
2394                 return -1;
2395
2396         return machine__create_kernel_maps(machine);
2397 }
2398
2399 static int hex(char ch)
2400 {
2401         if ((ch >= '0') && (ch <= '9'))
2402                 return ch - '0';
2403         if ((ch >= 'a') && (ch <= 'f'))
2404                 return ch - 'a' + 10;
2405         if ((ch >= 'A') && (ch <= 'F'))
2406                 return ch - 'A' + 10;
2407         return -1;
2408 }
2409
2410 /*
2411  * While we find nice hex chars, build a long_val.
2412  * Return number of chars processed.
2413  */
2414 int hex2u64(const char *ptr, u64 *long_val)
2415 {
2416         const char *p = ptr;
2417         *long_val = 0;
2418
2419         while (*p) {
2420                 const int hex_val = hex(*p);
2421
2422                 if (hex_val < 0)
2423                         break;
2424
2425                 *long_val = (*long_val << 4) | hex_val;
2426                 p++;
2427         }
2428
2429         return p - ptr;
2430 }
2431
2432 char *strxfrchar(char *s, char from, char to)
2433 {
2434         char *p = s;
2435
2436         while ((p = strchr(p, from)) != NULL)
2437                 *p++ = to;
2438
2439         return s;
2440 }
2441
2442 int machines__create_guest_kernel_maps(struct rb_root *self)
2443 {
2444         int ret = 0;
2445         struct dirent **namelist = NULL;
2446         int i, items = 0;
2447         char path[PATH_MAX];
2448         pid_t pid;
2449
2450         if (symbol_conf.default_guest_vmlinux_name ||
2451             symbol_conf.default_guest_modules ||
2452             symbol_conf.default_guest_kallsyms) {
2453                 machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
2454         }
2455
2456         if (symbol_conf.guestmount) {
2457                 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
2458                 if (items <= 0)
2459                         return -ENOENT;
2460                 for (i = 0; i < items; i++) {
2461                         if (!isdigit(namelist[i]->d_name[0])) {
2462                                 /* Filter out . and .. */
2463                                 continue;
2464                         }
2465                         pid = atoi(namelist[i]->d_name);
2466                         sprintf(path, "%s/%s/proc/kallsyms",
2467                                 symbol_conf.guestmount,
2468                                 namelist[i]->d_name);
2469                         ret = access(path, R_OK);
2470                         if (ret) {
2471                                 pr_debug("Can't access file %s\n", path);
2472                                 goto failure;
2473                         }
2474                         machines__create_kernel_maps(self, pid);
2475                 }
2476 failure:
2477                 free(namelist);
2478         }
2479
2480         return ret;
2481 }
2482
2483 void machines__destroy_guest_kernel_maps(struct rb_root *self)
2484 {
2485         struct rb_node *next = rb_first(self);
2486
2487         while (next) {
2488                 struct machine *pos = rb_entry(next, struct machine, rb_node);
2489
2490                 next = rb_next(&pos->rb_node);
2491                 rb_erase(&pos->rb_node, self);
2492                 machine__delete(pos);
2493         }
2494 }
2495
2496 int machine__load_kallsyms(struct machine *self, const char *filename,
2497                            enum map_type type, symbol_filter_t filter)
2498 {
2499         struct map *map = self->vmlinux_maps[type];
2500         int ret = dso__load_kallsyms(map->dso, filename, map, filter);
2501
2502         if (ret > 0) {
2503                 dso__set_loaded(map->dso, type);
2504                 /*
2505                  * Since /proc/kallsyms will have multiple sessions for the
2506                  * kernel, with modules between them, fixup the end of all
2507                  * sections.
2508                  */
2509                 __map_groups__fixup_end(&self->kmaps, type);
2510         }
2511
2512         return ret;
2513 }
2514
2515 int machine__load_vmlinux_path(struct machine *self, enum map_type type,
2516                                symbol_filter_t filter)
2517 {
2518         struct map *map = self->vmlinux_maps[type];
2519         int ret = dso__load_vmlinux_path(map->dso, map, filter);
2520
2521         if (ret > 0) {
2522                 dso__set_loaded(map->dso, type);
2523                 map__reloc_vmlinux(map);
2524         }
2525
2526         return ret;
2527 }