tools/perf/util/symbol.c

   1 #include <dirent.h>
   2 #include <errno.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <sys/param.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <inttypes.h>
  12 #include "build-id.h"
  13 #include "util.h"
  14 #include "debug.h"
  15 #include "machine.h"
  16 #include "symbol.h"
  17 #include "strlist.h"
  18
  19 #include <elf.h>
  20 #include <limits.h>
  21 #include <sys/utsname.h>
  22
  23 #ifndef KSYM_NAME_LEN
  24 #define KSYM_NAME_LEN 256
  25 #endif
  26
  27 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
  28                                 symbol_filter_t filter);
  29 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
  30                         symbol_filter_t filter);
  31 int vmlinux_path__nr_entries;
  32 char **vmlinux_path;
  33
  34 struct symbol_conf symbol_conf = {
  35         .exclude_other    = true,
  36         .use_modules      = true,
  37         .try_vmlinux_path = true,
  38         .annotate_src     = true,
  39         .demangle         = true,
  40         .symfs            = "",
  41 };
  42
  43 static enum dso_binary_type binary_type_symtab[] = {
  44         DSO_BINARY_TYPE__KALLSYMS,
  45         DSO_BINARY_TYPE__GUEST_KALLSYMS,
  46         DSO_BINARY_TYPE__JAVA_JIT,
  47         DSO_BINARY_TYPE__DEBUGLINK,
  48         DSO_BINARY_TYPE__BUILD_ID_CACHE,
  49         DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
  50         DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
  51         DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
  52         DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
  53         DSO_BINARY_TYPE__GUEST_KMODULE,
  54         DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
  55         DSO_BINARY_TYPE__NOT_FOUND,
  56 };
  57
  58 #define DSO_BINARY_TYPE__SYMTAB_CNT ARRAY_SIZE(binary_type_symtab)
  59
  60 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
  61 {
  62         symbol_type = toupper(symbol_type);
  63
  64         switch (map_type) {
  65         case MAP__FUNCTION:
  66                 return symbol_type == 'T' || symbol_type == 'W';
  67         case MAP__VARIABLE:
  68                 return symbol_type == 'D';
  69         default:
  70                 return false;
  71         }
  72 }
  73
  74 static int prefix_underscores_count(const char *str)
  75 {
  76         const char *tail = str;
  77
  78         while (*tail == '_')
  79                 tail++;
  80
  81         return tail - str;
  82 }
  83
  84 #define SYMBOL_A 0
  85 #define SYMBOL_B 1
  86
  87 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
  88 {
  89         s64 a;
  90         s64 b;
  91
  92         /* Prefer a symbol with non zero length */
  93         a = syma->end - syma->start;
  94         b = symb->end - symb->start;
  95         if ((b == 0) && (a > 0))
  96                 return SYMBOL_A;
  97         else if ((a == 0) && (b > 0))
  98                 return SYMBOL_B;
  99
 100         /* Prefer a non weak symbol over a weak one */
 101         a = syma->binding == STB_WEAK;
 102         b = symb->binding == STB_WEAK;
 103         if (b && !a)
 104                 return SYMBOL_A;
 105         if (a && !b)
 106                 return SYMBOL_B;
 107
 108         /* Prefer a global symbol over a non global one */
 109         a = syma->binding == STB_GLOBAL;
 110         b = symb->binding == STB_GLOBAL;
 111         if (a && !b)
 112                 return SYMBOL_A;
 113         if (b && !a)
 114                 return SYMBOL_B;
 115
 116         /* Prefer a symbol with less underscores */
 117         a = prefix_underscores_count(syma->name);
 118         b = prefix_underscores_count(symb->name);
 119         if (b > a)
 120                 return SYMBOL_A;
 121         else if (a > b)
 122                 return SYMBOL_B;
 123
 124         /* If all else fails, choose the symbol with the longest name */
 125         if (strlen(syma->name) >= strlen(symb->name))
 126                 return SYMBOL_A;
 127         else
 128                 return SYMBOL_B;
 129 }
 130
 131 void symbols__fixup_duplicate(struct rb_root *symbols)
 132 {
 133         struct rb_node *nd;
 134         struct symbol *curr, *next;
 135
 136         nd = rb_first(symbols);
 137
 138         while (nd) {
 139                 curr = rb_entry(nd, struct symbol, rb_node);
 140 again:
 141                 nd = rb_next(&curr->rb_node);
 142                 next = rb_entry(nd, struct symbol, rb_node);
 143
 144                 if (!nd)
 145                         break;
 146
 147                 if (curr->start != next->start)
 148                         continue;
 149
 150                 if (choose_best_symbol(curr, next) == SYMBOL_A) {
 151                         rb_erase(&next->rb_node, symbols);
 152                         goto again;
 153                 } else {
 154                         nd = rb_next(&curr->rb_node);
 155                         rb_erase(&curr->rb_node, symbols);
 156                 }
 157         }
 158 }
 159
 160 void symbols__fixup_end(struct rb_root *symbols)
 161 {
 162         struct rb_node *nd, *prevnd = rb_first(symbols);
 163         struct symbol *curr, *prev;
 164
 165         if (prevnd == NULL)
 166                 return;
 167
 168         curr = rb_entry(prevnd, struct symbol, rb_node);
 169
 170         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 171                 prev = curr;
 172                 curr = rb_entry(nd, struct symbol, rb_node);
 173
 174                 if (prev->end == prev->start && prev->end != curr->start)
 175                         prev->end = curr->start - 1;
 176         }
 177
 178         /* Last entry */
 179         if (curr->end == curr->start)
 180                 curr->end = roundup(curr->start, 4096);
 181 }
 182
 183 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 184 {
 185         struct map *prev, *curr;
 186         struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 187
 188         if (prevnd == NULL)
 189                 return;
 190
 191         curr = rb_entry(prevnd, struct map, rb_node);
 192
 193         for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 194                 prev = curr;
 195                 curr = rb_entry(nd, struct map, rb_node);
 196                 prev->end = curr->start - 1;
 197         }
 198
 199         /*
 200          * We still haven't the actual symbols, so guess the
 201          * last map final address.
 202          */
 203         curr->end = ~0ULL;
 204 }
 205
 206 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
 207 {
 208         size_t namelen = strlen(name) + 1;
 209         struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 210                                         sizeof(*sym) + namelen));
 211         if (sym == NULL)
 212                 return NULL;
 213
 214         if (symbol_conf.priv_size)
 215                 sym = ((void *)sym) + symbol_conf.priv_size;
 216
 217         sym->start   = start;
 218         sym->end     = len ? start + len - 1 : start;
 219         sym->binding = binding;
 220         sym->namelen = namelen - 1;
 221
 222         pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 223                   __func__, name, start, sym->end);
 224         memcpy(sym->name, name, namelen);
 225
 226         return sym;
 227 }
 228
 229 void symbol__delete(struct symbol *sym)
 230 {
 231         free(((void *)sym) - symbol_conf.priv_size);
 232 }
 233
 234 size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 235 {
 236         return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 237                        sym->start, sym->end,
 238                        sym->binding == STB_GLOBAL ? 'g' :
 239                        sym->binding == STB_LOCAL  ? 'l' : 'w',
 240                        sym->name);
 241 }
 242
 243 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
 244                                     const struct addr_location *al, FILE *fp)
 245 {
 246         unsigned long offset;
 247         size_t length;
 248
 249         if (sym && sym->name) {
 250                 length = fprintf(fp, "%s", sym->name);
 251                 if (al) {
 252                         offset = al->addr - sym->start;
 253                         length += fprintf(fp, "+0x%lx", offset);
 254                 }
 255                 return length;
 256         } else
 257                 return fprintf(fp, "[unknown]");
 258 }
 259
 260 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
 261 {
 262         return symbol__fprintf_symname_offs(sym, NULL, fp);
 263 }
 264
 265 void symbols__delete(struct rb_root *symbols)
 266 {
 267         struct symbol *pos;
 268         struct rb_node *next = rb_first(symbols);
 269
 270         while (next) {
 271                 pos = rb_entry(next, struct symbol, rb_node);
 272                 next = rb_next(&pos->rb_node);
 273                 rb_erase(&pos->rb_node, symbols);
 274                 symbol__delete(pos);
 275         }
 276 }
 277
 278 void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 279 {
 280         struct rb_node **p = &symbols->rb_node;
 281         struct rb_node *parent = NULL;
 282         const u64 ip = sym->start;
 283         struct symbol *s;
 284
 285         while (*p != NULL) {
 286                 parent = *p;
 287                 s = rb_entry(parent, struct symbol, rb_node);
 288                 if (ip < s->start)
 289                         p = &(*p)->rb_left;
 290                 else
 291                         p = &(*p)->rb_right;
 292         }
 293         rb_link_node(&sym->rb_node, parent, p);
 294         rb_insert_color(&sym->rb_node, symbols);
 295 }
 296
 297 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 298 {
 299         struct rb_node *n;
 300
 301         if (symbols == NULL)
 302                 return NULL;
 303
 304         n = symbols->rb_node;
 305
 306         while (n) {
 307                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
 308
 309                 if (ip < s->start)
 310                         n = n->rb_left;
 311                 else if (ip > s->end)
 312                         n = n->rb_right;
 313                 else
 314                         return s;
 315         }
 316
 317         return NULL;
 318 }
 319
 320 struct symbol_name_rb_node {
 321         struct rb_node  rb_node;
 322         struct symbol   sym;
 323 };
 324
 325 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 326 {
 327         struct rb_node **p = &symbols->rb_node;
 328         struct rb_node *parent = NULL;
 329         struct symbol_name_rb_node *symn, *s;
 330
 331         symn = container_of(sym, struct symbol_name_rb_node, sym);
 332
 333         while (*p != NULL) {
 334                 parent = *p;
 335                 s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 336                 if (strcmp(sym->name, s->sym.name) < 0)
 337                         p = &(*p)->rb_left;
 338                 else
 339                         p = &(*p)->rb_right;
 340         }
 341         rb_link_node(&symn->rb_node, parent, p);
 342         rb_insert_color(&symn->rb_node, symbols);
 343 }
 344
 345 static void symbols__sort_by_name(struct rb_root *symbols,
 346                                   struct rb_root *source)
 347 {
 348         struct rb_node *nd;
 349
 350         for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 351                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 352                 symbols__insert_by_name(symbols, pos);
 353         }
 354 }
 355
 356 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 357                                             const char *name)
 358 {
 359         struct rb_node *n;
 360
 361         if (symbols == NULL)
 362                 return NULL;
 363
 364         n = symbols->rb_node;
 365
 366         while (n) {
 367                 struct symbol_name_rb_node *s;
 368                 int cmp;
 369
 370                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 371                 cmp = strcmp(name, s->sym.name);
 372
 373                 if (cmp < 0)
 374                         n = n->rb_left;
 375                 else if (cmp > 0)
 376                         n = n->rb_right;
 377                 else
 378                         return &s->sym;
 379         }
 380
 381         return NULL;
 382 }
 383
 384 struct symbol *dso__find_symbol(struct dso *dso,
 385                                 enum map_type type, u64 addr)
 386 {
 387         return symbols__find(&dso->symbols[type], addr);
 388 }
 389
 390 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 391                                         const char *name)
 392 {
 393         return symbols__find_by_name(&dso->symbol_names[type], name);
 394 }
 395
 396 void dso__sort_by_name(struct dso *dso, enum map_type type)
 397 {
 398         dso__set_sorted_by_name(dso, type);
 399         return symbols__sort_by_name(&dso->symbol_names[type],
 400                                      &dso->symbols[type]);
 401 }
 402
 403 size_t dso__fprintf_symbols_by_name(struct dso *dso,
 404                                     enum map_type type, FILE *fp)
 405 {
 406         size_t ret = 0;
 407         struct rb_node *nd;
 408         struct symbol_name_rb_node *pos;
 409
 410         for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 411                 pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 412                 fprintf(fp, "%s\n", pos->sym.name);
 413         }
 414
 415         return ret;
 416 }
 417
 418 int kallsyms__parse(const char *filename, void *arg,
 419                     int (*process_symbol)(void *arg, const char *name,
 420                                           char type, u64 start))
 421 {
 422         char *line = NULL;
 423         size_t n;
 424         int err = -1;
 425         FILE *file = fopen(filename, "r");
 426
 427         if (file == NULL)
 428                 goto out_failure;
 429
 430         err = 0;
 431
 432         while (!feof(file)) {
 433                 u64 start;
 434                 int line_len, len;
 435                 char symbol_type;
 436                 char *symbol_name;
 437
 438                 line_len = getline(&line, &n, file);
 439                 if (line_len < 0 || !line)
 440                         break;
 441
 442                 line[--line_len] = '\0'; /* \n */
 443
 444                 len = hex2u64(line, &start);
 445
 446                 len++;
 447                 if (len + 2 >= line_len)
 448                         continue;
 449
 450                 symbol_type = line[len];
 451                 len += 2;
 452                 symbol_name = line + len;
 453                 len = line_len - len;
 454
 455                 if (len >= KSYM_NAME_LEN) {
 456                         err = -1;
 457                         break;
 458                 }
 459
 460                 err = process_symbol(arg, symbol_name,
 461                                      symbol_type, start);
 462                 if (err)
 463                         break;
 464         }
 465
 466         free(line);
 467         fclose(file);
 468         return err;
 469
 470 out_failure:
 471         return -1;
 472 }
 473
 474 struct process_kallsyms_args {
 475         struct map *map;
 476         struct dso *dso;
 477 };
 478
 479 static u8 kallsyms2elf_type(char type)
 480 {
 481         if (type == 'W')
 482                 return STB_WEAK;
 483
 484         return isupper(type) ? STB_GLOBAL : STB_LOCAL;
 485 }
 486
 487 static int map__process_kallsym_symbol(void *arg, const char *name,
 488                                        char type, u64 start)
 489 {
 490         struct symbol *sym;
 491         struct process_kallsyms_args *a = arg;
 492         struct rb_root *root = &a->dso->symbols[a->map->type];
 493
 494         if (!symbol_type__is_a(type, a->map->type))
 495                 return 0;
 496
 497         /*
 498          * module symbols are not sorted so we add all
 499          * symbols, setting length to 0, and rely on
 500          * symbols__fixup_end() to fix it up.
 501          */
 502         sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
 503         if (sym == NULL)
 504                 return -ENOMEM;
 505         /*
 506          * We will pass the symbols to the filter later, in
 507          * map__split_kallsyms, when we have split the maps per module
 508          */
 509         symbols__insert(root, sym);
 510
 511         return 0;
 512 }
 513
 514 /*
 515  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
 516  * so that we can in the next step set the symbol ->end address and then
 517  * call kernel_maps__split_kallsyms.
 518  */
 519 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 520                                   struct map *map)
 521 {
 522         struct process_kallsyms_args args = { .map = map, .dso = dso, };
 523         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 524 }
 525
 526 /*
 527  * Split the symbols into maps, making sure there are no overlaps, i.e. the
 528  * kernel range is broken in several maps, named [kernel].N, as we don't have
 529  * the original ELF section names vmlinux have.
 530  */
 531 static int dso__split_kallsyms(struct dso *dso, struct map *map,
 532                                symbol_filter_t filter)
 533 {
 534         struct map_groups *kmaps = map__kmap(map)->kmaps;
 535         struct machine *machine = kmaps->machine;
 536         struct map *curr_map = map;
 537         struct symbol *pos;
 538         int count = 0, moved = 0;
 539         struct rb_root *root = &dso->symbols[map->type];
 540         struct rb_node *next = rb_first(root);
 541         int kernel_range = 0;
 542
 543         while (next) {
 544                 char *module;
 545
 546                 pos = rb_entry(next, struct symbol, rb_node);
 547                 next = rb_next(&pos->rb_node);
 548
 549                 module = strchr(pos->name, '\t');
 550                 if (module) {
 551                         if (!symbol_conf.use_modules)
 552                                 goto discard_symbol;
 553
 554                         *module++ = '\0';
 555
 556                         if (strcmp(curr_map->dso->short_name, module)) {
 557                                 if (curr_map != map &&
 558                                     dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 559                                     machine__is_default_guest(machine)) {
 560                                         /*
 561                                          * We assume all symbols of a module are
 562                                          * continuous in * kallsyms, so curr_map
 563                                          * points to a module and all its
 564                                          * symbols are in its kmap. Mark it as
 565                                          * loaded.
 566                                          */
 567                                         dso__set_loaded(curr_map->dso,
 568                                                         curr_map->type);
 569                                 }
 570
 571                                 curr_map = map_groups__find_by_name(kmaps,
 572                                                         map->type, module);
 573                                 if (curr_map == NULL) {
 574                                         pr_debug("%s/proc/{kallsyms,modules} "
 575                                                  "inconsistency while looking "
 576                                                  "for \"%s\" module!\n",
 577                                                  machine->root_dir, module);
 578                                         curr_map = map;
 579                                         goto discard_symbol;
 580                                 }
 581
 582                                 if (curr_map->dso->loaded &&
 583                                     !machine__is_default_guest(machine))
 584                                         goto discard_symbol;
 585                         }
 586                         /*
 587                          * So that we look just like we get from .ko files,
 588                          * i.e. not prelinked, relative to map->start.
 589                          */
 590                         pos->start = curr_map->map_ip(curr_map, pos->start);
 591                         pos->end   = curr_map->map_ip(curr_map, pos->end);
 592                 } else if (curr_map != map) {
 593                         char dso_name[PATH_MAX];
 594                         struct dso *ndso;
 595
 596                         if (count == 0) {
 597                                 curr_map = map;
 598                                 goto filter_symbol;
 599                         }
 600
 601                         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 602                                 snprintf(dso_name, sizeof(dso_name),
 603                                         "[guest.kernel].%d",
 604                                         kernel_range++);
 605                         else
 606                                 snprintf(dso_name, sizeof(dso_name),
 607                                         "[kernel].%d",
 608                                         kernel_range++);
 609
 610                         ndso = dso__new(dso_name);
 611                         if (ndso == NULL)
 612                                 return -1;
 613
 614                         ndso->kernel = dso->kernel;
 615
 616                         curr_map = map__new2(pos->start, ndso, map->type);
 617                         if (curr_map == NULL) {
 618                                 dso__delete(ndso);
 619                                 return -1;
 620                         }
 621
 622                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 623                         map_groups__insert(kmaps, curr_map);
 624                         ++kernel_range;
 625                 }
 626 filter_symbol:
 627                 if (filter && filter(curr_map, pos)) {
 628 discard_symbol:         rb_erase(&pos->rb_node, root);
 629                         symbol__delete(pos);
 630                 } else {
 631                         if (curr_map != map) {
 632                                 rb_erase(&pos->rb_node, root);
 633                                 symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 634                                 ++moved;
 635                         } else
 636                                 ++count;
 637                 }
 638         }
 639
 640         if (curr_map != map &&
 641             dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 642             machine__is_default_guest(kmaps->machine)) {
 643                 dso__set_loaded(curr_map->dso, curr_map->type);
 644         }
 645
 646         return count + moved;
 647 }
 648
 649 bool symbol__restricted_filename(const char *filename,
 650                                  const char *restricted_filename)
 651 {
 652         bool restricted = false;
 653
 654         if (symbol_conf.kptr_restrict) {
 655                 char *r = realpath(filename, NULL);
 656
 657                 if (r != NULL) {
 658                         restricted = strcmp(r, restricted_filename) == 0;
 659                         free(r);
 660                         return restricted;
 661                 }
 662         }
 663
 664         return restricted;
 665 }
 666
 667 int dso__load_kallsyms(struct dso *dso, const char *filename,
 668                        struct map *map, symbol_filter_t filter)
 669 {
 670         if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 671                 return -1;
 672
 673         if (dso__load_all_kallsyms(dso, filename, map) < 0)
 674                 return -1;
 675
 676         symbols__fixup_end(&dso->symbols[map->type]);
 677         symbols__fixup_duplicate(&dso->symbols[map->type]);
 678
 679         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 680                 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
 681         else
 682                 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
 683
 684         return dso__split_kallsyms(dso, map, filter);
 685 }
 686
 687 static int dso__load_perf_map(struct dso *dso, struct map *map,
 688                               symbol_filter_t filter)
 689 {
 690         char *line = NULL;
 691         size_t n;
 692         FILE *file;
 693         int nr_syms = 0;
 694
 695         file = fopen(dso->long_name, "r");
 696         if (file == NULL)
 697                 goto out_failure;
 698
 699         while (!feof(file)) {
 700                 u64 start, size;
 701                 struct symbol *sym;
 702                 int line_len, len;
 703
 704                 line_len = getline(&line, &n, file);
 705                 if (line_len < 0)
 706                         break;
 707
 708                 if (!line)
 709                         goto out_failure;
 710
 711                 line[--line_len] = '\0'; /* \n */
 712
 713                 len = hex2u64(line, &start);
 714
 715                 len++;
 716                 if (len + 2 >= line_len)
 717                         continue;
 718
 719                 len += hex2u64(line + len, &size);
 720
 721                 len++;
 722                 if (len + 2 >= line_len)
 723                         continue;
 724
 725                 sym = symbol__new(start, size, STB_GLOBAL, line + len);
 726
 727                 if (sym == NULL)
 728                         goto out_delete_line;
 729
 730                 if (filter && filter(map, sym))
 731                         symbol__delete(sym);
 732                 else {
 733                         symbols__insert(&dso->symbols[map->type], sym);
 734                         nr_syms++;
 735                 }
 736         }
 737
 738         free(line);
 739         fclose(file);
 740
 741         return nr_syms;
 742
 743 out_delete_line:
 744         free(line);
 745 out_failure:
 746         return -1;
 747 }
 748
 749 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 750 {
 751         char *name;
 752         int ret = -1;
 753         u_int i;
 754         struct machine *machine;
 755         char *root_dir = (char *) "";
 756         int ss_pos = 0;
 757         struct symsrc ss_[2];
 758         struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
 759
 760         dso__set_loaded(dso, map->type);
 761
 762         if (dso->kernel == DSO_TYPE_KERNEL)
 763                 return dso__load_kernel_sym(dso, map, filter);
 764         else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 765                 return dso__load_guest_kernel_sym(dso, map, filter);
 766
 767         if (map->groups && map->groups->machine)
 768                 machine = map->groups->machine;
 769         else
 770                 machine = NULL;
 771
 772         dso->adjust_symbols = 0;
 773
 774         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
 775                 struct stat st;
 776
 777                 if (lstat(dso->name, &st) < 0)
 778                         return -1;
 779
 780                 if (st.st_uid && (st.st_uid != geteuid())) {
 781                         pr_warning("File %s not owned by current user or root, "
 782                                 "ignoring it.\n", dso->name);
 783                         return -1;
 784                 }
 785
 786                 ret = dso__load_perf_map(dso, map, filter);
 787                 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
 788                                              DSO_BINARY_TYPE__NOT_FOUND;
 789                 return ret;
 790         }
 791
 792         if (machine)
 793                 root_dir = machine->root_dir;
 794
 795         name = malloc(PATH_MAX);
 796         if (!name)
 797                 return -1;
 798
 799         /* Iterate over candidate debug images.
 800          * Keep track of "interesting" ones (those which have a symtab, dynsym,
 801          * and/or opd section) for processing.
 802          */
 803         for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
 804                 struct symsrc *ss = &ss_[ss_pos];
 805                 bool next_slot = false;
 806
 807                 enum dso_binary_type symtab_type = binary_type_symtab[i];
 808
 809                 if (dso__binary_type_file(dso, symtab_type,
 810                                           root_dir, name, PATH_MAX))
 811                         continue;
 812
 813                 /* Name is now the name of the next image to try */
 814                 if (symsrc__init(ss, dso, name, symtab_type) < 0)
 815                         continue;
 816
 817                 if (!syms_ss && symsrc__has_symtab(ss)) {
 818                         syms_ss = ss;
 819                         next_slot = true;
 820                 }
 821
 822                 if (!runtime_ss && symsrc__possibly_runtime(ss)) {
 823                         runtime_ss = ss;
 824                         next_slot = true;
 825                 }
 826
 827                 if (next_slot) {
 828                         ss_pos++;
 829
 830                         if (syms_ss && runtime_ss)
 831                                 break;
 832                 }
 833
 834         }
 835
 836         if (!runtime_ss && !syms_ss)
 837                 goto out_free;
 838
 839         if (runtime_ss && !syms_ss) {
 840                 syms_ss = runtime_ss;
 841         }
 842
 843         /* We'll have to hope for the best */
 844         if (!runtime_ss && syms_ss)
 845                 runtime_ss = syms_ss;
 846
 847         if (syms_ss)
 848                 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, 0);
 849         else
 850                 ret = -1;
 851
 852         if (ret > 0) {
 853                 int nr_plt;
 854
 855                 nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
 856                 if (nr_plt > 0)
 857                         ret += nr_plt;
 858         }
 859
 860         for (; ss_pos > 0; ss_pos--)
 861                 symsrc__destroy(&ss_[ss_pos - 1]);
 862 out_free:
 863         free(name);
 864         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
 865                 return 0;
 866         return ret;
 867 }
 868
 869 struct map *map_groups__find_by_name(struct map_groups *mg,
 870                                      enum map_type type, const char *name)
 871 {
 872         struct rb_node *nd;
 873
 874         for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
 875                 struct map *map = rb_entry(nd, struct map, rb_node);
 876
 877                 if (map->dso && strcmp(map->dso->short_name, name) == 0)
 878                         return map;
 879         }
 880
 881         return NULL;
 882 }
 883
 884 int dso__load_vmlinux(struct dso *dso, struct map *map,
 885                       const char *vmlinux, symbol_filter_t filter)
 886 {
 887         int err = -1;
 888         struct symsrc ss;
 889         char symfs_vmlinux[PATH_MAX];
 890         enum dso_binary_type symtab_type;
 891
 892         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
 893                  symbol_conf.symfs, vmlinux);
 894
 895         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 896                 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
 897         else
 898                 symtab_type = DSO_BINARY_TYPE__VMLINUX;
 899
 900         if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
 901                 return -1;
 902
 903         err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
 904         symsrc__destroy(&ss);
 905
 906         if (err > 0) {
 907                 dso__set_long_name(dso, (char *)vmlinux);
 908                 dso__set_loaded(dso, map->type);
 909                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
 910         }
 911
 912         return err;
 913 }
 914
 915 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
 916                            symbol_filter_t filter)
 917 {
 918         int i, err = 0;
 919         char *filename;
 920
 921         pr_debug("Looking at the vmlinux_path (%d entries long)\n",
 922                  vmlinux_path__nr_entries + 1);
 923
 924         filename = dso__build_id_filename(dso, NULL, 0);
 925         if (filename != NULL) {
 926                 err = dso__load_vmlinux(dso, map, filename, filter);
 927                 if (err > 0) {
 928                         dso->lname_alloc = 1;
 929                         goto out;
 930                 }
 931                 free(filename);
 932         }
 933
 934         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
 935                 err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
 936                 if (err > 0) {
 937                         dso__set_long_name(dso, strdup(vmlinux_path[i]));
 938                         dso->lname_alloc = 1;
 939                         break;
 940                 }
 941         }
 942 out:
 943         return err;
 944 }
 945
 946 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 947                                 symbol_filter_t filter)
 948 {
 949         int err;
 950         const char *kallsyms_filename = NULL;
 951         char *kallsyms_allocated_filename = NULL;
 952         /*
 953          * Step 1: if the user specified a kallsyms or vmlinux filename, use
 954          * it and only it, reporting errors to the user if it cannot be used.
 955          *
 956          * For instance, try to analyse an ARM perf.data file _without_ a
 957          * build-id, or if the user specifies the wrong path to the right
 958          * vmlinux file, obviously we can't fallback to another vmlinux (a
 959          * x86_86 one, on the machine where analysis is being performed, say),
 960          * or worse, /proc/kallsyms.
 961          *
 962          * If the specified file _has_ a build-id and there is a build-id
 963          * section in the perf.data file, we will still do the expected
 964          * validation in dso__load_vmlinux and will bail out if they don't
 965          * match.
 966          */
 967         if (symbol_conf.kallsyms_name != NULL) {
 968                 kallsyms_filename = symbol_conf.kallsyms_name;
 969                 goto do_kallsyms;
 970         }
 971
 972         if (symbol_conf.vmlinux_name != NULL) {
 973                 err = dso__load_vmlinux(dso, map,
 974                                         symbol_conf.vmlinux_name, filter);
 975                 if (err > 0) {
 976                         dso__set_long_name(dso,
 977                                            strdup(symbol_conf.vmlinux_name));
 978                         dso->lname_alloc = 1;
 979                         goto out_fixup;
 980                 }
 981                 return err;
 982         }
 983
 984         if (vmlinux_path != NULL) {
 985                 err = dso__load_vmlinux_path(dso, map, filter);
 986                 if (err > 0)
 987                         goto out_fixup;
 988         }
 989
 990         /* do not try local files if a symfs was given */
 991         if (symbol_conf.symfs[0] != 0)
 992                 return -1;
 993
 994         /*
 995          * Say the kernel DSO was created when processing the build-id header table,
 996          * we have a build-id, so check if it is the same as the running kernel,
 997          * using it if it is.
 998          */
 999         if (dso->has_build_id) {
1000                 u8 kallsyms_build_id[BUILD_ID_SIZE];
1001                 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1002
1003                 if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
1004                                          sizeof(kallsyms_build_id)) == 0) {
1005                         if (dso__build_id_equal(dso, kallsyms_build_id)) {
1006                                 kallsyms_filename = "/proc/kallsyms";
1007                                 goto do_kallsyms;
1008                         }
1009                 }
1010                 /*
1011                  * Now look if we have it on the build-id cache in
1012                  * $HOME/.debug/[kernel.kallsyms].
1013                  */
1014                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1015                                   sbuild_id);
1016
1017                 if (asprintf(&kallsyms_allocated_filename,
1018                              "%s/.debug/[kernel.kallsyms]/%s",
1019                              getenv("HOME"), sbuild_id) == -1) {
1020                         pr_err("Not enough memory for kallsyms file lookup\n");
1021                         return -1;
1022                 }
1023
1024                 kallsyms_filename = kallsyms_allocated_filename;
1025
1026                 if (access(kallsyms_filename, F_OK)) {
1027                         pr_err("No kallsyms or vmlinux with build-id %s "
1028                                "was found\n", sbuild_id);
1029                         free(kallsyms_allocated_filename);
1030                         return -1;
1031                 }
1032         } else {
1033                 /*
1034                  * Last resort, if we don't have a build-id and couldn't find
1035                  * any vmlinux file, try the running kernel kallsyms table.
1036                  */
1037                 kallsyms_filename = "/proc/kallsyms";
1038         }
1039
1040 do_kallsyms:
1041         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1042         if (err > 0)
1043                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1044         free(kallsyms_allocated_filename);
1045
1046         if (err > 0) {
1047                 dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
1048 out_fixup:
1049                 map__fixup_start(map);
1050                 map__fixup_end(map);
1051         }
1052
1053         return err;
1054 }
1055
1056 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
1057                                       symbol_filter_t filter)
1058 {
1059         int err;
1060         const char *kallsyms_filename = NULL;
1061         struct machine *machine;
1062         char path[PATH_MAX];
1063
1064         if (!map->groups) {
1065                 pr_debug("Guest kernel map hasn't the point to groups\n");
1066                 return -1;
1067         }
1068         machine = map->groups->machine;
1069
1070         if (machine__is_default_guest(machine)) {
1071                 /*
1072                  * if the user specified a vmlinux filename, use it and only
1073                  * it, reporting errors to the user if it cannot be used.
1074                  * Or use file guest_kallsyms inputted by user on commandline
1075                  */
1076                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
1077                         err = dso__load_vmlinux(dso, map,
1078                                 symbol_conf.default_guest_vmlinux_name, filter);
1079                         goto out_try_fixup;
1080                 }
1081
1082                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
1083                 if (!kallsyms_filename)
1084                         return -1;
1085         } else {
1086                 sprintf(path, "%s/proc/kallsyms", machine->root_dir);
1087                 kallsyms_filename = path;
1088         }
1089
1090         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
1091         if (err > 0)
1092                 pr_debug("Using %s for symbols\n", kallsyms_filename);
1093
1094 out_try_fixup:
1095         if (err > 0) {
1096                 if (kallsyms_filename != NULL) {
1097                         machine__mmap_name(machine, path, sizeof(path));
1098                         dso__set_long_name(dso, strdup(path));
1099                 }
1100                 map__fixup_start(map);
1101                 map__fixup_end(map);
1102         }
1103
1104         return err;
1105 }
1106
1107 static void vmlinux_path__exit(void)
1108 {
1109         while (--vmlinux_path__nr_entries >= 0) {
1110                 free(vmlinux_path[vmlinux_path__nr_entries]);
1111                 vmlinux_path[vmlinux_path__nr_entries] = NULL;
1112         }
1113
1114         free(vmlinux_path);
1115         vmlinux_path = NULL;
1116 }
1117
1118 static int vmlinux_path__init(void)
1119 {
1120         struct utsname uts;
1121         char bf[PATH_MAX];
1122
1123         vmlinux_path = malloc(sizeof(char *) * 5);
1124         if (vmlinux_path == NULL)
1125                 return -1;
1126
1127         vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
1128         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1129                 goto out_fail;
1130         ++vmlinux_path__nr_entries;
1131         vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
1132         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1133                 goto out_fail;
1134         ++vmlinux_path__nr_entries;
1135
1136         /* only try running kernel version if no symfs was given */
1137         if (symbol_conf.symfs[0] != 0)
1138                 return 0;
1139
1140         if (uname(&uts) < 0)
1141                 return -1;
1142
1143         snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
1144         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1145         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1146                 goto out_fail;
1147         ++vmlinux_path__nr_entries;
1148         snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
1149         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1150         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1151                 goto out_fail;
1152         ++vmlinux_path__nr_entries;
1153         snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
1154                  uts.release);
1155         vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
1156         if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
1157                 goto out_fail;
1158         ++vmlinux_path__nr_entries;
1159
1160         return 0;
1161
1162 out_fail:
1163         vmlinux_path__exit();
1164         return -1;
1165 }
1166
1167 static int setup_list(struct strlist **list, const char *list_str,
1168                       const char *list_name)
1169 {
1170         if (list_str == NULL)
1171                 return 0;
1172
1173         *list = strlist__new(true, list_str);
1174         if (!*list) {
1175                 pr_err("problems parsing %s list\n", list_name);
1176                 return -1;
1177         }
1178         return 0;
1179 }
1180
1181 static bool symbol__read_kptr_restrict(void)
1182 {
1183         bool value = false;
1184
1185         if (geteuid() != 0) {
1186                 FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
1187                 if (fp != NULL) {
1188                         char line[8];
1189
1190                         if (fgets(line, sizeof(line), fp) != NULL)
1191                                 value = atoi(line) != 0;
1192
1193                         fclose(fp);
1194                 }
1195         }
1196
1197         return value;
1198 }
1199
1200 int symbol__init(void)
1201 {
1202         const char *symfs;
1203
1204         if (symbol_conf.initialized)
1205                 return 0;
1206
1207         symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
1208
1209         symbol__elf_init();
1210
1211         if (symbol_conf.sort_by_name)
1212                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
1213                                           sizeof(struct symbol));
1214
1215         if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
1216                 return -1;
1217
1218         if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
1219                 pr_err("'.' is the only non valid --field-separator argument\n");
1220                 return -1;
1221         }
1222
1223         if (setup_list(&symbol_conf.dso_list,
1224                        symbol_conf.dso_list_str, "dso") < 0)
1225                 return -1;
1226
1227         if (setup_list(&symbol_conf.comm_list,
1228                        symbol_conf.comm_list_str, "comm") < 0)
1229                 goto out_free_dso_list;
1230
1231         if (setup_list(&symbol_conf.sym_list,
1232                        symbol_conf.sym_list_str, "symbol") < 0)
1233                 goto out_free_comm_list;
1234
1235         /*
1236          * A path to symbols of "/" is identical to ""
1237          * reset here for simplicity.
1238          */
1239         symfs = realpath(symbol_conf.symfs, NULL);
1240         if (symfs == NULL)
1241                 symfs = symbol_conf.symfs;
1242         if (strcmp(symfs, "/") == 0)
1243                 symbol_conf.symfs = "";
1244         if (symfs != symbol_conf.symfs)
1245                 free((void *)symfs);
1246
1247         symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
1248
1249         symbol_conf.initialized = true;
1250         return 0;
1251
1252 out_free_comm_list:
1253         strlist__delete(symbol_conf.comm_list);
1254 out_free_dso_list:
1255         strlist__delete(symbol_conf.dso_list);
1256         return -1;
1257 }
1258
1259 void symbol__exit(void)
1260 {
1261         if (!symbol_conf.initialized)
1262                 return;
1263         strlist__delete(symbol_conf.sym_list);
1264         strlist__delete(symbol_conf.dso_list);
1265         strlist__delete(symbol_conf.comm_list);
1266         vmlinux_path__exit();
1267         symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
1268         symbol_conf.initialized = false;
1269 }